From 277e2289cf003e675a76177cdf71babae1c8e2c9 Mon Sep 17 00:00:00 2001 From: EugenePlanteur Date: Tue, 12 Nov 2024 09:37:17 +0100 Subject: [PATCH 01/31] doc: add readme --- data_type/readme.md | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 data_type/readme.md diff --git a/data_type/readme.md b/data_type/readme.md new file mode 100644 index 0000000..edad88a --- /dev/null +++ b/data_type/readme.md @@ -0,0 +1,8 @@ +# Tutorial: Geospatial Data Formats + +Geospatial data allows the communication of information in a wide range of fields. Over time, many data formats have emerged to support this diversity. This tutorial introduces these various formats, their evolution, their advantages and disadvantages, and provides guidance on how and in which contexts to use them most effectively. It will be divided into four jupyter notebooks: + +1) [Raster formats](./raster_formats.ipynb) +2) [Vector formats](./vector_data_formats.ipynb) +3) Data cube formats (or multi-dimensional raster) +4) Cloud-optimized formats \ No newline at end of file From f0c471466113ae387e28c7c0e6ff487ea1a62c52 Mon Sep 17 00:00:00 2001 From: EugenePlanteur Date: Tue, 12 Nov 2024 09:37:55 +0100 Subject: [PATCH 02/31] feat: add utils functions --- data_type/utils.py | 108 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 108 insertions(+) create mode 100644 data_type/utils.py diff --git a/data_type/utils.py b/data_type/utils.py new file mode 100644 index 0000000..60b6e6a --- /dev/null +++ b/data_type/utils.py @@ -0,0 +1,108 @@ +import io +import zipfile +from pathlib import Path + +import numpy as np +import pandas as pd +import rasterio +import requests +from rasterio.plot import show + + +def get_file_size_in_mb(file_path): + """ + Return a str containing a file size in MB + """ + raw_size = Path(file_path).stat().st_size + return raw_size * 1e-6 + + +def compare_read_write_times(read_times, write_times, labels): + data = pd.DataFrame({ + 'Formats': labels, + 'Read': read_times, + 'Write': write_times + }) + + # group times by format + data_long = data.melt(id_vars='Formats', var_name='Type', value_name='Time (s)') + plot = data_long.hvplot.bar( + x='Formats', + y='Time (s)', + by='Type', + title="Read and write times, depending on the format", + xlabel='Formats', + ylabel='Time (s)', + color=['#a8dadc', '#457b9d'] + ) + return plot + + +def download_sample_data(download_dir): + output_raster = Path( + download_dir) / "data" / "xt_SENTINEL2B_20180621-111349-432_L2A_T30TWT_D_V1-8_RVBPIR.tif" + + if output_raster.exists(): + return output_raster + + zip_file_url = "https://www.orfeo-toolbox.org/packages/WorkshopData/data_otb-guided-tour.zip" + r = requests.get(zip_file_url) + z = zipfile.ZipFile(io.BytesIO(r.content)) + z.extractall(download_dir) + + assert output_raster.exists() + + (Path( + download_dir) / "data" / "xt_SENTINEL2B_20180701-111103-470_L2A_T30TWT_D_V1-8_RVBPIR.tif").unlink() + (Path( + download_dir) / "data" / "xt_SENTINEL2A_20180706-110918-241_L2A_T30TWT_D_V1-8_RVBPIR.tif").unlink() + (Path( + download_dir) / "data" / "xt_SENTINEL2B_20180711-111139-550_L2A_T30TWT_D_V1-8_RVBPIR.tif").unlink() + + return output_raster + + +def show_raster(input_image: str): + """ + Displays the RGB bands of a raster image with rescaling for visualization. + + Parameters + ---------- + input_image : str + Path to the input raster image. + """ + with rasterio.open(input_image) as src: + # get the RGB bands + raster_data = src.read() + raster_data = raster_data[0:3, :, :] + + # create new range values for visualization purpose + flat_array = raster_data.flatten() + lower_bound = np.quantile(flat_array, 0.001) + upper_bound = np.quantile(flat_array, 0.999) + mask = (raster_data >= lower_bound) & (raster_data <= upper_bound) + filtered_array = np.where(mask, raster_data, 0) + min_val = filtered_array.min() + max_val = filtered_array.max() + rescaled_array = (filtered_array - min_val) / (max_val - min_val) * 255 + + show(rescaled_array.astype(np.uint8), title="Raster Data") + + +def download_sample_vector_data(download_dir): + data_dir = Path(download_dir) / "departement-31" + output_file = data_dir / "landuse.shp" + if output_file.exists(): + return output_file + + zip_file_url = "http://opendata.lexman.net/departement-31-Haute-Garonne.zip" + r = requests.get(zip_file_url) + z = zipfile.ZipFile(io.BytesIO(r.content)) + z.extractall(download_dir) + + for file_name in data_dir.iterdir(): + if file_name.stem != "landuse": + file_name.unlink() + + assert output_file.exists() + return output_file From c6f9c085c2b49bf4c2fdb1235ee1b54428908c4e Mon Sep 17 00:00:00 2001 From: EugenePlanteur Date: Tue, 12 Nov 2024 09:40:34 +0100 Subject: [PATCH 03/31] feat: add raster formats notebook --- data_type/raster_formats.ipynb | 341 +++++++++++++++++++++++++++++++++ 1 file changed, 341 insertions(+) create mode 100644 data_type/raster_formats.ipynb diff --git a/data_type/raster_formats.ipynb b/data_type/raster_formats.ipynb new file mode 100644 index 0000000..739f7e5 --- /dev/null +++ b/data_type/raster_formats.ipynb @@ -0,0 +1,341 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0334d408-551a-4911-84b5-4e0b6c42ea0f", + "metadata": {}, + "source": [ + "# Raster formats\n", + "\n", + "This section presents the 3 most common file formats for geospatial rasters: JPEG2000, GeoTIFF and COG. The COG format (Cloud Optimized GeoTIFF, http://cogeo.org/) is actually a geotiff format, organized in a way to optimize its usage on cluod infrastructures. For example, it allows the streaming of only the required part of the image, instead of reading it in its entirety.\n", + "\n", + "First, we import all the required libraries." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4fe30afe-0572-4168-81c1-8c50cac8fd35", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "from pathlib import Path\n", + "from utils import download_sample_data, show_raster\n", + "import matplotlib.pyplot as plt\n", + "import rasterio\n", + "from rasterio.enums import Resampling\n", + "import copy\n", + "\n", + "import rioxarray\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "id": "12263017-8f46-4d24-9eb0-14ce18cd650e", + "metadata": {}, + "source": [ + "## GeoTIFF\n", + "\n", + "In order to highlight the main differences between these formats, let's start by downloading a Sentinel-2 image in GeoTIFF format, using the `download_sample_data` function. These data are not real Sentinel-2 data, we will only use RGB + Near Infrared data, centred on the city of Vannes in France for our tutorial. Other Sentinel-2 data can be downloaded from https://theia.cnes.fr. We then read the image using `rasterio` and measure the time required to read it, as well as the file size:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c501598a-e670-4a1c-96a5-4b4498e3570f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Read time: 0.06 seconds\n", + "File size: 80.2 MB\n" + ] + } + ], + "source": [ + "DOWNLOAD_DIRECTORY = \"./sample_data/rasters\" # change this directory if needed\n", + "raster_tiff = download_sample_data(DOWNLOAD_DIRECTORY) # this may take some time to download\n", + "\n", + "with rasterio.open(raster_tiff) as src:\n", + " start = time.time()\n", + " image_data = src.read() # read raster as a numpy array\n", + " profile = src.profile\n", + "end = time.time()\n", + "print(f\"Read time: {end - start:.2f} seconds\")\n", + "tiff_size = raster_tiff.stat().st_size\n", + "print(f\"File size: {tiff_size*1e-6:.1f} MB\")\n", + "\n", + "# show_raster(raster_tiff) # un-comment this line to plot the raster" + ] + }, + { + "cell_type": "markdown", + "id": "c4c7c72a-978c-4a6b-a079-a9e35431f324", + "metadata": {}, + "source": [ + "## JPEG2000\n", + "\n", + "Now, let's compare JPEG2000 to GeoTIFF. Sentinel 2 data in .jp2 format can be downloaded from the [copernicus browser](https://browser.dataspace.copernicus.eu). In this example, we will simply convert the tif to a JPEG2000. We then check the read time and file size, just like with the geotiff file:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "bd534bf6-358d-4597-96b5-f519600f85b3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Read time: 0.19 seconds\n", + "File size: 10.0 MB\n" + ] + } + ], + "source": [ + "raster_jpeg = raster_tiff.with_suffix(\".jp2\")\n", + "\n", + "# convert to jp2\n", + "profile_jpeg = copy.deepcopy(profile) # create a new profile instead of overwriting the original one\n", + "profile_jpeg.update( # the jp2 format requires multiple specific parameters\n", + " driver='JP2OpenJPEG',\n", + " compress='jpeg2000', # compression method \n", + " dtype='uint16',\n", + " tiled=True, # JPEG2000 required tiled data\n", + " blockxsize=256,\n", + " blockysize=256\n", + ")\n", + "with rasterio.open(raster_jpeg, \"w\", **profile_jpeg) as dst:\n", + " dst.write(image_data)\n", + "\n", + "# Analyze the performances\n", + "with rasterio.open(raster_jpeg) as src:\n", + " start = time.time()\n", + " data_from_tif = src.read()\n", + "end = time.time()\n", + "print(f\"Read time: {end - start:.2f} seconds\")\n", + "size_jpeg = Path(raster_jpeg).stat().st_size\n", + "print(f\"File size: {size_jpeg*1e-6:.1f} MB\")" + ] + }, + { + "cell_type": "markdown", + "id": "35048806-83d2-413f-a12b-a65c9c27f9b9", + "metadata": {}, + "source": [ + "The JPEG2000 format utilizes more efficient compresison methods, resulting in smaller file sizes. This improved file size comes at the price of longer reading times. To improve the size of tif files, `rasterio` offers different compression options. For example, ZSTD (a modern and more efficient method) improves file size. This is how you can use it:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a723698b-ce43-4dd9-99ce-4056bb7ffa06", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Read time: 0.18 seconds\n", + "File size: 38.5 MB\n" + ] + } + ], + "source": [ + "image_tif_zstd = raster_tiff.with_stem(raster_tiff.stem + \"_compressed\")\n", + "Path(image_tif_zstd).unlink(missing_ok=True)\n", + "\n", + "# Convert to geotiff, using the ZSTD method\n", + "profile_tif_zstd = copy.deepcopy(profile)\n", + "profile_tif_zstd.update(driver='GTiff', compress=\"ZSTD\") # update the profile dictionnary \n", + "with rasterio.open(image_tif_zstd, \"w\", **profile_tif_zstd) as dst:\n", + " dst.write(image_data)\n", + "\n", + "# Analyze file\n", + "with rasterio.open(image_tif_zstd) as src:\n", + " start = time.time()\n", + " data_from_tif = src.read()\n", + "end = time.time()\n", + "print(f\"Read time: {end - start:.2f} seconds\")\n", + "size_tif_zstd = Path(image_tif_zstd).stat().st_size\n", + "print(f\"File size: {size_tif_zstd*1e-6:.1f} MB\")" + ] + }, + { + "cell_type": "markdown", + "id": "56ca7b47-26a8-499e-8a4c-ded45e74697b", + "metadata": {}, + "source": [ + "Other common compression method supported by rasterio are `LZW` and `DEFLATE`. You can find the complete list [here](https://gdal.org/en/latest/drivers/raster/gtiff.html#creation-options). This method improves the file size but also increases read time (but still notably shorter than with JPEG2000), so selecting an appropriate compression method is important.\n", + "\n", + "Note: the JPEG2000 format doesn't allow other compression methods.\n", + "\n", + "## Cloud Optimized GeoTIFF (COG)\n", + "\n", + "Finally, handling large volumes of data in the cloud requires specific data management methods, optimized for cloud infrastructures. For example, satellite images (and time series) require a lot of processing ressources, and in particular, memory. This makes it almost impossible to process satellite data at once: one solution to this problem is straming. The data is cut in chunks, allowing the processing of multiple smaller images. Some file formats are specifically designed for these types of operations. For example the Cloud Optimized Geotiff (COG). As explained in the introduction, it isn't a format of its own, but rather a specific type of geotiff, which allows and improves data management in the cloud. The file is organized as smaller chunks to optimize streaming. This format also allows the creation of \"overviews\": smaller versions of the original image (with lower resolutions). This is particularly useful for quick visualisations: the full resolution isn't required, so loading a lower resolution image requires less ressources. Here is how to create a cloud optimized geotiff using rasterio:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9a558b71-b910-4424-ba14-77a4ce97b73c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Read time: 0.08 secondes\n", + "File size: 45.0 MB\n" + ] + } + ], + "source": [ + "image_cog = raster_tiff.with_stem(raster_tiff.stem + \"_cog\")\n", + "Path(image_tif_zstd).unlink(missing_ok=True)\n", + "\n", + "resampling_method = Resampling.nearest # Resampling method used for overviews\n", + "profile_cog = copy.deepcopy(profile)\n", + "profile_cog.update(\n", + " driver=\"GTiff\",\n", + " compress=\"ZSTD\",\n", + " tiled=True, # Tiles/chunks\n", + " blockxsize=256, # Tiles size\n", + " blockysize=256,\n", + " overview_resampling=resampling_method\n", + " )\n", + "with rasterio.open(image_cog, \"w\", **profile_cog) as dst:\n", + " dst.write(image_data)\n", + "\n", + " # Overviews generation\n", + " factors_list = [2, 4, 8, 16] # resolution factors\n", + " dst.build_overviews(factors_list, resampling_method)\n", + " dst.update_tags(ns='rio_overview', resampling='nearest')\n", + "\n", + "# Analyze the performances\n", + "with rasterio.open(image_cog) as src:\n", + " start = time.time()\n", + " data_cog = src.read(1)\n", + "end = time.time()\n", + "full_res_time = end - start\n", + "print(f\"Read time: {full_res_time:.2f} secondes\")\n", + "size_cog = Path(image_cog).stat().st_size\n", + "print(f\"File size: {size_cog*1e-6:.1f} MB\")" + ] + }, + { + "cell_type": "markdown", + "id": "b36b2e05-7dd6-4050-a8c9-2b710e518bb4", + "metadata": {}, + "source": [ + "Ces performances ne constituent pas une nette amélioration, mais l'intérêt du COG ne réside pas dans la réduction de taille d'un fichier ou de la vitesse d'ouverture. On peut cependant mettre en évidence l'intérêt des overviews en mesurant le temps nécessaire pour les charger:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "f23bc95d-c43f-4baa-992c-d055c9f6629d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original image size: 2410 x 2080\n", + "\n", + "Overview 1 of size 1205 x 1040 => pixel size: 20 meters\n", + "Load time 2: 0.0269 seconds\n", + "\n", + "Overview 2 of size 602 x 520 => pixel size: 40 meters\n", + "Load time 4: 0.0085 seconds\n", + "\n", + "Overview 3 of size 301 x 260 => pixel size: 80 meters\n", + "Load time 8: 0.0035 seconds\n", + "\n", + "Overview 4 of size 150 x 130 => pixel size: 160 meters\n", + "Load time 16: 0.0013 seconds\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "with rasterio.open(image_cog) as src:\n", + " print(f\"Original image size: {src.width} x {src.height}\\n\")\n", + "\n", + " # liste of overviews (for the first band)\n", + " overview_levels = src.overviews(1)\n", + "\n", + " # Iterate over the overviews\n", + " for n_overview, overview_factor in enumerate(overview_levels, start=1):\n", + " overview_width = src.width // overview_factor\n", + " overview_height = src.height // overview_factor\n", + " pixel_size = int(src.res[0] * overview_factor)\n", + " print(f\"Overview {n_overview} of size {overview_width} x {overview_height} => pixel size: {pixel_size} meters\")\n", + " start_time = time.time()\n", + " overview_data = src.read(1, out_shape=(src.height // src.overviews(1)[n_overview - 1], # read the data from the overview\n", + " src.width // src.overviews(1)[n_overview - 1]))\n", + " overview_time = time.time() - start_time\n", + " print(f\"Load time {overview_factor}: {overview_time:.4f} seconds\\n\")\n", + "\n", + " # plot the last overview to compare the quality of the image\n", + " plt.imshow(overview_data, cmap=\"gray\")\n", + " plt.title(f\"Overview using {pixel_size} meters pixels\")\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "d2d62836-21c5-4622-a45e-9f3674cee0d6", + "metadata": {}, + "source": [ + "With only the second overview, the time needed to load the data into memory is divided by a factor of approximately 10 (this factor may vary depending on the machine you are using). The displayed image is the data loaded from the last overview (the one with the lowest resolution).\n", + "\n", + "## Conclusion\n", + "\n", + "Choosing a raster format depends on the desired performance and infrastructure. Locally, if storage space is a priority, JPEG2000 is preferable; on the other hand, if execution speed is more important, GeoTIFF is more suitable. Additionally, GeoTIFF is generally more widely supported than JPEG2000. In a cloud environment, COG is usually the best choice as it is optimized for this usage context. In summary:\n", + "\n", + "| Format | Advantages | Limitations |\n", + "|----------|---------------------------------------------------------|---------------------------------------------------------------------------|\n", + "| JPEG2000 | Better compression | Slower compression/decompression speed, not optimized for cloud |\n", + "| GeoTIFF | Faster, native support for geospatial metadata | Larger files, not optimized for cloud |\n", + "| COG | Cloud optimized (speed, resources) | Less advantageous for local use |" + ] + } + ], + "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.11.0rc1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 9fdb02a7da74e2b49d7683131028cbda3dc76263 Mon Sep 17 00:00:00 2001 From: EugenePlanteur Date: Tue, 12 Nov 2024 10:04:25 +0100 Subject: [PATCH 04/31] feat: add vector formats notebook --- data_type/vector_data_formats.ipynb | 1205 +++++++++++++++++++++++++++ 1 file changed, 1205 insertions(+) create mode 100644 data_type/vector_data_formats.ipynb diff --git a/data_type/vector_data_formats.ipynb b/data_type/vector_data_formats.ipynb new file mode 100644 index 0000000..224ea03 --- /dev/null +++ b/data_type/vector_data_formats.ipynb @@ -0,0 +1,1205 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d8c0f211-59c6-48cc-b3f2-11f66c040415", + "metadata": {}, + "source": [ + "## Vector data formats\n", + "\n", + "As geospatial data evolved, multiple formats emerged for vector data. The first major one was the shapefile, which remains the most used and supported format, making it the most stable as well. However, this format also has several flaws and limitations, such as requiring at least three files, allowing only one type of geometry per file, and limiting attribute names to 10 characters with a maximum of 255 attributes.\n", + "\n", + "Next came GeoJSON, which is based on the JSON format and adds geospatial information but suffers from poor performance when handling large datasets. The GeoPackage format was then introduced, offering improved performance and eliminating the limitations of shapefiles; it is now widely regarded as a modern replacement. Most software and infrastructures are compatible with this format.\n", + "\n", + "For even better performance, FlatGeobuf was developed, based on [FlatBuffers](https://flatbuffers.dev/). Unlike GeoPackage, it allows for advanced and optimized operations like data streaming; however, it is more recent and not yet as widely supported. Finally, optimized for cloud computing, GeoParquet was created, implementing features particularly useful for cloud applications. Like FlatGeobuf, it requires modern infrastructures and software.\n", + "\n", + "As an example, we will be using a land use shapefile, available here: https://www.data.gouv.fr/fr/datasets/carte-des-departements-2-1/#/resources/d823cf85-5f6d-4767-a9fe-25a50a266a04. This will allow us to benchmark and compare the different formats performances (reading and writing time, as well as file sizes). To this end, we will use `geopandas`, a library based on `pandas`. `pyarraow` is also required to use parquet files with `geopandas`." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "03f8e298-4f9c-4ac5-aadc-47c8957aaa1f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "(function(root) {\n", + " function now() {\n", + " return new Date();\n", + " }\n", + "\n", + " const force = true;\n", + " const py_version = '3.6.0'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", + " const reloading = false;\n", + " const Bokeh = root.Bokeh;\n", + "\n", + " // Set a timeout for this load but only if we are not already initializing\n", + " if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_failed_load = false;\n", + " }\n", + "\n", + " function run_callbacks() {\n", + " try {\n", + " root._bokeh_onload_callbacks.forEach(function(callback) {\n", + " if (callback != null)\n", + " callback();\n", + " });\n", + " } finally {\n", + " delete root._bokeh_onload_callbacks;\n", + " }\n", + " console.debug(\"Bokeh: all callbacks have finished\");\n", + " }\n", + "\n", + " function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n", + " if (css_urls == null) css_urls = [];\n", + " if (js_urls == null) js_urls = [];\n", + " if (js_modules == null) js_modules = [];\n", + " if (js_exports == null) js_exports = {};\n", + "\n", + " root._bokeh_onload_callbacks.push(callback);\n", + "\n", + " if (root._bokeh_is_loading > 0) {\n", + " // Don't load bokeh if it is still initializing\n", + " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", + " return null;\n", + " } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", + " // There is nothing to load\n", + " run_callbacks();\n", + " return null;\n", + " }\n", + "\n", + " function on_load() {\n", + " root._bokeh_is_loading--;\n", + " if (root._bokeh_is_loading === 0) {\n", + " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", + " run_callbacks()\n", + " }\n", + " }\n", + " window._bokeh_on_load = on_load\n", + "\n", + " function on_error(e) {\n", + " const src_el = e.srcElement\n", + " console.error(\"failed to load \" + (src_el.href || src_el.src));\n", + " }\n", + "\n", + " const skip = [];\n", + " if (window.requirejs) {\n", + " window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n", + " root._bokeh_is_loading = css_urls.length + 0;\n", + " } else {\n", + " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", + " }\n", + "\n", + " const existing_stylesheets = []\n", + " const links = document.getElementsByTagName('link')\n", + " for (let i = 0; i < links.length; i++) {\n", + " const link = links[i]\n", + " if (link.href != null) {\n", + " existing_stylesheets.push(link.href)\n", + " }\n", + " }\n", + " for (let i = 0; i < css_urls.length; i++) {\n", + " const url = css_urls[i];\n", + " const escaped = encodeURI(url)\n", + " if (existing_stylesheets.indexOf(escaped) !== -1) {\n", + " on_load()\n", + " continue;\n", + " }\n", + " const element = document.createElement(\"link\");\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.rel = \"stylesheet\";\n", + " element.type = \"text/css\";\n", + " element.href = url;\n", + " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", + " document.body.appendChild(element);\n", + " } var existing_scripts = []\n", + " const scripts = document.getElementsByTagName('script')\n", + " for (let i = 0; i < scripts.length; i++) {\n", + " var script = scripts[i]\n", + " if (script.src != null) {\n", + " existing_scripts.push(script.src)\n", + " }\n", + " }\n", + " for (let i = 0; i < js_urls.length; i++) {\n", + " const url = js_urls[i];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " const element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (let i = 0; i < js_modules.length; i++) {\n", + " const url = js_modules[i];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (const name in js_exports) {\n", + " const url = js_exports[name];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " element.textContent = `\n", + " import ${name} from \"${url}\"\n", + " window.${name} = ${name}\n", + " window._bokeh_on_load()\n", + " `\n", + " document.head.appendChild(element);\n", + " }\n", + " if (!js_urls.length && !js_modules.length) {\n", + " on_load()\n", + " }\n", + " };\n", + "\n", + " function inject_raw_css(css) {\n", + " const element = document.createElement(\"style\");\n", + " element.appendChild(document.createTextNode(css));\n", + " document.body.appendChild(element);\n", + " }\n", + "\n", + " const js_urls = [\"https://cdn.holoviz.org/panel/1.5.3/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.6.0.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.6.0.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.6.0.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.6.0.min.js\", \"https://cdn.holoviz.org/panel/1.5.3/dist/panel.min.js\"];\n", + " const js_modules = [];\n", + " const js_exports = {};\n", + " const css_urls = [];\n", + " const inline_js = [ function(Bokeh) {\n", + " Bokeh.set_log_level(\"info\");\n", + " },\n", + "function(Bokeh) {} // ensure no trailing comma for IE\n", + " ];\n", + "\n", + " function run_inline_js() {\n", + " if ((root.Bokeh !== undefined) || (force === true)) {\n", + " for (let i = 0; i < inline_js.length; i++) {\n", + " try {\n", + " inline_js[i].call(root, root.Bokeh);\n", + " } catch(e) {\n", + " if (!reloading) {\n", + " throw e;\n", + " }\n", + " }\n", + " }\n", + " // Cache old bokeh versions\n", + " if (Bokeh != undefined && !reloading) {\n", + " var NewBokeh = root.Bokeh;\n", + " if (Bokeh.versions === undefined) {\n", + " Bokeh.versions = new Map();\n", + " }\n", + " if (NewBokeh.version !== Bokeh.version) {\n", + " Bokeh.versions.set(NewBokeh.version, NewBokeh)\n", + " }\n", + " root.Bokeh = Bokeh;\n", + " }\n", + " } else if (Date.now() < root._bokeh_timeout) {\n", + " setTimeout(run_inline_js, 100);\n", + " } else if (!root._bokeh_failed_load) {\n", + " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", + " root._bokeh_failed_load = true;\n", + " }\n", + " root._bokeh_is_initializing = false\n", + " }\n", + "\n", + " function load_or_wait() {\n", + " // Implement a backoff loop that tries to ensure we do not load multiple\n", + " // versions of Bokeh and its dependencies at the same time.\n", + " // In recent versions we use the root._bokeh_is_initializing flag\n", + " // to determine whether there is an ongoing attempt to initialize\n", + " // bokeh, however for backward compatibility we also try to ensure\n", + " // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n", + " // before older versions are fully initialized.\n", + " if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n", + " // If the timeout and bokeh was not successfully loaded we reset\n", + " // everything and try loading again\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_is_initializing = false;\n", + " root._bokeh_onload_callbacks = undefined;\n", + " root._bokeh_is_loading = 0\n", + " console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n", + " load_or_wait();\n", + " } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n", + " setTimeout(load_or_wait, 100);\n", + " } else {\n", + " root._bokeh_is_initializing = true\n", + " root._bokeh_onload_callbacks = []\n", + " const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n", + " if (!reloading && !bokeh_loaded) {\n", + " if (root.Bokeh) {\n", + " root.Bokeh = undefined;\n", + " }\n", + " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", + " }\n", + " load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n", + " console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", + " run_inline_js();\n", + " });\n", + " }\n", + " }\n", + " // Give older versions of the autoload script a head-start to ensure\n", + " // they initialize before we start loading newer version.\n", + " setTimeout(load_or_wait, 100)\n", + "}(window));" + ], + "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n const force = true;\n const py_version = '3.6.0'.replace('rc', '-rc.').replace('.dev', '-dev.');\n const reloading = false;\n const Bokeh = root.Bokeh;\n\n // Set a timeout for this load but only if we are not already initializing\n if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n // Don't load bokeh if it is still initializing\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n // There is nothing to load\n run_callbacks();\n return null;\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error(e) {\n const src_el = e.srcElement\n console.error(\"failed to load \" + (src_el.href || src_el.src));\n }\n\n const skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n const existing_stylesheets = []\n const links = document.getElementsByTagName('link')\n for (let i = 0; i < links.length; i++) {\n const link = links[i]\n if (link.href != null) {\n existing_stylesheets.push(link.href)\n }\n }\n for (let i = 0; i < css_urls.length; i++) {\n const url = css_urls[i];\n const escaped = encodeURI(url)\n if (existing_stylesheets.indexOf(escaped) !== -1) {\n on_load()\n continue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n const scripts = document.getElementsByTagName('script')\n for (let i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n existing_scripts.push(script.src)\n }\n }\n for (let i = 0; i < js_urls.length; i++) {\n const url = js_urls[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n const element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (let i = 0; i < js_modules.length; i++) {\n const url = js_modules[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n const url = js_exports[name];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n const js_urls = [\"https://cdn.holoviz.org/panel/1.5.3/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.6.0.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.6.0.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.6.0.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.6.0.min.js\", \"https://cdn.holoviz.org/panel/1.5.3/dist/panel.min.js\"];\n const js_modules = [];\n const js_exports = {};\n const css_urls = [];\n const inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (let i = 0; i < inline_js.length; i++) {\n try {\n inline_js[i].call(root, root.Bokeh);\n } catch(e) {\n if (!reloading) {\n throw e;\n }\n }\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n var NewBokeh = root.Bokeh;\n if (Bokeh.versions === undefined) {\n Bokeh.versions = new Map();\n }\n if (NewBokeh.version !== Bokeh.version) {\n Bokeh.versions.set(NewBokeh.version, NewBokeh)\n }\n root.Bokeh = Bokeh;\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n // If the timeout and bokeh was not successfully loaded we reset\n // everything and try loading again\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n root._bokeh_is_loading = 0\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n if (root.Bokeh) {\n root.Bokeh = undefined;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + "if ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n", + " window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n", + "}\n", + "\n", + "\n", + " function JupyterCommManager() {\n", + " }\n", + "\n", + " JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n", + " if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " comm_manager.register_target(comm_id, function(comm) {\n", + " comm.on_msg(msg_handler);\n", + " });\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n", + " comm.onMsg = msg_handler;\n", + " });\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " console.log(message)\n", + " var content = {data: message.data, comm_id};\n", + " var buffers = []\n", + " for (var buffer of message.buffers || []) {\n", + " buffers.push(new DataView(buffer))\n", + " }\n", + " var metadata = message.metadata || {};\n", + " var msg = {content, buffers, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " })\n", + " }\n", + " }\n", + "\n", + " JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n", + " if (comm_id in window.PyViz.comms) {\n", + " return window.PyViz.comms[comm_id];\n", + " } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n", + " if (msg_handler) {\n", + " comm.on_msg(msg_handler);\n", + " }\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n", + " comm.open();\n", + " if (msg_handler) {\n", + " comm.onMsg = msg_handler;\n", + " }\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " var comm_promise = google.colab.kernel.comms.open(comm_id)\n", + " comm_promise.then((comm) => {\n", + " window.PyViz.comms[comm_id] = comm;\n", + " if (msg_handler) {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " var content = {data: message.data};\n", + " var metadata = message.metadata || {comm_id};\n", + " var msg = {content, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " }) \n", + " var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n", + " return comm_promise.then((comm) => {\n", + " comm.send(data, metadata, buffers, disposeOnDone);\n", + " });\n", + " };\n", + " var comm = {\n", + " send: sendClosure\n", + " };\n", + " }\n", + " window.PyViz.comms[comm_id] = comm;\n", + " return comm;\n", + " }\n", + " window.PyViz.comm_manager = new JupyterCommManager();\n", + " \n", + "\n", + "\n", + "var JS_MIME_TYPE = 'application/javascript';\n", + "var HTML_MIME_TYPE = 'text/html';\n", + "var EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\n", + "var CLASS_NAME = 'output';\n", + "\n", + "/**\n", + " * Render data to the DOM node\n", + " */\n", + "function render(props, node) {\n", + " var div = document.createElement(\"div\");\n", + " var script = document.createElement(\"script\");\n", + " node.appendChild(div);\n", + " node.appendChild(script);\n", + "}\n", + "\n", + "/**\n", + " * Handle when a new output is added\n", + " */\n", + "function handle_add_output(event, handle) {\n", + " var output_area = handle.output_area;\n", + " var output = handle.output;\n", + " if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", + " return\n", + " }\n", + " var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", + " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", + " if (id !== undefined) {\n", + " var nchildren = toinsert.length;\n", + " var html_node = toinsert[nchildren-1].children[0];\n", + " html_node.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var scripts = [];\n", + " var nodelist = html_node.querySelectorAll(\"script\");\n", + " for (var i in nodelist) {\n", + " if (nodelist.hasOwnProperty(i)) {\n", + " scripts.push(nodelist[i])\n", + " }\n", + " }\n", + "\n", + " scripts.forEach( function (oldScript) {\n", + " var newScript = document.createElement(\"script\");\n", + " var attrs = [];\n", + " var nodemap = oldScript.attributes;\n", + " for (var j in nodemap) {\n", + " if (nodemap.hasOwnProperty(j)) {\n", + " attrs.push(nodemap[j])\n", + " }\n", + " }\n", + " attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n", + " newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n", + " oldScript.parentNode.replaceChild(newScript, oldScript);\n", + " });\n", + " if (JS_MIME_TYPE in output.data) {\n", + " toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n", + " }\n", + " output_area._hv_plot_id = id;\n", + " if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n", + " window.PyViz.plot_index[id] = Bokeh.index[id];\n", + " } else {\n", + " window.PyViz.plot_index[id] = null;\n", + " }\n", + " } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", + " var bk_div = document.createElement(\"div\");\n", + " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var script_attrs = bk_div.children[0].attributes;\n", + " for (var i = 0; i < script_attrs.length; i++) {\n", + " toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n", + " }\n", + " // store reference to server id on output_area\n", + " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle when an output is cleared or removed\n", + " */\n", + "function handle_clear_output(event, handle) {\n", + " var id = handle.cell.output_area._hv_plot_id;\n", + " var server_id = handle.cell.output_area._bokeh_server_id;\n", + " if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n", + " var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n", + " if (server_id !== null) {\n", + " comm.send({event_type: 'server_delete', 'id': server_id});\n", + " return;\n", + " } else if (comm !== null) {\n", + " comm.send({event_type: 'delete', 'id': id});\n", + " }\n", + " delete PyViz.plot_index[id];\n", + " if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n", + " var doc = window.Bokeh.index[id].model.document\n", + " doc.clear();\n", + " const i = window.Bokeh.documents.indexOf(doc);\n", + " if (i > -1) {\n", + " window.Bokeh.documents.splice(i, 1);\n", + " }\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle kernel restart event\n", + " */\n", + "function handle_kernel_cleanup(event, handle) {\n", + " delete PyViz.comms[\"hv-extension-comm\"];\n", + " window.PyViz.plot_index = {}\n", + "}\n", + "\n", + "/**\n", + " * Handle update_display_data messages\n", + " */\n", + "function handle_update_output(event, handle) {\n", + " handle_clear_output(event, {cell: {output_area: handle.output_area}})\n", + " handle_add_output(event, handle)\n", + "}\n", + "\n", + "function register_renderer(events, OutputArea) {\n", + " function append_mime(data, metadata, element) {\n", + " // create a DOM node to render to\n", + " var toinsert = this.create_output_subarea(\n", + " metadata,\n", + " CLASS_NAME,\n", + " EXEC_MIME_TYPE\n", + " );\n", + " this.keyboard_manager.register_events(toinsert);\n", + " // Render to node\n", + " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", + " render(props, toinsert[0]);\n", + " element.append(toinsert);\n", + " return toinsert\n", + " }\n", + "\n", + " events.on('output_added.OutputArea', handle_add_output);\n", + " events.on('output_updated.OutputArea', handle_update_output);\n", + " events.on('clear_output.CodeCell', handle_clear_output);\n", + " events.on('delete.Cell', handle_clear_output);\n", + " events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n", + "\n", + " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", + " safe: true,\n", + " index: 0\n", + " });\n", + "}\n", + "\n", + "if (window.Jupyter !== undefined) {\n", + " try {\n", + " var events = require('base/js/events');\n", + " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", + " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", + " register_renderer(events, OutputArea);\n", + " }\n", + " } catch(err) {\n", + " }\n", + "}\n" + ], + "application/vnd.holoviews_load.v0+json": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ] + }, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "9c4f5ceb-685a-43d3-8be4-c0d3fe4e67a2" + } + }, + "output_type": "display_data" + } + ], + "source": [ + "import time\n", + "from pathlib import Path\n", + "\n", + "import geopandas as gpd\n", + "import hvplot.pandas\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "from utils import compare_read_write_times, get_file_size_in_mb\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore') # ignore warnings when reading invalid polygons" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d901cb24-1090-4b9c-b9ca-f2300940fcfe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reading time: 0.092 seconds\n", + "File size: 10.418388 MB\n" + ] + } + ], + "source": [ + "land_use_shapefile_path = \"test_data/vectors/landuse.shp\"\n", + "# land_use_shapefile_path = \"/home/eplanteu/Downloads/occitanie/occitanie/landuse.shp\"\n", + "\n", + "start = time.time()\n", + "land_use = gpd.read_file(land_use_shapefile_path, on_invalid=\"ignore\") # ignore invalid polygons\n", + "read_time = time.time() - start\n", + "print(f\"Reading time: {read_time:.3f} seconds\\n\"\n", + " f\"File size: {get_file_size_in_mb(land_use_shapefile_path)} MB\")\n", + "\n", + "\n", + "land_use = land_use.to_crs(epsg=2154) # convert the CRS to a metric system\n", + "\n", + "land_use[\"area\"] = land_use.geometry.area # new area column\n", + "all_types_area = land_use.groupby(\"type\")[\"area\"].sum() # sum of area by land use type\n", + "# print(all_types_area) # uncomment to see the results" + ] + }, + { + "cell_type": "markdown", + "id": "8f8159ea-280c-4bc1-8222-43b251874aeb", + "metadata": {}, + "source": [ + "Let's write a function to run this analysis on any file, and another function to write a GeoDataframe to any file (parquet file use different methods for reading and writing)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c81cd7b4-2bea-4a72-adaa-9f6468191015", + "metadata": {}, + "outputs": [], + "source": [ + "def analyze_vector_file(filepath):\n", + " start = time.time()\n", + " if Path(filepath).suffix == \".parquet\":\n", + " land_use = gpd.read_parquet(filepath)\n", + " else:\n", + " land_use = gpd.read_file(filepath, on_invalid=\"ignore\")\n", + " read_time = time.time() - start\n", + " land_use = land_use.to_crs(epsg=2154)\n", + "\n", + " start = time.time()\n", + " land_use[\"area\"] = land_use.geometry.area\n", + " all_types_area = land_use.groupby(\"type\")[\"area\"].sum()\n", + " compute_time = time.time() - start\n", + " file_size = get_file_size_in_mb(filepath)\n", + " print(f\"File type: {Path(filepath).suffix}\\n\"\n", + " f\"File size: {file_size:.1f} MB\\n\"\n", + " f\"Time to open: {read_time:.3f} secondes\\n\"\n", + " f\"Time to compute: {compute_time:.5f} secondes\\n\")\n", + "\n", + " return read_time, file_size\n", + "\n", + "def write_gdf_to_file(gdf, output_file):\n", + " gdf = gdf[gdf.geometry.notna()]\n", + " start = time.time()\n", + " if Path(output_file).suffix == \".parquet\":\n", + " gdf.to_parquet(output_file)\n", + " else:\n", + " gdf.to_file(output_file)\n", + " write_time = time.time() - start\n", + " print(f\"Writing time of {Path(output_file).suffix}: {write_time:.2f} seconds\")\n", + "\n", + " return write_time" + ] + }, + { + "cell_type": "markdown", + "id": "d7650cb0-052d-4ada-b793-c2d1c7a3bc15", + "metadata": {}, + "source": [ + "The shapefile is then opened and converted to different formats, measuring the writing time for each one. Each file is then analyzed to check the file size and read time. These information are displayed in histograms using `matplotlib` in the following cells." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9972a4fe-9d99-4a35-aade-e00c5a7329e8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Writing time of .shp: 0.20 seconds\n", + "Writing time of .gpkg: 0.13 seconds\n", + "Writing time of .geojson: 1.18 seconds\n", + "Writing time of .parquet: 0.06 seconds\n", + "Writing time of .fgb: 0.10 seconds\n", + "File type: .shp\n", + "File size: 10.4 MB\n", + "Time to open: 0.063 secondes\n", + "Time to compute: 0.00368 secondes\n", + "\n", + "File type: .gpkg\n", + "File size: 13.3 MB\n", + "Time to open: 0.123 secondes\n", + "Time to compute: 0.00464 secondes\n", + "\n", + "File type: .geojson\n", + "File size: 18.3 MB\n", + "Time to open: 0.533 secondes\n", + "Time to compute: 0.00391 secondes\n", + "\n", + "File type: .parquet\n", + "File size: 9.6 MB\n", + "Time to open: 0.059 secondes\n", + "Time to compute: 0.00386 secondes\n", + "\n", + "File type: .fgb\n", + "File size: 12.2 MB\n", + "Time to open: 0.056 secondes\n", + "Time to compute: 0.00420 secondes\n", + "\n" + ] + } + ], + "source": [ + "# get files paths\n", + "land_use_shape_copy_path = Path(land_use_shapefile_path).with_stem(\"landuse_copy\") # used to measure the write time of shp\n", + "land_use_geojson_path = Path(land_use_shapefile_path).with_suffix(\".geojson\") # path to the GeoJSON file\n", + "land_use_geopkg_path = Path(land_use_shapefile_path).with_suffix(\".gpkg\") # path to the GeoPackage file\n", + "land_use_geoparquet_path = Path(land_use_shapefile_path).with_suffix(\".parquet\") # path to the fichier GeoParquet file\n", + "land_use_fgb_path = Path(land_use_shapefile_path).with_suffix(\".fgb\") # path to the FlatGeobuff file\n", + "\n", + "# convert files and retrieve write times\n", + "gdf_to_write = gpd.read_file(land_use_shapefile_path, on_invalid=\"ignore\")\n", + "shp_write_time = write_gdf_to_file(gdf_to_write, land_use_shape_copy_path)\n", + "gpkg_write_time = write_gdf_to_file(gdf_to_write, land_use_geopkg_path)\n", + "geojson_write_time = write_gdf_to_file(gdf_to_write, land_use_geojson_path)\n", + "geoparquet_write_time = write_gdf_to_file(gdf_to_write, land_use_geoparquet_path)\n", + "fgb_write_time = write_gdf_to_file(gdf_to_write, land_use_fgb_path)\n", + "\n", + "# analyze files\n", + "shp_read_time, shp_file_size = analyze_vector_file(land_use_shapefile_path)\n", + "gpkg_read_time, gpkg_file_size = analyze_vector_file(land_use_geopkg_path)\n", + "geojson_read_time, geojson_file_size = analyze_vector_file(land_use_geojson_path)\n", + "geoparquet_read_time, geoparquet_file_size = analyze_vector_file(land_use_geoparquet_path)\n", + "fgb_read_time, fgb_file_size = analyze_vector_file(land_use_fgb_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ceca6f95-7a5d-4faf-8bf2-ab27cfcac563", + "metadata": {}, + "outputs": [ + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ], + "text/plain": [ + ":Bars [Formats,Type] (Time (s))" + ] + }, + "execution_count": 5, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "1b9ccebd-d131-4c5b-a668-64688973c376" + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "# Read and write times comparison\n", + "read_times = [shp_read_time, gpkg_read_time, geojson_read_time, geoparquet_read_time, fgb_read_time]\n", + "write_times = [shp_write_time, gpkg_write_time, geojson_write_time, geoparquet_write_time, fgb_write_time]\n", + "labels = [\"shp\", \"gpkg\", \"geojson\", \"geoparquet\", \"fgb\"]\n", + "\n", + "compare_read_write_times(read_times, write_times, labels)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "40d4dbf3-9f6b-4ac5-b41c-deafb079134b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ok\n" + ] + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ], + "text/plain": [ + ":Bars [Formats,Type] (Time (s))" + ] + }, + "execution_count": 6, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "a3cb83f5-6ff0-4c3b-980c-85b7cc780410" + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "# Comparison without geojson\n", + "write_times = [shp_write_time, gpkg_write_time, geoparquet_write_time, fgb_write_time]\n", + "read_times = [shp_read_time, gpkg_read_time, geoparquet_read_time, fgb_read_time]\n", + "labels = [\"shp\", \"gpkg\", \"geoparquet\", \"fgb\"]\n", + "compare_read_write_times(read_times, write_times, labels)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3d13be6c-14da-40b7-bd61-0b893fd7e136", + "metadata": {}, + "outputs": [ + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ], + "text/plain": [ + ":Bars [Formats] (File size in MB)" + ] + }, + "execution_count": 10, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "f6c4ac5c-e826-4949-8f07-fd5c30d5e5a3" + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "# File size comaprison\n", + "files_sizes = [shp_file_size, gpkg_file_size, geojson_file_size, geoparquet_file_size, fgb_file_size]\n", + "labels = [\"shp\", \"gpkg\", \"geojson\", \"geoparquet\", \"fgb\"]\n", + "\n", + "# Histogram\n", + "data = pd.DataFrame({\n", + " 'Formats': labels,\n", + " 'File size in MB': files_sizes\n", + "})\n", + "data.hvplot.bar(\n", + " x='Formats',\n", + " y='File size in MB',\n", + " width=500,\n", + " height=400,\n", + " color='#a6bfe0',\n", + " title='File size depending on format',\n", + " xlabel='Formats',\n", + " ylabel='File size in MB'\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "08c976c3-fd87-4c4b-950f-eb5ec3ed473d", + "metadata": {}, + "source": [ + "As stated in the beginning, the performances obtained from using the GeoJSON are worse than for any other tested format. On the other hand, the geoparquet offers greater performances. However, this benchmarking is not exhaustive:\n", + "\n", + "- it was tested on only one dataset: performances are data-dependant, see https://flatgeobuf.org/#performance (from the official flatgeobuf documentation) for another benchmark\n", + "- a specific `geopandas` version was used: oledr versions of pandas were much less performant and/or used different engines, which also lowered performances\n", + "- it was run on a local infastructure: cloud-specific performances were not highlighted\n", + "\n", + "\n", + "Howerver, performances aren't the only comparison points. As explained in the introduction of this notebook, the shapefile suffers from many flaws. But every format has its advantages and limitations. Here is a recapitulatory table:\n", + "\n", + "| Format | Advantages | Drawbacks |\n", + "|------------|------------------------------------------------------------------------|------------------------------------------------------------------------------------|\n", + "| Shapefile | The most popular and supported format, very stable | Requires multiple files, limitations on attribute names and number, files <2GB ... |\n", + "| GeoPackage | Faster, widely supported, based on SQLite | Bigger files, no streaming possibility |\n", + "| GeoJSON | Streaming available, human-readable | Lower performance and larger file sizes |\n", + "| GeoParquet | Cloud optimized, great performance, lighter files, supports indexation | Less supported, requires modern infrastructure and updated software to operate |\n", + "| FlatGeobuf | Good performance and file compression, optimized for spatial requests | Less supported |\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "db442d81-1df7-46b7-8774-12f4b8143d14", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0rc1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 2236b7b097fcf621990cb7248b9b0534835d19dd Mon Sep 17 00:00:00 2001 From: EugenePlanteur Date: Tue, 12 Nov 2024 10:09:33 +0100 Subject: [PATCH 05/31] feat: add vector formats notebook --- data_type/vector_data_formats.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/data_type/vector_data_formats.ipynb b/data_type/vector_data_formats.ipynb index 224ea03..314c0d5 100644 --- a/data_type/vector_data_formats.ipynb +++ b/data_type/vector_data_formats.ipynb @@ -1161,7 +1161,7 @@ "- it was run on a local infastructure: cloud-specific performances were not highlighted\n", "\n", "\n", - "Howerver, performances aren't the only comparison points. As explained in the introduction of this notebook, the shapefile suffers from many flaws. But every format has its advantages and limitations. Here is a recapitulatory table:\n", + "However, performances aren't the only comparison points. As explained in the introduction of this notebook, the shapefile suffers from many flaws. But every format has its advantages and limitations. Here is a recapitulatory table:\n", "\n", "| Format | Advantages | Drawbacks |\n", "|------------|------------------------------------------------------------------------|------------------------------------------------------------------------------------|\n", From 1d886c3aa70dd6a604f4929de0d722b3c6b4b854 Mon Sep 17 00:00:00 2001 From: EugenePlanteur Date: Tue, 12 Nov 2024 10:33:59 +0100 Subject: [PATCH 06/31] install: add requirements.txt --- data_type/requirements.txt | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 data_type/requirements.txt diff --git a/data_type/requirements.txt b/data_type/requirements.txt new file mode 100644 index 0000000..c1715cd --- /dev/null +++ b/data_type/requirements.txt @@ -0,0 +1,8 @@ +geopandas==1.0.1 +hvplot==0.11.1 +jupyter==1.1.1 +matplotlib==3.9.2 +numpy==2.1.3 +pandas==2.2.3 +rasterio==1.4.2 +rioxarray==0.18.0 \ No newline at end of file From 73bdbf1c74d4f7609f9d49aca84123f3d0f7d8f5 Mon Sep 17 00:00:00 2001 From: EugenePlanteur Date: Tue, 12 Nov 2024 10:42:45 +0100 Subject: [PATCH 07/31] doc: update readme --- data_type/readme.md | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/data_type/readme.md b/data_type/readme.md index edad88a..67a8ea2 100644 --- a/data_type/readme.md +++ b/data_type/readme.md @@ -5,4 +5,15 @@ Geospatial data allows the communication of information in a wide range of field 1) [Raster formats](./raster_formats.ipynb) 2) [Vector formats](./vector_data_formats.ipynb) 3) Data cube formats (or multi-dimensional raster) -4) Cloud-optimized formats \ No newline at end of file +4) Cloud-optimized formats + + For each of these tutorials, sample data will be used, which you can visualize using QGIS. + +To run a notebook, first create a virtual environment and install the required packages (if not already done) + +```bash +python3.11 -m venv venv +pip install -r requirements.txt +``` + +Then you can simply use `jupyter notebook xxx.ipynb` to run the corresponding noteboook. From 2c5c7407497f519f396c173c96e8623d5b8d39a0 Mon Sep 17 00:00:00 2001 From: EugenePlanteur Date: Tue, 19 Nov 2024 10:59:54 +0100 Subject: [PATCH 08/31] feat: add datacube notebook --- data_type/datacube_formats.ipynb | 1510 ++++++++++++++++++++++++++++++ data_type/readme.md | 6 +- data_type/requirements.txt | 5 +- data_type/utils.py | 161 +++- 4 files changed, 1670 insertions(+), 12 deletions(-) create mode 100644 data_type/datacube_formats.ipynb diff --git a/data_type/datacube_formats.ipynb b/data_type/datacube_formats.ipynb new file mode 100644 index 0000000..c837503 --- /dev/null +++ b/data_type/datacube_formats.ipynb @@ -0,0 +1,1510 @@ +{ + "cells": [ + { + "attachments": { + "664ca6c2-36b1-4dcb-98ac-b1487a279105.png": { + "image/png": "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" + }, + "f2298fd0-2dc2-4bed-93ef-be7cb7e4246b.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "05c46b90-cf90-4dc3-9fe5-ab76a1bd8e67", + "metadata": {}, + "source": [ + "# Datacube formats\n", + "\n", + "A datacube is essentially a multi-dimensional array that enables the manipulation and analysis of complex datasets. In satellite imagery, datacubes are commonly used to create and work with time series data. For example, a datacube might contain a stack of *N* rasters, each with dimensions X × Y, where each raster represents the same spatial area at different dates. This structure allows for efficient comparison, temporal analysis, and trend detection over time. Datacubes can also handle other dimensions beyond time, such as spectral bands, enabling even more detailed analyses across wavelengths. They can store both raster and vector data. Visual example of a simple datacube:\n", + "\n", + "![datacube_schema.png](attachment:664ca6c2-36b1-4dcb-98ac-b1487a279105.png)\n", + "\n", + "Datacubes also allow more complex structure, for example (source: xarray official documentation):\n", + "\n", + "![xarray-datastructure.png](attachment:f2298fd0-2dc2-4bed-93ef-be7cb7e4246b.png)\n", + "\n", + "The following formats will be presented: \n", + "\n", + "1) [hdf5](##HDF5-format)\n", + "2) [netcdf](##Netcdf)\n", + "3) [zarr](##Zarr)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "2dbade8e-0cf5-47f8-a231-4b66358751fb", + "metadata": {}, + "outputs": [], + "source": [ + "# Generic notebook imports\n", + "\n", + "import time\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from utils import download_netcdf, generate_hdf5_file, get_file_size_in_mb, rescale_raster\n", + "\n", + "REFERENCE_RASTER = \"./sample_data/rasters/data/xt_SENTINEL2B_20180621-111349-432_L2A_T30TWT_D_V1-8_RVBPIR.tif\"" + ] + }, + { + "cell_type": "markdown", + "id": "2b6eb749-a202-4a9d-917d-f3e9cf8b3d2d", + "metadata": {}, + "source": [ + "## HDF5 format\n", + "\n", + "First, we'll present the HDF5 (Hierarchical Data Format version 5) format (https://www.hdfgroup.org/solutions/hdf5/). This is a widely spread format, used for storing and managing complex datasets. It's hierarchical structure allows storing multiple datasets (which can contain sub-datasets and so on), with corresponding metadata (dataset name, attributes etc ...), making storage and data retrieval very efficient.\n", + "\n", + "For this example, the test data will contain rasters (the same ones used in the [raster format tutorial](./raster_formats.ipynb)). However, you can find multiple sources of `.h5` files, which will generally require you to create an account (for example rainfall data from https://disc.gsfc.nasa.gov/)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "fbdaf48d-ef5b-423c-97ee-001a5d2a954c", + "metadata": {}, + "outputs": [], + "source": [ + "hdf5_file = \"./sample_data/data_cube/example.h5\" # change this path if needed\n", + "generate_hdf5_file(hdf5_file, REFERENCE_RASTER) # generate a dataset with random data" + ] + }, + { + "cell_type": "markdown", + "id": "e910b24f-d882-4931-afe0-0055a4e0973a", + "metadata": {}, + "source": [ + "HDF5 files are organized in groups and datasets. Groups can contain groups and datasets and datasets act like numpy arrays. This generated file contains one group with two datasets (one with 2D data, one with 3D data). To list the group(s) and datasets, use:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5e9f1850-3386-4a98-bd62-405178b71491", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "List of dataset(s) and group(s): ['data']\n", + "Data group's metadata: {'creation_date': '2024-11-19', 'project': 'Tutorial example project'}\n", + "List of datasets: ['data_2d', 'data_3d']\n", + "2d dataset's shape: (2080, 2410)\n", + "3d dataset's shape: (4, 2080, 2410)\n", + "3d dataset's metadata{'DIMENSION_LABELS': array(['time', 'latitude', 'longitude'], dtype=object), 'description': 'RGB bands from a raster'}\n", + "dataset's dimensions names['time', 'latitude', 'longitude']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import h5py\n", + "\n", + "with h5py.File(hdf5_file, 'r') as f: # open the file\n", + " print(f\"List of dataset(s) and group(s): {list(f.keys())}\") # only one key: 'data' (a group)\n", + "\n", + " # 'data' group\n", + " data_group = f[\"data\"]\n", + " print(f\"Data group's metadata: {dict(data_group.attrs)}\")\n", + " print(f\"List of datasets: {list(data_group.keys())}\") # two keys: ['data_2d', 'data_3d'] (both are datasets)\n", + " \n", + " # 'data_2d' dataset\n", + " dataset_2d = data_group[\"data_2d\"]\n", + " print(f\"2d dataset's shape: {dataset_2d.shape}\")\n", + "\n", + " # 'data_3d' dataset\n", + " start = time.time()\n", + " dataset_3d = data_group[\"data_3d\"]\n", + " read_time = time.time() - start\n", + " print(f\"3d dataset's shape: {dataset_3d.shape}\")\n", + " print(f\"3d dataset's metadata{dict(dataset_3d.attrs)}\") # dataset's metadata (dimensions, description)\n", + " dims_3d_labels = [dim.label for dim in dataset_3d.dims] # get a more readable list of dimensions' labels\n", + " print(f\"dataset's dimensions names{dims_3d_labels}\")\n", + " \n", + " rescaled_data = rescale_raster(np.array(dataset_2d))\n", + " n_band = 1\n", + " plt.imshow(rescaled_data, cmap=\"gray\")\n", + " plt.title(f\"Raster's band n°{n_band+1}\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "93e0b458-5732-4b41-a3b6-afd50fdcf3d5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Read time: 0.00127 seconds\n", + "File size: 100.26 MB\n" + ] + } + ], + "source": [ + "start = time.time()\n", + "with h5py.File(hdf5_file, 'r') as f: # open the file\n", + " dataset_3d = f[\"data\"][\"data_3d\"]\n", + " read_time = time.time() - start\n", + "\n", + "\n", + "print(f\"Read time: {read_time:.5f} seconds\")\n", + "print(f\"File size: {get_file_size_in_mb(hdf5_file):.2f} MB\")" + ] + }, + { + "cell_type": "markdown", + "id": "0464c94b-dcf9-41a9-bf5c-7ef7716853bc", + "metadata": {}, + "source": [ + "This file contains one 3-band raster and one 1-band raster. In tiff format, these rasters's size are respectively 80 and 20MB MB. The hdf5 file size is around 100 MB, so the file size is equivalent, but the time needed to open and load the data is much smaller. " + ] + }, + { + "cell_type": "markdown", + "id": "17645133-c7bf-4b62-abbc-80bd08055558", + "metadata": {}, + "source": [ + "## Netcdf\n", + "\n", + "Now, let's take a look at an NETcdf file. First, we download an example file, containing precipitation data (other files can be found [here](https://www.unidata.ucar.edu/software/netcdf/examples/files.html)), open it and print the object:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "12738f41-5e02-48f8-8f3b-42a7ded481b6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Size: 1GB\n", + "Dimensions: (lat: 360, lon: 720, time: 1356)\n", + "Coordinates:\n", + " * lat (lat) float32 1kB 89.75 89.25 88.75 88.25 ... -88.75 -89.25 -89.75\n", + " * lon (lon) float32 3kB 0.25 0.75 1.25 1.75 ... 358.2 358.8 359.2 359.8\n", + " * time (time) datetime64[ns] 11kB 1901-01-01 1901-02-01 ... 2013-12-01\n", + "Data variables:\n", + " precip (time, lat, lon) float32 1GB ...\n", + "Attributes:\n", + " Original_Source: http://www.dwd.de/en/FundE/Klima/KLIS/int/GPCC/GPCC.htm...\n", + " Reference: Users of the data sets are kindly requested to give fee...\n", + " original_source: ftp://ftp-anon.dwd.de/pub/data/gpcc/html/fulldata_downl...\n", + " Conventions: CF 1.0\n", + " References: http://www.esrl.noaa.gov/psd/data/gridded/data.gpcc.html\n", + " history: Created 01/2016 based on V7 data obtained via ftp\n", + " title: GPCC Full Data Reanalysis Version 7 0.5x0.5 Monthly Total\n", + " dataset_title: Global Precipitation Climatology Centre (GPCC)\n" + ] + } + ], + "source": [ + "import xarray as xr\n", + "\n", + "netcf_file = download_netcdf(\"./sample_data/data_cube/\")\n", + "ds = xr.open_dataset(netcf_file, engine=\"netcdf4\")\n", + "print(ds)" + ] + }, + { + "cell_type": "markdown", + "id": "ede02a79-ef0e-4d83-b906-f6f81f716ec6", + "metadata": {}, + "source": [ + "This is another 3D datafile (longitude, latitude, time), containing only one data type (precipitation). More complex meteorological files could contain wind speeds, temperature etc... Here, we list all the available data variables: " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "cb7e452d-d897-44d4-8b80-f76e73c2e58a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data variables:\n", + " precip (time, lat, lon) float32 1GB ...\n" + ] + } + ], + "source": [ + "print(ds.data_vars)" + ] + }, + { + "cell_type": "markdown", + "id": "51cc68d8-1f62-4b4e-8737-ce05da6fae88", + "metadata": {}, + "source": [ + "And the corresponding dataset:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "61935296-7078-40c1-bf0f-ca8c047b3db2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Size: 1GB\n", + "[351475200 values with dtype=float32]\n", + "Coordinates:\n", + " * lat (lat) float32 1kB 89.75 89.25 88.75 88.25 ... -88.75 -89.25 -89.75\n", + " * lon (lon) float32 3kB 0.25 0.75 1.25 1.75 ... 358.2 358.8 359.2 359.8\n", + " * time (time) datetime64[ns] 11kB 1901-01-01 1901-02-01 ... 2013-12-01\n", + "Attributes:\n", + " units: mm\n", + " var_desc: Precipitation\n", + " level_desc: Surface\n", + " parent_stat: Observations\n", + " long_name: GPCC Monthly total of precipitation\n", + " valid_range: [ 0. 8000.]\n", + " actual_range: [ 0. 4530.85]\n", + " dataset: GPCC Precipitation 0.5degree V7 Full Reanalysis\n", + " statistic: Total\n", + " level: Surface\n" + ] + } + ], + "source": [ + "print(ds[\"precip\"])" + ] + }, + { + "cell_type": "markdown", + "id": "8e6eb60b-5451-489d-aab6-54ed3717b7fc", + "metadata": {}, + "source": [ + "We can now plot the precipitation for a given date using `hvplot`. Change the date using the `n_date` variable. The `time` coordinate has 1356 values, so it can't be greater than 1355. We use `hvplot` to plot an interactive map:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "5901216e-29f8-48e0-b2fb-c596a1a54964", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "(function(root) {\n", + " function now() {\n", + " return new Date();\n", + " }\n", + "\n", + " const force = true;\n", + " const py_version = '3.5.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", + " const reloading = false;\n", + " const Bokeh = root.Bokeh;\n", + "\n", + " // Set a timeout for this load but only if we are not already initializing\n", + " if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_failed_load = false;\n", + " }\n", + "\n", + " function run_callbacks() {\n", + " try {\n", + " root._bokeh_onload_callbacks.forEach(function(callback) {\n", + " if (callback != null)\n", + " callback();\n", + " });\n", + " } finally {\n", + " delete root._bokeh_onload_callbacks;\n", + " }\n", + " console.debug(\"Bokeh: all callbacks have finished\");\n", + " }\n", + "\n", + " function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n", + " if (css_urls == null) css_urls = [];\n", + " if (js_urls == null) js_urls = [];\n", + " if (js_modules == null) js_modules = [];\n", + " if (js_exports == null) js_exports = {};\n", + "\n", + " root._bokeh_onload_callbacks.push(callback);\n", + "\n", + " if (root._bokeh_is_loading > 0) {\n", + " // Don't load bokeh if it is still initializing\n", + " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", + " return null;\n", + " } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", + " // There is nothing to load\n", + " run_callbacks();\n", + " return null;\n", + " }\n", + "\n", + " function on_load() {\n", + " root._bokeh_is_loading--;\n", + " if (root._bokeh_is_loading === 0) {\n", + " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", + " run_callbacks()\n", + " }\n", + " }\n", + " window._bokeh_on_load = on_load\n", + "\n", + " function on_error(e) {\n", + " const src_el = e.srcElement\n", + " console.error(\"failed to load \" + (src_el.href || src_el.src));\n", + " }\n", + "\n", + " const skip = [];\n", + " if (window.requirejs) {\n", + " window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n", + " root._bokeh_is_loading = css_urls.length + 0;\n", + " } else {\n", + " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", + " }\n", + "\n", + " const existing_stylesheets = []\n", + " const links = document.getElementsByTagName('link')\n", + " for (let i = 0; i < links.length; i++) {\n", + " const link = links[i]\n", + " if (link.href != null) {\n", + " existing_stylesheets.push(link.href)\n", + " }\n", + " }\n", + " for (let i = 0; i < css_urls.length; i++) {\n", + " const url = css_urls[i];\n", + " const escaped = encodeURI(url)\n", + " if (existing_stylesheets.indexOf(escaped) !== -1) {\n", + " on_load()\n", + " continue;\n", + " }\n", + " const element = document.createElement(\"link\");\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.rel = \"stylesheet\";\n", + " element.type = \"text/css\";\n", + " element.href = url;\n", + " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", + " document.body.appendChild(element);\n", + " } var existing_scripts = []\n", + " const scripts = document.getElementsByTagName('script')\n", + " for (let i = 0; i < scripts.length; i++) {\n", + " var script = scripts[i]\n", + " if (script.src != null) {\n", + " existing_scripts.push(script.src)\n", + " }\n", + " }\n", + " for (let i = 0; i < js_urls.length; i++) {\n", + " const url = js_urls[i];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " const element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (let i = 0; i < js_modules.length; i++) {\n", + " const url = js_modules[i];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (const name in js_exports) {\n", + " const url = js_exports[name];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " element.textContent = `\n", + " import ${name} from \"${url}\"\n", + " window.${name} = ${name}\n", + " window._bokeh_on_load()\n", + " `\n", + " document.head.appendChild(element);\n", + " }\n", + " if (!js_urls.length && !js_modules.length) {\n", + " on_load()\n", + " }\n", + " };\n", + "\n", + " function inject_raw_css(css) {\n", + " const element = document.createElement(\"style\");\n", + " element.appendChild(document.createTextNode(css));\n", + " document.body.appendChild(element);\n", + " }\n", + "\n", + " const js_urls = [\"https://cdn.holoviz.org/panel/1.5.3/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.5.2.min.js\", \"https://cdn.holoviz.org/panel/1.5.3/dist/panel.min.js\"];\n", + " const js_modules = [];\n", + " const js_exports = {};\n", + " const css_urls = [];\n", + " const inline_js = [ function(Bokeh) {\n", + " Bokeh.set_log_level(\"info\");\n", + " },\n", + "function(Bokeh) {} // ensure no trailing comma for IE\n", + " ];\n", + "\n", + " function run_inline_js() {\n", + " if ((root.Bokeh !== undefined) || (force === true)) {\n", + " for (let i = 0; i < inline_js.length; i++) {\n", + " try {\n", + " inline_js[i].call(root, root.Bokeh);\n", + " } catch(e) {\n", + " if (!reloading) {\n", + " throw e;\n", + " }\n", + " }\n", + " }\n", + " // Cache old bokeh versions\n", + " if (Bokeh != undefined && !reloading) {\n", + " var NewBokeh = root.Bokeh;\n", + " if (Bokeh.versions === undefined) {\n", + " Bokeh.versions = new Map();\n", + " }\n", + " if (NewBokeh.version !== Bokeh.version) {\n", + " Bokeh.versions.set(NewBokeh.version, NewBokeh)\n", + " }\n", + " root.Bokeh = Bokeh;\n", + " }\n", + " } else if (Date.now() < root._bokeh_timeout) {\n", + " setTimeout(run_inline_js, 100);\n", + " } else if (!root._bokeh_failed_load) {\n", + " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", + " root._bokeh_failed_load = true;\n", + " }\n", + " root._bokeh_is_initializing = false\n", + " }\n", + "\n", + " function load_or_wait() {\n", + " // Implement a backoff loop that tries to ensure we do not load multiple\n", + " // versions of Bokeh and its dependencies at the same time.\n", + " // In recent versions we use the root._bokeh_is_initializing flag\n", + " // to determine whether there is an ongoing attempt to initialize\n", + " // bokeh, however for backward compatibility we also try to ensure\n", + " // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n", + " // before older versions are fully initialized.\n", + " if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n", + " // If the timeout and bokeh was not successfully loaded we reset\n", + " // everything and try loading again\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_is_initializing = false;\n", + " root._bokeh_onload_callbacks = undefined;\n", + " root._bokeh_is_loading = 0\n", + " console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n", + " load_or_wait();\n", + " } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n", + " setTimeout(load_or_wait, 100);\n", + " } else {\n", + " root._bokeh_is_initializing = true\n", + " root._bokeh_onload_callbacks = []\n", + " const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n", + " if (!reloading && !bokeh_loaded) {\n", + " if (root.Bokeh) {\n", + " root.Bokeh = undefined;\n", + " }\n", + " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", + " }\n", + " load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n", + " console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", + " run_inline_js();\n", + " });\n", + " }\n", + " }\n", + " // Give older versions of the autoload script a head-start to ensure\n", + " // they initialize before we start loading newer version.\n", + " setTimeout(load_or_wait, 100)\n", + "}(window));" + ], + "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n const force = true;\n const py_version = '3.5.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n const reloading = false;\n const Bokeh = root.Bokeh;\n\n // Set a timeout for this load but only if we are not already initializing\n if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n // Don't load bokeh if it is still initializing\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n // There is nothing to load\n run_callbacks();\n return null;\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error(e) {\n const src_el = e.srcElement\n console.error(\"failed to load \" + (src_el.href || src_el.src));\n }\n\n const skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n const existing_stylesheets = []\n const links = document.getElementsByTagName('link')\n for (let i = 0; i < links.length; i++) {\n const link = links[i]\n if (link.href != null) {\n existing_stylesheets.push(link.href)\n }\n }\n for (let i = 0; i < css_urls.length; i++) {\n const url = css_urls[i];\n const escaped = encodeURI(url)\n if (existing_stylesheets.indexOf(escaped) !== -1) {\n on_load()\n continue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n const scripts = document.getElementsByTagName('script')\n for (let i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n existing_scripts.push(script.src)\n }\n }\n for (let i = 0; i < js_urls.length; i++) {\n const url = js_urls[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n const element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (let i = 0; i < js_modules.length; i++) {\n const url = js_modules[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n const url = js_exports[name];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n const js_urls = [\"https://cdn.holoviz.org/panel/1.5.3/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.5.2.min.js\", \"https://cdn.holoviz.org/panel/1.5.3/dist/panel.min.js\"];\n const js_modules = [];\n const js_exports = {};\n const css_urls = [];\n const inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (let i = 0; i < inline_js.length; i++) {\n try {\n inline_js[i].call(root, root.Bokeh);\n } catch(e) {\n if (!reloading) {\n throw e;\n }\n }\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n var NewBokeh = root.Bokeh;\n if (Bokeh.versions === undefined) {\n Bokeh.versions = new Map();\n }\n if (NewBokeh.version !== Bokeh.version) {\n Bokeh.versions.set(NewBokeh.version, NewBokeh)\n }\n root.Bokeh = Bokeh;\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n // If the timeout and bokeh was not successfully loaded we reset\n // everything and try loading again\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n root._bokeh_is_loading = 0\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n if (root.Bokeh) {\n root.Bokeh = undefined;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + "if ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n", + " window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n", + "}\n", + "\n", + "\n", + " function JupyterCommManager() {\n", + " }\n", + "\n", + " JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n", + " if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " comm_manager.register_target(comm_id, function(comm) {\n", + " comm.on_msg(msg_handler);\n", + " });\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n", + " comm.onMsg = msg_handler;\n", + " });\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " console.log(message)\n", + " var content = {data: message.data, comm_id};\n", + " var buffers = []\n", + " for (var buffer of message.buffers || []) {\n", + " buffers.push(new DataView(buffer))\n", + " }\n", + " var metadata = message.metadata || {};\n", + " var msg = {content, buffers, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " })\n", + " }\n", + " }\n", + "\n", + " JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n", + " if (comm_id in window.PyViz.comms) {\n", + " return window.PyViz.comms[comm_id];\n", + " } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n", + " if (msg_handler) {\n", + " comm.on_msg(msg_handler);\n", + " }\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n", + " comm.open();\n", + " if (msg_handler) {\n", + " comm.onMsg = msg_handler;\n", + " }\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " var comm_promise = google.colab.kernel.comms.open(comm_id)\n", + " comm_promise.then((comm) => {\n", + " window.PyViz.comms[comm_id] = comm;\n", + " if (msg_handler) {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " var content = {data: message.data};\n", + " var metadata = message.metadata || {comm_id};\n", + " var msg = {content, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " }) \n", + " var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n", + " return comm_promise.then((comm) => {\n", + " comm.send(data, metadata, buffers, disposeOnDone);\n", + " });\n", + " };\n", + " var comm = {\n", + " send: sendClosure\n", + " };\n", + " }\n", + " window.PyViz.comms[comm_id] = comm;\n", + " return comm;\n", + " }\n", + " window.PyViz.comm_manager = new JupyterCommManager();\n", + " \n", + "\n", + "\n", + "var JS_MIME_TYPE = 'application/javascript';\n", + "var HTML_MIME_TYPE = 'text/html';\n", + "var EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\n", + "var CLASS_NAME = 'output';\n", + "\n", + "/**\n", + " * Render data to the DOM node\n", + " */\n", + "function render(props, node) {\n", + " var div = document.createElement(\"div\");\n", + " var script = document.createElement(\"script\");\n", + " node.appendChild(div);\n", + " node.appendChild(script);\n", + "}\n", + "\n", + "/**\n", + " * Handle when a new output is added\n", + " */\n", + "function handle_add_output(event, handle) {\n", + " var output_area = handle.output_area;\n", + " var output = handle.output;\n", + " if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", + " return\n", + " }\n", + " var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", + " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", + " if (id !== undefined) {\n", + " var nchildren = toinsert.length;\n", + " var html_node = toinsert[nchildren-1].children[0];\n", + " html_node.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var scripts = [];\n", + " var nodelist = html_node.querySelectorAll(\"script\");\n", + " for (var i in nodelist) {\n", + " if (nodelist.hasOwnProperty(i)) {\n", + " scripts.push(nodelist[i])\n", + " }\n", + " }\n", + "\n", + " scripts.forEach( function (oldScript) {\n", + " var newScript = document.createElement(\"script\");\n", + " var attrs = [];\n", + " var nodemap = oldScript.attributes;\n", + " for (var j in nodemap) {\n", + " if (nodemap.hasOwnProperty(j)) {\n", + " attrs.push(nodemap[j])\n", + " }\n", + " }\n", + " attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n", + " newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n", + " oldScript.parentNode.replaceChild(newScript, oldScript);\n", + " });\n", + " if (JS_MIME_TYPE in output.data) {\n", + " toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n", + " }\n", + " output_area._hv_plot_id = id;\n", + " if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n", + " window.PyViz.plot_index[id] = Bokeh.index[id];\n", + " } else {\n", + " window.PyViz.plot_index[id] = null;\n", + " }\n", + " } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", + " var bk_div = document.createElement(\"div\");\n", + " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var script_attrs = bk_div.children[0].attributes;\n", + " for (var i = 0; i < script_attrs.length; i++) {\n", + " toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n", + " }\n", + " // store reference to server id on output_area\n", + " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle when an output is cleared or removed\n", + " */\n", + "function handle_clear_output(event, handle) {\n", + " var id = handle.cell.output_area._hv_plot_id;\n", + " var server_id = handle.cell.output_area._bokeh_server_id;\n", + " if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n", + " var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n", + " if (server_id !== null) {\n", + " comm.send({event_type: 'server_delete', 'id': server_id});\n", + " return;\n", + " } else if (comm !== null) {\n", + " comm.send({event_type: 'delete', 'id': id});\n", + " }\n", + " delete PyViz.plot_index[id];\n", + " if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n", + " var doc = window.Bokeh.index[id].model.document\n", + " doc.clear();\n", + " const i = window.Bokeh.documents.indexOf(doc);\n", + " if (i > -1) {\n", + " window.Bokeh.documents.splice(i, 1);\n", + " }\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle kernel restart event\n", + " */\n", + "function handle_kernel_cleanup(event, handle) {\n", + " delete PyViz.comms[\"hv-extension-comm\"];\n", + " window.PyViz.plot_index = {}\n", + "}\n", + "\n", + "/**\n", + " * Handle update_display_data messages\n", + " */\n", + "function handle_update_output(event, handle) {\n", + " handle_clear_output(event, {cell: {output_area: handle.output_area}})\n", + " handle_add_output(event, handle)\n", + "}\n", + "\n", + "function register_renderer(events, OutputArea) {\n", + " function append_mime(data, metadata, element) {\n", + " // create a DOM node to render to\n", + " var toinsert = this.create_output_subarea(\n", + " metadata,\n", + " CLASS_NAME,\n", + " EXEC_MIME_TYPE\n", + " );\n", + " this.keyboard_manager.register_events(toinsert);\n", + " // Render to node\n", + " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", + " render(props, toinsert[0]);\n", + " element.append(toinsert);\n", + " return toinsert\n", + " }\n", + "\n", + " events.on('output_added.OutputArea', handle_add_output);\n", + " events.on('output_updated.OutputArea', handle_update_output);\n", + " events.on('clear_output.CodeCell', handle_clear_output);\n", + " events.on('delete.Cell', handle_clear_output);\n", + " events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n", + "\n", + " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", + " safe: true,\n", + " index: 0\n", + " });\n", + "}\n", + "\n", + "if (window.Jupyter !== undefined) {\n", + " try {\n", + " var events = require('base/js/events');\n", + " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", + " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", + " register_renderer(events, OutputArea);\n", + " }\n", + " } catch(err) {\n", + " }\n", + "}\n" + ], + "application/vnd.holoviews_load.v0+json": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ] + }, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "411e512c-2318-4585-8bdc-fa205b66b53b" + } + }, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ], + "text/plain": [ + ":Image [lon,lat] (GPCC Monthly total of precipitation)" + ] + }, + "execution_count": 8, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "d2cc0081-e908-40df-a24a-805c7ce49fe0" + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "import hvplot.xarray\n", + "import cartopy.crs as ccrs\n", + "\n", + "precipitation_data = ds[\"precip\"]\n", + "n_date = 1355 # change to any value between 0 and 1355\n", + "date_to_plot = precipitation_data[n_date] # select the date\n", + "vmin = date_to_plot.quantile(0.05) # adapt the ranges of the values for a better visualisation\n", + "vmax = date_to_plot.quantile(0.99)\n", + "image = date_to_plot.hvplot.image(\n", + " x=\"lon\", y=\"lat\", projection=ccrs.PlateCarree(), # geospatial parameters\n", + " cmap=\"viridis\", colorbar=True, clim=(vmin, vmax), # colors parameters\n", + " width=500, height=400) # size of the graph\n", + "\n", + "image.opts(tools=['pan', 'wheel_zoom', 'hover'], show_grid=True) # additional parameters for the plot\n", + "\n", + "image" + ] + }, + { + "cell_type": "markdown", + "id": "ce43ea49-5461-4d20-becc-4fb0bf619b6f", + "metadata": {}, + "source": [ + "`hvplot` can also be used to create interactive animations relatively easily, using the `panel` library. See the [official hvplot documentation](https://hvplot.holoviz.org/) for more details." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "97acd29d-ff84-4d69-a99d-a10a8416e56e", + "metadata": {}, + "outputs": [ + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ], + "text/plain": [ + "Column\n", + " [0] ParamFunction(function, _pane=HoloViews, defer_load=False)\n", + " [1] Player(end=1355, interval=100, loop_policy='loop', name='time')" + ] + }, + "execution_count": 9, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "1556b718-c928-4566-abba-9a090d31eddf" + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "import panel as pn\n", + "\n", + "# slider widget\n", + "time_slider = pn.widgets.Player(name='time', start=0, end=len(precipitation_data.time) - 1, loop_policy='loop', interval=100)\n", + "\n", + "# function to update the plot, based on the created widget\n", + "@pn.depends(time=time_slider)\n", + "def update_image(time):\n", + " date_to_plot = precipitation_data[time]\n", + " vmin, vmax = date_to_plot.quantile([0.05, 0.99]) # adjusted min/max values ranges\n", + " return date_to_plot.hvplot.image(\n", + " x=\"lon\", y=\"lat\", projection=ccrs.PlateCarree(),\n", + " cmap=\"viridis\", colorbar=True, clim=(vmin, vmax),\n", + " width=500, height=400\n", + " )\n", + "\n", + "pn.Column(update_image, time_slider).servable()" + ] + }, + { + "attachments": { + "2861c41c-a656-4287-a6b8-d7623961fb25.png": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAACMwAAAPFCAYAAACTBubiAAAABHNCSVQICAgIfAhkiAAAABl0RVh0U29mdHdhcmUAZ25vbWUtc2NyZWVuc2hvdO8Dvz4AAAAodEVYdENyZWF0aW9uIFRpbWUAbWVyLiAxMyBub3YuIDIwMjQgMDk6MTk6MzkVP63IAAAgAElEQVR4nOzdWYxkV57f9++5S9zYI3LfqrIya19IVpFFsrlMD5vTPd09ktzSdAsSIOjBNmx47AfD9oNhvQqQAflBsGBAsAFbHhvW5lkkS9MjzdIre2GzSTaLZFWx9jWXyi0y9oi7HT9krWSRVZWVZHWRvw9QzIyIe885d4nkw/3h/ze1Ws0iIiLyGarValy6dIkXX3yRIAge9XJERERERERERERERERE5AvGedQLEBERERERERERERERERERERH5LCkwIyIiIiIiIiIiIiIiIiIiIiJfKArMiIiIiIiIiIiIiIiIiIiIiMgXigIzIiIiIiIiIiIiIiIiIiIiIvKFosCMiIiIiIiIiIiIiIiIiIiIiHyhKDAjIiIiIiIiIiIiIiIiIiIiIl8o3qNewFbohxHtTo9uP6SQy1LMZ/E891Eva0ukaUoUJ4RhtKn9HdchyPh47ufjfHze9Poh7W6fNE0ZqpZwHGXYREREREREREREREREREREPm2fi8DMwvIabx8/x5mLCxzeP8uzT+5meKD8qJe1JTq9kKXVGotLq5vav5DPMjUxymC5uCVhDGvtHa+NMQ895qMUxwm3H5GBzyxsZa3l4twS7566SK8X8u1vvEghn+Nhzqi1ljRNN7Wv4ziP/fUUERERERERERERERERERG5H5+LwMz7py9z/Mxlnn1iD3/22ttMjg1+bgIzH1yY5+KVd3hq9iJJarH33uUWa1mtl3nvzEG+/dvPkc8Fm15HHMV0u116vR5pkhJFEZ7vkS/kKRQKuI9hBZt6s8M/+qf/mnqrC9fPbKWY57/7T3+XSin/qc9/5tI833/9Xd589wxB4LNjapTDB2aplgqbHvPEyeOcOPH+pvY9ePAJDh18YtNzi4iIiIiIiIiIiIiIiIiIPC42GZi5Edu4v2oUaRISddborc+RH5rFzw3AQ1ay6Id93nrrl/T7fVYWlsibJiuLF1hZq/HW22+xunDuju2fevIwQ0PDDzXnJ7lR1eP2Ch1bUa2jH8aQrrNz9BzpA6VlAAuOHeX9SztJ7YPufH0Ia4miiE6rQxzHeJ5HppAhCmPq6+t0uz2iMGJoeGhT438abr83Pkm7F3H+ygLZgW1kC2V67QZrV67y2k9/TCHrMzuzk5mZ2Qee/733j7GysvKxn1sLrV7Kmbk6842UYGgHjrH8xc/f5dLli4xWs0yNj/DkE4cfeO5ut4txDE8+8dQDrvldut3uA88nIiIiIiIiIiIiIiIiIiLyONpUYMbQx9gWhhBLgDUlLD53C9CkSUTYWKB19Q2i+kUMr2BGD+IFxYdaeBLHnDt/jpHhYfbMTLEHaHVDjDG4nksm4wMQxzFnz51l585dDx2YSdOUMAwJw5AojojjmCSOSdIEg4O1KRaLMQ6u4+D7Pvl8gSAb4Lmbyyb5nkuU5Dh5uUKS2o3gy31nXyy1Vp5cNth0eMdaS6/bo9FoEAQBpUqJIAhIsglhGG5UnNlkC6BPi8Hg+xlWV1fxfZ9S6e7VhqIEjONQqI5QGhilWbtGWJ8n42fIZDKbrprjeT79fp8oihgcvDNIFEYRy7UGb5+8TD0pEFSnGBgeIU0ilhYuUD9xmd0TRaqV6qbmBigWiuzds/eB9rlw4fym5xMREREREREREREREREREXncbC4wY9dx7RWMrV0PzAyTmgrWlLHkbw5rbUrYWqI9/ys6l36AY2Oi4YMkUXfTgZlWq0Wr3aLX65KmCePj44yNjQNQb3ZxvfeZGJtg585tZIOATCbg8pXLm5oLNkIy/X5/IyATRfT7fXq9Ht1el063S6/XJ4ljstksrudg2Kgs47kenu9TKvWpVCoU8ptrWzRQLmDcKb77y4jUydCPU+LYcs/mTNZibMxQqcSR/UN4rrO5EwBEUUS32yOTyeD7G0Ek13WpDlSIogKO8/CVdLZSJpPhuWef5/jx4xSLRXbs2HHX7Wr1Fn/wg5M3ix0ZDEE2y3PPPs9AZfOBrgP7D5LPFWi1Whw6dOjm+1Ecs7BUY+XYaerxKtnBbRQqI7h+BmszDE7spLYAfTcPfolePyTI+FtSqUhERERERERERERERERERERuefDAjE0hWQbmcFjE2GVcWyNxpomdIyTmIKkZAgxJv03r6i9pn/9LfNshLB4gN7yfoDiy6QV/cOokb//qTRxnIwDy5ltv3vysF6X0ej1++eYbXDj9NtPbp/nyb/zmpufaaEcUcvXqFZZXlkiShGKxSKFYAsfFeBncjEMmcBkcrDA+OkIum7sZwFivr7O2tsraWgIWyuW7Vzr5JHt2jOO6Dou1PoOjU6y2U+qdiDD+5KouaRyRp83stgq/9aWDmzl8YCP8EwQBruuQJAlRFJHJZADwr1dieTxYSGNulefZfIBoU9KY1bV13nj3DP/m+28ysuMA+dIgjrfxFTTG4AdZyqPbOTN/iWbjTarlArumJ/C9zVW6ERERERERERERERERERERkbt7oMBMai2tbkgceRS9lLJfx6GOoYmbnsK1l0h5jdTMEqYHWD99nN78u7iExJUnGHvybxKUJx960ePjE7z80ssfeb/e7PD2hX/Niy+8hJe2aLdbDz2XtTA4NMTw8DAWqNXWuDK/wNzSOmFscV2fBIfk9AU8x1LI5ZjeNsnRpw5RLpUpForU6+t0Ou1NBWYAto0N8p2vHuXPf36cweIQQbbEWiukH90lNGMtSdyn5HZ5ft8EX3pi9qGO3xhDvpBnfHKcZr3J4vwiuXwOayHIBuTzucciNGN6Nfyf/PeY/hoA6eizsPe//szm99/6n/jV22v86cXt9Htdrl08CcZhaGKWwYkZ4qjPlQ/eIo56JFFIew1+/4+/x9/7L/4mlVLhM1uniIiIiIiIiIiIiIiIiIjIF8EDBWaSxDJXi6i1ith0F6VMiZH8FcaCd2jOL0FkyZXXCapLrM29T7hQJ4kM3sBBhvZ8k2xlCuP6D73ojO8zODB48/Ubx86wtFbnpWf24zgOxWIRE8UPHZgxxuD7PuVSmVa7RbvVJElTLi11iJwq2XIO4h71pTkWl9cYmpylZXI0LqzQ773F0cOHyOVylMsVkiR5iOP1mBiu8JvP7OHYuWskScpwOcdKMySKU+z1oinWptg0Im9bvHhwkid3T1Au5h7qHFhricKIXq+PxZLN5SgWi1hrcT1vU22m7jpHFN3zHLmui+8/WIui1dVV+v0+XrjGnrUzpOMuTi/EbS887LLvqd1uc/r0aQBmls5yaHSZYLhGZrFPcvi/4t/95ANacYjl+jnod/jmy08yMzWKBQLfIxv8+oeRREREREREREREREREREREHjf3HZhJU0u3H3OtHrHUyNAJh3FsnsEg4FB+kXgxwgvbFOsh/toCrWshaVLGH3qGwsxvUhjdBw8QdHgQF+aucf7KNV56Zv+Wj+26Lt1el1arSa/Xwzoea21LcbhKP4mImw38tMfxX73BwewQg5PDdLpt+mevMjE2xMTYGPl8niAIHmodnueyZ8c4vTDm3MI6tW6PoWKWtVZIGFvSNMEkIXnT5endwzy1Z5Lhaumhjz9NUxr1Bs1Wi1wuR6VSJpvNYq+3NrLWkqbpzRZZm2Wtpd/vE0UR9kYC6LobwaVc7sHDP47j4LounutijMGkKSa1995xCxhjbgaKjDHszK0xk23iG5fw6B5+fnyeVv227R3Dk3tnOPrErs9kfSIiIiIiIiIiIiIiIiIiIl9U9x+YCUOSlTWclSZeZIgil3YU04tTxoqjVIwLzgrttSXSxSbGWszQdvLbX6Ay9fSnFpb5tMVxzNraKnEcUSgU6KcusXUIE4fG8gr1q6fIJuu8+8aPGdi2n9LoDI5fpNms02g2KeazWJsSBNktaV305J5tGAPvn18ikwkIY49GJyKMIgpuyJ7RHK8c3UsuuzWVSdI0pdFo0Ov1KRYLZHNZAAyGOI5vBlyCIPjYyi/GmE+sCmOMwfM2bsUoiojj+GZo5sZnvu/jed4DVZcBGBgYYMeOHZj+EM7SYZx+DRxIKzsfaJzNyOfz7Nq1EX7xGk/gLEc4IdihAXAevtKSiIiIiIiIiIiIiIiIiIiIbM59B2a8Rp3K+29zdO4aV3JDvJ8dxfH6PBG8x+xAFt8ZoL5uaLR6uL1VkqTH0N6DZKszWxKWSdP0k8MSn0LRkBthkX6/R7lcZqA6yOJqnThO6PYiUjfH5cU1vvdH/wd+kCVfGcTNZIn7XXJBhj179lBfW2Zufo5SuczE2MRDV2IBeGL3NvK5LP/uteNURrbR6VrSpMOu8Rzf/urRLTjyO8VxgrUWazcqwdy4Dp12h/p6nTRNGRwaxPU+2p7pRuDlXmEX13UplUoYY2g2mzfbMzmOQ6FQoFgsPlT7JxtUCV/5x8RJgr1eYSZqtG7dNzeWZi1RnBBF8cbbjsHbgrZT8dP/7UOPISIiIiIiIiIiIiIiIiIiIlvj/gIzUQRrq5gzp8murLCj8Q6Fckprd4XBfZO4aR9rUwo5D2dohHVi4tUPWD3xJ7iZIsGhb2GczYcOoijizNnTbJva9rHbWCxJmm5pbsZxHCqVCkvL1+h2OlTKVSqlPIOlLKtRhJOvcuDF32Fi11ME2RyV4SniJMV3UvZuG8F3XcbGxlleWWbp2iILc3M89dSRLak0kyYJYb+3cbxm43Ucxw897oe5rsvI6DAryyt0Ox2azRalUpE4jqmv1+l0OgRBQJImeObuoZhOp0Mmk7lnSyXXdSkUChhjaDQaAJTLZfL5/EOFZW73f/7hX/L+mUsYY7BAvdmmeP2msVjW6y3+wf/6/2LYCAc9sWcH//nf/saWzC0iIiIiIiIiIiIiIiIiIiK/Hu4vMBPHEEaQpjj1GsHyEgNrbTKmBCMedqCEdSzYlIzvUC5X6dkdtNtNwl57oyrJQywyjmPOnT9LtVq96+eDlRIno6v883/3QwpDfd688nNymY0UxA9P/YgFZ4n3Ft/HLXhsG/r40M3duK7LxPgEq2urzM1fZWx8gi8/s5vX3r3KQrOB8fMMTO7GcR3CJCZjQ6aHA54+sAPfd+m0W/R7PRzjkCvlcZyta0210bZo4zgt9mYbo61kjKFULuE4DlEY0e/1ieOINElxXZdyuYyX8bDW4rruR4ItaZoSx/F9V9ZxXZdcLnczeJPNZrcsLAOwa3qCS/PLXFhcpzQ0ydjsJNliBWMMuWKF0Z1P0A97NFcXmB2vsmvHxJbN/WvlwkXM8eNw7RoAT83PkQ2ymFNnYMcO7LPPQhA84kWKiIiIiIiIiIiIiIiIiIh8Ou4vMOO6MDQETz8NxQKcPEFm7jzpuVW6wVmiQ1M4A3mMa3DShGzGwZZHcQf3kRuc/eRWSvfB2pT19XWiKLrr57t3jBNGMYurK1SdhNXeAhPFMUYro4RJhFNyObdyjtHB0QcOzABUKlXiOGattsbqyjKjlSIHt5cJFlustHr0Y0sap5SzLtPDBfZPDzJcKbC2ukKv38fzfEZHx8jnCzgPUWnnUTDG4Ps+5UqZMIyIwpA0TXGMQxAEOI5DkiY3r43jODevd5qmN//db5jnRgunQqFw8/XD3j8AxF3cS/+Bo84S8eAifhOumSkKAyN4fgAYPD9LsTpCY/kqe3ZM8MKTsxzeP/vwcwPO3I8wrbmNF16OZMc3t2TczTKXLmF+8QZOv491XbYBtDpQW8cuLMBTTykwIyIiIiIiIiIiIiIiIiIin1v3F5jJZGBqCjM+jt27FzM+jndsgNzl85gLTVruFeyuQZxqHhwHi8EvTzCw4xXyI3sfqh3T3fT7fRavLd58nfPh6IEpOuEA/+bYCQbLQxyYPsj0yDRhHOIYl3OL5+iG3U3POTQ0jO9nuHT5IkmSsHOiQiHjcH5+jVqzizGGqdEKu7dXGR0sUK+vs7yyQqFQZGhwmFKptBWH/sg4jkM2G5DN3hmiiKKIbrdLHMeEYYjjODcrwiRJQq/XI0mSB5pry0IybNwrjUYDp7fC4Dv/CyNuky/5OdyBGb7bmaHXyGLKw7iZgDjs02uskEubvHz4MM8c2sVQdfPXLY7jm62lKif/JV79DXAdTFomnfyNLTm+u/nw9+NuSnNzVKII77nnNoIxxkAck87PE587Bw94zURERERERERERERERERERB4n9xeYucF1MVPbYGob5mu/jTl/jvyPf4B540fU4wWiXVXcwSqpX6Gy67fJDe7Ey+S3dMGO47C8ssx3//RPPvKZdSEYzXJg+iB7JvdQyVdI0gSzy9CPe+SC3EPNXS6XOXjgENeWrrG0tEgShuyeyBHMVPE8FzD02jVOry3gez7T22coFot4nkeapneMtZWhkLux9uNbNG313NZakiSh0+nguu7NsaMo2lRgZistLS2xvLxMkNR5LopI9oxTbXb5UtElHT7MH//Z61gLQaFCr71OWLvM3/rGSzx9aCcD5eJDzd1sNnnvvfcAONxsUBofICnlyJ3t3NrIWmyaYNP0eneth2ur9Unfj9sdvXyV58fHCX73dzHlMsZxsN0u0S9+sRGYERERERERERERERERERER+Rx7sMDM7bI5zO69OBOT5H/nr+GcfpP6yjGiyKdy8HfIDc7i+tktXOqGAwcOMjtz9zY57bDDH731h9Tb63R6bXJ+ljhJaLTrNNoN+uX+Q8/vui4jIyMMDgzQD0P6vR79fp8kiTGOQ7FQIpvL4rk+Fy9epNlsEsfxHWMUCgW2bdvG2NjYpteRpilhFGEtd81YXLx4kaWlJfr9O485CAJGR0eZnd2aVkNwKzCTJAlBEOC6LtZaOp0OURR9Ynjn0zY+Ps7k5CRObxl/2cc/M49JLZWhfRw9tJtuL+QHb5zk8pUzTAxX+WuvPMvTB3dSLj580KtcLrN7924ASj+v4M2fxDoGTBXYOG9rC5eor8yDtYT9Lg97mj7p+3G73J/9OcmPfkT77//9jSCcMRuhnU7nnvuKiIiIiIiIiIiIiIiIiIg87jYfmHEcyGYx2SxmYJCgkKfa2k+aMWSGZ3D9HMY4W7hUePe9YxQLH636UalUmJiYpFwp0+g2efvs28RJzN7JvfSjPq8df435tXmmh6a3ZB2+5+N7PplMhlw2SxwnpDbFYHBdF9/3AEO1WuXEiRNcvnyZKIowxpDL5XjhhRcIguCe83ySgXKBZ/ZNc/LKVVpdIOkDtwJK+XyeWq3GiRMn6PV6AGSzWQ4ePMjMzMxDzX03NwIxaZreDMjc/vujMDU1he/75PN5CMZInvt7kGycC5sfo1LK86XDe+n1QhaWa0yODfL8U3sol/K4zsPdu8PDw1QqlY25AfvEf0zc+Z2ND90sNlPir776HC8c2XczJGMMzGwbfah5c9kcuex9VFKanMRWq9i5uTvfz+dh925wt7aNmoiIiIiIiIiIiIiIiIiIyK+TzQdmbuc4uKMT5EYntmS4D/M8nwP7DxCG4V0/9/0MruPiGIdKrsKllUucvHKSbtgljELOLpylEBTI+Q/XkunDHMclk3HJZD76mbWWoaEhJicnmZ+fZ2FhgUwmw8zMDOPj4xQKhYeau1LKc2T/NK5ruLLSpt2xFHK3FrIRIprgypUrXL16FYADBw4wMTFBpVJ5qLlv5zgOruviOM4dAZnbgzKe5+E+ggBGtVq99cLNkkz/9h2fu8DYUJUXjuyj1elRKuQYHdqac/Ph65uOPf+RbZ7cuwPgjsDMp9mm6w4zM/BbvwXLy3e+n8vBtm3wkIEuERERERERERERERERERGRX2dbE5j5lGUyGZ49+tHAwYf1oz5HZo+QD/JESUSr0yK1KdND02wf3s7k4ORnsNoNxhjy+TxHjx7FGEMQBORyOV599VWGh4fxvIc79RnfY3J0gMnRAc5eWmRhZZ1i/laFmWw2y/79+/F9nyiKAHj55ZfZtWvXQ1e3uZ3jOGQyGbLZLEmS4HnezdCH67pkMhmCIMD3/S2bc6tNT448knlvnKfPKiNzh+lp7PTWVFwSERERERERERERERERERF53JharfZo+uV8gXS7XbrdLsYYKpUKzkO2+3kQYRjSarUAKBaLZO5WDkdE5DNWq9W4dOkSL7744paG+ERERERERERERERERERE7sdjUWHmcRcEwc2gymcZlgHwff9mC6bPem4RERERERERERERERERERGRX0cKzHwGHmVQxRiD67qPbH4RERERERERERERERERERGRXzcqOSIiIiIiIiIiIiIiIiIiIiIiXygKzIiIiIiIiIiIiIiIiIiIiIjIF4oCMyIiIiIiIiIiIiIiIiIiIiLyhaLAjIiIiIiIiIiIiIiIiIiIiIh8oSgwIyIiIiIiIiIiIiIiIiIiIiJfKArMiIiIiIiIiIiIiIiIiIiIiMgXitdsNh/1GkRE5HMol8vhed6jXoaIiIiIiIiIiIiIiIiIyEd4x0+cIE4f9TJEROTzwhjwDOzdu5eBgYFHvRwRERERERERERERERERkY/wLrQ9/s189lGvQ0REPieKnuXvbO886mWIiIiIiIiIiIiIiIiIiHwsr5/CUt951Ov4lFiwFmwK9vb3DR964+4MYJzrv7BRNkFE5DHzrb1FdhQdUpvi+/6WjPn6XI/X57p3/ayXWFS4TERERERERERERERERER+nXmPYtKJnGVbPiXr3Edo5S4SC83Y4YOGQ/SxT2Utbr9NprlAGvY3gjOAtZY0TXGMwXGdmxkYazciNHZj15uvEwt2cDvkK5taq4jIo/bUSMBzk1kcx8HztubPfi9a4/RSm7Xo8xq4FBEREREREREREREREZHPs0cSmNldTPn6lGWkmNnU/t0o4Xwt4kLLJ0o/puqLtbi9dQaW3mdquIrrbDzUbTRbXLk6x/BAheGhAYIgwGJJUogTS5xu/Ov0I9bqDZr1OsmhAuTKqjAjW8q4DjnfpeAZHJuw3kkI7X3VPhJ5YEEQEATBR96P45hOp0MURaRpijEG13XxfZ9CoYD5mL97gzmHwUyqwIyIiIiIiIiIiIiIiIiIPJYeSWAm56ZMVAvs2bPnnttaa7HW3nxoa4xhfX2dWussjvmE1iJpihNHDGQc/of/8u8yUCkB8NaxE/zP//u/4MvPHebrr77E5PjoRkAmtLT7CZ2+pdmLOX91kR/+7BecPfYWqU2xj3mMwXEMrjEYLGlqiR/vw9k0c70b11Yc/sOO5eVz7BorcHjApRB2+NMTTa5FKeEWrE3kXqy1JEnC2toaZ86cYWVlhV6vh+u6FItFRkZGOHjwIEEQYIz5SHCmExuasUKEIiIiIiIiIiIiIiIiIvJ4eiSBGeDmQ9l7abVaXLt2jaGhIYrFIr7v0+v1Hmgue73FEgbsjee713/GqaUXWbphuvEzSvng/GVOnbtANZ8hkw0IHfcxjssYfD/DnoNTfGcmoNJc540zq/zRlZDkUS/tM2SMIQh8BjPQDxNqvYSP7eZ1H2O5nks17+OGIe0wobWJk1kYrPLivkG+PWZpLSX87HSTlWiTixJ5QIuLixw/fpyFhQUGBwcJgoDBwUHiOKbX67GwsMD777/P008/zc6dO+/r77WIiIiIiIiIiIiIiIiIyOPikQVmjDE4zie38rDWcuHCBf7JP/knAPze7/0ehw8fvud+d4wBxGlKlFiMgSTZeNNaSFIIY0svSulFKd0w5d1T57kyt0Axl2Vk+zZOHn+Px7uGgoPnZ9i3vcyhiQxjxYhOrcl3r4R0+GK0/wkKebZNj/C3ZwIGe3V+dK7OX1xOeLDY1XVOhsnRMl89MsDBIOXsiUV+OtfmZGcTQ3kuxcBnMJfi+BsVgDbPMD49ysvbChypOHe9Z22akqyt8gen23xQj79QgSm5JU1TVldXOX36NGEYMjs7y/DwMPl8nlwuR5qmhGF4MzRz9epVrLXs2rVLoRkRERERERERERERERER+dx4ZIGZ+7G6uspbb73Fd7/7XWZnZ2m32w88RmotYWKJko1oSJTcaq4UJRvVZXqRpdWLOXn+KpeuzpPxfbZPTZEvFHAcl8c7MWNJ04S19Q4XczGNdp/5drrp6iqPIz/wGRkb4NXdWSq1iIuLLdxNj+ZRKRV4dt8Qz7shmbkVji9u4WIfQqlS4MD2QV4duz0wY/Bcg+cYTBzTvdTmR5e7nKo/woXKI5MkCc1mk9OnT9PtdpmYmGD79u1ks1m63S7WWgqFAsPDw8RxzNDQEGfPnmVlZQWAJ554Atfd/LdHREREREREREREREREROTXxT0DM2nUw8YR1t49YmEw4Lg4mSzG2doHqadOneInP/kJ7Xabr33ta0xOTj5wdRlrIUogvB6YiVO7UV3GQv96dZl6u8/FhRWOnThNuZBn+9QUo2PjtFrNB1itQ6mYoZp1KXobAQUXSNKUXhjT6EasdVNiwGIIAo9yzqOScQlcg2c2KoB0+hErjZBGasgEPpWcRzVwyDqGNE3p9iJq3Zh6f2MsAIwhm/Eo530GAofAMWAtYT+i1olYjUPOL3Y478cstbqcWQs3qqu4HkNFn0rgkHMdPLNx1uJ4Yx31bkwttB9ThcahVPSpZj0KniHjGBw2Hsh3wpReAm7GpeQ7uFjiOKHVi1hpx3TTW5VtXNcln/MZznnkPYOLJYoT2t2I5U5MP4UUQ8Z3qRQzVPyNuTzHYLAkSUrn+rjt2H5s1RTneoLE+D7jAwWemnLopJZOs8N8N6WdGnzPpVLIMBA4ZF0DaUr/+rVb7aXE9ta6zfX/Vip5do1buqWUOIq4uhbScT3KOZ+hnEPm9vugH7HejVnrpfdZ3cVgPJ+pqk81Y0jCmNX1HisxpDgUCxmGij5Vx9Jr97DdLucW6/yidyswk8nl2FbNMJl3IIq4tBbSDNMvRGUh+ahut8vVq1eZn59n165d7Nixg2q1SpIkXLx4kXa7zejoKNu2bSMIAoIg4ODBgxw7doxLly4xMTHB8PDwA/0dFhEREREREREREREREa6gqrMAACAASURBVBH5dXTPwEy4tki0fo007GI/9JTdGMA4ePky2fGduPnyAy/AWkscx1hrcRwHz9tYUhzHvPnmm3z/+99naGiIb3/720xNTT3w+KmFKN6oMmOAOAWwxImlH6V0+gkXF5b53s/fZqSYY8/u3VQHBm8d432VlzFgMjyxb4Kv7SrzTDXDUNYl66R0Oz3Oz9f46dka//5sm2uxJTYek+MDvLxviFcncmwveZRcSMIuJy6s8K9+ssjPeh7btg/z1T0DfGVbnh1ZQ9jrceriCn92qsaPrnZZuZ66cLwM26cGeGX/EF/bnmdbzsWJQq5eXubPjy/zz+dhz65RXp3NMFGHYrfNj1ZT0nyJV4+M8JXpAruuB2e8NGG93ub4pTV+eLbGX8716dgPt266frx7x/nqzjLPDAQM51xyTkqn1eXEfJuLbShNVDg6lKFsEuq1Br88u8IfvVvjZM8SWTCOS6lc4Mk9Y3x7b4kDFY8iMWtrLX51fpk/ON7gQiehbT0GB8q8+uwYXx0JmMh5lDMGn5ROq8eJ89f4w+N1frUaUr9H6Rx3cIi/8uIQf+UFS9gPOf7GB/zjUz2OdzxGR8r85qFRvjFdYEfe4IR9ri7W+dkHS/zrC12WI0v0oXPwzJEZnj4MNu5RW1nhf/y385wsDvDlA0N8e3eBybxH1mzcB+eurPHD06v8f+e7NO8nseI4OOVh/s6ro/z2No/O3Cp//P2L/OGapW199u+Z4DvPjvHVbMSpt07zj05c41+eXeBf3BqA7fun+btPDfHXMzHteo1/dbzJhYbaMX1R1et1Tpw4wY4dO9i2bRulUgnHcYjjmFarxerqKp7nMTg4SKVSAaBQKDA7O4sxhmPHjvHlL3+ZbDb7iI9EREREREREREREREREROTh3DMw45UG6K9coX3lJGm/e8dnxvXwigNUn/oKJvPgD1DTNKVer/PP/tk/o9Fo8Pzzz/O1r30NgHfeeYe3334b13X51re+xeTkJJlM5oHnsNYSJSlRfL3CTLJRYSZONirMnD9zifdOnWe0XOTAwUMUi6UHnmMjPOEzMZRn53CWCR9sktCKDUE2y96ZMcYqefaX5/nH77RYjH3Gh4ocmSlxIGfwsPSTjaolngP91GPHgWn+7qEyzw15ZLHUuylBNsv+PeNUA5dhb4l/ei4kNj5PHprkW/uqvDLiU/QMaZwQGxdjwLMJ9m4NiIzBZLLsGMqxayDDgLHEUUzbuBQrRZ47GDA5mGP6V1f5v67ENOMPVZoxPhPDeXaN5pj0gSShnToE+RxP7cxyIAXjGkgsjucyOFzhZcdhMA35B8faLIdQHRvg5QNj/Cf78gxnHJzEYozHyEiFV4pZdpbm+N/eafDWmkMhn2XPVIldeUPOJoSJpW8cCuUCTx/cRpBaMh+s8xdL8SdWT7FJTLuf0opS+mHESt8SWp9ds8P89pMjfGsiQ8kzpCk4QZad0z7DA3m2BZf4v893+aBzx2h0exHtKKUfhtQ7MT0LfeuQ9RzKnqXTCWm5HqVsln27RsgFLrQu80cr95GYsSlJs8m5xiBPhgFT2YADoz6ZekTXyzFeCpjJp0Rhl3cXQ9Z7t10j4+DkK7wyW+TwiEu73uTN95b4ZSuhrrTMF1a322VxcZH9+/eTy+VuBhQ/zBhzx++FQoFMJsPZs2dJEt1AIiIiIiIiIiIiIiIiIvL4u2dgxg0KZMdnScMe7QvvkkY9sBbj+fjlIYo7j+CVhnDcew519/Fdl+PHj/Pmm2+yurrKCy+8QC6X4/vf/z7vvPMOU1NTfOc736FYLN7xEPd+WHu9wkwCYXy9wkxiSa//fOvkeVrdkHw2y86ZGUql8kdbjdzvlMbgew6BZ+i1Wrz3wSJ/vmrIjQzy0kyRo4MFntg1xPMXuvy4vrFtPuPg2YhTx+f43nLMYpjQ6ibMZUp8dU+ZQ0Mu3eUaPz63zutNQ25okL9+oMSu8SKH6m2mL0XMVaq8NF3i2REP02nz89OrvLYa0bYOUafLtdrHBGYAHIfAcwjcmNXlJj/41SonUp/tM8O8vC3PntEiL++r8tq1VU4nls6tNMb143VvHu/7H1zjz9Z9Dh0Y5UvjWaZsj8XLK/w/Z/v448P8xnSRo+WAnZNFJo93adqA3eNlXp7JM+Fb5s7P8xdXeyyYPLunqvzOrhy7Zod57mqfpXYMjiHwHbJuytUz1/jJXJdLbp79u0f5q2MBeybyzCx0KCzFtD7hMqXNJr84V+cvr/TopimNWshSUOHLk2W+PO5Ttj3efHuZX9QSokqZp3ZU+NpInuf2D/DL1Zil3s27C2zM2XPX+OnVDh90EqIw5HQ/pZXW+dnxHotXPBzHIfA8ds8O89xElvFKjqdGAv5krX/vW8sCcZezq33mxvPszvnMjuepnm9gqzkmyhnGiek1Wry3nrAe3QrhuJ7L5PQQh4eyTNo+l5fr/NmlPmuRvdXKS75Qut0u/X6fSqVCPp/H87ybf1OttfT7fdI0vevf2VwuR7FYBKDf75PL5T7TtYuIiIiIiIiIiIiIiIiIbLV7plyM65GpjgEGm8R0r54iTSIyA+Pkpw+Rm9yD4wfX+zM9GGMM2WyW7du387Of/Yxf/OIX/PjHP2Z6eprXX3+dfr/P0aNHOXz48Kary/T7IRcuXaGQ33jAO7ewSNjvc3nhGulqk1KxzMTYGAZo1NfvCDG0O23SJP5wP6J7zUqvF3Ll6ho/vGqxy+BmPaYHi4xXSzxZdTnWuTVLkiQsLtT4+cWQ011wMlkGR6scGfYZylianksxn2HcGPysS+AYsvkMQ5Us2zMOvZEyeyoZRgm5sLzOfzi+zGv1hK41OGYj7+Pe69TZhGa7w7tnV/lx5DIU+RRzPrPbM4yPFdmZrTHXS28LzHz0eC9fXeWH8x61apnJSpYJJ6a91uDHZ9tE3SwjlSxPl11ypQxDLgRejm3VLPvLhqTX4Z1TK3zvSp9LdHkyctk3neNwscTewQy/WkqZvzlfytpqk2MX6vzShCwWqvzWcI5qIUM151Ew0PqE62X7fS5da/CTc23a19+rzhSYHsgy7aV0Vxv84NQKr60l9KoJTTfgubEig6MlZkvrvL96e8+nlJWVJu9eqvPz5q13s1mD73kE2QyDWZec41DOOPjGkPFchoserulzj+5RbIRyEq4sd7m6XiCa9hgaKTETdKiObARmgn6fy9eanOumtG8MaFwymSxHZovsKDlE9TZn5hsca6SED3Qvy+eJtRZrLcYYPM/7SDgwSRKazSbdbveObWEj2Oi6LnGsuJWIiIiIiIiIiIiIiIiIfD7cV1kY4/pkqmM4e58jjUPSqEd+cg/57QdwNtGK6ea4xpDJZPjGN77B2bNn+cEPfsDv//7vs2fPHk6ePMnOnTt59dVXb1Y2eFDWWjrdDm+++TZ+xgdgvbZOr9fj3MWLDA4MEhhYX3VYX13GZHLguDfDP2G/T8/42Nvee8AV0Kp1mKv3WUhKTLk+Y0VD8DEFX6y1WMfgFgJGPUNgHPyhMs8Xixy5uVVKvZNQjyDwHQbKASXfweuH1Oodjq0n9C1YLIkFMB9XX+ZjFpGwsNLjaiOk6eQpBQGjARtrvlfCI41Y7SQ0QouTM2Q9g8HSbMc0egmx8TG+Q2AMXs6nFLhUTUoU9Ti1HFHvp4Q2pNbocbEPhzIugzmXYnC3c2/pRQnXmhGRzYLvkPEMwccd1m2/3zmaoZTfWIufRDSaHT5opTTilLAVsljrsUqJqr8Rfil6Kb07djd3jux4TE8N8o39g3xlIqBqY+qRxctkKGcMTgS+ax7gdrKsr7a5XCuyOF1iolLkiYEGnbEsUyWHdifk1NUWy7ElvLEK1yNXLPGl8QyDfsLcSof35jqs2QfMfsnnShAE+L5Pu90mDEPS9NYX2nEcBgYGWF1dpdVqsby8jDGGfD6P67pEUUSv1yNNU4Ig+GglLhERERERERERERERERGRx8x991EyrodfGmTgqVex1uJkAhx/82GZ2z3zzDO8+OKL/OxnP+MP/uAPgI0WIN/5znd45ZVXNj1uCoRRzNnz5zBm4wFvHEU4DmRNQtRpMH+5xZUkoRcl1N0SNiiAc+O0ONjKDky2DGazD4g3KjWkKWDAYj6xzZO9/Rcbc225yftzHa4kt28Us7be4fL14jc39jFcD2I8cCriQwuyFnszXGGxmI2qFO7G2Kn9+OxMYi1pajeyI2ZjaHv9vRuH4Fyf48ZhGnOrGg5mYy73+utPyuhYC3G6sVCDwcD1cQyuA8ZyPTR0c7ob3aRw7hjnzg+969sYA46zMa65Yzt7/dxsrNu5cdKNwQRlvrJ/kK/M5qg027x3epnvraRUto/yG9sLHLrbtTfXj5sb52BjTPfGuWu3ubze42S7wnShwNOzA0STAZPZiLXlDm/ORfRvuz/crE9lvMyhnKEUd7hY63J8LVVY5gvOdd2boZlGo0EURTdbK/m+z9NPP83U1BTvvPMOP//5z9m3bx/79++nUCjQbrfp9XoMDw8rLCMiIiIiIiIiIiIiIiIinwv3HZgBwDg42SJgbwZQtoIxhpdffplz587xD//hPwTg5Zdf5ujRo5uuLgPgGkOlUuU/+hvfoZDPA3Dl8kV++sO/5Gu/8Qwz2ycp5LKsrtd568QFXlt2CavbIXtjToNxHPAerB2UgY3AhoFspcC2SpYdGUvSD1loJvSiT6j5EqeEjS5ziWUMBz+JqK+t8+8v9mhbwPXIuxYTRyyFhmytTzPKkZSyjA4X+fJQne+uJnRSg+duBDrub80Gz9n4bXQkz/ZqwKBN6YUhC32fHTODvDTgErQ7/PJcg7PRA52Sj0hbIaudiGtpnh2ZPC9MZzkedmg6WSaGCzyZB5+Ia42IWieF3P2N62YyjAxV+eZMFq9e59h8mzNpSjdKSQEn51PJegy50EwMrrHUGn1W2xH9CZ/8YJkXBmqsRdAdyDE7kWebsZhej4V2Qq2fkkks3cRgXZfhgkc562AaCbgOXi5DNeNQIGKt0eInJ1b5aRvGs1X2jOQ5dNtx3AglGcfBy/oMepAxEOfz7Bwv85uTPuG1NX4012dutcv7C32+fiDL3n1D2MDDtOpcWGrxVofbWi0ZilmPPRMFSq4hXOowX+9z9d79n+QLoFwus2fPHpaXlxkfHyefz+N5t/43MDg4yEsvvUStVmNtbQ3f93Ech9XVVRqNBvv27btjexERERERERERERERERGRx9UDP/k0n1J1gR07dvCVr3yF119/nQsXLvDNb36TI0eO4LoP1FDoTsbgOC7l6iCFQhEDrNXW8f0MlVKRkcEKxcJGkCafz2E8sEEek918SAcM5UqR556Z5b/ZmWLyBXaP5hhKIlprdd5cS6lFlqmP2dvGEb1mkx9f7TO5I2BqqMwLT/gMTEU0U/B9l6hW5+TlNf7tYkq8VOP9tRzT5RwTo4P87pcDnmgm9DHQaXF+vsG/XbhHbRHjMz4ywLe/4nEkNJSHSuwd9LDdLgvzLc7lyry6a5Dnx32cWoOBToe5OfNJhXLuyfbbnF3u8NZSkZmxLE88uZ3/bDKk7mQYHcgzaVJ6KzWOrYZc6lry9zWqQ7mUZ/eBMb6x3SPX88jZlLWLCWtrXZbjHOVciaP7HYpDgyxHKeG1Zf50pc2Z5QLvTQ5wtFTm6y/MsLOVYvNZtg8FZOKYuUs1TjciluOUSr/P+bWUF0cdts2M8jeKFY60IsI05KcnEmyU0rEZhiolXjkyTrVpKY5lmck7mNsuRa8b0+on9NyAfGWAv/WlEN5psFws8/T+Uf7KuCGZgEZ7mdfrXS4ttDizJ8e+nI9vUq7Uunyw0GYlva0Sj3EpZjPsHvYIHFhZ77HcCumqvIwAxWKRvXv38qtf/YpLly7hOA4TExOY6z3CPM+jWCySyWRu/rx48SJLS0sUCgW2b9+uwIyIiIiIiIiIiIiIiIiIfC782jz5LBQKHD58mN/7vd/jypUrfP3rX2dq6uNiJQ8mTTfaCMFGVY9PK/SzweBnfEbHqvzmqEPgGdIoYn6hzltnarzfSmgmn7C7Tel3O7xxcpnRtMoL4zm2j1R4dRzidONgrl3ps77sQJoQN5u8fm6NHFVeGssyNTXI9PU2UJ0Vi9dq4y/EnxxuMQ65XJZdO3xmXZfAsfS7XU7Mr/PamRZzUQU38BjIZ3B7Hnn3E7tK3Z804upinZ+e8hihzIFqiaer4GEJo5hrCw2OnV3jzZWQ5dhjx30O6xhDJuMzWPDJG5eCZ7BhxPpSjR9eDrATOaaHynx50NLpRyzbOj+71uX01Rp/kXNxd+SZHavy8oTBsQm9Xp+TFxv85GSDU82YtrXQ7PLWmRpPeiX2loscKhY5EIesNxtcPrnM6fkmhcDh2YGAQ3tG2RamGM8j6ybUGzFLvZTEQr/R5sy1HG8NeTxVDnhyKsePTrVoug65rM9wwSGOHALHkHR7LKy2eH15gJkxDy/scmG5w7HliPCOa+mRz2TYXjJ4JmGlGVHrJp/Y2kq+ODKZDMPDw8zOzjI/P8/FixcJw5ChoSHy+Tyu62603HMcPM/j4sWLLCwskMlkmJqaeqiKXyIiIiIiIiIiIiIiIiIiv04eSWAmsYZeFLO+vn7H+7lcjm9+85s3X3c6HTqdzkf2b7baRPYekQ1jwBhSYHFxnlx2oxfO6soycZxwbXWdIBuQy2ap1RusNzukTmljv4di6fcj5q81WTAePpZ2s80HV+v84GyLhQhik9Jo9jg738CxIRc6Kd0biR4sSRwxd/EafxL2ma+VODKSZSLn4GPp9iIWrnU437ZYLKQhH5xbptvuc226zJHhgOGMwSQJ9VqX080U0pT1WosPsh4r7R6XOyl3FByxCe1un1NzfeKci0kiVlabvHO5zg8v92j6LseuZslFPkGjwRsrCf0kZrnW5oP5hHK9y9WeJQG6rS6Xlpu80+yzWk8IU4uNQpZqHd6dC7HtPquxJcLSrDV5J4pp9kJe3V5gR9EhZxMajS5n5tf53vkW831LH4duL+TSQoN3MinnGzH1GEgS+q0O7y8YBpIul1sRq92U1qU1fuEFZOp1jq/0WY0jOuvr/P/s3Xl0VOeZ7/vv3rVrrlJJKs3zhJAQ84yZDAaDDfEQ24md0UkncYae0mfdzrnd556Tvjcnfc7qlU663SfndDqxncFtbGNjRhsMxsxinhEgCaERzWOVatrD/QOsgC0IGIiHfj5radmr9O53P7Xft8Qf9VvPu/GEjUjIz4RUByna5SOyWvsNhhI6lwb62RFNMBhOYXami0yngqIn6OoNcbKpn+0tMQYNCwsIhYc5fbaddUqC6RlOct0qNiNBb3+E7sQw5+p66BzWGczzUOzTcNnAMmJEYgm6+8LUdiWIGmDEQ5xsVFAw6c92kBaN0BLRaQkP42rsY5+hEe8YpDaUYNDQUQZC7DrXz5i4A2+0n/1tYWpC72sdo4Cu6/R0D3FCTXCyJ05HVNrLiN+z2+1UVlZimiZtbW3U19czODiI3+/H5XJhmibRaJRIJEJrayvJyckUFBSQlZX1UZcuhBBCCCGEEEIIIYQQQgghhBB3jPLTV7dav268uQNv7pQ56SYLM3QCNv1DXR+zVNqidv69wUboelNYJvahdgKNh0gMh7Csyz02lCu/M7FQNQ0UBcuy0NEYLp4FgSywu26xIhVsPj6/rJCHyzyk9vTxzu46/neLeeNuMh8l1YYtmMUPFmWwJMeis7Gb5za1sDMOkq8Q4tPlv8wNMq84gNPpvOb1zs5O6urqqK2tpauri2AwSCKRIBaLkZOTw/jx48nPz8fj+eC/EWtPdvDS8S46Yh88Ni9Js/jTshDTx40hJSVl1Jr6+vpobGxkzpw5H6hLCCGEEEIIIYQQQgghhBBCCCHuto+kw8yxXpXaQTuq8uFub1kKugXDNwqjKCq6N52+sgVYeuKqi0FBwVIsUBSUyy8BKrh8YLN/qJqEEOKTJjU1lcmTJzNu3DgMwyASiWCz2XA6nWiahtPpxG6Xv4lCCCGEEEIIIYQQQgghhBBCiE+fjyQwEzEgYihc6fdy11g2O4YrAJYFI4cQKdf85xqK+qHu43epfHduFhNyXOTYFJwBH3NmlhIcD/rHtVuLoqA4XIwL2vGqkJ0R5MmlbhaZYH7UtYm76reH2jjbGf6oyxB/RAk9ga7rH+jkomkamqaNdJBJJBIoioKmfST/NAghhBBCCCGEEEIIIYQQQgghxB/Np/9bUUW5/HMXWZbFYCTCsfo4x+7qne6w4Ti7+wc/6irEH1nC+LimuMTdcqAtSlgfIMkduWNznumKMmzc3b+tQgghhBBCCCGEEEIIIYQQQghxt2gBl8aU3KSPuo5PvOrGgY+6BCFuSpJ85v/D6TfhRLeBTxu+Y3NGTZWyzORRf+dWDezqnbuXEEIIIYQQQgghhBBCCCGEEELcadqkHD9fm1r1UdchhBDiUyIWi7FvX+9HXYYQQgghhBBCCCGEEEIIIYQQQlyX+lEXIIQQQgghhBBCCCGEEEIIIYQQQgghxB+T9lEXID69TD1KqGE/hy7a8eUWMrYyl4Ay6kiwwlzc/y5net2oORO5f3LGpyPNZcQxOw6zbU8niewyKqZVUeL+qIsSQgghhBBCCCGEEEIIIYQQQggh/mOTwIy4LUZ0kFBomP6Yi8ysJBw29UrQxcKMh+k5uo6Ne9PInbeE7IrrBWYssAa4UP0m25oycM3KZ8mHDsxYWGaccE8ng5Yfj9dHsvfDbXNLjxAJhejtN/DlpuPVbNhHrf8GcxgxjOa9bNtwgcRk8E0YR4n7FicZbd7hdppqz3Kmpp6mnjAx046/bDZTx5cxId//8Q4bWTHiwx2cens79dpYiirLmVSaiuNmL9ejRJv2seNIL3pGOWMnjafMb5IIddEdtuHw+EgOuD/UH7cb7WcjPkT74bfY35JEclklkyYVEvxYP2ghhBBCCCGEEEIIIYQQQgghhBDX8x8gMGOBGSfU20VPTy99g8MMx3RMVGxONx5fCinBIJnpfhyKSaitlraOHrpCBhaAomLTHDjdPvwpqQTT0khx21DfyzxYJqYeYai7g66eAQbCEaIJE0vVcLi8+FMzSQ8mk+J3YHtfLb2DYSIxA1OxYXd68ASCBINBMlPd2N7/Low4w21nqe80UVOyyM7LJOj4YPDCMuJE2s9R326gpGSRnZdF8GaTCLfMJHTpHDVnajk0VM6jD00kw+MYCWtYeoyB+oMcO1FKpHQmMet681hgRei5WEfDxThJY+PvvcqtR0sSJCLtnN+xkRrXDMaMq2BGif9DzAPmQDMtp2t45wRM/eL9VATctxyYwdSx+hqor7uImdVP2PgQhVzDAhL0nN/Fu2vfYt2OGtrCCXRcZN6bhCeYw/h8/+3e5C6LEQ/VU/2bn7HW8zmWPplKZUkqo2znUVl6hMj5jbz63Dmikx7jicJxlLiG6Tr5Ntub08keW8XsKfkf4o/bjfaziRHtp+mdf+OFXUWUPvQU2eMlMCOEEEIIIYQQQgghhBBCCCGEEJ9Un/LAjAVmAj3UzKm3X2Xjpm1sPXiW+vZBIrgIZBZTOnkJSz7zEE8/NZMcW4ya13/Mz3+zgVdPhDFVG6rmxJucSU7pRKYsuJ8HP/sIyypS8DlUVMXC0sMMd52jevVvWbNlH/tON9LaF0O3J5NeVMmUZV/iyUfuZfm0HDzWe7W8cqWWc9S3DxBVfKTmjaFy3kM8+NDDPL18DD7l6rCIhR7uoe7FP+MvX4zhXvINvvlXT/NIvva+IIiBHm6n9qX/xF89P4Bz2Tf55v/1JzyaffsdTUZn0HH8bTa/tJ5fJb7B7PsqSXU7bj1UcieZYaL9J9n0s//OO2N/wGc9eUwr8X8ggPSHWcSbD3Fs7cv88PUMfvjAfPKS3CTdhZJvjQlmJwdW/5b1u4foLHmMv/jSXArdcZSkEnKzkj/e3WUAsKFqSaQXlVDkziQ94EK7hT2jqDbsgRzyiuLEs1NJcVkkIn2cXf33/J+zi5nzRAoTJ+fjveV9eKP9rKDYnPiziiksziMnzY/74/+ghRBCCCGEEEIIIYQQQgghhBBCXMenOzBjhBjuOsHaH/+Q5/d00RcYw9gVz/DZwhRceoih3ku0RnyYkfiVL8UtYqEhou4Syu9fyNc/P41UK05s8BINxw9w7O1/5YfvHuHSP/wdj1YFyXd003xkC6//9Kc8dyROUuUM7vnCZynL8uLUh+htvUCbU8WImWhmiOHOE6z9+8u19AbKqHjwGR4tTsVLhIH2i3SoTmIRfZROGxammaCvu5foUDNn9u0ld+MU7n1mGgGF33d0iXYwdPFNnnvlFLVNdoqGhxkMmfAh4iLiY8pKQOIcdRf6MYPTmbPyCR6YlY5dtVBUO5r2/hDVx5DixpU8jmV//TPmqX7cPi/OW7nc7sM76at8rygBTi/eJBVCd63aK1Q0d5Axn/0hf/OgHbvXR0ACM0IIIYQQQgghhBBCCCGEEEII8Yn1sQjMtLa20tvbSzweH/X3iqLg8XjIy8vD5/Pd5Kwmwx31nNv0K17Y2oI+43E+s/Relk4qIDPgQjPjxCNDDEbtaL50khVQsTBNE9ORSmrRZBYsWUKmYmBFQ/RNyqFg03p+8cJO3tpZz8xMJ77QPg5uep1VR3SyPvMdHl80mWmlGaR67WhmnOHBXgaVDDIyk0l01HN+4y95YVsrxozHeHjJvSyZmE9mshs7CWKhfgYNL65AFnbefxSRgWkO09s7jOVxkLh0loY929j2wCRW5Gm4bQA6ofYGTr/1BruGHOhWDCUaYSh01TlIiW6aTh7k4J5q9p9tpSdmx589lqpZc5k9YyLjM52X76u3cq66mup3D3G6s5f+UIwEDtzBQkomzmT+koVMybDjuJLDsUIt9J78Jf/1u1sJODUcWVOZeM8Svr4kiAVYQ2c5uO5fdyd1/QAAIABJREFU+R+1qyGcQPFmUDRpEfPnTmba2PRROoFYJIa7qV37U149l0Pe7AUsv38COVcCCrGz69iw9TwnokXc/83HmO5XcH4gvGDSU/07ftO0k+rnPWiuZPLu/x5fWlDI2GCcvuYajm5/h10nL9IeVtCS8ykaP4N7Fs1nWo4L53sZI6ufcNcZXvhP3+ZtrxOPI5+SqfN5/DtLqVCaOfzqBvYcquF8X5Q4LnyZZUy+dxlzp5QxNv1WYiAWWMNcOr6TA9WHOFDTQntYwZ1Wwrg5i5k7bSxVeX40LEgMERqO0HribeoH22hbY0dBo/SB77J8/hRm51/9sY7QfqqaY3t3setsBz2Dw8RMDWdSFrnlk5gydyELxwXx2lVUo4+ui6fZv3E7hxrb6RiIEMNN2phpzHr4yzxYpmEfPM+pQ/vZt/8k51r7CSk+MsfMYva8WcyaXEzGyPFfUXovnOD0gT3sOHSe5r44liuF3En3Mnv+bBbk9nPopWfZ5VjE1DlzeHCyj8RgHbte2cyRC60094UYTiiormTSCquYee+9TK/IpyCggR7FatzM6tUtJEpnMX/FPMa990lp2c6mX9Zz8Z00XHY3WvmjfOuJmUzN6Kfl+F5eW1fNxd5hojjxpJdQPmU29y6dS2WyDbt64/38jQfy6dv1K146lUn29Lk8sKSKTOUm183SQW/kwPp3OHjsHPU9AwwMJzAUF4GcCibMmc+cWROpSrPfwp4RQgghhBBCCCGEEEIIIYQQQgjxYX0sAjOGYdDU1MSFCxc+EJpRVRW/38+0adOwLOs6M4zCGqS35TR7NuzgpDqTLy1dwSMPTGVi0HG9C37/vzYHDk+AtPR00tXL/Vmy0yOE206SbeyirqGLoaE2Lp4+RHX1BZrS7+W/PPEwK8ZnkusbpZuL1U/LwdPs3riLk+pMvrxkJY88MJUJwZv8ctzSMY0h+gZ0tNwplA0mSOo6zLrtdcx+opRsrx1brIP2+hO8/XYttilzKDIO49UjhEIJwAZWiMb9m3hr007ePdnBsNONy2bR19FCa8slmjpCKI8vZKxfxa5f4sKR7WxZu5dzgVKKUi+HKTqaL3KhrpELA25SvjyDwqT3UioKKAqKqqCqCqqioChXHSilhwkPDdDbZ8cVjxK9VEt9fTtdoSimZyn3FoyyDU0duo6xd/MJgkoGY2aPJydZAQy6z+xkz7vnOOSyM1+5ZuWudaUORblcl6IoKEToPHeA6rc28eo7tYRcXuw2MDsv0dZ4kfMtQxhfXs7ELA8jO0UBFPXK+1Mvvz8AK054cJChoTCRWIJEvI+u+lM0dOpEjJUElo4j6+YWGDMRpv/MBta/8jZ7znfTazrw2GGgs5Gm5nbaux9keNk8ZueAYhmYlgWKiqraUBUVUFFGay1jDdN5/gB731zH661BKvL92G0w0H2Jtou1nDrfRugrn+fe8jSyHL10NRxgy7+vYr+zjLRUF0luk0g4zHBCxww3ceit19i8+yynugw8XhUj2sHRrS1c6g0xyGd4YmYmdkyGanez+83NvLmrhotxF16Xhj2i0zcwxEDMQI92U7tjDZvd6Tjzx/PARIX4QA27XlnFrmgQJTmZNI+F2d9FW90ZGpq76HjwAZYvGE+RPY7ZfpjdW04TnRmk+L65jHsvm/Teml9Zq8vrDxiXA3K9vWEicZ14YoCu1iYuXmyj1UrjLz4zhkzvVQs+yn42E8P0nX6brVtLGesvZd5940i/2XXLBSVxkWNbN7DlaA89yTnkJYGR6KatoY6G1j46I3bSPzuRNJVPwLFaQgghhBBCCCGEEEIIIYQQQgjxyfaxCMwEg0F8Ph/9/f00Njai6zpwOSyTnJxMRUUFWVlZuFyum59U76K7o459Rwexz1rKnKoiyq8blhmNhWVZWKZBIhYh1NVFV+cAw4oTr8+JZrVy8UIDNZdcpC16kKVjU8kYLSxzVS3VxwZxzL6fOVWFjLnZsAwACUxjkIEBE1fBPCYHesjoPsOqtW9zdlEufqcNZ0cN9ScP805TDvf8yQNYA810mFFCoQiWaYPQOfa+/gobD0UIlS/jy0/MpzIQpmXva6x/cy9bXw3jqJjEn01PJmCG6O/qoDfiJeORb/PtRQGSzE7qdq3hrc1HWfvrAPOWjSfZczlhoLgzSKp8mG/99UrKUzy4HB48Pj8e+i9nTZxZFE+7n0efmEuFJ8pAzUZ+84tNHHw3FVfRFOYXZL3v0CgFm91N4dSp5L7+Lu2tzZxrjTEv2YFihWi80EJ3wk2gooxynzLSGeRaKsnjH2DxQw/wxTkZ2BQbjkAmqWo9+3dsYu0buzgcuJ9vPLmMKdkW0dqd7Ny8gzd+/QucYyeQurCQEgDFjzt5Giv/4gcsyUsmU3Pg9PhJsalopFN2zwqCk5dhuWwoQ02cWfNP/MuW7ezJKWD87Eqy3DexvFacRKiZ46/+gtXvKqiVi3jwM/OYmWXQe3IjL/9uO+9ugHigiAmfzcVrAdhIq7yHyi99h+/NcgEKzkA6gQ/swQThvk46+3TiJSv4yrdmkOOJ03/hAAe2bWXtul/wb8mVZH55Jqm5YcJ9l2io60X7wud4fPkYJmSo2J1ePFkJ9MatrFu9lcPxYsof+Byfm5uPb+AEbz//C97a9w5vuEu4d3o6WVYvddtfZeObZzhkTWTlFx5iYXkq7sQg+PJIyfFc3hfvewZGrIfm+laY/VnuXbmQZWUQ76nn2Fsv8er211lvuvDkF1NYfv2QlC1jGvfc/wjfenwyQVVFcaWQnuLBDmSOW8jDT8/AnexBjTRzavMq1m89wCsvj+PhxYUEPI6b2s/XrlvTza+b3k9n6yWGPVWMW/k035jthnArR17/N17ft5u3zHTm3D+Be3yjdUwSQgghhBBCCCGEEEIIIYQQQghxJ30sAjNer5cZM2bgdrtZvXo1PT09mKaJ1+ulsrKSxx9/nEAggKre/LfIVrSfSH8nl8J2ssrKSPX7+EBcxkyQSJgYqGgODe29b8MtHT0eYWhwALcRZuhSHae2r2XD2t2c0gp4aOYY0p0naeofYAgfuWXFJNm16z7Mq2vJLCkhZbRabvhmLgdm+gctNFcWVbPLKbk0yLqfrmHTmUfITVJxnTrG8cMXaC17hB/NK+XMdhcd/VFCQ2FM3YZxbgPbDncxXPQIj377T3l6+uXQApMz8Zo/47nVx3h97Um+XDUbvx1AweFLJVg5i6lTvKS6FaZkJvDHe9j1i8McbYwwLfPKHDY7mieN3IIiitK8uC+3XyEx2A+A4smlsGIyc+bPpsymw/RiQqdP8qsTrZyvuUj04Sw873vLit2Be8JsKjK30trexJmaboxxmdj0JhoaugnZxpBTNoacKx2ARmPzphLMKqC4OHtkjF6zj6NHz3HarGLF9/+Wr8/1keJSYGYJBZkuek/8E2+uP8LyMckUXJ4FVfOTll9IQVEqOVffzEomb6yPbMPAMC3MRA6lzlPsOPw2XV2dNHaZXJnkxow+Ir37WfPGGcKTfsDnn/oc31mSix0TZk0l0N/Kv7xZw4F3qrnw0GNUXn5CaN5kUrKKKC7+w6kc1eXHkz+R6VOnkpvsRJ01larSPAIdP+BH67ZwekEBlTlXxtpdpI+dyfhJxUzP1QALfaiD+nde52BnGtkPrOBLX1jEeAdAKckdR2n93XkOnTjO6eg9BM0j7Nh+kgZrIrO+8Bf8zVfKcXBVQMYaJtR13UoJ5FdSPmEmsyY6wZzBvLn58Kf/lddrj/HOngt8vrzg+h1Y7H4CaTkUFheTfnW6xUohOTuJaWk6hmlhUURGtJFwWwc7dp2jIZagzLryqfwD+/nqdRvuudV1U/Gk5VNYNZOZ0y6v2yRPE729b7K29SyHmw2ml2sSmBFCCCGEEEIIIYQQQgghhBBCiLvsYxGYAXC5XFRUVPDkk0/y2muvEQ6HmTFjBgsXLiQpKemWwjLvuXyC0+XjVUaTOLmK375+jN1DZTz6g2+xJO3y6+alfew7dJLPbPpv2CwT0zCwtCRSiu/hsf/8RZ6Zn0kxpzl8pc2Fcp35P1CLxXVruTEDywgzFDLR7C7c+dMoTu/nwbLdbFi7l8VJbsLHznL8UirzvvwZypMMOjw26I0yHA6j6276a2vpHE4hkJNHeanr9+EFZxG5ebkUp53gYF0t7fHpZFyn+Y0tKYAvLYV0q4nBQYNEwrq14M/lWUBNJz3Ni98RZyAcImTCB3oHqQ7wT2PqhGwOV7dx4cQpOh5JJaPvDHVtBrZAHhWVudcNy4zOZLC5mc4eIKWYKRO9OB1XnoQ9k+S0EiaNUdnQWEfH4EyGvDeYytKxhi9QvXYNW989wMG6DnpCcTRtiMbaOKWlOgn95qqyIkPEWmupG3SRXlJEbm7alQ+mCoqfsvIicnYf58KlJurDFmPuRJhC8ZAczGbqlEIcxy7Q2h+iJ3G9rkcmuh6hoa6RwdZujv6vQ+x/+e9wXQmS6IMddA2mkXtPP90DCRID52juNbCl51I6Ju/asMytUh0o/slUjgmS1tlLd3Mz3WYBwVucRh+4QN3h7by+egsH69rpCpmYsV6GBlUSailx08K8xTkvr1vdba+blpZBcsCFrylE/6B1+bitD//EhBBCCCGEEEIIIYQQQgghhBBC3ISPTWBGVVV8Ph9jxoxhxYoVJBIJ8vLyyMzMxGa7tVgEgOLw4fQFSHXoNLdeIhSpxMB3TWcKM9RO24Vazgy4mR9n5AtzxZtDTtVUHl5aQZLNjtsbIJCaTmZeIQWl5YwJOnHGUvD6vLjNXrpa2hg28jHRRg1wvFdLilOnubWNoeEKdG6hy4ypY8ZDhGIWNrsThyeT7OxKliwdy/pX32SrK0FXh0Ff5nS+fm8eye5evC4blhUnEolgWRZ6NEbCtOGy23Fe3b5CcWK323HYLPRYDN26QXBAs2Nz2HGgo+sWpvVhv9TXcDg0NDWBpesYo4xQUEENUjm1iqJTx6k+d4z9rTOZX3+EhlAKrsoCKovdH4wVKFwJJY1emxmPoeuAzYnbpf4+v6RoaJoTt/PKGMO8QYDCIBHppnb1P/O7Dc2027MYs2AGC70W9B5gQ28djitHet0U08SKx4gaCh6HE7tdu6p6G06XE7sKph4nZsKHfuzXUNE0B16vEzURI64b6Ob1AjMWlmUSi8axksZQNXY6984sIkm56vcESCuqZJLHwt4dJaZboNlxuhy3Gf1QQPXgdtnRlBh6PE5itDE3YrZTs2s96159m809WUydPYWZSQ64dJTTR+robLWuHPF0a5Va1p1ZN8XhRNNUbKZxeW/e5LYRQgghhBBCCCGEEEIIIYQQQgjx4X1sAjPw+9DM5MmTsSwLu92O3X69L/H/AHuQ5PQiJpTa2VOzm1MXK6kqTqHId1WkxTRIJOLE4wn0q76kVny55Jbfx+e+upRMzY7b7cXrdeNy2H4fuHHmkpubQ0GghjPHdnG4tQq/y07aaGep2IMkpxcyocTO3jO7OX1xHFUlqRT7bjIIZOiYkTBhXcHmcGC3u/CmFzF24X1MXf0CR7cP0JezhMlL5nJPnhOn6sbptIEZJxqJYqo2PGlBfPZaooMDdPfo4Lmy9EYvgwOD9IVtuHPS8NvU628K5XK3HsWyRjrmqDYVm6JgxePEbxS2+cBUV9IDlvX7fMBVgQILBbCTPn4GYwvqOHXkJFurG0itPUKnu4KKwiLGpo7WskO9HH6xgaHr6MbVcRwFZyAZrwes3l7a2uMYxXbQFDBDRMK9XOq2sCcH8bmcuGwqqk1BseLE4haGyZXznxLokQ5Ob9/K8e5pVCxdwmOPzqDIp2Nc1Dm/t4Mu5ZrbcsMUhN2JLSmNoFNnqLeXwcEwJkmoWECMnq4+BmPgSE4m6AD1VluhjMogFh2ms2sAw5OF3+XAbYP4qGNVVNVOcjAZhzNIdsVsFjy+hAmeq9+kDc3hwuMBe1IqSS4FIzRIT/cABsFb7AR0NRP0Lnr7IkQsL25/El7lg9EWBQWbpqEYOrqhk7i6SUusmQunjnLkdB/c9wwrPjuesnQnxmkH/sEetrVe9U5vYT8rmhMtELz9dVOUyx8tLneikryMEEIIIYQQQgghhBBCCCGEEELcfR+rwAxcDlJ4PJ7bn0hNJS2nknn3VbLm+R3s3lFBms/GvWPSCHjsaIrF8ECY4ZjxwS+obS5c/jRy8vLIUhn9y35bNkWV45k2/iDbt2zi9c2TcM6vYGJuAK/ThmoZ6LEwYcODP8lNak4l8xeP5Y0XdrB7RyVBn8qi8jSSPA40TPTYMBFDw+b0k5Xuu+aelqFjDocZtjQ0h4ZmV1G96SSVL2LlnNf4+U6DYH4Fs+ZNJMemoODE6bChmgmGI1F0zYFvzBTKMs9wuOUch6vPMdOVg1/TibQf4ERNIxejaYyZXE66U8Nx0402FFxuNx6ngtHYSH1rN1lqjICiomp2nLfSsEPR0DQVKxEmPNBH77BOmlvDnjuFysrdlJ3ew7aNW0hqryNR9CCFJYXkjrp7NVTVR3JAQ+9vo/NSK63dHvyqSULx4ssqoyD/AEnNdVS/c5IFywvI8SsY/Wc4e/oEh9p85D08luwUP37Fjctnx5Vop6munQ4/eFwKihpDT0To649i+jLJyMmnKCuVgBrBSvHjdmhXdTJSLnfmUeIMhwbp7wsTS/bhUH+f51CcSbiyK5la6mRTwwnOnCilPrucNJdBYuAC1UfqadP9ZJaNocStoA3fwnO9wkpEife10dLehcNwY4v3cPHcafae7MZR+gj5wQCp2hADoy8ONoeHogkTyNp5gf62JmovDVNRlozHrmDpUQzViepw49ISkF7BmIIkTtRd4PT+/ZwaO41snxO7YmBiR3NYNwjQWAz3ddDd0U57tw+HFWb40k6OnB8g7CylsjSP5FH2laLaSEoOYI/20tNxiYvtPXjcCnHdhlfpJxSJElP8pBWNpSAzSKrfRsLvw++9us/Tre1nxZmEM2vcXV03IYQQQgghhBBCCCGEEEIIIYQQd8fHLjBz52gE8iuZ/sVn+Gz1/82qV/+JZ08e4vh985hTno7flmDgcC0XOsIoySrqLZ8b4yB78gLm9XZwdP9PWP0//zMtB5cxf/ZEqnL9eMwwvc1nORurYsa8WayYVcn0L3yLR/f9Date/RnPnjzAsUX3MKs8A78SY+hSHReGggRKZ/MnT0zGx1VdNAwDMxIhYjpIsavYNUBx4/SXct+Xv8algjjOyhksmBxAwQLsOJwampXAiEYY1tx4x67gvpnvUr9hBxv/LYJr+AGmpQxS//ZLbNrbRV/hMr7z0AQCbg119DYjo7CRnJZJTpoT3nyLVa+NYXhCgBSbF09qLlOmpmHeVLsMFRQf/iQXtsFGmk8dYveFKpaNTcFrz2NsVRWTj+7k1//+c36bUJh5bzmlJdmjH2mlONGc2YwpT0XduofqbW6CjqmMdUfpdExm0dSpTJ52nNNHVvPv//L3BGNPMDvPYvjkVnZsO8hB2zS++5mpFOUEcMTSCeSkkJPYzdsvriOjs4xSnw2nN4X0yYXklQSx7zjIkV0prE2JMCloobQ10x2KoysqCgqKqqImpRJw9NNQV8OR/XXckzWJXI+C9t4C25Jxp87i0ccmUf2rLbz9ygDR0GIWFRh07V/Fi1saiU78PI8smU2xyofYqxb6QBvdB17nxTXDTCsN4Og8wtEd77DmtI+x319KVV4mQWWIhlGvV9CcXvKXPMbst/4nq/e+zvP9A4QemcPYoIbR10LYV07mmFncV+lG8Uxjwb0TOXFxKxte+Sd+lHiCz0zJIUUZImbPISW3gJnZo3VSsQCdlgNvsd0bxd6VR4bSSc3651lzQiVn5QQW3FOCnTD6++vTnOSVjyFl3RFO79nCK0GLpfkaXf3JTLnHgzcYJEk/zYENv2Vz+kIqM73YLjRysSuMoipXPmvqre1nWzLu1Jl3cd2EEEIIIYQQQgghhBBCCCGEEELcLZ/iwAxgT8FfsJjv/ORZxmzYxPa9xzjw4j7eDMUwVAcupwNXoJyqSRUUeRVst/qFtiufsrlP8tc/L2D8axvYeXw3b/3rel6OGJiaG39qNoUz8qgyIKalklS4lO/8NIkx6zexfe9xDq2qZvNQDF1x4k3JJKdqMQuLLCImeNWrAzM6VmSYiGUnzWFDu7Jqqt2Db8JnearUQnG68VyVIHE6nditMHokQthSSVOymP3Vv8TK3MD6De+y/h+28WLcjiethKqlX+MLKx/koQIb7ls8O8czZjZTH+zjW/W/Yu3qv+cfXnbgyZ7FnAcfI39K2k0e0aSCksKkJQ8yv2MNr5zYwc9fncasv5qNJ+AkqXwSY2fdwz2rn2e3dzmTxuVQnnO9rWvD4c1g5lf/koeHXmZT9cv87z2voiXnUbj8+5SVzWDykqf4si8N77+/wbsv/JC3hxVUXzZFkx7lL3/wJJ+bmEqWR0FxVVE+6yG+9+VG/s/bL/CrQyY2XzHjFqzkqXHTWfD1v+GL2mre2vMqP9/9G2KGgt0OOllMywwS9AB2N7bKz/DgfXUMvnWG4xvX8+49E3k8TxlZR1CxuVMpfuLv+L59FRu27GHPL3axIQrOQC7ly77HypX3sWx6Mup1Dk36QxTVxDR7qN3wv9jbN0zY8hAonMiiP3+cP/l8BeOyXCjGDSawuVDTFvHF78dJ3/gWG7dv5Tc/eo1hXcXhz2DMoqdYmTYRCw8KTgqWf5uvuAvJXP8Wb67/R378YhzTmUTG9EdZ/ujDTMu+bqU4rC4aql/nhW3ddEVtuFOLmfKlp3hkxb0sztP44KZSUF0+Uhd9k6dq/pXXtuxl00+2s8GRSnDsY/xZ+cNMW/ooX9BNhl/fwC//n5eJmjYULFRHFrlj8gg6bNhRbnE/q2ie4F1dNyGEEEIIIYQQQgghhBBCCCGEEHeHcvjwYWvq1KkfdR13j2WCPkRH00VaWttp7xkkFNMxsaE53Xi8qaRl51EytoCg3aD79B7Od0EipYxZk3JxK1cFV0ZjJtCjfbRduEBzezc9A8NEEiamouH0JJGcWURRYTZ5mX4clgn6IB1NjbS0tNPe+/ta7G4fScFccvLyKStMxXn1feMDRLpq2bW/HW/lNEoKs8j23Kgqk77z1Zy7lGDYV8yMqQX4FFCMEL1tTTQ3NNLYOUjEsOHwp5FVUEJhYQ45/isJDr2DxtO1XGw3cI6by9QcDYcNrHgXXc0NHD/ejX/avVRkuUl2xBnubaflbA217QOEdRWbJ4PMwhLGVaRh1e7m2CU/SflFVJRn4Vcu19dzdi/nO0yigdKR52wMNNJY30B9l4EeHMfCiRl4HDYUvY2z21fzi//8P9gy7r/zd3/1AMsmZ+G73iOwDKxIB/Vna7nY0kVvxASHj6SCCUwek0GGzyTS10FLbS0N7f0MxUF1JZOanU9hWSkFAQ1NVQCTeKiH3os1nGropH/YwLQnkZpdSNn4seRpvbTW19LY3EnXYIS4qaBqdhzOABnFZRSVFJLrBawwHefPcKGxjyFHOkXTplDiu6rDzOWiwYoz0FpPU2MLTR0DhBKgeVLJLBpDcX4GWckubJYBehun9p6hx5ZNcEwV4zNvkHKy2tn33D/wmxe3sSX76/z44SzsCuiKE09qNtmFZVQUJuPWVFSjn57WBk4daoLxixmf5yP4vn1mDHfS0dzExaZLdPSHiRkKNoeX5NxSCotLGJPhvLJv44S727jUeJELLd0MRHRMmxNPRhH5RUWMyzRo3L+bBq2M3MJCxmUO0N+wlr9a9v/SMvd7zJo3kZnpcYZ1G05/Orml5RTlBkn32VGMOGb3KfadGMAIFlAyrpQ8lwVGiPbaGhoaL9E2ECWBE3dqCVWTisnyxom0N3K+tpnOgQgxA7Bp2F0B/Ml5VM0oI91lx0HsFvfz7a+bFWmmvqaBph6NlEmzqUpTcajvX8hPllgsxr59+ygsLCQlJWXUMX19fTQ2NjJnzhycTucfuUIhhBBCCCGEEEIIIYQQQgghxH90n/7AjPgEsrDMBOH+ARKWTqjjDEff2cJLLx8j+N1/5JnFZYzPdN44yCQuuxKY+e2rB9g14f9j09/OITfZyccuj5Fooa9hLX+17Ef0PfEvPPmllTw5UUIUn1QSmBFCCCGEEEIIIYQQQgghhBBCfNx9uo9kEp9QOnqshwvV73KhP0xrwynOn++ku+Rhvja3gLyghGWEEEIIIYQQQgghhBBCCCGEEEII8eFJYEZ8/FhRYoPn2fvcj/jVoT46fOOYev9jfPvbX2N+jhO37NpboKBqDhwuN26HDeXjmjRSVFA1nG4PToftypFYQgghhBBCCCGEEEIIIYQQQgghxN0h0QPx8aN48QRn8PmfrWNZxEBXnbh8SSSnOHHaJEhxS5QgEx/5PkWLoww708j0Oz5+xzEB2DJIKvgc/239fRj+TJIC9o+6IiGEEEIIIYQQQgghhBBCCCGEEJ9iEpi5Dbq+Gd3Ycsfm02z3o2nL7th8n1wqquYhJa+UlI+6lE88DXcgA3fgo67jD1A0bI4UsktlxYUQQgghhBBCCCGEEEIIIYQQQtx9Epi5DaZ5nkR8/R2bT3UWARKYEUIIIYQQQgghhBBCCCGEEEIIIYS4myQwcztMBcW4gwfcmHLckBBCCCGEEEIIIYQQQgghhBBCCCHE3SaBmdugmBaqbt3R+YQQQgghhBBCCCGEEEIIIYQQQgghxN0lgZnbYYJi3Nn5hBBCCCGEEEIIIYQQQgghhBBCCCHE3SWBmdugmKDc0Q4zH/7a7u5u9u/fz/r165k4cSIrV66koKBg1LHnz5/nd7/7HU1NTei6PvK6z+fj6aefpqqqCrfbTUtLCzt27ODMmTP09fWhaRq5ublMmzaNhQsX4na7R65NJBLU1taybds2zp07RyKRIDc3l+XLl1NZWYnf779u7fF4nKNHj7Jnzx5XC0tBAAAgAElEQVQaGhpIJBJkZGQwe/ZsZs6cSVpaGgC6rlNfX89LL71EXV3dNXPk5OSwYsUKFi5cOPLaxYsX2bNnD4cOHWJgYIC0tDQWL17M1KlTycjIuKb2o0ePsmPHDs6fPw9ARUUFCxYsYPLkydjt9pGxtbW17Nmzh4MHDzI8PExaWhpz5sxh7ty5ZGZmjoyLRCLU19ezbds26uvrSSQSpKWlMWnSJBYvXkxycjKqegeP8xJCCCGEEEIIIYQQQgghhBBCCCHETZPAzO2wQNH/8LBbme/D6O/vZ9euXbz00kvs3r2bUCjE3LlzrxuY6ejoYPPmzZimSV5eHj6fDwBFUVAU5Zp5Dx8+TF9fH7quE4vFuHjxIidPniQpKYkJEybg9/uJx+O0trbywgsvUFNTg2VZaJrGhQsXaG1t5atf/SpTpky5JmDznnA4zPnz53n++ecZHBzEZrOhKAo1NTWcPXsWXdeZO3cuwWAQwzBobW1l69atDA8PU1VVNTKPqqojtZumSX9/P2vXrmX37t0MDQ3h9/tpbGykvb2dUCjEsmXLRkI8hw8fZs2aNRw5coSkpCQsy2Lz5s10d3djWRYzZ84EoK6ujo0bN7Jr1y4URcHlcnHu3Dk6Ojro6enhqaeewuv1oigKJ0+eZOPGjRw9epTU1FRUVeXMmTM0NDTQ19fHF77wBbxe74dbcCGEEEIIIYQQQgghhBBCCCGEEELcFgnM3AblDh/JdKsdZizLQtd1Dh8+zDvvvENtbS3JycnXhF5GYxgGuq6zdOlSli9fTl5eHgA2m4309HTcbjeqquL3+ykrK6O4uJhgMEhPTw9bt25l1apVjB8/nuzsbPx+P/39/ezbt49Vq1axaNEili9fTlJSEtu3b+fFF1+ksLCQzMxMSktLP1BLT08P27dv58033+SrX/0qS5cuxel0cuTIEX784x+Tk5NDbm4uwWAQ0zQJh8NomsbSpUv55je/OTKPw+EgOTkZuNwx5tixY6xZswan08mjjz7K+PHj2bVrF6tWrcLhcFBaWsrkyZOJx+OsW7eO3bt3U1xczNNPP41lWbzwwgvs2rULTdNGuszs2rWLt99+G0VR+O53v0tubi4HDhxg9erVvPLKK0yfPp2qqioURWHPnj1s3LiRqVOn8pWvfAWv18vOnTtZv349v/zlL3nooYckMCOEEEIIIYQQQgghhBBCCCGEEEJ8RCQwcxsU07rDRzLd2lymadLV1cULL7yAy+XiySef5J133kHTbrysiUSC4eFhcnNzKS0tJT8/f9RxpaWl/Pmf//k193M6nWzZsoXGxkbC4TAAra2trFu3Dq/Xyxe/+EWWLFkCwKRJk9i5cyfV1dVUVVWNGpjp6+vj+PHjFBQUsHTpUubNm4eiKBQVFbFmzRo6Oztpb28HLgeEBgcHcTgcZGdnU1paOmo4KBKJsHbtWsLhMA8//DDf/OY3UVWVWbNmUVtbS319Pbt27WLChAm0t7ezf/9+0tPTefrpp0dqNwyDn//851RXV9PZ2Ul2djbV1dXous7DDz/Mgw8+CMD48ePp6+vj1VdfZdOmTZSWlhKPx2lubkbTNJ566ilmzJiB0+nE4/HQ3d3N888/j2HcwaSVEEIIIYQQQgghhBBCCCGEEEIIIW6J+lEX8Il2pcPMnfrhFjvMDA0N8ZOf/AS73c7SpUuZMWPGTV0Xj8fp6+sjFosxNDRENBr9g9fous758+eprq4mFAoxe/ZsgsEgAAMDA5w7d47x48cTDAZRVRVVVfF4PEyePJne3t6R0Mv7uVwu0tLSaG5uprGxkcHBQeLxOD09PbS0tJCRkUFmZibw+6OWFEUhGo3S3d09avAkkUhw8uRJMjMzyc/PHzmuSdM0ysvLUVWV+vp6EokEp06dYnBwkPz8fCorK0fmqKysJD8/n4GBAU6fPk0ikSASiaAoCh6PZ2Tce115UlJSaGpqwjAMPB4Pfr+fUCjEnj17iMViALS3t9PW1kZWVhY2m+2m1koIIYQQQgghhBBCCCGEEEIIIYQQd550mLkdpoKi3/j4o1ud72Z1d3ezZ88ejh07xpNPPsk999xDc3PzH7wukUhgmiZ2u5033niDnTt3kpGRwbhx41i8eDFVVVXY7faR8ZFIhC1btvDuu+9y7tw5YrEYy5YtY+7cuaSkpAAQi8Xo7u5mzpw5uN3ukWttNhuZmZkcOnSIoaGhUevJyspixYoVHD9+nJdffpnTp0+TmppKTU0NpaWlLF68eKQzjWVZJBIJotEoa9eu5fDhwwQCASZMmMDy5cspLi7G4XBgGAYdHR1UVVWRlJQ00oVGURRSU1OBy51tTNOko6ODaDSK3+8f+R1AMBjE7/cTjUbp6OjAMAzy8vJoamri+PHjXLp0iYyMDCKRCNFolEQiwcDAwEgXnnnz5tHS0sK6desYHBwkMzOT8+fPMzQ0xHe/+118Pt9Nr7UQQgghhBBCCCGEEEIIIYQQQggh7iwJzNwOE9Dv8Hw3Qdd1GhoaWLNmDWPHjmXGjBnk5OTcVGBGURRKSkp45plniEajI91ftm3bRmNjI9/5zncoKirC5XKNXGOz2Ua6xpimydDQEI2NjWRkZOByuTAMg1gshtPpRFXVa+713u91ffQH5fF4KCgowO1209XVRV1dHQ6HgwMHDlBSUoLX6x2pxeFwMHXqVGw2G21tbfT19dHR0cEbb7xBOBxm5cqVTJw4EcuyiEajaJr2geOpnE4ncLnLznvjDMNA0zQcDsfIOIfDgaZpmKY50iFm/vz5dHZ2cvr0aZ599llSU1PRdZ3Dhw/T19dHXl4eiqKMdJ1JS0ujvb2dlpYW2traOHfuHB6Ph7S0tGuekxBCCCGEEEIIIYQQQgghhBBCCCH+uCQwcxsUS8G6gx1mFOvm5hocHOTUqVNs3bqVZ555hpaWFoaGhjh9+jR9fX3YbDZOnz5Neno6OTk511yraRpVVVVUVVUB0Nvby/79+3nllVdYtWoVkydPJjk5maysLOBywGT+/PlUVlbS2NjIzp07ee211/j1r39NRkYGqampqKqK3W5H13Usy7rmfrquY7PZrnsE0eDgIDU1NQwODjJnzhwqKioIh8PEYjFqamo4dOgQ+fn5lJeX43Q6WbBgAQsWLMAwDHp6ejh48CA//elPeeONNwgGg1RVVaEoCg6HA9M0MU3zA/W8dzzTe+PeCwK9V+t740zTRFXVkSDNvHnzSCQSrF+/nj179pBIJLDb7bS0tACQnZ2NqqpEo1EaGhpob29n5syZrFy5kq6uLgzDoLm5mc2bNzN//vxruvEIIYQQQgghhBBCCCGEEEIIIYQQ4o9HAjO3wwTFuJNHMt3csJaWFmpqaujv7+cf//EfR44c0nWdaDSKqqo0NDQwPDzMN77xjRvOlZqayvLly7Esi82bN1NdXc3MmTNHAjOqqhIIBAgEApSWlpKXl0c4HOa5557jySefZNKkSTgcDlJSUujr6xvpxgJgGAbd3d24XC48Hs+o929oaOC5557D7/fz1FNPMXPmTEzT5POf/zzf+MY3ePPNN8nJyaG8vPya62w2GxkZGSxcuJCWlhb++Z//mYaGBiKRCKqqEgwGiUajhMPha64bGBgAIBAIjIxzOp2Ew2EGBwdJT08fGRcOh3E4HCOhIK/Xy0MPPcSKFSuIRqP09fURCoV49tln2bNnDxMmTMBut3Pp0iW2bNnCxYsXefbZZ6msrMRut3P//ffz29/+ll//+tf87d/+7ciRVkIIIYQQQgghhBBCCCGEEEIIIYT445LAzO0wgY8gMFNUVMTXvvY1Fi1aNBKWATh79iy/+93vSE1N5amnnuK+++67qfne6wqjadoHjlV6v6u7s1iWhWVZBAIBysvLOXXqFL29vZimiaIoRCIRjh8/Tmpq6kgA5/1CoRCNjY1MmzZtpOOKqqp4PB7GjRvHgQMHGBoaumE9qqpis9mw2+0jP1VVVRw/fpzm5uaRTjG6rnP+/HkMw6CkpGRkXFJSEs3NzdTU1IwEZs6ePUtzczOBQICqqirsdvvIPW02G263G5vNxurVqzl27BhFRUXcd999uFwu2tra6Onpwe12k5eXN9K1Jicnh7KysptaEyGEEEIIIYQQQgghhBBCCCGEEELcPRKYuR2WgnIHj2TiJo9k8nq9FBcXk5ube83rdrud5ORkMjIyqKioGDWk0tTURFNTE5ZlkZKSQjwep7a2lrfeegvDMJg0aRLJycmEQiGam5upr68nNzcXTdMYGBjg4MGDbN++/f9n7816bcuOcsEvxhhzrr33OT7Z22kn13ZhY1/XBctYljsVbnQRtlMGmeYB1UOJl3q4PPMTEA881gsPxVtBSbgkrAIkSlxK2GAEwmWaCzcLU8ZpfN3QpLM5zd5rzTlGRD1ExBhjrr3W6fLY6WZGaufZe63ZjH5EfPGNCLz5zW/GI488ghACXvva1+IjH/kIfuVXfgWf+tSnsN1ucfXqVXz2s5/Fs88+i1/4hV/A2972NpRS8C//8i/45V/+Zfzoj/4oPvzhD+Pq1at4/etfj7/5m7/BZz/7WTAzxnHEF7/4RXzuc5/DtWvX8MQTT4CZcf36dXzmM5/BY489hmvXrmG73eJLX/oSfvu3fxsnJyd46qmnMAwDTk5O8PTTT+OZZ57BH/3RH+GJJ57AW97yFnzuc5/DX/3VX+Gtb30r3ve+9yHGiB/4gR/AO97xDnz+85/Hb/3Wb2Gz2UBE8MlPfhLPPfcc3v3ud+O1r30tYozYbrd4/vnn8c///M/4xje+gb/4i7/Apz/9abzuda/Dz/7sz+KJJ55ACAGvec1r8Pjjj+MLX/gCfvM3fxMf/OAHcXJygmeeeQZ/8id/gs1msyA6rbLKKqusssoqq6yyyiqrrLLKKqusssoqq6yyyiqrrLLKKqusssoq315ZCTMvR5gecISZu3tWjBExRpycnCw+Pzs7q5FWzs7OMI7jpXufe+45/Pmf/zn+8R//ETFGzPOM559/Hufn5/j4xz+O97znPXj44Ydx48YNfPGLX8Tv/u7vYhgGiAh2ux1eeuklPProo/jYxz6GN77xjSAiPProo/jABz6Az33uc3j22WfxG7/xG9hsNvjGN76B9773vfjgBz+I17/+9Sil4Jvf/CY+9alPIcaId77znXjd616HT3ziE/jkJz+JP/7jP8YzzzyDlBKuX7+OlBI+/OEP44d/+IeRc8bzzz+PT3/60zXt1DRNuH79OqZpwkc/+lG8613vQggB4zjiPe95D378x38cn//85/HJT34STzzxBL7yla/gqaeewoc//GG87W1vAxHh7OwMTz/9NHa7Hb7whS/g13/91yEi+PKXv4wf+ZEfwcc+9rEa+ebrX/86PvOZz+Av//Ivsdvt8Nxzz+Gtb30rPvShD+FDH/pQjULz5JNP4sd+7Mfw/PPP4w/+4A/wD//wDxjHEf/2b/+G69ev46d+6qfqM1dZZZVVVllllVVWWWWVVVZZZZVVVllllVVWWWWVVVZZZZVVVllllW+/rISZlyOvUEqmY/LQQw/h7W9/Ox5//HFcvXr14DUnJyc4OTnB9evX8dxzz4GI8OpXvxrve9/78NGPfhQ/9EM/hGEYcH5+jnEckVLCV77yFex2O5yenuKNb3wj3v/+9+MnfuIn8NBDD9VnvulNb8Iv/uIv4nd+53fwt3/7t7h58ybe/OY34+d+7ufwjne8A1evXsXNmzfx4osvQkTw+OOP46GHHsKTTz6JT3ziE0gp4U//9E/x7LPP1u9/+qd/Gk8//TTe+MY3IucMAHj44Yfx93//93jhhRdARHjiiSfwMz/zM/jIRz6CN7zhDQCUUPTkk0/i53/+5/H444/js5/9LL785S/jNa95DT7+8Y/j/e9/Px555JHaJh/84AcxDAN+//d/H3/3d38HAHjXu96Fp59+Gu9973vrdTdv3sTXvvY1fPWrX8VrXvOaSpR505vehCtXrtTrrl69iv/4H/8jrl27ht/7vd/Dl770pVqnD3zgA3j66aeP9s8qq6yyyiqrrLLKKqusssoqq6yyyiqrrLLKKqusssoqq6yyyiqrrPKtF/r85z8v73znO1/pcnxXinzx14Av/tqDe+Cb/xPozf/pwT3vO0z+9V//FX/4h3+IX/qlX8Kv/uqv4hOf+MRKHFllle9B2e12+LM/+zO84Q1vWJDTennhhRfwT//0T3jf+96HzWbzbS7hKqusssoqq6yyyiqrrLLKKqusssoqq6yyyiqrrLLKKqus8v0ua4SZlyNMQAkP9nnfw3Ljxg08++yzePe7340f/MEfxNnZ2StdpFVWWWWVVVZZZZVVVllllVVWWWWVVVZZZZVVVllllVVWWWWVVVZZ5ftQVsLMyxEhSH5wJBeS723CzKtf/Wr85E/+JD7wgQ/grW99K0J4gGSjVVZZZZUHIP/7p/4MX/jHf4aIgIUBAQQCEQFErxEICAQKhEC6jokIQggQCEopmOcZ8zzj/NY5WBjDMGAcBpyenSLGCAoEgt5LRPCHt3cJBPqvf+7X+k5RiyReei1TihFEQb9nATMDRPq9Xqa/UUAMEUQEEUEp7K/zN4C5WPnqR1ZGe+S+kP1YG4EA2N6m1RKtg5fHHlKfVZvC2gHd8+pFYuWk1ifMkL7NCBBhCAsEXJ+V0oAYEkABzKxt01dmr2JeVpH9tmkSiEDdfkZWIRFvJ7JHkpcerRfbe7zu+i5BCIQQIghAYUYpxZ7Z2oYAHUsUQOA6Tqr4n7V6/fdUf7zMRDqmaa9z/T6xtt3/PHg7WRu2vqPahoTQ9Xtrbu9PrRfXdhMpkDLD81XarRAuEAAhRMQQEULS9hdgnhks0PFv9xCkjiEBo5QZImyNo59xzhBmcCkQAcZxg2EYECh2baXzytu1lhHcxjoIoDb2gxW67zMR6yfSuSoAuOvXEENrx0UnUH0ugWys2/gKNo9sDVjMFRvjfY+KjTNmqfOGfD7aTxs6XpdQ9TaB6Noi3jc+BoP2eR1ii44GiOpYaePvmC7oax4QQrA1TazcBSJlMa6Z2eZbAETA4muBtnOMA4BYnyvC9T0ijMIFJc8opYC5oHBGLhkiBaVkcGEApGtITIgxIqUBwzBq3amrx6X12wcN6t7CRd+pz4U9MyGEaHM/2HP1McylaxtCCDoecin1DYvWu7RgtXl3Ozm2ztW2OvQx+d7Uxme/5sWY6tg6VATx8vYvr/PnQBlk+a/fQEee73Xv26SuSyFevtrnAVDLVOdU3a99Dfb9Tboy1ZK2CqK7HV1ZuhsON70c/9Z0gK6p6x4C118Wa4/+y8y61tt89r2lf7C3TwjBxmSoZWh7m76WSwGXbGPU2iVo3bgU5DxhnicULrZnBV2nQoSIrQMUQCEghgGMYC0bbC91PcvLdvvx7uVzPUL3AlsbF/0Fq5+tbTZGxNZFsk25H2eqD/T7dECMsb13r5/6fqZjdu9edfb3X9fR7C9boglic86v97r6PW2tPTz2+/noe85xue3CcFBU97R5bAuZrn9lb0yqvqNrt+skh8u+X49WHx0/rW4HikxtvrY6lbZWC1QfYEbOM0rVC7I2DYmOoRh1jyiMeZ7BmZFCQooRzKoRAAFcy0tIISCGvlCX1w3mAmap8y6mYPNntjkrAOleR4DZEqaXdMun6tn6Dv932W7eP81e8bEcAiHGASEc0FFB3e+wuav7VAgBFNUGEoir/aabc2caaDliHGtZKAYEItXP8gxwaWvHtK39BNL9eLudkWcBc0CMAzabE6QhWfswKApiEmzPb6FME8qcQQKkYdByBm03AWHOBdM0Y0gjBtf7YkKgCKJY612K4PzmBcZxREwJIeoefHF+DoHofWlAtrVV1yjty5gChkH39Rs3ruOll15EzrO2A2eMKSGlAQLBnDPGzRnScIIQEhACiAZdUH2+g8B5tjEQIGBMuy0ErHqE7Wmq37X1CgSkFKu+qHZfwTxnnFik18KqA4dA4MLdeif2eUKsOqbYc3VNbtumVD2cECAItqb2+5HYdYwYCCGaDiVhMe9d59sfg80WobobL9ds1bG4lDbOfJzaulfXwG6OuK1X9YNaTy9/Px8u//sgRRYb+5FrXK80Hf77EVn9VrT9Kylt3Kn0OtyBi+9hD//ekjv1+9E2e7CFWNgpC13F/x8IMUbFC91OQsOI2OxzCkFtexHk7Pa1QPfY1rWB3J5x3Asg0TU4RdWdAakYFzNXPZ4I1e73dXKxvpLqITlnuy9W29Nt3hAGtZuqMeM2RdD9hQg5KzbSGoMBx9tq2/ku0GNloZbD1/ter2kYkeF3Jde9wO3O1jamyxUBF70vpgHDuLF6hK4fBOT32H3C/byjapdXewEw3KGr53ek3O/6eO/z50GvxdSNA6DNL6l4o1/YsKpq4/XlFwDiuigt9nf/SSkhBMWG3Sb2V7u+X0oBoPNZ8TvTl2NE7DEbCCiofQkBiuE8dR4Gt3Fb8VB1mt7eafq82geMQAFpiMg5Y54n5HmGcEbJGdF0yRjUB1C41HFeSsE0TWazJoQYETp/AYTq+tTPR9X5IogEzDPKvMV2d4HdbgKgOmUwTIwCmV3B3imANBu+79MFZnZJBAAvsdDF2nFsnEn3c3eyb5vsYzk9ltVefxnHbk/DYl+u19Vx3LdFt9ZZX/e+J0D3lxgjGrYcqt8hUKjXLW1m4EPvfws+/P633nU7rHJcVsLMyxHGA44w8+Ae9Z0or3rVq/D2t7+9ArWrrLLKKt9p8ld/91X8yV/8f9WhWcGoTnHaV7JdJwxBlcxSMqZ5xjxNuLi4AIsgxYRhGHByukE0YNCN5rYcds4o94ShBxeXhoN+5wB8K0+oRjfAblw6caY6whw4DE1RsyK4kcHCKGVaPBv+dgro/qoi1MpWPxO/rhnFPZCv9eJLbozqkevavX8OhAyLCLWdmiOmN6wbISBGJVeIGTA98QS0VyNXeMkIM60yC1Gl1ZVkN9oMZEbXJ9ScJVTHVXOsV1BM7DneR9YXOh7RjIdaTO8bXnx3aJeVS39IByjTXt/UN9Tvu87QR3RAntdzn9TTP6WO3m6caHdJBbzb7wzhGdX4qcaJtpGSC4xgQBECwTSrw8mHnJvNoAa8M+fqPHBwX4EcI8xASREpueOBOmNyOe7dWbA0fLXeoRKZyMam+OjVLnYjCEaYsTFB5phu87G1oI8t6tCzhYMQnZO0FkhAB8Yt27rQSGZUHZsC/ak19bWFQusHI6m1eeKOiPbufeCikXL8e3WouFPmspHbHPdE1AGAGSxt3AIOXEk1wisIZuMyxgQg9CvTpd9KKZUIpABJhkCJAMIMQkBMCgyEEJGM5LIAc/xh0u0ftSOV6MQGvGQj5xAURIkx2Lhpa4Y7y71+Orbad4UdVL0dgIDF99pkAcv2Xq7Jfm9zbMPGun++BIcdQFw6sXXGO4lTQdz2jL5cvV3gS/2+46C28QGpZJkjOElPOvBx4eXeP6/Q1ihfj9wZSMtrujLVZ3ubyfI9sQOyaz3qeq3X84E1s66P0rdbazuBGIHMxr8XHQCE1KFvdpcC3qmChiCdx/OszltmsbXIdJoYbax3wEzdU50sSuBcqmPcx4nviVwYOU+Y5hlclIDbCDOh6Qek7wgxQSTU9Qfia1HTBfY7+dB+0/e1HNDbuDq2+/15eS/6sb83Xr2uTmytny1Xzq4jYSSE7j3+TCcN7Q/eqgv4PTpHg5FDfB85RCzxfluSbewpXTvcjVOp6VRtTV3qb5fnKQADl73eDfBlbu3kY6rpUfrTE3d7AlTfDkArP4UECqkDEp1UiE7XMseQ14sKGLnNHZ9rrGs0mEEiKHkGi1QiZZEtpmmHaZptXAPjMCLEiFIEggCi2HRAkJIC9sbufr0a6dOBdXU8KWGmKJklBd2LKqFa/xVAOXJdPeHrDxk5Jpeq/+t6TDr/S0YlAwUyskjoWqo5spZ2C4HEPgkBcYhVv3HikXABi1LgQh03gEgwfb05tlgYQaD2UoyAFFycv4ictxBsIbIFlwk3XtqilAjCBpvNVVx91WPYnJxCgtadIpA2AbvdOXjeYbo4x7zbgUJASgnDMCKFASzANGVMuWBzcmrEm9GcaaO1jxLWcy7YbSdsNicYhlQJdtuLCwhEyTgxYs5aJyIgJkKMtu4aYeb81jlu3LiBnDOEBaHskAJVIguzgOKg45miroudg9LbH5zh+pGIrrGAkajc/hAghgQWMQcQV/2CgjtQdpjnCdFsVHcGxpBUt7DhykZ48ecHm0ju1A3B9zrVt4uQ6XY+zhrhpOqc0P0mBihhxg+R9GukuO2Kw2sWGWGm7rfdfaUs7JtQ7V5UJWN/3dp/l79voQdhX1+5rMM8CHGzY1/a/tLsBN8svt8IM9/JePL9lu1eCDN3qx9/L8rLIczcbXvejfQHgPeJ52LYhduMgNnOpgvp/ljAkkFGeKQwoHDqDtI4EcT2ZVo6R9t7BUNSnUDtArYDILyw33vCO1AgooRgX1GUMJxRSlHdwojPbj+ktLFn2VoqpLayQMmYIpjmuR38gO5RXErVSfxgT0/yrtiGr3DBnffd4T3DUlyv4Dw3YgsRYggYxrHiSUqYMfIkC4KRfhwLBMzuEjZ0gO2+RpLUosXah7VOEIhkVbx6u+4OY+x2ctAOWV5xz8+8v3t6O/Mu33Kf693Rt7jd5iOzw1LYxnuz4WLDAIjcpK4vaNBMjymZzWH6dox6CE9EULoDSgToHC069gLFemhKbQ3V7XRMw+aSE4kdF23zLoSAcdwgxIhu4ikxTdoBV/9xE9kxN4qqL+aSMc8zyjyBcwHnbMSV1Ahd4uuTHq7Kc65k/GB4k4jpdzbmlaSvhLkYo+rLMZrtNpuPY8I8Z9VzbV5Q1HnBzCjc9aoAUhWZZjvou/u1yPvS27HDhXF382mJk9yd6BBoZD63yercP3JT75NYwgOdfe7Kz38AACAASURBVERomCgpztEIM1THLIX+IE4tBECG6UZdu6MdkFA7jSrYo7OkHVgUCP7dU4+shJkHJCth5mWIMEHKA1TUmQ5Pyu8xWSPLrLLKKt+pIkj2wxBzDvYKTQgNyFedSgBixLquiRpUMWEcNzg9u9I/HFUJFtjpYCyUMjck9XupDpOmFLX/LxXC9juzGn89dUK4QIoamAR9h3jEBkiLHlF1PzHAO7c2MEeEl0WdNcaSdwWYYqufvb35iJox4Rd49ZpxtgcAmpVT+aTS117fg6AnW/yUih/2IGoOI6+DK98KWAD7jjIyBb45Mq1JCMaLWDq8+tavQHavACM0o6/2ob+/nZTx6CbMAhgBBCRgKvV52r5QhbsrQiMoNKKAF17r7A1NzUUuouOLC8SjAlhUlv6UpT/DnTeq8Edgz5nlIHONQFKBHqnfk2RcYgYfcOTZL7Vd26VeL/uOgSCsFqGUCvQ4ScyjELTxZm0BUuAJhAB1PIYUrM+bwThn5US34eEGVRsZ1RhCcwI4yBU4aBk6g0nnXotUU8QNvDauSmb0NW+Oz1T72Pu/J6c0OMCeaQc81JnWAa61+ATjA6HWorf9pL4EzbDr50pCdycqmaIfmwZc9DNGbEKrw7QgBOmatfWZO2XdycI2b1tUnFoN+9HR3RuqAkBYkMuMKW+7+xxg0b4IISENI8Z0WoHA2ucwx5S9rM7Gupa1NYVtjFLXzsvoVAYApnb6r+ElbCQgnSN+yqSud9KIDHqiTYkEWs9ufTngvDkENHgknrqsdWBF3QPMeezV6baiZR+g/6J9WEkZYnNUGvGnJ9rtE4Rq23WgxWL38zW2Bwyord39FnmMSOHt61GSuiv8zfZ3m49tDW/v8zbqYN8KPAkaYAZJcNCrlWX5Xub9frK+sHFSCZZoTj1AUIqCWH3kmGAEsd2cwUVBsgGENOjeCFsvCxewjiAd7f3ezYIsFtnComn52AAUnHagB4igMNR+YgMkKQbEgbHZcAXNGtC0bPuewNrvH1U3OgrIyqIt2xhtzehfuD632N8dKLO/DxFNlmSRI3OLYiUn1rHSRTTAfvnrJusE6q7edaVqzgX/faGv1XqQraltPumptL5d3fHS3rVfh0MOOJ9XzFJPG/frYLBx4CtZJaMRFvPC9y8HcFs5Wv/69Pf6uv5SiTW1LW1fYB+TOk8YALiASfUlDeqiDpZcNGpMJY8HYJZJ9WLx1TkiQKMvpmCnRqPvzQWcC/J2h3neoczqAIohAAHIUnzbrW0UKMBoz1U3aO3qbe7DoK1rSoa0NaQSgJTwUYnuEI2C5vpF0BEcEE0XUUIml4x5LpjnCSmOSgqJftI1IY6jqnVR18NpN6GUApIWXSrGQU/1CipgSwStm7j+5zowwMX6jYyAA6pOBQDI04w8XWg7lrmSVYe4gQwbYBisjBplhY04x7BTs1Gjdp6dnuDK6SlCGjEbUC8cUHjA5vQqwhVGPLkF3LqJnDMoJoRxBFFEZGAgxnBCGE9OEFMyMl8AhUFJRsLIzCgCbM7ONAJgCGBSJ2DcjFWHK6wkq5JnUyEIkICSM3ZbtbNiHPDIQ6+Bmzect+Bi0WZSxDAM2O12mOdse5RAxB2Nrt81FcWJ/6E6SRqxWB0jEcHuLQV17AdzcrIRb3a7CwCCzeakRRSjCCeTxQV018UOsLWcl6oxlJxMVScyZVmHR1U6BNGe0fwcsrdm3F6XcV2rafe2N4MQIgExdc+xWWn/HvK/uFO7vc/vaevdMflWkBUOBFNblKPTyB/4u78Vcj9O1du16u2+u49XobNo7ume42U4/t3R8SK0PwPaXtku2vu7vvB4Me9R7udJt5sD325y07H39UT2ByGH62wLomNYXCCkB3NKmVHybNhLhqAgly2EZ6RhQBpOgXACIACdvRvjBkCs+k6IAzyaLgAjhyz1O/8vZ7W/eoJ3dDyPdfUs7pAHIQ0jYmp6l7+jMJCYwXbIzXFMP3BUpqKHQXLGMAztUJCRd9RnTIaPNP2w6XudE930IbZnp2REBVL8KlFADgFM1s5oEWAUGmIEBKRg9oi+yPQkx0RR7TRKAaQ7kpJnbO2H9ASLPtql6+d+aK/1u+u0S+kM09usXG579DaI6xj3N2zvZ186fM8DJ4XS5dag/n/kBz+tTI4NiEUrNdJL3CtXLaetpUwCGN7X24Ns17L1s0d4pDi00ohaLiGSRfBrURVTTHWOVbJVUR1L7F8kPVwlIsilGCcmIIWIGp2IoHNI2p4vPRbCUOvOyFpcCISEIQUMYYQkUVzNbWvSa2NKhp8xIjOG0bBmUey3SLEo1PoeLgXzvMM8zch5QkwJzANyIMw5d7Y+Ydxsqi7FzHpwxvHP0EfF6m3k9isztcMTREoG6Q/yug+k0+0uy7E5tpRDa377W8eGR6OXDl8hezsbgRDQdbNG/zP7vh7wqOuY9jHIcTrtF0K7ZlkGv8sJ3ahrjvoSoDiBRSrzci3WoVoXK/O3QB/9fpWVMPNyROjBRpj5Hk/JtMoqq6zynS5MAg7qUE+usJjSDixPiLqTFCKmSLGBdupgipEhklUBh7O49dnqlBUIMYIjkQ4oioHfVaFyFjgZMOhAH1s5PIRo6ZTv4iobAHUahEgAutQBUirQyMzoM36o4hcR6bQWTX2eAoZgN00AkTHUWyj8RNHY9gGRaHFC3d+7L35qRJVVi+zAswEFenIy5wnCuYLG0CiXduqXzZFjbQcFBIa0QYwD+rDqqs/aSYLohqkZN2a2qWGfK7gQY2zRNKAKrI0Ga1s/kRur86jVl+FpgNiIMcKMOU8QZnPoGFPcGf5cwBQBc474SX13vPdtGAzwaM4xqtGE1BBxcN3GXTDDpqjzhiggDJtFfwTSk6fVOeUOQneCOXkGHWhAnrZqeRq0jzqhJ+LbNcKsYMsRA5yIlmCxgz8OIHAB0+XQfIEI6FKNiTghrJ0OsjfUcaF9ZKl4SsE8uUNNjbiUkjlv9NqcM3LW0Kz1FJT1UWvbUo1qb7PgTiryKEfF5q07hxnTtIOIncoOAaenpzg5uYJxOAVhsP4tZlV75AtrG+bu1LaDdaJOwtKdnIKePPayex+4g8YhDE9z4RENKKQ9XdVNNFo4RGqX9X3pDofW+tatB8IrViCtcwcQNHWDOaLaiRUrL/n8YBufGhZ2LpOdot51qWcIKW6Q0mgnq0cMbqDXMSEQySiiEWbYUrxBWn1STEgxab+CEMkKas4iBU+qh6iCXYEiUnTnl4BLrmClEzm80r1NT+ZtEv0DgEC4gaN9W9/JedNHb+qvzII2frynCFDXKNUxTbZuVYCyIzjUcNb2ZKZlip9FV3fgrq8dXYUvXbtPXOgJQsw+92jx3L5t2r9Wr4O2VxvIbf/oSyY+tfSvfa9WkObIM8xLfesCT63mBAM/FVSvrc+1/g4ABVuPuvWvl5SAaGVp66+udWlsY0NEkCvgaL9EwDBtBBDSbcMkH5b9fvCTTx7NoLZb3b9aHZwkdGn83Gn87vVzDzL311xysPZjoHMELNan7hn+3FJ0b4im0/jnfVn3iSeHSGyHynMIyOs/2yf++s8wDGhAPRbzJ3jElu56Mn3Dx1E/l/bvb40IXfeYIcRgNIe8eJSvGCFZ9TANQ67Arc9HkOogIQYNAV4jT2iLOzBor6vrYq2YiJ3+dfKOkYw9HL4IIBlcZk2lVGbTczR6DAUFgnfTFhcXt7DdXkBEsBlG7LY7cBFLBxYR02i6ipiOG1EElqIxoBSgMGEYNkibhKE7tU0idS6JiKmjBCaoI8ZSJwFG5LFdsJ509vSJHvofLX1C1a/I9T6AOaNAMBvhIgQF4Yc4aLtQwvn5Ldy8eQO7aQci4MpZwDCcYBw0Mlop2q6+f4kwbt58CbuLHYgCxmHE5uQEKV0FCynJlwIoncAJcURKlBNPu0kAMZSo0e0fZuCABLg6CK5nQqGA8eQMp2cKvk/ThIvzC1zcusCQNrh65VFszl6tZB0CmArC2QsYUsA4JGyGhNNxwK2bN5F3F0b0IfBFxHB2hjiOOAkbpLNUx1p1yEVCHGF6u+8HBVxmEO8MBA+IA0GiRgyadzswxHQ5vV6KOh7ABQRGYIHkgt151pP65iyMMeLK6RWcnZ1pWicKyHmnJ98Docwzgo1xCgFBYKQpJ3Z2a0A3V33ucDF9ELGmZZpnX2+0vP3+O4aIcTg5OOdL4erMMl/SXQuBEMXD/NuMlr29Xlr6vugR6ERH4r1IW06brtTbJbe/57tTvt3Eg/uRpc51v45egA/YE3cr/QnsuxUCjpKUbvMmQI6M29s867YlO3SfzUchOXAB3f5lAO41lH3AvbfFd8PYvN8yHtNJj+uqzY6oSyECKG4Qw7i4cujv6st3u+WQuTp3FWDMag/2uiOAabfFPM9VZxxPT+FkGmZBYUKxCCwAMI6DESdVh5vneZG2NSMZR9brzUpsTQlpICQAY9XlLZIOkdkxqrNlmeDJK/05gWIlAQFALnoeCqREBcSEYXOCFKNbo8iTRVarRJmCW9dfwO7iBqZ5i1yUeMoEpCFh3Jxgc3KGzclViBCKEEAJMWi69qofcNG93dLb5jJBClccLwQgUkIBYeZOf+1wwpZidH9MMAQHDpDBu/IITtq11bdabk8weMDvor06dzZLjyf652rbnMAPSWl5HW818oJFipGqwOgBLScft3v0lZpKLBkhnRbfs6eVhCCQHaYNBRIIYQBCHBGiEtlZCNOuQGC6IHXRazwSSz0g0UemAoIAItnmtGJ5pczgOSsGLgzHYQJa1BoY4USMwBFiREiWdikRpBRInpHLFtuLm7h5/TouLrYA2KIaB4ybDTYbJekVEaSTAQOd1DRyQkAMG8XhLXIfS6794zahkrAFp6enStZ2f0XXvU7qIYRKiospWVpVMrKbEv2lw976Q7AibYz0O+ky1bp/dtkud3sYjl3WtSojzxnCWdPoEkDC2N26gfOb1wEAZycnYAJKIFAMSGnAOCqeGOCHhglEg+njjo86EZYdaOgapZZ6L8phQISOTQIhsJVdr1hiQo4J+sGk7/HMNd9OWQkzL0eEICXe+bq7FFoJM6usssoqr6hIuQDyzQYUAiAELE9G66dVWa2OrgbouyNNT3L7szQ899LRF0zxbA5uZQVzDeVNRMhZjVYpBXmeNc1CyQAI4zgixS6UdtIQitFCeKsxEpBLMaOYzbne0jNFU7K9sGJkCs9bqqkTLBUKZwQaoPlMMwpPQBHMJeOlGzdQprkqokSEk9NTVSaHQZ0ObjQ4Sx9AyRc1RC2LnnRhC4s/54LCBRSCnlixUOVEESRBTz72DuaOAKD1a9o6mQOj01+rY1PsvcpBidURpqFpLdoDBVDwdlMAO8/Z0qoQYvKQtZrLeYwB290OF7duoeQMZdFbGhdrbz9VE2JASIC7hvw0srPagUbG2TdcuTCkmPPPHTW9Ei0A4A5/HV8QgWYd6IH3y06+fadjKbOOCc/VK306HG/vNkf0WY20QsaOn+cZOWdstzvM84wYI8ZhqO/NpSBPu2ogDykhpqRjulmynZiTlgCySAgKMDJQwQ81tErJNeQoiBADkIuG1iVSxxFzQZkYBcBc28VoHNSRSFgNP01hZs47gob1JwFJsSAVhMIBxduV9MR66dNUCDAMEcGAGwdvdtst5onVYKTmsNXvYeUSA2ciCLGOewqEkBIQPe1En0dcGumoGzdq4BlRIAQIEQoELLkzztxo89upkjd83NTTFESVZHUJQK8GrrWveP7j5hD3U2r+XL+6OQ411KyebCuL1B8+NmMakOJYy+AEKi1HxpzPvevgxBVBMcdmW8N93YboupzzbHXs8hKjzR13SPb19nC++hNAaQQj2Tt7Agu18lj0EI+4oHUr0GAhhwGBY9JOo/RiJBB7fr8D9s/u/211LJec7YeiTd0JcOu/V5Ld5esvXdODwzEa5+nyGnboGfvr3X69erJnL61f/XltXPvfTk5re09QcKoSAzpdoZ9T/mPPYmljuDnOL9fJT6F6aqQ23i7332ECEQBo5LlD3x1qq1ZWXY/ryLVxdGkcdrqRwKJTwNcJL4Hd0+HD7ZQrWe76y+DxPijW/8t131tKu+7SV17c+mVPjtkfJ8t7Lpfj2HsPldXH0nI8Leura2vviqlPu/y7KTjU9Y0HMuqJPn4q8KAEAJIgAKLfU9eJRc3aXCAsUmTWygFdlKVlO/pcYNGxEZQ3jGARjuZpiznvME877LbnOL91HdNuUpKMABr5TvfPEAYNJZ42CEgYxgFxFJxe5W7PEeRpRpkziqXdQ9f2FVC1spM2QxsD3mdio9hIcLKYC64/KYB+aURQXxxr22JxzQj1Of0w65uvkiPIdEkCZkuxICKI4wle9fCIq0Zg3GxOMQyjplgTAbGoXmXXpzHi373+1dXZVTijlBkvvfACSinYnGxwcrIB5nPs5gnDZqM/aUAKuq/lOePm+XVsL25hHBMAQckTthe3cHF+E9O0w2Ovfg2G4QSnpwPSMGIznoJFMAxXsdkUbHcXmKYdNq86QUoRYME8Tzg/3yKBMISERAM4E1682EEkIW0ewmgnMGFrRSECAiElqm3czy1fW7SLqfUr1wYGWMAo2M07UIhIMSINCSlFzPOMkPTkfAwR0bzaAsE8z5jnyfaSLrpSDMgiZju4jah6bjHHjJZHibVUgfZu1tABCPfgetMOVrgz4U77ov8e0BH87uSn23v3ISJ0T8KNoSu/HI728iDkXp18dyJqHifh3F8FvhsIBvcj9xNN/BDBVTPhXrZ5ezn2XRDcNeGjWhWkEaQOKMh2xeW9+47PdozI/nA9m7pdvGpgtv7UJ+/9HtFFn+z2p/b84zWUI18eH7uH9vg7yfE2ud173El8TyLHanRcCDou7kcexFzd170vfQ8liTnxom/OSj49dK9FU+nf4b+P44hhGKreUjEls69CVNtJnPQlgmmaNDqtqKbep/oj6aPWCjQSmdu5wQ7nST3QZcqFOXeXdrnjSIClhO0Op4XARgzV+pRScLG9qPZCNxNV74QddBlHxPgwTqTT58SImZbGUlixqGR2ps67jMzdQcSiETiD2/yeDosYDKnkYUSNVCLskb31J8DTXIZOD9Re3ue8yb4O8grLgy7D0YMuAIils+l8zdbFO3Y2GPl3wmCLAu8Hq9o4ohqRyO0J14X1px3kiJaey6MuaaqtnsziBGTHSRl5KphZUxGlMaJMO1x71TWMiSAlYzfNKLsJYtFs2A4KmBpa7flSWvT2YBGKSinYbs8BWDrkLhJnSqOObYucVCp/msCiPorTkw2GISEmAuyg5u78HHmezW8wYd5pWtHT06sABYusA5sDOr5HO6yZUkLOufZLlln11BRBQ6w2Qs4ZeZsxd9E7L7bnLZ1zGjAMpy3aIBwT1NSrMQU9S8AZuczwgxgBgIji/NQDcWJUI7Orels3ULWYgEv/tlSlaMOqG6MAkSANCUCy5tXRcDpscHLt0dpn3aZc+0FTqLpdqH+7j6WmDAvtcGmbE8ACPyQdIzlnzPMWXDLGpFGB22E2nxOkZKOYFv9qCVbGzIOSlTDzcoQJeMApmVZZZZVVVnnlhHPGbCcW3Cnvunv91z4LFEwRNqJKFxJ76YgAXEGMMTZnqqV6SEkBZb/eT3IQQaNJiP6QKeDDOCClpggp2UVJL9FP8NLyRFeZt9idKzFB3xkxjoOWQZSYsttqJJdip1xjGDAOp0ipseJZLKSkOCCm7GcETc+QHjozZ4ifBNbINmTpfDKTOg0qg9ravXi6BgP+o9YlJiCOUh1XNewhLA+ohX1cnmR3A6k5cRfGqAhgqXscOGgAckceMSO/MGuEDmnGjb/Pf/R0AhkYkZFzCzFZSgEoIaTUCC9hGbVAvF3NKKsGPJpnpGfXOwAg4gSr5YlNP1lX0z3J0jjwcenReVpfBAvX2xybQF9njyTBdr9Y+6fa5w304FrWEILm2K0gISwEPyORGlTaN6iOvUgExNj1jaZK0t+Xdemlj6BAnVHjpA0noej4VMe0Bg7RE+Du+CJK6qgD6hyvz7Ln6ekIbVwSQYitLI0wYE6ZGjhEgApu6nti0JD3vkb0/VzHiWSgzCgA8qR9Ll4aoiUyXO1SNdb7VFW+rvVkBH9F7zgnCAouRzfYl9rHRDUFh1hauH5ssfchy6LPHKNrxqmDYa0NSukjErQ+DcFSE4m06F1dyGnvd6A7xWyd4sCWNocRErs28mg70UE4m/8xDS2XebSoAWhgA0TXbfWzMchPqZEAdmJPuKCUamfrbV4msigQIdR+1BQ/Btb7uIDGC5M611tfapV7kk5b35qRfrk9lwA5Xfray3cI+BYfCzWiUqjvdwZqvatzKJPNt1DT6vVjNFh9HBC7TAA5SHro2sjLdtkjZ/X1edQD0/aHA76yIL609at7XddeDmb05Nm+vP720F3fyuTP8uuCREA0OoLif9o2XPUT6dq2a7/u2Yfm7TGCie89vcNLxOb0oo2kjjPPPuKnKYV6QKd7J/kH/Xe0uOpSUSse5XpTq/P+dUvnQqt/DAe6v3/2EdFgf9KVnbodbPmm9rbjThwni15+ae8U65toH/RbvqkCy4dLf/jWRXmWZTh6se0vB+strcaLliAnRC2/AQCxiFQA2nrbE7pFLFS6jzE7lTzPKEVQSoDgFONmxDCKEYAIEtr6GCwymjo7xEiXFv4bnj4oQMams5TCNcWNg5ML3cq22T4aY9/ELU1N+1R8LRaNQNnWgC6qhogSZz1SJdl4JR8Zy7Wyzhu7t10iICYd8KT6ja7FqQLFKY4WXS3BI93NeUIpmiJiNt1Ode1kds2Iq9cEgowQAOYZFxc3UQojUEGQjKkIthcXOD07RaQIcMHJJqmdIYyLPCHGhCtXXoUrV69hPLlWU7gWFkzzzgi3ug+TZEQUbG9exzAkI+0DQ4rgkjQ9VmElndqpYD0NrzZMDNEIqD6E90loqLog4GR0I7ASQf0ZUsc3M4OgUTl17c/gQsh5VkdB0bY5HUaNSklK+i5c6pbgKW1FVOdkLB3zSuZuJ0T7feB269T+SLwdqaNvjxa90t/Vz9dGxr7tIlIffvidy73xO1/u11H4neDk/HaK3KG+93UGtJ+f1Q6A2QX3/LA9cu2xq/p325tbHunbyp1mRa+b1v3OXlrttn09qeo5tRb1nsUb6w3dc+9imh6SY+Smurfckxy/YT/R1PJd/cmnI2W59MADeuDyroOf8d2uaXuvehAz/G7WiU6VvqRtAjiszAop82XxndR9rr+tQgq+NtPyna1pnKzS70OMPN/SfbbM4DJrFFbRg3IpJWzGESebU1Bsh9sEBPb0UV4mCnUeqH0NPVS4Nzdau1FXpka+EdPrPOJ0yR4h2ePQ6MgrDNXDiIx1bKmA3f/WTQPHj4ZoEUdMf1IbOiBFT5UiYLDavR0e0A6I6Y0lZ+R5wrzbtX6l/fp978o+htQfPKh20cEbu98Fup4LIIE7fUagBwJ9DdExqwevmm43DJuaujKG2EV8bmULNd1oqKlvQ4d76mGshtHHQBBEzJbLmGLEuBkr39rHAqHZ7h6zBkZizqXYYdSCPO90vJYIJo/KSIYXGAZgDw926DSaLcN5RpYMKYqbMGfkKWN7cYFpmgARpDSAgh3Kiwmg0EWxbNHw1Q7SA3LjOGIcR8W2px2m7S1Nb0qa+nkY9JDe2KXvrgfmDKe/DCsJBEUPhmY1YOp8tsWApM2R/bXpuH7hems/tw6BBUvd9PLv/TNkYWu3JVa666rBVoWRLaq844eh9ll/odc5dNiZ48DDMNg4U7tjnic7PNfWkBBIs/ehYOaC2Q6aZp6PNdIq9ygrYeblyJqSaZVVVlnle0qeet1TePVj/4bnnvsmNCuNA6qqmPROKiZ1ghK1XLMaJtCBWFeQAXdklUrAUaWZoCHsF6eWHKwvUp3cBDcwTXGOqQNhVBkrwpDCGkECzWkmIpinCdM0IVcnH5ttXczI1Mg12ULZA7BQ+oQiFhXEouWU4g7GLmIIBRAJ0jgiENU6ttPFUg1aKbznqBFIcYczNOwp54XT1R1zSoLx+8wYDlCgXQwKEU9JZCx1A8oFUg0TsYgIFJoCq4YIV9DO29tMcUNMrIzdSZ6WjkmVZXf8EMQyYAkCqVGtDHotn6ey8tOwbP2tHdunPRIz5DTiRdXrpRkmgNSQtO4Y8FMMvWN30eruqOIGiBC1U6gLyE4IzJ4arHPWyl76EzgNoXQAHoHZAIouCkU1Eogsz+5lB3OMrqZKvWdZh71xVEGN/gvq5mhPQmnOeBHUiExuMAopiUXv71INdI4EXwdIB1p3wksN+zYH24D3NUGbzNNmoJarAQoOInlnS00N5qc4/Pt6zX4fE0CsqbBQ157WpI28Z6/wHhRAoKfU+7XHHSxeXiewUaAul3lHnOrTC0Fq2XvHTXUoUiNlaZ18gKOeTLGVWOEDJyyijT2CEpdiaikJvM3rM62+LG20ihRkS9+xcKDFQQmBDrsZKOZhbJ0IWCtJ3kd2ik4KMmfU1CUGzIWQEKShlI3kYCBStNPd6D5vldFxbGk7pELqPidh5AYHHqFhGoDuPd2Y7IBZT9F1UGhv7nTjoIGyHfDUrUV1fTYSlYbidtJZAwl87Pj46DCMCmAtxrmPyR54hNe9ye2gce+bHvro66L7r7db6+tl8BttA51H1H1GcCJbdT4ui98q2BWWzNnt1yxq5yBc1UX8sftxVwS3q3m/FtRp3Tl4KqhuRVmmnfLytTctdJjLbzrw+eFrRJZ/X7ryIPPFn7+Hqi2+O/iwo89azLnufh0f+5+0ezw64fJ91Mq3D4yLjx3VNIKtU/WUHelaNA6xrk/MmgZmM4x47LFH8OhjD0OI8bVvfBXTNOORRx7F6ckp5mnGSy+9hFIyzm9d1/sQsJsKQojIhRFjwjhuLMIgYTNuIMKYdprHxV3K6AAAIABJREFUXlgJvxQGiIGr9eRww39tq1f9VHWpohBvsHZB2198lRGgho32NZ15f/Q0nTtR0hOndZ9vzhC/lqWdSFbCsEeOkRrRzb0zmrlPidN5zshGmNE0BcX0NMK4GWufk+WcCp1OoHtUi1zT0mG2SE8hRkTrSz29OajezgWcC6gAQlzrBPG6dGOsNk23KNQ57HM3gmioeq/rpu7siZZaUruQrZ8mCCawzMi7Gec3ZgNlnUQSMYwaUQUQS/2jkSwpJFPttI1FCmbbS/1UeqCEk9OrGAZNBRFDBOIIT1kKEZQyoZSC3fYCOc81PVUpG5Q8WtQ91dVTHJAtHDwTkJIdFAhKnuKSlXCl7B5Nscp6UCDaONe246pTCZMSuTiY/rxcq8X0eDdpSingQpVYq6QnYCoF0UZ5EQa7XQBp6ZbsXwmhreP2s9g3b7s+3atQFzHA9u1Ol10SaPdXy+9OfPJ2Tshju+O33W95uy6+57IQIPtrhdks/qKDlb7dEy9/Kd09h9uQFv/6lbcbzm7DuOO86ZLt/v2S3HF+7DmmDon05a3r6t01fFuOD1+/0B8MF+kv7Und/pyqVXW29X4tF2Tn/r7OrjpYnr32Wmq0B64/mPrpbuVQm9ypXY9/3/Cu/rPbzO+DY0O6747V68g4vY1BsWh1wYELL7f74tHVjmpkkctl6PGR43NZOpuj2jB7+sPitk6V6NWLVrZ+H3IbVVNPEpQEEyTa4Sk9OBc85Qxb21Dd/eArCkmfNN4c9Wj6l3h0mKCEWCXuAs5qUXJsqc9czAjHSslxxd4y2Dt4oJoCCALibk4SGmHCCBfi+z6bbhMILEUPSwVCjHqoUGqa7aCplv2nsMct0fTW3QEeL2BNM4oDy4rceQZ9u2V/DjbM6tC1R59yz+8UJDto4wR5J740Qrkf/gTp4cVx3Ng4crvB05vrM1IckAbDIo2UEKNiSQ1XTJ1t7HhWQfEDJWSpQ7nUyJFMSqyGYx4APNpSI4l45FjFrZjdtvC1qpstfjBFBERsaXYJmTMyqW4vohEZd7sLIw6RRTYeKk5KIqAgdj2sfL4WAWIRQplnO+ClB/qGYVN1Sbdz4jAiSiupr1X1ubB1yarhRDZIt295hGzzNVAztmt9jw2VukYdXNY7bGJvEDbstO0J7sfp94vLuIT1Yh3vl3dS7zq3fWG4aPAU5UFxNDJcHdTjn0qEUh8B2VhkhDiYPdv0FV+vGqmLzSY93Far3LushJmXIcIEeYCEGVkjzKyyyiqrvKLypv/uDXjmC1/HC9/8pkbl8BOApOE41djxvMFc9TARUXICN2UdwMJh3BMUCOrDjLRU5KrD2JR5PdXSyBv+HDZF2403V2wVoLfQlJ31m4sZn0m3/QygTKWWiSgCISLF00V7CCxihzh4gqqYoYvg4kZ1ki4HsCmwNSesOJGFL9WVoG0hEEw5Y7s976KaYK8+roRr2+yfhAfUqHWiSEoaJh4C5LyzkzEaZnIcTxCjn14Nlc/hYVRDiEhBI8gwyp5xo0o0F2XZt/zHXrLqOkLhDCka9l8BgbIMA0oRwSJqsGhEA+alIgw0Z762OQwIsBE3bGpbtHCO8yKKTg9+7ANK+wBNb1gsnVjN6eXjoVfcHRLpgU4WqWGQpRsH++/x73tQv77kjtLGyiGw7Pip2/a994Ea0lLbl+zC3ihj+0/QCGA6zv09DazdPy21OBlT+2NZj+Vn3e2CCrR4lJglANbAIYeRfB0LR9rAn+9kHhENRexj3EHZntwTQoB4ejLPBV7L3AzPVjozMElPv7d1kheAIQAIozroRdqpfwe5iAiJAgZR0KmtY7SsC1r0gEq8s2ss9hTckVjHtRFRYkwY0gaBBiW4WLn1dJFG7EERrUvFNjQagZ9C8sg+GgVKx4ava37SiWouaq595CAdi0Ym8D7gbt3RjlBazQI/dcdbh4SKR/qBz1VqY8jb3sGc0EJk9w5+3QYtso47IkjHmPqQl8SfXoTE1jQGoA5rTc2n5AAiT4VHtZ28DFytfgVqe/B24ejwT0UA6RxEtfRtXC7KJo2cs+/g6Scgibn7fY4sn2KgdBvrPmd6jeAABn6wTP3V6tS8HFrX9waqfyzLX8fIfUi/BrenHHhWt3b2996vXF73H5Bc6q+Gw+334/KapvNcJgTpdyHYukGERx++ioevnWHOur8PQ9IoGrb2EAi7KeNr/+0G/uXr5/ZKAoJASaasDocK5OrJshQD+GSER80rJYPnCTgjDA+NeOT0EQhlfHX7FUznO4yPDLg6XsVF3uKFixdR5hnnz183UmDErfMJIY2Ypoxh3ODsip48hBDC1RFcGOc3d9heXKDkDIQRlE4glJAzd9FJREOE2/Csupho1MBIjECMJ586xZNPXUEWxosv3cDNWxNyAWBpNQkESb4WE5apTLve2Rtbi7R7rFFqctYoLUpQt+2SyFJ9CnL2qHu6FpFk5DxZaqcCAYEZyPbMmBKGcaP6P+lJyhR73Y1sj8p1X/DPHGR3QF9TRQWkIWEYo+4lc7EIklBCpbSw8MIZlQxpNsHeCtMIdO4sCMH2hWDpG03/hToBYgSIGCVfIM87cJmw2QyIKWMqF5Cyxfb8BqZJI7VQUGLMtWsPI5XR9lvCOJxBQCispFAKhNOrVzCkhN1uh3mnqUxjSKCgpKxh0DSUwoxp3hkIrOHYmQXCM3bTFtvdFlyU0E4pASUjFCWnxzBoRJkUlZzOjGk3IQ2jpUQdECy6TIwKSE/TDtnSfg6Dpq9t9hgvx1EdY4xL+qcty0p6UZJOCgMk2el26ymnqFOsmVfhhEsNVtYRc4nqvtbsov0opfvrEmFxHP7SPDnwGXyPrx8c9i34l99NQnRodzpybeceEaDt/ipLHXlfb9h/yyEd415E7nBbb0fdxdOk6XX1CdQRCm/jcDq65x74/FAL7T+r1+eXZWzjuv9+Hzfo7qjv6Wj2e2Xe6ydd9Bd21+10ikU5sLTV7kYOE4Tu4l0dpnOovQ6lXwYuHxzpn3NM/zpm99/uPtn/zfdT4A5NdGffyBLLuFz3u7Hh77ZPb/fuQ9/ds/rZPW/5bB+7y3lHvu74pcFsuS6yES0fa4/jAx+297od27/sMq5zt5XyUizvIQoYxzP0o+PYdtHWHX9ap3STISRElulIo6uxFOSs6boFjJACBgwIYYQecrJIG8woZbLUO/pcxxRTSppBich0thY1RFj1wBrJ0Msm0tK8WOMXFNPtAU8jHyKQs0A4o8wejc8ipE4ZXGbM2dKE5oJcPHpExJg2GDenqhgESy+Ohj8oRjqjeOTmDq9QDBaXUszd7zh/uXJ8zTu87h+Tey6jPVvtqlgPHqbohzd973HsQOeZ4zrtjBPb4cZih6MiKGjEmGKpuKRkgAUSGY5YLaJ8w/sOdcoxF0sN7unLCX5QSNvGo16Gzq5XkjsREGKLFL7EYNshOa76o2HpgAFarLokBKXMmHY7TPOEcRgxjBvEkDSatuhAYmEEi8LouI9G3zH8yeZI4QnzxQ7JcLA0bBDjiFw0DRN8bmmD1PIrIV01zxiGvW48rhu0i4D9xeUybr2H/R2QuxmPFbfyoneb3EGNgAA/dNlwi3DpEgqp7oZVWzGgmmzdcEzVbQuvt3axHgqgbtyL29l7eq9jcECxdn+AQT2+z2UlzLwcecCEmTUl0yqrrLLKKyu57LDd3cLF9iZEgoHNydL3NOeJkIfEA0CEwrkDZxz4l3pK0RXsRgJRBZkpYRwGe4+FViSqjtY+oDAzq7IvRVN6cEbJjDnvsN1lTLsJzNlOPjSHeoixOy3apzkpl4CXXlyBrCqjGwlmyBn8Uq9V206B6HnOKDlXIyVFy3nMBfM0gwIhxYhhSGbcBkTSdk6JMY7jAszetxKbkgw9FWCkmJSSnpzOM7bbrRFntO9ijAhpg3EYO+d7sjD+GrZ+TGON/pKShpPXcJMZZbrArYsbON/dBJcCFiXApDhgHM9AaaMKalGnCgO4yMUilWwQ0hkSBYyk9XaneuGsUW+CnmYOQpqiirmChFwKSs7V8Q0ia1t1rTABF5kBbI8CYkRUT/zqI+7O0O7Bz+bQ1q43u0vBHwvryWhOfycQCWvUIAU5LOdtzl2fLY3QHgC8kxy6504G0iFQS+c3q6uKNLKQGqE9CNtBsySWpqOdSHMD2R3+lYxADnxbSh7popl0qJKY8VVTSbgRLh5euOVA9lMIbrDt91NtA/GUQct6u2PRAY5+bAAKMoWaa6U1QHOKWuQQUrJAXS+qkdui7QA+X5emIxEhhrG2nZMqNNxrSyeR4l46HrtWQz0L0J3YQGHk7OC6vVe0fmKA5GJ0CIMQMaQABFm8g3MGJQZ4AgOY5hnnt84hRdsiDckccBGRorq8WQCKiHFEJEIaQ9cmS6eF58X2/QICFCIQuEaYqsWUNs4AgMnbu51KgYNBoEoERAeGN5Kakvy8T+u9aONAx67nroc+2N4fQgP62CI4VIdfddDUSQEmo5lyIz71+4+IIKawNwahQKf96RGFQgiYd+oorfW3IeVkGd+Hlyi1k2iW7VqfAyPvwIlzmhIqBjstSR4DxNqTl/s8F3fCAwF2H+kenAaj2ornuD8uhxwqt7v2ds6GY+vn3Tz30PPuVA6/9k7vP/bsuwVPj5MfD99fA7OTRsIq2YDMOlId5OvHC+xMrOoHZCQEJ06BM0IoGAeglAkxEd79o/8e/8M7/3vcfPEG0hjx2GMPYTg5AQJhHJUk/dVv/Av+1//lL/Gf/+//dld1vb28ZD//de/z//fAtRv7AYCTve929gMAN/a+i1AKwK37LuX/9D+/Fv/jJ/4DthPw55/7L/jbZ76Ol64XIIwAeZQSDe0PApKl+9x3g/u+B9g+aWnrKJDSV4tARIkaqm96xAKd1TEMoCGqHsICESUlDQkYNrZGCuAQqY4X2z9DQIqaG17yvNjb1WGjqS+lCMYhYRgVIM55sn0tQTgil4L5vEBu7cCi0cd8Hd3tNJT2ZrPBOI4gTlXPFWlR+VSqZQBA9RePTER8oWQXBIzDBnHcgCRAuOB0cxXCguvn53jhhedRyoynfuBJIAhmnsABGE+vIm0cWNeUmePpNXMEZWja0IwbL13HPG3BpYBI33V25VVIacCQTkCBkBEgJWPaZoybEZurI7gUXP/GvyKlDcbhBCkOCDSCKOHqlVOcbNRpVopGg5xLQYoBYUyI48YcBJaKIc/YXZwjDXriW7iAwEhDhMSI4fQKJAaUTMg52+nwdsoYQNU1ejImF65+X1/TYhyQS0bOBSklnJxuMAwDSi6Y5lwdY8s+aqn3RAS5aPomJ1TFQVM7DklPQVNoRKAFORbLdVIs65ar4xWMh+2/rheafu6h4QFc2me/G+S29kozSRBcBWg3Xvqsagfk2uCxPXdfj9gvQ28nHUopQwc+25dD1+hnlwkhl9+7vD8c8aebs+UoZH24bV3vo4PX3KFerpug6ZLNiXlYDhGD9VHmKBdBr1/U76uei2ZXkSwcSu6kuvRs+7/rzfbXJb1kn7zSl6N+vv8+HLalL9Xb3ux22P5nfhJ9X6+Srj14r4yH2skxlUWZu88vEaUpLu53+7fXOy/pepfSXxyWY+3idhDvHRC60zO+1XKs7+5wl/3/sp6+39Zu/wIw8q0sppzbVm5D+57l49bTCrtjvZ+fnma71aOVDe6YPSBuuy/nvtpCC93Miuppl2Fl7wJl6mXEhhtZXUJUh7KTGYQQB8EJlNSihAVLU5n99Tq3IwEnMeLmVtNDAcAwaBSRNAyWjg16LzSCcAgBiEAoApYIYY/EbGmTLQWMiOKquUxIKWCzGVBki5Si/gyC8/NbOD/fYkynuHL6EAKNYJ41YnIMyDOw3U4abZqUGDwk1ZEoRj1gVPUOJWgoxscoZdZUPxQ7AqfiUaWbvz6eDu3n++no71Xudqxffv79Rca7nA7MPmOpaUgN0UEQaGotBoQLGMDMGjuoX5tyYaSoaW1S0giZQqpjhRgxxqhEG8OXnC8Ro4AG1Zm0RpYihxqO5nVMKcEPdelhKiClDVLagNmwzrlgSLFF0oVGMNTDjIpjaQoeQGlb/T6oDaMHv5yIw4ZTe2Rziypj/gYBQCHi5OQEm5MT8wcEcNEo65GiYRMAixJ8mn8gWVSngCEovjXtdrjYbgHRKIplFuRcUBgYh1Ocnp3aQTHrq0iYpxlzns02IIzDUNce36db+lvtV8te1mruuBNam++voe1ab6fL8+NYysG+jX3P7/f0Y/hKP1CP4TmHcJAW/VRq+BfH75woD7heb3qp7/8UwFwwzVN3CDZUna5F/NeVWFDgUWpXefmyEmZejsgDJsysKZlWWWWVVV5RUSVuRikzUjoxkCaA0E7VKwBvJwNNkR/GZLiVVMCGa75TdyaKhRrN4HIBlAJwQSZjt5tDz4HSqig5+QUtRKjmIVKnfikMoYC42SDIaM8xpdSUUzes95XICs5II6eUUmp4+Qi2sJehY1w3w96FrC3mi5f01AcXcFGjmacTpGEAQJhzwWTOcDUQ9ARsorHugfpdMpBKFicuewVUQ59q/Xa7DLEcylpXjxahDZHzhBev3wJRQhoU5E5DxGYEiAoEE0qecevmhSqj5txPUUkzIZkiKgExXjEAIkKkhWtlkDrco1iof6CU1tYOGBIJQrRBRAS48VKV86CpgOoYMoM7qTVBFbXyMQuQRbXo9foeHPN+vre5IIt2r+PGfpwg4aC+j3kAyNIIVO6M7/vXSTL+t7/vvgztPaPkbgz9faMrs9ovRIQwDNicbIwUIIAbOaSRgrKBUt4FzMfyv5eDQBRBDaKALq+vI05+AcyEs7Q9HjJVYOtOjEsIy+emtHlfLedKyGh11/oH6MkWGJBtc9uuCxS78otTCmo0RMMXoIQcL/ehUNKNPNSDdP7dfv85Wc3LCuAgyEtEyFIaSE0KoiAuwT3Hb4tdp6CCoHj0L1trUyIMaazjUp2qBcxUs88QjTg9S/AJqPmuWx52XRW8zrSsad+vB4boPlDg89xxU48mVLu1PlkjWMTY8h730bm0XS2EKzXnxTIiTDf/pAttBVYyqLev/efRhCDulObq2HNAHd09GpUmIoa0WC8AqeWOiSAencdTpEw7pKihaDenEU899Qje+Y5/j//t1/4e//WvX7zciPcp+5Bw3w/Lb7qW3xvnl5w41n/DScB/+LHHEAaPTtRAjH2S4P4+t//dIbDoduvmg3KK3uk5x0gyd0u0OeTYuZcy9XvIoq3sORGMQBkxCIQJ/88fn2N3cY97Taf/6MsAj67kpIa//r/+Gr928kxN7RgdiPU5T0DOGS++sL23d3+Xy//5f3wJf/SfvwYR4OJih92UzXE6wddSgeD1bwF+4C0azQ8WOjwYmRkgTBPXdZJESTAUlTSDBIwbgYiRgXyS7jnjmt7iF1nfSD+lDzmRqJJwuLASH2ytKmVGzkFJ4sOAmBTIzNMOQfSUtAj0ZLMo+K2RbgSAEvNTAoZBy+77c4z7866fW31ZpX0mAElAGBVgHcaEzUkCl4wXX3oBN299EzGQlfsCzIIXX3oJm7MzhHQNkBmnVyxaIpvTQACZJ0QRRLKIaIVx7fRVyJszsxkKRDJ20y1cbLnOiUDR0n0B55baNYSAk/iQpmZijbqShoCzq2dGHLrAdlswEyGEAdHISikEoOxwa3sd03yOabrQn90OoIAYRozjKc5Or2ETr0EQME2AgJHiYG2rbcRGkF6u5U0Ji3HTbDpI1QFCSBjMHpinbM9pvZPnXPdCTb2lhyFSihiGiLnsMM9bpEjmJNMITVkIc2FLUWYnjpPqGMXTyHpkOzCSNm4dCFwHhCz/sXWLQkSgwzryK0Ge6W2Ke9XZ6zPsx5SOBXWkfuykur3bYxcBclmuppvUtaE6vHHwHi3fHatwRI7fGGrECU+d62U6ck/da6g9uVv72p/77X4nMsDldUh9c64zojqOXO8JhmsEWurC4TYO+mT6a9VV3dZ1a+s2W3YfsaOt8R1BubtXbE735faFoOrAXSH13MBS3whw/Idqu3cv6DTFNnaqPbwn7aPlXtV93P6Rri/NyVjL2F0uXTm8PYLIHbGAnoQjNnG8D9kxBWkac42kVi3EYOlKD82trk1ruuNG2G99AIQ9nbK/bkmkNcLQgfnhZdI2bve647LHSA4SoPba49gc2Y9y3BMmmx13dzq6QBAiWXTp/Wb0hEJW1cLVdSRomNqd3rGPEx2eWFSdscs1UffTOsK9XtJG/D6W4b+GygMQHZsWmY8BNKJVr8vYeoa+P6gabISAq2ePgoKSTUNU3eRid46ZMyAauTTGoIfc7NAZgTDYgZHCGTJPmPIOk8zKmYHqnEpEiShZU5JzDtiJkhYKEzbjVaQUMfMOU9k14goRhnGDa3Gs5YQdgpqLAGWGRgPXdD0iivtyyQhSMFofhlpOWMrQvJwL1reHDj4eIhPc7prDsreuvQw5WgbsxQvYu4wi1TZdrnGW0op06ATq5lwIGIaEq5sNStEDWEWAMQZEFCQQhhAQIxACGzHG9iVxcjEbBsSYYIc2xee64+U6jv2Aq7dnjAPIMHqdRy3yt/efY8JS54Ee7GSebS60edD6ydZGj+xMbGUhWxl83fMU6ab4+FhJhCG5HmzkO9Ln6WeoB4TKXHBrdwvzNCEEYHTSkRSAGDHY2o+Cabcz0lmrW+ECWAoyBnA+XyAa7lvJIf2cF8CjNbfl0yNKHRg3cpkgqm1/fP273Xj3NeYQkfPw2KU6Jvy+fu3f96/oLxrxSn0H2t4paaRlUEvrpmR+HRfTbMQjZo06T6lG7W/lantgH/3+LmCUVe5SVsLMyxARgpQHZ2TKSphZZZVVVnlFhWJEGAfEzajKLATFojC40StQRTo7cCDANKdFpAwAVWlx0E0vFwDRoh3AvfQAqYILCEKwFB5iZmnpDHlhELFDAAB1zmQHH6CAvIMrCnznls6jry/QABVRkkgkQgoBAo90ImDqUpqgAQStjooxUYhItNHPo4MXsZJLgyScjSeNaU8ELuqAiMFD0jJy1rRJRK7sKjHICTbV4WBKsyufIh45QxYgDCHg7PRUAexhMGDBHMrKDQI4IoUzpOr/DyAjxtT0PHbKXEkuDg4RYE4zsBF1unZqSrSlViHBbtfSJOm/oYI32r8tz7IDEMEcFT0TvYX67ENDNqBXFfYlq7+OQ4tg5A5yJYCZsdQZ5g6WueGW9yJKHHL6ujiYpvcfNlruxrA/dO3B7+v/DzzHgSXRiCMahjUghYAxErhkTPMOeb7AlpUk1Z9QV2c/IKyGsLc1HTlRtwD1lvjeATzpQHkrmGsQmYRm+PaXLQAvd/7dDpT165agoBvjelJtwsXFLYiIpiYaBozDqGk7DMUTXRDbeuL5yuv72tjwU6X7J0iPG6OXv1v8XhHkHlTXMd6+s489XzW1OxcwUDXytZ3Zc1FDnXXByDvuGEheL1AN80x7ZSHs9X9X/mNzpbWP1Pnu9aglXwwp/6Nd18rR3UfdNX15fKyA/n/23q3Xsus6E/vGnHOtvc85RRZZLF5kkbpaEuW2LV9iuxEYTmB0JwHy0C/dyEMjech/yB/IS94bCBropzwkAewGOgEM59Ldjm1IbdluXwRJpkVRIkWyyKoiWazbuey91ppz5GGMMedca6+9z6mLSErao3Bq772u8z7H5RtjZMU4s3g3ZiuijsGkdQerwtaVNEzkHEjT2aUU4QgCcnESSalpHK4++xSeffZpPP/8M3jh+asI3uGD9z9AHHqE4NB3KwzdKV789KewWp3i+6+9hr/73vdwTKcSmSZGHD3xPH7pV38FCGdYnXU4u/+T4T3DscdT4btwYY0uDYgEON9giIzVinF8OmB5cIQvfP5LOFsNWLQLXDp6AjFG3LxxA89efRYvfvrTIHK4c/c+7tw9xarrseoi1usefZ9gMC1wGRWPU1cyBeVMFVCmtK2VZrMGzsoAAkDyxVfKXiIDwtox2cAXi6XeY0o+j8QR5GT9XSwDnnvmCbz88udw5ekllo1H4wnBA7c+eB/f+Mtv4c23riGlHh5LnN6/hO7s8YcrPrl7BuDssT/3J53u3ulw9043c2Y8Sn26h8uHx0jO42wFnJ52YL9As3wCoV3isD3AkIA4AF3vsV4HeHeAEBqQY8AZ71f4rqxwZgiPbTpOtnX+AWaK8rXJMxr2YDiAGyReiEEmCuBvUCW98wCTlClxxJBMsQxAUweIcabwsFSlIRUFe8331PuhFcn2buU7SfhJ55wos7sVhi4ixg6rk2N03RopDRoVpUNoFuiGBFpJGtAhEtrDZdnfPGUgtG0LKUn0NfYJRBHesxo4q7nsikd84YOl2R0RPFuaKOGZBwxYYSVRNEE5cpsZlkAOEtsGYL+AI49FOEJ7aEZRe1dA8C3gF7p3xdJg2XhAeUyYQWsc5bAYGwqQlOH8NOpR4cMdgJYc3DLktc/kHC8IePnOjOSlIR0x2JlyXQx0TtPHmsdoLhcKgJ6ZJcqoRmvs+14iGWkHUd77qzUbhClP8uOkXbz83B5hcg623kejj/IeiwA3BV5WAJeZRzrnkVMuo/BTNQgEsPloYJyS3sh4Lfs+XUXG7HZ5xqi+Oulrvs2OT2d8toPX52rZSwoLS8nEbHyk8qgqD2e+fCIDoC5ffdzex+PDyQ7mctRe0hr91Pl8LOtGuET0m9I0isuYZy6ARZNVsNFKciyzr9X6X4+NcaSuct5S6qXswW2ya5Fly7sxusbWlDneqK7PPGBm/pptYGiaOBDMGQSnIGabWiUdMuU12mRcG+ulz3nUtBahazx/m3E6O7aIJpv1G8mH9Xze6EYeBaoxENX0Xq6M1I4LCCq/czLnbA64VIBEzuRntjfnBtRrUtUM41TUdkMBXfHknTyq0+yYtT4CMEpVvGUZ3MqtqOw7y9VOb6rqau20m6YdZO1xH5/fAAAgAElEQVRffd/JR82dy4wYRs2yscBve7atZzI2EjNYIwv60MDVJs6qT5wv65Xp1zhGEDdY+EUGHRmIJa8hMYGpRGFi5jwfat6BlMckIuEXjCnT9oqDptnUdSNH13EC/nYpZXmbCBLhkAHyAU0VaWoK4NquGyvv3zizsWde7L5ddJ4Ob+76DVw4UI1RWws486ROI+Q6jSjuiEbRSszpSgBUKTsHxWGQHJkUwQPgtO+sHNN1iolEf8Rl/ZH3WBom6V9Hljrb1ttJRbik/sp75ojf0G+5X61tkHnmqR5nzP/XgGmU52/07/gaznw9Z35XoiTLuZSS1N954b+TgYrKfaL3Rk7hLo002f+I4DwBsH2izJXxnlWXsehY63qeR5s6tfk9dEqmtzc9IOX2KXpBTimfy7q/PI+LDr9eH+pyEUj051zGMqKTVLwoekhL/258h5UB5OCDLyVmTHhIzlEnAWgU6T09Dtq35CMQJzzWCDNbIlHuaU972tOePiLyrkHrF2jCAuQCJMQxIbEYiIlL2EBiVd6QsjO1QUk5FkdO0zklDIPktmWNbGAMlEUosfy7zplnp5rLjXlKXDGlDOOMTMA25WAd1tDAJoxUGYwLA7oho1oYY6fPyVEwKP9lgb5SKtr7HIXCyPv6PqgiRUOjKvDEFNGiqGI4NboLYCMWJSpbeitRKCSGMq9jJZWRKcnKcYdFewAXigJamGCAkxh7GQFNW/LgFsW6FJ5rThQmVEUkEDTS7KhfiUgdBVQjlBUjprAq4BcqmlLrgiI3cFGU6005rGe5nuB8Yz2b+16Yd1OuSTtgFOo4gZMoB1mFcTGAc5bULLRtrSgwoaD2rJqCZ2plnZTdFQkQY2F9t9BeC1S7BZ/Zs6Z7YsJ4mNjYkzb0jrBsGnAQg1tKjEHD2DM5MA+q49ExoYNzmxGCsxAzLc9UcXYe1QrabcoI2vJdj5yjwxgrgGX+ey9eEGbEoYnSEll0rF7LY0E5+AAfdL4TcsolNkOgzqup0Dw2XOkaqBUpbcqoPTZrUJfTfPCmNChjv4xR52slF0ro46ys0Pe74iWSheXqnVOltT1i6pVqzyivKClhyjFZ6wWg5Uub2vmZfrR6l3Fig7NodOvhxsyAY1V2iIpVYuNoOxEhK26ZwEkj6iiYMWFA5AjAIZmXNifEIeK9NzpwFMCMIwHMhOBw/8Yp7l5pcOdqwK2rAsi8c/suYhzgHdB3a/TdGW5fW6Jbr/HmW2u88yPCWdcgMiNGj9NbDge4j/v3j/He9Z8cUELsGde+P4B8RM/iUeg8MERgvQbOVsCiTXAnK6zXA9qGcXgo+cM/eL/DydNnOHvvHogI9+6d4P7xCut+QNdHdH1U4KhFoSNcvupx+apDNM/fpGBFIgWcOkRNBVNI+h8AzDqg266MEzOI2FXVWm8rtAByY6UO1P1TBzBng0ZRiClStVIIirebRbgjMIY+4cY1aUcpmIdvHJ77TAT8ANc4LJoFlssB3p3h+WevwHGHbnWMZbPEX377Pt747hrvXmcMEQjEiEWPtadPEN1+z+GNVzwYwGrNWK3EA7Rte/iGEILwajEBfe/QdR7OJU0/B4AKYObKzzksjjT8OaMaj7YOF/51ouGeVfqXPYrV87rsSWCAGzUcxgjXDyByGMgZUl5SCzgPF0uYdwJl1lCMjhEcUxWCXr575ZVijBJS3fkcflvurcvIYO4Rk/Gag3ooDnChhWeABw9CROtb+KZBjIyzs9PMY68rEIfzQee7pB2Ek2hs3Mg+kSr+vYQKr/bCGZ4QzGBNg2CG0URAr+HbiQjwDZzjzJ8mkl2VWYB2gShH3LSIlDWAHxBwa0yDtONozXIw6cl7iXwmUT4NfFHqUI+MYN6rJlclW9dEqe2cF/AWmRzAMFHCDBAttxiGHuvVGnCM1lI6OgvLXxlwKrCByVy2jg4amn0YBoTgEQdNNaDg/WHosF6vcnlzj1yU7XxYUkZl52vUcD2ZdcIzVwbGmvKuMR1bhdsCUDaSep/Kv6vniFG/kpurstffc2pUXS5GWM6Z9+Ry0biC+RgVKdr2RsptVsnmtt1VhiUz2NTPmxr8eGIyz8bYavwXL29nXTErIxg/adE7xnVEbj8zQGdZVi+oo8tkMEwyvqNq54olmKMyJipZgedvq6FGo2U+y9+iOzADYz0uWGXtGvhn8msNstklh24DxUzP7zJWzwFg6uOpSg+e1ysUfq3IYWNwlfekzkbDOCKAlqdef4qxsvZcL9EIanLOzhcHk7n6ztTUtk+g1hVNn6+L6Bi0jRwtFFbTev23NXzyO8+lql/HMuQYaFQDJoG0UQ/mAvo0YNKUpGyyX2oIkw29weSpm+I1jXkQe/dokXnItX03vzN33ucyZbmSxuUYgVxsLFKqbxgVeduMmR7faH9tq5T1XLrGKZBmXJYi7xv4kZxHaFr40CC4Ju+5KSW4FKtxbTo7TYEULUVoiYKRU2XrnlTvA6xl04BneS+wNc1S7hj/6jQV8hgcIw56Je2WteCuNWf7WmTtNb8O7b5v27Pqz5p26+7mFBsoe+NokEi7OS8RGI2/8tUeZHteSgmgpGuW8lPOZX2W/ZluJ8aYedii29Rxmko/2TEBPQgYegzSLxEW5wAb5/8ef9pethuMtH0v2d72ZQzZ/le2VwajpPmJSfgTk6PKvqr7MvnRc6hmKmw+wkAgUqe8R49LPGmL3YvaXFtu2z/PfY5WrazNqvObewyX8zXVe8y07clB0rlTymtAYksHrntPBGI2KEDbsMyrXLIc9rpcR/oO45fOT0W1p4vSHjDzKLRPybSnPe1pTz9VdPuDOzi+d4aABuRbwHkwkyifmUDEaiIURW5S5Y8ZZgGoskJDPCbxjo9Djzh0GLqVhNXUNDuOzIglRmnLs2toeYuoAhJoBktmZ3m+atSEoUUW2GGMtRaJAMB5+EpBZgr6LJFomZMy95ENiKEgirpuQOUBPmFWUcJCGhUFmnwME2uVKRliBLIqbRqKkcQxACgKS+/DxruQy8rTg2A4xEiIYuutmGqAWUE0TlHfmdEVsaEwqip4oShSaqFGhDef60oJVQlVqZISOImXSRpMoS5pqCzrSg3DiEiAei+LpChehJbXNOe1djV4QD1u0qAetpzVUWI8kLo5ENi8aaIAu8Qbdto+Y4VDSRWwqRgr90idi7KVZ7plt3A0VhKdp8TJ+gf7LysritJ8Mk9jwjBEdCkhBI9Fu0CzEKVJ13UASV7eSnWovYj8nKmCui7fvLgmAtMuTdGsKm2LsLxbiL4YjZ9BaJslFu3BBe8rY46rtc/CizYhSJ5oIiCJ532KRTEZyQAd9lkp0mwNopKr3RQk7BhmdDSvI0DGvffjaF+Agflk9XaOcpSpnFqPCDTpyuyB80CKyDLXxs+SkZM0XYs9eJpzOUesMcV3svGG0fwZifTWNqOyqiKjMrLJ8xnAAO8TPvPSp9A2LRwMxMhAklQjfdeBk8NycRlghy4OOF2d4HR9glUfwexwdOkSDg4WaDxwevcM3/l3b+P0eIpGiADu6N+bsy1W2urt6uiV0TVvAfj211+bvf+TTH3v8Z1vvXDudddesTQ9A4AT/e5Q2u5i9A9+o8EzX/Do+k6ApXyAszVh1SVEDiDXIqYBCdFUxqp38XnNBgTMmY34XMJWm8KZqugJIRAWywXatpHQ4sOQjdjr9RqnZ2cAA0dHR2ibBjFGrFZrDMOAZ599BiDg/v0TnJ2diWcgPDj2CMQIB0t894+OsTotRqyDI8JXvrxEWA7wwePyUw7PPdXi1o1reDsk3Lr1AW5cv4HGXcb/+j9fx/G9iOl42tM8baxbD3nNw9D1a5dw/dqlHVfUb4r6Nxe5Bnj5txe40i5ApBE/8touvEgxcNEIXDlNNzp+r8wXht88BVmBnfdoKcD5Bl7TN9qmZQBvAMoHxgyyicOQQ2/b+m8GFpDIEUPs1aO5Nsg4ONIUKaxp39KgiliIh2jTwHODQAQfY0kp6Rw4JXTrM8ShAyBpPdfdfRA5eN/In3PwvgX5AEcBPgQ0bYvQeDARYkoYFLwBSDniEBFTBYABZf62gpjMtjBbazrAhVafKX+kimBy5t0r4FhOnI3AgBhUHDl4lv636DDS18o7OwcfAoJvNBqj8b6QZ1q/kvAh3rksI82NkQJgYN2LxfhuUlHiKLJO3yAN0tbBt1ne4BQlBaLxO7EYH6ZGZ2a5X0K4B9DCi2e9rturFaHvO2Rv3jJIL0a882fdS+OjNL52dv2oeLnqaDY0luto9AkUGcDaOhskGbmd6vtnjQYV34qZ60fgqsrowQw4Sy1b/UfQaJ5mbMmGUh61gRn+a0Nq4pT5tmz0t/JoFEwz4BZHi1LGjegGo2qq8bAyHpMr95ToRVAIWTF4aWtLuSxtTe4pSNqYuu2q93J9cT4oOot6fX2YfaOup71zLiWJUElnnbsbADzBcTmY65G7jPW7gipiqub9WBaWiphzU9GZZPlw5A1bg/awfS1hkzKp6F9qHj+cI5NUYyjPUydp4QDGMET0fS/RJKsy5ci/qAynChRhTgihOOoU4zHnuVfemBUAuo+MHRvy3B+NV9Vr5BKX+hsoou5I0nrWg6gGuswZTfN81vpE3Qvrtcj6nxPn/rE2qF+Wr2MuAR6zPoira2aIRjWzRht/Gd1cz8c0NpZWmxTzROeQ22xCXH/wjoJWRR7N9eqhk+db9UdrCFnZ7YrN8Tmryxt9Wp1HA222fOP3j0tXHN9s/wKaIM6RRF75Mk3JHgw8ZnJQAcAaIEO+C9iCU1TQZ1lXWfW0JjdpaHHhL1id4SxtkAKGG42OYgZ10/cyA4nM8Wcs6+fnY747zwP5XeTYRemBgAoYj4ZJISrnQOgCCyRo1MMIMA8w5z0fFNSd54nqVnyJShN8k6PBG2jUwJBxiIixjnjqsq681veaXnIaqazcR/n8fLWm4L/5tj4PWHNR2tWX9Vopv8uYtYUtbYyz8fwvAJnz2cvRNK324Ael8+r0IPfmdYnreVQqQyBxkDa0G/R6lLFr7bgNNGa/fXAze1LZF8vTyyIt/BnlM+Ve5HvKblnLVQ8/h/c0pj1g5hGIk5PQ/I/xeXva0572tKePj/74G1/Ht195A5efegocGRQTyDl4Eo9O5y3HJ6Pr1ohDDyZG7JOEhM+KhGGkvAVEwXR0dCkLU8yUwR8mvhkLJk6dhUFiYpBX0EsSj3Jj4C1vbm0YlWeq5pJIjMX6rkTIUUmgHmvZ0y0bz6BKF1M6ADWjls9QraRUgXikaDmfzHNizCyeR7uvsPCI42NATgxNhXG3KCwSBYg3FKwWonVUx0pwKAoVFWiThLQ0IEtWmpvSAAlRx0eMg0YpIizaBbx3uS/EgyJkBaN3Dcj5rFR2GrJdImBEJJY0VublYmPJaUSbmBLiMGRPHEcOpAaRYegxDGLwYGaEplGQgykMSjScMUiofE+JK++zIjQ4V4+hB6NtHna7aKow3wbKsboMw4B1t0JoAvrYgdaSezampPlmRZkjivCAsZ6PNp57XnllqFA21tWRSBJDUxLotZA5yTDd4GYY3jFQiUfngPmcvhch5tyLpb4byuqx4CxdLVFSAEnvM8ReI1RE5JRDbEonDxdaEMy7u2qLpKnCXPF8LAKiRA2Qtc3y/sq66g2g48ZtH3zQiF+l/6slthgrrLFhQmu1ntZVzvLsTJhubB8Ptl7X/Vi8HCkHpDJldKmxCO2mNBJcnwNzp+91sIhogBh1uz6i66LUmVj2L0pwNOCJgwb//T//R7hyeQlHEQERgRgUHe7fO8X16+9hSIyff/nLWK9XePe9m/jBG2/grWt3cbbqwHD46le/gF94+edx9ZkruPb2Pfzxv/79GcDM+TReNfb0KPT8Uwm//NkBp+tTJALc4km8dyviresnuH/KWMcF4BdwPoghnEj4HDCG5ND3YjprgkOKA4YYARYAnGNGCIRgubY9sFgATz3d4nOf/xSee+4KTs9Ocf/eMY4OjxCHiJs338MbP7oF7zx+8Re/hKvPXMX9+yd44423cOP6h/jHv/s1eOfxV3/9XXz/+7dxqb2Cw8Ul9Os1Lh22+MJnP4//8IffxOp0nevYBI9f+vLzePqZJbq+w5Url/Fbv/VreOOt63j9zXfw1o9u4Y03T9GdRXTdPnzrg9B0Ll5kTl503j6cuvfhKPYOw9pptDSHmCJ8iPDB9inGuhvgNLqID8JPDb2luUQ2HgJFOSmssFNncV35K6MVQICXKFvU6spNwsOPjDWVcY85IcUBMZlhRMLHr7sVVqsznJ6eYrVagZnxxBNPVKmaCgjeK7vvnENMxquyacBzuzg4kONR5Il2cQCOScCSMWK1XoNTQlQ+hV1CTGtQ7IRnGTwWvEDDCzjfIIHAnEYRCqKXqGPGz9YKXUCiSVr9Exugs6RqBQgheISmUeNyyp783oXKfib9Ju9SQBE5hEZUnK2XZwSLdOck8p0ZQ2qgqvEYjhgp9aXdlM8QMIrs+NMoBEACKIIxZHmi7yP6YQCY4eEQmhYpMfpukHYkh9XqDMPQw7ySBWQESCRCASqGRozdFokUTIjsNTJ1ArkEckBMawEsJkaKwKI9BLNDipD0EhgASnDsZCxSBc1XvseMm4UnKqelE8WwkN1u62folbUif2I2qM4XcNKYj7bH0sZnbdwhkrRdAGXv7133bIBKTLZB4aPrOTFHpEY34b/cZOzMG0jm6lSTydapApLURlkyw15lNMwgb1CORGCSwjQCiPG5NcChUBq1X75nXEKVJ4tJWzyhKzOn6gCm4Kk5elhD7HmyzrwBUqOnjvQXlIG+5Zw+j8egJgDiqdNsvgPQ/oGmirLzo0sYBq4cO9gYWLOWJSuqjWf1PLR10k3BZvl1VsUZI3RCjMWRwfsFiJY6Nury1fUklf2ha1G15qnsL+tRmUdyTkuv80LmRplfzmQd3QctXbids5TkBeBizVLrFVxOGT5uurLHpDSVl5Ou3yrrNZwdEvJeqWRgGnE8KqBFq199fV4zSOQ2i1KRO4WMl6j2DdPQMFCimDBIeW1YWes0fNrmpkOwsZIBT5hEbNCxRrVOi0v/kZVkZmxPDemjc+dxclSP69qRowZDbuoqRg+wtQm27RBY05VbPWzNydFtRlF8lOPIU9IUGpR1G6zXMsx5UW41kGlO284OXVdSzpY0SgRwBMdBnNpY2podAOUBCOIMF5wHMSFFicLJThz0pLoOLgSQV/2ScznlXZLGslYEc1R9pOkWNyM123yWW40H/Wik6+m4Ofe9Om+qA5PnUa5v0dmyOFjGVNYOYrgISQ9agUQlep/L/SXpmYR/jpHALClSHRGapkXTLJCBkqobzk6p1XGr25yOUcq4GZHsIiCZcdPUa9c2oPbFn3dROu9ZDwvc+TjoPP2oXeN17oEKgEV0voDo4yzKbllH5P/tbbXtfdhY+8t4EiCeXEPKZzqnQDBKmUdXrkOfV9tPnGZEqIFOe3pU2gNmHoUYjznCzON71J72tKc97enBifsTrE/exymt4FwDUIBzASb/tosF2kUj13ISYIsLWCxUccdVnnn1uiy5nblowtQI7aiwPFlFYgK5lSlrhqHCl0O9YdRKjm0MPHF+CiiJclfC2dYIeVNkmnYPIDLFvBqFR8ZyvSuZQqMINMDDMPCPbxOcY+hjFAN8VKHHFK7Wbo2G1J8qXYvXFUahiaeKhhKWVbwUHBjBEWIcJBWXehoTEdp2Id6vzRJEHgQH5xp9Z0LkAetVj344waJtIF4QPZJ67OaUM47U+9dnYc7CtA/DgMPDQzXQC2AreHFNq8FVXX8GZgFpOTsPRmJV6rsa9GIKGevbqeJuKuw+el9uo+1K7YspBzKgJHgs/WEW3BkS7YjhJNISlfmHURoTUaTMeRI47ZM6vHUJ90ogChuh1AERe0yRCjXGmVLL+tueX/d3LcBP22cqLNZAr21EisjYnO0oivpJqHcbUwZ0sTtZBTzv599HqnTWFgXzprJBDFCWY1g8qpvQCKjMeTGsBQHJpJy2LuV2TykhurGX46YAa/PdPG+lfyxyTb5yImhPz1cnt7bvlJylQzOlOBHgG8A7NeyIAY9jj0XrAR6Qhg6eGIQgaxevEdMZ2pbwc59+Hr/0S1/FN/7tDfzB731vbATXNd67Hq/8ye/naFF1bLAUWSKhMdC2fwFm+d31Pfp+yG3QLr6FRfsKvHcY+oQPbz1aqqQfpxj00agLP3768z+L+Pa3AOaljGq6j6dfdLjy0gLOEQ4bh8uXCUdHwNVnLuHzn/8MYrfCyf37+Pq//wDf+hOJZmNGsqkGPhvnir4e3p+gae6O9iGnhg7xZpY96M//4DV4/zpSSuj7AcMQ8Z0/+WOACKvVGl2X4Og2iO4CqphumvdxfG8cReT4fsS/+hfvwDtSA/q7WB68gb7v0Q8D1mtJWcW8Qr/eC9efFNo1Bx93L7357RXe/rv1aE/82u80uPS8Q9c7dGeEV/50jX61wqe/usCLLx+AWSPKMcOikUnBx6BoZsbQD2jaBk1owQD6vkfTtABIUxsRQhA1W0oRMfUYp0Gz/dj+PALEGC9zqEFoPdq2wXK5QNd1WK/XWK/XsDSuzBEx9tlgb3uxd6EY2OyfetR730yirRAoiIzACuImF7IRz/hc5yiH+yaSPbobegHbmfduCJUMoukKYPwBRsYGd9DCPLcpRTE4pYjV6hRd1yFxxKJt8OzVZ4Rf9poml0JOF6mdA9I2tz8Dpjpn/BiNjMwjwzaZtMUSAYY1lgAX8NKcjLVJZkg1hbekST0IyG1I5BC7DhERiSJ8CFiEJZZYAsZDqVLe3hdjxNBLiq2oinROCUN/ihgHiV6aBhBxAZCwjD/nGxBUviAPeA/WtFaZcn/ymGch5UelwWBscBYky0dlIEfu73GkisJfFaAyjeZUVZwNQ8Mc4IWI8ljKUQm5hMG36wwwbmXKxmUvzgZzfHKdgsc5hxBCcZxQR4JplJYcGcp4+SzrS/SWubD+jEmEwYk8ZdFnyEl0IzPK143PHJFBFQBi3ZYz75tbaHdBXQofMH+ufka+/iEFv+m8mj6nXj/sepvreseG/CDn3chxwOSm8h5bgysj2BRAYOmwMuDBvpshmyfjVsszPlDKvqMd6veMrrVJdoHmnfaorE0JKdX9VJ3P86wAQFjrJzJRo3tiPac3Cz7qs9FXHoPR2KLgAiCVlQWZk99b7zX5sXkKKDhsOrGq385PW9lkNV+WsUkb2NiZG4sl4mLhA4goR6yw9brv+yIXZ1WJjCmLWmPz2p5t+oGUEqBR5CTCicn5KUe0zlWlajEg2cMTW8pjzgNnZHjHJoiIJ204BlvMz8MHJVkrt5kd58aUnxzL7kX1UwsYJg8Mm3Na9vHkyV/zNdU9th9JV4kDnfV7r9ECbd7EmADnQdSC/AF865D6tfBjSfbio8MlWCPXEEl9+l7SZDKMH2RNu1lHLeTMD2jjjXiCNPQbLbiZHr1EE/8opd9taWC2g6/m7nXV2CtrqUUGbILLkcDl2ah4YI0c6JyAhNn2BBlBBkQaeND5LP3tg0fTKG+ZEmLqMAw9ZP3zo/lucq7VawqIcZVOdo53nPI3F9kvd+k1d91/3rMf5pk/STTW0W/qR/UX8rrBhR+dgmGnffWgoKfyvYxb4YNrHpU01dh47Y3mbJH5RMrAU+9dBvw5IqzX6mAxrLCnx0N7wMyj0D4l0572tKc9/VQRBYewbLE4ugRHB2CWKB8iyPYgz4g8AEyiiCTJgy6Kr2EjdKMobMchbouinCBCIVcMN3JakDETLgwd1UKViYqJi1fgnIqMRalQ1MJjBh6uDvZXMYXM4tWhggpQlDDbeOldwtkD2I9/PKRKckKC0/qlvnh21mK5pXhxTlIWJQOosGK5VRlqHkhyc/F+mTLjjjzYufxcMfI3qmQhpJgQ41qV+mKoESWteJaK0kjTSVlPkoypQQ0NtSdJichRKccU7FNTyYXMk/IWxlx0pTYoMbn2gTrgIe/b8rStAt15A402frksjM7cO5q343Yyo5BZE2RYmSeShdY3L6UEMcgVhZx4wbiRIGVgDVKDczagxB6pj2AkDS8rRhBTCNfrzlz5yQBtRCPF/nwLjYXzbd9zzm4T7lT5Y9/N+DgVMnMKJJAqk8bvS5yq8yWsvs0fCysvnrbIf6bsqmtic8GZsaEsp5VCrgb7kS4V5n27TUk5pul43CVMz50THZlT49+AS4cOjB4Hhy0++9Jz+PKXPoVv/c238MJzz+DSpSXisEbfrfDCs5/Ca6+9ilsf3pG9iRK60zfx5MFnsQyM1fE25Sbj5O5FUv2c7Dh3pn+ffJrbHX8a6fRE/kptIz77FYdf/qoHIQK8xsFBj8OjFsuDE3RnP8TVZ1/AU08vcXQYsDqOO55uNF1kEiSV1G46xnrj2Mm948kRS7VjtKkcTolx6/1+cs2ccmgfXeZhqbJPfST0oO85j5vozqb7NbBetRj6BuAGDgHrk1OsTxO++NmX8Fu//XN49ftv48MP76HveyD1aBuH5597Cr/7O1/DpaMWjsQD3CvvZ56srCAG5wIiM4bIwg3qxhQT4+7JCteu38Lrr/8I9+6d4PS0Q98l9QaUvTwliTwpe7RH2ywRfIvl8kijtCV0fa8KfQnjP/R94V+ZMcQefb+SPVG4GwU8B4Qg6dCSGovJPBmd8rVswJoyt8xQAHmSGpsY67gGXCc9Rw7OezShRQiNAmc8miDykXnXG48lIo2BbFM2hKcUMbQDDqJEppFUtYcg18D5oNE0xkAFMV5FBFci8Qmbo56iAKD9VgbOvFF3/LPw2ZaOwyIU2Pfs/a8NxRrF0Qw4BRxS9vxhGJAG6bOIJKm0YHIiaRqekEHqHozQBqxXK3TrFfpB+3/QPqSA0LQVWMmAXpT5CVO05za38lb1dr7iYSoDg1P+thgRxrLkCd0AACAASURBVMabHLFPbsj3FRZnvJKMWB8TnbQs9uyNyU3j8prnby5HHe2l4l0zv0smzxVe2/sAcha1p0S9kGJxNlo22q4GQDMes8hIcsxlozOX48XeOcvzidF80iAofHyxh5thb9NotsF37lgYt6+xvNHkc++YfgKlXmM9xhgIVF9rIKQpAAoYA13sepGRpfQCLDcYVwRzj7aJ+I3f/AI+/7kXcOlooRE6RGa9d9LjBz+8ge+/9g5uf3gXMTHa0FYyl0VQMQOzGuWZQOjgXILzouERHAOBkwcgYCtJ36GyOCWkHNGm2nsuYLDckGV/DMbKKTBs7vwUkEZkq4fNSR3/9lUulA9AEXbl+aPxoovz5hiy5zGQYn5P1j0Q1FW+rN/j1tm6gM/XEwBRDbqSo9l46V0WFqz+0Fk+hxOZGsGZGcvlsjx8ZjmbUg3SS7aHcJlTNaDG3rkxB4kBTjktosm4dWQ2sB22NOMGriyOcYDK0trJUrY4mt8XqtRGQ+2q//xF1ifT6zYBTRN9m32bKePWlY4YkROyzMBFn+GcQ+slNaQ5ClkKPkmn2SNxgqceYHFsG9Ia62GlaS9Zo+1GpASEpkWzWEIc4bRiZE6JyHNFVjGtmyPRIarpNu+bXKUOq45Z/cscfnx0EaDAxZ9l/9VU+A/RnUH2QJZU5ilBHLqcR/AB3rdomlb5nZKuk1IEWBwVnToX2j5vPJrXaIOWpj6nsM8sk6WgLyDCKXhiThe5DQizDWz2SQGofFLK8eOi8/R3u/rU7n+Q8b9rv9Vvo+iEJhPZ97y/oPDHZqexcNQiPxIoKcAUDr6RKMJ7ejy0b8lHIE6PFzDD6WdBlbunPe1pT59cciGgWS6xODgC4QDr1YCY5LgnQuJYhYtVBbLK8kX5O8coV8o0BcCIp19hnmvmCJgoJSuFcomgwBvXZUG2UtAZs6UvUYGMDPkxVj5qPRInjUpjYT8NDLBb6YYND5DqLF9U0KoVrLOa0+qq7cz9tjc5wGLybygCzCvSAi2DAVbvYO99FsSctZcjIAGJIzgxBo1iY23KGcBSe96Kkm4YhlH/MrNEdVchWryBNd+xCY1V5WqhbeChKCHtEiIMsQcGZAZbPJsmnrZbWm8kZvP43INrS4zGaP9ZZeEjUgGYzdPcECQNaTnyyptq9lHmU1beT5Q2RMXzTAIK1YCS4vUDEs/RxBEp9qX/SfJpO1XkizLdBDhJaZTV9swQp2CfQ15L0SYK6jReI/In5hRPGN1bf9+4vzpmyhoDD+Xx5Tbnshl1zCMeMGUEqnZC9ak9ZPMne9Lb85CVHVYW+RzXx/S9ZR7urrOR27FmTY0FtUfY6C6u7wFuvdNjfTJWnHACnng24fKzCYdHDX7nt38RhIjvfed9/OBv7yJ+uMQbf7/CnaePcXg4IKUBfd/h/Sv38MYbK9y9m8AgRCaszlZYffgmXv/eg6dH+mmm3SvDTy/deZ/x5t9HcBqQUoT3ERKMYMCq63HlWTFOv/nDnwzw054+OvqkzpmH4UJu/Cji3oe9GDhjROzlCe9fW+HV/3gXb7x5jHv3zxCHAZwimkA4vRHw3cWHODxohO9jRu24PvZnJsQkBoxUARUSA8dnPW6+fxfX3j7B8ckZVmc9+oHx4mefxu/+11/Buo84Pl5jrSCaoU94+60b6LuR2QSL5QKchEeXNKKDptpUXnDo4D0hNOoVa7IDJ/V858wv5IgNicHEAiQnhvdmyKGcEsbkjxgHMEeQA3wIADmQk/2r7zswIhiN8C+oDOQG2oB8pMij6GxEQAiEdnGovI/TtKEV3+0KsLXwHwUkS8BGahyTuczbuObDpzzNSBbwNGo/AUGn8pdBMwKUsdQdPChQwKVcZ7P7Cc+nDgjK08ekzhXEwj8mlT+4gAq8axEdIzogOQ84hnfCCXrn4UPI7wq+gfdeU1M2uT4xlVSw1t4xSvkt+ob3Y/C2pLr0GbQw5d0BjFIPWx9574HakMdV5AZIvc0Rg9SYVfjG+Zk9MhBrXXMUlwpEZZWrErlkoHVlfRMADZVIiXmCjeQsquoikRtKlEmrSz3/c2Gx8fMCsu+msYZmj4958423PwaqpOvKSF072tTgoxFAZEJmICyRuwjOsXpRS/rWeg4d30o4/rDI0WTplXUtknwngAFmQmBcDvdwerPFwYGkb/MOADkcXPXouggoKFGMyZK61AzjInIwyCWsTxjvvzVoVQYBzDjR1kgKbQE0Li81uPrpBXqOKAM6ARN9jlHdX+Ohsakrehzy8IYcM5HlptdujQqBqRwzh0AoY4V2jMPpey0iSzFCp9EQysAGfpQ2mVlHAIyA1JUsSLpGl2qUCLMEQPzjKlAeEQxYYamdsnTNyGALEGXHF0KlP2CrKUn0L/ayz1aGTqv71NAuIJpqDEPS+XmNPmLtWjvx1aCcGhCFjTFp+gjOc1t0lSbYlzRj0zLZZw2Iso9HHdlWp4voEbddQVv1ivLJtjEDxSEHkHuo4h/y+pHASBLtLfaILIB/ZpYIfFBQjfIPjoK0RfRgF4pOotbLWbG4mro6uEzvRPoJAJ6LTmi0757TFg9DDwOWmS1HxRfNrU82vew7c9nTmQUI5nLqLOFTJMJgAqI6bjErOIzhnPBDxjdkpyvnQBjzKgAykKaUaXdkmHpvrgGj9blPOj1KOXcBTD5JtK2c59V9bt98WDoPvFpfNwcsLucBG5fi+2B1UIdK7zfu2dPD0R4w8wjEjznCDO8jzOxpT3va08dKhCqyiIZljDGhRYO2DaDkkCAehc55UcJpJFmJa04AWUqmkg6Ecy5Ul1MVMKows/b+iSKKqERGSJAoNjH24BQVVyyhpZENz0VQN0R8ZrS4hFam+nrTOZq2gAlOkmRKPmlTFltYXDKFZW40+WBkAUPeVyk95n5XbW5Kb64lxYmycPSg0XM2n0qEmTfZ2woDWnvBee+z4ngqlMckijGnChRWoUuE1IiYpJ+Hvq9ANTYwxiGOzVuoFqjGIZDFENJ1fRVhhsp1rqiUTdFo5SgeGdLPBu4yfW1W4I+0QpS/j4/XYu5cH2zSLqFDcgfP9Ag9btAMbSnd/LXlk0ydhRrRb+pwmx8EDbPMnPm2UnzSa0t42XoOSj8X75VhiEipy6m+AMZAgOMEzxEOTkFTBAenuZQNIMM5zCx4+o6qLYjLnEUR0uoxnse6zcE8ZsbzJadwqCK8MCN7Wcs1Y+/ROYVsfU48tq3ddc1TZWo2Ro6UlHbdpkK6ntdT5d3UqGNpkKziNFHc6NERYEaMZKWna1VxfYwhCnrvHIAID8bhwQJPP/UkgIQf/fV1vPv6Kab0y7/d4gufb/HUk4f4r/7LX0ITHN78uz/HH/7eXwH4kV41jQrzdi6t/DkAT+Bb37y+8fw9/WzS668OeP1V+2XjuQZT3fxoC7SnPT0G2qU1meMBrv+wA9BtHP+bb76Fv/nmW1uedAvf+H++8RCluxi99Nxl/JN/8g9xcrbG29c+wM337+L4eIWTkw43blyXtADKe7MZaRzQ+gaOnKTsiT0MKJzSAQ4ODuB9wDAM6PoV+n6FvpcQ823bogmSuqfvI0AinxAiyAlv0lCDOCQwSzj64D362Ek6AfX0DSozkJe0tc55AIwUEwYMIIoAixHP5fQAsqM7IiAxgg/ZoAhycCEgNBJdkSwtovKNRIJzF7OJtokaXZym8pDGGcsnBEKKccQH1DxJbYQrPL9KaEnSa/R9L6mqTJQyg5oTzowBcJJ0XpLplpGGBO8lVSRqQx8RXCjcg3cKBlBgDzQ9FWtuHSYHcg2CW4CWCyyyfBc1qpFE3EsxSV81DZoQ0LQtFotlkUVT1OhDJV2IgV3ats2fdbsYn2Qy6NgoLPJFkW9LugJJdSsgHVYAmYG6agN4Tp/gQwaHM4qDRjbDZ8NZ4a9rYI+enByr+UOL2MgKehEOjYjFd8JkEDU2lluTRhgsMup01RmDRrbTeYaabUD0ufvH8ukY/P0ohhzOfVPJaibr6HcBGQmYSjz+dSwl3ugfc76RMSDOPs5Lf4h0I7ILa8oZcMLtGwOufe8iUe4Kff+vvw/g+xvHf/E/O8DVTzdwLuDw4BAhtGibBdbrNU5OTjDEXtLTqSxxcrfHD/52V0RFoWd+rsFTPwdEitkwi8QSsUt1ILn5qgikYJNOubqmyBSPSmMg1WQckKxVtjSa4wIRwQef5+V0nOYVcaaQFwX7zBkba33Irnt/HDQPPKPZc+V3gqNB0y95eCeRf2OM6LpeDO5Q25D2smdxODPpl+M4GhmQcor1K888iWeuXNZ3Em7fPsb9+6fo+kHHUANWxx42UIQ5fEEBMZERm7BhvDeZ2KLU5Cg0WhbZYJ2ucjIXOcnYZmYFqlXraU7rV9Zp02cxG3i0itz8GLt2NJZ2jBlbr7Y8ZeaIpo8EgMoZR85JivKiwxzQRe0XOCQOYCYksAB8kYxLEfA1AfAyZgS0IVEHHSKcDzqWZN0UfchMfQz0VPWt8ROm2zO9lWMFPVn4uoegh9pHSKFolY5EVdKqk6W8/tgXW4PKbwMkTQHNNXDAgSGgrxAaaVMIDyYgMoJjp9msVT+axOEVSfW3rDyUtVV2dpXyC6hG5lJMCSkOGvnY2ZaocyvP7jw+8rCcNj+PeVNAn2FKrUeYKPNTwTSaW+6ZvO8ivMw23mTunlq3+0kAzuyq16494UGfteveWvc5bbep/ee85+W+sN/V/7Veck+PTnvAzKNQoscbFWYfYWZPe9rTnj5Win1E6mNO1dM2BIQGPrTwvoFzDCZjbBScAAYQgWgGdwIxASTCUrfuJP9tTLh0eAnkzasqCvhGPU+AMTMFbDLXnjiHOwcAkcTsz6j6bcy/M/ENGWgh79N3qJG8JolW4OF8g+BLlBtmnsmXK+8z505L/zMKsawK7ywQ6rudI1ES61tNfp+ygWOyiBQmcEwY2B28rLV17XkDFE9JngikojAO4CTeoNOHizeBlLlpliMhIQSPGGNRHlbePVMQQf3epmnQNM22CoxahpzfOG+C6kYK74vQufdstkE+s0OISGkTKb9b6JgH2JxLdA5ghsfKaX3VeMyNXqwKaRVsE8zwYYLiltcwj8aCHcsvBKFpPJqmrYpOeXzUxwCIY6WW3ZQJPkzqMUPJ8+zzNu7gSrHBtVJ1xstBDVys7VCHWM8eu8CG8DcHoGEuAK76nVzdY6CVAqIRY4e1hSkMASCEgF7TVIzeVUf+srQK+R2q2N7oS/GXn6U8hlxVbiCxk8g/TLh06QBxfR+Benzxpafxn//ObyENp3jtm9+YBcz8w699Ff/tP/sSbt+5DdevEMkBlDau29PD065dZU972tNPB83N74/OJAf44LBc+rxPTF/e94NE/YgD7tw6RmgcPrh5gle+8ybefOsaTs9WCOEJEHxJJ6gpXOV5JNFKyMG7poBBvEe78JL6h4EYCcPgASxxdLTM+2FKET54kHrlOtKMGsxIiPCN8e8JfUqAS2iXLZaHCzAzuk6AvpTUoGR8ERw4OZBGKyH2ssc7QtCUSk4NgIu2EWMtbA8mEEnEG4m8J+HxvQ+AD2DvMYpiqQxLaZ/qhIkZVNIyTj3us0MDs6ZA9TnaSNedoevW6Lou8/DCk9fpN3zmlxIzumGN9foMQxTDTdu0ODg4RNu0IO9gESfFi13u9SiyFYhAwWNgzrwlgREogQKhcQLAkXKGzF8JMCcUoHHFc3rt7wCPBdrcJhuyZqXEz63IjBQHgFOR1VBkJ2IWJwLvJs+IIOcQXCWfLgKKSp8y0EjeQ5AIE7H0UTkr5Q9TlXWGG+T/50Dh5jww3fdFTh8bKGtAVV2ffCdho43ts3a+qMeZUV2mmieu+f26/afXTWnWEFX3KY1NZVMAef6ejWoGfieAJVWwXEQY4grOAU3r0TQOzBExil7D+wYhtCAAMRajj3MeMXYyrz3gKYHQA80A3wbIsGrhsYRzDRxHpHgGwuPjd4+PP4C/0+Po0iU8c/WzuPL003juuedw48YHeO37d7E+O0XTtmiaBkNKWK8uFpGR4LBwDQ4iQJIfBMkBPRGaRUAfI/qBEZnAFqUACQ4RhKjp4RhwQcAVk34HHt3AuAl8KfO3ltOIaLRWbtsj5wx8c+8aj20uAZkg48B0NnPP/yhp+r659nfO5fnpHSPQKZ5+8ikcHCxwtDyAdw73j09x4+YxhsSICGDXgv0CgncckLjXqBcBfR/hSIClSAMIEcvgAe7wm7/yD/Bf/OPfRPAAEvBHf/Q3+I9/9Qquv3cbcC3IL9D1TlI9epuxEURJtBJE8NQg0CKXf1PW5gyYkTUqou8H4UWiRs+GyPbkXU7zZ/caOFIOyH8FcDDAImbLnLfxYu/eZtTf0UfnXr9lzDzkUJoCCIpKiAAUfRwRwXmpu3eEhoDoIpat6f8s4kwC8YCBe9WHAoOmlHOOsFi0WCwWYIZGftO9bGM+ESyKbqjqZm2f4iRikpwsgJVchwdoiy2dNdXh1W3FNN7PGNU8q8ehHScCUQC5kMeqAGjq6Hol1aTtK845BC9tkrKumRHUWUwcujQ6HGScx2FA351kIJdTfu7g4BDkJKJin3oB9ibbF4GYgH6IGAa5b7FYCK9IAGu0s5g0ipnyGl75ISZWvdP8emzgVFT/PyxwcL53p3zx9CzPnt+2ztu5uWs3dKo/oTQHTN5Vp13AmDkyx1zT9da6SuPl7dyoras5YWWr/4jEWbG64eKV3tO5tAfMPAIxE9I+wsye9rSnPf3UUNsu0YQliIKAIJKEq04xoe9X6qU3IMYB3hPaVoANzhGGfshMTkoSKp3BaBYB7UJDQVo6ERA8EzgSNOF2Icr/ASZwMmdl2AhLMkubgIY0kqd2M4D5Kcw5ckpNRJQVyLXyMCuCVXltiiALBy9GbrUfUMWUDwzHY4GBOcH7oFFJaoac8qeUZVxeUwgYqKeu61yIzG2RL+rnWeqkKdCjBlgQ1ZE9Soj4Eo46jeqxLQRyoY/CSE6Tz0en8+s19/4KVMFUHWeQ2w7OmSMT2mnHXVkhVl3jqISdt74So8R4vNVvkim5HTBzEWDQnPA5BzARpeb5yvP5gtQK2LGXjq1FsEhWVf3qKk+BMLOgsupvc66Mo7yUeyfzEqrcYZvbmhahOi9Hy3/S38U4kGKEJwfni3EGgFim6ma5oGDvUjWmc+on0f5x3f8EwBE8JVw6cHj+uafwC1/9In7vX30Xr37nNv6ieR3/5/9yHYyEDz+YT33z+//79/D//uHriCmhaf4KIMLtD1cXKueeHox2rSp7aWxPeypU1Lo/2bS5i//46Jd//Xn8D//jb+Po0hGc8swpMoCAs/UKf/CHf4zX37gOOryBf/Ev/w8we5ydMvqekdIBHB0gDrZnbvKDUwMfUO3HPiCEBsvlEgcHB8UgphFJJPWOUzmlF1DI0Oe0S9yzeCc7M6YKMCemAeuVeNo2TYO2dRi6NVZnxwCA5eJAjGzsgIEQWSKtdH0PR4R2sUATArqUwI7QxxI9MRtMoKlyvINzAW3bFhBCZIzTXM7TnMJ/zqg7juZZlNTkGE0jhvTDwwKqYAZSLJFBs6HLJThiNP4Ay8Xl6j0ejrSOBBhYSOoDlVMAS30hcoRH162z4YkZGSQjf2GkdK95sCnfVfNWU0DM/OeU3yY1QpX7prJM04SSCsHaPjEosdprZsAbGHuilzKnLXziOYYke4/1EwoQxFc8K9fImQ3z6KZsPAUUGc2BZrY5kdT3jtrIyoPC98+N223jvO6PXEbnkBRYRKj57pwgDiJXAb5Ky9bHJEAZeIA9loslmBNuvXuM1/76nuofxvJ2loGwwuXnFvjir16C8y2iOgJ5F+G9pBMGezTpCTA8EjH6VQdwj+s/6HDzh/dQDIWMYf34VuV3/u4A1189gCPCd5qb8O4DhPAahkGjgqQEogiilegOhou9+/Z7Hb75f90qFnWVRQ6PPP7pf/ciPrh9G7fvrdGngIECEmRsJ0hUYNboOibb1CPxUQyOc/Nmet6usSgjc6C5en2c0nRcjx08JLZKCHLf2987w1uvFvnl5d86xFOfaiCRbkTejkmMyiqdbpTTylEfq9eEXYb9XXJ3LWvPgdNsvyy6iYjDJfDZl57GFz7/Ip67+gzIedy8cRt//uev4MZ7dzH0AFNCjGvAAU0YEEKH2zd6fOfPphGltc6qM/rbP/4b/Mv/6e8zk3J6ssLZao04RIBWADowAy+9vMBLLy+R2GHom6wXcA5wQVKN1WBDA52WtiQsFgX8UQMODLg5DIOmXhy1qP55ELxEjUpRo9Yg6yZjTEhpwCb4w9aX+b7a0lEaU+fi9OPk6cpLuMAckvSkYwVC6bngPEJwaBpCHCQ9ekoCcHIOSKnD2dkKZ2eEpmkVEOokSlBU/gsSQUWimBCABDgDY6YSQdr2n2qf3QStfDQc/K59cO54TBGIwpfCSypyUCzl5qJrJvJgdhgGRoxFvyNBvDTSjurZa7CbIPXESZVckMhmBEQmnJx1VZk8XAgFks2ASwnOJzRNATBM01DO6YdhrLNFZZ4dmNVBlllbxTl6aNrF+5bv22fKTv664n1Z13vR26V8zPix0TPOR799JPSgAJeHpW17zzT6dX19Dbruug7DIBHNFovlLE9pMsDcWDQd9p4eD+0BM49AbMbOx/i8Pe1pT3va08dHKaZKaEzoh4jgAefFs9A7L8ygE3Q7gzV8qQcn9cpiY3sB41fq1Z3UVM+UkEwhnZVRJdoCp4QEOe590PDlksIkDmMF+LkKxYeiTUVKPlMxZlMmTS+Ah4P3DA6+yp08oERMKApaSz1VFBibkSnKPQXqIMrkkIU0A/KIt4be8ZDtYvWZKlVKmwDbhNA5hnhcj08CfRLMYNa2+rNqrnGfP8jzSohXwhjsQY6yl1QxjjgsFq3OrYSzsxXu378H7wmL5RJN0+SQuWZoGgYxNLHN9cpgwZUCYy6KUJ1H/PDwEABGIK8NzwK7V6eNcy6P+TmF/oaC35mCsLSrlEvayoxU9mwz7piRbk6ZuuuvrusuxaaVadeUmJ7LPxmiULKlYHodaUo0zM+52fadO0ZAGkV4UcWYze/UgzDAO6BtPEIgXH6yxRc/9zx+/Ve+gheefwp/0LyGk7sJJ+hweyYdSE13bq9x5/Z65zV7+vHTthXn414t97Snj4s+CdzC46apEf9x0nLR4NmrT2Ld9bj2zrt45/qHuHN/jcQSWePeOqI5OkLPwI33zmQPZgFUeKKy91XGjqlSNddjpJhWgIIeC0HSKtV7cB0tUgAYA1JycDDvWEbfJ/Bg72PENIBZUpMGH/JzGATyAppY9T08c07j5H2D9iDAL4ynIfRJDUL9Gl69hYkkAg3IoW0XCJrywvsAx+KMwCA4n+AsCgwKT3KeYdd+z/HjG/s+STuvVqcAJPJMaCT91XotKY0seo93HiE0aFtxiGAuKRNEfhLequa5zIu6AFwSun6tIBmJnBdCMwIfW10skkydPtbGRf1p38f8WETiCAv6EmOnRrwBBOF1vQuQKEYyFpkJMUqZxPhaPGIFeOUzmGg2YqYZUGYYvbqsU57X5Lf6mVPwz+jTZOotfTl9n927jTfc1p5239yzppFi5q6bRntgFtD19FlTmgM+bOXLOYEcSyqpNMBTRPAD7t65hTis8eSlBS4/eQBHCU0T8JUvfxlhcYAhEZ6+fBWnJx2uvf0unCPcXAR8+08+3CjPlH7+K0/in/83v4FVx3j9R+/i2jvv486dU/Sd15RWCc6t4TwAYsR0hjh0ODsFTu89PsfTKfWr+tmD/k356wdf+ePAOLm3mTYqRcY71+8hwoFwCAcHxAgHVlyDU6ciiRQiMhYX4c5KVAE6aieFWracozkdzfT8RUAwD0K1fgSApN5ixtB3ODtd4+x+aSeRc10BrrFZlamsFTPlmMqP2+Z0TbvO7ZIJN+RnPReTx0l3iB++fYybd97GcvkeAIezVY8PjhlrtIhuALkOR4cJX335izg7vg3iM7w7NPiLe3e3lgcATu6dAZh3pJBGkna8+kTAr37lCOwaPPepl7DuBrz19g28fe0DrHsHRsCOqgMoES8KyGCcKpoooGlExxBj1JSEJfpXHFYaQWXIQGADbATvi+Jz+k6rCsZ9ujn+ZD1PKWZQyIMQGYbtI6KEJBGAK5eePC+cAzUewbcGLVDNC8PFqOpiWw8I7BgCjJG+YEcjsEECBHfEDmQgC+tDfTdQgUNtnn2CaDQ3U5T+YpK1gagqLgHKByXngOgQVefjQgvStGiI4z1wbi8GAO+bjTHH1XiUQ2VtqdeZbXv63PGsQ6t1X5MuYOYRqCQlGQGexuvzBhCnKs+4HvNr5PQZudk1Tac4p/qKHz1PP6Zr9YjPBYj8zvt/6oRHpfPaee76OT59ugYul0sAKI6IPuS1uOYBalmopk+WreEnn/aAmUehBKT0GBn9fdT1Pe1pT3v6WCnGHmno4RgIXkObOi8AGQcwEgI7NOQgubdZsgkR50gqIlRGJK7ALFAhTtPnyDW1chXKPJs4BREcYIYKQoQYiSX3ulwzDENWXO5ikGbFzV14BBUcaMIk2w3eB5EHHDQcuqgsLTVRMdCzyjziVyXMta9eqoVIJmRU2HouYbbJXq9KFQuraSmHamWS/eVQut5Cvj84qEjuKY1Ubi+gGa7apVyzvXE/eYzs4zYVbaNd9eZyiQmF+Q7CtnashV/nJBWOpDmQEPJMQGgakHqXcNIOIwkj7+DgfdBQ+wlEDO8J3quXCmXVDcAEiZqvz+Io3tgwhTmQOGnI44iDgwM0jXhHk/nPqYIqcULiqAIrI6mHjQ9BPYuwYWAwz2YRnjS1gRNgCFkutCy8Vr/dVLi1yFAm7ItPCwj5WUWRtimE2bFtuXaBTWPNruvyNeM3XUjAtvfMeQhOy1s/sFaM6JNUoccbSxM5W9PkL2ZvSAZhwJNHeIB78wAAIABJREFUHp/77Av41PNX8B/+5A386K0zrN8/RvfBTTTt+7j57vH5FdnTTwSdBxoIDfDiV0jWoSGAId6BMfbwnhEcsDpm3Hyr/6iKvKc97ekCNM9lnE9f/MpTeP7FJd65/gFiZAAeDAdeDvjTr/8AZ2cr3Lj5Pt67dQf3z1a6h3vZWNDqgkLFU9aMHSiyAEAj3tZo1nDKwp/oVwCsIAnZtZIBTQkgLw4AnALi0KOPvToBROUvAggpl5EtPRQY/dAhDhLqHgp6TyBgSGBPaJoF2nYB5wMcJ6Qoe2xihvMRLhYgickQgITAT2kADRFNI4CVqOmKNNchoGH7pd3cLLvAmY2a50OmUQaqOyEpgsx66CFpAxx80OeSRDzwXsA03nvhNwGAKcsyuV8rOaTmweR16nVOUEV4nS5FolZGNazJcYma4s04YX6+ucLKryLJJwG334o4u6epldQQF2NfvN5BaJeEZz/TYnkp5AYkjggu4e4HEbffE6/2YZCIBVbG0Dg8+/kWvvEKvHY6Xvvc5qMmVhaLcromaSVL+2R859SoUBsWqKo7UQIoqV0wgEnLwaUOpJ7QSY1xDBp5kY/HzdiQOzWIbGByKgOv8dS1nFieNb7Hnj2N4DouS/1ZIpdm+VwrUPj/BMQO9+8eY3V2gqYhvPTSC3j5S1/Cv/nfPsTJ/Yi7hxG3j3oQEkKTwMfHaBYDEjs8+YTH6qzDO+/cgXMOx3cvJqvGmHByssLJWUTXJUiqsgbOA4kISD3aBaNbJ1x7dYU+9kjDgOMPbbx8MujwCeC5zzgkbnQtF7K5bl70NmhotPAQfEP48KQXmVOj6VjaC4u0JBGFTbB0Mu51PbF3AeMx8qCAltpwOQVT1vOnnk9zDg0XobqMMv6d6oEIT15t8dLLJeXw8igASUFDdRvuoE0D97idLlK2+veD0Hi/aLDuDvD+BwNu3rqTyw8iBOfx3rUBp/c6OOqxXCaEs2OcnZwBqcft9zfBVQ9LH9wY8L2/PUVoA9rFHURIekdZ+IvGcJZ07NoYTmq0B5WxUjv6TMeGrVVRIR9EQZ2IGD74UfS0/B7V4+HctW667kJSjOice5D+3xDvf4zE0Eizoyavxg1I+BXHo14hcN6LR0c55pDg2wAIrDyPvSlHZho9fapbeVC9I8+24blziObn27b7HKluWJWpiav1EixRCjMAptTLxV7SfirflRLDkejGvPcIPkgqT1Rjiwo/trPmU1BMdjBj0LRZDLSUtzHj/0YXjfiG8VhHXjf17nzc6kzKf9uzsh682ovAKAAqu9zKypyvN1GAEstaPAXM8Lh8WvpxgJgZWaTeUzbH67j+mJz9aaCL7i288aXwi7mfiWQcO7GVMJvNIwKcdC1lQNO81TNc0pF5SNSwx7fv/KzTHjDzCLRPybSnPe1pTz9dRKyhtUODZXMZib3kJuY1IneQhMwsimT2SEziQZWXb4agPxKAqGHFlSFiYWQIJIJqZmh5pDA2ZtOR6FWEOYIwPynCOxqlTzFhYqcBmwp/Jsh2Y9A3w1IDyngxpC5cmxLUw0nT1ci1wrhB72HRiucoHlkBCsDpP9MdmbF+oJjNBFkGsLqo8GFCMDMjQZlGUI60M2dQsPpaSN/zQDPbztn+XCtD7fsIeb9554XfYfTRAmo+amHlvDbiogioFeNbimn9bQKfA0RQYPHQYRDE8cmUNaShhsXA430Akc9hi6MCV5544onRnKqVNJZr2nkHEOec3iag2B9YwW0gmJRtiigfHDycAOwS1BgjwB0Tni2Pcx09aU55OhfJZjqGnNt+zxQAM+eZU/+eeu+cN5+mnjAb5ayEul3Xjp5rCpbJu6ZlGr/fVQaZ8iQ5KfW/dEki/qxWa6zX66zsYoihLzGD1RfMuYhnnl7iK196Ab/xa7+Az730PP79v3kPf/H/vQfgPoA3d9bhwWlbO+9lh4+S6l6YtrxvCF/4WotEhK5vwVjAkUM/rHCwiLh8FHD3etoDZvb0E0c/C6tMzelelD7z80f42n/6BL7zyj2suwRyCyQOiLHDv/vTv4N5/jIBTAEgw31olA7lw60EhdMm+4KsNJ3ZT+c8THcalZT/D7UXeAjoPaEnAfyCgeAbSa2hW+0QJVIEc1KwxQBOETGK/BKaBi4IooScGBGD9yLfVEb9zBU1QZ9Nud1TSlj3XebRJCXSoYJqHEDiiIBkEVZIeKjIlfwzb4K9uJFE+JzF4hKgQBd7dtu2aJpNQ0H9bEd16kq7RtOK5DdISyROICS0TUDbhPy8DU/h3PcybsAS6cWRAbAj1t0KMfbCa1IC+QTfOjShwfuvJ9x+e25kB5gqmCnhytUWiysNhqHDkDqAVzg6CLj5YcSb3+qquVG+LQ4JL3wROLq0xKWjI7TtIbp1RNetcLZa5TE7DOIdS66AnZwZCJxGV8rGocLvTg2ptZwbo0QsJRJwUM8DyDV48tKTeOqJI1xaNli6KHI7EU6HAXdOVrh991TTjrmNCT83Z8YgncoSpdYnM0KZPLhprDSjmPyaSw88T/M8LkbGw3qsDODhFKf3b+H+8X0cHC7gm0/hmec+hfffuoI7Hx5uvOEvv/7ujvdfjG6+dw//97/9NtZ9hAsNEie0rcNLLz6FJy61APdYHhDe+eEpvv6vfwQx6bXnPPWjp8PLDl/4tQacDjAMxcCYmNG2LVKMEycnlL6odBYRDAOMlVSwNoYYINVFpPGaMwWHGG07PqW586N7eYu+ZwY0c55sN/deuUe+++Bx9dPA1U9PC7SFl6iMwtuMsRfR4cyXad6IP3fe3jNbwCTOc04BiUCCdwlHi4RX3jjDjbdK9KLv/tkb55bxYejVV07x6iunaA+Ad++/h8XhEs4v4VwLW5fOGSWwxavmd2o9gJHJ+hbR1hz9mrDMexsrSIdh6cdjTtVU8y021udk/NrJre570YsKD1GvndNx8KCOcI+XlKPh8TFs/OTRGavTFAQ654g/1jGWyMlybvOdcn2tPyVsjAreKGV+gz1423KzfR1igLaDoub1OwogRK2NNp0vIXKSgqoeOlet7+AG0eMxgDhETUUaALTwzmn5LaozZx18yuDcefDM+BiBN3Tz47Fb3zddS7etyXPgsW3PAjYd1FJKo9RQu+69yPvqsu6SJSzVYw2a2cYPl3vGAK5dZRgXaEPNd/49D0GP9jxrg3Jk27gqs4vmpiMKH2BpYItu2SL1hVCcrstfidDoWOTNFGPWTe/p0WkPmHkE4uTAjxMw8zij1expT3va054emELTYLFY4uDgAL5ZYogADQNibxEelFFMAxwRvGvhXCNKSojAWpRYVTqfZGFQJaJDIIA5IoaoimC5ZaoUT5zye5mTRJ1JEYMamdt2rHSqxKRyjIBkygjmHLlGPBqNcZsyjARiQkCoJSj5cIBHgETYkTy69umcKBHIlOTFUqCPccpYGgrfAY7gaACzekVWwqGBbhIrKEhz0VISATwyIwIbgkX9CZxjQLgA7VJEbadN8M6jvO9njeo+mwpmU0CEATlcCGgODhByeFCCg0dwAU2QYyf37+Ls9BhdfwqQCCDtogVcABSkIkJ3Iec8vHcqyGhucyZ4twRpTm+ioNfZu1WpRuIZkNKAIfZgSNoD5zya0MBCmc6BVYqn8XaBeApqqT/te50GCgAWi0WOTGXXTEOyTsPkbwrOEGPBjrH6ION4TpG5i7bNrW1ebMQSkcp7AnkP7+R7jJJ+zzcBL3/xc/ChwbW338U7714HPGGIUNgTwbkIchHeMYg6/Nqvv4x/9Lv/CZZtC4o95lVQD0sfpxJwT9uoaRx8IPRDRL3bEgDnPe7fexLtgQfRAFAPUMJikXBwMODFFw/w9EHAN5r7uuWbWXxiIAGD0whLtqc9fSz0s8aJ1EYkQBS2i2WVDtWU70pvvv0O+NsBEUcYEuCoFQCsY/EqVuMoOIBTGCmvyXhwmIK9cPBEwieMI8Rt7u3bFOZTmu7l9f4eY0QILS5dakGQKC8ms1jZ+r7Tciek0CKEFvEgoUR7AWBKfE2l0HVrNN7//+y92bMtyXXe91uZWbWHM9yhu2/37YvuRgNEA8LIKUialOlBVlgKhmxKYYci/GS/OhwO+x9whN/05gdH6MkKhyeFpAdSlqyBEmkJskWDIAEOaEAA2HP37e7bdz7T3ruqMtMPmVmVu3btfc659/QE7gWcvufsXZWZlZXDWt/6ci1GRYEoaOqaugpRbGpb0Ua3I3OWOWI6RcHVFb4eIUYQk9ptl1JKhX+lTVekVExXiYQUnNat6EvBh3QK5rZEeoknOlsnVxorEgkg6bMAcifnYTrw4L20WVdS5MNwT/I60r739IytS9N7WjIJgreeRVUzXxxhjFCUmkV1zM133+T45D7OVRjj2d2f8tQzT1CUl0B2OQ3yFS9cvap46kk4eFhzf3ZEvagor+5Tlun086pWohRcuVxx/dkJX/7ida4/8ywf3HrIB/dPePWNt5nNF+Dh4YNjDg/vMxlPMWaE9wqLoI0KdiAK6wG7OlaHbICk33tf4LzG+gWz+W2KwvLil/f5pZ97ga984TmeujSlqiochnc+OOQ7f/Ia3/r2v+Ho0GKb6O7sOTuW+mVJzw6OYe/dknMvEKuTg5hsLhM9PiE1V9+51P975Z1I95zDkVjCdy5GQ1EoNJ6nnpry5NOCFXj7gzkv/+1/yKwq0WbTah7XntzZ5SOeEZkjYTjLCl7tvaW2M5AGgPnJAfvTPf79X/k5fu5nPk9ZKJyzfPOfv8Zv/E9vtE1fjYywph96rRxqNniy4AxrRZn0iANrpGhmi0lMCdelQlIQopOiETx9u8un/51i76d1vx3D7RBZb8MNlbmunk1Evrz+/PtkH2667+OQTYSIft/ka0KfiNG/3nu/ZOuu64NVqVBqhpIdnFM4H21Cgf3dEF3yoxQBjFaIWJpmHtIDS0FKB5/ml4i08z5RNpbHLsNeaWjxAe+WSYBKFQH/i+uDdz5E546HhqxtAqEzRqu1NhJxXVzDoUuLHeuXWN8q5rA8t3JcT5CMyOuztaBz0J9hxXt0kUSW8fQYM3EfcCvlt3tocozbNEbz+7r9I+kf3nf7wTJW1JWaj/eONBPQ2JUnlTVrS3isTsfJutVnF630Xav/ZHvf0hX5PpvGYNo7lw9vJWwpjBOJB76yDgKMGkUMOdw3GeklXcx7YbGImEw2F+omjEUh4Hyj0SjoXHG/Sxvd0N7UXzNgfaTlPpaf3w+rOFX/uuX3LDFVaio3tKyP0TVNM1hG6rY0fvoHTDdFfkptbZ8n9Uquk8V2pSdYHYer+1r6N6XfHJR2TPU+zsq9KDl/eWGc5+tdeE+6JRh2dkH3zGkurtok3TP107H6SBZTqqAoioy8GN5LTi5P9eiiQOuPeFP6CZYtYeZxxAve9vM0Pl55W9nKVraylY9PRJWgSxyC+AUh+ouj1KBkBL4Ip0NFoVURIlQo8DYYionpa63F2pB2JT/v2CnzAYCuqopyVLYOa6UVWpk2VQsx3VMyhjwS4NhkiEkbwHGD5SeIj2Gyk3EXCTHrdx0PytH4OV3B3b910xBCtuuQZkqpGF2mibp0ALFbhTo5CFR0BEblWlSItKGUaw3oFDEmVzYTsJ5APDxtny21OlP+jTHt6VCA2WwWy9UxjGwOUC8r9avyaEztTwLw9FHKZvB3fV+c9t068LCfjsxbCzakCLBx3ImHBmEewWCPwpQlZjxBGY02geSiVWTmuy7sfDKbQzSajoSTxlljm+i8qXB2jm+Ck0srzWhUonQkq9hACNPaYKQ7Ca2QTvfz4CVRMzxKPHiHbUK0GtRy2rU+wSbvj2RQJYN9KHpMX1onXirfryGe5H8kkGqDDBF72tsBrwdOVMHaEympEZtWryFx1DgsDmFalDx34wm+/KXP863/+13+yT/4ESLCd37rDxCBumnYu9rwpV8QhBKJJ7HFa/AF+HCS+84HD/n7f/cP+Ht/6xXA88H7x+dq07Ccx3D/s7W+fBLkL/3Vz/ONX7rMb/3OH9F4jdYFSgxCOH1qRiBiwz6fAEsPJ7OCV96w+Mbxjb84YVQa6voEoxVlMQpTycWT8s2Mu+9WvPrdT94p7K38ZMh25VgvuXNg79KI//a//wWevfE07968w8vff4233n3Y2gHFKOxhWmm8BBtAiQ/gfYKXW/0y/eTOc99zjHfOiqGQ2kPEl3BPB7rmROI+2UAptUIILsuSqqpYVAu892ilsCnlZAv6p1P1oXOUaMhSA6TytdbooguF3zjBVjY+lAatEaDQk9bhhHdY19A0DfPZMVW1wHuHMQajPNYUXf+IQlRHvE9UAYm6jzZFq/uLS9aRZKkmM10k8/qkdBLtxHC5SyjqapneIQLKCDqW68VjVUhX4ZzHNx4tmkIM4oMbM5B9GvA2nhUIJJHFoqZpGkxRsLs7xXkB3+BczcnhjFd/F+pFN2N1Ybn+0h3cRKP3L2GPpjz83vM4/xnwnkagUsJDE8K6VycDupes6hnf+kd30EXSWT3eG35k5tRd4IQ4N7oZMj/x/Mu/26DNfUblH2L092hsSIta100bkSPoy2XYG5kDUIyFr/35kmJnB+sE29QxHdiyo6VP6G7bIoLSRSSxCZPRDtad8IMfvc1bb99hMplS6B1cA95rFpVlPq+oKsDplagH6wj5K2S0nvcw2PQdqUgyR0/r3PLdPE0ymFItf0dtvbkTMtf9lz8HhZMx1tmY6gKMGC7tjfj8L81DVCsBrQRNOIWsJKTnsrZBVMlkskfjhMPjQw6O7jOvDqir+xgtTMZj7PFlbr9yfamd45Hm2SfG3L13gMdgdq6yWGh+4x98h3/8z/4EpTyL+Yz79w/5wp8PjvRROaYsJwiGurJobUIqXZGY/jqOMmcxGoxS0TYTnFcoXQBCU9cYXYNfcPOVhpuvbtafv/DziktPG7wrAiHZC4ICJygNOq4ZXnW2U+5Y7JMvlj5rcY74fqLzOx0qyt9dSPNxNofl+nGxLP1DQvk+kH+/yQ48jcR1HtlUT/7dUJ19Z/Om8tP1/XKG7ON07VBdQ8Sbts8IyRYbX1O7CqTm4LbllT9o0BpOjj7a0/zVHL77OyGdn6eOLVztr/FE8Yt/cYoYRV2DtcRDc2lNEvAx+lkixolajqIRGRKpfxrXbQhBhQmEESWCMQVQMBqNWjwPGrwH67uI02Lifupj9NaMBNsyK3xH2GvnW0aOcd7HA4cx2nNac507t0tNfOzBcwz9oL1oUAPEEzmbE36omYlIG8gNaUy7iCvXiAR80xhDICTZwb1xUx0rhJdeo/qEkfxJhj5LdXa4zDJZADqiR9ctSafyvXZK+5nJ8KEwL3VHoEljKa6nSqSj7ERdNCd1KKUpTYgwEwgeEiIlxjq1MmhdRHw4RIdPjZLsfebrxSqJl5XfV4iSIkuH1TosWyK2HVKjp8jzQrcOLRF70lsQQSvdYuchcrVr9x6JD5A0hrA3eWyKhh3L997TNE07nto6M2JOpzsnIlt/nK//LNTpQvQT70JqWqXb9rXPQ7euCF2fp3WoHTsD8mh7V0eCP6sk+yOQAg1FMT6lnC5lYZongXCp0uBKLQm2RkydGyKZC7Wrl/bEpDfkukP6vfN7XCyp6M+ybAkzjyHeC85dHOS0Tcm0la1sZSsfr3gRvCiceJpmEQAcpFXeIBkF4HEB/HS0CiAsAw5FUWQAq7RsaqUUo9EIU2hEiCcwGpomCx9JbhSFPMXOOfCmVTJb5Wn1SZY/XAKIk8K17MxejcjiETEZbSA9G+1pz1BNPFmXSD0+7mehgogshwp9Z+fEdjmsxLsFXEy+qrRZNoTTs8S+F0KRqfgcvEq/13UAoYfAj2S4df2Q9dugPMr+/OjK6pDS/2kg32xq43I/9787W18NAdv5CYVw7tN1xBMVDA/bNNjGYp0LeWFVNERVADeNCWz8ZDRa6wAVnSHBGeNyN0GLUzvCCXJPnuHA41gsFqnR0UjS0QhXIbpTBjuEtmYAX/t5SKck7dyM10owzNo5m4NcAuI7Qhq5kygCVPlpkDVv5EzvY530QeUNV2b5obvxYZSKgF4XbrQ12JOhGt+Gp1s/iL+r/PR4qr4xQDiBV881H7w/Z378Gq/86UNODsPafcxJe1sxhsYqaudwNDhfY7Rmb2cHZz07O5e5f3fB+2++wZuv3X/0ztoatZ8qee+D++y/1zC5NMX7mDotm00un1uJqOpDWPHF3CI4dvZBKY+2E0TpkHPaefAV3tUUY8dibxt1dCvr5ZOvDfxkSGMbfvTaa7x39wNOThrmtmK8a+hUUsH54DNJ+3ICpNev7DlJptO3h8gvp8lpzs/833RdAusT4CoiFIVBxLOoKry3ID4c/PUSbJv4d+LROheJ+9KV2+kp2f4fdRZyB6j34F0k3UT7yhkUip3dgqm3bQjy2jWhTu+x0QZSKpxar5vwt9EGU5iYYjMA0lpF8kw5QhmD0oE8olSX7lIy8jIqROhIPp4QISzZe0EHVJh4itmDb1BqgdaW+eKYhw/v8szTV/n1//jXsI3l27/3bbxz3Hj2GkVZ8qevvsJb79zk3sFDKmdRhWaxWHDJFHz22Wd57rnnGU2m3L3/gFfefJvDkxmihGaumB1dppl3+8GVqyX/9X/5a+xeGWNGE17+7gN+8DvfWnr3Nv6sjIkNHsGTw/4dnY61+ml8xw6OHqQaZ2vLTneGssIgso2isSPE+jjGaJ1h62yJVQK2i25LwboC1UyZHzjmhzVaHWOMiyFWBS+B9JWiq4axvDmixpBzvd8hQ0765duGHSmnze/+9+sODiwRB9DBbiYcYjEx9ay5nKKjpHg3yQ4I89jG+alNQeE9ZrrD7uUC667i3LMIYd04vK243Wtn3Xjun3jmLhwoCv48x6Kec3A4Rwh2mrOay1cvIQJam0AyRGHGyTlMxFE6rEWJwWiNiiTDYBNIxAY81imMGuG9wYxmwIJNUoxGTHbKMH5bX5OgYsSQFIE39XPfSdpfmwdtnchDaO8LFy6/qwGCx+NK7sgd2heGvk/XDDl7lTjwFhdTkTe1RZtgQ3knBNpVWMPDQ8YowYPkrq4N/basIw3152V/P1vnoO5/NkR869c/VA/0DpJ4sDQobUEsztUcH3w8aS+8h9lRbBT5v8uiRfj8Z5/AjArqRnN4WHHzvXtoM2K+qPDeoSMxwEf9JdnUuU8+pBEjc4ZHZFDa30B8i49Iu5YrRBUZSTdz+HqHdz6SQtzKe7AxrUgaH9a5mPHHRywwqy9z4KM7wkWrhw11T9JdEv6wvhuzZ84+a8tZxaXCx49iw3VkiIDLprmh0DqkFIKE/Syn7e6a0p8LA/vGJkBug/Tn88AVvevz6nxGhYFEuujKTaQQh7WJ8BfTXOqAbykVyCTOgSRAOdrYrr/P+pAWVKlA7A4kjRB1ut8vIapHsMV1jPARfgSl8z19eQwsk0m6Pmj1Ss6G53b7gtB/hR3VBVQ+L9MzxLVXqUR8EToSXCyWDEiPaWANCnwR2h3XQmeL0B8RL/Sx/SnKVP+52rmZpYcKe/nyupi+66ddy8tZWYfzvl0iWi09WLffxDE2VO+QLOlt57Wol9712fD51Hd5XTkWm9K55kQvCAQYUwSfiHW2nbveOeqmDmNGQhrEgBkn3HeLIV2UbAkzjyHeD+cafJzytrKVrWxlKx+ffO5zn+edOzWL+RwXHefeE+GlkBqltSGdxWKjg70JAK1WiNIIJiiMrUEW1LuqbqIyGqPJ6MAKVyoAQnVTU1Uh97VOhlFkheRRIsQ60gms0BjfMseV0uEkY0S2E+sehpX0oagU3fdk9luntHvvMnA/XBtOUaXvOgMiByXSqbhkfAZlnEhyiMqk1ijpGxyh/tQHtqmxTR2A0p5y2Q9XCF0u5k6BDG38cBXKrr8uQvog16dNLqLpQ8DWErhFAH1S6rPkwIqWJCIunP7LjOH0t0S0RMQHAIlIVomfe9dEsDY38AWtu3CpwXBPkZCCUyFEowpOmuAn8iHOiQhKR2e7hNMkgTSjumEjXT0pvG9wBkk0iLq+UJIMVR8dD6HetC5ki0X6/4W8k1w2nXIaBvk9SnRIm6CkjfLjI0BrdHj2ug6pbYzW7O3tMyrHHB8eU9c1tXMxbVKa+6GPW2O7NUglnrpVNM7z4GDOvQfH1Mpy44tjYBn8mO4LtQun8rx4jIHRyDCZGo6PFljnuPdgxuHshBsvmQgmNly9ugtNwff+4CwkmsdZHz69a8EnTZ64UTLe0y2YJ0vpD3JA2rOQBW/fdHif5ZKOYFQCbJXSkPYgIMI9kUzj8SiaOkBW4hXWKxSeQoF1Dc88/QRXxlP++Js3P8pu2MqnRLYz/2LlyesF15+bMp7sceuDB3iEh3cqHt5e0DSON958QFEeIlIgyiyt2uuckOvkLE7wIYdg+ryvf/Rl02e5szeRjcOpVIt1TZvuqKurO/XdlivBuRCiVXY6SH+vH+qPbn/1eG9DJB4vnV7lYXdnymIx4/DwGOcqlAZjJigdyfMWjk9OWFQ13nm0LhBVorwOkb4iIdqLwosOaX5cSI8V7AIPpBO0wQZQmYOk1Rm9J7BzO13LR13QOYeSBpEFDx/e5v5NxcM7Dnu74YdP3cc7x9vfW+AczN4/xBSGN96a8f4HDQfHUHuFaMWiUsyNUB56OKgoSuHOvRnvvmc5noV+xmlcs9SNNA289m8c452gF73x46OVdz4km8gy55VV62bY3rn0FOw/FTov8NB1qyPrQoGRcPAk6bpt9KCB9mfjqh3/UccLhIoCpUy7D4tXxBMZweFLtEdddLHIsvPiImSdg2bd2rDJobOJNJT/vkyY6UdLCnqKUV26k84JFTEAnw4DJIKbpyxGFGYc60gnzT1cbrjx0iJG0AqlTC9pTubgKIMt7zvCfmqGMRpMOgCT1szQ5pSWOujvLk20zhksKsznaJ9L9j0ZAAAgAElEQVThE8HKozQgCvGKS9c8z2W4fGZGkTz742mZpZTKrlhK+zHk/B52gA+RZ/L7ht7Z0PfnkbMSvDaRKPvXDLXH4zm4U/PgdgV4msaiteXSEwV7V4toQ8YUE1kaukRlOG0/HCJ0Po5smi/nrWOlbT7hC74dk+Md4cYXPXUzRwSMUVQnhttvXWD2gceUpvb86I9n6GLBpScNxa5DlMPRRSMwRgWCqnhGI8OimjOfzwJ2YQqULoMTXjRlMaJahAhwORkiAYU+rrWJNBCiSBOd2dJeO+Qkz4kzAZ+TiMF6EEdETtoVO2zTXQQRyQgBy/VEHLc31hO55Cw7gCTHfEZAWF51s2vPCKyclUiRMM5Vcl7Am5YJM8vPuG49eJQ5ke47D2Gmuy9SBSKenbrM+RARJUUOFBHEK5TqxkfAqBOhpYvQEVKgm+U1OIskaHT4PkSHDjhzwPiWo9Xl2HGoI+B2HSaXrlt91oRjDfVDjmGfJstj0veK7P/Ncp29r1MX53VHNSlvHm36tqxEbfTSO/bxZp/amO3bOb6eCDN9Qmm6rp8GKn2eyDVLaZ8yGyVFZsvbkZqf2tSS2Xx8UJbrXuq1R9prBuZp7tw5gyzNm15xfVsp76dkn6VxmNbFjlie2SmRTJXWKc/HQ+b8SZQtYeYxxHvB2YskzGwhsK1sZStb+Tjli1/6Iq++c8Arr7wSTn0LNNaGKBTaRFAlEUO6EIHKE8L5xvQuIiF8cF1XMeRhMmJsTPcC0uhIivGRPRycdVo3IWy6NmgTT2C6ECYd8ZF574IjODLFk1NYKUFrqGtHzOcUTn36XPklc9AHp3reZuIpANIdSpaUQxWNWHAoHdqZlHNrm5BOynWKr/MRhPcdINYpv1HZdTp8HhV9rSNwFkWigaUiUcA2IXSksKxgAzGUZSBDtHqpD85KpTpSQTqp2vZJesBByfrjY5TN4OqjnmZ5FDmtn85Z2hCwR+955XRoI8UfknQ0Ip4g1TqkTkllqJhn1mgTT6tY4jHmUGcbYrcDH1IY1zR/gsEuS6kXoI2kGYluHSEGT0g7FgEgUfGkd5w7AfCJpC6Rdo44BGw4aYNE4o10kZLaUzfRSlZqmQSXiHtpBfAi4VmX0eTsJ14XATBZ0k1T//rsmgS+JwMuGmxd7y3dH15p92/IYm1RgEZhtHDtqUsYA0UheFdxeDDD+wYlNdeu7bG7U3D3DjTWUDWOk4XDekM5mnDn7n2qRYP1DpxDSUpBEaIPBeAtnlBShsvPllx+NjTTuXiijXSaTohJFjC6oCjGWK+oGs/i4THeQbEjfPZrBUqHNeb556bUh+M1hJmLWj+29sJFyrUXxzxxY9TuM+1amsCXFsQKf7vGYWnifpgAPB+jIgAuAnM0CCHlybVrV5hMypjuwsb1TdDGUBQGo4WRrnB2xktf+CwPb434TbaEmT/Lsp3lH7544MUv7fPLf+FZRHb43g8sznveeBke3l6gteEzzz3P0ewh81nd6QCc3TECpztHknP4NAf6WQDf04irCZxO/9ZNzXw+w9qaIkZq8d61YG3Y16OtEYkHptVdVp0zq46d5WtCF6o2XU+4KfyIgrpecHj4kLqeM5mOKIxQFEXQiwTmVU1TW4pyzGiyS1mO0bqgGJWUZYkxJp5EDjqXgqWUPinNgcOjlAOf+j21J2gjiWgR9EIJjh3v8dailEUpxeHRjA9evcrJncvcfxV+/O3f772Nd7Lfn4w/nTwEHr4GL5PrC5fWvVoADg8q/oe/8e3lDy9osTiPhtJ3tgx9cuUZzQtfN3gUTSOINqEvHXEsWSKtO7x8dC+dRT6mujHkXCS/J8eshJQKoleJCV1Z0mKtqjcnznsY4TRCxGmfD31/HmdOnwSX7u8IbCt3tM4piJHwcqcYURvvOdZCmZ1TarInfPbrk5W0bt57tEggFEZnp9BhB91z+t7fnQTH7zqywbIjLLW3tVoErl4vuXq9HFyPlg7SZPhEEiddnw2tWckhtW4NfhRC1Kb7zirncXzn/TFE0Ey/t+skng9uNrz5ch61x/LCV4TdqwXJyG6d0eLierlsE5+lD4bmwWnks6E5eBZi0joSwUaykYR5IQRylncw3YPP/bQwm88Q5ZhMNAcfaG6/telpP1qZzyy//X+9B8Dnv6H53DdKvCqxdsHe3pRRKShqPOHwz/7+mHv3Dpmf3KEYjXjm6etoM2G2sAiGy1eu8u6777OoQtQTMOCFxib8LZFiXZr5RBZVa1d3Tt+cpCqt4z2llgEfMYwwX7XWS4dach0ml7RXJLJMuGbdmhjbmOy7fO0b6tDktE9tSOtSXCKW0Y5+OandcZ4tf9prU799sZXeB2yDbo0l9t/S40m+jucrfCpOVvojq6rDaH3v/izdXLqyX02OFy+1KrazjQAsgvIO62wkeaSIOenAW96L4b2GdEkhoozWBmNCZGjXphHq8LCUsiqU3ZFblgkhviXQ9rG0cIFro6usyuZ1bVmnPKM8EqFjtRo/8GH3vofX/iGReGP610Ort0vyWcTDh+mOdOC1xTC9j1H486jRoT3tvmxDBCmyuZ2IcDmBpL+HrRDv3HKEszA1/fLvbR2rfZT7dQY6Lr+y15MD/Zb3HV3/rMOy03qWR+cJn4UDDeAilq2X7Jl2vXOxf+nSWW7lYmRLmHkM8U7wF5mS6QLL2spWtrKVrZxfmsUCV9cY0Rhd0uAptIKYTkVUiPRgxSLKR9a7wltYLBY0jY1kkiB13VDXdQgbbgzj8ZSqqmiaJiqMQlGEU1mNDdFnJpNxNBgEY1LKpgBaO++D4iQWrRVlWdCFMg1Kk3MhXKyomFs7OtoTEJYIJQHwSoqtAAqlO3Z5Ut6MCQz9JoY/L8qSIj5fMnp1vG8+P0GaJn5HBOOr1qgUFRRRIScUgPImlO9DWMmi0DQxn31gmYeymiYqtNaFkwUE5TsZSkm5TG0LEusW0MagtcJZiQBPAgl9+z6gTzwJTvMhwO6jlvXgWmr3WfWIHIw+Lwu9hSjXfLemxsx47IO8g6AWAWdpTfXciN3Yun49sGoUuRCdpJYWwAmgTKoiGSLh977RLYQTZs5rfLMM3rXgT3yK5WYHh4GKoXTTUpH6wkIkdaXPpHXILwNLEXDSinIUHO5tDVlbnQNbxeePSbpFfAxJ3zmHBI2IBh+IJY4mhv4Mz0kM8So+kONCHzd4ajw2HnAIYeATSBXqc9mzhLrwSXcODrjF4oSd3THKN9j6mMm45K//R3+ZS7sG1xzy4N5N3n79AU214PDwHk1zk+K45KUrl7l85SmcFDycQcOUnf2n+O1/8QoHzqExiDaU5Yid6ZiTWUNtHWiFx7BYOJzoNrWqiKCNiiFvHSIx3ZYuwHus8xwczBBm2dh1pMg/IarRiDffOuTeu/dXxtzFydZWeBxRureOCihVgC+is8CBqwjrYtxLvIr7hIAD7y0LWaAKRakMo6KgUBrXeJxtcPWiSxmo4doT+/y1v/ILvPjCVerqiPn8CG0KauvQZsRkssNoNMI2DVpBaQz/6rc/Qaj7Vj4y2c7u88lFrLLPP3+Dl770Wb73R6+zUwqWCqNDpMfJtOSv/NVf5Nvf+RY/+uHrzE4E/ASJKUJy0PKsZJah04RLztteOPO8jvw08TpZRwDoA8wispQadj4HCBEzg5MpIxHjVu6HFFGvKzvpKXnUykBOV9m+CbZxwWGSOzPEs6gtupxw5cnrHB8fcXh0wLw6QSvB2wbbVBhTcGlvl+l0ilKKxeIIUEhTovQIo0eUugjlhhAUONdEQDmeq5UQBQwH1lmqKtktQa8ajco2AmBQAz3iLdpovAbvDdaXPPX0V7g7PuaE+tT38ijyKFFhLkrzUGbVqXb2NsR3rSY0dhLHRCxMgVFRJyXsp+F8hEakQER1hy9iJINAggq3B6eCjfqsir7O1TG/zrbIv89PRuc69jrpz/O+LZP+zcvrExJOc+KvI+P0142+DTXk8M/net6W3OE09Iz9tuXPuY4Ql9831Cfrnvc0Oe3adf257ln7a+DQc572PEOyjqxxHuJHv69Pk40kj4H6hp5pqE3hj5gioli+TukUsRWCHZg3KOBQ6+pfJ2clIa0bb8DK3piu6ZedR1Pu7+H9unMcKaQfVzivgAKRCVo8O5NLeCyjwlCWHl3cG9Dj2gRCvU8Jh+A+gmAAlVPMGk2pNONC8VPP36BQD1nM32dnd4/xZMx0Z4fX1X1OjmouX9nh3/3Vr+Lrhtu3PgDvuHFjj99++AoPWSB6B60neFvy8KhBxOOlwfsF3tcoF3ADvAGnwneyPNZTSu2875PuYIxpccuc5Jt+ErkmLw+Wx0F+fZL0fX/tbppOB0if5XpNXk+7tngPMZ2gT42N0j5T+1lcV7oL4qenz91Ur3MpLfdSDvD2nzSeA+l5dV9YJytrO4FQHHTA8FlLRO71T9u3PYguYVjh9yyFVGx70M88pSy/WwiHI40JhJg88mHCo51XeAQX8b5yMqYwCqNVIG6mNTwj2YYDmrGn0vsjx9uASOZY6Z9Te7AvHy9WfFZZN+7WjZml8QtLBKzsKsiu0wImYpT9va6fHjaPNGMjASRJf77n5bQ/G+yjfjqodmVv00D6DnhmeR6346Z9hjC2142Lrg7JSwpkoh4JbNM+nGypUkZL1+f3pbWpP4eW1oitPJZsCTOPIeGE6gVGmNnCZFvZyla28rFKUjwW8zknbg6imU53MVrjEeqmDgQQ79Fa2tC+Ior5fM58Pm+VwPF4TFEUjEajJfAsGIFB4VIxqot1uaHmovM+ne4MRmVrpDgQFM7CfDbPlKPOOFFKo00CjAVtytbAdM6DT+3pnPFKdcZQ6odc+RqNRq1y20auIIWxDNdPp/vk4ZRFfNuGIC6mR8qVZoerK7wNIeHresHxySGz2Qzrmu4UQQwf6XwIJysqRpxJp1cy0D7I0vkzAGyTQjwKWhVdPlCSobcOtfj4yTKny6O08ZP+TOeV3JDoTues2iPL34V5mRv3yyd7clBARGL0J0MX+pf2ur5B0wdlJEaJEZbz/KZxWxRFCxjpGAknfZ9OXrVENhPm6zIY1EVvARDlu1Mi0j1vHty0NdjEIggGA2K601OAx+J8Q0sQCY0CYh8IRGZb1s+JxCVtXfFpSWQEo0c0leCs4NyIByeK//Fv/SZGO/Z3S47vCd/+nWPwDuf2sj72aH0XSMQjhah3OJlpnAtgimARmSOywHv4xi9f5Qs/Pebmu7doCo33hqZ2WAdlOcJJjPQT+0h5h/gGRZc7m2g8Ow/4AvQ4joOwFokWlJoDd/uD7gJkayc8rtz4asHeUyYOS89Ia0aTGu+7vBeOON9c2Iu1UfFknQpR5rxm7EqkrpmOhS+++CRf/nPXmI4tP3j52+Bm/P7vGn7v/w0EM63v8i9+459QFDoCcmEPCmMtlKskbmISdq6Tkw/HAbuVT5ZsZ/SjyUVqLk8+OeFnf+4GL37uCsoYlBH+t7/5XX78h9/l5HjG//6//iaIZnY8pa49Sof9q902MwfrWR2dSdI+D1BVVUuwT06a9H0ipaf9/1HqSm3tOxGd9RRFSVkWMTJmIqsnWyQHYoNOEKJOnM2ZPeSsVkq3dkDryIiEZa0N47GiKEr29i9FTT64RxSeojCt7WKtpWnC81Q1NE3NfG47x05kXYe1tkuFW5QlpigIThyPMYEoo5UOkTONDs9HXJZ9SAEgPpxyruuK+/duo7WiaQyrRPvzy+OkTLrI+SCAGQmf+6Uxk91i1VmYKpTlSC15CZJSAY3SfIn6M9FxFQpDKYN1Ia2JdSeYouHK5cs8eHDIvfsPODmZY/SIS/tXKcspIjqOScVkPAljow1Xn6cT6znz+i2M8yDNvUeZS7nkczInyqTT1Dl5Y2ju9p1F+bXr2p/uWyWyLUdUetS14rTn7ROD+s8y1OaLbsc66dtduf02RDrcRMR4nDbk/552XV7/pnvWjekPQ67/1JinniuXPjOji09lfV4iaD5HkuT9ktvvFyNB748tCT9xvW4PznnPZN/xs//hFKU0Roe1DYTRaMzh4VHbZh9Pjo3GJT/83QPuv1ddYFuHRSlHOWrYmxg++8J1vvl/vslbP36I9w2iZu3cCIeJrqKU4l/+xncAj42RsY25xclswa/99et85WeuMxrt8uDhjD/84x9TNyGujLPgGLX4m0fwMf3huj1uiOzS4S/dNf11Lne050SafHwkPWqIOJhHqBmKmjVE9FvSn3yIUDd0/RBpsD/X+7+fRnDJyT5DJJ4+7pTviX0ZItC1+4r3aKHVO88quRM/pbsM7YjOfxWjPcc21c2CpmkwRlMURXtPTl5tI5NH/Mw5z2g8RptOD1QqHHYSCYloJO7HXbtiuu81j3IWUtFWLl6G9Ij03qxLGEyGvcY5mvSt/pqwabyn1Gar6aEUIQ18jk/2aUHLn3X48eqA6s/zJT3sjMOsv8enuZ6TY9p+6pGItmP54mVLmHkM8U7wF5mSaRthZitb2cpWPlbRRmNMgS4KsEGRstbiqSGGiAxKPV1uUw9GG9TeHpPJZAnsTpI7u9MpAR/RWBGhO2nnYvSZpOx3zv9cOfORIJ8INhBIMiamcFJKxZzuAfx2KlxTFEUAhJWJoctLlOoY3gEIX1YUh4CJTUBjp6wFUCGB4cEJDXqJ9BzCCDZ1hbUVtmmo6wW+qRkZhahRiLChwukEZx2VtSzmJzSuYTIdB5DfZkBhdECCQklnUGltUDrmpZXQssViHp0DDRAco9FdujwwPvEpExOAc85bPkJZP042AIrZx8Ms/C6qzjJApuLzCa2VHB3RSyBB/CwNzqVQssnISXPA23ZeGxPC/vvo484NvSFgPDf8VSLMiKIPjiTnWA5+AEunsLTRGEmEmnSCOz9l1TPQ8nziohAUCh3npQ3niLxDR4tAC1y9vM+LL9zgrbdf5fj4AdeuXeKzz19nb7cgpEaCxayiWtRoVYAYGia8/tYDXn/rLk2TnAShPgGcD+Q/wYPKn1tjvY+JjxS2hpPFAqHm4eEBD2/BB7dSTKu+zr0u5Gg+VjrD8+67P+aJJx4yUQW708vMFvD8M8/y/AtfYHfvCv/ft77Lvbv3WVQV45Hh+rNX+Pmf/gJ3PrjJ7du3aGzD3v4lptMd7ty9z9FxRVHu8/TTz3HjM5/lzdff5a233uOhn61p1+PIJ30N+nTI/qWCS5fD+jMaTVlUVZj+WlAKlDi0NIg4PnPjGZ5/7hlGhWM8NmjlODy8z727tzg5vIfWHoVjf3TAww/e5r5bYHiA8wvq2ZSTw91Ya8PB/cNztXP7tn9yZftuzy8fproiShiNSy5fVThfcOfOQ06OA2HNWse77zzg8hN7iDJoHVL65XrEOtA0/z13AqTPciA47fcdoZ72u7z8vnO6X98mh29fP0ltEBGMMohSOGcRNFbZpVPc1tcB90okEpeILsth+52zraMmkBh8RrxJ4DiMx2VIc+mCnRX6R5PS4YXn1OioZIn4YHP5WG/qF20oRonc2+l4MXRNzBISI4M6S2MblAop8fIT1EVZhD7wFm8FXBNtD4NCgyiMxNSxdYNvakrjMMa1J6YfVc5KlLmoOXCW9UcUTPaEyZ6KNmK8Kw2AVFByWkQ7LxGMTHyPWoe0V3VdcXxywHwxozAFk/EUU5ThJLsVlJTookAJzI4MWGF3OmYysiiJdrkOEQckRvx0rqFT2Zedk+1znEI46c/jTc6GfL70T/X2CRr9tuTf5Y7MvOx03bo5npcx9Jzr7hly+q6Tfhn52jR0bd8BPIQXrCt7k1wkcSWvu98fQ32xaQyd5ozaROg4rZ6h+zfV8SjSX/+Hys3LL0qhKC/upPq6OZY7TvN2pr1z3bg8E46wph1DZfalKz/hSr77ydbtEKlUUMqws2+C3StdJGOtPfsmpBXEp/QZDmP6mNiHJ4UpmE5G7O0Ik6Li+GDGvTuJqNMnYYVGHT7o27JBL/qZr/wUv/pvv0jdWG7ducMzz3yNP3n5Fd555x6zhUJxKeAMAkiIV2LbA0qp/0OJKW1SLt27SPjn8vqybhz3HeLAip6VO9cTNtuPdNOvK8dklsecahk9p5FdNq3f+TWbyGND43ZoHuTElfNIuk+3L2r5+/yAZF5vf44m3Dpda21IAx4OQJo2Wo21oxCBUKuY2ifNm1gOibSzHBXIprQ+JNzXR/JuBOXI9yLi3x8t7LnpHX9a5VHbvmmvGyKXQBy70qVTzInIQzpXslf69eYEuo7AtbxGhOjawbbAZ6Rw0noVD03FckNqqVTueh1ipb/c2fW2dX+fpoOcJVLiVs4nW8LM44i/2Agzn3yH3Fa2spWt/GSLKI1ohcSwjhDSILnGRsA2ONWSCadEUDrkSS0KRVEUS6ccOulIMr6NverbEJpkBllwePdZ9t3JAaU8Wnd5eZVK7Owur6VWpo00oXWJKQPpJLD7NUp0JNgEoyUA4DH8eiSxBDd7ZxglgwOWjd1lUS0wnpRIa2saW8V8mjE1UiTBCCkdTkVIYhP6bbGoKMsCLQbnHba2aB0U58IYptMdQCjHJUVRhPdkQx+DxFzHgqACUUapCLjGXKsSlN3FomCxmLOo5tTVgqap2n4OymY00j4NLq7znk5NRJJzy5rTbUuElSE5T8qo1Lx+z/cNq9xIj+8tzU5ZNkbWGWXJsGfJwJD2vyIhQpLSuiWjKG1Q2sRqulPgYS4Fq7zLhRyfXrqT5D7GP0m/x9aDLIeLTocafHIaqdjeCLoRo70s90HWXT45kAhrCBYljquXx+zuTnj79UNe//EDIBBmPCFd04M9xeLuPW7dOubkZM7hewWz2wfsTgvwFgGqqqapGrQygKGh5ub7x9w7XvDkZ4S6BusCYBaanxPRcnKSDREWRRCl45q1g7dzbDPj6WtTvvqffY7ZyUN+71t3uPX+4gyjZ1huvWNpqobJdEJRwqL2HF2taR4csbMLvp5TGLA2rInONShmvPfGgjdfq2msZWd3wWSsePCw4mRWYcwJB+8+4OC927x78z7vv3/InffmG9tx5YZhZ79AJDh9Lu3vcPXyhHffOOG1Hx8M3PEpWH8+wTLa8Vx51qN1yWQXYl4l8A0j4zk6vsPxg4LqeIqID4QZHM39GdWdIwrdUJYapRzHx0c8fDhjdlKFPdY5vK+xTSCnFoXBuZK333xMJyrbt/6TKNt3en75sEHuP/z2e/wvf/O7WOtorOLevUNe/u778VtBmOCsCencFG36hNOcun1HzjonTN/x0L8/d/ScRoY5K0i6TLAhKlyRDKBViORoQ6rYpmloYuQbl9krnc7Z7es5gSaluUxEmdyBYW1NVVU4F9KrlkWJKcL+7zIQ2rmGuqrwAlrpaDeEFKxKBZ3BFCZ6RYLOFHS2lO5VIbFu5RrqZoGzDYvFjMYuWudd02R2l2jKYhKJ0URHjhByMUHIBqSZTHZwbsHV5xWTy57Fkef+2xcffeFxZfSsZbRXUOgSTUhtdXCzoTo6xfk/qsEIiVQkPqYnTjp2TMclMV2XpMMGPtisnuSUTKmVgg2aHGLeR0KViw4Jr8ELi7kHRpTFCCmTupvGjg++XO9bXbu/WZ6VANOXVQIBDK3YQ7bEkBNz3T3p+/58XbY9zy6nXS9xbpzWFUPPdZY1ZZ0j+3HkIpw968gwp42Jdc98lrF00USfD0selWjyYcjQ+On//iiyaa98PFkmErTN9BAS/oX1MeyRwVa3tlne25UEM8TBk58ZMd03WXnnf+5Qp4prKXhvA7HQN9x8zWEbePCB440/qZmUnnend7h/+9Ft6e9+6y6HDzxVVXNwfEjtNA8WJzTNAmc1Ws3RRUlRaIpS4Zzw8LgJmFzIixv2aqXi3puvPdnYzDraSwQT8PhIgnWBuRuuVSGCCSk63MCYassaIMz0dbPVSBTL34X2+SXCzNC/fWd3vi/1x/tp6//Q98uRlZYxr7Pqp/ne0+qbsrondISZoH91nwdM2bv8gJjOCDMBD1cqkGV0Ii54G8aq6tKPJww6XB+iAnbYXtTXbB1s79g2lXQ/OkwNaCPZhd8/2nXu415XP/0S8EiXltE0BoR2jW37WECJbg8c5tKPOAVDczW/Q1bGkWT/7fTaLupmTpxpOTi9drQ20ym6YV/WfT+0vizrkNvxd1GyJcw8hngvuIuMMLMlzGxlK1vZyscqoiRG8PYhRzMK3/Je0qmQ8LsoQGuUdAzm/MdaG53oEVSUcB+E3xNrPl3rUqqgGAJzXdSKkAfex1DkLhJkIgjpQdrTeMFYKQqDKUwLDAudsYh3gSgTy4CQM9SLX8Igk0ufzIAaBpQUIg7XGquWan7CYnGCtQ1aKYzWYAqMNngE29iQq55goDmE2vqQ/1gJ1gYSDmIoioJirNgpS8oyhAl23gWikg3ReZIRXtcN3vk2/PpoNIr9FO6xtkFrT1EqykpxfOypDueRbBMB3KSUf/Iw8AF5FB3iEe6RYUZ9V1w2cnz2mR/uxI3Ggu9MlhSVpZPciE7mzGpUl1RH+j2dTMjrDqlWVO+zHAzIyC7ex79N61zJUyckyX9PQIhSEk5VZ+SRMB8hEZGSc0KpHHgQvE2Es+xEr0unLpZPFPQNNS0eJY6QRsIyGRVcvTzhtYOG1//4eKDj53yHO6nngaP4c7o8cUO4el0jMgKRsBYASIjGEXKax3zWHoQ60ocUXgQf33HjGoya8MxzT/Lv/cpzzA6nvPb60WMRZh7ce5IH957sfXoC/JDxVPh3fr3k2pNXmTeKk/mcO/fn/MF3XuP/+WcVN9/QBE9NFX8ACsKJu3fiz9nkyecN154fx7R+NU9f2+O5Zy/xnW/SI8xs7YKLkPGecOPLirIcBYenD6DcopozKWuaxS1uvzXmzptPLd33Q24Bt9aV+qG3e2iV3Y6IT5ds39ewfNgkmPPIt775Jt/65pvt3x39I+gG4/EepIgW0DnqWd6a/CMAACAASURBVHZybNqDoXMa9B0jeVqAIRlyIg45Q3JizSZZ+V4E7210XniapqGua6q6oqmbaGvUwW7w3bO3WPWAoz0ByjlJJtkgALa22KrGeRcILVohvsBZi7UNzoUDCs7W1PUc50HrEGUk6EyhHKUVZVEm/1twG8YUs2ROM8SjjeC9sLAN1aJGKk9hDErrcAKalM62RGQcjw+ANx6jwHrBe4WjgBhpcF4pnnxRIcpy/6bl/tsbu35QJMP/NkWbedS15OqLcPkzmpEZYUSwDbx26KiO1kXoAxHHZHxMYU4CUciFVJfOjREp8V7j0VGXE2KCwUCaEY9SIZy+tRa8Q5RhOrkU0/Ym8oaADymxwrhtVtrhe/4FkeBY65wmtCl/h2yJIaJK34G5TOZaJs6fhTjSn4ub5l9ObDuNmLFpLTltjvfnZCKxbZIh5+1pMtSOj9tR2Hdu9+VRn+u89X9aZB3Z66Lf4yYCw2lzd2g8rpsf64hoZ6l7/bvrfe7XOSQzfES6z5xN0aVdd8AmYgTXP79sS5y2fgxe4wVB412ItgE1mhm2XnDr7bDm33m74s7byXZ9vCiof+f/eHnls6/+quLq9ZC+3vkjlDaYQjHdKfHeczw7QsSws7PHYmE5Oa5QusTFdIdIIlLmz+ZXur4jAHpc0yyNV69UOHizpt35WEip5cOBui71dZ9EkxNS+rqaZDSM/noz6DDP2rHp+3UypGcmjGqo7NOIf/n9CTOWiNvEB2xxNhFpUxOriOWGqN0xXTUKb8NhyDyVqPc+w5nDdy5+FtTJlKo89mgk6wAt3u1bLDDoDlqlA1b5Wu8G3/tHTZSBzWSls+joW6FV/FIUoURXSb/nPhXi32nu5zZWHrVz3XtJUbqX94JQfkeS6yJSOhdsgXDvcirQvh229O9K2vr8cYcj9J11H+7j3R+3HvaTJFvCzGOId3KhaZS2KZm2spWtbOXjFa27qCvORrhUgkGQUhcFcn1QnKyzNPMaEY+1rgWJIehEdb0cRrCu66hQqRjhJRA5nHPtd8mAC2X4njLmIhgssT7bOu67fwtGo1F8jmDUWxuMeB8p+KKCA70zUkKDnQtAdAKjRQ0bXcuKWQI1Pd7NEKnRKpBX5vMZD+/fZXYyR2nD3u4+Ozv7jEc7aFXQ1JbjxTEPTw44WZy0yu1kdz8+j2Gki5DzNjnZRRDlsN6hxOJcE4w75UFq6qbGVpaTk0DSMcYwHk/Q5hLOFzgLdXQIiITIQVobxuMxTVOjlGI2m1PXDVqBMQWffBEeLVrMMOhzJkXbCzE+fuc5cQLiujITdtSSbIYNhUGjPvvvuntaoyCN114xgdFP6zjJiWgJcA9lqNajk8gvOWGt/5OAABEdT8XQzqU0FzK2UOdEikQZpZYNqXDfsuGXgIF0Sjs57xKRZp1hlhxT4NFK0N5RFkFfrW1IMff9H75F+dot3n374vRObcJaYK3j3h3L1SeeQKFobIPDxbDT2WkwH04sa1sEgp4KP1ZbrHKcVDOM1rx694DX//63eOLyFe4eN+hioM3RsA0GcwgBYG04CX7m9ivh2cu7PH3jaWYLy81bd7l5a85tP6ZxFlM40sFCpYS6ShGtzi/eNtSLOaocMSqmfPD+Me++95B33qmy5+sPZrDN+vqUAtHdeTylAzjlHcznq46on1QRgTyDBD4Aa9ZNmVeGcSkUhQMavK+4d3AbMy2Y7E0xRXAsWbsK0n5SpN+sreX4yZPtOxmWj3NKbaq7KDXGqFaHB2LEwqA1G+3Q2uIJzhlBL5Ex1jnhc30jv2bIQfco4OY60D13ppzmBA+6ULjGOcuimnN4eIhtbOcgUQBdhMjWiSJqo965CbRVDiajKcSUkL6xzGcnLBZzmqYCAa0Vo7JgOo4OMHE4P+fk+ISTkxmLxQKtNft7+ygd0mIopSjLgvFo3EaczHW3pmmwroqHFMA2gZA8Gk0ZjyYU5ShEDS1MjGijw4bSHqaIG4wIjXMYsx+BcI+SBl2cnPbWImHEDx66Ey9nTtE02K86pK9qdXsRbox2uGIUjV9gxeFKRVkKuhC8C2O9LxrH0/4e4mus11ivOV54Fs0UX17CjHbwUjKvTMeGitEVtA+HIPAhsqKPnws6UmtSG2O9JhJo/PoxfRZHwiZneJ9EMTQPhsbreR1b+ZwbsuPzNaBPql9X36bvhp4hr6ffpk3tHvps3Rz+MJwxj+pE7Duf+47pj1OG1voPy1l62rOeNrfOW+Z5n+OshM5N9fWdgnm5OZlhxd5nde4PzZVHea71DY6oW0y1XlUVTdNQliPG49FGh/pQu4aeOV0b0gtWITWNchS6wciMRf0QYZ+Q9jDYhRkXYkVsc3okqnWi1WWUlDgW4I5oFjOa+gQcFCMYFTOUKnn6qQm3bx9y6/0PUHrK7u5lREo8MbouHosLEc1cwHd8jNDdT23ZJ4q0vzOs8/UJMHm/5venlNchArZbujcdugq6YE6YgeRg7/7ucKl15JVVxzp0kcjTfb3owb22D6156/bKlgDgOztXqZC2PkThjpHkRC/1S04uSv8aEyKsBzqLjcSDEM0YsfHwpIvpbASHRIw5YtH4GMc7w4ba/9CCOP1H915W3u/Hvdb35VHX1fOW9WmWs5LE+pLrTrmkWdPX+zaTIjt8OuG3Symb4jq+dK/vorjkel7e5u7vhOW6sJZFe2FIHuU99wlyxpgWo97KxciWMPMY4r1g7cUNxm2Ema1sZStb+XjFW4evLb5xCIk1H5QRay0iQSELTusABqKSw94Hp3B0xIe0TE1UuojGXtEqWd57FotFiIpCpyjlAHv/lEP4LuXuTA70cNrOEyO72AV+YdGNar83Roc9xuekgixfbDLQBFrvPKwyEJK0fIjgVEiWjhLBNp6T2YyDg4ecnJxQmJKdnUvh1IEumFU18+qAug6kFQ8U4ymXpzukSBkdyK0oIqkopLvyHB8fc3BwxKKaMSoN5ahAOYXSGl0U6DKcVtm/Esqw1lEtKmobIlpY21BVC6pqgVK+VS6VKSnLcQTsm+Aw0CDGsGqufbhyfsNvPRnlDLWd8/PE3sguC96MQFbI75fud4cPIXUHisO71c8T2EVHQAlh3ZOBUON9AhE6go5EJ0E7jlLzovHTxGhOuYGhJEQ3SSB2UZTtaZuQLmDEaDSJYyWNUU8w8m0E+m3vDQwAzQmoyMgdEiYvDh+NMBWdB92cQgniQsQrvMeLBRWjMTUObx1FoSlLDRxT1Q9RUjPZnVJXC772tZd4+dtzfvcfvxsNtwLE01QXZ4T/3K9OmVwRjuaWciygHc7OERxGqeAI8smBRXgGsTjlca6mMMGBY11NbS17RlPoMcaPqBvP/bvHXP9SwdNf2Ee1CJUK8Vp9g1BTFvCZzzxB09zj+9+Z8+M/Onv7ZyeO3/jbD9DmiBe+aLjxUsnepavMFgue/+kxL/7slJ2JZm8Hrl9/kn/6927y+o/OFnWnL/u7cPWyx9GwaBzNaAfnPNdeGnP1BQcurOVpmgnQVJ4f/utD6vlwSrRrnx/z7BfHlFrwdsHXvnydr3/lBd59c8Hf+O/+9SO189Mou096XvgZi1Yl+AJroxPVaJQWjDZx/Bg8BTs7n0dpxQt/TnHj847FbMH3/9WMav7pAKg2gd9b+Whk2/dnk6F+uohZ9ojut/a3v/zrL/Erf+F5/uiP3uDme3ep7Iy3fzTnnR83KA3XrxsaJxwfQFV7MJ1uk0DV3BmXHHVtTT1nfS59Z82QM/+8kjuE1pJksu+99xilKNQIcZ4TfxzsgaTieIcm4F1tSibASzoh/AhtVJCA5BTC0TrQ5RhVjFuHUe2IzhZFOtE5nkwpx50DLTltgiooKJGoz2Uk48iJHk1Cuqn5Ys58PsdZC0qovcVVcwrvGI1LWMza+5POCdIeqigK056eTt9duqb5+l/aa7OPeonuIA8KhfcO5WbYxQPu373Pu9+7hq2WcUQPZ444MyTPfekDdq42ILuo4gqT6R7jHUOFwiIhYqpVvPgN4bNfcRzcmvOnv7+aBnIx0/zOP3wqkqmSjUjr3vpP//OX+OovX+J//jv/CF3usrN7CaMKxIGRgvmsastSrcLmolrbHbSA+G/rXDz72B+aS/0y1l2z7rPTHBZ9Z+umcnOSzGnO8bO0LzkmkxNnnUO9v84MOVXX1TG0Rj0KMWJdnz4qAeM89/WdZRchZ6n/bM65zX2dvt9U37rvT3tepVYJepvuWUcwyb/vO+XP0k+r5WWY08o9aR4tkxDwCR/YvG+u229Pu2ajrKzJffwl08p92LuMLtBj07Uh2v1DoiQHWLJSnceRUgGl/0biCAJiUMrhxVI5z8waTmYTXNxPnv0pw2deKnG+BBIZogZpgi3tDT/6/SPu36o3P/8asWicFDgT6rPigAmLuUMtAPsE3gsnr1ucn7J36YWAd6BobHq/Qtgtu8i54ZRKV08+f3Kn8EbCYPiFgFPJUu8630Un6bChRLgKZTkXMJuQMjtEmKD3DpIjvH3768ZRJKt4l1IDx78zxkjXwk6vSajTyvqcEZn79wQ8V9qoLyooM0CMepSVoySkHjdGo5ShKEoKUyxh0v01IeHTIoIovzw1WgxDdW2K2FbeM4/m/vx02OcXJRuXpPX8i0+MXDSZad2+JUNY8mllAbhsn4vYbat7+8zOi4dEffSVeAJpbolY431MH0U7b0UJok1MT+87LLhHyFkrbtmGzH/aZ5fuYHZd161vaSuPL1vCzGOI9xccYWZLmNnKVraylY9VDg8Pmc/naBVy7tIqJXRGh065Wz0+AYBeWnJMHtrSWuk559WSQReMr2UQoW+U9FPB5JIz/8P34ZrFYg6QnQaYZPd29YRTlssAW9cux2JREQxHFYFivQRyBFssAaqhP9JJGmsdxhSYogiGvgvlTKdTQFCLCh3L00UZyBYSDLC6rlEqpqKhoaoa6ib05aKa42ni6YYRIgYwKDHZaVio6yr2YcDjPQ6jy0DAKSdY12CbGVU152R2iG1qxDvqpgrAttIh/Lvo05XZT7WsPlsYCmsMkrWqSjLnMxAsN4tbksnqbSnV0tI4HGqpT4B7KjKa4xGQVyqdiolA2hLwEAot/TJwF8a7iU6bLMKMDieMjEkOEh0dJxFc8S6CAbJUVn9OrnSReFLY+gQkQAQyUHH8OnzM7YyEk97We4wp0UpTzyuUcrz944aDewGw0Cr1QxNPVivKssE6GPmHNMrz4pdL8EJDgzKe2287br91fgMzl3Kk+Pq/dYn9aw6nHeOYUs7aBvAtubDtowQwxXlZThUnRzUL69gdTbl66Qlsc8LLv3/MvdtzROo2kstnvjRmeknj8KgCQqqAkMpBKFHacljPGY1Knv2iYnzF4m2IeFQtQgq7FHFEFwWI6uBGARvr0Zc0J7UJObgpmE4iaKSFuRVu36+49vkJ46sNu7uaF164jvcLfvef3+a9t+an9Jjwxg8c779R42lQheLrv6Sodc3cNzQGvDOIm2JEo7VjZwo7E8Wrv3fEOijTlDDZURg9oqkUtx8c8cNX3+DOzZ8Mo/kbP32N/+q/+XkcMeQ3cHA058evvsfL3/8ht+/cx/sR0/09dvYCSOcC94gw2BzeeUJWlBSpKRDgqrpCa894VxNYkmvWqk+wbIkzH738ZPT1aU/x4c6DJeD8lGvP35INzsDs92eu7/MzP/scztccV/d4cFTz1IuWnSdAF457R/fBGxwalnTg+AwDDtpNju9116XUrEkHP6vzse8kGrIrNtXvHdR1g61rFosZeELK1GQjWNemk2rrVF3Y/k2r5bqTz+uIB61uILqzhVzS/YJOqbVGSa6/6dbmSnU653De4WyDMYpCB/2tcSnlkwXSNRUjHaLJOFczn1uMCfqf9+Fa5zxlWWKt0DSKqkqRCMPJ7JAG1zDaV4ALdlFL+I5ONiuILzDTPfYLw/vf1/SD4PX7Us6ADf7Ul5/gP/kvvspi4Xnl7e9y5/4d6qZE1ISiUHjxNG5BQwMiGDEUO2CrOV4tSLPwP/hrN3jpK1eZTCdUVc0//a1/hhHFvZs73HpjOW3InQ/ucfvOPERnGhmcq6lsg/KgdBn02ESyWXFudDbjWeVxiDTnlUchbjwqEeS8kuyadXUO1fVhnE4/T5n5tfm875MXclLPJqJGXzYRVE5r56b1cei789TfJ9L02zVEZOrbkWep/6zyKMSn897/KHMnkRlEwun41793xMHdir2rhue/PG0jJa+Ud4ayP4x+XK0jYQ8S8auqjUAbImoNj/WzyAqZZ+NBpoCPOK/wUmDVLmpnwud+MUQa3b2kGO2H35NTuGk8TV0jCGXpUfqU+bLhu3d+cMAHrx+zc8XzmS+FFIqNUzinENEYXQLd3h+i0qq1xLHYyo19c+Y5Gi5INy7vsfG7/B3153HCc9J87f4OxB7nOh0p19/6BJMhh3f+/Osc4X09cQg3zv/t64V52vA27VL2THkKpaRHBa6Sizi3xIMmnozag0gXeTfd9JNhF32KpI9zZvJh7P0XKR8Ggfa85eXzPy8/Xe+8a+eTb0kyHcLtl65fnvM+EtY6ws1AOza8v/YSNTzPAZqmWVoz8ohYW7kY2RJmHkO8B+dW2dqPU95WtrKVrWzl45P5YkHdNCG/RTzpAAT1yNM6boMy1LmoEjFlndFzFmN+yHhaZ2RvAlhywy39PXTiVGvdftdXrELeeQ+2SwGlRRAfEdAE2GXECucs85Njjo8POTk5pmkajCkQAV1ojCkYj0YxsotGKaEsC5TWiBi8SkZmw2Ixx9omGm8RLMe1UXu0FopixKicUBQFgVXdtKQdETg5OcJ7R1EUlGWMGCIKrQyCQoviaH5AXc2oq2OaOpCDmqZGK41WMRXUEgHko5BhcOh0+Sjbt+6zPlkma1M2bjaWngOIkuZB96fPrpOUoku66DBteiU6UCg4eFLKJL/0XUpjhhiUxJzMKn3eOUXSvcuknpwAF6sVH08UpLq6vhHAp9D+3ganDyFIlQKMhmeuXcYYj9YOLwvq5jA4ahoHaIzSFDJiOi25+fK73H17iKAhgI79r3j7xYqrz2iefH4SQD1qRHtODituv1UN3H92EQ3714QGT1V3J7lsEwgziSAjkuAv6U5hOId1YJ3DW2gaj4jms89f54+/+Ra33zqEjCLy9Z97ir0rwoPDY6zyOGvDuuBDlCBBcXjcUDcFZqJ58jkbTnEh1LUPKY18JD6aon0nEnNwp/RXAI0VVMrpJB7rHI0TZg0czU4oLwtP7JdMp4q9ZwCvMKPTBnj4/t77njSSx1NH8/UaSotYi1gJqap8gRHQWHbG8MxTYS1cJ9rXaD8DB4213D9wzBcV9999vPf7SZHxFK5/1nPn3j1miwbrBCaWyRM1l64r7LgASsoygLJh7kXHpQh4G4g2zkdnbIwc4KvYdwrX1CxmMwYjXn1KpEdT3MpWNshZRspHRx47rabzteRsZBmA/5+9d2uSJLny+37H3SMys6q6erpnGoO5LAazIPYCYYnVLkmRIimTtEaZbmYyk4wfQK96kD6EPoDeZHqQXmk0yfZlxYtxjVwtl1xwRRmxGGBxx2IGmHtPX+uWGRHufvTg7hGRWZl16+qenkGemeqsiozw8PDwy/Fz/ud/JhPHF17e5etffwVbe9557y7vf3iPB4+O8AHmjeQ1OmT3VzGfna+fj787zwE8drRscoaf5XwdHDOjVKupmsvOxVFEvJAMwr7r6NqWGJPOXMq11hJCYLFY0HVpLTbGYLG9MTjd4LSxeVn/ySqgyLn2rvGzDywdQ7tMJlW2wZXoZoCylykOzFQHk5lsYtSUjiLXKwSP9z5fY4e9W65oCD25OyWgLQTty02MnyltVLoqQN5XFCegBFDJ5cSiFxqM2WG6MwFzzHWMLeMC1c0FEizu/k3MiWKtAI4gJRVC6ZchR6Qb1ESiGd5Rte+pXuqodypsiNx8XTDScXRwOrflL97/BPfTikl9A2umaJSecj5oScs66M2r8jwb8y/rxLkIoONpgWauWy7qiDrvma76vMvz2OUdY+N6bZpHN1236e/06+a5fThJRy7+NBGJxpzKLZNh5j3sYD2iB1Wk8ZL2bcXW1O8rR/PEsxo6l2n7JwKi6MhiEJXHd1s+ea8heuBr5R2ueeg1YMLzARQp4U/61ZL2yeW8iOKxNjKd1sx2pnRdx/zkhKb1GJnmQC3b29nSegJpnSj3tfQ0YxQ2jdIrhrVyiT1Msn1EJdOvdShdtmcJog50SmKGURAP+FSuDomBNG1xSey7jqo23Hl9VA8VbJ4+kqpgkk0iLvDtYzRWuU0uL4/vNgD4tuXVrxzhu4rOg0hNXe/gJhEfIjGCYDG2yimtbQJM9XaVMkKWoBlLP73qUdhVcuv2v50xRtaO4Q1AtSKrAN8hSNFS9purjGLrUrWUv9cBY0q562yy4/lw6Henyx2fPzzLkEY8pZnMx5Xs/M96pyltUOoYiZlBGcgM0Sspu0ZL0dUsl89uf/HZkXU2Z11zbHz+5j3F86xrnSVXqftVn3fduC/HLhLYXGTVB7R0rCx0XLzH9+P+jHrCaSByqvfWEnRdsgXMPIGkaJHrBMxsO/ZWtrKVrXyqIpJS5gIYS0qBIphs6EATjSVBEVNSM6UdQ6EFjzHSdV0PWhmzwqzbCK2igVcVs1UFcN1Gal2u9HH5XdctKXjWWmaz2ZrHH1JBoYrDYE1y0kvaRaUIWMMIAJEc123TcPD4EUdHh3TeZ0YawRrDdDZjNpthjeXBg4ekDVxOhaQRzWmmrHMJcCAG7xOABWyK9EzQAkBQk0hbyYZx7wNt29B1HVEDxhjaNjmKE0uMwWa6cI0BVU/XLTh89JDOL1D1oAEfAgI4Z7HGpfspI2fApwlKOUuut15nG79kraHqtKyv07r+u+5Y2biPdxgqBeJA2vhLoXotxoGB6UiQ/nwzovaNcYgCGsoCayQzyrgMvFmOEoqxOAFSG5hSx37Dr/2GKDkkhIE5J10jxfppLCYnOTh+6AmNYlHqSjA3b1OpUIkmiltvmVUVGKFtPUYi+zd22N/do7afbGz9amK4ccsRVBFrab0QYsAaYTKZsLMzZTo9BFrEwN4tg3GGGCJRFZfzdycA0qpht7wTxU3g4GSOrVPUueb2skIfLW/N6GohA59SGc08IFphjMV74fHRMW9Mb7P7ouGFL6ZcxXXlmE2n7M5mhOOW+YNANMKrb+7z+PEjFgsPtsZIRVRHGvoms4tk56EYbJXGs6pmTEShTlVM7F9UmueURH/d25aScWw6m1LVDu87QhcJMXLv3iF1ZfH+8uMwqvD4xFGrAyqMpij0RJ2cDFadV5qFoGeOc48hYo1SOeWlF+9wchB4cK+5dJ2eR/n43iF/8M++w9s/f5+j4xYfBLE11XSHEAzWvZAN1cPcNDZ0FMdqWsYyxbuCho7KJiaAtm3o2hNmL0ypO6GdK+3Jp/K4TyQr9sytfO7lab/lq6/3V7nT5Uta45C/xJXvvfeI7/z5B/imY396h70KdmrP8STSncQEspYAsUXVk1gNc3036ErrwPLnGXLHYJmyV9jkFNkcWWwGh0g6kIG5a4zvMaIxEruO4D2JWdEs7SdUFedsz35TQDJRdaQfDAb7ARCz/k2m77T/XJV1Ud4JDG36+dxaGQUCKCIR70NOmzukTTIGjKnz/RSNea9kk0MzZURIaTclO74Km+awfxOMqXJzxV6vG35SulvvIzF6qpjXnV4HBJFSz6z+YXDGceOlim7RUXTHpGd69m/cYH6oPL5/Nth156bHVJGDxX3+8J9/G+MmifadCfRMASmVlajBiSWW1KHGYCvLbL/m5hdbEOGdDx5yv32MdQ5rDG28TQjHaG3ZfzlFnsecOuO483x8V6jMDci2UJtfu5bAitE7Xe4DlwfQPJFD/hLytO5znRHRT1suOmdd5ZlWAQ1nOaquKhcBMD3J90XGzrLUTsXhXwAJ2u87EUOISogliCASfBrfrmeyzQEFKn3qHY0xzyW5/H6fe7qelwEIXUSueyysOheX7pOnjBAiOzcdtzpl95bL7VHgNE8okv/p1ycLWtbyCEaJcQ60VNNdbrwwZX7iadoTQtOBpsCvqrKZmTkSQuzrXW5ibZ1NAumdlUfu329ZjzKYyhhSOuIOHt7t0GARGpQFSsBaw83bFYYZaA0EhA5MAmkqDnK6Qs39RACjESRAVEqKQyPJngfC0aNI16Q10PtA2xzTNjc4CzBzkTfRNZ77Hz6mbQUfDNZOmUw9k6mnaTtUDTv7E3Zvzii2lAIkM/kXIWYzk/RAjeHdrdRpNPZKCsGzanmeznaRa4ZUUIOdZ901m+bSs8DPm75bPW/VnrxuPihm2mJvFRkFLC0VSLbvKkNepWVb8nkBoH05l5Xn2v+p1zL1XOZ2pxrxFCBs/Jn7uujGdnzautPT1FOuOlY3+UyuWt4mHXbdfcrn6h5O+zG3+Zp191xX43F9Chju9DnXh1H4ZZctYOYJRDPN3HWWt5WtbGUrW/n0xGZnOdkRbiSna8Fk+9+Q31Y1sRuEEGmapqeyLICTMT1nkYsYDjcpe+sirsqmaZVBZgzCKeCRYvAGqOv6FDAgRUwaxBiqyhGDxzcN3WKBtYbJZEJVVT2IoQseI8nUO1/MOTw84Oh4jmrFzmyPySTdYzqdJiaZfI8bN27QNAsWi4aTeUeMEVvXlKjHST1hZ2eHEBzeB5xz1PUEYywxlvycLV3XMp8fMp8r0+kMJObIoaSgTiY7PbuMsy5HbAWEFo2etlvQNHPazCxjraGudlA1mQI+QyGuyVbzPMp1G0PPkmI4XO3fm+6TjGglIjhm9g8dQDLO9GCo8p6CjxlEZYa4pFzOsEdxPdAtAaksdTVJ6Y7yGF51tMMAfBvqWxLD9DXOG9aygS39J2Y7neKsYMVRuwk705p2/jHff+uIj98b0ub8HbiUCwAAIABJREFUax5dtYmX5IWXKn77P36BRQhAwLcndO0JQSJ3bt7hK2++zNF7jh/yGFcLX/kbjt39HRaLhrZr2dvdoW0LS1SaD521gzNEU9qoSMzGl8jEVTjn6LynrmvatqRTyg7AAjKyFiMVYhJ9tKlTGoOonqO249/8+Q/Zeb3ht96w3Nibcef2Pl/+0pf4h//bj/nRWw8A2L815b/6b/8Dvvu9b/Pxxw9wNhkBQ/BYKmLMTFkUymFNTs813U01pWMabBXZoacp4tNah2qkrmu+9NorvHBrj0cPPmF+/ICdCbz+yh1eurXHj//1gg85LyXTGqlqxAnEgMnAjigNPgM7Pnnsef/DY7pu83iN0aJU7O7U3JCWb/zmDf7tHx/y0z//DCI+1sjxHN5533HSvYaZOibGICZgZIGtOlQ9GlLaiyJjA31Z62BsjFACjibPLzFWVDs3+fLvRMQoH/848uGPP7tsM1v5vMhnQQFZV8erGVIvB5pZNUGed+Zp+f1/8Bf8/j/4i6VjX/+bO3z1d6Ysuo7OR5ykNI0aB3DuOmfIOuNqAcAUwMX4/FN1HB1fl7bo9Bw21klydLAUQ22CqSYQQ9ZFsj4VQsB3Ld53xLxOAtkBWFJfar4ugWaqahcQvPfMF4ukR5nMqIL2Otomx+hFpOyfVqM7x/uq4+Pj/rnHTJllL6OqtG2bgTMmt2V6Ru89JqfarCoHCJWbUNf1EuByzLIzTl1Qfg8hAfO996P3AIusExpjqKrEeGaMRTXXQYcUUr/2d3bpwjFRWyClj5rPj/jd33mDn/27wJ/907tnttXrXz9mdntOCDMi+/g2kjJNJresEBFNLBdJkyipP+lTyu/fsXzt75U6pj1i8AGvHZWd4Rvh1uuG135txmQyYzHvUIWqqrHGEcLIeVOc+qS91ibZ5DRfF5X7pHIdztHPi2x65mf5vOucrufNiU96r1PH2byintVfNju1EjtGTNQZhDzhJmBaGhbTiaUyICiVs6CB4+NDIDCdTKiqaU4ba0BqxDh8iHSd0nYdRE2BH1bAnK7Hk7THaqrvJ5Grjqvxd7/6jd0LlXfpupT9uU4p7NEQQTxIh5gO7x/TzQ8IWnOyeIDvBN9FYjTEuKDthKaZ93aIrgtY60bO6jFYI9sKRZf+JgY0dMTYJeY6B3s7Mx49FN76w9P7/3rm+Z2/d8hs5tDYEmJApcNNbA+K0ALIHCwfQEpNHWKHxhTkJzZgnEc18NO3Wj55r+gYDnjxYu3K5vEDcPRghx99880N39Yo8KWvR3a/3oAokQrNde01HgHUINjUtjLYXSkprQsAivFFQzru8t3y2C2BWNcnZ/XRs0Ax62QcAHmZe20urz8Dxfd6Xf5/zQXnlff5XBs3y+V2I5eT5XIH4FfZJ6zOKaN+8SmBjDat1c8L4Hl8v1Xw2WXW9tWyNh1bDS4Ylzm2dY/3EbqmT/XM2yv1Ip8pK9VbZ0N/WnrUVraAmScSVa6ZYebaitrKVrayla1cQSpXY22FkIzjMSrOmUy7CWCI2eDsfcD7CNkUuYomXud0X7eBHx8qv4uYUzp6AW6MdbexgjRWCp1bXt6tq3BVnTbUIoMBN4PnRRUxNqUdaRc5WkaxYlLUojGourzmJSNx2wWEiDGKNbB/Y5ed2R4p1YUZbWYjbbvoFUbvPd6nqMq6Ts54TA1SKGyFRY66TMb5SIxt/0wxRnZ3d5hMbhKCJ0bl+GhOVJhOZilaSwVjhKqyOGcxAm23IISOpjnh6PiIw8MjYgwYU4BDJhuRxw6PmCMyrleeF2PtVQ1lm4BeZ0nsadqXz19nIFjeLI7/HqHqjcsODoAhR7OiyaA0GocpBdiQaqmAZYxJDpfJZLY0lrz3/X3XbUbS74ZIAtcpEQiYbMiUPFCHXNEtKi2/8bUv89Uvv8bLt24Q2yP+6A//DGdmwPTMtruKxNjQNXepq11eee0LVPUtThYHLOYHmOqYjx7+JQ8PcgSzKn4RCHVkYqZMZxViAtNpSTdAek5JMCFylKTFYTRSWYOzHb/9jTf59V//FT65f48PP/iAl+68wkcfPebHP3mXxVxBa1QriC5FjZmIckz0EYNiUCxCjBOm9U26oDx8FFmcKPc/+YBHD+f98zVNyx//0f+LuA7EMs9AOmsqdqc1ToQQDULHYnHArd0pr71yh1defpn9/X1852maOSfHxzTNAo1K17W0TUvbtjRtx3wRmXeRED1qoF2c8P0ffIhzkaPDB/ytv/ab/O2//jWaw/tI9yFmLVjm7HFhJLJf3QcsXicgU2zlaLoGSMANa4CJQ/Aby7nzQuBrX4rsTAPN/JB6btH552hjoQ0xfpTAROrQmFLrkZ2DBkuE0bpzek4qa9AwV0R8OCFqHu/OMqlrhBnBB8QkR+bzIr9spsrnXcauieuRz9sbHjuOLi7XOWtdtazj44aHDyMxToApHSASEBtxcflNXcTRP9ZzLgoOGPYd68sb16KPalRFYxjtFSQzqySWlsODQxaLOSF0hBgSwNQYnDEICQgSgyeEuJweQCSnUIz4ztP5DmMdk9kOztW9PtXjacsz6RggPaLz39DVz4q0hAR8nE5P60urEZYxRo6Pj3Gu6YH+XdeiGnCVxXuf/07MM5PJNKfVTdeXdE1lrRCRHiRT6rPMDpoceEWVTed7uq6hRHqKCHVdUzmDMZEYA85NQWZoVCIRt3OL936+4OMPz2eGU7tLNduhlimVq3NKy5SaUjAJRCqRkthC10beG1DNKT8FsBixyUcpkb3dqq9717VYl6+XjqA+5RMdv6/8r/dDW41BVOc5zdftact3TyLr9PjLOh+vox6XkU11vGodjFn3/s93sDxJHdYF+my6/irgps03LgAuWN47FjCL5jkyjVul2G+KY3KwR6CSi4t92SKJmbSwZipgXLKtBIlpbvUL2sUBJ0cP+cobr/N7f/ev8zd/92vc2JlgUFQ9P/7Jj/mL7/2QBw+PCOp4/5MjPnlwwrxRrJtSVTOqukLV5jnWohtShq6CFVfbc9N+fx0ws1x/2b52neCb65cMujCr/UkBi0ZLZb+Asy8iKnQLg6pggMqS0vYGyWCD1C7WyIrzuji9BVWT0iuJYF1aGFVbNLaoLoAO3zV4H+iawIO7DthZU21NTGT6PvPFCYtmjnGO2ewmO9Ob1NUuYmoCgrUp5VQCx1oMM5yd0EWPxAhhQRPu0fpH+HCLp2F7WCenR3AHzPGdoDGxtwbf4duGGHxeGy1VVfXA16p2HBwd0LYtxlrqesa03sfYCUIN6rL+UxzSmQE4MwxrzO8t2zJWayhXmWf6932hhwaGNXLd12c773Xlc1TmmeN0TXmybiUYfz0wMF+kuKvL+jXpfMm2d4nDPK+GlGatzN+QgLs+nyeorrq+Nz1MtgWrPgE4ZbT/GYGJC1tYiD6/64j3HYvFAussxgiTeoq1NV3nsdYgkvwSy+Wu7K9WURXnyRWea5Mu8DT0orP0s4sAulbrddZ1m9at8+61SUddBcusCyLoAT3pj963xHj/lKeyy4Ly8jcbr9nK5WQLmHkCUZU+QuO6ytvKVrayla18enJ0dMT8JDllE4giRyQazQpVNo6MkOCFxWVMf9cbr0c5bYv0xgldjXS4QOSDcgqFfJb0xu7osc5ixaTNoxFUAianoihKvGogqqfktVUxiQ3COjCGSFICfYwY61D1RDxIijTtfJNZPkyOdjFZ2U93CSFwdHRCVVXMZjNcVSVHdSz5vUtEa8ygG6GqaqqqQlVZLBa0bXJoO2cI0aeoKzXU9cAQIoCRZDjwoUNQjo4ecXJynFhl2g7vQ44qNSubw6e/Fl800up5lcsYO8ffj3vuaiR1cWbDAHIpfSCNjeUxVr4bOyP6n5FjauzwGMoeUh+MI5jLsVXA2cZnzQwgRmKi/08PhmjAEcF7kJbJRLl9e0r76Cf8yT/9gPsf3ERjywfvzXh47+mo4s46dndmdP6EaR15/+2OH3z7aGBdMYc8vjeA7OrpBFtLZt9xgKXAf5QCMMpzYmyprTCtDZVzvPnl1/nTf/4L/skP3uObNx8ybxacHJ8wnS2Yn7REG3jtqzNisPjoiaZLc50KMdaYbMA2xfhkDNGntq0nys0XhFe/sMf3dh/2z9c1ke/+yQG2El56VXjxFYtViwRDrYGdqeXFl/Z56aXb/MP/4y3ebVt+MrvPzs4JdV0nRpHg8aP0eSUvfQwh0acHxceBLjoS8cEjKHe+fIP33jvhT5of0Bx/Qmwfcf/BDKgu9Z66Bv7iz5LRJ6qCdIiYFI0uUBxxGpWu3Tz3//yncHygWBMIvmI6mXP37AD1z5QoOWbdmmHvpQaizd9ninMdWMZWDRaF5WyIPEpMCqafS2w2XCQWgjtfqth7wQKKq2x6DxpBOtCGn/xbR3dNGa+e/1l/K5tkPCqv/h4v6IC8cvnXJ5c3wxUHxtMo++mUJVgsU8RMELVECahoigMs9vmViEI42+l7Vd1u3WWSATEDyD61sSpgS7qIkBhkNKZ0k9ZxfHxA0yxSmSL4rkWqiqApPZPGmFnhUisUw2/XdjnVrM9zaZoPfdfSdV1ipnT1AAoaAc+132UM/Tdu6MmDkbukMyq625B+oIBjCtNL13VDuoHczoXd0rlJ1vEiUJGX+jz3K85VuMqNUlHJElvN+J2N9cZy/6HtS/tr/3diLfOj6y0hRBaLRb7OMJlOMotfZk4UR9tG9l8x/NrODGMUZyPHJ4+5/65w8NHYwVljnEWoMkBlaJfBqT4yym+QTU4BVcFInfZGWQcyS06ZtGfs+yJK5z3NosXZGpF6BBp/MuDpk0bNro6/demRizxPe7Drrcvly7qO+69jk3naIsqwn8jR+T1gTGyygUC2eSSLRwLRFACEoTCSJKe7ImJ7gI1kRltlYB0OnfL2Wyd0rRI1pVONweK7Gxz8zPPxD37Kv7jzgMqZ/k08fvyY+w8OaJoWxXCyCFT7nv2XI5PpHpPJlC4IqMn3l5xKbr3j8izAzMa22nDe8zQOrlfWjfvSZg7J7rExLkkKwODUpZvaKDOaOp8c5CagMdJ1J5ycPOTgXsuj92+hMe21IdIu1jttfSf87Ds7GBPxwRHCDtXE8tXf3mEy2UXEETTZ27ruGKVFJOCMwUiLiKNyZHa5OV3T8rPv3OD44eX2qstPd9aTny/33jWcHFS9AiMIUSs0mH5tLgx2RlK6Z2MMXbdLiCnAyVqXQGvSkQAU0vvSvviVY3ZfUEQqlApj67wmVQzBectr2WdDLlvPqz3XRrDMtctV270AY2IeqKtsz/kdjwetagLOnGKDWgW8DZ89udGVZf3usNgu3/3Bgume8NLrNdNpsXlXmTkx2SasrUALy/26unLFSp41iq9XrpP15Or7qGer/6zTe1YB22MblVHNqf701PdXq8fndf1+9rIFzDyBqMr1pmTaAma2spWtbOVTlZOTE5qmHRkeoERLlk1cccyFUPIXKyLulPKzziA3/l7I+vsapWqjcil5I7PWgD4oZKcMJpLSLFk7GIYTVfhAJwhgrQFSBFPRzVUMKhA0mYc0RnxMzAfJuW4IITBfpPRGGnMKFLGIsViSMTiq4n0ghEhd5ftEIYTTxlpjbJ8yqnyqal/ngso3kgAyzqRnK1TkoMTY4f0C71u8b3n86AFt2/YpYkq5Cb29bGh62vJZN0Rdx4ZlNY3YKmhlDGhZvSaBYooDwyxfY2TJw1Tyu47HRDHir372Za9EDqx75hTFCxoCk9pyc9+wv2+oK+Xxg0+IzQnaNWjsmAjs6w6HDz7hp2/t8N23XsqlPL3oLms79qYLfHdCe9jy0TuOd36wfl5xleU3fv116qlwMm84PGo4PvF9dFYOgUA0Yon4MOfFl27y2ss3CX7O3nTO409afvy9I+DBqOSUOuH1r+zw2ms3uXf/hOO5x+cxJ2KIUqWye0ekotEQomKcwVmIfkHXPEbD4HyKAR58kPrDS7cDL7+gWDvj9ddfY39vh6Y5QPWEHWt4/JHy+FHI9Tle2wYX79HJKfXyGxMeHiqPDh/h25bYRY7m51y6RkKAj94tdw+clcrgLLl/T7h/D9LLcjxPzCjXIUGFebCATUBO8rhPXo+EuGSZBnfdPLVEoQvJIWjyvIMk0FIGkO7cFGb7CShrbV5ZYgbkRccZBBCXks/2arCVsVzNBPnZAcvAZeAvl7vq8mXqxuue1DwrmWkDNVghu1NHgI1R1N9lwQDj+WlThGJiddGN71wzgqGAgwvYM3hP9C3Be0JIDl0RiMYQraVr5vi2yelXc7oe36EYiEqIkbZte13MZIeVagHB2J6ZL0VtZ6CNpHQKmsERzlVU1STXT3pwSwxpb2HN8p4pPeh4/5NBGkJyOPbtM6RsWgXQlHPKT1WlFJEJSBLxXogxJAYewDmXU81OKECZ8rmO4WQ1YvX0+pJ1yAwWKkyD6dzk/EjvKv+dwf1Cjm7vAUYw2TdMbghGlKqGycmU+UHk4KNxJ6ggVqSUwbl/aujL6NFUa4IByvs9jz2kdxSXy0X6VzWq8qgFhnSnBawzlqvus67D4TK+99Uidn855bLML2dFeV/1/pd+J0Jvw+jdoqp5PoxZZwyEkFgErU17Sh+SjcJ3AREzYrYN3Njb5ebNPSbTCo2evRtTXrx9k72dKZWBxw+P+c4ffo+DRx1Q1iAHOA4/hvf/8hPgkzMqncbuq7825aU3DM5NCH0aodwGxaSzpk03sTid136fdXvEcysSEUnsFsl+mBgxrLWEzvHJu8JFXHExCA8/KuCWCQD1TLBuCs7Sdg1d01Fbh2/vo3qMtQvUxZR+UCaImrQ0xI7YNDz64Eu0iyfbwKzTdS86Sk8eG04erx61nB9wsq69FFbYV2+8cpdqf4HIDJEb1LKXUlIJqNpROQVUB89Sw776CnM17fv5lXH7X+IqHSA9SsDHRZ7nLSIVRipSf1J6dheJiGRwpAqoJbFUm76knrkG6G0xUsCTV3k2VsAs0tubUcfju4oGi/3SDFMnnd4VfVZj0hnVnm4i0aFOo6qtgiw+r3P7ZXWSJ7nurDa8iF6ybj0un2Ob9qpOvgqa2XS/rb769GULmHkCURVCuCZrKVvAzFa2spWtfNqSIgvpI9FFDMba5EiLJVJvVYEBRNGYvivbmUL5m+zag1G4j7zsrTlF8R8sk6uu+f5DBCMkUABjRppioM3nmJHBFsHYuketl+POOaLGVG9RUEVMldLKqBIJREKiCtfk0EaT4SgZZhU1QlSYtx3H8wVOzHCPkpZJSvukyNW6nmBthe8ibRMIMWBrl9PmDIpkVVXUdd2/F2MMOzspsiSqpnrkZo0+GcE15oivGGgWxzRtSrfStg2L5gRrXI7mdKNWltEe9Kx1+LrX6OehvE8ftT7e3JW+M2aYKeOjjL9+E9gDZJJDpziAVi34BXS1yjRzCjAzqk8MYXA4CAzMNiVSJXUYwRG6gJtaXv3iPr/65g5G53zzT97h+OEDtO0gKCchcvjhEcF3zA93eRbSLRoefvQAg+Pee4+4/+EN4NbacwXDjuwhPhKPA/OHC46OAy+/VoMITeNpW5/MBwISldnEcXN/wvx4zg+/+3ZvJF4rEcLCcPy4wdRCbR2KxVYV1Uy4/2FDcxQwCqJCRJjdUCa7Ft8EHhwfcvzwPsfHuQKrxbee7rjDTIRbOzvs79zgo4MD3n/3LkdH79O25+vql3V0u8pgqglBd8Dsgr0Fds6q4W6TTHaF6V7ujxJBA4sjWBxt9wKQ0gfsvej6FBezm5YulPR5kFbSRGufQ27znDBmoVpxQK+IqiKmLn/l+47X9oENrmtDnoNAjEVjxe6LHZM9zUpAiTwWRJTFkTI/WuOMfJJGGckbX7nBS3f2MNZwdLTgk3v3QAVX1RhjaRctD+4G4tXwV1t5Armc+X39Wc/7LLCufhcwHV7orHWiG/5aLe26TIdKIGqKClc1YBKIzpgR6C4OzFUXMVqePmXMVnO69mn60v7c5euUiCKBnOq0o/Me37Z0i4bg2wSddC7p+kAwkpCmGom+sKgIofOkd2MyA0qLasQYS1W5HnQizmBzvYp+JHlPA8khHUPAh5DetDUYyYAVUSQqvjgPrMsMLMVgDANYpbRJcXTQO7sSYGZImWmtpXIVPqRnKOlVQ/A9aKO0XZqbky4pYlIqKldROUcB4kABHw2G7E2g7eE95d+Lc1sE1CTd1Jh+TwmpLGtNr486N3JqaGqIqGlJK0w/URzGvcDsZsv+FwY9KzF0uuGWY4d6/09hrjndv8bS69TDgVynDDDIpa6CaVQLADUds9Yym03yuDkNJrsISOc6ZVPQyiZn0vPkfLhukMNFn+08vem8a88CzFy1fVefdxlKuOp0VYKGxAqmASNC5RwaAiePhG4eQD0aPaFrQCJ1ZbFGaLoWHwLNosHYlKITlOA99iVlz00QHNFHZnsT7uy+yEu3bjJxwr3wEGssKd3MsEae9cTTXWG6V/atKT3N3u0J02mFiqNrfXL+xhKc1VOZrm2j571Pr5NS5aghOwgDMSbmnzR3WmyxB5RW1ScJWN6koZV1bHTOirP7dBnJFpXqm9lbMxPd/NDiOxJIqz+9QuQm4q8eHAGgER4/gJOTlqY5xjcNM2OJ3RGqh4hZUNmWulImbgoxAWYkKl1rRixyTybPa886OYyI8yAdzgYqG7h5e0498ahMUUYgW8oe7vp8ejDMWeuZCDe13VncLpL74/O+O7i4DKDGYUaXHMxS3KKavy9sMjEGjh9aulYQiUTt6PwJoBjjsCYBpfdvga0yW1QGzqRUZZHFoeXkqMJIYXiC2V5kupfGZNKfMihFdVy7DU+xoqfLmnNHL1yLrghJVySBYkQkqehoOi5prC6VNDTUcCjb9X3whOzHWE1TelqeXT+6qn73/K9dlwfgrAuSWAd2XceSPP77ovfbypPLFjDzBKLxmlMyXWNZW9nKVraylcvLdDZhMq1ZLBYpmwppni8GTNWBJtyaClMn0Enn20zXnr8nGXQEWWMkz1LofmV5478pQr4YNE1mzFjn/C+G3aXvyLm2C8Agl+/DYrk6PcAnfRrAqiUSUQqbjCRKc5vK9r7j5KTh6GiOMTWII0XmJkp47z0xdP19q8oymUwAi+8C3ntCUKqJxdpkmFeNnMxPMgtOhXO2R+RrNqiEqPiY8o0bEYJviaEFDdlo3/HowT0Ojw7pQsAYw2x3P0cMDzvVpXezcQMLQwTCdcnzAJZ5kus2lHbGpsiIEFlmXho7IpLzwA0bCAYAGiIYZ7Es93nNTgDNv68bDwUoNgbHrIpm49y4Q/RPooAmAM3S5iU7yLvY0DFl/9abvPLya/ziZ+/xz35/n0cPn01u8E3yycdT/vAPXr3QuceHLf/7//KtpWN7+5a/+T+8jKfj408OebgI+LCPV8dsts87vzjgnbc/YlLX/Kv/u2Nxspn2/923T/gH/+vbAPzd/8xx+4uCj4bdvT1+5c09/uBPj/np906WrvnG362ZTA3zxqMSiAhhww1+9L0JP/peirz7v3hr5duLG8EuY4qqnKOyFaIWcRVUFda2XBQw84U3HF/6q1Oq2hGkQfSIn3878vPvbLdmAG4i/ObfvsFktma89oaDksYqAed0NIYvYqAZQKWbRHvQp4hi7WgOcPDV/7BCFGJIzhfnDJUTrFXe+U7H29+5WF+4ivz9//6r/Of/zW8yne7w3R+8wz/6R/8UVcft27eY1Dt8/N49/sX/ecT8eGtI+bTkfODM6W8+y5aA1bpfpudtVJPXHFl37nX3chVPNAtiNHTdFIzBOgWTwN9wWk8/y0GSWIlXa5xABWUuK6yWKRWBIJoiWwsbVpqPCoNIxPuW+eKErmszgDxiMBib0o/EGOl8Q9s1FLBDiApihxpoAaAP+vVkOu31pXJvRQYHBsXAm9OE2Fw3I1gDxipd1/K4eZxSwVrbs724Ojk9u1DSb44MxDHtM4r/qgCiRaQHMBHTzoqi7+X2i2FIXagSc8rVFGHctgtCCBk8VGGMpeu6BIzxEXX5vsQM8FBWU32OWUNX37fkRUIgX1ccu2X/J3nvmNM7qvQ/MZrlNtChH/TpbDXpwXferLnzZt33p3V9rwcvnVr/zh4hp87vJ6/i2Lmoob6ce3aK4dVI6FXmmfOiai8qm/SAyx5/EnlenBlnMcJc9rnXMXBuYl96oucXpZgmAGIGTWhxsYqSua0QTb8LAWsiwc/xocE4YTrdxfuOd74Tuffu+Ab1yg2L/n1jTWUiywwxHwLfX1fp/KlLfw1HBvnCm5Yv/9U6s2AJXRdAIcQy/9gMhEv2nxKsdJ6se6dXAT89CzFWQCK+a/CxpevmLJoTvG+x1jCd7jCb7eLsBNSiGCRWXIn1QRQKAFAHAI4UAI4WluKhl5GgqcSluTD/aKDrDpkvDmnbE5SOqo4YE/nZt+7w+OPZkzXOBuka5fv/qlCaWmAn//7F/PPLLR9871dOHfvtv3PAndcd0YE3iVXOAEZH6aCvMXj9LGBoYRk//f15hV6hIs/xpkJJ9l1DxKIYjQkwI0oQQzSCSkCNR7QFv6BrDvnLb89GrEuwzBLTMpkt+Bu/94idWzeIMsGHHHjnj6ik4b23J/zku8tj81d/q+NX/6oiZoZojahDo00p+6QAubN+V16U5IDTAujJwJxhbhkBY5YALvmTpMsrPtugRy9Llj42SO5PkSGQNv9njXviVJiftjwJu911Xvcsy1vHLLNa5lmscWNQ3lauR7ZW2SeQLcPMVrayla18zqQoIJId+Nbmuf40q4xkg62oILh+k92DaoiZJWOzfWOdQjQGu5w6P/+EEBK9eaZhhxRJWtc1dV0PdOm94jQYO1dT4azWp1fUspGqdypqyssN0HUe1chiMefkZN6XY63NEVbJYJqMHRNc5Qg+5HMzGwCSGGRkyHHfdV1mktnBWpsBNX4PxH9dAAAgAElEQVSkPMbcDoLmnOTZHp1obn2gaRq6ds6iaQiqfbtQjLLlgq18KjIGrIyN/as/ZDPoJmNuipAKGJP6flVVvdHdOocR6Y+Px8Pa/j8OEDlDVp0TiFLVUxYN/Jv/7yd8662fMT9qmTdPz1H+zEQDvvuIasfyyqsTdl+Y8O4Hx/jgWISOxi+IIdDEjqCbwTKrUpu/ZNc+gLri5s4t7v9szvzoFZTEvFPe9K+8vseNLwTuPoAu3CA5YI6A9ik87CAXBc10vqFtAz4mZqzd2ZQ1WKyNYphgwy6hEaKdgNlBOQaukNfp8yiqaT1wg+NyPHdsctxd1imwmjrxQtcLyege01okYhHjiNHSdiCdwfsTLgqeuor8yz/9OT/+8B6qcHS04OBgH1W4d3+BdR3dQghxcHRu5fmXz5tWsuw2HB+9WJ9cGeGnrnqaPTsEpW0DaIsY1+vQMZCs02tkI9Cd3t85qnV5HskMNQWMQd4zRJrFEb5t8N4n8LnGIbg068xN2xBHNFKqSvCBVaNrSV0ZQkzG9VyvktZyAO6U5w9rAUDLzyWnrimSUmGa/ilDSLp526b1++bNO0yqOsGiY8zPk/cYmhpsSD+b0z4FT+dbvPcYa7DGElC891SuQoF5k+q9s7ODRk/XJsD8ZDLpmUPLvsl7T9Ok9i3PUVUVk8nkTN30lB5ID5dZ2x9W+8ayMVz7ti8/4z3gKpCklFEYa8ZlnCdXYiWJp59r5YwN99pcoXXjpBy/bnDJswTGFLnMc5xVj4tGKV9UrnKvi7bTeFyc9fxnlTe2WYz3ZgV0VmwFkkEyCTsTODq4z7Q2iEQ0tOzu1vz9/+6/5stfusNsImhOU7Y7q/kff/6H/Mt3f3GhZ3pyOb0CnjqiFTFM0VCAG250Xj47+2d7KIeun5fPY/N5VgCYy0oCOypOKpyr2KlusDeNBB8IMaZU4sFBzCmYST8pSXh2Uq+R9X0w2QCMHVIZaky2pX5tRTPTcupjNq/PsfUYm1ieDQE0gHZE/wDiIU6PEWnZqyx1bXnfbukdnydpFoc0jcGYGmt3QR0SwarBaOoBz2q39LyOxWctaZgp6AJsS4hzYuwQWzGpX2DRgYmebv4Yv/gEEx4zreZY3gRubixXCEz5EFl8gMFR40AEYwJTBxP7IrAMmNHwAG3vYeyUyk3wXcDQYaUlxg5VwccpIUwIsUZ1wnR2E1PdRGWGMkHVEqMgskCkyWtVhaoFLemfxnqz6WucEDPn6Vunn1RRYvAcHBxgbQpKTcGn273/qlxJBz6jHa8D0FN0/FWWmXV61Dqg+Wq5T0OP/mWXLWDmCaREhlxneVvZyla2spVPT2JMMQfO1sScRijEZPK1dgUtnhEl1ljUWbQ43bM/QDOesgedlEjFfK3kL9cZX4G1ilOJ9kwgFrJROX+KYE1KIUUPeslK02ipGuyYMo4b7MEk5TkkI+VLkqk+oj9GDg+TYq4aqao6p1myEDwhdH2p1lpihHaRDf5BqJwdjMuSGHaiAcnG9fSfQaPik3cCYwRnLWIMMSbjdlCfDCohIBqI6gm+pW0WHB8dAMpsMsGIQYzFikOlMAU9G2VyUwTys5Ynve+6vnlVWaW0Hyv9Xdf1x8QkJ3RKQTZQ2BfHT6EbLXnmXY5kttadYpPZBBIbOy3OMpVsRvIDAjEK87lnsfDEEHnz3x8MoEXySM4GvpizOrlhgywJABS1IQYPmqionZkgpCgXawzHB5Gff//pgyoWc/gX/yhgXJoHumA4OklMGtAQcko0IwF/CQzLX3z7Nj/90S6Ioa5r2maX+58MUZ6lpf/83xzjJpFFE/t57/DBAEBwNXzlGxY3sTiXosXm8xOOTw6ZTmpcdihZWyEqdHGBMYHbL+7z6hdf45/8w3c4OV4PaLgIaObd73d89HbI4EnB2YaDe2ekpToliTbbVTfoQk1dOV79iuHFl4Spq/l3f9LSLn75Nr23Xq+4/VqFGHDVeuPC+HNVVp28684/LzJnXXnLJwJxAIb2jAJl/RTl9ms1s32TO1JiReiBqMn7kfoOxUhSil42iBhj19bLTJQHD46Tkzko1lZpzQyBtmuJ0fPK1wK+C4BgTWFxq3IkGtl5HLDOouppuwU+LAgB7v1wl9Bt96VbuW453ZfXu7WW/3qWYBmA2WTGzb0pJ4tA2wZaH7AkEK5kXXgTo8JmybXOEanCkAJWBLwPdF3SlYP3xJBSK/kupVsKPvRORCm6c//7iMEkDo5VGd1a81w1VLUwnpw/H24y9MIy+GM4v9whzYsxM8M4V4FC257g/SKBml2VATM+BwOkaN7CDJj2PpGoESPCZFL338WoGIo+mOZLyY4HI0LQzEIWBhARDIyG5VhJXdWDipS+bW1m9QyZrXJV0r5u2G+llE+rAJuU4pcRO0FK+ecwZgDRFCDS6nsq9xl+Shnk5x6YcIZ7XJdsKussoM71jtCrOC3G1z3LPdhl7nGRum8CGD0Luazj5/zy8mdvX9CsRhkkJiBE6r4x9XGNOShGMKIgHdYpd3/ecfedZGvoOsWZ7O5Wi6vg4Bff4caNGc4OY8JZy4++/+BCz/3ilx9T7zWkNJcTnJtm4KRFjMWIAXF5jh3ZSPKmUIp9YxUiU4KXchvu3nQYMX07lLkktVN+7yQfQQ+xNJlD4FO2K1xYeqOTDLYptNdDQzjh4N6c939SZXtZ4vvYv2V582tTQlnPJIKklOA921nvYC6AozGIEfq5sA8aI+27o8tcEYm9gugRAnff9dx9Lw7XFhtdvx4M5WZXNTHMiLFC4z5IxFmDtcLBp8wyu5VlcfWMqnIIM4KfkFhAEiNVCsYbg1C38izE0mKlQ40nhDk//2Hk4KEBUaw9JhERKjEIMewjOsXZyOGjs5mbutby3W+9hjHZht0DsBVrhINHk1PX3H1vn5ODup/fYw+kK8A8SYAYNQkAQxrnb/zmITdfahEzAWMJ2vDO9wOH99O8IzT9PCWjWQng8EHH3m0L0mFMCvrTPN8kdsl8YpnGsuNgUA1zEKgxTDMzZLGNPhU79xlA6GuXM/zilwWqnHXdk1xzHUDj8e8XAbmeGegMS3vCrVyPbAEzTyBbwMxWtrKVrXy+JOkbJhtjIYSIsVCcYcuAmUGy6375G5EcuZKNp9nI0RuIxptxlh1966IKxwrapojHU9J74dY4Ahncfb2Nde3TrdIDClVV94ZjawcARNt1xBh6sIKKwfsUwaMRjLjsJCxOw+wolGR4UB2l5lHJip9iJNU2hkjwXTI0i2AFjIX5yZz5/JimWSRaX++ZVDXOVqRNTjKg9+2+lUvLEoL9CkYFJTuIpThAxt+Uvj+6n4IwAGWMsSPQjPR9zFrTfzrnMpvMkE5gFaBz2U3kueer9IOpgCdufbFaGZfjMmLefAPYYVMo6e+ooNGBKiIWZ+vkGCNFvZkPnw3Fqvfwlz8qs4QfPcHq/S/Xnh9/dIP1dOfL8t47DVB6xulIvaoy/MZv7dGFjqA1yJSjE8t+Y6kmBpvTRBgxEKHzDmuF27cNN2/5kpXiyvL4E12p1+XYRG7dqvjiy8K9+49x5hYSlb29jju3lP1pxVvfbJ8yl87zKbsvWO68URNCxG6ImL1I5PX4c7x+XWb8Xywiu/SDcT1hegNm+zavc7qqHSBAzGu57dOfxOTczXNiv46O58WVOhkBjCI6pExJc4dy62WLagpPNmZI5WisTab+KESVnPrD0PlIiBCD8OCnQrgM/msrTyS/rBaAdaNxxRz4zMEyAK+++gLf+MYdPvr4Ie++94ijkw6RCqEA5S4p4/lCNTn/cnR8jIGokWbR0LYdPgNjiB0aE3imsEqGELMhP7PRZGcAIsnQDvQI+TWdqsdsnFnHlWs2zIMiZT9ygfbIup/rI/sDIfj06X3P/CIyTmdUUiUlx4FRi5rBcazZOe1cPeyjclViBGMNxpDnuoFJrIBgio5YgDBFt0zsOstg6wGQdMazKtA7VpYBLol5NKJqUDWEQA8S6svN5zpXYY3rn318/3IjXcNy9HQCAc4r8/L3vO56rtsvf9pyHfVJ/SOeOvbZjR7Oe/ECGCPmdBYmzT3ZxmLylBZDS4wLjFGsdWAgxjl3XnyRh29H7r5z1Jeb/hWSNUb48O1319z/4rL/Us3+yzaPW0tVTzDGpdRJheXEuB4QqDH2O9kCeiv70CTjdzY2tozmrRHIcNMbliUQzvK88Lz3C5EEXtQMFC3t0HVHHDw85O7Plxkj1NcI095JnMw32YBEHIGV+jv0P33wVWaJEUO2B3iMZOY4CQgdMc4hdljxLB5XfPKL5TRd57fqJP9s5XkWZ6Y4U6HUGVScx03BJ3y61fullTRdWlRqHt3z3PugrHnjDaghpR3bOXX9OgnB8NEHL1yqHscHM44PLp9C7ZU3bAJ7Cqh44IjHdw333ruYDmDDgmpxAOKSbdAmwGCMksgsxSGmJgE00/qj2HScwb5Q16PAs+d8LbiYjBbFpyhX0anGjDDXcf91ddnEILMqq7au4ptZB+7fytVkC5h5AlEVYtgCZrayla1s5fMiZmTgKI73Qn2dwC/rATMKfbSM9CCYElGupy4p0UObdLR1lHpnKT+ritsyCEchXtzBOCqEwRBFb4kWgf0bN4mqo8hXn+xdYinWLjVCUMFoukhsziEbk3NRJNU5ls1qLEblweiRjNgpskzVp/t1LYJirCAZENHMjzg5PqRpGmIITCYJ6R8L/SVCDMVI9ew2EpePQH7+RTEjx8xlrhvwW8U0URwe5Z2bPIZStKwdMcos9/3ljYRZGhvD2FqfA/Y6N5JmBeR2sbKz9a6v1PJ3RqaIE9DkFkppqUCsEAlQKfsvuWQETHenRGCTo/aMCF0LRw+v51mf9oj54mtTpjNL6wNt61Mqmd5ZELGiGAFnLTZHlbsK9vcmHBwGfAORCmv22N27gZoWxAMB1YiaCOyiKIeHyuGjj5jd6JjuGObHcHK4/ISTnchkNxlkjQgnj4Wuvd7xa3RGPDE8+OguL7y8j289xICKIbTxl9Z6Z41kZhlZihaF841A61hk1o3Nq8wBq9crif0s/d1/AxQ2hQEUCmmsmgIQzU5zJbFIYVyvZ4xW3HRaiVwWTs2Dq/UrxhKhQsWASWDTMl+ndVYJxOSuyhX3XnHOUld7aV5RwwsvH9POOxZHSnP8+Vi7nld5ktY969rP2hRyFlDmWT+LqMOGmkorXnl5n48/ecR80SUWxiuazwozDcRM8R4SYCR6us6zWDQ5nVKaQ6L3aExrWIyKamJMs4WEQUlOw+J4zVsULcwN6zqHcipwM01Jp0F9py5dB7wfOX0vcv5wz4Tc8V2gjR3e+z6Nk3XZMU1AJIMOSeu+94HQp6BKDlNj3NJ8PziQ6XXKVdBkAc2MozK9H8Ar1haw4vB9YsyMS/dYes4eDLDcBmOndon+TG0ndL4AcnKrmMQQKpWCZCYLChPQuK0HIMXqPmN1r/FZ2Xtcp26+7pk/K+0wls9inTeKgiljRGDg9UzjO+lIEWsUtOPhvRO69gTnwFUJ5Bv8nBd3XkS707pQ6T2n4San29DVys7NBNaxObAmzbFpvO7s7bC7U6Gk1KDOuswqM9h5TM6VlPTBtGeTUTq1kfq3UofTc9Jq4NRFXvtnr2+sgivL3Ap2Yrj9SnIAl7lu56bBq4JmBzEw0CXHft0aSivze2IMMRJo/ALfdvi2omsqQmipJCLqMeIR7QjdHLSlsrA43gOWATOnZ/WtfFaknhhu3EqBSG4iKBXJBuNZminK3mr7op+pKI6gLgEn7YS9Wyf4WIKPMlBaykoRicETY8fJYYVvnw0goJ4q+7c8TeOxts7rRQ5kUagneyhVZi8PKBP2bgqxgzRPeSBy+MjQNqfn7Pag4eDdI4IKmJDY1kVS8IoKSIVUu8xuOKZ7BtUaJTHhaD8fbjvueXLd6+XFAqquXuZ4n3HWvYr9e9XOtQXMXJ9sATNPIBqFGK9v8Ok1lrWVrWxlK1u5vJSoQyAbS7NxlAEEs9Y43EeLMjJsjg2pSyePPjfP+5eidd5wTW+MWfm+MG+sOhXLOYMCJv0NxiXHGIkh4L0SfARSu02mVTbup1QPqoqaFDEG5MgiodAsx9xY4ibJGRgV7z1te4gzFVXlqJxNzKnQp2ZCPV0z5+DxIw4OHiMC1jl2ZlOcc0SFqCZtNpDkPMRm6Mzg6Hza8lkxaJ1HCwkMRkEjCRh1STEyMCyppnRnxcOT8pIP0bhmHM2ra5zfUTHW9IwJ5ZxlA+Xm8XD64QagzWZZMZutuc94fG2Myl4a9xv6h658GwWDQ6Ny40bH1/6OxzqDsQKa0qB536BE6kqoKsvDj+Ct/+dyrCcbqvHU5ff+y5f5lb+yw71HJ3z0yQEnrUVF6HyHhgVTF6itcmt/l1ld07WRew/mfPDhEUiNiiNmo4QSQUNyTqpBsIimaNAIdOpBOr7yu8fcujnh7e8pP/rWMpXGnTdaXv2NFg2G2lT88M8qHnx0vWP5W9885FvfhMlsxl/7LyJ2WhHFctB1PD5qCWeAHD/PIqIYA84a9DSx0ClZB1Q7K5XBskP1bJDbOtCNqhI1kFhlQv57GZQTcvqP4oBO61zqk0bo57cECsypkmzFpJ6llCLG9NemCLP19SnPNugq6TxjEihPkBT5rAP4QEQIMTHZlHpba4gxAdKctYDn3/uPJrSt5xffjbz3vc/GOva8SsYxPJFc5frrfmtXmZFWQTDrjq8e1TXnPGv5o3/8C/7oH/+C/VtT/qf/+fdY+O9z8uHdlALoCg0rqhB90o810LZz2q6h6xratiVqRGPRzSEGzfPIqAwxPRvVyDs8+iXrV6KorGeiO83Xw1JZm/Dkq0wXpy9eed4VkMjq8RAkM+Uk9sDZLLFWNs2cbjFPOr21dH6R06qm85umZTKpcS6ZMENQQtctgWDGIOqY2SjHjIOrjDIFCBNCyHsXpa6XU4AWto9V0M2ynreMRirnbHKKpz8CYtKc3QOw8USVBM7Kamea84f2W1ePIX2VrgUyPU0D/8UB42ff6yr1OA02uPrMd979n+Webt3+5VnX76rlresXBrAmp36WkoKZtGnTtJ8RPEJL1zb84M88zbxaKXmPt/743nCfNfc+DZc5NVly40Xl1/5WQHHs7t5AtaJZeELwWGfzHJ+0sOnEDWAaClvfKJjKxN7u8ST9d9Pf58nzyyawqpenz1XWndnObV7/ym2+9FVJqVCC4EPa+2OqpAOPyhKSDYDMHoamPYOGBmOUEBpEG2YTxTcPePzwLh/97EUevP/qSv1c/jmfVWK5xlv5rMgLdxy/85/s03rAWLyAElBaSupG1CHRZLarz5s833Av0WyfiREk8pVv7BGEHEiZGFYmVnHGE8Ocdj5ncfKIH/27mzy6+2xSnt3+QuB3/9Nj7n70kJ2dL7Czs4MxU7oONBpUXLYxGyQmtuO/8o2AiAcWGI4QWr71xzV33z9tO333vT3efW/v3Hr86m81/OrXPUravxszI5E3FJvG8/ueryRXeKQn1VcuK5vW3uso76JlbL5ma7e5LtkCZp5AogohPCGn+0p5W9nKVraylU9PQmwBj5hIyCh3Z6uklPYOzJj1kAwvB66U+1Y1e8NOy6VXA5Gcwma98rbO2H0eejkpYevrl2zRQl07rE2RojFGIpmW2Agm2h6Bj5KZYiBIlzepEYNgnUGcJMM3MTFJVJbKprKFQAwdikeIKC0PH97nwYMHBB9xlWM6nVFS/Xif0rCIjomNU8TRkEroepHX6yNvr39NP0s533S/s4ysG0EdZxnW2dzPzrqugFl6wIgdv4MhSjqdl6PMYiQqGDWIyf1Mcz5hTYwkSnrfVVX1UYBSQDm5wqXMdIflZ0FT5LZISbWQ8qSnEwQkGdWimmQQlYC4gDGaGEECmQmjONM193ezZDQe2iciWhgeJKVg0kICZahclRw+mWGjRKXH6IkSwaZxoxJzfmfAWFw1pSDbfBC6LnDZNEFjeZZb7x/87BH32hNCVHxIqWkUwagBZvighADNA4ORgKoQ4gy12RUtJcd0Yf0RwA5AAwGjPrFdqQIOM3uZRTA03THL1L8gbh83q5MdP0bUNqxLC3UdkvpBg4kGi8VgaUKV7/c5M4BcQEKI+NYnxrGV5Wdd9Iz3nsKsMk7XBpwaf+cxTq2yEKxjpkljvID9hvRy2i92ZPYERn+nc1OEXFkllcSgkAxrQsPcLbIjxvbPYmyFca533CYwzCgdI4UaOKUhK+lHeiYEZGm5i1rGCZm9ILFTRR9ogqc1gATq2uDcFOc6nmQe2UqS9aCZ86E0z5Nl4NTaeSlZBsOsHl0PoPn0pWk6/vSb30ZNwMgeahTN64X24zsxUI6B6UIGPJD0gagtXXfM8ckRx8cnvQN2AEIM24Ee+GbrjJgYgTBgBGTXpfPL72f2mQ2NK0Nx67/f4LwvII7ECliA9pEQYj8njh2lJmdfSWlWhrQlxeBf1/UpA7AIeT6Duq45OZ4zmUxwVZoXjU06Q5KEMBQJCXTbdbiqSnT1ktaXCtuXl/YYaV5UAj6k9FeTSZ0B2RmIpJqYw7J+0X+utvbKn+eBNsUklJJqJOaIaglC1IiEFhFDVTmsdRksld6hrDHhCoKxJuu0ib2sgIT6kXYJsMrmd77ZqL/ueS9yr/Pk7L3F2amJV9fwi9TvMvXZFGRwEbnK+7jIPnDdO7poHccsJ1fFYqwH2EWi+lwXg5LSkyUdPuL9AuciYjrm7SFKzXkr4Lh6m84c4DIj4IxYjJ0AlqZtCdoRlcyEO6CUi85l7SrwTQlh0IvKeavPfREH2Ljcz0qQzXrRvIjEHoAIUFXVqC+t61AmpR9RIRQQQ26HEEGMIYaQgTEGMZaTo0Mm1lG7rPfGlrb5mLY7oG0PqCvP/nSXL94S9ito7sKDa3jCz6Fb+nMtQYUmFJbiFEyDBEQSg6yWPZAMdpxnI8t6XZK8LzzFwjRav6RcOz48Lmtk9MghaoMh9vmTYLRYjUlsKQbRiC1wSkn6S6cK1Jjpbab1TWzVssk+fd3i44yFv8PuC29gjKVVC1FSIKfkQMK8n0diqjMpWBSmiM5AhcBj/n/23q1JkuS68/sdd4/IzLp0dff0zGAwM02QIECCC5IPEi8r7mqltTWT6VvoA+hr6ElPMplkepTpTQ96lK2ZtCvtri21XHJJ4xIgSILADDBXzPS965KZEe5+9ODuEZFRmXXvywzyP1NdlZFx9YhwP37O//wP1yi0HWUXb2sUi2LxKEKbxZHkZYqnvzy8rIu6Ygz+JsfrF2FDbnEz2BJmroHksL/JF+WrbCRvscUWW3z18ejRQw6PnuNcnTOzBR9CDoCliRWQvdLXm4SsywC8Di5rt51n6F3k+6LIUwKWIQZK7ehUljwHPQtpAcVITE5uAWuFqnaInaSs2pgytUQUmyMIPixp2xOa5YKTk0Pm82OCD9RVBbXJdcVdnhPmIOapyeiLHV/XtdWLcHxdheByJvllMO+W8Xx7uA9G613hejdlga46FFe/N10ARjvHv0gmhQwC5a52OOcSwSaEQTB5cD1rHJeSDypSCG99hnaJYgkBY2FWV1TWICYQw5wQTiDGTslXpASh+5+PP3R89EG1kt/49vtL7r27pIkWpULE5Z9cHsDYQd+gaC7ZIFbyO6W5/nYJ1yT1JEroJgdLdg8s3/19R4yABCqXgkjN8phb+xX37t3m5z9u+bu/Ojp1r8a92r1vtrz5XsTaKWLqLB1boeJofQqOGSMYIsRA1EjlKkIclBvY2FUqdqYcnaw6EnrCUXKkKhCHnJXCwBqd9ca5oyYFmjT/FhBHiMob79XM9vtMckTZOTC4cmMNJEndVcLM/d/aYf+uJYZUVqOqKsSkwF0bA41vqVzFZ3/TcvT4LMeOEJiloGAmPi5CPNVcrhbuf3+HemISaUwDGoSf/dUS3yhvvu+4964l5GcyRo9q4PgpfP73VyMI7t1W3v1O6BzdqhFBsK5K6iTS3xsBmqZhOql5/JnhwccRWylv//qCeneKGIsAxlraZYNzFUbSc1tUowB2DiyhjTm7bH0gQTXJ5A8DjyVQsU6GdhyQGGfnrwuiFUWB4T7KuskNufrslWe1fF4lQ5S/BYzpguiw2geH1iNBMBIS6dQYjI3Y0GIykaaqHILp+qzyOJf7430ghpjaO6tvDVEC0OXcCtlHNZVLlAiuMjTLREq8+65jsqO0S89HPxT81f19v/Q4nx6zitfZK3BeaGFMj9HR7/LpdSLKuBp+7Xcc090a1aQUZazQhiOM2vzepQSn4ZUpmgkvvbpHsV28b2mWDcv2mGU7p21TYDZ0fZ7kcq7ZAd89JIKUYPJGDPuX1cUi5vRyelXHoU3SjaUyWifb7Un9xHZkQY2JlaOFrIdmH1ZMNlintCAdIUUhB55LolnEhwDRJ1UtEYL3SSWl9L2lr41FkRAqV7G7u5vmGyEQ1VPXNSKOEEIuqxRwbobGQAyBNqbzcs4RYiT4FOg2xmSiDFgxGFdhRWi95ICvR9V255eGlnRfNxJmxndoNKacXpaI2lqIRUFRzQE9etJCXafjJQKPFl4QnTkupdxJCtgcP/Z8+iMPCm9+N7D3RoUzk42+xvXk7t72Ln+PCQGr5VAv9ga/CAf/WWTYTYTZ6xxnaHvc1L6vi3XEoPH35yV3dDaOyJXJMhvbomThpw8My+ukQKNnfvKcZnlIs2jQ+CZw8cTUU/OW+yfs3xWqaoqxFdZW2U9gqGZJtQotZT8EW+UkBYbtcfo45R0Y25XFJ3JRotNQHWq4zleVNKOkMdA5g3MO71M5waTglfumtf2lQdQOmE2aSEulDDgmESBRkKSGuFgc8vnPHc2xTf2eRnyYEOMBIe5gjfLpxGHFEPwdnj+r1xz3atgw6m7xGsLoEucfoFIRxYGk5CvFkgwuC7g8EXsxSTGXw/ipGlpqhgxF9fIAACAASURBVE5u+5TlnD+PlAWV06WNXy8ElDDq89L82HRjkGFYesgY4Ve+53nnW5oJK2Ewp81q4mK7JM4HHy14+NFi5ahvvV/x1vtTROts+5Yyy325z3Q0oZ4ZYqyQlVKorKw3PveeICig6Vm7/71bfONbmdDdJXTmn44YYrp9lP3FvJvd22lfXVuVW/51Jct8DfEiFAI3Eba/ombEa4ktYeYaSIoDN5elviXMbLHFFlu8WriqwjmHEUnByxwQvGroYqMhk/99WQbNTcsUqmrnGCq/VRWrrnP8hpAc58aUQEOJEDqMSQIjxghiwPuIoNg8aQmhYdE2BN+yWJwwn58QfINvPd57jHG4aoIYBzkrsyPldIHL4bm/2IZ+WQ6um7yPqcm0I8F0PILB93lRF9QtgY+Vll0TELjIeZznGJTB+r3M/Or6JauvkCvKesWJf5HMykSsKVmO6VeR2E6bBQSPxDlGAk6WCM9BD5HYIjF2ATJbyDLO4pzw0fEtHn5ya+V4b9x5xq36CV4dk5038N7QtNB6IUSDyATfemKMOAt1nQIq1SQppvigtI0hqkkTcSqUKgevJN9RpdqxvHG/ymUeAs4JRhTvYXdmuX13whefrVGeWtNGOwcV9+4bjJ0ClqAgJsnQeq8ENbnkloGYVDecc2eUcVi9zynYv3rkjhy1aasNwYpNdXtLPFBFKHUOhEQs2juwWZkmoDGgeMQrYiS7YE5fx/6bhrvvOmK0ORhXUTJPY/S03mCN8PDD89Q5FMM8EY1iPqs1l22scO+9KfWOSWQZjfil8tFfN4Ayu+V44/4kZaYbiCERZmwV+fzvr6YQUk0Nd95NfazkLHhIqmtJIym/c6Sxsm2grirmh8k5bqxw990Jk70aTAqUWGNp2/RbRoS4ghBLwHY1eFcCC0VBBU7Xbz7rmVs3Hp/VJ60j0PR9yuo6m/oY7VfMTr8ccBv1qYVgoJmMkzSmknNXjOnayvvk1OsDLXSB7e7B6QiBp5+lcRuUIE8616SeZ4ykPihYZvvCbE9YHAc++dHaS9ziEjhNmsnvz2i9r4JHoDy7Y1yELDMuDfQ6+HuNNdx9Z5ed/QlJ+SsWSloKOnR+7N52L31+iroCMRJioA0+kTWaJU3bsmwb2tAmJRqRFDzOmaGpb5BRZ5DVV4rZPAr6n6Vwkb7qn7SV8bEYegN0bvvSb5hsU8dI0FzCyJL6ZJRC6Cm76WzHgVpMp/hiDNYVJ7/kRQYkta3GiBpJQSyRdA5SCEf5/GNSlStjQlX1ZVqKrTEMOhe7kAg2qz6E1oNqttNye4WYCMUI2Fw6ViwYEvFUJKt9pXMvZKhiKJYyokOc97ks65Z3X2t3y4RSorSQjDKxGpPbIa0v5XmU1H/0Cg7Kch558PMUJLp93+Xv+2diaC8Px711JJNNRIzxc/eqSCPriK+bznu87hjnzWHGxxguex2wrp+4iMrJ+LvLEjcuQsQp3WTP8opIUXsQz/HxI54//YLQzpnWu1x3VLjzTsXdb1qsq7Gmxto62dhDIqL0c4OzLnfdvd7UXmc9X0OM56llP19l0gwIGtP4Zo3ksp+S51XlekdbqAVsNy8LYUmMDbEQByXNB61YJM+zJrXj8HHg2Rd+8JRU+edlXenrYbdssRmqHg1zTHULxBDFdHOsMmhKV/f29bmbp+25FQ7F+RMEySt1+3lN+xPjUW1Ytm0mnENV1VQu9dVdMtvID3/wlqMQhVVtstsyAUpIyTkaFygNi2eBh6PD7h8Evnnfo+yguCR6LiH9lBmZ9nP988a3U9+pYLTMwwGU2285euUfurkF+fvung0W9WULtVtG3ra7s6/PY7vFObiO7bkJX2174auBLWHmGtAbLsm0JcxsscUWW7xa3L1zl/39J5yczHMelCCk0kJ9HG59QHPtXEvOMYJesaF7EwSMFcdrJh6oKsF4Wh+orMvB6OTITVLtHh8C0Qdi8CwWc9CY5doj3i9plg0xBBaLBcvFEkSY1lNm0xlRcwmbLtsiBzDGM8suODB0Tt98o192MvWq0cdkhu2Sp3W9553+WR8884PJ4zAb8TysrjOKtJxe+/TH4SaZqGVKHXlJkvpmRd7/9H0ZZ/iW3927LmQmlyOQM6lVIbYs58c8eXSCoaEycyqWEFpMCB1hBpOIBeKSEsTJ4engfXsSOXnkEaNMo+KXLYt5y3IZ8dEgsmSxWBCCp6ose7uzVHJgkogzbassG0NUS1SHaqSaBvbvgA+GFkfEAikAZUSJUZKj2Fis2+ekiTRfehYhcPBWPxUYtpYM3pnprQlqJ0RMIhIR0wsoHmcUlz04qgas626WKfUXRFcetRV7t8siLPcknUkqu1VIS8l5UfqXdG9L2+bASGYN2A2EGSPSqZyIKlVlkkIQSl1ZdqY1bXuMb5eE0DA/UZ58YUAj7eL0+x11mQq9mRrE0oT0DFREZs7yxl6N4Pmpazkrc01j5OjLZ4gN+ACIQ2OFjgj5RuDOLahmENTgPRyHloM3DH4pTHctUSwpsgliHWiSt79qSR3FEs0uzmSB5FxKrJVhubtyHwTrHD6Cj01eIlSTA6xJBfFQJXjF2ZqQs/4hv4eDPqgEZgv5LebnwIjp1isKCt15nCpPomzwS3RYF9zc1JevBNrW+Fb77YYlmla/UwUdbVyefiATtAoRJknPp8zoROhKMexC5ivZyTlWbySvZzBWu5IvK8HZ0TUPs6KHxKMYAzjTB4dFEKPs3fOEVomhZbkINEcvLzjxdcI6f/dFfOBlxU2qFvoKPKfjV2F8Bnrqt65d72WimsD+QRoPhmoxVW0QdvCtoSh2JKs2DBzoRcljoDGlmkkdgaiBtlmwWCzwbUsInqhKUEhlAnPZRkynLAMdB2IUTexbtyc8rJY46tYsfRSljGOx8zR9Xhnci4rC6t3o1pdEgI0AMfX7ISv3lTnNsART2afNY49mok0hB7mqwkhWhAkBBZxLdkfIsnEigq1cvlbJ43Ui34ZgEIlZ9bMb6gcl+Eog1gyIq7l/o1cqjD7gqtSvtj4RmqxzaT+ljQa2rzGpFJKIyf0pg/2exll97fDzynpmTLrp+2NrkyJPIQRBCaiPHpOBHV0qB9vKcivbdtPZFCOuI9QMj9erAZ3GeUH/s74/j6R+kxjvb5OSyk0c+6bP/artdJlM5fOSGs66/1c9h01zrWIbGQmgC2I8IUbP8fOahw8OOXo2xxpF9jerIW3CdBemu0LU9N7s3d6lnhk0ppK72qnVlPneMGkpdSylj11Hhrkomeqsv4cwRkiyBXkcyGO7SpHlLf2yZF9H6Xd8voZeGbULrUocBFBzEkOJnZ8ajc/DUEmxi9T2n7X/2C3O45uGXnUxxkFwt1+x+1FsPs90tKNHDfOTOTG2kAkzGhVnHVWVkrCUCRqWgH+lVIdXeewtzocCQQTjKpA6+Uw6326mzkgi08Y8rzx6EmgXkWpi2LvrsqLeWE1u/OQrKp7+aRBSQpMM1lTKfHk4Dxz0NCRtpfJiKcHPsRKx1iS7Kiva0tk9grFpfO/7EsOg59iAdU+ujr5/8UgF8FI5vqie5w89VnbY2w/Uu56q2kGoyVK/lH4aSb6IYvuo2qxSleexBCwL0GOMBlbqEgPCHMMxUT2Ky/tPCmiJOJ5+i/bl0VeIVvkoyV4utVTTnpNi1qgFyzoDP+b47pP778FJ9n+umWSNn5stvhp4nWMDW6zHljBzDaQAxM099De5ry222GKLLa4CC+rQWDKuSZaqSHaSDyL3HZKzfB3Ok+vehJeVsXbV44ydSWXZsHSVrQx1VSYAKSs+hMDx0WOeHz3j5OQI79vkGI8QvV8JcFZVTV1XTGY7VJMZIUQgpkyAKFk5I62bMkB7R3TnBC4TrP7MR79vBpd1zp5FsLkJEtPKsTadn6SgxLq0ut65teacZFWqex1BZa2DVmXtNsOd5XBx9znSO90Q6YLuad0s7Z2vYRiQK0oQ69qkL/XTn4uhZBlldaSopDrBktUdapql5a/+xNLMI3Dn1H4vig9++gYf/PSNc9bav8QePe/cn/OH/2zOvHEQ79DGnaxAk5xBzoZB+6R2C1F5477h7v3d/M2gTbKjtVex6J8DY1z3d/+ddkH8qFleO6Xbo+pBksKNmKSdoQFCSM5idSGr06TnMb3KDWJyADIqMTpC6wjBIVTJKSuLfMyYsxcTKafKZeK6yFq+8KpqcXVSC9LguXewR2gWGAm8cWef+/fvcHQcWC49JycL/u6vG/7lv1qV8R4+TZO6paosTaiIQSBGnBFmdsm9PeVX799mb3eXv/t3S35Bu/HutUvhh388PfcuVw6+9+2GyY5j2QhPny/4tH3GP/i9W6AWtYYYAzHHdVUgEolydZlpI0ItwtTUnCwbggjqDEgAjZ1QcteNaFzpbouDSUVzuTSPouxMZ4SmJfpcns+k50Wy5nEkohoIeJybEiIEH7HWZWn3TMBSRaOnL4/oQHrFs2HgbF1/MA6sle/HQcRT/edov+uy8Tdm5Q/W688n/63ZBadkQphig6UNKYidgqfrpeX79zHfO5NLaK257qEK02pfnB4cKwZxnkAgkO7RdH+f7/zDJc5Fjo9P+OLDEz7/wdX7wV92XJggcwkU6fWXRZw57W7Xle/G1JjLhuteFA7uwu/+kcHVu7TqCDpUp0t9dRrL8hWUdyTHGEz21yipHwzB07RzQmjxwdM0SQ2xkD2TApcdEP5Y6Sc6+2ngCVfV1RqE2ZYtJBBGfVe3koy0e/qYwnBHFEKiJrZd+hxjuuYQOzupdlUqkzTqT5Oyn8UYx1ApLMZIIOCMw1amO5cYFM1+s6QKE7E2qeIl1azYEf5ESjA4wdlENCrlHq0t5ZdCJtSko6RgUurzqqpCVfG+RSQRdIwx+JDmIU2TSJ37kwlVVXV9vsZI8AHraio3TUQfH/L8A5wznY26jiBzHlFhaDeJSFc6b7iucw5rbUecKe26Yl/rIPw9COhHTaW+ZgfCb/6T3W6/pY16ovHqMzi23S9CEDgLlyF0XAQXWf88FZCvGta14VmqNpvu2Sa1meviomSa9LwKBosRh/dLrDYE/4jQfM7iuOEH/9+3aZZvA28D8OUVzuftXzG8/z1HGyfs7OymcqlZvTZqH9hM85hCCB6c76iPHF7fWLly2B+e1Q4bvxNNtrkCWoNWqQSftECDSgPi81hQozhEHRCwZo6qzX6qOs1VxaPSguSy1ypITEHkpEylaX/d5Q1G6DWnmL5xaA6+q8ZUEUZi70VRxcbsFVMQSaSBaHJJ1ayCKlrauijGKMXXBi4lQMUWjR5j4KMfNTz6rAS5xwkQ45qgaVBe18ovy84Yhby3eI1grMXtzPAqRE0qvqpVUitCETxCg6pP0x8VPviPJzz61PPGuxXf/8/3oCOsZdKaGCQnJaEm+4k9ahaoyaQZdRCrjsRhAKMekZYo0pVf7nxPAqjBi6T0GgvWBI4PP2NiFuzOHLQLFkfPWSxPMNbg6gmqFTu772OqfWAGWiWlPtP710TIJOo+wbAoEq9a5X0fKIN/XyQ0TLHssr9ziyiH/OzPljz8JHDr7SO+/QcLbtkZwpRUNiuk/lGafGamK1sqWojiqfQ2kvxKmBkiDeOkIaVB9RCjD5CoJIWaGdHsEMwElQkqFVBjosOqEDFEHLHY2eKJEhHx6dgiiDokmtynZuLj2S0w+rjZj7vFC8TrLtOzFdV4pdgSZq6BrcLMFltsscXXCyfHJ8zn88TgLxOjEUHgNGRjGZCrOqc27e91wWaCSPmjX6938CUizWQ6Yx+YTXdzsDuyOJwjU8HZ5NTOhYIQSU7wQMDZ5HSL0edkq37MLI7yi5SAeRG4zv0aO9DPyo7cvBPYxLmVdIKnl2uxO0qQVXLguzzvfUhvNRNvIGf9IiHSEaH6Ravkjd7xKV1QwRqLmM3v5DoUskeSd03HToEpi8GiwdPOA+d0BK8MlsCuOWRSVZh6QkCZL5Vnx57o9ohMYED2M92tlc53Kt33Jcy53hEch6og9K+haCZRKKTphUXxqLYYq1R1xWxWsVi2zOctPkYmE8uv/+out3anScXEp+x8g1DVNZNpjUrF8+PIxx8/4tmzJW1wYCakbNHcTxQSD4r3ARFNpbESJ4cYA//Z7/0Ks/qIzz7+KY8fPcQsFaORndkUp8/55MOfM1/MeX70nGXT8OTJHvD+yrUPg9zf/dY3qO60fPjZMwSHqy2+9diJEE3DTz74mPvvvUXrb65PkgjTakIIkeAhROFkkhyByd9lMGowKhhp2a2EtnbA8moHNAuCfczff/YQI1PUVKgxTJyhdoaJFaYTy63dCXcO9hGUtlly8nHkMwQjgR35EitTPEqUJXUt/MHv/wbL5pijw+fM53PmJy3Pni4QmaCagpqRgDjF++cIQlVZhIjPd0FzBpgXS8nWMwoyGAMuEvQb9rlxtO2YADMOGt8khkHP4fn4ts2kIpNKGdrqjMDXMEgFvfLC+iBuQYwx9ZkkYnAIDQu/6MZhYyxUirERkVQSZTKd3HQT/NKh70/KM933L9ch1Mgaf8JNk2jWkWV09P3roCazDj7A4QJmxnbDYrEl4Gy7XQCR2NlMURPZe7FI84ZCeEtzh5yxqhA39ENnBbFLsFK6A6elKTc69XrGDuwcTcpSIUAJjujozki3s/4bawxkssXQakp9UPqdyBu9CaRaVKx897m3HWMmuq4G6wvhT0RZLk5ofdvt27kqkXSNTYTdnD29WCxTv6yJMJ9KLaV2xubsX2syUcZiSYRZYy11XSelnJyVXdq6qLaErGBZ1HNiJgw55zC51GwIgaJ0dpF+/ywSzdjWhxTQk1xWtKCQexLhp2/fYXA+6umSlWPSy3BMG5Pax9uMieTXxU3PYUPYkJSyZoz/KpNkzsN1Eis2zY/PspPOm1OvkunPuucBpCHEOc+PPyf4I27tBaa7c549fYLyLa4bllAMahzWVCuqJptQrm1oe216ljaRsc4iKI33MUYakgPIMgXckW7EFFKgXfLcTLRFNCU+xDgjza/KD1kVIZciISA5aJxncolA383VymCSySZlvi+pj+0IKBIgK7BFycRP7ZNatFP41bwfASpMSPciBblTqSUhYoxH4xyhwVnBikXjnGXT0IQG6wxZiu2SWE9ZeRVEliEFYYtXD9EW1x7RLJ5R1XtUZpIT7iJRW4Jf0iwPCe1JdpMpsXkH2IVwgiweJIJuLhsmxoGxiK2xUiGDZzwGQ4x1svUGaifpPYxoeR+lo9zms0yJIiqgJoBJZaGVJeof0fhnVG3A6pxbpuH2rmJceveXjaU9Cnh7gHUHiEklhqrJLsYlhRs0lcruCTFF7aRXTUlliWz/7GrI671gn2rxFUcDMgVNiryVm3Br/zaGaW6YvHIpQ961ZbmsVMa4b09JZTWNQQmcIsw0h+jiY5xb4KqUdBm1wocJ6icoO+l8zAEqB6iZgFbpYCOlMrSUWn5JvtEtttjipWJLmLkGVG9WYWZLmNliiy22eLUwtg++jzOQroLXxXH3ss5DusylbgmllEpR6JnUuxhT473PmZue+mCSAxHZ3RNCV1LCGItzRYo9EoMQYuic20OyRLnWTY6voaz65a7rau13ke2G66xTaDkPyVnWzyfHDtWN15uz/vpSA+XOjaRnpSxZXXbWtawN0Orp+7Fu3ZX22HDq0AcQSuatzYGHlJHXq8yMj1G2Xf1czpGONJMEetNCIx4nVytr8zLw+GHFv/1/7qBqECsonhCUxkdU5rz368+4c89RVXWyXcXlUhQpC7DLBqRIcA/Kz2zAKacwOUho+qxAQ8SKx1iP0QXqYVaB+AXTvSn/4Le+w29/7y7/+//2IX/7109TDeuY1KhKSQLE0LTK8fGCpgm8+V7g3n1QprlPyGo4uY/R4HG1AfGE0NDOW372A3j800+w0nJ8DMvlHsR0pdZZrDW5XzG0bU1QZTE/u9zMn/6r50gV0Cm8/70KiaV8TuTJo8gP/v2M3R3P559e5872mM+V//P/WFBPWg6+Ydi5ByftAUsVjIHaKFYWSGjYqYX77+zxzlv7fLzn+Yt/eXylYx49Fn78JxOOj+/yB38045v3HcYGLIGD/V3+9b9o+NtPInUl1PUSAWJUnjxK27eN8OO/cIjRnKXqMEZ4/OGnxOBpfYP3SSmgXQpI6MhrSiE7mUFHkFQbfv8f32HvNjx6Nufp3IMkJyZRIVzewTfug8fBkdPBxtN99joizXnZ4GOs2z5En0ubGZo24H2Tsguty4Hd1SB/IfmW/nbYp3ZB10HpJ0jBSA1ZJSoGQvT4IvudS69otNTVFFHPdCLszGquWurr64TzzInzRvJLk2auGJG5KRLNOqLMcLmuLH29gkff+Lbn4F5NvVOTKHl53Drn/Vy1SSIhNDTNkrZZ4oPHB08ILUWkQFVySb3VMXVFgecChqgO+4iBbV1KdsQYWCwa2rZBhI54Yu2UEDTbRQ5nU1nZEFIpj84ky2XxVFwq/8OgvOpAcaGQXYoCS7K1BSTStg1RUzavdek41uRyU4X051NZKhsN1rrcjoLJARohlU1pY6AWhxjb2WTWOoSIimKtYK3BGMmlXVP2tDEGJ0PCR2onH0KiVuZ1hoSTtm1pmqZTcqmqPN5HxeS+dVhyalMg/TxFmUIiKL/HBBpjTKcwMySAj4kK6453EQWSswL8w/a4kkrGNXERhZKLXvdFxtNXidfhXK5yHy9COL7IeqoQVfGN8NFf79AsHHUtWBOYn7xJaC9X3vHON1ruvRux1QyYgBh2bxkMKeEmhpYyWI6J0OtIbcPfm9QBx9d91nfr/l6BCpIDsCopmK6SS7JEICpWhMoZJJ7QLJ7SLg8x0uJsg1iDcSnI7YMw3X2LECdErUjKMI4oRVUnK/MWhYwV4ksmyAjE0NA2xyxOlnz2kxmhNdx71/PGu4GgFlfvI5KTIbrte7sFiYikgLek0QQl0nqPSOTjv2k4etIAISUzSHJchBAIqohJ9+nwyXX6m/G2unZp/8318erf7C024fljx1/+8S4+JF+iSFJBTcRmQWNNjLfQuEN2P3L8PKl4Hj21/OhPp2n+0zGrASJiGgRPIWe4KvIr33lCPZth3S5iZ0SJSe1FNNszBtVpZwdKOpG0DgN/jIKRCCHy8OdvcfzwNtak0qCGmOdkaf0YIGiNSIVIndx6BIw94f1vf8hs7zkxWKypMRY++eB9ZrMT7r39gBgNYme4eg+pbqOyT9CKeErV6UUidOQX1HL/t/Z4+1vKZCcpkqWGWnL6DZbBPUnfJcUuzfaxR2QJ2mRLfxVffn6bk6MaYwJisjtUU2mn1E9awPHmN+e8+d4RUt3BVvsEr0R1+ft8/EHyVq9E9GqSN7fYYoubx5Ywcw1olna7yf1tscUWW2zx6lBXFc5ZmqaUM7A5gAfb3JEeF8lwL18Xpwgi2bltMaaicrFThjGS6islh3xIQQjfdpmhyd+lSc4dTSVcxObiMpJLdcRMnhhPVPrQjcjZTubNTr+bHZ83OncFNmYpnHcK0gdCVvafH9vVQ0r3WwYTThluW7JgBt+dd/z+z9VtT53T2s1HJKc1Ts3VYAOULOQuSIxkssv5jswCzVk3fW5fziTqsu48yBzrjrKz8PWz1U5OLD/7YGewpLwDAni+/a0nvDHxTCYzbDXj2M84WhiW3hGoUCzWALFFVLvsQC0ZPH38HYqbInnAOypVzI4fsYKxStsu+Ma9Kbf3p9SuxegxEpcYGprpnKpq2XdfEhfKh3/3lB/8+fMLXetkT7j7rknZUBrzcxKxJiAEgp/z7lvvMJlOODw65PPPnvDw0wWf/uTxoE1m12xx+NlPTgB4672KnX8gLJZLVJLz9+jQ88nPrn+MIXyr/PhHLdDy3vcq3t2ZokxwRrEmMrVLDiYtd3YNd2/V3D1oOdg/5Mnk6o6bZm549FEN1PjjJ1TBM3FK9A0TWo4f7/DgkxLoGDqlsgMrwMPPhlPN9PeDj5+sOVrJ0hoRLtfkif7mt9/lN75/iwePj/nkF3MeP53z/GjByUmL94VsGdeSWDZi4MDXqF2/kI46/q+XWu6PsRpkGS8bUwqGgetVrI6hMWcGakzLo0aMkUHJDkE1jaWKMqknTKZTjFQwKDWz0vflPrKQDfuxU/P4KVR2kgK5xnRjbam4JaQx/JedMHORJ2st6WXjOqdJM2vXF11LgLksROVayjOFAjImy7yuuPP2hDffnyKmpm1iLgWXSCCwSnrbqB6AEqPH+4ambWh9Q+gIJDmEKIKaFEhJAZF+65U9jewyKQp35OXFdh5vrZlsIYIxirXFhhVEHFVdIz6iMZPjjM3jelFvyQo1xmBiIhuX619r95XzGNj0Pamm10WIUVNJJZP2FzUSi+3f9TdNbluTj9vbb4lUUoyNdAwhEVrFgDVJLNE5RzAh3beOI1P6LgVVQow0ywYjgrM2EQwrl/vUiLEOWwlV5TAuZ40LqWyksWttzzE2EfPHAfhN23Y3czj/0PxW6Xi90TZ53e6ROCd4f/Y5bMaLIMtclARz0fPYqOBxBqnhZeJ1OIezcNl7nGz+XJpM03iUfgb0BFVEFecEjS3RnxDjMepbnj+YspxfT6Fu93bFm79icdUOaE1flEdBQ7Z51pPVznonLnOvrkLiGq0xOOuQiZsOhyUzWDAK0T/HN18Q2ieYyqPNAuMcViuiGLQ1WUBiFzEzsLtEmYFYQiauSLZHkzB+i/PH2PYEp4LECpUJDY6gu7TR8PATT7uAetqwf68hqMFWFWJK+dgyZuR7DUkNRyOinsafEKMgZoLYKdDw9MGCx5+dDl6nlntRQfrNfrub8Oi93m/2Fou54fOP1vU1icCSsL7M7XJh+PLTTeWSlVJqHmAy9XzrW58h1hGamigVaifYqgZjMxGjwtoZ1lg0lx9Odl5RkwuEdkmIS1RaaudZPJnx5Iv9sHclcAAAIABJREFUK3idPG/ee8TEPUilMK0Dozz94oB2/ykHBz8lBsHYGfgdjDsAsw/U+Z3dQewumClJucoSMwVutdSQdr2YXumNin1zIhy8WdFPvLPRKcXO6x1RA8sn/StlcpqTbcSi1CSS0hJGZbGPDnc4OtzhPEz3lXu2RcUhlPmS9tetY7+loqcIOme1yfA5LOu+xr2KCq99+aJfMmy2c18/X/VXFVvCzDUQVQjh5gy8uCXMbLHFFlu8UrjKJQeqKQaIdtmUfbbhigf8WtjkUHndHWxwlrNps+Ooy7q0JvlbcqxVSTXGUxAhYkOLaxtCSIGJ4JskQR4ABKspiAeWELNMuyZlGu9bYhwEM4k52DgkxfTfp2Uvt8033nehz0RZx5k5wwFnRgHRbpvBsuF9KASdsQNxUyZt97eu7HUjNgUZhvscG/orkt4iXeClfLcuM9BkOfukgpCvyaxXGdp0XWlCHiErlSgVaSLfEuMSwxHWHQK3L3Ttrxv8XDl50uIrpZ5ZjpeOp8eGeQNtVpiZ2IiEJiu82FyHXvsMKaFzFhgEiRETSo6PEDRp8uwc1HzzW3uIsfzar77BW7cdy8NjPv2pR9tAaBZ4D0dhwYOPf8wPd7/gi19sPvdqAnt3AAxRDfXOBB8n5OhWCthZj7MNlsCDz48IdwyWGfE4cPL0ODtMbub9HgezjQQmZkkTTwgCvg20HuBmStZMdiKTHRDT76/edSiCtYGqcjgDu8Zzby/wq+/c4fjQ8YuPHvFRO+fnPxe6jvYa+PAnTzg6XDCbWLxv2dlpefrkbeB8p9NNIzQ1jlscTHc5mZww9w+J1qN15DimwHOMKUu/uPh6nHK1pWdoQLRL3dxqMDKWsUQLGSeM9qmD4HdMW3d92/j3+v5xPZkzq5kOIukhKMGnWu7JRkkkU1SJOyErTQhJvrpHOV5PjtFT/a9IChY7V63aPCjBL0FicgjayK23hLZZsDyuiO3rXUbyInhRFsCYArZpHRn9dfrTYP3stLwucaZsfxHizIjuMSLLnF8C42Vi77bgJqvk49neLtbVoEJd5+vOpMtxWbbNwdU8BpqkdhI1BSISUXd4LxLBbAijMnoW8t2VfknHV4aObFI2Gr6vRgzGGiqXiJnlnRaTSptao6dI5Hal7E7+bdO1hUxOP0Wuy8SMNgzaxWSSbARrUz+TqiYJib2T1GhiUGIAYxwpPpRk/gthRjrrQTDWpPXyXCsp4iRyoJGkHid4JEbUx14VKCpRI771KDGvK6msbvCYynX31RiTyE3GUE9nVKXtJQcttA9dpN1fLgh+Xn8+tncLQSa1iYFMVhyqOZ75dl+BRPKycFFlkuHns1TaLqTacYXz+GXCzSnMCBItkknOnTpKrvWqCn6pHD9umFSGGBf45SEanoN6Yqzpy1qcj519w2zPELT3veweTHD1FMFltZNCZg6rk1561abh9dzEfH+4r0v5crouONuJHekwlYlNalmRpl3w5JHQLJc0TQStqOuauKyxtsKapBTaeBDxiFkgDupdYfcuiJki4kANEpPyQgCiNMTwmPbwIfNnFRJ28NxiWd2hrfYIYcLBvSOiD0z2cpUkySWWKAoMhdyYFGySWkZLWB5z+MRyMp/jg8dUO+zuTdi7q+zdEQiWtoHnT9aXWHsxGN8bXfvNZZ6I18nW2eLVQyMcPzPMjxY0zSFtUMRNqOsZYuqk2iKOut7BuBqVGtVEqjZi0BhpmyXt8gTfzBECs6nDz6tLe5xyT8fJ8wOs5DKZAkigbSrmJ1OePLqVieIWkYDwDOEE6yy37gZMfRszeQdbv0FUQUwFaggkv1DpsyQZvnksuAoBX9a8TKMZ03lzHB2S33J50QCHDw0aKxbHypgwc1EsFnucHFfs3t4hBJMI3FKUI5O1pmoyiSQRR1MpO4t0pZrigGQyvrbBNa5d5zXES4tX61fR3fpKsLVzXyy2hJlrQOMNl2S6wX1tscUWW2xxNZQgfIybnSBb3CzE9AK+qkJloLJ99q/3Dc2yIfgWrWKKlWeSy8nJHNWAiMFVBpE6kW+0lGpSovSKA312xKpzdhgs+TphU6bsRSWlx9sNAzhnHfO8wEJHnhpk/60cuxAiBusPCTUr5Bqy09KYrLxwmlxz1vVhLL2yjyC0qLagc3xzjMYjbHiZDr6bxX/4s3trlirQ5J+bw7d/y/DP/ukb/Op3fp3KeY4Pv+Sv/+JL/tf/IdfpwXIZksXBm8rv/hcQdELja1I2qYGYZMnFKCKeqgpMxPLBD2b87b//OW0badsX73gIwTOfLzEmZaqLpMCjq1KfFHyWWN8EAeuKuPkgays/o/fut3zzuwZX75Ok0GNyyJiWKMcQAs45nFlgIhwfev7n/+kpz59HNmXOXQWf/fzX+OznN7a7a+F//O///NSy3/4vJ8zuCIsTxdkqKaOQ3msREFvaNgeQB0GKhEIASOOFACnbP30nXT33IvkcVrYd0wnoFMPKd8XxdwWboiMpDoKponkcFIwo1qYyktY42gaC91irVFWVA8i5NEoJrA/Ihs4ld4CYpFpRiJRF1SY3BeRANwp7byi/8Y8Mjx494fMf3Gb+eFMm5uuFV+2KPIs8o91y7cgXxRH8oi3R84gzq67c/l0py151u47xrd+xvPHuBKXKpTtJJYA0olHoVX37gLzIoPTQWvWOpPSkmkhr3icFlVQO0CSCS3e3BBnyf7tDafnVk1/MabKZqq7mneZ1x4QL55K6YlKbSpnKrW9O2Vfjbc/6u23bbv+ljyjLEhnP5WOlMqfBexIPpcL7VDZvWIoo/ZDVqlLfY6WibdtkcwtoTMS/2WyGtRbvPUSPqxwQExFeW5yFw6PjXF7BpLFVwfuAcxXVdEJVVYQQmU0NzplMvPcsmzYrdBlU0/0SkWRHyMgWjX0bb3E+1s0zNpFfztrHeLvztrmOMs3rjrPO/VUn1aTyQSlwqpLGLJOTXgzC4aOGH/y/h4MtamDdPGQzrEtEsve/W/Gt79csWjpyXimFEjVkX0Cx62JnFyUizen+7WU9ExsVDgvvR1id4xIwLAihQf2S5njJf/y3U5aLKfDehY979+2G7//hAlfv4Kqk4hVxKDNc64g6Iza3ePRQ+dv/sDvY8inCUyYzw+//13epd5UQNZdFrbGygwYhtIEYAsZGlDkiASOK+uccPfmEv/5336RdTihJA5PZU37vv9rh29+vqIzlyefKn/6rq5WJvRmspSCzahFsxutm62zx6tE0jr/8D9+5xBYKp5RILLCffy4HWfPpw5/82vo5xtMDHnz+3ngpANWk5bf/07+B6oSZLNiZBGJsMWpBHL21P5jXvgJWg2hWe9bsOTG9/isSadrID//4Mc38ej7dzz9QmrnwO/9wSiHJpOl4ni+hXUmtom4DmUCkghGwlaFTyxnNpBLCq2jCLbbY4oLYEmaugZT9cpMlmW5sV1tsscUWW1wBH3/0Eb/4xS+YzXZyEKkE3cfB97MzCbu1ruiY+ao6+a563snRBSlQDMMSO2LA2ZpJHXPKbckE9sTYUrkpz58f5iC1w02EpmkRMdkxTirtpKW8U68elI7dZ9qvCy5oiX1eJoPsupD1pJVL7WKUIb0Ow+u9iMrM+ndh/bHPOu9NqjbpV5d+B8asPA/DTMFyv8oyay1VVWElT6AzAeo8BR1ILt5cjSDRZtTj22OODj/niw8sjz/dA3ZoFl99FYUXjY9+csz/8t/9DVX1kxwI8yzm1yjdEi34GmGKw+a31iNZEUgxBDUsvTDZEf6b//ZXeWMf/s2/eMT//c8fn73vG8DjLw1//M/Te/Ebf6Ds3vHo5JDf+ScnvP3WAX/xb3b44pPN2bTVxPC9PzrATQPBn+DbE2Lw7O/vo1gwFWIdqMOaGpWIqieEyLJZ8uTJD5lNhOPPv8Hzz97CmiOOjr5+xL/z8OM/aRBLTtLPAd/83e23a77z+/skeebYKcSk8SARX3JuND05hjXLyt9Q6panoUShK904GBPKODMYIob9z8XGjjR2peuRFI7q+sBUGsGIycoKBudq6rrG2iLz7VcC81VVrZxH1yfm8TdqKnWSVB6yM3RwXcaaVAJRLTEEbt++x6PKML/AlbxMfBWm1L1z9fRyWfn35ZBmgAuUaerJMq8jUaYgvRsuEahjen8y56sIk2WC9ur7uS7Ib60lxkjbtjTLBe1ykfdpsCaVz1DNRUqMDHqJPgSXlFIyMUTjShm0Qv4uNkh6HQs5btWOK2VMh5/LOYcQiBoJwa+832NS8um20s6GOsteGpZvE7HZ9qrSbwzOTQAhhHRdzjmsNTiXSseVvkwVTLQEDRhJZZGqqsZYg6CJGGOUaqdiuVywmC94/vw5i+Wc2WzKdDpld3efqqozYdDw7Pkz2tYjJiJGaReLjgBvrcXY1F/5mIis1lZYm92gI9WJRFYyG9trE8bziLGaxThYf55tPF5n5fzWkKyG66zDi5hXXmZeNGyPi86bLqoIctn52U23xcsmsNz0+V84uaAszwFfRZFUiycRakmkW2vsBlrCxeDqwLd/9xfs33mT6e6M+UKSSkO3A6Wo/JX5eZonlr6G3P2+mFHzos/w5vYbnJma3HyK0SUf/33LR39nUJ3SLC9//s8eGv7sXwgiLb/+uz/j4M2AuDeoJu8wiYKoIdS3qGYTYJW4okDUwGL+KWY2RWyFiEViS6UtQuAXHyz42Y8bpNtCs5EixPAObWNX7rMiRDNBq0igoaXpyLabr+5l+8D6sbrYW1tscRZeFy+tDP5dXXZ5+Mbxw7/4DUD41m9V3P/NJplH4nulGrIisw6P9HKJMyo5YcVAeVtFe+2rpHd8M3j6oOFP/q8HXOX67nzD8ht/OElnpUNlrkSwSRiQj3TrY9xii9cNW8LMNRBVCDeoCrMtybTFFlts8WrRtDkD0QohhuR0N5JlFwcrDrvr68yst7VAAQZlBQYNuxJkBMR2GbuqimiF0RpTKeKmxNCz9CcxEkMkxEgMgRACRnN5jrxMY8S5OjmI8rrpDCQHBbRTLUkKNZpJN6VWrvQqBDo+2VV30Ribh/sSLRnKskv5f2W9VXIJ3bN0SqmF3pk7Jn11BJjBfmT4OQduhr+HhJl1kvPrrnVlH5xFmOmDt5LbYqguMw5E9NnL+UeKrHtcOb9xwGJMvokRxKRMZpElE3uILh+wY59g4j7zo1unrmuL9WibyJMHS2AJXL57HD9BApioYCNeBJ/3adQiJj+/sSI0hiOFzx8e8+z5kkfPTq57KRdC8HBylIOXxsHEYBQm05rZzh7mHOV5I3BrL1DNDD7u4GNNjJG6TuowIZe6EAkgDYIiBqIXRC3fu7/Lvbu7/Gi+z8c/ErrU+F8yLOeb+1zfCpPJFMXSNgtiSFnJxoJal6gwWtQjlIhHNaYyTFpUZXJJJlNIMnaQLBaTo2vYH3aBeO2Xi1zhhcgBqfJRUtmO/jCRWPpsFZrW48MJSAkopb7OWocVh8NhbTUgpdKrbZRTVenHqMH4VoJE1qbgmLPTRNYxS17Vc/f1tqC0HzPzkuuWYLoIxse4vMz6q4cxNqkLxiaRWLK3P+bMz9O2U0+QTlBCVmVqjpYD9UEFKxjrVmwi6AkrZT8hxFzmKCLD9zgxZFL/EmM2J3s1hBhT3xMDVNWEuqoxNqnjGDs4dxFEE49c8zaQiCq9bRNXiMPjUmzleG3rk01cVUzqSbnSzPdTJjWZhC7ZZg4oWXHGOApBPcZEMOrCOAJVlYgz4FAUI4bQNFSuZrlcslzOadsG1WSTl3Ov65q6muEbZTbbo55MqVxSuEElk4+URbvsSDpN06JRs22QSIQYh0oqA2tNT8rv2rE87wM7W0tnWO5vYTPlwEZn5Q/Xyc9QVPq3Vvr7NZ42qsZke0oqiQWrtu1QNSjdv7SXsmwdzlN2vCxeBBHkRZzHyyLGfF0wnh+O54jntZs6TcU5FMBiZJL9JJEQPaGNp553ODvkOLyDxhruvnOPyd4BMU6SDXz6IlauZ5wk8nJJTJd7zhLHSMG0YAKKB9Pil09YzA0nR7uX3mdBCDA/Tv1RCAZbOUw9ozWCNwLRIHECVMgawoygSbFSd5BYYxWsLtH5J6ge0pzsMj862HDV60JLEeFpUoWQCqQG/OB4Xx189SyhLb6uWEeUWb/kInsq9qDQzCco0LYkNVWTfZ9YVE2ypbo5gkWwqAoqOdVEQiLUUEpnmlyeyOS/AYkIae4a14414zdN137SnERZW0V1AXEBLJHYArMrtcYYwSvzo6spTN86OWRv+SUgaMykGakQmaC5TBemQnFEhCBVtlctMasgJidSavuiXCMUl29OX5B4tXJYV8LL6gWv5i+5Eq4yr36Z8+KrHOurNLC+5tgSZq6Brq78De5viy222GKLVwdrHda6nF1d8kQLE3wQAOswcJhv+/BrYLNhvDYMWgg0GCwwM1Vy+tE7/komboyREAIheDR40AA5EFKCHoU0430YZG+m4ILXmOoAC0g0EMIgo00YBx/6My1/nw4kbnbk9SSWPuCwZkK8zqkpm79bJ5eeziMfR09vt7LNgCSTTm39uW1ytm5SrRmvP641PyTIjAkzw2XDezEmMI3/LsGHYZZuklSNKRitDYvFM4xpePZwh+OnM14kvvN92NkPLJaBtlU0TvjiIzg5PH/brwJ6V8zF1h1jfqR89LeeaBYc3He4vVxmh0RYSI5ni2JplsoXD5YYFsRauf+9OgUZjaCxBCUjURsmVUvl4OEXli8/u6HpkHdYqbCzKZVZUk0nmUxwtsKOkuSOjQUnFdFkt7XmskEmKZyIIT+7YK2hsjs8/uQbLB9NePawuplr+Bpicej56EdHgOHg7Ug9K0HTNNbHoEmFLIbcPxggYm0KanrfJuKMSv5NnwmWHYIrff6KasXgDchEy8uhBNo3vUWlv0v79T4ghdwjMQevHaKCxEQ4QwzWSnqHKAWAsjKGFsrkoL9nlWzYqepgMOK4937AzZ5z/Kzh5NHLIxf+sgQvXiZZ5qxz0HOWvE6IXgieTNAApSiS5T412z7GjJUC0mfvPW3bJsJMk8oW9jZHVp9MC3t7CoFCTkGwRgkx2Z5oSO+k9sW2hGR7JF/ogLQhplilQFKk6UpmadH26aceAmAEiUqvrNirwRTCzDAoPrTHEjnDEEWwxmBzibYYAiEmO7qq61SuDTJpPJFVjLGpL+lsOHKfQ6eg4327Uh7RGoOVNC5bZzBBiDEQfLGtE1EkhJCUYFzFbJaeN2OgbdtE8NHUHsvlEhSMGDQq3geMNfneWJCkRJdv18D+zX9nUtDqE50JMjr8u/Sz/ecRfSYfo5fm71cthJvuNieCUzz9DhWbdmivnqU8c1G86jI+W9wM1iVAXIYksm4udulSRZr61fRwe7Sd4+OSJ5/VLI/g5OlqqdeLjBbDdYwI9XQXTI1Ge+bWw3njq8UlSTOYPF+NiA0IDTGcoHFyY2dk3A62miBmF6IhSgCjWFXMaF7yxltz7rzZINYxrSusCs++jDx/EDHaEpYRVeHpwwHZivOv2nv49Mcttkrj0Mmz1S1O7+NV3Usd/Lvp2y22ePW4ObLMcEtd+YQaNFoixX4y2VdW7M9koyrS2awGBQJPv2xolpG33s/EcpU8Zx6eYUQwmFOqKvk97Gzj/sqKMEvsFmVijnhEPE8eep596Qk+EK4hbHxTODmEn/1N9jNqticlIhK6dkzCaZGIIUoE8ajY1K4WvvlrDlNNgbwsz9lVeuXbq5NlLu+P2CLjtWd7bu/VTWFLmLkGot5sSaY1c+Yttthiiy1eIib1FGdrNCaZb82526UU0FrWu+b6pVu8NBS3Ruc4NH2Arzj/XHb6l8CB9x7fLlPgWfpSFUXSPcbIfL5IajSmZHGCtprLfBRihukCEOPAQDlep0qwwXl5mmBDd+5XYtWnrTt//CZJ/fGyfgJ3PslmeJxN65xF1lkhtQw+jwM3w+/WEWaG250iy+TTG+YiDtt4nGEdY0SMQQ3EGDAmEa3aeWB3ssPnH015/OAciZBr4ru/Ldx7T3l66JnPk1Ph6Jlycvj1MQqv0zseP1d+/FcBCHz/tjLbB1WDzYGsXh0jB/OwBCbcervm4BuKElIw0AtWklJLjMrutGFSN/ztX9Q3RpjRpeKioZ4ZJtNINU3lIc7cBsEzJQnYp8ysU+2VJ+b9sx5TkNPs8Od/dnDtOt1fdxw9bfnxnz0B4Lf+kaPeqYjqQC0ihuA9qWqLxZoUgRaTgjYxBgimc1CZGFNmtYnd+FHUJ4aqDgWXDkStRR4XLrxuCZyDNRYjFhGbEz0SOVSIKciexxzN79NKTz/ou4eB23KNqooR4Ru/5ti5N+fzD49eCGHm69MTXgy9K/N0Vv2mp+Am2mi8bx0sX3Wl96SP84JMrwreg8ZUiiexJUfUa8kEiZEtVgjWTdPQNM2pso5p5VSCKZlOSYXSGINxtiPiGpPKG4UQ8N4To0/KCz4pzsRM7hXIqi3p+EYMkk2O6FaVYUpfM1aEGAfQi21TyjUNlw+JxwXGGOq67u1hA6VPCG0i/Exnk+74Aqn0ZUg2Z4yJ1De0yYbE5LZtOwJ7ukZhVleZWGSZTmaEEAk2tVUKgAjeJ8KSiOBcCTrE3J5xxbYbX1MMESQrZRXSy6i9hhgvH7frWQom4+2GGN+r03bv6txl2IbDaxt+vmniy1XLOF11XHuZajDr7zVc1Sp91aSjTaqel2m7i6y7XpV0AJ/eY2sVjXOWyy9ol0/5/Mf3ePZlSjIoJNzuuKtHWPPXYB0FjQEJWaXgjPd207m/1shkPkUTmVkVNOAkYOVse/4yT66xe4hMIThsuyTKCcZ6nHhSl9qTc978xjHf/Z3ntOGAqG+gMufxLxb89K+yL4UD4ODUMc5rbd/Chz8s8+jlta7nxeH1tGO22GKMq74vF6BSjtY0qFaIVKjaxIYufvCsIAPJNyPkPiwcE2PLk08CR88M77yb7MaczggUW1eJooiGrn+XjpRM9qun3914rdkVomSyX1LmitoS/QLB8+QXwgc/eLFJbpfB4eGMH/zw/UtuFfIPTGbw7ntLnLVEbFI7l0yTkZDmMZpSyLad1xZDrNHk2+KK2BJmrgGNN1uSSW9wX1tsscUWW1we02lFZYXoPTG65LwmB5kyq9FVKRjVS3pnZ/y2C38hKIG80+gJIqvr66nfIkJVVdR1jRHtJl4pyz6t0/oG4xw++FyaIzmt6umE45MFqoKVPnMXUiZt+byqZFKCGgEojqL1BJrV8y3KNnCeYtGKo7ALpvffrXMknspSBUqdq6ETedP2ZaMVB+eIwLLOoTv8GWfNjlVlxscf739Mmlk5DpCyyNc7HMfB61SGJRI0BZaiplI/prrL88WSKAZXj50I5IcyfQ5+VK7tghAB5+Dpc0EfT5gvp4RosRawDdb1JL10npZfdiVCi1KbFK5VNd0d6Z0x5Oe5XqE3thGMVPjUmyN2l5NwyNPHjzhckO6xKt6ztqupa0nle/JOlfy+aiKdlUwm1SXEFodlYpXjJ0/wzZSzplsCWJsUT0qfM3xPymdYJWKUz5NJyv3yPjmmtzgbwR8RWkPUiqYFayaEEKirmtl0B+sc8/kCIwYEjBXcbAdINkAISTXCxwa0D14P71cJDo+D1UOsC7KO7y90PfK59kXHFxQBsbk/TAS87qcj3phMnllDBoCVd2DcNw+fSWNMKn0iEXEW665GLvxl9fOtp6H2jq4upK6ycX0dfb5JdMfQoqayGuRcPavR8/0CzucyEJPeXWtNeeQH42d+F7p3tifQJvWStiNlQP9eGmO67M70fmfSmLHUkxpnHcYMbZ30Xkop6RlTCRPv03FUE2HXWdfvP7+36+zY8ntocyZiiT9lFw3JMeXdLfaqxjRertpgibhjrWWxWGBtItnFaAmhzfaKIYQUyPa5rF1S39KuhFAhCZXPxe4uqj3lvHMFou64zlU4VxHjCaohl6RKpJ+0jwnGGNomdPekaRqQpIpz6v6nHZ+aI2xS2RlvO7YV1xFhNpFlxnOP8TrDYydFUzn1U7Yflmq6CNHhouutu95N35237TqsG8sKtBhRl9jfTZIgcnzu0u00HOPHeBFkn7OOs24OdN55rHuGh9+Nr+/MfWlS4dPgIZwQl4/R5jHEW6RSGHm94fFW99AtlVPfpeWxbXCT3ZTUEOlslnW4KJnmZeOsc1BpCWFJDHOknYMeMSPgxnP0ayDoPsvGQbNA2ocEjhCzQFwL7Q7wXrdujKl8tUoNZhcxPwVxwL0bOZd1WOOleAFHOQ9bsswWl8eLtL034byeYXxOZ51j6XdPW/CF1JKJ38YRvAzWyyqNUnx5aanoguboI5pmgV/cgrgP7QmYHURmiEyIuKRSk6eiQZvkf4sVxtjOr1LKacasmigUwnQaLyp/BPGEqAuCLvHhGFRoFvvA/sUb9HWHKiwaxCwwFox1BLEohoBDVTBZHVu2PdgvJZKNUcpjwupbvcVNYEuYuQaSwszNPZBbhZkttthii1eLpvmQxfKHHD7Y5YO/fOvUTKKawG//48B0p9Rhdiipvui2JNM1UAIxK204bPx1brc+Y2Fdy/eBghyMVO1rvko6VpmbRY2IqZntOCAHr3OGrg8BJQcalCxx35fuSMGL4uAu52eyU7Y3s8p3qpEQigJN+a6f1qY/z8oWkC5+2jnWC6litL9NTtVuT9K3b0+2Kb/L8pFyjJTSHf0xSqBkrLRQgjHj+2KMwTnXl0QaEQM2EWjGhJmNLSSr++2Xrw9eCxGNEaIAFmP2qacHfPs/MRAlt8US1QZjIhpOsPEIFz1/+q9vs1xcXm2wnsAf/lPDdL9icVwTdILYmvb/Z+/NliTJsTS97wBQNTNfwmPJjFwiMiszqyqnq7urW3qme3p4xRFece4ovKEIn4DvwwfgM/BqKEIhZzg9TfY201vtVVmR+xK7b7aoAjj5yeO7AAAgAElEQVS8AKCqZm7u4R7hsWSW/SEebq6mCoWqAtCDc378J8y4+eEx1945wnAM/jGz48fc/fhHzA6vX/g83yX84q89788st34PGpO7yCDoCYIRXU5xAZgIWI/klZuJBDnCVK/z7r8I3Pog0M4b/ukvIs385Hn/+/9hh3ffc0xnkYOjyGwR2D+YEQI8vm/4xd+mcn/198pvfxIQiRgDGreYTZ/0XohUcoBRS8Bkws9y/xeRlGJC+36uCqNJ5H/8n4+4cW2bv/l/Lf/5Pzxdnu1XA89jEnTy3t/5hxGf/CR9l4aBlhS0mSOmSRRYTcLHtz403PqhQ6gwdoTBEqKwaFtoA2ISqTa9A0JSSQh+ECwfvKv07B84qZKwhHPfHsnvUZMH85TCrGMNnOFMEWRJra079RmBtKS+Bttbu1y9WvPVs1T9dwjryTLSUZq6Ldo/jXWWzsktF7nbTxqbdKk0KXroa13sxV27LvT54qFxgbUVVVXRZqWVvh8Aarr3AfR2ynw+y8osUGw0Y0wm0BXjKGJtEqCH0h8iUZNSVfAeHzzD+yRGqI0jukg9qoBxJtykPZqmScQUHM66FEYOywp6w35YFBRDCNR1jfcB7wPOWba2tpJSSyHNWIs1ibzS+janVEoETR8C89mMENuORLBYLNjZ2WU8HmPtCNXA4eE+dV1TV6N0boHJZAJZ8cWH0I2dzloUaJsmET5EcM4l9b62JYaIE0eMhaEqmTCqeN8kEo01A5JNCuQaMfiQSUbOpvd4zxRENM8IJNmAIoaoJAL1yvxs1YYcjr2rRJd1Y986Us1ZJJvTyA3BB6LEAXFJlkgyxiRFy2L7Wmux1jwVSftpELNaZgcdjEbCGfUYjBFLKQUz0VhksJ908zFZKlC7YoxZuXeUuc+Lw1nzjldd1WQ49xmOI4XsdmHykM1zWECxCFtYSePXqXVg3fNKW1e/U1WmR/u48QTjKmJOR3FaKWeeaa1/4fw1PB/6OcjwvdpPRXKQOf8kpduWrz5a8OnPW9K7aQdhC99c3trwX//tDGtTCBzdRplQfBzRL58nhMCibZEqoBIx/hYds/E5YEOW2eC7gBcVnr4IjW61PZ/WvlfnIUOCjWpgPj9mtjhgPNnDVjbZWVgEQwwtzqRUTKGZs//oIb/6u2s0C/Ct4fpNT2WPaf0C60K2tysUR0rlFHHhG46+PODn/3DrjJqtu8CYieVjYISyA4BvLi/zx6uAZiH81V/UiLTc/v49bn3/CDUTkAnOXUFkK5Ma82KVVSXNYhB3m1bv69A267FqbZXjnhzmOG2HzQj79FDoFoEW/+DQzigpxlN8IYY0x4uhWVvaBhfHhjDzDFAV/CUGSH/XVw5vsMEGG7xsjPUxV8w9WgKzoxsnvg/eE+ef441F3B6mugoyAR2BuBMrQ9c52JYcay9q3L9wftNnwIWvSZO0JDB0nvbf9v/3RJEIEhGNqAY0NvnHp4mUAWsrxNbdZEKkkJpMXrFQnoVkv6xgjKO4YpMCacTZiHM1aYJHDjRkh6OA957gfQ6QJql9jYVIUnXpoMJASt85IQzTdsSItbZbtQxpjlPSRqW/+6BOkptP+8QYscZ219GTdhjUN8+Z8urlQnzp7qmkD/3v/rNZJd2IyfdwmcyyLlBwGmFnmBZgHSmm/5tBmct1XOugluF0vz9mCI1FzYPiFcBgMCXFAmmbmIgd5z6cag2MEKOIOqzWsFhQFHouDBHiuKI1jqg2T3ZaUNja2cJeGeHsVZrFDu19h7jq6c7zHcJipoRFwEVPq3XxQ9MHZRg82B7atZnyrCQFosXgRoFqFLIywBzWTOz3py33jpTWGxZS4SuH2zFIk0gWxVnRzMmEm1LGk9uGtcJbr9cctwsO5+DVgbr8PumvTfH5d+qwEi2qjs8PHvM4HvHweHll77cLz+v9tDweADTzdQ6j8ns5OLBVW956o2I6E+4/uI8Pgpga40aMtydEDd3hisOGQIiGKo/7rW/RmHKVa1RiSCoTaCFexvXjGCcDcOcNaPVjLn37obxDdGlM7vYrZecUfcrJc687f9lmqBCzjTUO5dtM2noxkJXf6bOc3LZElllfxirOkx70rD1WqaTrgpkDN90STWa49wnn+xNrdcnQluAXiLjU90QBn18XBjQkR38shAyfUgCFlDJCspoMGIy4joAhpiiaDK5OZOmeOmewrk7V0F5Rz+ROaXK/K0RnUEajmvl8ltNEKtYYxuOcqiiErHCpOJcIE1VVY4xhsVigqjRNSntkjSDaYCUk9SeNSIxJuU7BELGmpBPNKZOcYbEQWt8iKNvjEUYj7XyeAuoKlbEQlIBHjcWKJTQt3reZ+AJiUko7DdkeDoHQNkRVQpPIHrWz4CwakmEaYgRNmoBCIbrTDVvO9vdeU568RPRJGZcYkuJL+qUIPTl+JYC91EQGtnVR2zoLq+SY08ockhPWEWqWbF4k96Ns19PXO5ktklPf2DRH0PRjxC6lv1qt34l6ndkDS3ukTCC6WvRzirRfr1TWzzWMkWybpIemGjuFNjTr/2XuS2qTyQ5Hkg2WOkWnr9nPyzD9Q+1sqTLe5AayQq5fuuYzSCxPoz7ytOWd5/lctMzV8ovq1OrxQ8Ldan3KPudVlVk+Z0QlpudgRritN3DxGqY6W2Xu5LtgfcsUlJ2qRef3iLXH1leIOCKSFdkFwWSlGx385FQhUsotDbs/c09LXf92LXPwU6/hRJtbvaJ8Fkk+hEUzxVlYzB8zmz3Gmsi4NtQ20k63mR1t5yPz3PrMs59Sp1O2t7NILzxpOGtOYp1lVEM0hyiOKGMQ29kml/kOfzUiHpsg7gaXg5MzzVf/bE+mHbbUFVhXYVxERVGtEnE+p+b0zQMWswf45jGxbZlN36Nd5BRuYUo7vYMPEO0YMdkfa6pkp2kktg9pji2zw7ee8irKOP7dIsoUqMLsOL272sU+Ej4jto4Qaqy7gamuIdUe6nZQMtGeXqXciAz86Tr8iGKS7dn5TTUtOOudGv1v6VtbP8dM9pku2QwKEgBPStul6R2tybd+ZqtbjVM8TXzkOxdLz34pSalq0TGoBc12ggQqMyP6QxbzA0J7zLUrk0RSiz94uVX/DmFDmHkGRIUzFEefqrwNNthggw1eHkbOs10HptX6ATl44YuPRhgnXHtDuP5GRGwWpujD7b+7eCpjVSDa3rmcndfWJkeYUAgOmUWNgjYQZsQwhzjnwZcjZkcC6lEtqzVzyl0JpDQ9KaXN7g3YvZGkRo3NzrSyql56Z5wVC+KIoknKPlc1XWf5pUSXAhrJdxzTu1wVJK3sjTF2KTqgd5qXbeWnyOWXSQsUwszghAgxBqJN+xtjCCGmYELsHaHDVYTDdALrFF1SSg26v1dVDkRMXt1ZnK8WGZBEVkkxQ8WZ88iGrxJmlredZhj1QeATkOU/lqZyxWtfJm5KctprH+RLh/VRAtWVM0XBmBrEgq15+4eBZtFycD9y+ACsg5vfA1flVR8q3cS0m0AKuAqCqRAtChCgMQCR8WiMtRBig2fO1dfe5P5ofMq9+N2CISDSoiEwGo2zGkDf7vvVzAMSDUkNKgVqSkmSA3EWiIhzvPVDi28jHRMnx2PmOO7uG6JalIryhdgFxgzTrl0cvlV++9OWWeuprsDOa7lvqR20yD6ndVF+wggaLfvzHY5aj9kJvPsHDb6JfHNnRPC/4++iJTzdu/nhN8pv/7llNlce7Td4D7e/X3HjHcP+QZuCfoAxDmsMUYTa1AhC0NSmOiKlD2iMmTjTp2waplc5jUBzYbIMOY4oJajcj+3D36vqFXLKfVLVHGBf3lbeV1EjqoIdW978Ib0zB1gcRx5+tSHRFKx7kpdFlinfnR0af3L9Vskxesp2KG9NXdlvedt56lWwcyVy+/st29vb7GxvM5se8+Xnx3x+Z3SOowf1k4gxMRFRicsXkSW6okaaZkHbNoSQiDNiepJD/3//I52DuQ/cJ1J0yDaDZkUXkwkBktRQpCiERaJGKpcI9lGLfbas0peuIduwlD5rsOW3dZlEkVQRx+NErq6cobbCnZ8eEjxsXQ3sXA9YKxwd7rNYNISY0kiNRiO2traJocVIOta3Lc5VGCt5lWIEjdRVlexMTXZKIBAjtO2CEHynVOGcWyKGWGOQmJW3UIwkZcFolBRuj919gkQmKiaviCaHf7HNyfaqDoP8S72m+3NI/njS8LlKbCnb0rHLNunq+LyO2LhKmllXzjq7d7W8bqy2lpCJl1HTfKGuTqY/Pa3uubSlgMRAmIfOXlJFO9s3zWGssZ2NVVUVIGhUDu96ju6mOqVHUvpDHBBmpDuZcfDGDxyqqZ+IBhbTBQdfbROzWne91bDzxhGT8TZVvY1vFd9GnB2hpPQMJR2E5DUCZ13/ZWOVXHKR4876+2nrAifby7pnf/n3Q8H4tNBFJSntmT1Q4fV3PTtXI0JEWRDCnAdfWObHphy5XM4pCEH46uMdAoq6FlvNMZXl7fdKqg4HVIixmZAVgZDHjJAXYBdbekiOWXf+/uVwkXu1PG6UoK10fwoBw4KKGc1snwdfzXl0N2KMUldKZYTH91baxrnPfr5jbr7j2dqVNF9Fmc8OePT1FovpyQUYj+/vcOcXkgKvmpYIPb63fJ7LaEmbmckG31W8WC/w8z3b/n347JdgK+W1t+8x2lJgGw1lJGiIzWMO7k55dM9hqLp3OcD0qOLOL/dI3Ng0bqdcqYAKMRo0XmF6WD+3a/guYf/BNp/++nVCFGJIfkhrFXENZjznrQ8E6xyqSfles/+x85uLR6QBIl9/ajg+XCbMJF/7YIQfvh4LqXpgd092lDduB2J0iEmLhkFQFWKZL+UUtWjo50AUArWhLCZK+5mBX2E4/9pAsq8a8rMkKTYJDXc/nXP0uKFtAtHD/g68feuI2s5eap2/S9gQZp4BqkKIl9eRNwozG2ywwQYvF2KvIO4GmPU5UIO3fPrrxIQXsVy7WUOswJiV8MDpDtYNTkJUkyO1RLS1QaKgRISQlGRKIEEUDXM0HBL9IRrn3Pvoezy6ewU4beKVV50Bt3+0YOdqA7iU5kQ0ByAsIo7oIUZJq+alImrKFRsxJ97TAlibftZBTyF8qCohhCXSTLcK2ZicOENzzF4Hx0S8bxFSihZjcgBDlRjiiSDsMABbCDPd9kwiMHaQG1gEa1IApneoF4e+ZBWOvA70FCWlQpgphJ7TAg6nrbrsV2Q/v74zPLf2F3rq1GwYzE7HCNEI2Iq3f2SJAT77acvhg4h1cPv3hPGkAuo8cc332ORJjuSV+WrQWJysQl4bjassqi1Nu6BtF1zbq3H2u7mC5sKQFmsD9WTE3t4u3hvms5amCYimZ7O0UiWTlCyaUu0YYVSPcfWYpmlpfSBGg6mEd/6gdOQ0qe/d30JQk7cYRFNAwDqhqp/Ndm8Wyt/8xTEA7/0hXLlWVuVUudaS3y2J2JNql6/RGMbuLcBz4+0pb9yeEeaRB1/U3zLCzGW54s/CugDr2fj8Tsvnd8r63BRgeP/dEe+8Naa2C+rRFo8ePqJpZoADVUZuTNt6jBqsG0EO9EWJoAG0qFn4JaJMCZSfpTpzFsowukRUzCk8SiqP7v2ykn6knL9QAvoy+7F7dfW6aq8oEAmoRqpty+0fpxWIBoHoefRVy8N1eZouDc/abl5cP5E1n1fJMqLr3ISy5tP5zvM06Mkwa7Z30ty6VCtdS5op3/THP+lp7V4L/NG/mbG7W7M1WfDowT6tHvL5nTcvdg05LZ6xQp95KTvtNZEuQkh2U1FwSf2j2CmlJO3IF30KpZA5HNLZcm3bZNul74vWpjRIxtSAdDZfCBHVekCuSO+dyo2STUdKRdS2c5TQ2V3GOIxUaISYqsBoVCcSSbZxxyPH2I15/Flgfhx4/YMFOzdalMjR8T6z2ZymaQFha2sL8DRNg3MO6yxKSkHaEXhCUki0LqvHqOJ9oG19HhdCd12FCJ7uf28HFjJ4sXeNMeAMgYgWUk1W7enSepqkIFGeQG830pV/XiwRxC9IVlinEnORcxasI4mvfl79e5W8XsbqsxRDhgGHVRXHZLd3e+b/S0+NRAJoHPBcWhTB+wbvW9A69YHo2f/Ccu/ng5Sz0mm+wMq7VoDRFrzzodDEGRob8DPm+wd8/dNb+IVDga0bB9itz9mq32RrZAhWmIaGEKaIGUNRCJSk/rSkpjWYKz1PPKsyzdO0wfPgPOVe6nxKhkQ0S9QKwfDG+6NkN0tLVKVtFkwPYX58vmJLDdvW8OtfXBl80zKeNNy+3WIrS0tNZERayT5K9rBmkpkYVPJCBV2dN6VWqjogxq9cmOrZfXSptOEijELuK6RMAoQGZ1oW7WMO7024+9ub57sR58B5WtHb7wVev2UQU6MiHB9Gfn6sLKYnS7n31Q73vto5pSRd2Xv1m8uo74ulG1x03vEiZikbfPvxvFrx+nIv2iLPX7OHXxsefg3VqOHKzids1TOQHbzPY2xsMOEhs4fbfPPbGydqcny0zUe/3KhcXBYe3rvBw3snle8BRpM5b791gBs7glZEKpK6pmQfd8BIg5MZQuDeb3f55otnIyq9/tacW28+JKjD2D0wE1QqlAqhhqIAJ4Ggc4Tse1BQjaRsrcVGzET6OPAts6HLJA+BTQtotFfJFgkIHqTl898E7n1RM4x/XLsecNW3VXH61cOGMPMMiEC4RJLLJYrVbLDBBhts8BRozQdM1TDTiKsXZ+4r1YRgtxJzfuAq3OA8GFLXI84+JviWdrFAY4N1gfl0CurRsEiy7iF23nIxASMtxqQUTDGeX87TcEylD5AA3jfdSmC1jtFoh6CwaCIhGsSMENkhsoO6cVnuu/5a8q8QkkqNGDCdlbUcKkurjh3OVZ3TMeTr66T7y97d5xSMCTHkCUdK75EW0kmnZLNKwhmuCLC2J9h01RJzgljzJOdrOTypEvQORudc93uVMLNMOFnv7F8m3lyWgzdPvqLi2+RUt1aXHklagXH69XZkn5iVe4jEKARNLnqRGnFgqwZbgQ8VbUgBpzRZ9WACGJ9r1AftlqeFKd1CCuKBlZrt7avcu/c13l/FVW6wmhI0yO8c2Tr6KUYir93cY29XERlz727L7O4MIxXOGUIoJHQhL2ciWo+nYVTXvPbmHjvb1/j6y695+OiINrQ4W4HaHLDOcu/J5Z6ekJKd8DY7ARSkSj+XNLUPzYxm2iBmK6f9qBBjMC71MRXJsshpfxVQv0tVgVVlbBZsXa2pR4IGCAGCP3mes2r68t5ip4XpT6/Ty2j5IbTs7Vh+9P0f8uabb/N//d//kTsff4FfCHghhBFCjZVRSmESBbHgTFKSSqlVbKdKURTREqGFtHosK9Gcd/xbVfOSgZKMcy6lNTGDMT0HF1eVbUrLXyVApiC5P3HOEiBSU6d2WuVRVBUhoH4BpuFictkvugW+mNYlS7/7/1eJMsv7no8oc5k1Hd6NQnwZWCA9KabUNwfKZUCaWS6rfDMs8wxIpNUFv/30cz698wVHB8csDl8DLkaY8T4wny9wocY6m1/y5Z2bfqy1jMZjrLOEkNILhZjIJClt0jBFRv+0omZFwiVbbtSlTZrN5iwWC6pKqCrLYu7xOWVoIr4Yjo8Pcx1SyqEQIttb2xhjU+AXg6ss3gdi9Cltpwq2GmOcSepWCiEqRJ8J50kNpgmCsWArwQdlduxxFVg7Zm9vAlkFRAy0fpYobzFAqKgqhzGS0lP5SPDJplwsNKvZkMnZPeHPGJOJQaazQxPhp+3swKHqISIYHCanhZIScF5tGx1xgwFpaU2TeQ4EhKfFRW3WdelwCkEdpScQ5fHcWosRszzWZzK9aiFeJjs7KknpJZVAie0n8RdDUTtS0jso+gZEccaBGubTIxbzfXxzTLOYsZjNCKFFVGkevoPKO/110BNWdGlrmeWBsw2NP2A+fUw726c5nhP1rX50CB6OD/FVhYxhb2cHpzM+/vgzJjs3cHYLMWNExqivibFGnCA22UWlvXT2errBF3oezwNPq0zz6kJAR8tT30xMB8VnhSKRETiLrebYaqgyN0iXlI/yXp/wYkhBNj99SBxBsBVqKkIcUdXXMdSIOiRWEE3mrOQ0Ikv+Gc1zsnLm4Ukz2/EEyeZJiCCZwUi/AELzvWh9y9aVPSbbl6OkcL7RLu1lgsH4GjVbiJmwt3ODyu0DZ/u3Lr8+58XLIc2clwyzIc1scB6s2tHPo9zzlK8n9rl46zUSGcsBfnZA0IoQLarJ1jPaoNF259j0jZeEGPCPPoNRQ1BBjXTKhKIBIVBJwJqYFgX4HwHXn+2cfko8/CgtGK62ULeFMkZli3r0GsZMQGqaEJjNDwEYjcc46wjBc3w8Yzye4FxNmZMUJc2Suvrl4LTeu+KjekGvqfR2cqT0Vyar91gQg4pFqoCr26Vj5rzLIr7+Yir4O4ANYeYZkAJXl9dbvlNzqQ022GCDbyG8jml0ws7r8Kf/buvMfV1tMCavIvquBq0veF1qhChZLUaTVLctQejsTxPjEevBNHid0TT71P4+v/r7t3h0dxt0kmde16BbWbpqPCenV/ncLs4v1//lR3vc+6woCJ0ka6TTFUdeCZI0fPivj7n+ZlLBkexoLka+Rk8ILTFG7vzj6+zfm7B3s+UH/2qG2DFQo5qY90iFSg3Z6Z1OpwTTQlRcZuWrRJCYlAm6680roBWIFteVoaiLVNkJKJnU0QUakOREjKYjayQnYkClzYGMQrDp0zJ1ud6l/1u721YINoJ1BueKk7E8s5hIQOSAhzhS8CltsxqXQiSxLMzrVo4KBts95qLvkSqioEqZU6U7ZICAkNIwpCKUGBeILtj/JvLLv0kl/OjPAlffsHhqoozQWFGhCJFgIsEqGBA1GLWYaHEqRBOJeILxYCJODRItqvDGB8KN2w4RpZ4kbpUQsvNe03WEKt9PGbQt6CnT0qX6FKq0opwJ169usffnSoyBZjFlf/8eMS64+5vXmT0+e5z6ruHjX27z5Sdg7BHGzAAhhNTWtncd/9P/8i6fffU1jx4vMuGtxtoa9Q0uBrSZ89UnX/JP/88nTI88Nz8wvPlhSr0GRf2HbJRHAgFRm55HrIFxDhIb1C6Idk5Kl/Tsjt6vPh5z/4tRJiJMAeGdHxhufzgiaFktkvs2HkQxZo/glcgVYrTMm4Y//m89N/bgo58IP/kvF6vDea/gRU1ZzjrPReqw3mF48ef1T38959f//DXO3cfZnzKdTmn9eEBcE8BTUmhVY8OP/u0W9ahGYsSpItZQ2Qm1mxA0EjUQ8IS4IAnRCBokrbYKEDXnrz4DS4pdmqkLMY1hgknv4EyW1Lwamxz4d6ak0Fu+R+sC0avkHESz2ohgTYU1jmaxIHiPiYHKpJSIa2p8sRv/wnHS1Xw5WKZfrCfKLJ/3tBqcQfE8177rqGmrhBdZ+ty7xLu7s6ToJax+WkeUOcuxPp223PnkEfuPZzStgB2hcvGUdx//ZMJnPxeuvTnnh39WpbSfuJw+NWv4mYirknJLCLk9t2UFX1HeIxN9k/pbIi1Ug/bfE5uiJLJIXdfUVU1d150Ki4kGzSmGEpGtT8dZ1Fn2D/YJIWDEdCSeEFpEhKqqUKfMZscpldJkC2MMR0dHhOAxxlLXVerPsuDD/8Ym8jYjIgYfPKN6ktN85mcTyvOIBB/xrUe1IQTtFWKMo65HgMUXJRkVrBvndISa05/2Cobl81B9cEk5S4Sogm9CJv/KQN1HOnsUQExPID/LT3Y6aaa3s1ZJgOfFMvH87Dqch7yzRBgv9l7mchmRZHuS+0jsySiqMY/ZHuscYi2WpM5TWUnzkNhgbSLWBK+I1Pg22emVU8Cnd1UUQoTglRAD1oAlgi44/FL5/B8maByh+hqq1xOxslRWQYMb0A2W+/q6OzWfK3/1vyvoLlG30fgmISqh7V3Rs4M9Pv6HP0qkIGsxRohxB9/+MCkQSSEjRFLAv+EHfxK58oYjSk2QolSUCRMpFwRlOmBil/yUWDjra57h88BZabdeFE4711nt+7RjZO3+y+1aMYhUvP8njnf/qDsyB3zSfMsQaeeBn/7nKc387D7WLCx/+59eBwNX3j7gtfem7O5uYaLBiuS5ZUuM89RWrcFWDsTiWwWxSFb81KW3W5ljJ7KMrOT70m7XMl9fvRkWIWI1zfNMttEjSouloebo+JijuQCn+yrO0xLO3ufkt9FAsBBMIvvb2PT9+Il41W20y8WGNLPB88DzpoCdpy0+aZ+z6rdYVPzt//fjNDwOZillkUXbPn1K6g0uB03j+Lu//TA/o4xuoOrpqSXl0nz+7OTNhw/3+Mu/+NOeKJqJ3vUo8Kd//nPG29uIvU4l15iMXqObKUXF2ciVnVFWOE8+ixjb5P0Vk9N8GlRPlW8fXKSsbO4tU8n+8B55fzV534ENICmtI5IWHwgG1AIu++9t9sJEkOTjEQldudItpGClTO1+YlapLvVIayYHc5T+Sug54JrmrYNUwN3VqOUH/3KX8MfL20cTg78w8XeD07AhzDwDIuAv0WLaKMxssMEGG7xcpGC9wTiYnKZMu8GpKCrHVkBoiP6YpnkMfoHJpqKoxzpBTEDiHNtOEetppq8zOzLPdWIJ4BuLb+xSoOo80NkXMNtHSzqjtBUrJX1QQGMkTLeYH9Xs7B5R6Sf4BqzbRmSEqkv5XmWcJwOZuKKKRA9qwI7BbiWFAiyoIWK7gKzJjkakBdOiMYBoUpJQgzEV1o0QM0pqBSV1ho2o8wgtpaVDIoRAcZr2QYl+1W+SPy+BoZIqqjwoIanpDOckheSUVhOX4Gs5r+QgW/ZY57QzabeuUFRTBniV5GI12mJpgYioR2MKIuf4QiIxq0Nkgsg4pd8Rj7HHEI6IPjA/Sp260iMmRjuCnMpuUg3JExnJ12iIEBti6/FNWoGOtZhJjdgq3TObCHOVtVSjCoNJTrMhmRgAACAASURBVFfNQY6O0hPpVtJ292rViNQuNUS6Z2mVuziDVDnQ3UZGWjE7OuRVsByftzNoFW1jaBsYplkrkLjg7qd/j8QFWw6sGzOZ7CTCTKwIsUakIoYRR4/vMj0KXF1UEAXpVvYPrkcNalIuaKM2u/oXnStctAWNK0Hip78bvhF8s0yiapsGFY91FYpJ+cARopocQDvGSCJthTAmMqKaQCuRNqag0tI9euraJbxIR/Flnms9TeaiZxDmU2U+9SRSTMF62X8gBbPn94mhxrktqmqCqsPgwKV2FTE4BJ/Tm0RRVCB6wceYpHjPuraBcleXQkQjISht2wCKczaTALQbs0trXw70nt2GT6YqSF45jUrrG6KkFWy2tjTzhqaZAntr7s/FcVnt4YJv/gsfse5csvJ/IcvIiX2Xz7XuzKeEMM+xz5PKGbaz3jVe7kBxQUq3NX+nspSiqd9PByUtr+I+Lei0s73Fjz/8ITdfu82jh4/59JPP+c0vZuyf43qGaOfJ0mlmQkolI2gOnmtiknX168SSWCU8rNZy2WHZKezlbYUUYjMBrWxLqjLJHihk5HVp0YoyX6mTtXW2F8GYpD4XQlJ7Op4eIyKd8lPpi0lpJOBGICHgfUSzeoMqnUpMCZAnRRLJCliZFKG+UzBEQ/7cImKpXJJOLylxNDuEo0KMgZKiRGwxCvNdzkTvYhuW64/xJJll+Lt/DsPxZhlnc1nWf/k8FD+K2s46nEo8ML2TvSMiDq5xmEJvSNIyLuJc2jcGIQZIqYocRgOxPeb4+D7Hx0epjSjEoDSLhhAjVVUzGo8wVvBtQz2qMLoghhnHDyfMDz8oNaCnmaxc79Josfz3iXsTYXqk9MEC248FeY4QVAgnFj8IJR3i6tkADo73cYstqrpGcxuz1oKkNIid1a2JPFCCEydDDy8HZ7XDF0WmuezzrPbd0aT7Is3tgDQYSFqUYEqw7ewnogqzaRofX3NvcHVvhDU1ThzRz5jOHuPbh1TVMeNJDVi0MSgjHFdSWi9GRGpUXac+k5Qbc7pcjStBL0pt8xyY/N/wTda/68rOUubOpmZ753XM1GCtfyb7+wyr7NRvrJsgecw3ZoYuDuGJhJkn94yXY4s9Lwytm/Nd27Der8I4ssGrjRftJ7kozjahhNl0/GxlbPBcoSrMZudfOHoZCMEynZ5M+xO8EsOcGC0iDdFG1Izo55e5pRjFx6L2Rp5JZR+GgpBUeftReZ3V1vuYYeljtjWEmP0e/b5hMIfN81btSSxoNZj9pvmiyBxJnnhEes/uYDaP4ihp23sSjHalDOtezi/du/iUeQrFY8Op+9WT9XOOTX+8PGwIM88A1bJ+8PLK22CDDTbYYINvK6w2EOZonOL9nG8+dTSzCDl1kAFQgy2yi2qIsaayhtlxmpC9iInlRckyAPc+H3P8KAxW8qftRpLTO0vTMJsm5v7suOLzX+7iQ8TYGmMS6SUFWTwlXNMTVWIOqLQYO88qKYnhrpkmA8ksT6udPagn5mXCIYBiMBKwNiKmTQoF+Z+plNc+sJgicpKN8MK+T4GkzpuZbZKiOlBIHF2t6ScKmogFOb2QojkYm/LmplzxSvAHxNCCWkRqKreLUGUHZHE6JulQzeo9wQQgoLHl8T04vFfCNAHVoiaT6htVUXU5qJBJDJJXAKjh+HH/LL/5zHK0rwRVgrYoM268UzPecaikYJAhon7O/l3PwTeR6Nu0utpart127L2V6BNKWgFtTcrrbDTfvFjWGOZQguR1jN19lU5ufx06WXntJ5HWwriqqHe3qPYcx5+MmD0+tYjnjuFU8FVwBjWN8o9/NcfVSarUWKhrjzHpPoeY0t4YC2++54haceWmw0rVEcf6FSnpvscAD75YMD+Ca9dG/PD3J8wXDdN5IKgBrSny5n148PLuxuP78OkvAmJnuX8Ku68ZrryelEOieJC0GibljzYEDNNGGV1z3PqRoxDLlEBUT4wNSkvlah5+apkfnq++z3+aoms+PZ+zPN0TuviRsYWvfq2otFjXsHvN8PrtFhhhqBBTYY2kFIDisDntVkTxGolBk/pRviGrwa2OIDP4OwXp03gcQiIqxmi795SxNr+DSwDW9Jely2WXc64LqnVKFQo5E0gKPKEYE2j9lPniiGXCzMsly5SyXgRpZh2F5VUhy5yGdaGj8mmZ8NKnYLpM0szsyPHZL8csHkw4OAjc//oG08fH56r7eNtw/Zbt0xqJYWsvrQ7sa9WTnVODLWnJ0t/9O9n0jtxVVaXBttLfynHD9EMh9PZiCbKWvjk8bjUdZjk+KYXQ/Z3SM2mnWlMIJOm4oXM53/E1dV4N0BdVxc4uIZF7unRtnfpgTAFlo4ialJY8lpQ+ZNJ4GS9W1Qb7B67DfmCSMsS6Op2EDMrtoVrOMzjJ6pFS9h28X9beh2cbZU4rY7h99doKQWbt9pXjrLW4ylFVFpMd/0ktJqIxIhLY/yLQHkeitszmymymaR6gSgxC01hiFFxlGI0kk7AcrrKgNRoN7XR0JhVb13w+mY5p9Sbo0n6nldftfsb5h3j4lWM+hd1rgZvfSyuT2+aIqBGTlXaSdL1k2yjPfIr85kt2vr7qhJmn7RNry8wvv8FMFgBXC7c+nBDa4ZvhlPrk72+8vcVovEX0iqpHxWGcRaIyX8y4/8WE6G1W7FSM8QgLkKTOGLXYPMrr71gmV/qx0xD6OuQxVmVAGtN8KVn5TDvyfk7LpMXbISTFGseo3qFyM5aJ1peBJ7URi4hLCq06I+oBMOb0ENCLI8uUsl6FuePTkGZOHrnBBr+b2LT/DQqCt3xy5w1cXXP9jRFX3lDSwq3ks6KLBiSSfpqraZ5RlnepDn7T2Y+d7VBk32S55Q1mP4OfvEWU2WHLvc+agR+7+L8H9dLib88Emzz36bTMRZfK78kxRQc9vfeXapTVYURL7WCyC298DzRGjEDQpGsjxgKWKFmNTyWp1z3jc9ng6bEhzDwDIqlxX2Z5G2ywwQYbbPBthQn7aPuA6A9pZi2f/+x9mvmNC5ez+mq9TEPxacgyAF9/+ubS3ypnGwDHBxN+88/vPdW5Eton70IfgCh/peNOHltNhGu3JhhrEUlqA2WCsuQqKpqeAuQUTcvqA5GSHgrtV5+mSQwdsUNMCrag2Ynoj4hhlgK3jHFu0gVqe7b9HLRNP7LA6ZQYG2JoePzlNp/+dJdlrFN2mOafIZZXXnzy0eqqiDmjq0q9B4jLxBdP6494+GXk81+k1YrpB6QK7L7egowgJrJMZTxOFhgJGI2gIU/HkraSV2HeQogGY2qM6SVRh+QYkT4lVgmqqYBqxFnDyAr1xHHz2jYfjfsJ34vCq+wY8a3hVz85LW9vr7Qymgh/9u+2GE1qFIeqQTWtiE9T4Ihk2dVRpfzy4zn3Pg+Y39vm7f/uKgcHcO+BZ7owqI4ohBm4fNLMo7uWR3cB5t22935suXazQrRCpQSDJREiAJWIGsPVt0ZcecOmYKdRFE/QBh8CUReMKmH2GGaHpYTT8aLIMi+qfZ11nrOf3MVq6L3w8S+vdn/feLvl+ls+pzPZxuRUdVHBdkoUORAdAfVnBvVWg7SFYJeCsKS0dSHiQ39V1ia1iqR8IZguJVMKmK8jyJxJmMnOolSWotoSY4P3M1o/u/B9exFt4HnaGKvlyeD3k8gy5yfJnH3Ms0AGn4ZPeP2efb/tbCtZ7stDJ+ZyqcPvEh7ei/zH/2MK/HZwnu1z1Xt8RXjnxxWVq9FISmloHCFkG4TBar6cSirGRGwJIXSkl5JSMrVp0ynGDH/WKYkMSQ7DnxhjZ1oVdO/2vM+QaNOrvxTlKDplmRiTWpSRoUM2pXIMQbEC1rlMqOmJO4Wos5QaqatHOW/ZBkXRcKgWGGMgRI8x6Tp9jMTMlikqEbk2vU2z0tO6d1ROxVTu29mB+Ry0VliXJnbVZb6cXu4k1p1rlXj4tDhv2esUdMr2dW3NWotzjrqucZUlapPULmNLjAHinMYfce83E46+Se8UlWvAteXzkqzYCMwGd249CWb1m9P2gZSmcvn71bt5kXH9POOzAIdfb3P4NbRvz3jz3SlOYDY/oG1bnKuoRpOU0s1U4EZgRqiaQpu58DN/2jZy0ZRHzwNPc67nWr/8QnRjw/d+vEXPC155Aw1SHcTczlQMPraJDBUFY8aMt25Q1Y79R5aPf3aVZr46RpdUXotB+XBlD7a3BB8SCRBI5Lw8Tzamwpg6zZuxeVGFBbW5qgGlpVtGu8KgaJoGZ9a/M54e53suUQOKRRDUz5B4TAr/rIaAzkdkex54dUgzPTYkmA0uE69a+75MbPrJBkN4b/noV7cA+AEtuzcbLEcUH6rk94/gBvZ8SGSZvOBGJRK7bWlOIoVkszT3GS4SYLC9fFfmmxFDy/xgwZ3/OudVwM3bkXfea9KcSgSJgleL2DFRHCoOlQqhyuqo3+VR5NXGhjDzDNgQZjbYYIMNNtigQGnm9wjzbyA2qHeXtnrvtFIuaj5epsE5LOtJ5JlXAaqRxexeIoTYGjF1MsRjDpACiFkJqiT1FFcNHX19MKn3cPZkGc0rtTUqmmXijRXGVU00iveOEB0xRJRAYfkLEdEZqgs0zCHOMHGKhiatIFw4YJUwc3kI0dO2KUBRWctiMaeZTwneAgNyC9DM5xwfLKirZLm52hDlAK+PcabBuphVfixIjY+O0MDxYUvTjqiqPerRLtZYjE3LFU3Ku0BHH+pWdgPGEE1FIxbvIwdHc2azIxZ+B1e5FFDzz28ydZ7W/eS1oa8OlHS/+zbuiDmA2usGKVYablyrGOXHrzpH/ZeJWGNa2mBYLNYH8Lp0HybkcumCX8FLl4riaWBEQCNNs0CqLVI0Nq1wTcHKPihqbSK1aRQ01lhGjNwOkQa/UIyZ4+peL1NI6d3OED96ujpbwdjeEZ0CppoJc/1q4xiSqs/ysekn1Q+858mq8s+ApxnNz/s0YwjMpjNElHqyhaBdKpOi5kXu+zF4vA+wojyxqlawnswSuzJX0yi1baBtddBGUmDIOUflaqx1OOfOv7q8C65nAkDO3W2sYh1YFzIByK4NeC8VBVhHWdgNmp738/bKXmbQ5rxkmUIfWefuO7vUs/Y7X71Ow/pAtXTfnSS7rFJe6MgoaesySWZ127r3xolHLUmxSLJ90jeOZRgHgYCRCEYQo2lcLKsTh1XM/4UQ8N536i09WTU7aUU65Rfo/x72w0RAsx3xZqgY06k9CRjTE0OG5JQhOaL/PttSyTBLdpitCKQUkEFjGj5FQA3BN7QIsXK4rTExBtq2ZTafMZ8nB7ERk1IAlbEkajdGqAoaU4A1kW2GBKBICD6P1XlfTeoktavTussYkZyqKWrs7pORdK9CDOl8mcxXSDpDy2F1rBqiPK/148DgmEL4Ltue0jZ/GmWNJ5Fu1iv8sHSvJadgEsnKhc4xHo0SGVFy+hoFIxaCJbSeZnFMu3jI/v7XNIvvIUXRa2WsLQpQpe+uXmG23Jf+Xj1+3XfriDXr7t7lDeFyov7eTzk++BI0rdaNzYLDIw+mxqulqidM9q4z2tojqGCZYKTKQZhUJpz93E9TWnvS2+N5pP+6KE6ve37m2n0iZvtKjGJdurbldGiXaOUPxueS5qBrgwJGwahgioKp8Xn/pCKJOpSaoJYYRojcYGt7ByP7OKddbK2cIaRMvksI7Vcc7T/m8KihDZIMECqMrXC2pnJjKrdDVU2o6jHWjVC1tJ7UXx1ZxVIGY5R2t8mYRL5/GZ7+KD7NaKIhNi3aJqJdj9P7+8vBy5xBLlshZ9okpxz5atzDDV4lfBt8Ik+LTXvf4CzMFw3HRy2uTmrpIg5I722iA9I8QkmpZMXEvNiypdEmz+dMSjWLw4jDGoeRLJWuA2VN7Ufhzo6QrFwuAWizM+FsFF9Vj+STWvVLPStMnDGaf0G7aJNNrxVGa6LUxGjT9VY7mPoKUUZ4zde8Wo7T5Do+YZ99l0eeF4sNYeYZoFxySqZLLGuDDTbYYIOngA6MLhl6Z7X7ORnvMWWt2guq5MVxkihy2rXA8nUEMCkApgJaGN5qQZNCSZIvDmhscHLM3c/3+OLjm6hC2zxfM+NVWZn0bSDP+IXwq7+YpIAJ0CvRrDjVV467/mbFj/58ixgdQYVoLFGgqMuIStFQQeMCIw1jPeKzX8Gdn1eDMmugAi2hsxlD1QwoATQBxqRUN1fS0ZrUQ54nfvt3KZUVNF2QCN3BNyfb2INPLPtfCWWlYlo0bUmrefucvOmi0piiCiEWxR4QSWkm3vm9fa7eFFw1wbgR463dvCpcIVqQCmMMrbb4doaPEVPfREeOD/7lgluzhzz6esGdf7q4ktN5cNHW/KoTZ0r92rJyPnqMgDUOgsdIgzENj75p+clfe6z1zI5T2olP7wT+t/91RlRNKdDi6fPvcp7tm/9MNblHVVn2rmzz7rtv889/dZN7Xz45J/hp+OyXga/uBNxI+PDfNoy2LDYKLlhMTCv9gxiCSfMUFUVN0jqSCBIVweKc4Qd/MiJ6EI0YaZmMjvmnv1Luf/XU1VuLW++PeOdfTBAnRFlwMP2aoA1VtUVldxDdRlC+/NWcL37VLB/7Ibzzo5TgzFnLz/4SHn55ufV7Vpy3n+zfd/z9f9gFhB/9G8uVmybJ8FpHoCGqEPBEItFWTHYSWyvGeEIFYxhcXyXFSJE77lJ+9HVI74BBgFDJ+9melECfXuaJq8xNgKidEoaIIcSK7a3b3H7vgHr0Jfv79zj88gPa471Tiyn38N0/iFx/K6ngLOaen/2l0L4ai8JOxbo7VO7xerLMWUSZdZ8up04XPUZPfFf0s9ZRa7S3yToCYiljOaRUthUqzsnz9HvXW/tce+cjbly/zXiyS1VvYd0YkRofpVOQsZWhsuV9q8SQUtAJQklxBOBDwLcNbdvQtot0fD6ztS4TFkxHJCukl9I3+lWPse8/QIiJGFYQ44CUgqAxtYREVomgklOj5fsaS3rOfBeyH1gk30+N6dyaNkoa6ru0nCIQNDBtZlgnSCW4WOG0HzeQPh1UkKJwk9ujSYHplPqoqNOkfYy1iQCTFWJCCMQQU865pfoKZvBUAyFfL9B9010Cy0SZQihZT9siE4+eiI5U1ROTnngIPWmz/H1hiKYI/9oqFRKZdNUTBGcMYmwKvNuKqhpRj0bpOcWIMeQ27ZHYIjGivuHR/qcc/OItFo+3UXWovkaIV9HGLbnLh/aYFtt7jRrMuk/rCDKrikFn3d6LfHfa3V5fxsnR4uDBhJ/8p+8NdsnvRynjleHG+3Nu/uAh9WgXNxoRfUtUxRhJBFE0Eflzl1Y1gOuU14Ccui2TPKTkIdTOzk+dwKBYiiy/5DnyKk5TqiqIS3dm0C90+BSGI+zZrfZU4o4oYiOqLU1zzMd/JxzcFXZem3Hrx/dxdouq2sZVWxg7RqiIYTn929m+hPxbZWlrusJCcFO6kaNLcVDeKYFgEgkXNYgOfS4pjXEIgdY3xOgTMRf4wb/aZe9mhUoA26DxmN/8NTz+evn9+uu/v4kxr+VnS3/uPD7RKe9FkH7eWt51t37guf2hYN0uSEXEoppSMBsUbSNiq9wOLjsl09loVFhQ48wYW9XgTE75cDGizGV5Nc7q56/WnHHZXjkvIUbOsc8GG3wXsGnnGzwJX3884f6XE/p0qsUWarsGlOZUQ4umEF6E5FcdxlfS8cLQR7T+zdGP3CUxU/LbPQm3Phxx+/dGaa5FwEjLZz/3fPbzy23x9+5O+D///fvdJEUH9pIi2aw0IA3FV7+uBh/8yTHX37JpXmwntD4RevWEAvsGT4sNYeYZELlcs3ejMLPBBhts8JJhIBo6B5jJzpxhgEDKyviln1drqr+MJG/YGZ2dM8ouE2k0lkhH+lNIK7jQZHipQdQmx2EAIWKZYeUI5Zjoj7BmHw3XmU9Hq5V4jlf3at39ck9fFHHm3A4ahWZq+j+WyGAndu2wOD6knX+Fyhhjt7C6g9VJ7hcBUcWIx0qDqRrQKTY8pJ2NmR4Og6PDSc9qHVavCEr6oxeFdgbtYJqWsH7CEVohtHDScV9y2p8Hyeq7vjXlrWsLVCxeI85NaDzgaryvODwSRqMdxFgq48A4VEcYUzPZGWOqwOH+0YWv9zx4lhZ81pN9kTj1GiRS1ZoCfnGBM8LujiDMGdUePYbp4XIbbRt4/PBi1vo777/DH//rP+atN17n6PAB33z1aVKdOXfI6CTaheIXUHklhIeEACNbsVNVVKQgzNQHZj7g1WDciBAMSEVZga8SAKGamBT7ycS3uk5pddYFpZ4F6lrMpGY03qVpDVfqm4hErB1hzYiwaBBZUNUnZ1Z1VTPZcnidYV2LscWJ8u1DCEI4zu+I1mOjwWARa/GtJ/g2B+0EaxzOVSkQHjxt2+K979O8cJIsUzAMQA9oDB0Jpty+ku5j+GOyysEQq6o2gzMh6voV6BpTqhCNiFjqkePmrTHXb97gN/s1+8fr78uwtY23t5jsGIyJGCuIvJgg0+m2xNltbT1Zpv89JMuUkOHq2/BpQvQvogesvrH7bdJtW/3UB3YL0WF1LDlr7BsSatI329u7vP/9P6Sqr4BYjLEoyqI9xktLNa6wxiEYjPZjQ6fIFCO+bZl5n4gqmRCbAqQmpyfrVV4SqSERG4wkIkm/ZjGSFFJi1xeBTj1kmF6x9L2oESMWk9X7koLfSh8dEG1K37M2q7OspIxC0nddX6YPvjtnqWuXxowYiLEhhJjLc7msSOwUZtK9TkO+nhpU16gE9SmdTRkDtCfroGkFprOWuh4hYjoeQfo+EY9CTKkqRelSwXWtoFM3XFuFS8Hw+Qy3Pes8opRBJkRnDsAg7p7IANZaXFXhbCLJVG6Ecy6lSrWCcxYhPbe2bVgspsx8y2hUU9cVRpQQpsRwHz+7hj/a7gILWlKGrtZt8Fshp9Fa7mdDFLLMMqnm7P2fFU8qY3nsORnuD0EI04qz0Bw/ZL7/Bd7WxHqS33MWcQ61Dh+VplVCFKIaVB0iI6wbUdVjXDVBbUrpFHPHMd17b9CONZLs+95zcNrofqaiTXfX5eSYq/1eXeoBkSV1wfNCYgv+mNAeYuIB7fQqi6Mxk50DtsyvgR3Eb6NhhyDbYHYw7hpIjXYSLqtvt2Ftsw2imlJESiGNDchHw3eGlGuSfrPmNq4WJI/xkpVNJXOTrE0pLTX1iBgfYozFjSZIPUZwWDdDVrz3zfw84ZDBdaygmd4jzB9BtUvUiqgOGCFmC+N2MMYh6kir4V8sHBYHiLZg54lQlJ/ZiyTKrCvv22HBX5w4syHNbPBdwqYtL+NJ49bmfvXwrcG3wy2n+53XY4V0e+HjLw5X14x3dkEtqh50jnXHrC7wfFYEbzg+Og+p5TRfeUIt95i4BRpG+MUI4TUqt4XTxanHbHAxbAgzzwBlozCzwQYbbPBdgm/38fO7IJbKjTGmQnAoJjlqlqbCxSmWQ+yv6Ow/EV/yqtSshiPaO6RStfO1aEirZkkrYo2xeRVtXsGqoCFATIoihw8Dhw89SkCjweh19h89v7Q5zwoVfWF5QEXllVWbuYhLZ3oEn/5cwQSMaRAzo6wMVJQ3bk/Z3W2xJrH+jW346o7h0d2znddPU78X4Yg6X+s42212kXo++HqCnzsiShs8YhUfBIjEEDg+VqpqjhqHsZHx1oIrN2YsjtP5VRboJUuFcoH6X7TMFzlMKmCd8OYHDufKGB0xFr75rce6iKiiMWBE2RpbhJbKKQePL6embjQiIMyahojQ+HZJhWC5thc7Z/DK3V96bKWMXGRsAzanclj4QBMiW3uGdz5UjqdK1F3QiiRnn+9HLBSxtJ4m6rqgwLM+OUVpicwR2QYRKjNGLBhxCJYgDfXI49waAp+O0LCDyDYaZty41bC9F1lMI1//9tu73KBpWxZNJqS2QtAGFKwYjHFYU2GsI2ofMC9qGE+b5mGoSlOIMVVVpaBtpyAha48pn1dTQUkh4HaBYkFLENoIo/GI8WSPN95bMLnSdEQD7z3HDyra+bLTyFiHmNQmrS2ryV/Wu/RiZBlZ+bxKllkOJvZ7vopkmXXnXEd16QPCurS12zJI0bRakq5sqSeRK282bG/tpTR5Ctt7jt29CT4UckmgbefMFzNUPTH6NI5k1TvoCSydmkomnaRArel+nMmqSl2qotjt731a1VcINX2qJUtJQVmwSpwZKkAVAkxJ17Tcd09PsRZ8UqwZkmVK+at/W2upqqxG13pUI23raVuPiM37kX9KgD8pyZzVtQpxqNRxSNRLyjvl3ZCeYIgRHwx1VeOcS+1A0nOJMWJjqkcT++tcPd9anF3Nc2F4f4fPc/WcUv475wn7ck1KS5X/trZXKUrblKqqGY8TSUYyGcsYMkk1EOOU6dEDmoc14fE2TSO03lCPBFcl9Z/ga5rZTeJsPBhN9ESVlWH/HG5d3kdXPr9ossxFcFFLZFi/48cTuHMVQXA2KZhZkwh4YgwxKj5AiIKqSbNgUawNWNdiK4OpI9duL3CjGmtrBEeMJrfxIUGw9w8IZplQM2hvZ6eAKuqVmklkJWifn5QkVZb0TSHfXeDmlCPFo3HGYnbEo88dixzEaY5H3P3N6ygjrr45o5ocJt+AtVTu6oDoMhh3y7tOIpJThEJI47S2SPSIUQzC/j3H/n2LsYHdm/cwLubrEURsUvsSh0bSynAxjLeuIFKhYlBMSrmkHo0NR/cDRw9AfSR6oL2Pny2IYRfL69TVmPVrtM+D0weEgwcVn/1qgpRUfUSgRcwiEeGMAxyP775YdRkAR6BST8AQzZiIgPhcx7PxvPv2+r78omeJ58Xy83/S62FDmtmg4FVt0efBpg0v4zzPcdP3v90QbbBMEamIBDS2yPNwsl4S7n8xYX5oCdHgvWCk4e13jpC4/7Kr9p3BhjDzDEhTgMstb4MNNthgg5eI+Zcw+whrFXGFKgAAIABJREFUa5zuYd0YqFHGREYojpTcMkkup9VOxTkGfRBATzGsX07oZ5Das/MGd35uIqItIgtUs/SfBiyRWpUQW6J6FJ8cUzkJuGjg4Vd7fPyLa8BO/llOC/O0js2L4KIT0RdNmll3/lcD52uJs8Oaj382fK4BmHZ/Xdn+gr2dGaJCDC1ihc/v3OL+N1vPuBJj3dEn+9Vl3s2LkWXK52erwW9+feUCe7dcf/2IqzufMp83iDFMtmq2qz3g2YhqL6pVPu8VhqvX4Sp47/crRtsuj9We+bTlv/z7lsVs9egyjl9ezR7tP+C//uMvILZsTxyVDTTttbWB5/Xh6PVQktLRlz+rVrYOyzDceh9+/w/naAtNMybicignBRw62db/n70365EsOc80n8/MzvElInKvytqyuEpkSxQpEtMjqYURWhCEvhJmrvgL5kZXAvQv9A90qQtdjACOBGiAAWbB9EA9UDdGQy2U1CqKZJGsNTMrt9h8O8fsmwuzs/gW4R7hkRGR5W+VZ7ifxcyObcfMvtfeTwQj0N/pYN2YqKQwG+NqaVt0jzXgjAcdYw3xnaIQREFLJAvYjmDcfJsKCh6LSBfVDq9/8ZgsL3jxsOTh+1fcV88JKAKMvCeEEgGyTMicw9kMJ3FHcumVsiyYFBNKXxCCr0krleuYKSO8NKMQdNo4N+e2SSQqHjhXK8sAc+6e2n+r79NG5hLwjclWGgpWIFrpgw/cfddy8y3HZOwpvWcyGfPxyMwRZgp/ROEVkUBZeJTFvrs3jfPEML0PTmaIMjJ1vk2PuW4L6avRh5ILIpo3ZF19pDL6Sl1P26SZ3h48+CXh5q0uITSy1IV6xsUEiIorRTEmqCJiKYpqRUYJvqSm8CSSQlDFiGBcjjHJ5VDlqgypSQ5RlSWlKdVZRQlBE+khptL7hmw2S2CB5IpJA5Wbo6icojVhplGymSFspD9V+ysTubJN7JiNL8uyOtyK6DMaj6KqTlkmQlxUfCyKIhqijRC0UnPRSHqp46hINfFd0jTzSLCs0haJe9Nkn6h4EyiKcVTmqck8yfhvItkIBPVVvdA6HSb5KpomFLQqx4lsgIq0wlSenkTKkZm4ptBS4WpiqAgJsX5VdakivkhS66r65SzLybM85gugGnDO0clzrIvqnWV5TFEcMS6HaBgxmRxwdPApk/ffQT+6C3QIKBOJLSWWSg7sThni5uky1fHmvtnfIX1vrz+2yTKz7XM23JeHecrPsn5ocbri0cH+PQb7r8301ctIjIuRdcfs3fqIru1htU/QDhJ6uLzfyOCLQcXWpUVopazlLqw+1kr07Oyi/q0lw9ERIZR4XyQyX6DX7cTyDArisNkOzrqk3hTXKmq1lqn8qOp3fF8HK0y85eMf3aYYRTWk4eEeP/3nXwLgazuPyXYC0EfNDioOEklINLo8EGJfIgSEAg1DVAuEuEubMMCEEdYGjBEOPr3Fz/7pFi6f8KXvvEfWKWpKkGBwWUZmuwQv+BKMyQjmLjbrYEyK3wghTDDlmMNPu3zwX/tUb51c9rH+KcWwgw+HSHcH9TcR8jOTHRade/H0Ni+e3l5yR+WC4nJ2e4s/BG8QuYHaGxjpIuwDkxPvu4xViqtPLFifNMMp12zx+cDVr9sR27o6jetQZltsFobnOH2I4uImYUqEDtC77KQtxEc/uTd37ObOp6g/uITUvJrYEmbOgeiSaXOvli1hZostttjicrFjP+OG/QDVDB3fwI8dhTeovYFkN6M8c6cDpoNqh0CGEYMGSTst02Kk+GSsagWuEuXi0/G4k+/in0mmdqbFSLUy6Ihi8MAE0SNghMgE1THijzD+Cb4c46xQ+gLvA3neQUOUX486yIsXitZ9tPORK9ZDRVp5WcSZNlaNcx1izaq0jfnrFt+5Dg0kjJ8xOX4BYgkBfBkoitdWuncxJWa9Oxqz29mxXi2YNlO8bGSm5E7viNs9wWUZN/YcT0yHfzhjeJe5QHIWCsYiGCuIXWw6cplg6l+GooTDo1GSTY/8R1PdW++iT/3bBvD84JBMDyhHAwaHz+l3HcPjB2jqN0+qSdO7Yc+YO6HEFBNudvY4DspYC0qtjNk27TiN5mtrhTffuku39xQYnrIYvFrNMS5gjCHPuzjbxZfV3SZ6AQzxufJun1ExYFzMZ3ywA3xWoOqwRJcIvuxTTgo2LZNbYdX+9DzIu46sKwSvZFlGbl1Ul8EgKviJZzQecDQ+JhCw1tJxGUVRYkSwxqJAWVZKd9TuDqr0LSLMVIZi51ytLNNWxliE2eNT7mdC5X4ipSJZ+rRlhC98gUHIs5zMOQbDF9jMYxesRLx49jHkBc5Zjg8mBP8FLmfJYnkJLzrTNrwaregY0ySZ2fsuYgyySVLuaelTmSaxxr532jhrjCZX9A0tUOt0mqk3eLfXY/fmawxGJWI8JikIlOWE4+MDRqMxIQScy+n1dlCNfbiIBWMxIQ6wo6sxU7v5gfk6bJKCTeOOCVCPMZZeN4v3GxiNIrPSWpcUPlorNqnvbIu1aCK5VC7OImEn5kHjfkkTB6WqIYmk01KnEWOwyBQZpyK1tcluxhgmkwmjUewLncvBWLLM1SonkZQiBO/x6qMbPlI/rlFpTUTrtNfUijR/CBqiUR6t+45KeUYT4UWDRhco1lKWBePxGJFZl2+GSnHDGhv7K8DX5J2kxpLISdFtlrTmUpViTbsITF1/Ih+hoRrUaVzgxq5NmJlz0RTCTBwxTCMm9r3W4lzecmMXyZ7OGYy4qBBmc5yNZL8Yv6/z15dx40HwRxw+/4QXzz4j+GOMFOT5kEzu4xMNAVL+prduJLVUbekkikhzRUWEaQgzOtMOm3bZvm9xmPNYfyx/NqxGlFk+J4i6mLMbV1Y3Z6p67Pgx/kCYBEcRuoi7w41bb4BYVDJUuiB9QoixGMqo4pLafJuSJFKRK2dTIEntNWAkIDLhs8c/YTQ85GB/n8P9A8Dzxv27iAjee2zW48bdt9nb7dPp9nG2hzV9RPqEtPagBBCPiAcJKB4vBm+7mBxcZsHP50XWf0B3rwPkBDV4qd75HtQjGtW71Ec5GO8HFJNnBD9CpIAwRPUYw4hOJmAFLQxwC5FA3x5hGdQu43wI+LEB65K3aIPrdNl//FNcltPp9rAuI6AIHpGAlg8Qdur8MzomlyGhGHBw+IRj6yhGvwrcOyPZ4SRi1Wm1ffYuXfBt9bun71r+NOPRE4aHQzC7uOwuIl0IZqXn3xrPN4MtcWY9rDMivk55ehVJM9cp/14mzltO2zZ/faHFc8rjj9PmiUiSD8VbXFXCzCJIGCFh65JpU9gSZs6BAPgNLkptCTNbbLHFFpeLe7df587eXX76M8ff//1XaMyCcddYlitf+7cfkve65J07dPObIBmFgPchKs8bieQBQ3TPXYUicSG9MWZJJK9c+AxKsWHR4qfEhSlVUI/6MWVxBDrk4fs7PPrZOwhv1ovLU7tck2GgLM7jdmc9bDqb1jVUnSf+s4wU1lWnmd0/uPp1Jy0Nnh7ee//4Ney/+OYOVSbj/IQ7TsZZSTSNKW6Ve06O76xXvQw8eXKD//h/fTP+SIZB71fxg7sYV2lh9KzpePMrfR58bRcjUbnE2ICGEtUS54TerqFUw8RDqY6ss4vIGFDuf9nx9tfijtXxeAha8vAngUc/2cwzDT74RTBfgeTq41hAfTPxrp55Wb2XJb9WxaOPLf/L/9QDPF/9zpAbr03AOFzmEAIaiIZQLXFSMDp+TihP3n26ampc7nnnV59w+959dva6qHOgDlSQ4KK2jQmolkwmA0o/xJfRiD4NC5ojmhPUYqRa8C8ute6eN+5QHuJUEJchAs52CAEm3qNeCV4xmaNr+yjJnUvpcc5W8gCRnCHS0rhLKghSuXNopXfGKFz9rYzwwJTKTBvW2vr4tMoEoG2nHULcYZ/uEzBGsBLo5g6Dcrh/yMNPf4bngNHoq8Ctqbievn+f5z/XWpmjLOwZcvdiMEd4oW3wnFaUaRNm4GLIMQvTuCFS7irhLL2mVhkS9t4dcPsrE/r9Hax1aDBoaCsfCNGll8FmUPoJRTmgLIvkjqgae1ryTr/+Di6pfEhDknBSK5VEC7FipXJbMk0Iq2ttImuEEMl9leKSSHKjlFyuaDAEVSaTom4/planMellqrjEAqvcIAUfajd88TKDhmnawnTbhDaZo3bf0xqHVy7NBoNBnY5I4sgwNkNDILQIoBrAiCFU2shKJMmoR4NHCYkUEyctFSlFUhqtMYlw0iKYaEX4MfF+HyNSk8gxJhJ1fFlQFpPabVR0f2NRE6hc2VgxYIjuoipiiMbnMjUpxdC41GrSoRrwPtR9WVSxqZ69cme1mAxY5Wnb7RVUJNqmbjXEH4eR6MbHuU4iJTmsE6yJqlia3F1pgKIo6xeF4hEpa7KCSCCznuzpG7h/ejcWEkqQAGWe+o/odidSJ1I7UInX0JBcGhWZNjFmnigTZogw7fMnEU2g6cc2ObZeLayTiArNFTrz66T0tscv8bvO3L8YxSTjn//mV1r1L873jQnc/9oH7N0tyTt36O28gWh07awaVackjrgiZcdGRaIqHVOkGSW+P63Fa6WQZbh16xaTnuBfvM7w+S4Azw+qd6OCGI57yu6vv0+hSqE9svwu/f5bGMlRLEGj202vFXEGwGDo0t/r8m9+x0IwxM0wVT4EOv2UoxLVYyTs4/0xZTEglBOcieTXn/7t6xx81gMsqnfj+kFdw2L9rtZAqvWDctLhve//O+qFhTkySPomleKYVJ3k1LXlZNqs8eN/+TcY+4uJiFhd0zm1lKfrxapY990uc98aGtXyufhiLG9FP/rHt7FW04snqntNRk24l02amc3jqi1Op+JlYb2nXTdvXhap8DrirKV83fL0pPn+y8RVzqPLwEWVx1VaX9tiNXzwk9f59MO7ab4Qa8ZVWoNYBaX3+LBlFmwKW8LMOaDoRhVmlu0S2WKLLbbY4uUgYOnu3KC/02Vw3Jk/3y3ohEd0gmBGj/CjDl46lNLH5jexrgfkhOCIW2pdNGAlmWI1LdcFukgq+SIgSGvxqxLj1sr/uCiCxdldjHWE0McHy+DIAVkKoR3a9LcLT73Kxt0YrWpQ2tSzLd9btmY4rXRvkjwzTZyZv+ukSd9knF+42vSq5aBztXPeAHByWJe9jHE6vDccH3c3GuZ1n9TnXU//ZkFULRFUMqCTDH/CRD1eLUGIqgXWEiXJlaxr6d50CELWd/hQ4rqb2wsWimny2LIp7LKFtOm6e5opax5lKRwmV8ZlsJgsQwmU5SG5PcCXYwwBIx4/GfD44wHj4WusspvmtFwyxnL7zuvs3IiG8hBM/UCCTFU8IxZnc4wpmauN2kHCLhJAKMhtgWGA0+vrjglgr2/Z6Za8OHjGk2cH7OzeQ4zD2oxO3iHvduiIwfoMNEcVJpTRsJvc/agqkshYEJJCRaplJzTqtguXEMKc2kLbeDyrxlD9rUg0U5BEmMFE1T2N5DXnLGjJi/2nPH3yEF8e4/IwR40C8BO30OXxmYinZ7hn1TsbQ6ekkVzztyLQbCYty3Gefvu8LiNPfJ5W2N3uDnu3Yh9gbRqLJpUrEiG79CW+9IzLknLsUfXJtVGMSSQRJqpcr8kRZkpxpE0sqfgRFVklRtd6PqUm16hqTZaJroWUsvQURZGUZRoFprbKy+xnKgta10d3PqFpV62+b1oFShPhgrn2NusqzRhDt9udSk8MOJFeWvdEQownMSTjNYT4TpGkaJOKLcYRpuJb1D9U91hjExknuoESEcqynOpDqjC891jASFyCDCEQlJqYb12GsRYxtlbRMVOujlqEndbzOaf19THcWH+MaTK6nZ9V+tufxs1do0NS1bGKjORc1lLLcbE2Vi6ZEGqmDwpMiIoeijGBshhxePyMwXAfY5VO7kAD5f493OhmqpKzBJZEzGpVmYAumRdpxaMk1ESY1l+ZXmtcZKBfpfVvsh9blYQzG+ei+5bNZ5ald5Y0M31myT0K4+H82gAozr+gJ4fkHNIN+5RlYHQEk6JHGXoY48i7PfJuH9EMDRYkqslVVUZJRFcDXhXFgjhUDDs3vkg+OWY/L6hekH7mRVkyxkweITpGcQQ+Y2yeoHQQ6WPcTYzbQ4NFNbqWhgDG4KzFZYKWglbuBMUDQ0IYUhQjQhgRdEQmL3A6wOgExGNNfOcVo12GR92Us6sZmVSF8ahf/159vncyinFnJSLYdLzT7hPP/n4915v5nPc3mIxP3tS0CmlmFi+DRNP+dVVm5Rfx3Kv2f68yNl2+1yFPN7fCcLa4t4i4Kn3LqjhPek8ja23rRUQxcRST602RyPIM5673M1wlbHPyHKg8Zm8yvC222GKLLS4PR4NjDo4OGRWLh5S+NHzyszs4l+TN1RBUCCbg8pIbd5+zd3sCpoeS4/KbiO3EBXkUgs5M/1/WcL1ZuKp20mlNliHuPJIexuRI8BhbsNk33NXByybLLAv7vJOTVYlEq8S1qWsuG/NpjEeq4y+TLHMd8quN65beNoRjjB7gg8VKl3FposslqVzWlGlXa9xVG3xlMIwEDKMeVLDiMWaCldUX+zeNk+rp8nOrLb8FDCoWI6Ah4IvnPP65YXRsMUYJpQGfcbg/67LgbOlFhG6eI0R1gsq4WL2FKgJQNDU6jAi3X3fwyz4Zbi1guXmvj1GHZYQ1Qz77sGB4MOboRcl1nso++lA4eG44PDK82Ld0uiViFOcgz4QsB8Gwd2/E3s2czPUgtwh5MjJLdIPiPSEUiZwSDdA+NIoEyxBCNHADtRF4keG/QtsNU32NVESuhsgAFhUTS1k9AY81lsnoiOPBc44OxowOXiNz4Cerkf/O2jetszB92rUy91eS66WKLJP0NirCwxnSuy423W9X44pl4yTrhHtfcdgsqi6iQhmm94VrUgowaXy5e9+Qu6RVEmiJAygkpYwQPEU5oSxLfNC6n6gIMSIGa+IO+UrxQ8S0SBSzKi2L0z9Vf7VVlqneV2SZSnWkTZCpyS8zbaBy51QRd9pkjoqMFjRElYkFLoDaYUUFhflnWERcqQg+ldpMJMZE10jNrZEooxrwwRNCSVBPCD5Kz5DIcamsFpFzluVnVe/b6WqT7aq/bbJL7RaJMhFTTHQ9ldxLWZdFskwiqrTVdRblx2waZ8lHoHOKPVU/FmaUhZrybT4NWSaq4zg3rXbTqNe00lX9kOhOJ5SBwY+hGAmjYcZk1MPkSudrATGO7DUlkyOKYYH/5CbqGwduzYyxMQPOv52rbRANWaZSMqnIN5WSDFN3MRXOZY7/TurH1u1HL2ssu//4NuWwi7WRVOW9MJ4EijKQ94e89tYRk4GjGHfo7Nyh27+NmJwQhBCkLunY9VbjI0Mc41iMzcg7GTY7AoYL0+C95dHP3kRsCQgYFxWnMIgE7rxZcvuNEsWiGMBGQmEowERX0mUxIvgCNLprtvaYZx/3GB6SCLmCkx5GMlCf+o3Y942OFpGJrj5myTLTxxusRyddrxa256m64Vrc3xNef5Bchmkkro+OSh5/OF47ppfdvi6TXNBOw0XiOs+/z4Orvs52kbiMen2V8+Nl47L7lHVx3vSedv9Vby9brI5FGxa2ODuu7yrjFUBAKTfqkmnbTW2xxRZbXCYGg2OePX/Kwf7i/rgsLe//6AtL7//CLzxlb+cxYrsIOcbeRcwuqhlChtJJixXJ2HAKWkvB8X+dPzM/xJ0dFqdd/TJzT1qU03SNV0HUpkXlIdWC3GVPKs6qLnNW9wer3LUJhv4mdsG8bNLMsvtmcdkL79NpuEjj5cm5dt0moO08uk7pNmEfWz6HIIjpYYNBNBoEvCpalDijiHhUS3xpQd8ELEYPcP4YozYZzJSMHWDn0p7npJ1Ai3ZUn3amucRHA4eAM47JaMLDn97k6cNZ0sLsHu3FsZye3oCEfTTsoKaLMQ5jFNSiifBRESwIgDhuv6HcfjNE459mCA5Ri9EJTo7I3BGfvC88+lC47tPYn71XGcT2gD2Ops4qlXTX1//bQ27ddFhTYsRgJMPZHIhGOesdIQhodIsSQon4gA9hfqSgGtX50/vfB08oAqasVBMaIzE0LmeWGaghGogjAdfEYUYyVGvaNh9VGgIhjBFTIqHH0cN3Np6fy7BCy5i6dtE1bbJM2+VSrShTf58n1pwHq/TDZzfqLQlvydhJAJvBm9/IcX2LSFQpKMqASuV4IxKxUXBSOVdLxntVNISGKCeJ9JXIJCiJpJAIEiQiimkRZhJZJtZL2+p7WnVOK6JEE05VsrWyVXU0LSpKOlYRKKrFxnb9r0kXdRCNmVXEULkmk3bdr5RpQkhElqhGUpdVuz0xQ1aT6Wuii6KGRBTVUwTvS7yv3J206FwS1abqTwg1WSaoT3mS2q7qVEWq0qJ1WTUKO1W+xLpSpbFxZ2VMdE8lxqT+xqRjMbyi9MnNjMW6DGsseZ6R53lSfzNoymtr6s4qpleniR5NGTf9W5WjJtXJNmFmmgjU5FXjlk4wxmJNlvrBhsyT5Q6RiowU66xWvl4qkhPR3U0IPpWV4EfK0T86wtBh6NFDMT3lxrcGSLek7E8Y3/2M0dMjwuMd8G1lz4Y6U7WcttLcFCmGabJM7aZvyu0SU9+WH3n5mCYMnNx/rjqfWSWsTeGzT97isyXnbt9/wTtffMzxsGQ8FMS8QafjEfpoqBQRHYKtxbkMVduPhLcgAWNKRFqKWTPxlKXj4/e/PnWs/ezWZty6nyGa6J2i+OKYonyBMVF9yhdHhDBCwwTVMbmb8Nn7v8iLR9OuE08aC87Gu0msV1dXmx+vivWeaf7qxalp19Tmzk2SZvo3DF/5VhdsBx8EQsmzTzyPPzxbeOuW7UlPcdJ8Z9n9L2td6mX2i9dtveA6YBPrbBeJl9FfLorrIrHp+ch1x1na9WWtu1/19rLFaijLEu/Ly07GK4PrvdJ4yQgSHWtsMrx1oKpMJhMmkwnee0QE51wtz7tsd9UWW2yxxRaLYQUyY7ArkFkWoZspN/KCohzjVSmOXlDSIUgXzB67tx7gfQdtuWKKi+jVcmY0EFAt7CJx4RiDpkV6U0mnx+XRelm0WVxtJO9Jx+JCcpNOEUWmFo3T82pcpDHW4vJZokGzcNscUdCAatzZ1o7jZe6euEhyzDrXnmdidNbRRPXspxFn1iPNLL561fxa5bqLnpCtU7bnS8urRZqpcJ3SHYoBOnoCKKOipNvvkmUuGo18iceTWRtVDIoC8Q7hdcBiyhfY8ceIGrQyqJZvcZmEmQqnLaYtKh+ZOjN9Vy4TcgoIBgmKUcf8ntqTYzupv5o9psEzPP4UK3dwvRvYrINqhg8WoQPq0ntKQGyTdk1vSDUgAaHAmCHGvMDYISJ9KneBJ8G6aGCeJc8tSnnwEPzVrPGv3e5xs19wdPyM8aBkPFZu3rmNy3uocYjJyW2OAr70lIXDhoo8AyG9IwIBrwExJbUegUYeldcQlT2KaBCOagpxmaAxJi9Clb9Rd1XFEEcn1ZgiIKJ4H8hyw85uxvHO5e18WsU4MwuZ+p7IMlNumASplWaakdKqcegJv85iNF51wdpm1OQWEZlp4dXNDSFAEGwuBCxlqUBckIuEhDgWrFz5VGPQ0B5fwoyCSQy+LANlEfBeULUIgrNZIs4AJpJMjJFEnoj9hYqt3ReRSAyqPpI0UIxE0kRUptG00NKMkUViH6Utl02Vqsysi55GUUkJNRWhIvVYjETCpSioeoQyqTH4SMrRSnUlkmeMSCKSSJPHi0pSUgkmt0oavbGhGvOsKIu4/mMtxliQqAKRuCq1+g3ach1lUnmHhkYUGRXTLpiqMp91XdRUjUjIiYpt4DJHnuVYaym9x3uPMQ4fAqU22ppeA0YcYh3GudoFU9V6KgWimIRKvaVi5rS+E8+LmMSR0prwVPpYrlGhxsS8az9bnf6YA1mWJ1WZRNSxDmsigdAlIqF1LtaP0Kz+TSvaBISAL8eMJ2OsdRiTMR54xDls3rydJQsohuAnjMcHHB0/4/DoiG74Kobmvdy8b4VKg0TrY+2P1mSZUJFoWm6ZpnPtbHgZxhSZ+XtVwpoNc10EP2YyekJuHVnXEorH7D8ZgewgZpfe7n1cvgcSVfVQRdSntYEyzvOlQIifeb2g5Sluz8WDdvChj2qZyMsjRoNPOTz4OcZ4BE+vK2RWESkJWsK4iAo0LeiS7+fFafn7MureRWLxu3mzsy0RxbikRFUptVlLIE/uV8coB2gYU81zLrptrzJ/WYcUs+k6d1VG/p8Xg/XLtlC147uqeXtZpLBN4qTVhKuW7xexRr2sDK9bWV6lPnGL9bHT79Lp5KdfuMVK2BJmzgFF8bK5Rb/VJz8Rw+GQv/iLv+Av//Iv+dGPfkS32+U73/kOv//7v8+Xv/xler3extK2xRZbbPF5QJ536XZ65NnZBho//fHrfPTB3WZHaL3EKWQd+MqvfUynv0OncwNnu2gAYxWDpMXetK4uBjCIcYix0e1TEEQjuaYiqiDVqvjMEqq2h+nCnNM/jUaexVDe/GqH177gEAIkpQatXJRIwIrHyogw+Yxy9IjJcMJ73/8Fihl/2csNutcPq+4EOetE4ypMKs8W96rmuZPvOnv858f5F+ZOXo65CmX7KuODn77Bpx/dA+JYOhq+4rkpY1s6EFSYpL7qg/ff4NMP76WT8aaiuBx3TCdhFUP/LLlx9lc/H3CzpwQvDIZDRsMnBJ9H8sqpkBX7wOaqcmL55//yADGWt74Ob3+9SMZrwzSxszIMV04l4ntTDfEdhE9mQAv0WdVd1tf/G8ut1x1BM1SyaGTX5NalejsbgIIP3xvy4XujlcJ92fj//pPFWItqJxnh4c2vfkK+d4TNdrh1923yTp+gloAgTnAIRi1lafDJdaTXqLCEeKLiR4heykwGaqMRP6lSFEVRb8aoFBbarlHaH1Wf7O2K4MGUAsX9AAAgAElEQVTEt6AYg6gQfCQyDEcjfPBXwrf26YulNZUAqE35c2SZRm1mGmcl5LR/LX5fnEz/WmXMVV3zpd8oyW4OmYyV3d07lBOB1D4imSUpEKU+1VqLyxw2h5bPn6TqIsR22Ywsa66NNKlQVUof3eIFjaor3vvkHcggGIw4nHGR2FFxy41gnW0FGN3LxfQqKgEQUupjmYjW5PDgScSVipBhEdHkKinMEB8axZH29yozjWlqT6UtZKslNY1upzSAmoBqdPVThkDhQ+0GKOYZNTFnEaprqnRYsbViTnzPCXmW16SYKr9trWATmilBpZBjYh5L0EioCI3JdtbVlLYIKLNkmfoewFpTsVtifdHoFi4o+DISh5Co3BKJOBYxLp73PuZi2iSQ0aj6INJQk9ppa3FnVJVQli0eTTxpbXQXVqkTzfKSooJQQ4hyzk25jsozh2mNI4Iqk/FomjxVlVFKVwgwmYw5OHyBc5Zer08n30H9kN5vRwKOGM+kOOTFwWN+/ulDiuIZwhhnlMx10/yuIcvUZU1dlClDGhWZkMgyjROmmWtb5bXqnGzRdYuNQTHU6zK2PY/h9Dxz18Pn9/in//zvoSYmGtrjoK//mnDr/gSxhm63y8HhUVQokqi2FBMQ1wDOndcCYhQoKMsjnn54g4f/+g2qHDH1C03rNlWMl48RzzunX/ddeVF17SIMqO2wl/1adOQ8z7h7e8QXf/kJ3Z3XsNkNgnYwJsOZHCsDxpPn+OIhoQzAl6bufVmG0lXiWGXOswpWuX/5atjl4FU2WF/2GuB1ydtNEmhexvO+LILbJrGsz99Uei/ynXLRuGp94harwxrBbIUzNobLX7G6xghEzv8mw1sVn332GX/1V3/FH//xH3P//n1+67d+i9FoxN/93d/xR3/0R/zBH/wB3/72t0/ZFbjFFltsscUUjFZr/mfCZOKYTBa/Wicj5ad/u4N1DmMLTItwObM21SyqJWuBEheJv/BLfW7czZq7FBqXS63IpgJcHy4XbMfG3eIaF/WqHeOCYEUw0qEc91CzQydzfOWb+zg3oQzHFJMxvujw0Q+/RFlM58dFkGhU9MwqM2eKL/29iBgvaifMaWFthiwze2y9UK/iLqD1J43Ll2Ou24LCdVlYKiaOYkm/e5H3XgZO73uW0WbgX3+Q8+FPouHQl5ZJkXF80D21H1u1v9OpqxRVYTLMUCAUBmscgiMa5ONufJIiSU2WqQ1/kl5x1d76DNUdfOF58HW4/8Vo2BGi+4vgY1jGOsDig3Lz9S5ZLyeoi2Sb5EJIUlyCIn5Mt2t42r+6iwvDQZu2EfHop3cw2R5iHI87grUFShmNxAhZDl/9VYd1DoLDaCSvoILGfcaNMR4zRbKdNQqHEAk0bZJM5bapVrCoSU/aGo8kwzuCMY6iKNjb3aWrN3n/IjNsRayzmHkiWUbbBm5YFOpZ+v7F9ywj1OjM2cXhvv3VG/zm//CAn/38IybmOYVm9HsZnW4XO2nGmpGrEQhBkqJKVHjJsvnB8TSRop2CkEgKzZskkqpSHcKgJhI5orILQHS1JKapW5LcEJla+THmdNAWeSKp2zTunOrEgUbXSFQiiAqqHh+i8XmZKm+7rjfnNan5JXdFGsu/UUQxQCSgRVJGJJqYEJDSE0LAJ/WV02pg2xUakJ7N1ESaKk0hhLqfFNOQT0Jo3EvNkl2myq+dV+3Sa91rjJnKh1pxxkcXf0YkkfkC1ZxFqdRuJCrISOx/jGlcXDUqOG2SEnP5vpBUpFoneY62UZ1o9UWm5QqrIsnEfDXJHV1DmDGpLwthWl1ntkxapQUI1ubc2LsNxPItyxEuC9hOiTElLgtQTOB4iPnJA7LJW9RqSDiknFdOq0gz1QNVtJiKXlqpylR6o9MumJq0rjP3amr76ZD53D8xzlXiX3bNJsKbvfakMDc1KgjeMh7uLI2vLCa1SuhwXOIyk97TVQribxHLzXfGvJsfMDgc8OwnrxPK1QneTz4YMdgvqGuOKsP9jGK43pOuUz9m7zkvzhL3Sde2e+FNGziXEWVOS8/pVy1H3sm5+/prGLtHkA4iOdaAcEjwh3zwnmH/6V0mwzMFf26s+1Trlskmy+8y58BXcT3kvLgqs6zrsrbRxrJR9jr3XQYuO/7TcNHpu86kmUU4y/t3i5cLay3GbjkAm8L1WSG+glB0oy6Z1tkz8PHHH/Pnf/7nHB0d8d3vfpff+I3fYH9/n52dHb73ve/xm7/5m7zzzjvcv39/Y+nbYosttnjVEdQTtETxmw/bC/uPuumXUsnZr4P77w7YudXB2E7cbYYkmflqMW09rvxJO1vrBdckMx6Xg9MyuAAExHRx+T0k8/T6issDQR2TiWd0DJ/8GCgWRjGXwnOTZmh2Zr4sXPREaFOT+oub2FxcDlz1BY2rnr4tPl+YNdQvapVPH7WnfQ5WUpZZva5PX9f8kio+7aBEo2T0nBJo3BFGssxU2mtjezRCB6IReu+ept3XmoymkTQTFRQsiKX0oHTwmqGJHBINkyVCCZRY8XQ6Y4yOUA+rKtdcBQwPGyn9AUAiNVR51+mB/sqIvNNHApReMGowXiOxqNLikKRwkcgI8c1vp4zLbdTqeW33LZhWoSXCBUKlHiRiERRncybjAYOjI2BvwzlyNix/g823pcbtUqMqY3S25Z0U0vLzZ3mXLGtvJ4UrmcfdGbAzCUyeZTBxGJMTgms27kilXaFgAzW3WypljvTzhB1stVsm5t34VPdW5IPqWAhJBcUK1rXcIVGRGExUiUncLNESgyFoVKCKajJR4cYYW4fpQ1QxifFodTMQy08TsaRK16y6TK3Okp7XSqzvRVEkMomA+JReUlwGSW1IFEQVY0NNQok+5v0UmWVWuWSWnLEsv6dUVzS6P5sleTTkmqVFVqMsy+n23cqT2bSKMXUZK9OurKKqTCIkGUE1EWSo+ps2uSfmi7WVaybm6k2brNM8O/X1C/NHTHJ9NT0/mnW31SbLxIzyU3kI1HVhMSJBFAydbgcjnqI45vDwiNFoSFkUoIEsD4gZU47G5PtfhHGe7m5/GkWZFk0ruVqqXC+1iDISNdiU9cgyq+CkvklXOH8aNjmDOGs4y57hZc8mo/uxkmIyodPtURQFQQVjHcY6ghoQx87tnHwn5/jFmP2fC2HpUsL8u2mwXzLYL6euOc9zrjM23DRWiXuabHYaKiLkZtJ7PrLM2WFMRp73UGMQnaCM8H5MUbwABrx4fJenD3c3ENP6OOvzrVoml1XPtjgdV400cJ3L9bqQMK5r/m6xxXVGWZYEv3k71ucVW8LMORDYrEumsOJrpSxLPv74Y/76r/+a3/3d3+W3f/u3+cY3vsFwOOTGjRt873vf4wc/+AHf/va3t4SZLbbYYot1IIFASdCrOdDYf3KImiHW7RDdjlh2bliyTrVz3xIVYeA8PPC4KTeAUSQRZsaHgfFRANG4SB2UuJt9B2uE3duA3UGkxJkSWwSiP/YV4zzl/FWdHM7u+riMCaLK8lhXXbRe/67Zazf/9Fd9QeMsLcxkx5j8CFCMsRTDm4Ry62t2i9Ux2xeuQpaZP7ZqjzpDYllyhTFK/9YAYw1ickQyGuOD0NvN0eAAgzGWIHGHc7R+VyTMpiUZrYwdUFEUKpUzBXxgmtZqNJE7iW5QRJL7JRCNczWDxzLByoRiXLL/vGSn5xkNDjh6kQGXY0Q4CxaVZ/tYCMqLxxO6/RzXE2xXEBzWAGJq5Q+VSKCJRuyKicCUkR2miTLQnDcmqtNMGbeJhvFKUSJ5P6Hf2+HFi+c8enTIVSHMwPLFZ6k/066Zqm/zx86O09rXavfJ1PU7e5bX38n57LMnuCwSxwpzwD/90xGQoSFDTHS5Wfq4DiGVud34uC1Ii0RuqAgoqxFm2tdMk2LCFFmmQlQwiVFZFz9GqvuBUBmUfWzjExg8nWCNSYQYJeta+ncMwUfFE8VACKiPadbKRVNVxxEIUhM9VLV2PdZWV4kkjlj3DQZRw+GzkuEwKjXEPk+5+boDm+JNJLSqHQjgTKjzz1pbk2bKspzLz2UkmjnCyqziiwb8TBmJNDsNdSac+hrSeKvlgqlq39WnUcahVpcy1kaFr0RkinkVSSqRTJP6EaEmzIBgxNXprlR3qnDbJKXZujSbJ4uIMFPXSEXcMVOqy22yzKJwZvu5NhaRZmpuJ+BDgcqE4f6Ig4cDDg8OGI+GaChxVul0oGt7GB/JYI1ijNZrgQ1HrXGyVJ1PLbN2xVQpyzBFlmmla2W0n1Pnji4Kq03umcuPFTFH6lsjrBV6oBViXBebD9OYHMgIPr4vi2LC/pMxxRi6/Q437iUXzsZibZesK5jdfKptn57GxTiv8fUy5+bL4p6elzc19HRiVEOaOS2O0+JtHzkPqWxdTEbw5CEYV6AUlH6MnxxTjo8QKZmMTrZdXMS8exPhnVZPl587aw09iY68xaq4qmt31x2r9lEvq+5u28fVx/nGUquFs8Xlo9qMscVmsCXMnAMB3bBLptXCOj4+5tGjR+zv7/Otb32L27dvA9Dr9Xj33Xd54403+OSTT3j06NHG0rbFFlts8XlAlmVYa9fYkfRy8dF7N+A9SCZDwPPLv+W493YrvQKROLN48XMe8zuAowHC4yQgGlAtePS+54N/XDxFy7vwzd+GvTu7BBWClthMUIZ1Xp530nzqot4VWNFYZx/bImx6YeG09CzbAXcxsb26mK96yytj5+bP6d79ZwKBfrfLs5/+OqODq0Nu/vyW4vXAJskyq/U300b4aTR9u8s9X/7OJ+T9nKzzGlm2g+LQIBibA1K7t6iJBrVRExr3LYmkoFKrd9SxSeUOJRkhapJNQ7ipTIZR9cQjBETApjgsY5wp2H8e+Jv/s6Lc3F4pJy4TJ5frNFlGgHIs/Ne/3gGUB7/keeeXHCLQyTqUviT4MuZVbVCP7lwq0sysmsMi43VDfEgmKU3G+GS4NRIJEoPBgH4vo9/rE8ItDnYGG8yZzaA9vpgeazRtpSHPLN6Vf1GGgXXJNNX1b3+5y3//P97lf/8//pH+3h2C6TKcCMguQaMSk0lPFTQSzmpnLxI1LMDHNhcEIco8L1MvmUvbjEIHNASa9nkA5xzGGoxVxAREkkoKARIBRQigJQIMnig/+7/HdYsHuPm25av/3kTFqUJRsQQ1qQ8SsswhJhDUU4YS78EZh3UWE6JSSqOkEt2QlUXJnbt3Elkk3jsZlPzgP+1TDJMqDULeE771H3q4LoAF48AYVCNBkEQqCSEgRAJHnueUPmqDaJinDaievuA5rR4TmWnW2TpvvS/xvpwqi0WqNUYESeSVLMumyqpNomnfZyqXWRhMUmkRE/v5oE16JPmrEhNVgiqXXErs55s5R1zobZNe4nVau+M6iaTV7pPq64xBZFphpv23eiY/sxvToHPXxuAWExQ0dXjGwmQy5LOnDxm810d/9gW6CD0Ei2Bm+o82zbAaN1ZKMtPEl0ZZJhJmAl4a4kxFmm/oNbPhpzxa8n366po+NXfvYtLMyb/XxfkIHIsohE246929zhWrUDemr2yfsZIjatEQx0dHBy/48AeOg8eGm2+M+IV/N8LaHsEYJCR6VZH6xlfMJL3MvfJJG0PmwmjfR+yj56kwyzBdA9cndOnCc6ul/vwzsP2ngb/9j5P0ywC99Ll37rDPgk3NKder5ZtoE9O16AosMV07XPWe6SQy6HXC6UTALbY4GauOu657W/k8oNfrkefbjZibwpYwcw4E2DBhZjUMBgMODg4wxnD79u2pBmGM4c6dO4xGIwaDq7cgucUWW2xxlZGbHv38Ft28f9lJWRnj48eMjoSss4vNdhCTY22OYglpsdvE1VxQm/4aRErKcoR1AZtDCJO0sxaYjPHFIaY4wBDQUEBxC7izOBEimE6HUnoYl2HzQFEOgRFnGV7PGYVbC2gnqqlULj2WLLhdBZxMXVozrCV5sfputqs79bm6KTsnggPfw1khlJJk/F8+Xtn8fQVxsonm5dSfk/eeg4hjZ+9rdPsdQnCot1gbFRdCIlLUhtLZHfoqtN0hReMgBOMrHgw1XUElGfmpuTLVz1ATaipqQzT6WxNwNiA6wskBxfgpw2MF3tlE1lwoTjfPLTZ7ytQ3wUhUEgmTEsFgNacyt4pNRInaLdOMYozqnLJIpRQSXdIkwk1SAJJ0jxXIOgZrewiewShwPHIUvstVRJNbEdL+rSe7rjjZEL3auUXpOQ0nGe8++vQp//P/9hNee+0XOBxMUBxZ1sP7NsUqkq+bdplC0KjQJPTq9idi0vtKaPMWppuz1r+nwmuhTTpoKxWJia6ONIQ0do1uoYwEjAid3DDWcZ3eaMBqzFjj8QFPH/+IW3fukeU9vPYIvoO1GWAw4jCiCBNUi6ie4wSMoEVJWZT0sk4kS4QCXEkng/H4OcYZMGC0oJsXdV1vysGT8RCr8OJgzMGRJ+/usXfjDs52ov6jKpbkXkUMZQiIhaybo+pBAxo7PjSYSHTB18SZtmukKh9n1VUqktEsKakivAQf4qelohlSfhsicQmo1WS894tVpeKBWE6RYUdQwDckSomXgFRqQUQ3eiJJW6xy51Q9gFKUE3wo63iqTQzt1rfIPVOb2GKMaVSBEiFwkWLWcvdK1CTC6bCVoKFVr1v3J3Jg8BPUD8kcOCuMUw01UDk5mzLax1Aa9ZjGGVokyDQU0IYOGuprlqNqFevSOxaHMn/faXEvwrJ7zjKCWX6PTl2xKj1idaxL51lO2WmfGRfPOT4eMB4N8OUYwwgND4A91L9gcvwTTLZDCIIvFTyESYaGL7B4OX96FDAb3ypPtco8eh0Sy6pQ0YVxLzq2SvzTbWG29S1NxdpnXoV596awySdctbXN05w2OTeaHW28HFzXmnJ1V+AW41UkQ71qz3MerDsmeVVx0vjttPHBFtcH1dx5i81gS5g5By5LYabaoQTU0sEVKj/Mlf/pLbbYYostVse4cIzKHqX2LjspK+PhT3Z49gkYaxEpEPG8+yvC3r1qwSDgTYmoRVQRtYBitKSfC0hBOTlgdHjAB+/do5xYQlAIHYRbcXlJlcFhRc6cH1aXE+XHf1Ng3EFcaBYIRYmf6NoT59pY1VocmwpD5dRFsoskzlzmTo5Tn/vU4xc/Lvi8jTzWfd6gjqAdvI+uE162aubnrXyuO5Yb4hcYFJaEsWzp+KxLyu3FxXvvKncfEF1wuJzC22iYtg7B4H04g1Elqgo08VR78meoDCpI7YJQMSih3n6gCB6Rgo6Dvb2M/ecH/OifhRef3WJ4fIYH3zAe/KKnuzsmhALnFGfGfPCvtzh80VmbdDFbljaHL3xTsJlh56ZDRQg+kVtCZYCNVuz4twnnJLTnnBVpBqIRXFrqESKGEDwKGCN4r4jJ6PVu8Ma7Ba/dc9x/bYe/+3+OefxxsUJuvVy0yWi1x7DWv8L644vFVy9vtesYitqh3framO5tg+vlZN3XOBoaVHYxxqFqYIlyiYiZZr9E5tNMMheY/7Q5F783ZI14rEWxq8gxLQLDNJGhcqUWEsEiYMRjKBkdH/D0XzqMXjjKUdUraJ2qyUHOo3+4x/NOBzGGQInXQGBEQKg4EEpAgycQMMbHNhACGhRrI5EkEkwaUpiYqi4EJEAxqbIl9kx+bPjR/9vDGJgUHUxvxGu/cIiVDrkFSwYhAzJULSFURDao3DcJIbZNL3gfvZ7GpiVNMbSUTtqEmRBCdJsUPMGHhSQ3AGuje62qS9YoC4URwVmLtZbxeFy7orLW1m6jahdNaYxPSpdKzIeqOUxRBGqVGAGtNodFWojILHGlvZ5lsVYwplKxqc7P15k5VRkaUo1qyt7W+VXWx9r1uHUU0CmyWJMIKCcjnj77lMHxc0I5QIZvY7gDieASL2tTZqbVZII0hJjqP1/H2ih31YSa1vF1sIn5yrJ30HnjnTXonD2tq+VJdZXLlS99c0jW3UHopD5IQEpU40c0KddRMJkMGI2PGU+OKP2QEHwiZsX2ZchxroNzOS7rMj7q8fjHnaVzsY9/6HB5H+/z5HYuMDyIxNLBQZ+f//0XEONQJc4ZFAiWsljmkqmKY5pCACvm6YpVavYduCkCzTLSzGnxLwoHputVe2WheXusmK4zXXf2Gfh1Ix7A5ZBl2nG/KqSZ6zhXv471dYtXG6fNpa9jOzsv1mmnn8f8ue6I879tyW0KW8LMORAEypV1YVYLbxXkeU6320VVGQwGte9roD62s7OzlWLaYosttlgTw8IznChFeX2mfUcvOvAifo/LP543vhrl5IuyxBjBdeK5EDxagvqAyARjPCEcoeNnmPERTz+8xWRUmQDy9Gljcb4ED88+jm6cll+1GHO72gCWkWVa51dZmFt10W1VnERIWSWW8wxft2SZq4d1n1cBMYIYS1DwuipVejP4vJXPdcc6ZJnTsGwh+SxLyu161Lsh3H1ggAzUompQooFUVaOrl4r2coI7jcWYXc7SZNRPhtaQFAuSUTmSQqsURh1QRFEf8AU4Y3j+2PLoo86a6bgY7NwW9l5zhKAYmaDlYVSJ4+T0rUKAMla481ZG1o2udxSTDK6S/rYM1VIphlREpPmwF5VdVLOI7mSi25NUPpikQhMVLYwRosIHOJdjdwV3q2DnxgE2v4q90uz4Y9Zcz4Y6080s5c5e2X/NsfeWw9ou1maMxxOsy5JCTEudY0EqpmlqRLZBy4A/nTeR2BY0kk2ChqlA26ogs+5yZkkOkThRJyKRM0AIiBaU5TEHzz/m4JO3GX2WUXG82iasMMkYPM4Y0CIdSFkrclSua6ZztVnH0fR71hnO9F+gVlKqSDSCenj+cV4TaDq3C8bHT+lllqzvMWY3kUoMPihIhjEWFRolHdMQjUKo+rAUU8rKNtloVqmnnc/V93iNbanMWIJ6JEhNqDHWYkWwKezKPVFFFirLco6g0+47qvyg7kNqylSL0iTpV3Wy2QEprUaV+DvxehVUffzdIuO1sZgko1O/JfVvp6nKtKFNalvhBWiNw2uyINX8asJo9IKD/c+wpiT393ApHJmpU221GCWO7xvlmEpVRlvnmbqnysb5+nwyVqAgrBHa5rBwnnfBaOebmEB+4wk37+S4bBfVDnGZvExqVCWgWDHAhKKE8SRQlAEfIARftwUhw9Alc12syzEmY/+R5fGP2331dK99+NQSVfZm3/1COe6w/+is7nTmRwubphG0ISvOzVfBJubvs+mZfVeuQ4F42WSZzzvOWvKvAmnmOtaV67NqusXnBds6eT5cx35oCwjeoy97N+YrjC1h5hwIKF42SJhZsVvq9/vcvn0b5xwfffQRw+EQiPK5R0dHPHnyhDfffJMbN25sLG1bbLHFFp8H+DCgDEd4bYgiu7cdNpsQyhGqgeP9nSibviIumkixe9uQdZJLhLRgneUWLT2+8KgROlmOAXwoGR5POHhS0DUFmSsJfoD6EvEZhGVuB85nrj3t+mpRbC2iTbpnFbWZ8y66rVI+m55YnJUgM31u/qrtBOj8OEseVveEso8f3cWHAFKg/mLJzdvyftWwvC9bb2m4sWzPGhAWXbUsjIAlkCOSJTKLQdXgVesEze7WX4k4o8nISbRDaQjRcNsyHpMMq1FBwBGntVGdAjwq0UxehpLBcEyW5ZXXoUuHAF5ygukRCBRhxHh8jOl58r0j/ETw450VQmrKsbtb0OlajMlwHYOxHSpZjWhz1obkkmRTNJETqkyVKBcxZXSGk8pM0+76ABhUbHK/onXyNFCTNar6UUwCnz58xmi0yzwx93IgrU/1u3LFtJzCe57YTka2E3D9Eu8D1hgUKAeWcuAQA927PhIwJbrcMsYyHhfk3T7OZggW9ZC7HCS6/BG04URV7nqIbdUHn8gqMX3R7ZFE0lkqzhCqOtEmd4SW+m1SITFCdP0ptVLJIlLHlPpM9Vujisf4ecCPAhpKiknJwXOlHC3Pydl+LIYnVUESSRjN2GoRFWbWGNaU/eLyMq36EZ2Sxd9hJBx8BHJYMukXODfBdZXs5jFiuojdQYwDNLnr0RS3Jr5444ZpngDDXN7V6RFBjWm13/hMlQJNCPP575zDRkYJ3vuaSFOVrfeeTqfTqNnEBp2yNCnOVHlUE6V0KhPrlFZjfQlNnkrLQZiGmiwU1KPqsdZhTIYxpP5/njQzqzgz+121eZ7Z6xdCYZ6KMl9jKiJOCAVlOcQXA8xgF2sEyi5BtFaoqsKryDAqDWGmccnUJsw0hJjqzjaNqj1HmK7Rq+KkPGjCsvmYrFeSZTnWZQB4X7lLsxw8jZsm1gl99sr1xh3rXbXKnRoCx8f79G/cwzpBsajG8YTiQHxqmwYxHZzdwXXugniUsu67FE39nsOY6EpsXAwIOmw97fy38z/ROk9b9XLLy+hkB4QrRCesNO++CJdOs5hdK1j0vpg9uixVZ6HVbOdg62ETI6yLJIVVWFyPPn9Y3oecjquUdxdNgtri5WJLljkftm3h+iKUJeq3hJlNYUuYOQcCYbMKMyuGtbOzwxtvvMHrr7/O97//fX7nd36Ht956i6OjI374wx/y+PFjHjx4wJtvvrmxtG2xxRZbfB5gzSHGPEekMeB8+Vt9dm6PGB0/opxMeO8/f4VifPrrU2b+Lh6+Lx+SrjpY/dI3O9x9OwNsNI5JlNy3Jqff7RO8JwsOEU+J5/lz5Uf/xSH1EGDvhBSuTmQ5C9ll0f3zMZ5tKbiNZaSZkxZVLmOycH6SzLK9bVtsApvIz/H+fcb79zcQ0nJsy/3VQNto2/RV7aMn37PsXBtyzj5D1VCqrU3FUhmQlZbaS22FXwMxZRoUMRBCwfHxc7wv6OaOPM+wFrz65CLEgDGoMYgoYhQoEUqMUVxu8eUYJSeSai4PVU7knQ42s5SFYmyPfMfw2lee0T/4hIPHwuGHX18axmw5CcobXz7i/oMend4uXh3ichotg2SuTdbb2kpqaIQAACAASURBVCCmJFUYEntmQeCnIpJmvAdJxA0RgzUOa20KOsR4RHDJzYqzN5P6zOVjNhXz5BmZO7boPljfWLPs2r13x9z46iGj4Yhur0fwnhf/usvBj/ewHeXNXy/IehZrM/KsS57t8OTxMzq5w1ZujQgIHqVAJRC0ccFVeo9vfYqiSOSzSHixtirLSAVRBA1au+ipjOZV/THG4JxLSiTp2aQhNCxynTOfc4qGgBF49HcTDj72CBbhRvyowMJxUqy4TV/ZmLOMVkQOJVSkmdk7pek5K3dw0JT7XGwtknelN2OQhkAzuMn4Z7/Kk1YY3dcH3Pu3j9ndew0fPKIdjLEYm8IKMcOiEpOJ5JI6v2Kb8d4vUUlJeZdIUNHFVIjtMvia0NS4WjJYYyJxl0T68J7JZFIrF1sbyzPPs6gWFSoST5O/xlTzjjaxhym+TDu9qilvmxcE7fdDvFfxQdFSKY1grcM5j7MdnCORwaS+r65vieBlTOP2KygsUpw5DYuvqchX1M8QQmw3IYwYHL/g+ZNn9D/+LUzZQwGPYiTWEW19ZgkygcolU6MyM1u6dSlPEb5mSTNTqV32dKf2T23aWP/uC+5+6YDbt++xc+MOQYXhaIKqp+v6fP9/VSbDk0JbHNuiPhdW6z8b6sPqL6sTrxRwzpI5i7VRMSakEhI8YjwVrS1gETKEDhosGkxTfwkgJciEoB6YMBo+5vj4COHBqWmZn/leFJbn8rL5+crpWePld9LGl027VF6mNjP7bMtocrO/XsY862UQPxbFeR6sS367qOebnzNtAtUIcLoezcb7qmM1ksxqb5npI1tscX6sO/+66Hp3Gf34ebBth9ccniXzxC3Ogi1h5hyIYt+bJMysjgcPHvB7v/d7/Mmf/Al/9md/xsOHD3n+/Dl/+qd/ys7ODr/2a7/Gl7/85Y2lbYstttji84CBf5vDyTOGRb8+ZrVkJ79NP7vFeBQwZshpw8nGqDJN/5jfkbKYkNKe6J825FHJUMnj2jqCUUAN+OjqT1QoZAKqBONQ1wHGC9O86Mhpg/yTjAmr4jwTiVUloE8izZx237J4N4lF8ZyatiVXnn13XIOLnNytthh++djU/tWXtbC6xauJRYv6yxdsly8Rr0qiWQ8ewwjUgUbjvailUuaYFB6x0YgZjZXRvKxJRWJhqsQADu8LhALRAuOfIeP36XcCPWcxBHwxofAl1mbYTgcpo8G028vpdTq8OHjOeHRMKYFCYDIeUIy/AZzVvcFmUBs/h8/phS79bIeiUMhuEva63N69wwtT8sMP1wtzZ/c+nb5FjSIazbVoK4cjY6YmzFRuR7TydV0ZwoXaOA7NwsusckPlFguxRDdMsabG6wOKb+qXNEZOVQv0cLaLkSOgWP1BN4zl5Bc58dtFxD9/sofrdNntRPICAoNuNb40GHMDYyORZVJCUQ7I+xmI4qVIhARNbnYMvvSUZUFZFjXppU0iaMpZ8R6KokxtVEECqj6RLiKBpqKLGFxLRcbWx6dIKTPqKMtgjCGzWdodVxApB60RcWuc1BAOqrysxqzN8YpYYRJRSEQbhY7604wN6zraNqzOKCC2STSJyhJJOUQFFFMdS78jR00QXzIYPcVlGXm3izFdkMr1kCAkFR4jUcqHAGoRYzAmtsPo9gyi6o9PrmAU70u8j0SXjs1QEYLE3Cs14Cmj6yySi7pQot5jgUlRMCoKSu8RgW63g0kqNSGRbqqyCyHmrTGx2UelmFQ+Fe8lmDqXGvWq9Km8N0kg+DKpycTniWQXImFLBHHxu7XxY6yCCagUSE3k0nrDmTSljeLbJYCqqclbMf7F9S8SUpJzWa07rRh2SGUrHpESQ0ERxhw8f4hxAcwQNQWVK6UqCp+IWu13eEWYCUJ9fVUX2+SYmIz5kf4sWaaqi9r6vvzb6WiHtXf7PvcfvEWW9VCfI1h2eoKRgB+PEY7m0jKNpv2ukob5efJJ4a6GU69UKCc+1VkoyjGDwQixHuuUTtfS7VjQkk8/eYyzHfr9G3Q7u2ByIsesRQrEIsZipUPX3KVrs7VSfNZx2ar3NesLp5On1qk3U3V1DXXXTc+nz4aT5uAvlyizOA3XE5dZsqvOg84W4mLK1brhX7fyPZ0ss2oOLFsRvZw8uW7lsMX1wmURB9fFth1cf6jpgVwN1+OvAraEmXPgshRmAN566y2++93v8uLFC9577z3+4R/+AYBOp8Mf/uEf8p3vfIdut7uxtG2xxRZbfB5g7G1c5y3uvJnxjf+uj2DYu/v/s/duwZIk533f78usqu4+t7nvdXYXiwWB3cWFWIIAcSEgEhRDpiiRhCiHwiFTCoff/OQXP/iNEbYf/GA5whEO0w+2JYUlhSMki7Jkk1KIAIQgCZAgIEC472IB7O7s7twvZ86lu6oyPz9kZnV1d/U5fS4zc3bQ/43Z011dlZmVmZWV+X3//H852OAEyAbwvl/I4q7MaN6MccvxwUBqJJhrtS5Rt821S4brb06GHFh8YiysnzU89f4c54P0edjHSuOAWj+bN6bZtrFUSf6SYDT28b/Vs4bnP50H2XyC4Rs/ZGfzBq9/Z426NE0a80vVceyeGbzC3czbBXAQSefjlH++l1LS+5mep78tfv5eR+/9cu2gZhR4JxpO7n+Jlwvchx+zjrDZ39rfugiQ94IwZ3VI5iugQKTASh80x5MFZQBscAKq4pw2oXqkcaJ2lcojpkJkyNbmVTKGlFvwk+89jjHhdSwoXj0+OvyNtY1ggbUWm1mqst84kRHwrmbr9npHfg8G5e41ym2w+RrOZZhiFWssiGX9nPCenw972X1dYgV2tiyvvTK5dF8/a3n6+T6qsHouQy3hxa9m7sAwJhYkakGETlJ0k1pFF9qqDarj8DHhL/soOQSVD+eUJ98rPPYug3cjdrZv8eSTZ/je1zNuXLl/5JRpV27qmYn01T7WJk0cFGO3cYAtlPMfKslXghNafVDWqGuPYOifDmE9bBZC96DKxtOe3ikPopgMUnScUNxEQvNUVSDGePWgIYyO94FgoerHSiSqEyF4usutEK8JN5HCQBmszbCmiGFzgtKUemm4WTTPqUO9YvZV95BgDRHl/Pstp58Tdm96rn+7nnDutt1UXWNd+q1NthGIIkrS/BI4EVPPQajM5pi0rpdEDGl/Z0yQaQg08RejjfYWBoORAiTDiI1hyqTJJYW60ri8sDY86014MzSqxTiMCVSR7e27OFdFlZNYxz4QTpBQ38ZaMmvIi5zRaMSoHFFVZROCCxRjDf085KeqjcpMCqmVnmWb1HBMVPUiEmJiI4yf+VgTzXczNR74qGQ0HkfG74Q0rkCWSVDhMTaQaEJnBnwaaOJY08o1KuwAGGsQMa2xae/+F7ssmBaJUIUQJkxxvsJaxdW7bN65Ql0P2bxzHUyNlKsUl1+CGGaz3aMmxlXGxBhFIyUs9cf5c/pxLzjIm7z7CWHuUVg9CxdfAGNWUAz9DUNuLUKGmCyEOVMPWoMuTnZcZE3Z3gAxb3YwD0eZByuK1y3ubl1moIJzGVt3trn52grqDdY6rAkP5u7OKiKGLPNYu0OW7/Dk8zfJeoKYHtaukBFCNzsvDPp9Tm0IkYZ1wPtYfAV3sPuddE7PH0sPQPLp2vRxDCGR4fCr04lnUPaq2ZNJllni+DGvDQ/Xx2Tq78FzP+g4dxJxOFpm1zWz69f7VTcPQzss8c7FdN+7nwSaZb9/uDByOZV/sErKDxOWhJkjIOx9ejAKMysrK7z44ov8zu/8Dt/85je5cuUKeZ7zzDPP8Eu/9EtcuHBhIcnZJZZYYoklxjDZOll+hqyw9NeyuBve4ACvCply5skiGl48QUMdgjcu7DI1ElRe1GWIU3bvOq6/2ZXb/OVZ+5es51l7rKLX38CoDcb6RsY4nLf3+0NiLPYgLd0bKBeeDjL6gpIZQGvu3oJL3x/nPz+148d8k247V50w6j2sE/wHQ5ZJx+/dvOGwKd/vtl6SZZY4yVj0KZ0972DP96JnW4b0uQsUVHWG0Mf5PkoPkw0wXlHJ8Ko471GvZJGAqp2OlOQ49YyGN9nduU4uI8rtNW5dvbBw+QMGBzz//sLqXbTaoqp7OHLWVy+yO/KUtYLknH1iQC/rgc8wAreuwmuvTDrdir7h3FNFCDMjY5fcIk6qaeWYNomiTZaZt55MvyfCRQqDkhzU865Lx51T1s6CEY+op6oMa2t3sPkGUHRee1gchCwz/VmmzjqoA7DLOQkgVlh9PKO3ERSZnPM4p6jmDaECDOpMfBF68nXI1lKdK+pdIIHEMDSox7mauiqp6ir8Tpv81NawoCHMTIfNmayFqNABCJaGEiIWkSyoSslYWyU814HggwnEB+9BxKP7hGVSHxRgRDyDCxLUVTK4PtWC89xUXa6XMTkhfW+RD+JzA13v0imiDIzVYmbymyTMJLXHNnkmz3qsr52n11tHJA+cgyYBjUQmwLfqsMXUSiUP7UUgISmoF8BAJK9Vro6EGbDGkBnBxZnUqCoZlqOoTEMg3qhgTSA/BWLjbNin8bPdMGPCjHxKdSr9Ng5g1hyaPAdpVGzGZJmAcegnafqnOJc6USD7p35kQmgpzHgjQbpWpsk0C9rFBLDGxpBW4dkI2wtqRCrQmqq6y/bOdba3b7O7cxdrauzQYrceb/WO1LLTf8f90bfJMnT1we40DobZt/leNVH04OwTBmN6KEE1SjCICt57jAkhirzfYWd4A9WVfVLcm16432/T99y18jnqPFhQbOYxpsJQhoy95+5VqEcph5RLv3VdTd4rOffMq2TqgR7oCvgNrOljTE6/H8KW6QKhIO8HWWbf/A9BcrmXG0julc1hr897EdaWeDhxsBXS8Vo0po+eVBtX110fjSzTlZruc2SJJR5+3FuL7GQ+SzxkyE+BXX3QpXhosCTMHAFOlEqOjzDjDrjYKIqCT3ziE3ziE584tjIsscQSS/w0Q0wPzIAwTTVhIyNt0e8IJSjLqAE8wRxtUQxew65RMRkiOYONEacfK5FkFI4y+ao1rnJs3crwfv5+Cq+eyjkGmSCORTeptVKTaKjTuBE0iIFLNIg7B0JG0TvF6QswGiYBcUUIO/hRpdzJKXcyjIX1cy5KsRON48Td0Y5yO6PcyREDa+c8NgsOlmqkbN+c/56b3uXWvWwe18/074u8QY+ya+VeL1z2M5TvfdZi1+x3tdwnk9FBMdny9w6Hd0bcfywXuT+9SG2/3/M33UdWT9X0+hZjshiiwnP3lmM0HJ85f4zszm20DXevgqpnWI3AKF4diKPXV3rrFdlgA1GLuqBuIcYCwek768SM7jB1lNUuqhWjobB9Z/9wLu80lLt9tm6NqJzHi8OIcntzxO6uozfwXHi8wBhDVvQQYylWPacfGQLJCaysnjHBWZXCISExJIoyvaycruvp712KI/OuaSvMtK9v/w3O1bGjfYagg+AUnPNk1tLvb3Dl2usMh30OSphZ9F00TZCZ/nY877S96Wr5GhRriiksNu+BEkPqKN4LeZYjYlEP3nmcuhjSTEkhfCCQZERjQBev4RpVvKtwdYV31fieGrJMqH8fyQDOuQmCQji1NR6k/FRAgtJHOp5IMqHPKV58JEuli5MSI7HM7X9tTI46GiVWrAmkoaxvWHvMkpzWiRgRaHXK8KbgRrMp0VzR/bk5puMrJwhN8f/t72NCzDTGFBFRyHqO4tQw9u0ca3IGF3LWVy6A7VO7DN+EgYqUCfVBMUiTckub5hOUN4wJii/eh/Ax/d4KWijeu0CUqmtcHVU/JNSViOBV8XVN5Wqc+kCmsRZjbQh/JYG0FfqCYMTGMqU6SSot7cBXjEkqEwouMvHyaK6bINeEtVP6vT12TKvBqCqurvHxe3tMMcag1kYSTTxuBCsxvFO7L0yRgPYi0CSVGnUuEJGMw1BhjaN2u4x2dhneytm6Y3H1gDwDKVcm06Ddz9qkGG02Oyw2759/bB5m5wiLhd8JFxmEAu8MEPqIFQvi8YxAK8pdZevOiFvXd/BusEfKe+d40PH2uIgM0yO0qqHaOkuZbaC7BXVtqbb6kYzWjfSL93D7qsNkIcSYqxx1VZLnKxT5gF4vY7hVAGudZJ/J1OaX9yiYdsbve35S+dmDOHPcJJmjvnu7xv75hKv25+Vq6kGhq81PfmscV0/dmxjyziKKHKc1aLZ+FhqzjrEES7yzMd0X7pet8rixqK1niZ9ebJyBvB/WWKoCYihOnUOKk6Om/E7HkjBzBDg85XESZo5RrWaJJZZYYomDQ1RaBqJECAmEEUMyrAMIoibuDk0m0PEiLxiSDCqW88/2Of9MASiZNVFevcTXd9m6s8W3vniKcjjpsmnvAM6zgvWVAW6kiGrYrXqQ2bNEN4n4eE8OwSMI1ha42uN8Tm/1DO/71DbD0RZeS6zUGMpggHeOyy+vc+WVU2SF8uIvDrF5hUI0UkNZlgzLbd7+/gZXXz5L1lOe+1TFynofJOPGGxU/+MJYvnva2CaNNH2q01j4CRxtSXyUq+/XYnxRgsxeRsD2kYOXez5p5v4u2u7fTqPF0zwZJpmTUYolHjQOakx56oWSx54ZkBdreFdQ2BFf+8I2Vy/VM2nOz62dn/Dmaxu8+dpG5xV5f8T7f/E2q3mOSh/QQADJTBPyowteg1u8NziFqPLmJcvlH55stZjD4MevvqvjaDBynHmk5JELtxj6XfL+Cnmxwvr5AR/49GkEG6OhOJAq/EvuUM2BpNwwJixMo60WkcgTSU2hrS6THNiTzu7J7yYEoWzINs4FVm9o6wxrLVmWzRIyJFwtJkdxDMtdhiMfhCQOV6Wz99nxafZb968qyjg0TzeddNop15oFNt9k6tzT71IufAAchizLcb5CIoHB2qQSE9vEhZRyk8UQNgJRs8QKGAnOXlWHqiPIlnhcXVFVo4m2anqCMRPtDeN2ng7DJWic+LbuvMUMURx1HcnYYrDWNHPCUNb2fDqRLrSZS3eqfxgzVtdRoXdWeOpXLOodIZSPhtCnRvG+5o0vwtabsa51ts4TOWHiGHS2Z/v2wudxeqJJO2ayZXVqbBSE/tkdzn3yEltbu6ysrDPon8XKOt4XeGdRkyHGoni8r9GoAWOMgIb1hTGCio/PsQ/rEGOw1qKaxectPOd17RBJyl0+EqxC6dI53juyPEPx1HUg14hzZFlGlmdkkqFlRRn7jTEmhjRK5KjJWkmh1xI/pulrmhp2kvgiDbuGpr8AE30ukWESmnBQSYlGNar8xBWX9yiBEISJ4fm0oftjw8mdmBeCDDyj0Qj1fkwIqmts7lBq6mqLrRtw/bvPYfRnEMK2iUrHocCY+BtUk1S0+Zx+7wqvNOnQn+6587EfmURapJm95g7GCEUvD/3UK2JdVJXxeHYYlZu88X3hze8WQFv1bbqcxzOKT5dXZ44eDNPtI4Crci59+4WpMxcLpeyqHm9++6OHvNvJ8WqynDLx6bDz/q61ojR/2+tEmc3nGEgxi5BvjoJ5NdhlUZgo18z/98pBF3wKl1gU83rDvSBHHF/Pu/fEkJNKmpk3V7q/ObYxax/q/uVoOc7O7Zd4p2HZZks8rPiZn4ULT1mcFjgvqO2hCDW9B120hwZLwswR4FBKOeBW/33SW2KJJZZY4sEhmVnb9Jf20BwcUhKJMmNyTWD1+mig8dHI5PEaDcKEnbi1FoganKuo65yaVZQRs9N5aWgzhpyBOUst4L0LTgN10ZlDY9CK/ouQkuj4cypT+hcJQKhBnQbpf2PxtaK6is0LLGHHd68Iu5/ruuZmbxcYAoZR+Qj9POz4rdUHw3ImrPVr+oPk1LDk+WPUPkdV8H6Iyu2ZOh9zkFp1oMk5tThh5CDY24zWFGiBI0cvy0FTWOzMLjP8wbCXc/D+YDq3cT8ffzt6Dsd95vFdeXw4XtrZEicN0wbWecj6pyDvUTqBqqRv6j3H2P3z6ybRjH/2uNEN6lGOLU6TWRverGKwNqiLzDotQxATY3JsZuid6tMfjICKnyaoLymHN7hxdwfbX2N1/RyrKxco8nOgGtXvwjvdiAMUNKh/aHJk063KkxRF5hFk2kSKvVRpkoPcK5GoEcsePzjnqOs6ON5b/6y1iA1hVGyRk5kcK47R0GFM70ghhfd7ax/E6J/mUl6DjoqP50aOQLhWJ4k0k8b1bmdkWVWMRh5bWHZ2d8hzG9VUwlXehbrNsnEID2NsQy5RdWhkFXmvlKMR2zs77GxvB6KEiaFoYo5NOxML732YFU61f+oXIY9Qah8JM0FRUFpEiDhDa/ohjVKL99KQZ5JCjfcpBE/oA+1aaogUEv8pqDeBBIFCQ4KJ4WGi2o5XF+fWY8XEdGa7TdNcuE3SlqmRLxFiID010/SQcI6hTZoZE2b8ROtDnm2wuv4iWVFTVY7aWSTL8B6MyXAKVVnifB3KbxVjx+FvQj06FNfqoLF/+PR8eaqqigS1UL/93oDBoB8VZxx1XeF81ZAQw3mWLBO8Mbi6pqxqytJhNNxdnucYa0NYpwmCyyQJJvBdAiFF0rHmnFnCzLitdWYcSRj3jfFvKe1AJgqJpLo3MZSUSSHJBIwINgtkH8z8N9yM4kw6U4T1tTXKcsTmndtsbt7G+ZLHLqxz5/YVtrZusHtrFasXJvqZj4o+06+0QJRpEWfiCNnuj7MkmfHx6TtY5I3dNSdIabWVZjrn9BqIaCIOkwleK5w6LJ5Lb36fW3feYuvG4yjv7nzvdz1bXeh0Ti5A0NiPNHPQGc3B1zWds52Fr0zWhXnvonnkoHux/tyvZ+2lSnTQe+/aJLN37vvnN78m0/G2LUc6+9f0kf3OWDrOHzwO+7yeTEzaOU4yaeZkYf6IeBzkmXm53Ds74BJLzKKr/x1nX1uOL+88TPQJk6HkeG9w3iJmgIphSfM4Pixr8gj43G8/z4vvv7D/iQvifc+fO7a0llhiiSWWODg8tGTSx5h2Cwaby+QZYzvM2FCcDP3NV+roMFRsVtBbzfmZX8jwrkbFRUdMBhjUB6NjbyWj9qNI4wmJqRq8q6NzBLLW7CmZiCaM18kZhgllUotqcnO01M3EkkkM5yBK7cOuYBXL+XcNWD1dIFYoBlnc4Z4Ua4IDQ7MeZ96tFGeCdLzkBqMZolmM7z5/Yj5xPFWmdpvD0rmHkYRuu7Dm5T/bAzrKeGTI1Of9U1+o7o6BLNM20x+FbHF0M9VixvODX3VvyTL3evG5X2/Zr96XBp+HF+02vPCU8ujTBmNz0Iy1MznqBaNDRO5SV0O876MHWA7u33fGxkpXGV773qPYvIfYoGxmc88zL15hsHYKa1aCUgIWddEdbUI4EPEG74JTU103WWbtrOXiC734njCNoxlJJXKxPEoITxLeV87VlOWQ4e4O9fAmty8/RrmztnAd3A9s3+3z6reeYFjVGJths4Izj8KzHxiiZBiyEE5HPaIxXI3aqIKRnLKtVpkKnZQURmDssJ4mzkAgVbR/b4dLmVCpicRZVRCTzic4qTw476g1bDIRI4g1mDyjlwflGcUidoX+ylnOXNzCq2fn5vFLCs97p0277tpzvqQ0k1Qt2kQKI+MZRdcO+nRkZS3j1//Oc3z/1Ve5W++QZX0y28M7DUQFhaCiAZm1CDGMjveIMQ1BBkI71LVjZ3eHuiqpqgrvfVQeUbwL87dxu0XCSLozCaE2u9q7KxwO4kEMYuLn+IyphLBuiegiifAiIR/nXQwbFSvBgbGWPCsiIWMc5idMqcNcVVF8VClKqjoiJhI4wu+195F4XuJcIpmM6zy16dhlqoHcFEkNgVU2/pxGkPaMs93O6XsYZcakmf7FEf2nHDYbEJROwkw9WzN4LTBZj9yAdzXDsqKqaqAKoa1MUuIxIU1NBKRAUgrEEBvbakxiS6pHgiGzGdbYeL+h7j0urAGMRYyGf1qjgM0KjM2iepHDWB+VW+J9iYxVXdJIorPPRHrGU8hWSapArb7QuNpbpJdmdu1bacn4b5ZlkTTTOo4CHgkvhFYrB3Kl+lBvXjWEYbKCNULi16g0ejQkOpQ1QYmnKkuyzCK4+MxA7WquXL1MVZd4V1FtC7d+fIqdfk5VPoKvT+PLrOkDfmqsneX7TYVjYnGyzPTvi6CLACATn7XpL3awyerjb/DIIxcpitMY+hT9DDQPa2HZ4crrFdff8IjA1vZ5ymoVt7uyB4Hh8HPQRdFNLOnCvF9myRqLlWnBsFZ7prD/7+17S5+6e8z+BI6DOMS61sHJ7jBvLXjY+uhav+8ZAmqmbHutVI8L82tu6Wg8CTh8ux/kyvvXzu0Zy/TRB4e9xvqTh0m6zH7j43HnuhwTljgudJFl2n+Xfe3hxiJjbF3tot6R2xUM0W6GQfzDF8b8QWFJmDkCnn/hPM+/cP5BF2OJJZZYYoljRDIOHf5smZnFpl2VwYEHYoL5SSycvZihGh1GGETy4PgSQXEoI4b1FnU9woglk16IJ68OIybsQm3CJliszVAfpOxFghE7KeJMuDWjnD4N+Wc21JN30cyrwspGzspGPnn3YiKTORrVvKO/VtNb8UHMhiE2OvREq4Mb7aKjauHzFzpvfyLMvTS/zcfhTCLTZJmj5D6b8tFMkQ+mHo/TuHTyyDIJ8+7xKPX9oI1ySxwvVjZyzj+VI5ITiJgZoh5kiNohjl1Ucg6yHFzkmU7neC9sXl9vxl1F6Q887/8w1NU2HiWzK8EZT46qQXxwQ6p4hLpxYnYh7wtnn8ywJgcsREU3Wu/b4CpNaQRFFu9q6jJjOBRuXnubu9dPXkjcapRx69pkqKvcKlrvIlJgrOIJ4XcaImxy7DevTYnhXAKSw905N6EiE5Q/Enli7NZVPyZWoDoxNhiRoIgRneeJgCOAkahOIZJSaq7XGGaICqz35GJRyaJZu6DI1zn/uFLetezcPHi9dZFfFnGOzuvXybXsZUyKlta/MTFDmopvH29+t8rZpzxnHbgbF8NX4QAAIABJREFUFmOCw90aieoYqX1apCMNTmojysgFYoyr60B0UqUelXg/bstEdBgrCLXme5E046XVFhrvRlvuUG07QgVrIgmCQEAYz2W7XNbSqkTFqyJOGwKFEUF9IPsYD9Zqo5yjOnYUiRGEQNJJyiHSTls19vtAIpoeH9ohtMbfJyHQkMsS8cE0rZrucer8jjSK0xmrz9gwhklQC659hdMRW0MbyGIO1Cl4bdrJqw8zfjFj4lDiw0y4qCXer7TIIqF4QXVlrEIUyE3xnBh2KxMbnsMshHBSH9pFvcd7DQSfGOpougk11nXoK+H8RORRMU3djcMGGVTHYZXCv1RTiTBDqGkZ30ObpBXUYibDMgGIutDQ6kAl9hcTCVVm4j0RCFcer4GgFQg7ZtyCcZgTQlgvQ41S4l1NWQ3Z2rrN7c3L1HVJr5ej1TnKm+cpAWE9pjRJIPAT/WX8eaxCNG7ZeWSZNu7lPGz89Cq28KxdKDn7pDAY2BBezymu3uXW7Wt4bnHj8ipXXz8T72SdFDZwnjNnP8xclzap7LEBYr+5affve12x2HvhQWB/4kv33e5VR90knP3LIa1v89RmjrPeVHSh0E3tPI+TNHNc6+kl9sfRW+z+kGXS+T+tpJl3FllmGvuNmvcyxyWWODwWmV8t+9rDi0XHWO+HeO8Qk4NkoMQwvMuecVxYEmaWWGKJJZZY4r5DQYKzqzEbaIaSgS8AwViDmCG1H1G5TUbVXUZ3Ckw9ILcZXj1ZllHXNeo9RV9ZP+sRLfAuC85HsYjJ0SwHGUv6h1l23DnaaaQUwm711jRBFJVUXlrljoZyDNbXYSerG1FXjru3c0RHiApbt1qOu31qZ8Jg35bR7zCkHWVKuJ85dS8ch8FgNo297m+/Eh0nWaad5tjxdJh73suAexh0pzdv1+d88+f8hebJJcnsheMyYHU5kpc4WbD5Lr2VmsFgDScZ060mGryeg/UeSg/1IBiyGPbFk6HSx9uMtbM9vA8KJSEcYcndmxnlqHt3St4T1s8EFbQw7qdRwqPqETxGGO/uV6Wua4bbMNo1iDGsbZzj1t0tqtphrIa3h5FIzABw1PWIzdslgjDanUNoUcV7R5YV4Xn2Dm2Fh5EYCiM4R0N5UTAU9IoV8myN3Z1tTp1fob9iQnpOuXsT/Mnj0FDtem5echgLG+cttieoCYTV1AfartrGTdtShknf2+F3vB/r1xEJEaoer74hwrTPFwEvBpMIHWpR9Tjnm4g9Ytv9R0ECyUZFgkPW12jpKcUgnkD20Iw8W6VYK+j3aybU7w6Awzpi5o91KZxRetNEYocmmkCLUCFjMkYbde149UdvUFaePOuhmKjeE0NXuRDKMpGZYEwmMMYwHA4ZDoeUZYl3QU0mk0BYSoQn51xzTVs9BhiHZAKU2Gemb1jTuz71BQnEnjhfTDSBhljlCSFvNKjMiAnH0nMfwiZpUI2KijJAIP2IR70NpBlJylASBWoCkSiE/Yk1HskejVKUaCBtZRmDczLeTSdpxjJW9SCSOpyvg1JLaXC3w9x2OsRSal+zpmRrLpxhsjRljkpA8Sa9ogNLWRvqukKsB3HUOqJ0I7xTvIe6Viw5he2RZRl5nk+079xe12q/JvxZJEd1KQEFhR8fFVpC3s4F4nwinnuvcWzTxqga+pyL5LrQL8bkuaYEiAnnS9NWUddH0/MdyFVGJCrOxOtSWWOfCnU9VpFJyjOprzdkm+YiEDUINoYjS31UInEvPX2J3CM4jWsTNRg1saXHvUHUIVKTW4fzI3ZuOYbbFbu722xu3sH5Glc7tG8x1bhnzLRR81e7uf3Tz9gCqpiLzrm65uV7jX15D9ZOj69QlGyQkdlT7O7U1OVNwOFdSTkccvn1Ed7vsHvLAGcmb2Mq7f3G205nz1SFLUKcOQzmrHDprsGD4zidVouvOyeJWIuU5bDvxEnSTEjpnq4T9mn/pp+0ypbqoTXSHBHz6VfvHLLA8eG41/GHw/653cvyLDK8H3duUzOy++4gfzj6+n6j5r3JcWk7WeI4IHO/3V8i2BL3Bwcdc70fUrsqbH4Tg9pVXNQZXeJ48EAIM8nwdljmU1pIW2v3P3mJJZZYYoklThzGxu60y1dEwNtAVJGgEENUicmyAjEDXvtqn9tvpVd3ctPkCHD2iV2e/9R1dndr6soimmNtD5sNMHo2SLEb0zggnHMkg/Ws9UuaPILkvgMpMVKB1EAwsIuGHZ6CQdXQE8VKjdMRd0c7vPzlU5TDSafXIm/+aaNvc80xGpsXvWa+YVimjHUHy30Rg/OkQXC8l3deTgchAHXWb+fvXc7Y+ZP6Rc6Zl+dh0WmMn/vLfjSZvZefJ2kJcj+MWfv1kyXuPwYbV3jiuTs889wH2bUDfLPnPTgTxIfwJU0oEY1kGB0Fxx4ZcA7vhGc/pBg8hhojQ1Q3+foX17n2Zq8z71PnMz746TWUPtDDq0SSSonXEYaKwiq5AfXBSb25NeT17wuXXzV4NVzbXoFeHy2gNBYQLCWNw0Mdu8MdvvNlR7k7vx4Uh9ddxJjg/JWx09erImpITAcrdhzqI9aLMYbHL76HR5+oUa3Bl4x2Kr7+R0I5PI6WOl5s3hK+9acC1Hzo03D+Yo4YxVOFN0PwFqP45m3hO5g/02F4grOdGGYlESJ8VG0In72vJ0L8hDlASM/abIKwEcLH2Ob8RjEihsAxkdswHG7hXYnLB/SKPr1iQJ6v4V2JsAOMDl1X046+gD3ICfsemXbNEeonujQSeab5J+PPqOC85+rVW9hBDyMFKiGMjjrYvHuH4WgntpXinG9CYY1DEjFBKPDOE8RbxnPJtrpMcxetNg4UCGnUZrrqI+U5Jt4IJBUSUaIcTFQzkYYcY4yJj9qYrBPCDQlWQsgh9SGcUyA/gEYVEI/DmgxjDQh4F7+HggeSRApPJUTitgdfIwLnPpQ1c2eMQySQj5BEDrJ479neGVH7IdXVnM2vnJqaI4y/KcLqMyXr7x8iJicr1vBq8B58XaOupCxr6kopvWF421NWI0RqTOYxNoRBCiQNS2GCClZmbUNuSmpAexFmxn2gvV6YJNHMfBaJYjQxdFZSoUrMwfEVDaElqBSN3c1tG51GMoxIDJeX+hVpHAhdwlpLlmUzhK3p8jefta1CM76PaXWZ8bXElvH4SNwPY1NQ2gpEnkDIFJuRFz2MyaISDaTxDBRjPJl1iFTU9Q5ltcWlb62y+fYAGADnm16x1aq1RMNqL5ma0UDmzI8OQP7Y78x5v7fHur3m5etn4QOfCm2pEtaAWzuOa9cr3rj0Kt7dRHUL77Yph8rozd9G3epMWh2jRucIe9j5aZtI0ybPdBGD2gE3ZOI4E5+Oige5ltkrz/YY1iaN3Nu5+ny1me6z538bY3EyRAiRyPjdO5V6e518HJhOa7/n7WFZJy1qq0k4zPO+OAnpwZJljjvPg1qK2n161u50b3Cwe9uLqnnSMElGauO4x/KHZSxY4qTh8D1r2SdPJg47elbDTaohmL6BzGDzCo+J6+AljgMPhDBz7do13nrrLXZ397CC7oEsy1hfX+c973lPs0tniSWWWGKJJd5R0LSrtjWpiY6A4IAxgTzDAGsMQg8jNd2msnDUCwzWVhkNlapUal/jXE3uFfHBUGow0fEijcF7dgYdTMJeFaFGqDBmB2N2EEpGo21cXWLFUGQ5ed4LxqsyOdYqiqxGZGM64YUXkfMIITPcngXS6jq7+9a7FtCzhsF5u01niSX7l64xvKnM7Kxs19V+NI7DEmj2MrB3kWbmH+k2LO6Vx3FjsXxmSz1pZG+fcxgq1MOLpQHoZMDmPUyxjtMemZjGealewEeSiIxJNI0OjGhzDBVELSk2hkqO0wzvh6jOXx4659kZVaCKtTVZZrGZopQYrUA9ziu+FsRbPD16gx5FbwSMUIXaWWxhQALVRlB8fAgNyQGbESQs5vc4I2ZCrSGEd7FBYcDF96pPTt8UWih+VwHxiGYY2wNy1FuwGchoz3xPApwKlYektBGpEMQbDGQZoFF0kLEz3Hs/rp/0mwgSyTYh/EodSQoaCTC+mS8k9YnkhK+qKjrZPcZYrLVYmxzfYYNLIgrEIiHGY2yNrz2l8/ja4WvFrGxgTIFIyVEIM6Fke7/fZo8t8saEyTdj657iL0ZDn066FEaC+oSSUVWOUblNWTucU2qn1PUIH9V6rM3JshC6qK0eYjPbtFsgqNhIQtEZxaC9VUsi0aGDrJBILmMyNpEEpUE1CoONznZNKjjxmWquiGF7DCAtsgx+XEaRoFqjhPFEVXHGYYzBWsFag+IiMSKcmMIH0eqfXiuMNVgL1mSoeKpqhGoVymwtRnJUHXihyPoYJ7imZaZbX5rQOs5BNQKvjuruJt6FW0Mdwig8F14QLIglz8N4ZCyB4OMIYywmhBnCNnU6Jv9MqqpMwyRmWat92m08/Xu6i/B4GoikmXHaGoksDufq+MyG48YG9acQ7ksSQyUQLyWSXdrzW43kN5EmpJQxNqZPk+8k4UWa48bEcG5NP0z31U2YCZ813JdxsROnd5pHCGHOQh/KsDZHxOCbDu9QX4f+JRpkzHUHdEg5uoX3BVCkEk7MAOMbstG7CuPqbBCmeXPi6XFFOj4d/H2jE/ktQmAIofzWqOqSXs+yW95ge/cOWVGTuxLNKqzx5FkBvuDSZcG5/Ryhe62E9rhqgbA76bwuxZl5pJ1ZskT3rLXrruaV6CS6gbt6zphAdD9IM/Nq9SDnT/46ueqatG+k4/MIKns9Sc1aX6b7hs48w/M/7Z1nG0ezURweD3p9dpT1/lHpFge99qjP9FHr+SD5p+dhkhZ3Eselo9Kn7jdmn9SDt8v+OZzsleQSJx2T4+pPX2+6VyPJSalJmfl8sHWBaI0vh+w6QU3F6um1YMuiPtZy/jTjgRBmhsMhdV3zxBNPHOr63d1d7ty5s5BCzebdLf7e//IP2Ny82xzr9ft8/OMf59xjFymKAQDeOzZvXuFrf/FVrl29OpHGf/6f/k3e//x7DlXWdwLc1hWuXXqVb796lev6FD/38z/D049t0H/QBbuXcLuUm2/zvW+9zBtXlI3n3stzH3yOJ0xFfeMVvvvya7x2u8fKI8/ysY8+y1o04i+xxBJLHA+CGzNaniNRJv11jYEWb1ApEAxG+zz9gvD4s8kIXaMEcooxnmwgGHOO3ZEjy/qsFOE67zNEViCq1jiXjIqT07Swcbg1NRdBTHT8iAPdBbdJNRrx6tdPUQ3Xwg5iMRgTFd88MSyH4rxSl6bTeHSURelepJHDpjmJWXP2+O/sdLbre/uXsXljOu+pmpgx5k3ioHvmFj17sfboNvHPP+tgmKWn3BtM5zNuzSUxZon7g/2ekUX632DlFOsbG6j2MC4qVWhSgwjhN0zL6R38l8lxGN4xGsmXEsPpERVBxJzl6Rc9554Oi+1eMaB2HonhVPIB9HpQjbbw9YiqHmFticlgNBzivSAyQFjFe8vK6irGKI+8C1bPFhhryHKH0cn3jSCEkDAGxJL1Cp77ubCx4vobFdderzpqwiLaxzvbOAyjAAbeO6yxhLBM2nL4TpJnnBe8CCIWkR5Zz/Dej3hEPVY85e4m1y6/zY3Lz+Ldg41kvHY24+ILA+pa6Z2yeCyZsWNvLcQmT8yWQGzw0bnsfVCBCaSLRF6IDupGgUSj4sRYDTaRYYAOpQoaJRHvJeYT0k/O8LoObWdthjFpdlPj6xrvoNaasqyoyhL1nl6v4NwTwmCjD3jEeEajIdffhNtvH3cbTL+hZ5/BWfNVl2to7Fr3Ehy9UXOF/hnl8Rc8WMP2zpDdUYlXsFmGzQSwOD9WG1QvDfEgkY5S6EshPMre+1iXrRJMKAbJzHGIYXOSGgztPMbPTiJWhGPxufEeNZEMI+GZSc9QUrPSSJYRY6KaSmzrSJQxUb1GNSmYhHtT1aDFYsAawQjUdcmYuhDOqaoy9i3FGLC5Rb2ndCMC8VzwWhEUlhTjDIIDlaCGpB7vHWbgWPnQMNY1ZDYjywPZoizD8exU7Pfe4SvFu0iQEA9Sx7HSxPrysSf4QJQhqC4KFpEMQ4ZgxoyqVrso4RkVpohOMp5vTrdhW8VlGoqgPmtm+JnRxoAhEsKstccEVQJ5JobV0lQuH+ecUUkokHrGAaySopVE8tS4XUxTxnZ52+UWkfB8mDGpbkyomeyPk6GnQr4m1jlxXA9qPRlGskDEifEAfSyP1wrvSrxW7G5tMRxtorqN287YeuNxqipneHusqNamoijjcTENs+nzNNrrhb3n8um8o8w2u8PipGNrZzxPvlCT5wOcE5SMwUoPyTKEGiyI1Di3zc7ODawp2b7yHG5nDRPVkXzdg5lc9ipBOr4PDnjb80gzKa9pwshsGJOuFpE9vs0/a9a5wURe+2GRNdKiZCIIJJDpOkg9q92/DtvTZtNeLMXD5De5Fk1tOKeXTTXpdBkn3ucy2R+ad98+5Z13D4uthtvnd6d0XGvN6T55nOkevR0Pdl3K9yBY6Jk6YJr3Kr3D1OfkONNlg+qaB9xb7N/Gh+0FDxIHs0x2vX/npbq0Ky1xVLT70P0cfx4U7vXo8aCfy24/QtfRvUv59k+e4MbbjsFGyaPvukW9e5asWCM75tCmP814IJY/5xxZlvHYY4/te25ZlmxubrK6ukqv18MYw82bN7lx48ZChJlRWfGlP/0qV6/fbI6trq5y5tGneMps0F/RWKaa65eu8Cd//g1+8pOfTKTxG7/22YPd4DsKyujyd/neF/85/+sfvMbt87/OysVHefTRDfondJ7jq112t0eUahmcWWfv5Xw3dHSL7de/xO///X/FN986x4t/42/wm8+/m8ftLne/8wf8y//7z/mz60/x3k/+Oi/8/LtYZcSVb32Jf//t13itusATL32az75whpXcQD1iNByyvaP0z23Qt2Ef2RJLLLHE3tA4eEUnZ5QZBkdSAgjW2eBQEYFTF7LguBQFLEo0YhsPUlDXPYyrsbZPZnNELN4HBwzQyKRrzNeY5CAJ3yU6JtJ2T6XG4DDiwJe4+i7lzohbbz5KOTzcFOKgk9TFzl88xflnTjkBmTSALy5A3W3EnU5/bLTrNud2le1+Tn+7jIL3YlpwdGPf0UuVHECzxtYHvaQ6eVjWyOGxqGF3v/rN81V6vSwowfig+BBeJ9IkMuEOaL7HkagpiG9GluSYFumxccGxejYQbvI8wzmPGItYA1qj9Sa9bAvDLr1sSG5LvHpMv0Clx+Z2zdZwl6xYRY0DMQxO5fRPWRRLIIA6REMwKWOE2oPToJKmBPLO2Ys9REu2b893lmVJOUV9DA+VVHVi2Bf1VGXJcDTEKPQHBXmenPkCYnDON/VnTMbpx3pkVjHUVMMcyQtuXwP/gBVui75w4amcug7zA0FBQzhEaLf52LnrkzpMVOhI5JeGXIEfTz28x6ujrivqum4UQfYLo9wmV6Tvnc78JkRLaBets3FZtAyqNlSUVU7Ryzn9WI7NgmpQVWUM7yq33z5s7XU9fbPv1XmOs+6rJ915E5oPojEcjJINhNNP5jgnVA68CsaG+VeYu2kkSLTrbrIkSQ0kkSyAhogyUaY57TS+Lmk6dV8zQZRpFEI0/YhzNe0wUU2ZkjqNBMJLIGPM9oOgQpQIQR7vU58wgMc5j3PaELa8H5en3Q9FTCRoxz5O2WqDaNvBI1SBTBjJPKoeKRzFYw6UoIhkBGPj+OgcxgZiiPfE6xxjB4miiYwok6REr1FRyNiooGLjfD2M0al9PR7vYr1EUkhQWwkHUj02FL85bdpNmgmqNoKEEEomhkCT0OqepM4SlxdR+UfTfzrOb4JAH/8mNZkxuyoQ5KqqoizLib7TLud0+CUbCTihH41JNrP9LyUS8m3aV5PyjcVIAcT6VsAnUlN4roa7d9i6e52q2qaqtqjrLby7Q3Vrg93Xn0EpGoLB5Aga/vqJI+33Z0ebtP5q628X7oVLMaWZ94WzT2bYLANThLrB4LQGCc9MnhesDlYZ7tykKHLu7Jxn59a5TsP9bDm7S77f/SQyiIoeiBiyKNJ6a3arwnzqx6K0h+m1ymy++5dt31wOWCeJTDSd//S68yDz9nklWLS/HmV9MJvH5Fu2/XtXH5p5l0v7mW6nOa+8e5f+cKvh7to/jrVUVylOwhrtKGNb97WHT/EkuTOO2jaL9qST0AfuzRvupOBgdX4y2mOJhwUP85MF9+/eHtRz2TV/nH/Xe5dy6/Y6AKf1Lnl2C3UV4v1D3T/uNx7YVjljDP3+/hom169f50tf+hLr6+t89KMf5dFHH6UoivtQwkNCK8qdTW5ducyVG7fZ3BkxqhVMTtFfYXX9NBcef5xzGyus5CejK5fXf8xPvv55/p8/fAN9/wf5jzdH1EceiRX1Fbs33uSty9e5cWebnVGNw5L1Vlg7dYFHHrvAhXPrDBaVbvE1uvljvvWtl/nh6yXm7DO89Fd+jovmEB252mR4+d/zhT/413z95vP4j3yGX3agOmT71T/mj7/wJT5/++cYPfEJRupRbvHy5/8J/+gff4Evjj7Az/7Ok3z42Z+lN7zC6z98he+8fJPb5Tk+8luf5Jm1Hqsno2mXWGKJE4tph4i0rLAKSfxbpg00Lhi8W9crFryNu7wLil5wFzofDOcB0eA/Y/EzTTrBWB3z16QqM0IowQ/ZvVOzfTtntOtRF3aIavAyzkWX8S8Z97pqZG46M78fborbbSTrNj+kf8lQuqghM+1ma7fmdE7HcS/HhXkGt/mf5k32F025u/2TiXueks6sa3N+zofDbNmWBo4lDouj9ExjlN7akLzIsTbHSIZi4g5+YfWUQYyNYV6Y9ODJrLN9cgxK32x0BbbOV8EaE5zeNg9OavXRN+wxVvFul3J0nX5eU28ZjPTAZlRVzer6GcT2MZRkhdLrD0AtnjzkJ2PCjOgIq55clExgqC44x8UG8TURMuspR1sxfNDsTF+oyNztVigRAyZHjEHQEGJIHcPtIW9f2sEorK2v0u8X9AawulHiNQ/EIzLEZCA5SI5TodYMMsPpR1Y485hQlcpwy7O7FRQuNs5brAXva5yrqMuK3a2VhqB63AiKbkqehbsPvAQfIq80jvtpEkXLMR+d6LSc4mhQg0uO77qucK5uQjYtsjllL5JGKHdwfqc0G8e5zwiKej46thyjcouyFgqX03cDiqKHiMXanNVTypnHgkLO1g1DB19kDua3R/c7ef5506mNiZahPbLC01/35Hke5khO6W8YoB/ONSHkkrWBvlDXVQx9GZ9EnXpaG9KJaan9hHmX+lmiS/t7m4CQCDMhrJEGQkZSr5m503hHibCgPpAPCH0lkCaCkofQVqMxkeyhjeJImyQxGZIplc1H1RkXyTKuuedJgkwK7TUubwrn1IjVMLv/OpBAfJNmIoQLofxZlgNCHZWX8jwPoYV8UmTyIcpUbCFVCXPuWCaS8smEIpCN9xiUfHwak/0kcaRdP5JiVKV0iUM542PTYZu6wjgl1UeRQMoKpBEXxgn1eFe38g2h0jJbhP7U6m9JASgVy6cQbhL6ufcukvG01Q7ttcTkvU0TZow1UZ3STPw2L7RYUvQJlZLCDYZ2RLPwDlRtyFNet4GKuh6xuXmFm9dvsnvbYqwjt4KrM6q7lhbbtOn9Y7IMTRiXdDyVaJ7aZBf2MncvOsfcb+abfl8/Y8h7wtpZg1DgnMXaPgg4X4J6jIRQS9b0WRucZjjYRP3dSDKdf1/t1cBe64FF0FaNOSpxZp4TeVZhZer5OUAOi9zvouktcr+LpNXQf1J6U0oq4xXN4qSZ/fK9H2ui/UgzC6XRem7HaXTntcgxZsp0UOy1Sj65K82jOBTvB2lmr/QfrCl+Xu7zw/4sWs+L21v2w/wcjzpO/HRg1lrUZfebPvvkPu1LvJPQtSZd9q2D4yjvuEXTn39s4Vlj/Du/pGIy7GANMX2c5nhdxkY5LjxYbel9UFUV3/72t/nd3/1dyrLk937v9/jVX/3VB12s+VBHtX2VN7/7Z/y73/9n/IsvfJVvvnqZq3drtHeas0++m/d+6FP8xt/5u/yVjz/P82ce3umG+pJy8xI/+KN/yD/6Z/+Wz//Fy/zoyha70mfjwrO872N/nd/+27/Fb/1HL/Fsb//0ALTapv72/8Hf+6//Cb//9VM8/9f+Lv/tr/wcj+WQ3dOq9OBvcOknl7ly5Sa35QY/+sHrbFUfoHzj/+Wf/U//O//9P7kM7/ot/ofPvMS51SVhZoklllgMXQbv+Uh7HVOIiXCsvcsXaCTi469hF+aEEy0QatC47TQZjBNZhuAoEDfC6h1qt4Wrt3jz5XXeevmpxe9tjlFwZkfYHgSTbiw+tV3MGDZrgAn/xoZjUZkp3zyJ8Omj0ySQLuJHlzF3cXSXY69FwKzxd38j1PQEX/Y6V2dTHddnh5NnosTdAtaeEOqC5qzx50Wx/7nTtXbQQFgnF2IcYqLDOh7z3sZYt0scF45j+mczz+MvXOPU2TOsrqxS5Gt4LXDOUfQsnoraj1CpkDntN5fo0HTxLmd5fDdAi1zZuPKBitpvszPaQhF+8O/PcfvqAGvb58JTL6zx1PM9vMsxJo+uK4n+HEWkxuguWu1Se8VmFi1r1IPNc7K+x+QZzm1Rj65RVwVweuZWfLXD8PYVah+c2pIPMMUAb0LYl6BiANVmxpXvnmpfyanzO7z7g5cZ1Rn91dMMBhsY08PVNUUxwHvwZEiWkfVWePETFeB44/slr3+/pugLH/jUCr2Boy4rdrbvcPv6Jpe+9wx1lcVXqqaXc6hBL3h/cCOGzYNSRJaHMCbeB/dRcDCPCQGJLDUOySNNiJS2Qzs5pSePuRiuqWpCMi06P5nX15IzfFppJJEirE4Sdklha7xQDj3laBtjhhRFTr/f59xTBY++W9jdKfnOF3uMdhXvZC5BSWb+P1Xuqb+Lou2QTHPo58UHAAAgAElEQVSF9HdwquaZj+xyauMMqoZy5HG1UlcejMWQhdmYJyjQOMVa4jyuHTKrRXSZ+jxNhkm/tf/Ob7tE7Ij30DrNxBBDSfnFeyiKHAihiZDYr2KYs0TUEyOI8eO3ZUP8sM19tcsVwkkZrLVkWYb3gSiT1GySulE6x8YBpk2gaddFUrcJiirj56tdP9NqSWICWcNpOFbXMaSQgqvHIcl8JM6kekGkNd511G5MD63xLUIIsd7GIYS6n82JckcCjsRj7Wva502STlKeNCSJqt6lrkbUQ8/u7g5OHXkvo99fpd8bILYHWCARktoEI08Ii5bK6Knqit3dIVVVU5UO78FaS1EUrTBLoVypDafDSFljZ8gybYWq6fZr9ysIs8QwD/SI1qhXDIEUVJY7bO1cZnvrFuXoNs5t4e+cwb32YWqUsjV7TCH7wp1FuuEUSaYje47mDj449nQMG8hyQIX3fDjjzGN5IIJKgRiLV8H7Op4bQui62uGd4LxFKNjcKqnr8a7U7jXA3vfbXtt1rY+m135t0sxByDNtlZpx2SbHZYjr36afjDE97s9f70hnfRwHwec4ML1aaavNdOXYJnzBdH8+GU7wRcgAE4SgPdbh7bW2Tv02e/ai5Vqgfx4h9e6r2qvdvd1792K9ehSH4l7P2OGuHT/N89K8t/143tN18Oun3yzHUe6uXjPv9+5Rcf61RyvRSRhd7iUmLVKL2t8SHhY70xLHh4PMMJf952g4yjtuXnrzj6d1s5JlLrZztCI0oWcnoVMpTB8FkDxnqKdZLU7jKfAnm+bxjsKJrskf/ehHfPnLX+bq1av85m/+Jk888URjNDmJ0N0f8uf/9O/zf/5v/xf//NvX2BqOGFUu7Nwrr3L5h3e5+VbNs5/9a/x8/aBLey+hlNd+wI/+zf/If/Xf/SHfevM2d0Z1qAepuf3Wd/nGNz/ARz67iR60B3qH1/vtwMrAvoe/9Ld+h+rxl/jw8CIv/NpnuLjWI1fXxAJf8viWWOLhQJejYZFd1ofJZ55TY09npygpQnkIx5B+SNMuouOspR4gPjo32v/StQAe512MXe+58krJ5e9XoDlwGtUN6upoo9w8I9J0fPrDTFwXOb+LotIuWdsw2ibLGB1/SwbHLkfbPCNc+9y9316L3fVBjHH7Lba6KCzzDINdrnWYNB63P7V72sT3jvMnW2DOTkBRnE7K4zfnTe2sPAzG7To2sk/kv8+1Jx3rj/2YjSd+GKJ/qGKt5fZbz3HrzecOnNZxLy4fBhxnHzA248Jj76XX7yPSw5MHQoiR4NiV/QO57Ut2EKAjgKhqUB6YTAtQxZWAW6VfPI6rS9QXPPGscvFnQCSotCAFWd7H+D6CRdVhbYmnxOMwxpNnisgd3njZ88bLBYILDmng4vMVTz3vUe2T2SyQTeZIidy+OeAv/vgpmjFDoqra1K17N1sXd28N+O5Xngr3mxzMlBR9+NlP1+SDArxFNcP5HBXBGuHJ963wyLs8tQd6Qk0wVKxurDBYrbjwOORGcNUuo90tytGIalTi3C7X3z7LjcsX9m6XDrznpYJTj1rEhM0kznmMhLAvoc2mDCcySZyYVuxIZIB0vK7rSNIISiJtx3xbHeSg86A2MSf9nSQGhPBA4XN884pg7FhNBfXUdU1VlRgrqFpM1uOFX/Rs3b3J1R/3uHVpY89yTL/f7s3YFXIpih6nzqzjYgilvF9QqKUsHXduXKcoCgZFgRGD845KLcNyF6cVwV42Oy9s6qJ9LBJKmGl7mfk+JlDRmh+G+eL48kliU5YFokNdV6AeK0QFmUTykIl+EsonLZJUKHdShElpB5WYcE1bTWaaVJPneXMPSZkoEHrGfaldJxoOtog3Y7T7eyqzMQZF8E6pXQr9JFRVsDNIbAuiSkxqm5T3+O94lhPuK5FATKP0EtRRkjG0m/iTrp9UnBkr4rTvZVrBJR0L9wahuoK6VuW2Kastqm3H8KvncMM1indv03tvRa+Xk8KBhbK0iHS4FhnPRxJTGCfCeFEhmEiSySaIPCJClmXkeT7R3iltkRg0qqOfd4bxauo9NIQhtEuCNR6VGms8l34QCI3qzyD+NKIeUUW8xcaQfRBUfwIVKIQlVAmEmc4QTOm+mr9pBTZftWIvgkYbi84b5p2nwOlHhOc/JjhfkA/61ORoVKUjEp5S+EXv0xhgyYsVisIg4tnavk0I2zS9IlisrF1kmIXua2r91xlmR6b7Qzhnv7Vj+D4bnmm6beY5pmT6b+da52RhmrQ0bxU3TZ7ZM03u7Xx/73JMEgzmu4smoVPP5n7r88VKML+kez4be/y2xwz+gCmd7DXZ8RNnunG8z+XBx8HDpd69SWgW02fNlkQ6zptHvepO6yT3ogeP/cef2VY92BizX/pL/DThIKSZ+4FFynKv+u29zvsoI+C8su01dzh9fof3fuRyUGCWPsasY8waSCC7tNVMlSqWLANsXHZ6EIenBFWsLciLDVSLeN5J6jnvbOxLV7h06RI3btxgNBp1/m6MYWVlhaeffpq1tbVjK5iq8o1vfIM/+qM/YmVlhc997nNcvHjxwOkMBgM+99t/k63t3fFBETIRXv3uN6lb8tBrgz6f/vRn+NQvfnoijYsX99tRr6BDfvz5f8of/st/xf/3H65xWx7nZ3/rN/jln3sP73l0lZ7fYev6FX701hof+9CTPLUeDU6+or7xHb78hS/xla99j1fe3mLHrHPumQ/wsV/+FT7+wWd57lzRdPn69it896tf5o//5Ov8hx9fY9P1Of3k87z/47/IJ37hw7z0xKA51929xKXv/wVf/Pyf8o0fXubGdo2zfQYbZ7nw5HO89Gt/i8/8zCnmB8ZSfLXDnVe+xOe/+Gf8xXde561Nh6w9wsUXPslnf/WT/Oy7H+Fcb/qBrNi8+gbf+Pzn+d6la9w69Uk++2u/wl//7Is8mlfsXH+Dt/V5PviRZ3nEAL5Eb32DP/znf8SXv/Eqb9zeYddZeusXuPjCJ/nUZz7GL3zoac6mIUxBy5/wwy//A/6b/+RPOS/Qf/Fz/I2/+hk+9/HH0N0bvPaVf83n//SbfOvH17lV5gzOv4v3fvQv86ufeZH3PrGxxz3PgcDVH3yVb/zJv+NLow9x7em/zF97/xn6xIHV3eDuW3/A//xfvMY/HRSsPv1Jfv6X/ir/5W+8l0y3efPrX+Qrf/rnfOU7r/PWXU9+6gne/eG/xKd/8SV+/vnHWF+ybZZY4sTgXpBjjjcvYRyCQ4jxK1o/azCSto3RamkM+xqM+mMzmEbZ9hoRj9OaqqwZbiWTcMzjPmHvGuk2e7UNevOMe5PHZ82IbWIHxBpSYZ7xeL/yzTPQdZVrdmK7Vzp7X3kQTDsS06c9jcdT6jETSjzTx3SyXqdL3JX/POlt1WD49q0lZHJ0qCppf3uS4j48pqW8919AnbRFbReynqO3VuK9QzwYI0hWHTq9RQ3X865ZFD+dRiPBmBCKJngJ60ZRDNIucMPh9z3I3Iqd/0oS8BlGB/TyAp/VGDMi71sGG714XQxFQg4awjuoJhenBVFUPIjH+ZKyFHa3030FVJXBiQU1ZPEeRbrfP94Jw93D1YF3wmg3nzqqeOfZ3rzJ6eIMVvrU6lCEuq4hy7C5xeaWqk6KFRqIBCZHxJBbjxGQYgXbL+h7D14RdQx3DDcuH7ysWU/JBw7voK4FY4Kr1rlEGOgerdrzi7bCwzSBJpyXVOtkgnCT0jnMXGX/a1pv7egMDySGQC4I/cczHI5QdYHYZDKyvMf6GaHydzAdzS8z/2fm81GRHMvj4DA0TlwXwx4FooAyKofcvbuF8xWojcoOkQjSkEps4+JrEzymoUmxSKffUovVd1AcDO/NSYN+VJ5pSBvg1SFGsBKexMRqMzbDSArXlM4NMyz1glgTfjfj/maMIcsCsaKtoJPKncgvSZEkHe8kC3UQbIibadqqRu3+PUkqaSm7YAikmJCW0zgGRp5KqO7Yc6ICToyBNgPnFBEfCTmTZUUjaSaVt6Pd2spBqhrmTy1yzLz2HYe6EqzNyWzoSyJKluWI7WN9zfZQqHeFwhuyzJLneVBnUgXxiEl9QqPKVPrnY7isoAQUxjyLGIuIxUhaT4zbryiKGN5qUkWnIQS15nmd7TkFTTsvFTCC0ejwl0Cqs8ZTl9tUO4puWQwWUWmCzk7P0aThIUXaS2pv0loh9ufpcsT/Twb8mcWizv2Dzx1n1wrGQr5qyCmisT1HNfVpRfBgwvPtVfHjEQuRnKK3wukzF9gqelT7rHjmqch0EV0WvqMO0sx+mHfO9Pqv3ZZd7TF/rTO1zjkWVZl5adyjjYDHtDA5jrLtX4x5zv+DY4Hes+B547Nl6tO8PO/POnDWyvFOWScdpUt2jaldlpPF0+8+87DlW/S6efap/a+5H71rngVtCThozUy+dw5aq4exsSzx8GGRMe0k2SCPYwSZma8fMb2D4CDP3bxyzZvvtY/YLKe/voHXAmMGiFkFBhiT4wnqwWHjTQ1UiIS1d7AVmLCGNx7FIBpsCXiD8R7UIX45ahwX9rUyqiqXLl3ilVdeoSzLid+stayvr/Oxj33sUJmrKru7u3zta19jOBzy9NNP8773vQ+AN954g6997Wu89dZbfPSjH+Wll15iY2PvHWRdyLKc977wQYala47VdcmPX/4OL//gu9y8eROAoij48Ic/zHPv+wBrG2cm0ljbOMWe0BqGr/C1L/4JX/nqq1zNL/LUJ/82/9nf/S0+86FneOrsgMIP2blzgzevKueeeZSzPaC+y/Dad/m3//gf8vv/5st85Xtv8NatEc4UDM7/Od98+dL/z96bR0ly3Hd+n4jIzLr67p7uuW8AM4MZnARI8AIgUgQPCLxEidRSoilRkvXWa1nWs+QnW/bz+mnXa2tXluy3EtfUYa0omid43/cJEMR9Da6ZATAYzD3Td1VlRoT/iMisrOqq6upjBkOyf+/NdFVWZlwZGfk7vvH9cewdb+Utr3sZVw5b7Owh7vrcR/ncF77ON+99kmdOzJBYSTS8he0PP82ho3cQ/8ptXDsWEFYP8+j3vsQX7/w8X/jhIxw6k4Cy6DhB24i+TXs4ve2N7NvYTycYkp47xbmnv8NH/+GjfOl7D/H4sUmm6iBkSN+mR3jm1By/8rZbeP11m+hvWhMsca3G1OmzVI3BBH2MbL2Sa177Rm7YWEBPnuB0tUS50udSF1kN+iiPfv+bfP1bj3BoPkHrhLopMrLtUZ45O8ds8Eu8c0/OOWFnmDr5FA98+yghUKhdzbU3XMf8mSMcu/tO/uHDX+Db9x3m+XNzVK1CBINMPPgUx2bfzy+//npuHG7t7WKimTx2mGefeoSDcT/R0Wnq2uTaUyOZO8rjPzzD01IS7R2kuPNVxPUpTt/3KT750c/zpe89zONHzzFrBdYWGb3/CZ45+S4m3/pGfunASJt9vmuyJmtyseVig2WWlpLJK6IZU4w/YltWD2udN9hKyDkxXfApvTYHTxCpszzBYkDU6VsXs2FPFepVTjw3hk46AGZWoMW2U6q7OZW7HW91Vi1FYW+MSDPwIwXL5I3dXsvt5Mpt52LPu6fzn9pRwbeHmrDI0cWlMW6iw3H/1+bHqPlzflaByG9cXnBNL21pf9zvLs6JtRYjBNqDadxG8aU7oO2C/xuBll6vv1QMVoCgOEN59HmskEgpiAbPoH3KgiBwaS6kWh0gXC/PxUrm5qVu9i2nb+X+GSqDVVRYJIgqqKCAEG5XiQpFFjQWwrN+NBRO/1e54PsqzzprOryXLC7oSwgyQBExvk1RKCusDLDeOLdCIKzGJ2FyQUkjsR78I4TFGos2IZWRmI2X1zwgJkAGIYMTEVaELlWYUERRP0HQPkB9IUQncOyQYvKUpjI0RXnYEpZGfFoRF0h2pA+ebcMasBK3E0iAsCTWIkSICIU7KhyQYniDBWWQnhUCtHv34gLtia5hfEqk6qzk3PGSa5NOMEaBkP5ciTWOQcJakbF4ZGgn0fiYElS4c3wQOAMTpMwabmVNUz6mKWjc9b2Egpb3hBo3XM2XW9CpDiPcm9DgWEDiOCGILAUVIISgWOpnZENCoOaozleZPjGE1Y3gfTeH21LW9lZJ32Uy/zcF1xpLEicoqVChpF6rMzs7w/z8LIWogDYxWsdo7Z4DKUQD5JkCPwz+r2uhlCmoodFypwt2B1I09dem4yn8X8hSBeFQIsIDfCye1cmCVD7FDyl4BBz4zReCK8OxE/oy0/CidXQWSimfHs2z0Vjj1xl3vckDUIQrI47jBQCKriAimlNVWc820wq2yYORtHV6lrFgjbPplVKNuW9M8xzxL/kWDSRfOniIRpq+qLlur1MK0fQ85jWOVrugwWKTgmrceWkZ6akpo49AY6Txej0oEaBkkaBsGNgL1dkahXWCMCgAjgnHXavJAvfW+hRtiU8R5uakA/5IBDJj6UmZK4WQKD9XVKAIVICSfp64wQQhsimDadbRujF7pqm6Uu6XFBwF1gNAEjCa2fnzxLWIyA44BhsaPGypftioMP2veT6l/IKNFWRhSh/oPYjR+ahoOrKcgEjY/wJROaFvbBilNpLogDTVrvW9FtYghFvX3aPpn02EGw8LKowYGRnjZFRgrksbuqVUAlYVNLOa0ghb2pZj7c9NLZVWu2cl9Xe/w+1ZLReTRc9fBdXw5x0sk79KtHzqfl5vZf48ynJt5cWfo6WUf2F8KL2euxzwxMWbLxeitkvNQ3KxpDGWKxnVnwY/yJpcOOn29NgezlmurNtwjqBQRZuAQqFEGBa9r8Pbc95+EEI5nwTOH3L06TpJ3PuM7RuepTI0i9YWkEgZEURlVBBhEsPJQwK9SHaWC/F8dHvuuvmqVWBZv30SqcBYiSAgCEsglAeuC0r9RccuIx3QXWtJoi3W1tAmcf90jLUxQmiCQBFFuPS43gaXVng/lNP6seAN2oYTaE1WLIsCZkZHRxkYGGBubo7Dhw+TJAkppe7Q0BBXXnkl69evp1hcMmcH1lqq1Sqf/exnefbZZ7n55pvZuXMnQRBw1113cf/999Pf38/b3vY2xsbGCIJl7CIUYGSIydHBGk/rf+LkKV544RjgmGj27d+PFgFGtu44XGT5MXXMuQd46OALHDquqVy+mwO3v5e3vXobE32Bc/YlglLfCFtKQKgg0cQzL/LivZ/k7z74Yb5/okBh026u2j/KsDnDMw8+xP2fO8G0KBNt2MFlNxaZP/hFPv3PH+GTP3qRyYGtXPGql7M+mOSFg49x5Pt38olzVcz2q9n5+gmiQ9/jO5/9KP/wsXs5Em7h6ptuYM8GzeQTD/HIvY/zwrMBR07XmK2bDgtBndkTT/DIFz7Ef/rHH/BCaRfb9h7gZRMSe/Ig99z9Tb70kTJ9o+vYvWcjByr5MVKU+ofZdMUVrL/7UeanD/Pkfd/lyxsUM/u2MjE2zvr1FfoqnjlHSERlHRt3HuDauRG2BQJbPc/JJx7g4We+y9e+upHy5qt58xXbGhNWDjK8aTfX3byf9VJQvHwfV0wYzh66h2/8w9/w9188jdh2gMtfsZmNhRnOP/Mgd/3gY3xMbmF0bIIrbl7lV4ooEfVt49o3XMfmSoG+zTdw9c4SyfmnuOsjH+Qjn36ap9nEtmuu5jXrFbOH7uO+R7/Bl2tlbP8ObrryJsZkO3L8NVmTNbnY0l7HaDimO1y1zLraACi6VeTTA9nU2WtTda5VrRPZ+dlxmz8r3ZGaOvW9U1hYhBQMrrcMjc1jZ85y+thwW8DMhXJuLqjnApUrcn8FDee6izOI3G/NI9xNeV7oCm8BkrQ6nJu+tIZhGkwnNvvWuR8Lv7f71FlE01//v20+0hgrmo6l87JxfGHdvbVm8bstmlrorpDWhakSf9DY5czPZkdq5xHvXsKl4hIKSlMMbH4IqxRB6LQna9wu8ihSFKMC02GzXr28AFB7Wc1x+Fl0Fg2O1dm4e46wGBIUQsKwhJARLo2CZw0Q+eBpy/qePZurPzJt30sZy0LD/TexveS/29zz5hhk3LMgSIE91goQCml88EqUGZyoMjihkVJirCIII6SKsAQYIZHSUij2EYb1Be25UKITyfEjboPGuq1n2FSYp1AsEhX7McYSJwnaQKgihHQpLly83gWSkQ4oYPHHhR9PIxgYDxleHyARJDrBsbppD4rSxHGNJNEIEs4fDzjn2Wi0MWAVUimMts3lI7A2/35ueccIMsYYxxQRkySxT3PjgTH+3tqUJcS6fjVLJx3IZkH8pUq2xgrr2pAGc00KHHD6iJAKYwX1OEFWq4SBRCcQhiXWbY4ZXDfN9LlZ5s4MkrRJv7Xw3bP8ZyZ9B/rkO+6zTY85oCh+Q4XRhlq1RnV+DjAoKTAm8aANmznOjBVZ2pl8kDZlx8goT2wjFJ6+Bxekr+nmJMt+cgAYmaUv82MtJGkKHqcPeviHNVifXkhK5Z9f90/g2i5F4/6llVlrUFISBkGWTi5lLEnflhkownfWGkNikywNUz5FUStgJp++KgUE5dOApeCY9Nw844y1TZpvVqbJI1Byw5aCNvJgjeaBdemQhEeAGaP9EMk2Or1tsNa41uXKsY1DtpEyK8PC5QEKFqRUTSAhAGNqmZ4vpUUikEHA0AGYnUkcqEVGGN28PlijAdFgktEWo/EALoFAZcxBDqwjAeXmvpQEoQdGSRogvtSJ65+ZFDRjaGxky9KFtfQjA4MJ15fUhknvgUWghGNYMSZmvjZNEldQDPlWuefI+AsznVo07mGm74mGvt1el89/F9ndandOZ2mdM0u/OgWiApRHjjO8MWF0tIKSBeLYQ/KF8eAYn47Kv58c3NJ9BuHB5SCkpFQpEwS5tFpLSKkEDX27nd693LJWU9L7ln9227eqGda/ACS0jDq7Xb+Uni7p3CWM4fIspYYsXddf/ph2k177sfLZ1d3S6+XJ/lmzZ5YqS7WVW5+lbtd2eq57O6+XdqxclqOJrqZ93nttP+8zdXWl3T3sdYRXcu2a/PRLL/d65e/mZlm3+Tz9o/MY+iiVCxQKCmtD8AyTSIU1OHvCeKB93fLikXhJgJmhiZiNl81Sr4O1AUEoiYoQhJBUE848H6CT1Vp9lyZL8Z+nn1Ro2LpnjrAo0NZt8IkKCmSANhZtHJNurCOEdEB3l3q6RpzU0bpOousYU8faBIkgCEOiyKVeEjIgUCFBmvY2ywIgyNLVXirO6J8BWRSBUi6XednLXkaxWORTn/oUp06dQmtNX18fV155JW9/+9sZHBxsyk/cqwghKJVKnD17lu9973tUq1Xe+ta3Mjw8zNe+9jUef/xxXv7yl3PHHXdQKpWW1cGLIlpjTjzPyZlZJk2R/qFx9u7fRilUfq5qatOneOHxhzk0aZHrLmfntnEGTx7m4c9+nB8dm2N6/HW87bd/l9//zZvYMfsQn/zjD/AfvnaYx++7j+98+yF+Zf8VPP/5j3HPk89zrHQ1N73lN/m3/+a9XF98nm/8uz/kP/7z1/nq4Yf5/Kd+xG+98vXM/+Cb3HffQzwjNjFx/fv5n/+v3+OVG09w7wf/nA8efoIXphfpk53k5HOP8pWPfpsj05L1v/gbvPfXb+c91ybMHvkKf/Zbf8aXj/yYgwdv5r5jr+PAZXmoR8DQ5st5xbs/wG0P/AVfeuQFDn7lP/HoN/6Zv96wn1e8/nbe/o438pprdrNjpEgoI2zxZbztDw5w2+wMszNTnDt1nFNf/9/4X/7zPfz4+Isce+YIp+02xrMqNrPjZe/mDz/4B7wmhKIAO30fd3/mR3z8i89zrr6V1/3Kv+L9b38tryk9w9Hv/TW/98ef5rF7f8zBgzdy+FWXs2k154AaprL+dfzW//6veeOWISYkUH2O0wc/xic+/ySHjpfZ8avv4r2/935+bXud2fv/b/7kX3+CLz/2OE/9+Cc8Ft/EKyNQa4vbmqzJSyz5sH+73zrJ6pktvTDPiCxA1aHeltgqmCwg4xzYDYevRYBVCFvw3wxSRsjAoqOEoIALcmjpUiX02g/vsBO5urqd1/p7+6MLu9fL8VZJe+ECXPngl/u1NZSRpfvJtbnxfaGJ4oJRadBLoPBIcBa6IfLlNNXhv7u6BUa07JDt0q/8917vmLB5IExG2J471nxOvr72LDnt2rVYa7oBANqXktatyF3qizEtTDO9O5wuEEX6RRRrHCuDRIKyBEqigoBASQpBH6WwSKgKq+4AvFDSHIq9NGS5fVYB9A+NMDq+DiuKxLqI9qkx3G7wtHCRi9u21HaR/ZmNAEzLU5LFdxe2r3GFQQiJFNKztIBSFYKg7NlPJPV67F5N2iBEQiAUQloXhH6J0pYm9XniuSkYqCF0ARNbrLZIETiQg419UN7BJVzQ2K2cDnjggETWGh8sNhijiZOExLjULchc2kNTQgUFSoUQ3S8IIrffPwhCxz5k8KllfCBeNsX1G5IF1336JuuAMtVqlWp13qWX8o4VF4CWOUyGa0samG9OndNulGzueJtgaRddpglo08JU4NLliIxWWGOJkyr1WpXq3DSFQoFCqUixWKBUHiGQ/UTFtD+eHUVKkjod2rf0B8ePjPtn8wwzAqkMUkIYSkIVOhbd6Tmqc/NgoBAWnG4nhXsOZCMNjdCiqTnCNsLigpRppoFgEhnAqJG6qGu78yw0nglHSg+OSVLmCUjiGmEY+FQ6AmM0iXZsMFaAlAFB0Ly1IwWTZIAfkc47SSCCbB5ljEbaI8wyIAwZO4q1Fm00OjEUi8Ws3SnwJQ+QyerPgSvyKaBSPTpNAZW2ocE44+a/FOnz58Ro3QTgSO97M4Cmne5tcSnpyEAzjfHwGmZuIcvfsmbgT2oD4NfMhVpcPk1TEARNoBxjNUkyT5LEfpMbfmeiS5EkCDHaojUZIwwIlFAY48YqiY0HzLn6pXTAHJsB69LUSopARQ60I0Epn+pRWPDrnutQ+kz9O0YAACAASURBVHaQbSOlnVLHNQ5aPBcQYDE+xay1FhkoSpWIWj3Boh0omIa+mt6/VJ/Na9vpJ5Pp8+00+lb2j3YwiMXF1dyqxSxdg8i3sFwZZHxdmcGh9dTqBghIrS0hPHsV0o2lds+ayqwTEMLx7mAT5muzaF0C3KbBlC2mG/CiV1aYpTLPtCu3o1UgExwwiEznyCxOK7GmeRNkevfalbfUu7GYpWKbaupmBzfbG0sGsHS4B11Ug+XVs8jx7rZf85Ge7dJF6u7UooXaavPx5UhrWYtBMC6cat7bs7H6Na1clnrfO82X9uUsdkd6l4vlju/m8ehFFrt25fev00gsp+TlvfNWQ5Zb68rHb/ESVmLKt+vXUsppvf5S8a2syerIsuaUtASBe1aNLBP1jRMV12MISLRCpFSj4OxQJFgH3EAkzFanu75ppbKoAMiBPEqVdQwMrSdOwKIcSYaN0fEMNqkCfavax9UUISAItPOneHstiBRGjSHCiECEIAISFBiLsY69M441SeI3zxjh7dME4zeMOJZU0AakENTimJnZc0ipKBSKlEoVyrJMoJRjh003HUlvW68FlVdNeqJsKRaL7N27l/e85z187GMfY3Z2lhtvvJFbbrll2WAZcEZxsVjkjjvu4NixYzzxxBN86EMf4sCBAzz66KNs3LiRW2+9laGhoWXXcdHE5hyGouUFZOc49dT3+dy/+SP+5mFNePMf81+97xd4Q/kkB584QS2xjF11I3v3XsHu/gqh2sXrX3c1H3nwDI+9cIJzzz7J0/MjPH3wRc5P1+nffQWXXf9yrhoMCcUWbrhhP3vueZivfmeKmSce4fD8AaaeP82pM3MURyfY/sqb2TdUoH8p9CXJaabOPc/BQwlxYjn8+X/Ln337L/nLAthkjnOnzjOXVFk3Nc2Zs4ZWbhRRnmB4/6/yJx+8htu++w2+861v8d0fP8KDR37Mtz/8KD/59ne5/f2/xfve90u8eqRG7dmv85EP/TOf+daDPPbiDDWt0fPnODddQ4/FJLUaVdt9UTRnTjB59AhPVhMS8xzf/svf594PFSmKGF2d4tS5eWJ1hqmpKc7O2dUFzLRrz+wU1UMHeXK2znQ8zUN3/gX/6zc/xF8EFlOb5Oy5WeZMxPzUGY5PW/RI68RZkzVZk4stjd2WTolpOLvdsc7Xre7D2ykAspx6LGBkfgGVvpMKKZQ7bAzW7zZ1jsYErCAsJlx58yQ2mePYU/0ce2q4rXOum/NxMYdqu7BDuxJX06mQN9tTZ3oaBIOFBmw2Lv7/vHO9tXzp/ykrCax0YBlAIZFZcNmXIRqOe2ObHfZpHZaUGc9gEDmwToc50sbBJGwDALNwVJqDCulZKdPOguMLruok3dyo3aTz+aLLZ4sg8MENYY1jm7HNoJnVcJJ3E9HyNy8X26gLAsVAuYKUiiCQSOUCXyYp8NSPrkXXiyRx0Ka1XQIkXX+9eLISB9Nqt2E5ctm1lomtIdoWMInLX+xYWRzrx6UxyqsjjbVDkKYxElYjrMIag7Yai0WKgk/5gQu+S8N8dYpQ1v0CfPHtwMlTm5g9v4FDKgRRA1I/UQxUF5wfFSX7X1smKCjwqxH4tdpqn+IlBuECy9porEmZGgRJDQKl0LUElOHqVyusEISVAKxLyRQEQZY2psHWoXOt8Ku09YwauJRO9XqNarVKkjiGibROrHv35N86qynNgBu74Fg7abX5M1CED/fqWDAb15idqxOEIf39JYaG+9l/Sx2JYWbqLFbPMz6ygbu+ElCbz5XF0nqZf85bwTLpd2EFg7tOMbghpK9/GCEUtVqN+fl5jDFEUdQE/GhNE5SmJnJ+SOPxJP4tb9P+51piF66ArWObZ2aBBvOKYzMSaF1vOg9cempjDPVanB1XQeihOhIhFUKoLC2ZlI5xRqkGUEVIQRA4VhkTOzYdnegmxhjHKGXQifE+E0Hsz5VSEoZhE/CltZ1pP1vBXFYvHF8hBFIox1SERKb6qAcTaCuaJsPCdEit0lmvcdXm0yWl6cGcBpgB04Sb41L4NdGnwkrngRQSqSShkg32lxRQ5B2pSknCMPCp4hrjr6RAFcpIWcPaGkmSoLUlSVxqnjCM3I5EqXzKKgBn72itSZLE2z6yCbCkjfGAR7cGhWHo+5WmmHKOcCESrF/TSYFv1ulnUgQI0RtbdJOtI8DaFEjTPPZJopmcnGN29izT0zPEsU81lQN3p09PeidM7nirrp2/uw19p3061VzzMum2rjTrTwuD673qFGkZsUlISLDSYJV281wIb09YEmPAOAYygUAYB5oRUtLYPxET63mOHn2GufkdwFCjnsVst6WwmLRuoGj53kt/20lh7AFU8YRbM6U7W3imp2RugvnjN7a9brFaVxImzs+hxn1tf4db7bhO5fcETFr0eHubdbnlLl26W43d7kkvlmZ3Wf1NEO28FKsH2eit1gtpKax22csByyy0qXtJ7Lx0+dlxv/d211Zuy/f61muVpbzplicXwqez9LFa+hWr5V/p5n/q5b33s+N9WJPlyOBoncuumwJZIiqPYlUfNV1EqchvwEnAp3B1BgrU4zqBCpDpxs4uk2jDriqbrrBIOYogwlpFWJAYa1HKuLJ1jNCzBMk0SVIFW6ZdHo4L+Y5aTJdPJYw0l7/8KOXKEEEwiBAFrA0Ii8NoY52NK0HbhOrcHLValXqthtHpJhDp7SzrN6kkGO1tKL9cWuVqTX1oSaKZm3OpqIvFElFUJAjChn/I0DVmtSZLk56sViEE5XKZnTt3cscddxDHMRs3bmRsbGzFQBYhBK94xSt44IEHePLJJ/nwhz/M0NAQzz77LG9961u59dZbHWJtmWK05vypY8xVG3Te1hoqpSJXXXUVO3buACAMQzZu2MDoYJm+vqipjDBYpI9KIcfWM1wqURFVZiZP8+TBF6hevYmBgkvJpON5Zs4c58RxTXhuhplqjC4m1OvO6aQKJbf7R0qEDCmXIwIlIUnQcZ261dTqzokhw4iwWKQgBYKQYjEiigKXGqpeJ7YJtTghSSyiEBCVKhSUWJqr2SbopE41BmtDhrfuYdeWCTb25R0YIVtvuJxdw21KFgGqOMTYtqt4+RvH2XHtLbzh2YM8df/X+ae//RwPPfsjvveDA2y5cj/X3VTlu3/3N9z5hft4YGac0ctv5vV7+gme/z5fuesQz1oLPlDoym4Yn02LmXZjVbMSK4fZdMWVbNswzGC+ecF2rt+3hbFg9dSpLIBoW5JmGIOtVakaixH9jG7Zze4rtrAuP53VBNuu3sOmUKylY1qTNbkEpFavMT8/6wIFSnnE9GJKh8gc3a3SKTCUd/an79F8YCPvLO70uZd6st9Fw1zK4gX4XfDGUXYL4ajb3W5OgZARgein3C8xOkYVZM+7/hb7rfN5y3PoLV5vc7l5Izh1iLu0ImSgGWh2eGYliPYJklJXoEQQWEloJQUriVBZYA1SxhjvnLfuu8FkDuxmZ6twe2qtxfjP7vwGaKaVQyXvYMpSTdkstLHAIGg1pMWCkvJB79b+NpfVbkRWKq2ldHO2WlwQM0BCB9BMq7Q/3hwg6WUu9uqAv1jOCCUV5VLR3XuV9scQJ5b6XJG4lk+lunxn/EspL5VzZ6UzOypHqGIBawtYAhyIccFK8zMhNgsEQ7a5wEq3cllw7AOu78Kfa60hjhOmZ6aQzFOdLwGVi952owPqGRal9b60CZcY9yYR0BQIt0b7tVdmVxoLwqTpbaR7TiOBFCCMJixApSKJjYbApWOy/p0N+NQ+KRtdix3m3ytSSkeRrDXaO2dcsFx6J417tywWi2sFJ3Q6Z7G5266cPMtMb4Bg/xbzgeEkSZibr1IoRgQFSRSGzMwZZudmmZybwtgh7DLBVoLGe9QBZXKgGRrsdAKBCA1hRRCWUmrlOEsBtADA0eI7cY4ynyDILtTnHIDGt0Q064qtY55nR3EsMrYFoGMxJs4ALynDixBpeSKrK4UYKOnot12gPQXiNJgQtdak6eOUD8ZrnThAV+LmHgifPsgzvaTPlRUYjyIJgtCPjW07V/Lpl1rTM6XjlKVIa7qD3r8L5FMhWb/mtpt3ned7nvWLBshFiuy5klJk458fy7RuISAMQlTgqLqFd2xIQRNwRckAJQRKyQwIIRLQ2qW6Ukr6dzs+xZch0Zo4jtE68c+88tdLd51SgPL33K0BSeJ2PLqNAsa3tfkeBEohZZDZRW5uNeajkMaDZRKs0Fjj2jFfrZLEhlKxQqFQRinpV0hLuyFuvRfZ9wx8ZJG4MtyoJgiEB/E4MFDidXnhU9Wlqc3Sp85aN9bg9Gppwfjv2f1vng0tn5t5Q5byxu7mkG9ND9bumrxUq9PMzFQpV0YIwiLaGIyVWOFSrQlH34Yn/EEKSyAlia45K0JUScw0s7Onqc6fx+h4CT1ZnvTKSNPxt9z/ACqsowrV7P2TbnoRUmDrcU+6Wlc7tkd2nHYAoIUa3WLWaW/j0720Tr8vX6/sNmcXG5nmGZ3evdSiXKTeLuOeH6fWMV6oiVw8xtA2WuECS3q1Sv9pshR6tY9pmRu9+B66yWrY7hdKVnr/2s211Sz/UpaX6p71JpfeyOf9T93G7tJr+ZpcbAnCiP7hEQwFkEX3V/jNdda6P5lp5Tc9KKdzmiZNu72oMKRYCVGqgjESIRRSaAQO5B/XZrG2RmDmkWYWdA0YXVDOas3Vbj7lnq6XgmJ/mUK5hDWKJDEu5XZc8F5XjdZ1avE887PTxPUaRmuw+I0cnj/TOAZWt5HKgLchpVKOZVY07E1rLLFxrMxCOPbPJElQSqJUgBCQJBden/95kd62eeACepVKhQMHDmCtJQxDv7tk5TI+Ps4rX/lKHn74YT75yU8CsG/fPq6//np27dq1orLjep2f3P1Dzk82chCFUcS+vXvYdcU+l38NUFKyfmyIHRtG6K80p38qFxYZJhkiR/ezZ8c6tow8yb3Hn+HhL3+cr+y+g9fs38LGAcsC7V0UKBYHWD/RT6AmmX7hMMePn+BUdYSR6mkOHnyByel5RF8/5eFx1oV9zEwMUiycpnr6BKeeO8IL89vZHExy5Mgxjp+chMIIhfH1jIb9hINlKuWAeGqS008/xrPnt1Kxs1SrNapJc/OzXVvGYOemmKvF1ChTKA0yNiSQpyAY2s2Vr76FN1y3kaEQMHVmq4LBTZexY2Lhwmhrs9TOH+fZaj8jI5vYPrGDnbu3sHvdFPfc+VWePn2OEy++yJHnjlO7ZpoHf3A/Tx45j7z6Ddz41t/gN28swD1neOLpExw94wdOgCgUiaREmTlq85OcOm8woz6IWypTGBxiVMF5I+nf9jJe/gs38ortAxQw2HiGObOO9bt2s6UwTSJ8znU7R7VaZXbOQF/OwRXXiOdnmdZgO6z9IowIwpDQ1qnVz3LqfEJ9vcVGYIOQYGSM0VARSUlp/HL2vObNvOXKMYoSiGepmT7KY9u4rASriOFZkzVZk2VKtTrPfHWOKIqQSqCNc862o4LPS+o4Xorknf/pumOtJYkNJ4/UGV4fUh4IFpyb/95zXSZ1NjfYQyQaYzTSGg+WcchuF7R0mpmhiCEhMSGmxXl1IY395Za9mDvStjlihcDrou5V7dMddHKEtwsLNsApzsknraM+D5AUUARuFgEutUSCyYAvEkiQ3nWfdxuJtIWeiL6xc9RgMSL9reEMbGpH+jkX5Mv/vrAvi7lfmvvbes6FCPX3CpZp/T0PmtE9gGby1zccCj6ow+J9W4oz72JBIurzFU4d2eUNKh+isgYdK4xWtHPnd5JL2YlyscZzpVLqs6zbahAyojhYxIoCoLBCImwDVPLT0JelickcK7bhZfHAgPR7Guzyn/2umyh0gK/hdZZktsapY4WXqhNdZXAsYWgdRMUiCO1YOGziui4Ex56uomPL8LhicF3gVmPrU8jgQyrWgpUoAVKB9L/MzExCKImKBcIwQiA9aMb6wLzKea8a4yukQQrcbiUPmHCBbuEBNIkbf2vdu93mw0o+sLUISCa9b72BaTqV13x9Pt1Mu9rAsZgIgWNdM4ZqVXP2vCEIJIUoxBBSqoyiojIbdguMwQf48UwmFil8SiJrQBjq8QxTJ/uoz7tNM+lINrPKOI4b4YPsUTmhvH6ORFtKgyFhWAQE9XqNer2e9aM1xUwrGMQY40EjeWkYng2mEjKQWbeVojUtUWPsHcBW4IPKQjXprS7tTlarZ0EJPFjGp8ExLtWLc96lGoSby1IKLCZji8GAMH4URcqg0wC1GJN/7l0fU5adXvrWDJpJr7fNoBjbmNPNc8rX1WEcO+rYtlnnceMkHKhICIRnjkl3Xnr4OUKCy37kgC5RFHjwitfHBN5ZGhMnCY71xdsdNoWHpP1wmp82CSTWzw+LsSZjnbIpVTpundU6fcc4YI3I9dGadCzzwC4ylhkHhAozQFADNJWWYQENIsGYOueftcxPG5LEUq8JtBZM7LZEBYO1msUc6m3uRtN9sX79tN45L4Qiior0VfqpFwrEZCsT0uvNwgqkcLNfQhNoxtIAbfam8zW0xMUCUIv1qr11stDWalfH/LlxTh6CuVOCMKyhDRRHJgnLCYVCif7yEFKG6Bjm56aJa9MEAcRJgtYJiZmnrqeo1c9j7DS2ians4kgrIKXbpgy74AggDFKmjEgN5hwhwMjetqK13uul3s98mxf0Z5Hymvp3CYJlWiU/Vr2OU6cZ3Xp8Kc9S+3Rg7WbIS59ed3VWi5e6FxdORMsnkfu2cOPO0su+FEfuQvrPVqP8S1ku7XDJykb+Qs/XZh9Xs/wsz5k1aS+Fcp3B8Sm0VhSKfQRBmfJgASsDHKOL8r5rDUb7SeJsZoTBpEBhQqdzG4EMFJsvL5LUNdYkCOEYMY0FhGJoooiQAUaADCxxfZrp05rZMwZrY5LY6aHShkhbQcdFdLLQZljOs1Io1xkenwYkxWIxY9pMdIy1mrMv9lGbW4hvqAzNUBmewVG9KIKwDCIg0YBImK8raknNxdKNxFhBomPPzpmQxHXvF6hhjHYgdomnlvdbX1O/gMl5c6xwLJEIb7A4f4+l4VOoVufROiEIAqy1VCoVtNbEcX1BP9ZkedIzYAackVoqlRY/cYkihODqq6/mTW96E3fddRdTU1PccsstXHfddRSLxcUL6CL1OOb+++7j5Omz2bFKpcLOnTtZt3mcYrkfACUFIwMFNoz1M1yJOhXXoQMBlPdx/Suv5b4nD3HwR89z5Jv/wN8N1XjxFVdwxXrJ1JOP8PSkIbFpduAC/SMb2HvDATb84C4OPX0X93xnnM9WjrKl9hRf++ZBjp61DO3Zzo59e9haGqV4w1VsuesUTz73OAe//3nu3KfZF73I3d94gIePzFIc3cfOG65hc2mU+PKdbNkyRvSjYxy969N8+guWZwaPcfCRIxyds7k3pSAoFCiUS4Q2oXrmcR564HEO7DjAhrEdXHftBF/79ilmz55hcnKWGoowFJjaHElhM0NDo2webH3tGqrnjvLsDz7NJ54dYmLDBBNDZYrmHOeff47TVU1MQFQsUCorICZOwFhBEIZEYQCeErhpIZQKObKekb4S/eIEZ194hB986VuMbpFExQk2jZUZ2Ho5128u8cLRGc6dnmRqOsbIgFAm1Kt1gnUbGRoZY7Q4z6lyP5VAENizvPj04zz0kye46sZxSpU+CmGAnD3BqcOP8v27n2H0hnXEbVZlMTDKQP8Aw8Ecz00/xT3f+C4bj42wcWCIgQHJpq1Xc/22QQ5PnWd2cpKzZ+ZJZEgYGHQ9QfUP0TexmfXRpa4Arsma/HxI7BUaRzEfeAVGetrzdk7edo75xSXvjG/dKZvUDc89NkdQKBKVIfC7UHvZ5d22LiuQBKSREFezQaCRJgY0kgRsFWtiLBohJUYU0VQAgbYBxqqOymlbR+YishrGWXeHdvc6bP6snObtXPDN1xr/r92GtwYIJd2BvlCUFZnZoXzgJnEJljxoxmCgydGalpuLX+XaJjxwpsGM0+iKoBF+avAapEG/VpaZ5jFpjFsj9VPz8dZRbQeesQvOWpq0a5/o8Fu7etw4u8BKRsBv86CZzq3LOxQaYarVdSXkbtcFk+pMmReeaAaddwpBt5PVvn8rkcXacqHGczWdV+UBy46rLUIFWBFiCLzhC1ZoxIqfmktUhAWRkIcguMUshxAS6Qd3vgCUCumrjBCIOgPFaQJb59SxFTSjw/HVGPHhdZqd+y0qUszXNA4cZLA2QZqA5x6fpzZn2bE/YmDMQy6kS9FnfADbYhBCO1CLAIwmrteYmT0LSlA0ZcrlPqKwiEvN5FKiGCNAuMA71pXthtqlYAGXSiplvNDaZowzDRBGgzUjZQ/JM500dI92rtb8b13Wky6MIZ3Ob3MUKwQCBzCxxr2ZtbFMTdecY05KKuUKA33DFEoF1l8Wo0JJELrnrV6DODaEMnDjbmKkMkzPTFObLRLPR1kP82AZ5T8r23inRpWY/l1nSLSiWO5HBRFaG2o1B5hpsPmk+ckb//KAFus5VNO3UyPw2wBAWdNwkKXMct1IftM6pJQZo00KtBLSAzoctaCrE4FUCqNtxmijVICUngErXav8b9I3zV3nPlurSRLHbmINCCtRIkC0Mt148IxjRbGoIPBttnhNi3xYNttVlwPK5MexIbJp3qb0OU1sjqIBKE51m07zstP8TLWCFDgihUT64HweluzYIsnARDJw9yJQiiDw7D449JCUknpcJ0lqWWoqa7XLYZ/DMeQBQ3Gc3ieV3WM3ho7pRwqZ7VpM29ugAW/809l8dEPm5kyDScal+pFNjDANMJb188rZFImucuoZxdQxn4YK5zcc36L8umI8rXsuLVDP0g7a4JzHSgVUKn3MFCKmSWFKuWfK3xUHTU9fOe4eOL6z5lBSesR9bqcJtA87rTQk3su1aUviya2cnbScBSxuN+noZccojUxTLg8QyYRCWCapW2anTzAzc4IgMmhtqNfr1OpzxGYWpRKUSnBpIS+cP2opZbeHQrQpT1qkskgBKnArtpvLxqU888CKdmwlrSwlqyUL0k+11LGgbz2mOe5a5xJLWIk+tJyxah2DhjW5kPV0KaAZaB6/fPtfeqhMQxr9b12/er2yl6M/fdIMkcnb+QvTMfXKONSujgs9XhfrfvQyG16KudHJD7Pa0s039NI/E6vTgp+l+frzKMtf1VdfurXFAqW+hC17Z6knIf39A4RRGUsZY1OwsUEQI2yd9O1shXC6ovCsqML5Hpw9JZGBYvveCtbUMaaOwBKGEdpYrN98YSVoqiA11fppTjwvOPFk2dcZIei2OWr5o1fq02zbO4cQIX19BaSw1OsJiYmxxFRny9TmFl7XPzbHhsvOIWxEvQ5RQWJFgVpsqNXrzMwmaF1DCZeOWAhBEs8Qx4lLSZxolyYptS8EPhd2gzcenM/B76wA77m3foOJFM4Od/tMHAONEI5ZxlpDksQYo4migFq9ThyvMcysliwJMHMhZXx8nJtuuol3vvOdPPDAA7z5zW/myiuvfKmb1aNIEAPsf/O7uO3EJM8dvZNvPvcUP/z7/4nv/a1X/b2zR4iQwSAgUIq+DdvZd/u7ufULh5h77AG+/Y8P8d1/UpRkjZmaIOi7nNe+/EZuveVKhkuGwTe9m1d/5yjPHbuXR775N/zRd/6ePlllPgYKm7ji+ut52ztuZLxcpHzTL3D9A4e468Gv8tCTn+Q//NefcF4QozHaEg56l44QFEfWMbZ5KxtLD/L8uW/ykb8cIIh+l//ynfu57Vdfx2cOfomHj3yVT//VN/jcX0f0lQTVmVm45l/y+//qfezaNcpA04pcZ/LFx/nhR/9P/uOXz3BqzhngCFzqDxkQFjdw/eWXcfX+yygWSuzdt451z03xwI8/w8eeuZufbB2hOHWIgy/MYPsCVCCRKkJtvoa92zewfegQdz/6Rf72X36XzwxAvOXdfOD33sVv3PAq3nX75/nJx57i6Pf+lr/5/j/xt4WIskqYnU3Y8d6/5L/5rXdw+Q0Voomd7F7Xz6NnT/L41z7OR2PB8OY/4T2bd7N+9G4G9TM89YNP8e/+pMLG/++321IHy4nL2bp9B/vGv8+hYw/wqf/xd/h2v0Suv5mbbv8X/Pv/7mbe/ksHeGz6Xr7/+Jf5zGNf43N/VaY/TKhWE8Zu/l1++bf/kJft2LSWkmlN1uQSkCRJqNeqjnFFOmo7pTqZLw0zrROQpWMKJSC/qGits8CKkIIwEmidEMeN3ZytO5R7rQtACeWcR96xjTVYU8eaOkm9RhLPY80sUmiMjUm0QVNGRpJynyWKikRFRVhI63b/tJYY3dm8u3hG2eKusU6/ZymShHO8u52ooBSoIDURDCbxO6NpOPUEZDvPW1lcNJZEGOpWI4QghCzYpizOyACstMgQlN+RnDqQUtBO5kAUFiwksWONSZ3/LpDk+iIUSOW+KPxueC0hkR7Ik28jNEI/DfdlI4jUSP/UGKMUpNMewGKzvwtpsVfiUBFdv3W+9woB1u0xFsKgLWjRHArpVF+z4zb3rPfUxt7kYjhG8nUtJqvRlovhJOt2D5bah6W2d7n9c6k6ArdmChzrjxV+l0mS7dT52ZMcmCKj0ZENUIbw3Fm54H22jhgFKiQMyy717DKl3XrXqGcVwio+mBwnBhUUMT41kwzAxDFBCKbgU6vkFhZjjU+j4VbVMJCECrDGpVRJNFEQOqBfoklqdQphEakCpAhwmBcfuLYpG0WWeAQh8LuOnDMmjuskifZ6DRm4QGvjA+3gwD4s0DeaUy7lw1/pbz3my3bKj1tfRQY9oOnJte1THgpfV2LB+PeqCiRSgLYa6XN7T05OMT9XpVKuEChFoVghSPAggALKaAIVeoYei1KaOK5RKITUItcVmwiUlbl3e/O7XgBWG+q1OoXSICBJYo1JEur1OlprD7R2PXRgJZ0BHPJgpHx6S3hRtQAAIABJREFULDeeotFj63Kbu/va+kbqrHe2gqwddkQ0jW2+zhQ4kWcQaYBU/HEpERJc6h6f0km6dhidkCQJ2mgELoUP1gNtfJ3WA1iyNqRMr372SNJ2p3OpmblRa90EGEn76trZnEYoGxnfR4EDkwjpRi3Tr2x+BRDZPXGum4WrvZuzeZYV4RmPPCjKGqRUnsWk0UalFCpQrj0pOwyNZ0tJiTEJQkKkXAo2BzxK+5RLwWU906AHDYVhkKWzcuMnCFRAGIYYY3yKJr0AZJRnisEDZYSQWWqjxvwV3j+bPu/p/HFlCYdDQhtNrV7DmKK7mxJk4K4LQuE2IqTlLJUlM9X0cixl2R/hgIBBUCSIJIQ+XZ2OEFY26erWAzJbdTyvXjcV3bzKtddCWo8u1B0X61daWh4ev7CE7hZWbqZqTX1unvpcTH02oVIexCSSWn0aY+sg6mgTk5g6hqoHaUbONBQJQtUb/dBh1o6lpCXq1u6m7wLCEKzV/rUgsEkeUmHbX5eTMCihZJEkMQ6ElaU9lBijugfSuzDbNLW5R92seRWhLdtML2UvzZZdXa1dLDLTVirtZnYraGZJ5XW8N5emPt3ypllRGZ1kKWN5MUapM8hBLPi9VU9vrM8rsyy72Ya9rtftWY0uvPT6vC+lZSvvxeJrc/74avgF2r1rO31fzfXqpZAL5Ru6NFfFnx3Jaae5Twuf4E7Pw2rdn8b62a4miwyc3l4slxgY3kxiCkTRINYU0YnyDUm3imqwGiGMS/eZ3xYqfC3eTnD2kQPYO3+0Z9SlgBKGxCZuU4bWaFulGs8wN32WuFYGyj1qAo1xDXw/Gr4lS5J4O0OCCprtxEKpTKV/K0pECBkQ1zXGakplhZSGQiFGKutSBgsIQmcfF4oVyuUQbMTU1HlqdUhsQhxrtNGoLCWvQZs6AtBxQr3uGHMEkkBFpNzBafvzn1LGzrxdnmrB2iTO10NjM5MApFKEYeDq0wmJTpieniLRyVpKplWUSwYwA7B7927+9E//lHq9ztDQ0AVhs7mQIoeu4db3/gEb91zHjXd+lq/e/QhPvXCWs7MxWhYo9Y8yvnk31163m10b+pGFAQYvewd//OcFtn34E3z+W/fzyPOTzKkxNl51A69716/zjje9mtdsj0CBHH8dv/6HMLH7Tj7x2e/woyeOM2UqjOy6hhtuewdvfftbeNveIpVAINffzJvfV2Fi2x7u/NLdPHZ8HvrL1E8+x8lnDnNMClToEHBqw/Vc+fr38ifPTfH/fOF+nioPUimWGBu/gnW3/yn/vriLj37qq3zjnid55sQMUzMBxcGtbNswwuhAyMLH0RINrmPT9b/Iq4/fy4NPH+PFc7PM64BoYISJ7ft5+Zt+lbf/0q287sohijLiF3//f+BU30fo//q9PPjcYR657zBShRQGNrFr7+Xs3b2ePhkiitfy5ve/j3qphP3cXTx4dIaz0xVGpUCFBYq7ruKW//av+PMt/8jHv/RD7nrseY5NzjOjyvRv3MXGsQpDBQvBGH0bfpEP/NGT6P/8Zb56v6Uclhla30eh7738+ntmiIIv8sUnQ5L+QUaUZLrdGh5exg1vfCf1uEb1//0yPz5ynpnZIv1GUCqExJVNXP07/wf//YaP8tnPf42v/fhJDp2aZTqJqIxuZWJ8jHWVNfVlTdbkkhEbo+M5qqaGTmpUKv0EpRKCNMAhXAoNoEnl7aTjddP9cjt70yCaBaJywP5bhwgiv3MXl3ogO3cZ3TI6bjjJpfuXmITE1jhxxHLiqTJuJ2gaxHG1BSXYe4sljEpsuhwmNtfRyRxxfZIw0Bw7NMjRp4ba1rlU4335BnX3gGcvzsdULXVKq3PgTVxm2XAFGCTWzvP0j0MmT7Rn2RE0dqI3Ql0u/VKagind+S9dLMYzoFgK6y3Dr3HafRJ7EnmhENbR11tjECJBCQN1ePYbEUlVLJiDFhjYVWfgshr4neSlQsDswTKTjxWbgDJpe6HVEeXYatLxyANmNBZtU04bWmpvFuPLMD3dge6y0Jm28Awfxml7rUr77YP0whq0SPH8nd0SraZuGjRZiaOzUz0XWgtY7Nn6adNC2rshFv8t//tS61qpCCTKFjAmRAhHd9uAleUZWFarxuVJNxazpaYCBBA4ZIZjUbEIoXFED5ZEu10waZA2igoYY9E6cWuUlMSJBBF5gGFtBT1rgBkbR9J1amWgmTiR1HRIqTjkGF8wYOpgXJqgAzdHSFEkDBoBSIsFadwOeYQLFprEh4+qnDtZ57F7FMYMkSoIA6OWnQdmKFRGEFEIQmBljJE1wCKNRFqFsG5uGWMJfD5rIRxgIAzx6ZgaKVocQHghKMZNBcdkkk9tkx7PmDuw5OMIizPhpe8e99mmTjdXbNsNCnnR1kEerAUbu+KUdWnmlAcM2URTnZtDSsn01DxJ4pg2LBCFBYaHhunrqxBGgQM6hf1c/rKQarXKmaMxxx+pZIwykmamtoxhJowYHhyhVBpEhUVmZqpMz0yTJAmFQiEDxiRJkoFl2gE+rJWeQSYdv5axyo1947BLpZnX2RyAoXGeTMEsRru0QYECGTi2E6UaqaAsCBmAcLv/pJINoAQeRAwIfJ3C4kDXxoOtklxKHwFCoX3T0rRjRqfAMDcZrfUb7PyYOsY8r5sYlYE43Bil45Lvs2mwzTjXoZsTns2mAcoBhGo4JH397v1vsNLm6vBgpfTCHCgmm5+eUSZlYhFSZrqdyGwDd54KAwe8l8qta/Nxds8d0M3dN/c8GlQQECjPCGQNKTAntQ1Uzk9tPdjOGgfuN9qQxDFSKcrlUgaEkUoQECCVcKnIZNofN4xuTXYppaR0jm6lpOtPWjENNqS0/Y5xM9XwDNpojBH0lUcIA5dSqjxm2XyDoVQsQ2AyIGEc1wlUoXGDe5IcP4zRucClwBKCrCBkgaHt09j+w5w/+QLJoVcikiLSNrTlhg1lW0pvDbg18Ts2ic3a01l/a7VpFtPzUv1ypTL5/C4Q2wHBOSE9mw9YO0xQKVPa/DCBUm7NVSF6epyZp64CawnGH6Yw/pCzEXWJ6uFXYRPH9N3KmpI/1klaf7UtR6MC7Hut5PzMOUddP13hxUfLtEr+rdQ6Quef3w9iLyk9UtM9NKpn27IdW0k36cXmFC3l9VLH0vSQ5WotC0N67X7L19D6LKxEX1p4T5pBM+nvvTADtW/LpcQt014Ws6EXu+6nWRqer9ZjC/XzbrJU8Eq3NbiXdWKp9a3OvVraGnvh2tG+xF7Lbh7fpXv8Vmq3X5xxWl1vzoXwDV0Mf9OatM4+0eVb87tqMf/V0lrRKV4g2H71LMMbA6JCP1JWCGWINYGzO0QCaGefYLFGYGzJ2yMpaN/Z/CJL/drYqBOEEp1toJG49EEJDpCdcOyJGkcPOsYaawtYswEdy6y13Z71Vq19x9XTjEyAUiWkCEn0PE/cE3HupGJgJGbn1bMYK+nrGyQKC2hrmavWSJJ5tDbZP3M2QSoY2xliZMDJw4owsux51QxW1qhUSliKnDx5lvla3dmiMnAb4YTf1KItRjg2USwY62xptwkq7YDNPqd2hGPi9CmFM1uyMRL+KMJqrG4w0QghEMZSm50HIQiDgGIYUatWHTPoYhNkTXqWlwQwE0URcRzz8MMPdzznzJkzHX/TWlMul5fluL2goopU1u1iz6sGGdp6HTefOs/0XJVaYrFCocKIYnmAkU072LK+HyECZGmE9VfdxjsH9vKKt5/h3GxMIiJKA2Os37aDzRND9Ie+n6rC6GWv4nW/to3LX/tuTk3OU7cBhb4RxjZuYdOm9QxFfrmREI7s5vLXjPB7197O1HxCMnkv3/z4nXzyqaMoNcLEWESxIBHhIGO7XsVtvzvBrrecZUqtZ8vO7awLCxSHt7HvF/4Fv7n7F3jz6Umm52MSK1GFEn2jW9m6bSN9C25DRP/6vVz7zj/gj151lnPTc8zXErQVyKBIsW+IdZu2sWnDKCMFhbQVBnbdwu0f2ME1t5/m7HSVmnZMNEGhRHlwgvENmxgVAimKjO19PW/5wBXsf+Mpzs7V0YQUh7awbdcWxgsDFDdfw6veNciWV/4qpyZnmasbjFBExT6GNu1m+2Y39kFpnJ23/hf8zvY3cMdZgxrayO7hgGK4iQO3vZ+hfbdx+ySY/m3sHx4ifucfM3bD+/gNO8Lg1p2MlAKkkAxsvZ5X/PI46657F6ena8RWEVQmmNi8jY1BRGVkN9fc9uuM7389bz49xUw1RqMICmX6x7ewacvo2qK2JmtyiYg1BmO035WpSRLNzMwsff0DVPr68R5m70iHVQtuNhVjiUqi6R2XOqvTgNJSxQqbBaUy/5Mq+fyddWpzmnZFO+WtjBERMoSgEqF0SFEUwVZR0cJcn61d6qW5y3caNRsbK3XiufRILgygCoriQIAxmrnpKWAA24ELLO9szzvl8wFZg8HgaegzB75jHYjKzqktI98fm2CNpxQXLmepsD4w1KL7iFwwQAUhQVmRTk0RSAiCFvabXPts604umQWa3D83XzQWhSFBoNuGl5vvtrAC4wOxnj8iZ6gv3dnSSdqboc3lO3Ou8exk3D3CAYEWcyHkf218Xo47prP0EkxZLfnpdJZ0Mvs7z6VLzEJwgVapkNalqrAeMucobwMuFSf/hbCtbJrrwzqWk7m5SZIkRghnE5ZKFQ+USWFs0rNuOLCGMQlxstJ8zPlnvdktnwZQlzv+UoEKDFrXsFaihERkuaYhKvmUKda6VEIWrHbvZOPPkRaCQFCdP4+OzzE/B9W5deR3c9Xn54mr5ygUQ5QNEIQuXzaOFiVN62VJvJrinDAutY5jzIvjOMt5nYGArWmky0lHK8eA0n4sGyJEe8fcYsCZ1t9th+Pt603vZeqAEll/ZMb44cAiWFAeuJCCVWr1KnIeIh0QBIpKuZ84qaGiiGQo4hQNsEz6/mh+h4KSIYXCANpK5mfmmZuvYVJdTQha0y+1G+PGPcj3Mv/FLnjnp/12rEA2+1nk9NJWFhE89sFYg9EQeLCHTMdMKFQQZCwlmabg05o4VjsDVvvytdOVrc7ui8h2H0owDpmtPUhJCEGgQlwqoZg0XRTQABOBR9H48bAexuxf3mlKKVcXGXOLwNFU29zwtp9Bzex4C9/u0FCQU7CM9M+P+55PcdV6H7MUTf6cjDUyfT5k41xjTXb/gGx9SJLE99X6C1qYhfJzwTbPoZQdSCeNcbKQsdQACKUIfH/SNdkx5OAAxWSHG+NvcxUicJNBN7XDMfkpsAqD+y0IFeWBIu6ZjNx6aKxnFVrOeyZXf9N9kxgjQSjCYkCxTyLPx7gUQ7ZpxZdWoITXbRes+a0aXgMe3hrc7Rbya7sW9tC7/HW9vYsWao46DoEwKyvJyrOUBkbZvPEaD4xyLF2TxyOee8aBVPqKoxQGFEoK0AVqUmFyNQEd09+0k25nWgAp6BuKCPoGmZw8zbnz54CFgJl8/a2i48Ki57gfG7ZJ99Pas0gsRzdoWVmWDDBaXekWtOvlqlTbbjwP3drb+qbu9HvOy0En0Ew36bTOd2MevZSk2zrS7tzVrvtCSud+LQTLtGqQCzSeS5yBc7HnwUn+bvfWn6X0+uKM0PKfq+ZnvveZ3+6spWoPi71bV2fsVlJK+xZ26udKa7q0n6afTsm/yxoaJE1H213VzY+1kra0rrF5KfdB36BBSO02Wng7GXCMLdY96c6+UIDbUOE0Sq/7N4FlPHWnsJkN6umTEaIGzJDENZLaLHMzEdWZctZ7B0dYOF6d+pUfo6jSR2FIIWWItQJZSxB+Z0EQBvQP9lOt1ZiaOUetVqcea8fMS2oX+7ePtUipCMIEbUqAY9cMoyHCgiFJEmZm5kmSgKgQetvesX7qxDGfKuUA2knO/mpteMoWCjnbHFLi1RZp4x9J/TLg0/ZCg1nUUq/VXCpevdCnsybLl5cEMDM4OOhuan15zk+lFMViEaUWT2JTLhX5tV++ndnZ+exYFIVcuX8PQyNjBJEztISASiGgGK4wMY4qUh7ezM7hzezs5XyhUH0b2L5/A9v3L366LI2yftco63dd3fU8e+4xHvzu/fzgwTOokX7KgaV6/EEeP3ycs2qYyuaXcf2uMsMVt9hFfevYsG8dG/a1ti+itG43e9btZk8v/QFAEZZHGN89wvjuHk4XElEcZ8u+cba01t9Ggv4NbNm3ofO5QR8j2w8wsn2xZkaUxq9g//gVNA99xMCmPVy5aQ9NScH23MT6NoOgSiOMbR9hbHune1JgYMNlDGy4bAljuCZrsiYvhaS7ssEFs2q1GtbWUCogigpuN2kWhHI7Mi+GrCiImSIFaIBlLNIrvwED60MgcUSBTiPLwm4iEsiwiLUh2krnJFdFUBprqgxMGLbmQkjpPmSboRM0J48kzE+vnuKWNy1s2+PLk3SE3S5n65llFEbHxHF9YbCr6XPD2Te0PSDqcyeEUiENKFwQ1W34tlkgwlpLMARogdUGoxO/69hSr9cyRVgnCUm9TlI1MKaRsdNbZLrTV0iQClORzM/7NBIqQNiQaF3AwAEH1EniOlLgd0X7eyyBNP/peYE41tfk0rEWl/ICn9qIRhqrTqOYmovGO59TFT91tbZe2+neLTT4RNvf0u9pYKR9kEM0/lq3J10LBwZazIXQGlZbeObKXRCdSljBk3/R5cK0tVupzQGuS98J1Ahup4av/P/Ze5MfWZbszO93zMw9IiMz7/Smeq9eDa+qSaKKZJOEAKoBiSIkQBIE9VJAb3op6P/SQjuttdFCkCBBBKmJ7GZxaLDImt94x8yMcHczO1qYmbtHhEdk5HDvu1UdB8ghIjxsdvMzfPYdyQwsFCP76+3Fdc+a69lDtq8vMf+0B0U+/YeOduV5/I2K02/WmYmDnnGhMBuIBCqnrJaXLJeXwINb9Wl8h286a5MVJGyyYd2kl6+eCj//W8VWSz76foVxKRVISgkBYIhqRiwWQxsSIAFEIsGv+OyngcsXjuZyG0rfXFk+/ac5sxPPB996yeLBCcbMEXV5z0ucZmJGJ7O1OGYMVVWl50lmtEjPNFlz3JS/BegxOHT27Y/SP7dKGeW7+75307U07AXbazSHw5OfDhmt45TyqLBnlPdD8CyvLmkaoaosPszw3mNEMLXhySeKwSCqWBGctTmlVtIRVZXqNHC58njf0LSJZaUAJqaAMlsAoR6UVOZh7DRbv2/GrDRQ3kt7RkmnNZ6rdWfcKE1RLjCEgMsAGXI94xRSZVQLCEcUiEqIIe1XGlDiep9yupyiI4eoGTgrPchkV2rRAjDSOIRNh/tlA9ZQ0rmNnIfF4agT4zyub7wu+jYLaE6XuQ56STp+SVFUQDNlPsZzXABARWcbA2u0P1WofT9FM2Cjvz/J92QYpU1yGNE8nvTlSp6/st7G9xsK3g+pqwqwqL9DxOZ+lf0IxAjJCV40/zJCw26JDAyMkNoJpreBUjsqvA88+MgwOzcsHjkMjhAiIq7XA0t/bibjOR/PbwKVW5vaJRisrbA2sXll33gPDMsv2cVLuA2Y2K3x7b/iMNkVPj28zPUn2+5Phapa8PDBo349qCrufUV/kL57+v53qRYNIkpohafGldDIHQK329/s15dGLq6+wtURkWUG3w3tnrIVdsmu3o/HV2Ana8k+uatGtnt27q+ONyFpLV2vc2++t6//659Ng2Z2yf4x+80Czdx3Pw4p7z72te33bw6W+XWV7fHbtdtPy+333Ncl91PLlB22S17HWticl/vr1W1llzdr/zfuWuOvw974myS7xzx9Ymzk4YevWJyeYF221Tv4xT9A8JNfvLW07RXLpWKcMKtSLNyHkOyDnmESYiy20RD7gNKRwR7X3gbNNkJmEn7+ecuzz5ZAm1IGdfDyi6n1fvi9fnJuefc7NarKyWODWqENikbFccL7HyvnD5X5qdK2Hc+fX3F5taTrOqKmNEZ96mGT7FWT+9Z1wuzc8MEnM6pZOZQEvruk8x7rThCjELre/pbCFpr9Vv3YjDvUT/z+O+9Qn8jYtzL22cQYe2bbm/tXjrJLvhbAzPn5Oefn52+krtPFCf/tv/5v3khdb5OEr/6Of/u//o/89//D/8WnZsbcetplh1ZnPPydP+YP/vN/yX/yySnvzH9T1NKjHOUoR7m7JCUj5gCL6YMXISaEcVXVxYs/gQaeln0ByCmFpj9pewvZrmtwfasUF3FuvwhgefANy6NvgNXMBZLBHFGUYBTRClUHmETbr5aAR4zh0YeRRx9q+kxtCv4iRCIqEUzHxbO4FzBziLNo3JMpJ/dtxmufAw+SkRAitF1H53Pqgg1HvZLSD6XT12lkH3+v4uyjpMzWpkJDDqIlahliDHjfrgVGVheJRaHNwJwQAsvlMtUnEHwG7YSAPklpPJKyb5JxYxyYmtZY/EuLFYerajR66scz5u85rDWsmhXOFcp9IQhYa1ANdG1D+xNBf3nW96+o9iXWoKQUR2Wcdo17AhxlLhdNM1YcoZrTiwy/98/DMFey8Xqq3s3/1ss3fY8Mko+ja5+e6XDZH0LZtxqnWq57P71JC17vN68v9+spdTzrQwD17RMFPGmX9XkXSwHHGG7f4l1G8eti4Rwb6psB791fGv7RaHj6U0e7tDx4MGc+nyNi107dIBGNHuIlQRva1ee0q4bbAmZgFDBjelXJaL8bnpLbZUy9fv6Z4flnUJ90vPvNFbOzUwwnaGYOEtGcpi49BwQlncQa/mr0XD7/ks9+esKLzx9P9qFZ1vzqH58AMD95iqsrXP0YUz3K60pQUxw1iRkk7duDY8XmnNcxhsz0sQ6YmRy765hi0H4wtsENNy/32rWrkvWw8VNIMKYsovKnADiKzlZ0O4ixw/sAAk0jXF1dYaxN6XaM4fH3hcLsZq3BOUdlUzkhBKIqPgReXXb4EJIjTgSb748QBtDCfrYe+j6MQSD94be1a7ZX4LjsAszZCdgQEGOw1qb0SAVsAXvXQHbHoYSkg/S57XWkB+e88eSGS3LgSc7tXsZkE+RRXo/7UdqzGXgvgKICOCv6UyxrP5943Leutj6TYY2Ynk3G9IAZax3z2Tw5WckMPTFkZylr8zuw84znMfc16tp6GO7JoYzi8ExgFBCJRKUHM5WfApgpoKe1sdNxmzR/x/VrwbmqZxgp49inhE1oxdEy03QPQAYzRJBICC3L5QUhgHMzrK1xtqKuZ3gfePLdqgeoqSZmte1hn15r+8BOfZsYB+/TnDtbEb0HNRhxWFv1wP1I2jLMWgm7ZSrQud9e0Inv3EymtMfDy9z3ZBtfZTHmBI0lTG04fSCc/fNUs5gTkIgQaVcekdUBkIPDdPjN1gJo9Lx48WNOzgzIisrN1wBLg96/rdft7ume500pbYOtYl+aqbdTl7x/uU5bHJ6y6fdN1/2+1bn+2TZoptR7/X27uVam069Nv/P1yvr4bstN9pfrdoKb9P3Qeq9bP2XdyMZ7N0nBdB/yuuzfXWVv7+vX6dI3kze3jm/W7kP2k8PWzH3KMBvbc3WY7+D+2nT33o/3zO3/bteCqe8f4tk6yqaM/ZyHiXHw/vcanrx3ynxWIyK0S/jspx3B3230N9txtVxiXnXUM4c5PceIwQfFGkVMhUg5DBARsemg5Rq7uKz9TU/tbBPiQVYE9Xz1K88//VUkQQ4cwsnBbd617k4ewMe/bzAm2YQprRLJPBHLe9/yBB9o2pbnL694/vIVMSZbqHYOk22mwUYziFjEVogazp44Tj6qqKs5YoQYA2Jq6npOiIYQW3xIBwyMSM9oU2z+dIhASGmD12dh0+65ib9kU3b5FUIIpbCDyzrKfvlaADNHef0S5RHvfvO7/PYPvsD+6inPryznH3yHj3/wL/iP/st/yb/6V/8FP3hkqI/30lGOcpSj9NIHLISMOE6nIZ21VFVFXdcY69aCe9cheW+D8t25NV9T1M5AAZaSRlN71Xak+GoJNiTnoWTl2GgANRRqmp4eX4TEUpOc1agFLCmeFHI9kahhVM/ubhw2QuOTr69XFEASYKrtOparSDSKna3PTfnfjFI3AFhNFJMaElW8ZAp5EYhRubp8Rdc1dG1L1zVoDIgoXddycXHJ5WVCsycGmBzkdJbKDakBxGQQTpkDLGIs1lZUtiZ6R7O6wOS1O5vPMRaMdRh1CA6jNSbOEYG6OmN2qlzMhhHuR1xSqirTQYy7gwf03xo7KjfMHhWQTaNrbeQnjMzdTrWpEsZXbzpjU1oNRTCkHA4GLznd1bid18j9Od7GPdjnrjj0/etb9Tqdhvcnt1FQZfT7rnKYA+3g0mJM93uImMpmp4RNBnkXivf4xvLWpafdEMmR2RTEF5x1WAeuFqwbmCdSWpac9EYDEq5Yvfqcq6svCP4F+NM7tWPsvppy+ZQA7D4n4vp9M/Fci4HnTz/F8S4nc4ezyekVTEw5vTUBhkrqJOwSxKNR6dqGZ08/o2s/BOpr+xPDK5avVhi35OG7cyKJUUHVEIn9eGsYgucFMOOcw3vfp3/pgQdxnTFk3akka+8P/287bqa+cxPZrzMVfWRzFkc7fQn855fDCayQ2HWIGAFjpWfbQIUY8uMpJiBs51dYY5BgoOkSbbPNa7QALY0ZwLAhEkOg4HY2dcNd/Sr3wHj8C+hFVfG+y8CHpKepxszaoZn5xOQ0ot0WsKJILAwzGcDiTGElSvVb4zbmTxgyDyVGmRg9UX0GhpgBOKLlwpIaKWl91lrEDmCZ4sgrbRuzpZS0TNYanNgeXFO01tyLUXtGrD1pi0n318R9uc9JWVhkbK/jz7Jenz53tqKqZ2l9xAQY8mFImzRmuQnegyYnabnXjEnMTsYIUVNfu64jAeUKcChSGJ/Gc5CYdJTkeB3AOOXeLeDq0seeYlzpQf91XTObzdbSQw1jUEA69ACX1K9yTelZJGqbHOGh4/LqJZ/98pdcLVvq2QnnZ4949OiZUopjAAAgAElEQVQd5vMZs1lNSpGU1at+6AcdONWxNU17ZY1Fp9/J0zzFmNmsoiDisKYGtaOVU5gRx7vFYA31dcDW6pH+2u1nw6aGsE+v2qXlTWnCU4G8/SVNKA8pG2sGnmW7pMoh6nxYok/5pYAIITQYk/bFQfs/LBh36E6/psmrEttnhBai79DwMH1S1p+Ulk+Xfpuny7gP/VrYke7lLv2dsnHvqqndLix6vRzSrs1VV/Sl9JlujetUC6fGfrPM8mpTFzu0xzJRu06UdNu5eCO+B6bbdxO77T7bedd1W1bJ5i51nSfhTcu+sT9Uds3R8P70qr7/eb3rCji8nfve2zeWY5tsX+23k10eJEa1brIfXy/XXfc6erKrNJ14V0af3GYF7GvtoT15+31L02IcpOQlY8/AWHY9xbdnYlNvuW7vVsDNHLOTb2GqUwIVKARR3OwpIdscpTTf7S7Q2Ig1mg5/9OyS2ut5Ahg3R4whRmF51eBs8iEbKeyh2d6Lmg9ZJqbIdMCh2FQD44y1CSgT44oYG0J3ydXyBZdXc25z0Ek2/h93NcaGrn3BbFbTNpEYLEZmGFPR+IZmecnl5QXL5YoQIq6yNG1H0Gz3G5OgP4UhFDBSkQ4FG5BIoCFKYpY1NgGJMBYTKySA71JsI9luxWYjg2/SuI9T7pbPr7N77pMV5sgwc39yBMz8hkr13f+M/+q/+w/5k3/d0Pl08k2MxVZz5osFZ2eG6jaMuEc5ylGO8hssJXUBmpzfIUZUhYvLSxTDYrGgrmeYHJBIJyd3KyXXKSz3GezcDZYBo4lisaTHUUhRofFF0CvUkCjMZeQwH1zOgSgBCBSa9uKw7cEUAoU9YdMpcpgKN23w3bf6N326KannIXhWbXKof+PDb/PgvMOKUtUVnQ9Udo5IjYYajS6NlUaqkw5RD6RTtYqgMdD5jq5dslxdslq+JIYu/cQuo/gjXdeirKjqjqo2VK7GVTNEKoR0ilc1BQYUC5ICMkYCaJuCMFiMGmKrNN0KMUKYzdAQMZUANVTgjMWIUOVAmUawTwIP/2uPEkACrV8RYks1S6fyX/4fDwi/rEYB5qkZ2wwxlBUyMuV19P+ERBkCGbFfsevfGS/Z/XM8/k55lUAzBoPL943v63xdRN43dUvfpZ7r239Th/9ty7m5vF4n6uH9ng4G3FaefQ5/9j8pqp5/9scdD97XdBK+D1Dl8N0tAolT8rYYy+NUISFETBX58PeWPHjwgMVZAm6UlDkAvvOsrl7x8quv+MXfnNE1p0Akhruvi/W9Y9v5NZhF49DNvmDmhiOntfzj//0NfmosH3+/45u/1WDrGSIGawWiTfuzCWAiXju8v+D5L5Uf/8UJIXyCbw9L8/iPP/oAY5XHHzgevLNCRYjREMWAMSkYSVxr4BQDiarpKXzL381APDAJ/uiZNUapjvZ951DZ/Z3i+BPWQDOjCSrNGJfRdV0ChViT7zUBAiW9jCoj1gUlsSwYjJMcQCaxthmXtKCeDSQQNQ54kZCccCHuCMDuZM8YgCAiuva+KhiT+hpHLCWgVFW9BdreBD71c0F+KkdBrU0hyQKgso7C8jQuJ4FYEsOiRp8cqaq98za1J2bHY9kvXQIDGkksNoGtTXdIFyR9G3tQU4isfEefCipPVzlJOKTkGQdxdu8N2yCR4a9kMEtdz3DO4Vwah3FKJjQ5R733dF1HCB0lE2txHJd7Ka0J6cE3qbw8Pznd1HgMNhlvClBnaHNhK4p0nWe1WqUxyvexyWxBZkA2pZRiZujDGDi1Oe7ra2TQ0BJbD0BJywb1rCLGwKppWH4pXP3V76CqLH7vJQ8eVpwsanxokcyqBZvpvVLZqZKkb+6ar31zmf/L/n/JIEuLoMQI1hhmsxPOHzzkpaSDAaZfH5uB+HFipnW9aVNv3B8AHK42o2t3aVFTuqtufL7HqpxoxfZ7508i3/+jwOL0CSE4ImArBeuHvVNt/11jDKKgeBrf8OryksQsut6+qXZttvfQJ3Xoan75//1xD8yL3kyCVwatfbruQ2Sq3a9TQzrUPtknuufV7UvbF0hmb7qqMfPP+h2znf7ovvp/O6tpuK/HZeiOq8efvi1y3Xp/u1q7LpsrbCr8PAWWOXS+7yKHjNtd27Fr/96eu8Ns9XG77vvK11vG/rGU0e/7K/ewUqeeWfc9ave9lrf26h31jn0X05+/XrmvsXzT8tH3I9/6gcGYOUgN6oj5wIm1EHxIqe5zjKBwU3e+ASLGgDXlSWgYACUFFD+2x5ImupZORxU7N4gziE2ct7WJ/O6fnnN5+RzVlqoCjfA3/1tFt5peYY8/fM4Hn1ywODnjZHEOGNou4oOCqXB1ja3eAxMwUuHMKSFaMrFlYriUBIwxlsQ2k+1lMRGhMKgUUcAjpsPaQGiUv/5falZX7xC6bf//be6L8Zo6mTs+/mjB06fP+MlPf87zpys01hgzQ0zAh7ZPN22sxZhkh9X1DDFK0JCB9sW+SQwzztUpbZR2WIU2dLQh+UXSNCoYQbQcGIEQkn2UbLBiX5ZWm1GrD/Ncvy1+u6OsyxEw8xsqUi04e7Tg7NHX3ZKjHOUoR/k1kmjRmAABmJzCRRTfrriMLb69YHG6wFrbBw3m8xNm9UlSpBkcz2IMmuNVMSpd2/UBCutc+rychO5Fsma4L2B0cykBHZXBmDS6rZwNJ0rHVSkQ1l6aaNhui4KEfCo2jUIMFehqqwf7ncFv1rkp/U/qj9FkqMRVg78K1LMF1pxweh5TYMRa6qiIWFCTgxC+dxmKCFEyUMgIRpXVasnV1SuWywva5ooYmhR8iulkdfSetm0IoSj5C5yrsLbKgeT0EzEgJintOeeqogkUS5WCbWJSioI8YCF4mlXAdyswysWL3G+xuGrB40fvU89mfXDKLgQxFhHLTC3KST7ZrkhOS5C5lzZMJu0DV9q3rIzxOETB2iuZuCaqEogEFCOl7ENXwL57ZChjSM8kuOwkDlKgYfcNmnndbsD7l6+nxfdf601L3N7V7mc1BA/Li1SiX/4c2oDYGVHnWLcgikNJP2AhJpaqvDJROgaGBcmb+jYg8VCZMszHAexyzT4D/jDApwyBeBHqas6H3/xGH8hNICHBiM0sGZ5Vs2LVrlgtzwnt/Zmq5ekyxX812XLdPq+8tufJxvdVCCtDANruOV4/I4QTjJnh3IKIIWrIwfOWrvmCrn1Oe1nTXH4bpTq4L12bwBuh6VD/GWLOEE4QFhDrxERmwtBmJbOTpP4bEkNZRKlcStGjkZwCxmYAxZDipZwsA+31hBToVDRE4kQE/C6A4envZqCETEXbt8FmQ6qcxM6S2NmyniM5uaBmvrHMwGFMSs2DCMaWcQQ00vllGieNxKiEGAkhPXMBNCgx7IVv7O3rPnaf8b2Z0hApXlO7UrofwFpCVEJUqspRV1VSKaWkxVF8SOw0Gg2uqnBi0xioDsF+LYxDoaeeTvfN8BwuKYZCJLHqGNcz2xiTdB/VSKQjZtCFqwq4x4OS01xmwEIJlIsglaAx9uyEiXUqg2dlehxTGb7XccfjrZrSVxZAvLEZaCKGqpplXSulrSxjnYoJhBjwvsvppRRX1kfymJfJQmPM/tTU1uAD0Q9puWIMGXg03Cvj9FRJx4sZHFWKjYllw2gGM5DBdyb/tVRVjXMuM+Wk/cpKslsKUK+nVyct1ZSSEwipXyqSNHwjOCvQvKIiIDFgUSrr8G1L0A7fXUALsX2MqHC+eIfTRYWVOunDZcwl5vtCRj+DziraDbN00HOk0MEXBpySci4566NGxCoqgpoZ9dn7RGOIksYu8UIN9k/R+U1+CJS1ptCnBRrv/dcHqrcZFKbX6fD7sMDSVM279sahPmMd9ckCccKsTjq9StqjNPNhIgYtTKoWNHhEOmoTODs1A/hwT61Tcth1ac/qmpOtUTok2Ln2egLksYs1Jtc8WeJNNKnNdbFL7kej3W0X37yOYp3tH8cJ6359nGUTZjbAym4TNJ6+U6aT9h4+5tv3zr7799cpzHv9fvRm6t/3rux9d1oOCahO373Xy03G6raB3UPqeRtW2qH71yFy3/25yXxOXXvzPk334D48TndbSYfWsWs/GN59G9bc2y6unjM/nZONJlCfdE012R42vd81jWZCztc6T6+l6LKanANIf+mUHjloHUWzjcM1IUG9UcNiMWc2f4KIR0zI6TIbds3o4vwxjz94gjUOV1Wggoma7bDkw4aT3Ld00DWlM9K+ZcZUWJP19ZivySzmGhP7ejlQa0Sx0kHsiPGSsLxidXlGu5w+/DO+I3bdHfv07ufPXvLnf/YTQlC6VnD1KUgC8Rgs1lWDXZXtMQBrLBoiwbf58EIGy1hDCCvaLtlrta0wpsY6QwyxZ3lHoW3b5EMx4JxBiPjg8cHnwx3Fxs3tXvs7mvUJm2e/v+QWd+8RfHNvcgTMHOUoRznKUY6SpSiQyTk0CnxoxHee4Bt8t8QYwQePamQ+n2OkygEJgJJ2wnG6OKWuZxAV363o2g5X1czmc6pZzeC6TZKCOfer5CgZBLChoPVBw03QzMbnU4qa6Hq7++tMotAXMSlIocK733IsHkaQ0Occ1UgyPnCIpBRXSgnIRWJMYKQvfqYsX8HJOXzw7RI4MqANly8Cn/5sdqsxKc5y2fw/B0gNwuorw1Ogqi3GRZ58t2b+IBkAyccs2R4agj3r5mkODwj4rqVrWzTGrLQbnDPEYAhdpFl5YkisMcY6rK0xNqVsSad9i+dac31Q8sUCfUAqtT8bPVk3F1LgxfvQj3FZp03rabuup+0/OVmwWCyw+ZS1SArgalQ0KvNvK3K2ImpHPat48uQJn/2bhssvB8BQGeFY1sSwOkZjPQ5cbIf8y+hFwkYpg+xzh+9KrDI2wpQxaMZgS8BX7gKaeVsMlF9H98j9hBbuu8Q0kvcLofrq54blixSAreqO7/7gFWJnqM7SfaMAFYKhZz3qnRl5u5F+27lXuf8UTxlcSGKs8F1HXc/y6R6yA4r+/6qqODlZwKOG1TdfEn3g6uWCqxeLe2xRGsB9Pd0XPCrvpnmYPll98aXhF38n6blnPc61xAwuEEn0xV3niP6M1eU0a9c+KXvn6sLw878xYCLn779k/iBiq/P0DCppXyhpObR/hroq6R/GCG27wmCIJgFpYyxB/BKgjqN50lE5aTQjCbQxXjqHrKMx28Xm+3u+tXeUpr869KMAgIozrQBlUpvztZJPjUl63scQCKGjbVdEDX0bkx6THYkiiTVD97Vu35ishx83mUcKq0jfUBHC6D3JqaFiAROJEPPD3kjRCkoKquRQdNZhTdpjVCOa0yAl1piQUy7l9kgZw+QMLgAMlAw2cT3TyhgnIVlnKetFNTPFlLLW+p/GSIxNKaRyBb3Tce0OWR/LAXSzfjf231GwrkrAHmOwzuGsw5hqSMvFsKbHTEtRE5tiAqRIr//2fchVjplepmc6pdg0GWg9zHPRxcff1H6qS/8k36+F/aZyNfP5yTDukvXX7NAt+rTS9WOjGnjxmXD5paDG8/jbOVWPVdBIc9Xy4t8p4hXRmJJ92kDnlYihCyc0vuPR958ynz/g/MkZlZuhaiYeSLtDmzcKI5Vy+73HjHRi0KwnSk5ZFrHUi1Pe+52AX16w+rKm+WoxYhBLe6cp7csAmdKmmOurH31OddJSVXNm81OQBUbq1FfAmgjiCaFltXzJ1YtA++LdKctobQQOCV9tX7H9znsft5w/tIjM6LxDMYhJgYP5meDqOgE0g2IIIzBWuldUFCTdizEGMIEYVixfdjz9qSP6w55HN5nL7Wun0+9svt4lOxlRdjRquqysY01/Za/c5jtTsntF6Oj3fbVh/zcOLau0eWj7oav7kPoO79H1/f91tIcOk6+jZ4fMl+x9d7/sm89dvoDrSr7NGN12P3hdV9/XXG9qXa9z/9pVtuz49D7acth6mNJNbje619d3X6N8vfzm7nT3K+fvLHn0bsBVD0AcGg2P3p+B1mltaIARQ2vSzc36odIsIiNgyA4VeNrHObySrNdCSHX3Rk+CejtbARYk4lzHx7+j+K4cZshsNvkrj79RUc+qvnoFxCh2XJumNMQadc22LKlcDekgxXCnZltKgexHFhMxREQCn/90xdXLLh0ObgxhwMNPyvodoTx41/PgPcXaOZDSI3kfCL5DJB3Oef78KcurJY0sefZlS10vcPUJVZ0PAIhitbRWhv7H2GuZGhg5CbKfIypBPSGGzBRqcvrdxBpqoknDm1lXIbG+GpvTLoXENmvzgdJyCAzG9l1hD51aDdfJ8Y7+uuUImDnKUY5ylKMcJUsJHCStpzisS1DH4H1D13WjwAp4H+jasEbvZ63FOce777zH4nRBjMrV1RXL5YqqmtGFBfO4oKpmiW1mgyL9tfRtR9n3GyDdMAME3vukogTYrE0naKMXNFoMM6ydpwCKDIAZ1RbVyOWLlqtXgcUD4ZM/dNjM0KN+yWc/Wd4KMJNmcgg4DibBeutXzxzNs7wm6Fg8qZifDxeaRH2SwBXjsZUcplGgBKC6DquKWAcCK98iMaUfCF0ktJGqqjHWphyqZqD8VC1sMuTAZapk08kcc+AmfTy4MYccthHpUzil8ryPXLx8gbHCfDbHtw1En4MyJbiWv2OExfcs7uOGGFecn5/x4UeWl78wXH1ZHKUyHgZi/unpR9fGfP1vkVH4iOtgCrf5ZFPGoBlGoJmbpWd6Gw2aN+GgeRv7neR19P6+nFFf/nygf5yfRL7zvS9x1udQg0X70F65d1OqtfJ+SnGUGGYG1pmbyf0DY/bVBaUfKQVTCkyXQC8ktgVrLbPZnLq2nJxYrP0pVjo+/Yeaqxf3157BXbLptil+l8Pd/KrTwJtXXyx49cUY5FNqzXMrBnjSO7RKcozr9pvBfZWkeVXxkx89QoBv/cFnuHmbaZRrNBrSySubnV2mByYlVgqHAqtm1Qfrx4+yzVQ/m+8NazMxeGw7EuVaneZNUBAP6YVkrU3W2r6d5bpx/2JUlEgMns63eJ9P9Y2oF0TcoC7esiu72J6m0vaMPxcGB2e5rtxPIkIICfBiRkwmxjjquk79N5IY3BSCamZSKawoEXJ5SgLMRk057AewcNIRnKt6wImqJqdkDsiXlo+dsuOUUZOpo+K+AMNN9q2sYYhgc9opaxILjjWWkmt+PP8xA78KYAYSI8vaHBQn+GgPLTpSqW8Y77y/aU7hFdMYeu/7cRhYaKb38rX7MP+ICM5Z6rpeWyOiJdmkSUw+eFRaFE8XGmLwfPUzy6c/qqhO4MEHktICakeMFyyfveLTv/6YsLJ9XWkeB5fh2QdLPv4Xzzg9e5AB7GXuJdlLo4FKe+xmv5Qowy52KFNZ0oOLTlyc0AlQlZZfYrgRtbi64hs/7GhXLV/+tWH11Wh/H0osruz+//H+e/7BBWfvrZifwOnZApEZzp2BOtAUuBDpaDvPy+eXfPHTlq9evLsN4pgAVd4eNEP/7offFT74lkPMCW03I2iioE/zlQC5oVO8j1hN93qaC5ufP/lHlBA9VaV4H3j+Zcs//dUuF/FNwqL7Sxivk6HUbVa3W8moSbrxd/P/dPmbC2rukrv0e3tM34yUNq+vzLv0RSb+ex3y9touRQ6d0/u4Xw7XeA8v5y5lTt2N+/o4eDyG2u4bXHJfcpcyb9qvQ70Xh87O5n0+9dlhZbz+nerQcRrvYdvP6ZvVNe3LOqQ1r2s83uw+9/bvqkkevx/55PeUejYDmeGDRbWARDZ6MWIpmZL7sWGLth1JDKpm9L4M6VwFjLV864dzwNP7LrGD+3LERlrS+A5lpUK0Z5QdVqmQWDdNZmuJPQtLNnk1oBoS040EwKN0xNjwix8bvvqFIUELDoMXjO+Phx94vvP7EesWIDUiM9qmo20EwaPa0f3TU/TVBc7OWJx8gKtO8AFCBjeZ0saiT/bTYjfurnSIBCm6ZmFW1d5X4L1fS2c7ttXy4IKup0kuLMrX97oPL61/cmSEeWvlCJg5ylGOcpSjHKWXgBJGDnFygKk41AeHuDGCtQbnKuYzaJqmp6RPtH2Rq+UrVs0lTdOwXK5wztH5Fa1vWDUrTk7OePjoMcDIOW/vn2VmD1jm5mkR9tVTgjVZbxTNSPUZIjNEDQSDhghRwDhEa0Q7jGbKcBHEngJg66dUsyWmrug4RU1iLgnhJV1Get9OckqKSRaBIXBTXlaVpFPm3vRpHcSklAwpwBT6oKEwGBe+WdIsr4i+RWJD7Fq6rqFtG1bLJU3T4n1AsIjUVJUjIoSYTu2nsRSMyYErpaeKLy7e8necPgN0a24L00AMJEaAfN3D8xTU9d7z6sVTXr14SggJaT+bzTg9PeXs7Iy6rjFSI1JhnANd8E8//pxlW2PqfLremz4gESmQmfR73ZEmmSK/D2n1Y6694bg7EdN1q/Kmd08BzQwnKEhnljPwqCSbmna4//ts5Gy6hw6T7WBFefd+nEavx/V0Py7YzbbFGHj11Rcs4iPsSYWrKjRaBtCb5BRryloqGrHkYy+3atebAsyUdCQAzllOTuYZdDqAF0pqEvo73uCqU84ffsy8tlx+GahmHaCgivfSO4du3J78d3xX7+OaOSRYMVXHtaOrg9tYt99ea+tmPbIB0imvTOyI/orQBZx7TOcdRuocKHVZfzGZwSMksK9XfHHGaQZGjJxsZY42wTNjQEeiK87MJKNrr1tj963nHFpfjDE/TweQgnOu/yyEQAiREJqsA8aU2zz47Ggr9RlMypC4ASLaX//2+6EfrwKy2EyPtua805SSyUpJgZT64r3v6yhlFEdfSduT6oh921UTpXTXtQTfQd+OUgYUHIdG8n2nGDEZcGKyY5XshM3wWCupXzl4X8Z63M/xmhqAvIYQx4w0eV/Q/XfVtE9bcjoux2w2o2k6IOWyL3q6MWP9fn0v7edBSttL+ivtx3yofzhBOJ7DYhOkg4yxX1+r1aqn9x6vjfU1MuiApT9pHiJYXVsj/VwjCDVKAkwZGxFpaNtXPH/2DCsG3z4kMZhBZRUTO8LyOd3qc9rnr5D4IQZHmjnSpjQCfVTVgkfn54RoiQhRfX4MZQYekeTul6KdxgRKkQShTg7qaks/3e7/5hyn/StdCIV5pgC8U7o5m+oVS4gVYheYGuxMR0D5vEcFhZDZYpxiTALyxNyWR+98wsP3LEZmWDNDZIEzNWIEJLPaGIdDOXv4Ad2TFc9ch/pqfSOf6gtsaZVT+/1U0FhEsBUY94g21KivsG6GaEekQVkRYkfXRIiJtRJJDDTrNZQfzWD6iHM1ldvkhxy+4qpi3KUrVCOhK/fpdtuvC3JvV3EI/9t+2Z2O6XrLYbCubi87WW+matxo6121zDcF+ylpy2ATqFC0+X2pCbdKG/2+neweM+1/68aVh4zz7Syc+5Vpe2n7vZu0Tw5+dTvZLmMaPnCTum6yn9x833kzsrkGt19dL/vHYaqG+5eb3hdTnrYpufvc7O7/vnaOLcF1+ObNxnJzXR++H++y9m5W765372M9/Lp7uqTXX2A+f8KsPiHoLDF9x/zsEkA02djFJ6G7+35/NmzSk5FsZCkkQEyyicRYhGJzWFBLArFr//2x+RuznVaYfAcbCsoh4GJTJTvODj8UtsgERFE8EBAbIK4IXUMIK0JY0vkLfPeKrv0O8ODWvbfWphRIGhA8xlbUdYWzgsaOF8+XgOPx4/c5XTygWQXA4n3b23gqJd3wUG6xwca+ppiZZIyYfo7J9m45RBNjpKoq6rre8hvEGHtmnhhDYiEth1LQHtBfDrquzbKWuX4D8gYPxf2myxEwc5SjHOUoRzlKL1lpHbv8RPHZ0W9temwWhpkQlBhbQoi9wzcEn08zW1arVY9WLiCbqnJYl5Q07z1d11FVQ87NQ05l31tv106Lr8s+MM3u9mV3tJZxjNkIyUq4JhS/EUFscpvHmBDrmgMeMQdgVOC7/8Ep3/6jGcZ6lIao2eGuV6i2N+prAWYUF/Fu0ZHhDNVM+O3/dM7poxpjU4A6BU5iOpkrmd6ShNpvViu6riG0S7rVK2JoWTVLvO/QGPFdx9VqSdt1oIKrKurKISYS8IjJga3ieMzBGWMS7eQQlBr1TYrRU5T0IZAyDnyWU7klGDVeb865HqxVgkFt29J1Hc+fP0+GhAj1/ITT83NiDjSc/mGH++0XXP3SE//tx/3YGgrYJI1p7N3g6X+lgGbGLgkdsdKUdw53hB0iWwHqiSv6oMronU3oznqrd9e1fsXNDJhDrn57nBiHudDepCPv9ZR+ux7salfXOv7yz34LsYbv/q7h2z/s8FExMgc1RJUUxDYj8EIpU4oBvi3j9CBT8uZAmfl5mZ+ZPnQ5+KoEH+l8R/CB2XxG1DFgwOCqM7oYeP/7ynvfcUi4pFm94u//3xOef1Hdrb2b7Rx/lh1m5bqbrqk7XX9NKqhBM5GN1/DZ335Is/yUBx//iouLVxh3zvnZu4izCdSpgliTT5WBqxwn9oQmXBFy/g2JBolKDLvZLtbaI4r6kIL4bD5r9svrZr3b1KfK6+JAGzOztO2gT4zBHTGCaiCqYkziARrAQAkkkfSS7YD/FGh1s/9jAEmRwgwz1s8KMAYgxIiPEaQwvLghJc8G8MA515eTdC1htfI9yCnpp4lZprIJqFdythuErmsTIEYEl9kQk75rRmPocjoq7ccneo+KYuywF40BPJtzIjKc8ivACO3LG/SWXZJAOTGDj1K7KlelfPYIXeupXNUzssSoOZWUXVsHhWGnVKWqRB1SVQmCEbdBYz6w+2yyy6wBg7JTVlWpqgpVpeu6wdm6AdwZ03r3gJxc33pf4tp3jUCMPj8zlKiebql8/hcf4RshdharghU4WxiWVy+4evGUbvkC6dajA0knXwcvqwoSwJqkuxs0gzoTm5WQwJxj0EPR78e66ea9sHtykx02dUmxxdIahR7+HLbQp4YAACAASURBVAWRCudmvPvbwpPveqzxQEPwV1xdPePFLwMv/u4jAN794ZLTDxTnZliXADJultmbsDjrqIwQ4hXJBgm0ockgNEPlFiweP+fRb/0NL/7dHxG7emhjbn8Zz/793T3eKQJUM/jhn8KDx3lcQwBpcbal9c9YNc94+mnkl3/5LmjgyW8/5f2Pz3lw9k4ed0tiBUqMPGnNKF3bIhicqymQ93F7q5nww//4jMWDGWKEEF9x8fJz/v5/P6NbTYfIbyrrIb5pIMX4mTwFjrkuWLrr89s/8TfKGukP18kYeDJu25R+cr2dcahMw5FKu6dGYKr+TdAMo2vGhyCuD1Xfn94+FSIe25A3XZNvj32VZN84HT6G21e+mdDa9u637247dB3erPZ90IJDYR23rXu7/tv2ZXocrr/bdslhu97UTnyo5X972ec92dXu27SjjOl1zMaHyNoz6oZtmOrxzVpz+3Vwu/p+PaSaCX/4J6fUc4erLSEaQtaBMkFmP/6JKTHp3MkGmLaH7+/g0dgzvX1HJYbPzUOiha1W84odnnKDrmxGuIkxG0rMwJmUyrf3jmvygBsDxibbtwtXxHCFRE/bvOQf/59zXn6xQJmDPkqHLtqbQwrGPvkYWprVBU1nMXaOkRlVtaByM2JsWa5eslhUGLGE0ORUuWS9OqbDCBqIBfjEYJ8Otnzs7bRycEFEEJP85umgTOjt1YuLC+q67g899KOoinMWtCbGFN/p0+L2abumfCXXx3be1EG2o9xMjoCZoxzlKEc5ylF60ayAaY70pXfHZrRQAirp+sQs4nC9811QZhhjUY2sVktUkxLmfUBpcEGpasdsZrAjJ/s+WvY3LbcKqGqickQK7KH0JacTUQvqUgojCQkeIR5JfB7JeYsQM7uCmxfVNyJ4HB2iHegSwd+4eckmEkS3XYabboxiOCMwO8nBqpgCMymoo9lbrWiMhJhOab98+YLV8hLfLVG/QjTgQ9sr4z54Wu8xVY01DiOOIJbKzpKLOkpKlWBsDpSUQEAZy7hmzKeA9HQ6jNGr/md8SleVzC6QAzqaY14mpZkwuew+mCPgNXKxvKLtAkSonKWaRWanNSu275V1V9HQcpNfr0OYEpim/Gi5F+8oU063sayNaK5TGAIdxS007UbZ7cKbdg9OteAwmXJMvW5n1e1knzvv7Zfr3PuH9uOQWVYVmlUKrvm2RbTDmjkaGhAh0eSmlZecNtmBIqWlb8eo7jT0043UvxwC5Sad1AdC9BhzQtqHYmKYMAZcAlraSjFqkBipF4K7G1YmtaP/PXaT3ke4bFx+kuuCHDcJosrW7+GVbyvwILqkbSImCqoPMSamvNwaQAURWx4cGCPU8wrvQUNEA0SVnuFsk/liPM8lvYyV6ZRMU4DcQ/SK66+Z/nxXEH4MYtgEJpQ+jEEHqW8JsKCje670sVwmMvCkFSaUqb6MaZ3H7dw3NmOWmTFoVkRwIlRACAU0Y/rrxmwjYwdgAcSKEYym55v3oWd/KmwyPYAEehCUMQZjHYlNJmZGD9ODc2MY9FZjDM4m4ETAo8S1FExT87TW9wyOKUM5Htd966J/HuaUqAkUZdC8lySglMPagWlnPM5Dm3QE6sl/e6aX9GuqHcU5O56n8fxJZiYsdcJw/4zX6fh1YU0Zs3CJuAyeTqCfTbCMomA6gu8wEmnaFU1zyeqywS/P8StL0QCNKm3znLZ5hrUts7MZsROsMT1oWcf6WJoZ2u6SF8+fIhZUYmKFxAFznD2hqheImQMOLcCyoudlfcocCCgYJlgYWNc2x55cBxlEmhzX5H1J5qAzgxGHIFTBUC8qaDxfZcbGxfk5Dx87EsrIAo7KugTu1wg0XC2/omleEbVDVfHBcv7gHWb1A4ydYWyN1DGxKhUgQWESK/3dAkfI2n/D+7tFBOqFR1xAYkxZleKKZvWMVfsFQV+hfkZzmUo7nS84mc8HZ/7aECpCJMQWkZYYr+i8B+YbrUvrsz6xVPMEkSIo9Rw2b+ebPEP391XXRudQXXdXcPqQtlwfxr9/KcCTm4bSJ+6ErVdTpWyO49rrEWhm8/qp8sbAoIH9dNM+kZ29uc9RXrc0N99/O/Tk+5e725KvQ663dMeztZtPaupO3Hx9071g9z0xtPpulvr11u99rMap+/GuIImb9fe6HWhrt7hhi9blkPbt6v+h8zm2Bu8DNDMu96bfKc+/3d++/zX1m7pLQtZfFjX1SYVmr7NmwEWvaSis+VXeqItFQB3Dod3BN6oTPN29aPGtav//lpT3i5K8Vk625TJDvBKIGtDQEuKS1j+j88+BFvUXNMua1eWMlEj61j1lfIDV+0tWq8/xwWHsDNUa1SfEeMby8oKLixdYsRhJ/nbVAkxRkEhifCxply2FRbKAYgozfDpMkVnZY0493FtE9Mzq8/m8P8jcti3WpoMpQ3wmP7N0YKUF+rhAOVBzU9lt4/4m35lvvxwBM0c5ylGOcpSjrMm0aZXo9jZcTSogBisV6USsSacvTcqFGmOiCLe2whqTFdZ0Qtd4T4yeqAE7UjxjiInJ5NdQJKP1Kdz0a/klJKVhoijuERFPyoNq1n7IjC1GQDRRxhtpIK6IYYl2ryBcr4w+es/w6P0E0mlWHeiK1TPD1bPtiOuUad/DZtQlvTy7dlQGOsa2a+jaJT50dL5leXVB2zZE3xF9IPiWzifWoZz8AXEnGFdhjEvBSyxqZrlezUuvmO7ZaJai3I/aKOPg0zoFdpmCtR7llBwp6JOColHHnw/XiUk/xliscyldgkBQT/CeNqTESj4kg2N2Bic/eIWzytVPFnSv0po29DxDOQiTKiwm6tisGANqshnXz82u9EzXyb5VUsod6t5g7oGJAMPtZL2Yu7umJp3XE++9LXJYu+422PfhBD6knYeM883bIjz7zPDjf+OwVvjmJw2ugiiWqCWBUAldluCjI0ctR+UUp8d6orNUxWjF3zRgeRvZW0UGxwSP9z6lo4uBruvwPuBjoIuBxcki0+KmYP2srvngO0sW5yuuXgW+/GW9r5JrpYD2NhNB3OSU+PV17B+K29y3U+UJsHxxDj/9kC5YxMzpPjc8+Shy9m4cwAei+fGc5qCeZYazTgiaTpeVE1X7QC89YxmkQLPGoR+j72j/VqKangLfHC67R2rXia4xy8cmWGYzLRAUIIMiUtwk+R7SUZvXfI8F8Dy6duR632zTZt97oAPlmW56HSDhVBMrSUjH5xJQx5oeCLIGmNgAphgjCQNgwNoEUgsh3WcaY05JZHpmlQSySWxDZmt+pO9roZtOqasS613flhHTjJIABGU9rAXgR6M7WjhsXVh0yn2Sx6mcFhQMxliMZD3EGKx12Zk6AGY0Kj76EXjKs7bGJK/wUWM31+8Uo9LWe/mU6nDCMZ1M9N737RuLMYaqsj3dd1qrgrVpXLu2xUhKCZuKL3OvBF0hNmKscPWZ8PRnFb4zRC99Uh5BoINPf+Tw/hyJCyoL6gWC3bR00k8O6l9dCr/8e9crbz2LpBiMUT74XsviYVp0SgLRKwaVIRBpuMXBgBFTyzDQ9IquFB1Xyp2nYFrIIPfcCYyd4cycB0/gm78bEIGzxwbnCmNG78YHDYSwpG1ecHX1E57+6ozmqgaEGIUXC887H11SnURUHY+ffMRzY4YdYOM5sskokpb5+hPguudBYsRaUdUOZxwGJXQNy4tnfPWpoV09IGrkybe/4Oz0HR6/c0pdzRIAjEjSrBNAToyi4iE2XC0/xXcvWDUV8NFEexS0TXacKsSwpl7cVA752rCDDvD6w8qbLv3Qpt6T2n+vMrV3rn+6/eoQ3WKzr5tr9jZjsVnvLnvlPmVzfN5orPMNyHVzfvtyXp8ctnb239u31Z+3NdDd62GXfX6btb9dxyE709shu/t7m1Vz/x6JqfaNte1d39n3/Tcht62312Mme73r1VGsUz74pMM6hxiHSGKbNM6hyOjA0eCVlDVDRLKu33tM3oAIZHbGaZl+go51/2KDDr3Ivo0Nm92YrHn2dkpmw8yHWFVbkIYvftry6rkQ4gzUIupoLm9/YmnQS2Tt/8svT/hcnxA1pZ9StTx833DyqOHFiwt8F8FmQLtajKlImG2fbaucKteSJy0//bMdXdJPqUaa1mdbJfm3JbO3hxD7wxbOVb1tFbKPu9jNycaNtF3Xs7APh1o2uX/vQ26rYB93hfuSI2DmKEc5ylGOcpReiqM0y8hhP/hlJQcTklPUyPpp0XK6NKGOkzPcGjcoU6YwyXS07RUxLIii2Zkv/YnYVHdJw0PPMjClvG+lixmBe3pU+S3k5ikTiqMtKeBJ+df0fzE8NOVFhZBeCyg1A1gmjbPRiKBI7FB/RQwXWBpC8xL0FYaTa9v/6APLJ783Q7Ti8hJifMVnf29YZsDMXqc0w0ow4pDsbNaYGGPatsGHjqa5omkvcyqujqZZEYJHoxJ8oG0i3kNUm5iIqpqqXqCSKNExNrHJ4DCSguLoEMiTMiAKGgO9GzAbfClYUYJ4YzdpOfWeX2u5Lv2vxefN+CtmTdmPmsBLovm0rgpEg1GQHICKKN4rdt4y/2HHfK4sn1eEV0NoJpOeZvBMSc9UXPDjQEEx7zI0Kfc/SjnjfdhCXgvE7ZnfzZ+blndTd9C6A3nXN4cZGIVZtgJYU2Uc4pQ5mlDTcvi4lPlZd8Le3jwevvnVryq++lXF/ET56NuX2NkKifnZksFyKgpisqFfoeY8MWGUlHdIumdzUrS0V+Q9VzwpR3YOcG4BQq57vXuUdjPMlO9MPLc0pzkRwVrTMzqE4OnahourSyprqasZIpagkaCGb3wSee+bLV/8vOPLX+5s0rUydrROucevD9HdXcbh2fu4N6+ePuLq6aO+1S9JqVPO3hOMtb2zMKVISTVWrs7LJCA2brVjkyWlPJv6IH92UJX0HvR6ig7p9VSHv1mvsPm5tiYyunZSdu/WuyiPy6mwgcVkcLCNUx5t1xPXZ1+L8zE3VBMbnkhOUQR9v/sihN5ZN3RR+vYCxPwcLiwkmkEnMa8/Zw3B+9xeUn1Rhn1gDJpB0agZcOGwNumQ6fNIDIpvO7q2pa6qlPtdFZ/TTIYwsO3UziHGZKad4lwuZWlmOEnpuFKPTWKHiunejhLT/S8Z+KPDPTUGHhXP9KBu757jNZ/2WDI4yJiy7wk257ZPenlmgBTTMwOJCF1oCN6vscqISSwrJQ1m6W9i4ZMyiev7w5i9qABDdFDNEljG53vJ0nUNXdfg/UABnhhlcj+1jG/sQTPFroAErEcM83lcS3mlgGrAOsE6YfWs5unfn+XZGRzVgqCd8MXfnAPnJPhzYl9UGbEqjX7KsDdXNZ//+L2U4m1iOh6+Hzh5VMqIqJTUP+NgQLtzjvfKBlPL9jGG0WtJzz4hJBBAHOwSxTF/UPHtPzCIgagNQRvAI0Zp20t8t0K0Q8OSZvWUGD/n+a9+l1dfvrPWJGNfcfaeUp843n33W/yTHeto27IbNAPjcd+3B65WK+r5DOPSsz2EJV13xdNfvMvFVwvO3r3iO3/4lHffqRAzI2ITG5CGrLvktAPiQVrENTSrz2hWX9F1jxgDZkp7RCP450iYY41Fw5KwukI53dnS6dbveueQ0Pq+q3Trv/Hz/War7W5P//sE3I5lVzB7X03jlbXbcl//bJMh6T50k7uOxpSqMF1HsSLXv/ebZfvcbjRfrzY7LYfd3deDZorcrA86+n3IlaWOzb3kkFr313KdP2JKvq75Wq/3Lq0Y34W3n8WxTO1jU+O3a0yvm6XXtU8c/pTb/t5uf9Fv2r52P2Ir+M4PhWpuEFNhzBx0nu2M4vUcbJqtec/L9Y2ObbErN59csvF39FF5MbZlx/Z2MiWHAw3WFQbM7APQcgw0GWgigaSbN4gs+fIn8OXPT+AAf/umyOT/Y6DM8Pvyq4dcfvVw/fuxI9oLXr24wBpHYrF0iKSfko5JMZl1JtmAUQf/Q8/OnA+bhBhp27a3j8tYRBQkH1yQYvOm1MRVJYSYUhf7ELDWEHxH17V0vls7QCHFV7/TUB3mbOudvd+5+Uo87gv3J0fAzFGOcpSjHOUoWSS7jYFtZXntBHFRjtLrELseKJOCfgVAE/rA0kAVKCAR1Y6u8Yg+wHcejQ5rKqwkvpkQswKHRSMYaxOa2qQgxGaqhPL/mBq+T7MTbqc67fT37fRqBETCKN5RglD5DeOJMbepnOSMM6KdUU5ZinqsNlg6JDZIfEnXPuPq1UtO5krbvMK6kBDmU00TsFUOXpiKECqsKKengLc8d6Zv0T6xDowV7MxgnQNSgKNprlheXXK1vARJLDlRPZ1v6doVl5cvaZqGGBRRizU1VX2CtXU23Bxi634QNR0hRySkuGMkfU9MMnpE+7WYAg5lCrSEI/rQ+KZJLj3LT/kZaCwTWCkF+wZJwfQhHURaz23b9aVWYqlMYlSCFOQJqiy7iAeirfGxpDkqppiQVz6JClUzXGotvAgohrHTLHFqBE1Aoijr6ZPG123/t0t0bbTKGCrZgGTf2pgm6r1NsPtQB9nmeYV1Z9FUb7eDBvvKv0nb3la5izvv9n0dz8J1pdzUxRtR/4zYpmBp17ZcLRsYMT65qsLNTghiCDE/W6RGtUqMWFJO9qfTMWqG4OHQnglK3d5pk/4O1LIlRck2M8A+phAtIAMKW8ZwvYhQVRV1XRODJ/jEBlBZg61mRNtSIUjwqDgMNW3jqdwcVwtVvYRbpOabbOdmn8ovvS5INy2be8I+V/Ft1uD2Hri7lSEE2k5TyhAp6VFIEEZxSLAIDmsDQTzBJHrhAgIGen2i5P8e90Yh5xMvz6lhH+13S8kOoQwK6Fs6cvQVoO/a51N93/HhzhRHI7BOeX8N3NA3ekg/hFW8TyfRhpSZZMBKgh70qXIUxJSUOaWODCIZOUGF9EyPGwAatZLGBSVmcEb52FiDqRzODql+NGpmiElll9NyUSMxJACLtRWusjiXUiyF4GlWDV3TEXygco55PUNEUg52V/eORGcTuGrMMDOk/+mHFMhgIZMZPAj93ANr2U3LuA/6MD3ASUblJYKQmMeojB1ZRxoDr8tc5H3FSBorM+SuL/tMScNkjM39Mjm9VoSYQNBGBOvc2tpQTeAjRQcQeq6rX1sZgyFGMC6ngiLdYzpayKqJNlwEfPBcLS9o2jY5gsUQQtfrdzEOTD9lzJ1zOFf1oKAynqvVitlsNrIxDCJzUmq7uHbIsKy63OTiJh9+lP6dgQB+CDzLqIzx37GoaNJvjevBc6Ip/VO6cTOa5K4kmjsD+WUvyS0OddJzS4pYSd8t72hM9oqrgZAOMWhs+OyzH9G2S6yB2gnOKGfnizy/rNXtasPJwlLVM4gV6Iph58uBCJWt741l+Gz9v8ldXaHrMvBHIKoH1yJ1xNURVysnJw94+OBDYJ6YJMVn0JbFYJO+oBETA6oBWOJCAvdLNz27qpH28lMqk1Jvdc2KF58/RcM7yIH0/FPzNdzp20+1qW+PE1Vsrb8drw99xm624DbP/r6sG4Jmrrcjtsu6Sduuu3bSrtlkdLphfXe1JXT0e7qGzf/KnMn4DkSZtt1+XUT2vDrsk69fJnXsjSt0x5zerp7dq+e6tmx/fvjKuelec8g1b3pe77LvTcsui+j+e7ZLJzjs2tfv/zik/Kn1uN/b8++viJDSNEvZ96GuLZU5x2GIHlQM4rYPg4iODn2MpPgD++vK+xMsnvcrEzNagOkbHxVfjGa7KY4Otij5oIgOB0ZssX9MYRlPnuOgis22iUiLxhWxa1C9QsOM28AFZO3vJkhm268JbOlKzfIKffEVy8tXnJ6egUv+rKAtELJPIaX91WxoxlDGKdkxyWbPBoeCNYbFiRv5t5Odr9ZQVTVVXWFsYXXO6VkFQujwwWOdTQCbbN875/qDDINdBowsqNGM9TGjr2fnOcpt5QiYOcpRjnKUoxzlAFkPEq1LCSaNrymOd2uHE8AhhHSSWQTU0HWRn/3sF8xmMxaLBWen55yeniMS6HxL8BFrLFVdJ4MpB2r6yD4MAQTAik3O/KD44FOIpqSCehNjIZ7eKT28OfwWkwK3JYgiybyxsSNFfzxwhfCCGC+J8YratlxdzPjL//O7PVpegBinPe7VzPD7f/IQW1uq2uCcwVrSqWt7mk9kXi/v/zPHhz+oEISoX9JcXNA2K5quYbVcslouUU0pmdq2SawyOUDgtMZUFfX8DI2CtTXGJDrJGCHEnGvVpACbamKQMDnglhgyC8uQQgnQSaQHda0BtnIwoMRwRjSbvald0nGkC3LAKaJmMLIE8onysn7p13Ap14rJazgbXSYZoxojXaeEUKHZCDUILkNgrA4pliKKF5Ijf2J1jl0rY54a0dT/tdO5G0bWPld7SilQmJrKu31BW+6cmzhebir7zOzNz2TPZ/u+PYzj9e0eX3F3R+W4FJ14dfe67vr9+90R77d37cryZ//ze/nr49NDUjbSIeCcATDf+N6nfPO3nuHcHGtPEPMAOEGpiVqjoQJ9yMD6ldlm1to9UPommUoBd9NIZ2K+GRZjAnx637BaXnJ5+ZJ2teRb3/4mMXii72iblsuLJe9/8FF+1HUYESIB6wxKPiV/D86qIQQ3HSK7y0nx+wgYbUpq3UYb2b/SXr58hvlsycNHH1LNTjHWpZQ+gEGx1hLz3h6x/fO9pIspr8cMFzB2Hk73cpczsX8/6poqk31c+8dsQ88al7erviGFWbl+eEaWOQohEFWIPoE1Urqiah0cUwBjGtNz2gjOZJB0DAk0FFkD2SQwS05f5HUE5BjuI08gUWFL78zsHYvlf1ViCP2z2xqHrRwxpjlItNEFlCD9SboQDCGk9D8oWOeoZ3M0wrJps16ZQdauyo7UBFKNmu+xDGpJY1FSF41B2yn9aB+qXNujxvpImcL0va21lP/GsueVeeu/E3O5ghFDVVW9fl3QeFL+MuStlwwMjrEF2gRKigm8VHLPjwE2m+vIucxOY1L/Qwxr4R6TabwTy3lifrGp+B5AH3zHcnXJcnlF27Y9Q0zf99G6Lo7x2axeA5OlMVOslQQCEtOzz4ztDGsNTduSTlZuBwKKbAaZMwUQooLpWf12Pdt2740aa4g1BZaTR2mjxjckknVjIgO7GhiT1pP3ngTf7mi7l3zx8yWf/tUZIfxuz+pWloMY8M02UH82n3N2viDEmi8/v2SPqZjKAUp6qZEZt/Pazf3dt4af/fkjHvzJQxbv12jw4JR63vCtf97ijGM+P8G6BT6UNLKAKNaW54cH8cS4ZLV8ystXv+LTH32Dy2ffm7StFPCt5W//4qNM5y+oLgjhIcEf5k4+TJ8+hNVlrNWua8ey9tld5f7DxmOZ0g+G+b5JiH5/HUzUc4jchzZ7Fx3ouu+NZ2fz2tcZeto3DvdV79R9v6/mr2FnvbNMr6/hyXqTu+8m63xXqPKQed3nX7hJfbuu2LUjHjYW9wsKu+3ud7M9Z9+T76bfup+9/3XYbTet/6bX3ve+8+sk1Uz5oz/1zGY16ByoUCxVbRGTdL1ISr3K6EDsWG4LfNkXF9glUylcr5N9qZHHwPxNCWHz0G4G8hc9WAQjESMBkQ6NFzz91ZK/+/MaWNCubv9kkR1/d8mmPVHXFQ8fnVHPKlbLhhi6ZGsqYEbpkv9/9t6tSZIku+/7HfeIyKyuru6ZHgywu9gFdgmZQAqgUTI9SJT0JtNH1TfQG830Qr5QDyJNBI0gRQkQOXubW093VWVmRLj70cNxj4iMjMzKqq6enQXytFVnZlzcPdw93M/lf86RkWtMWpw3JuXOIsDEGCfOBQwy7267Ybfd8vLlK25e1qQY2PWdORx1O0LobD55R9919F1nDio6RtvVVGSukvaKhbYs602eH3x1oeeiC2DmQhe60IUudKEH6FhqoqXzhemZKuALs+u9H6K+SI4Cc3t7S9t2bLctm82W113Ly5cvaduWEIMp62szUIirQWrmkQGcGGCn6zq6rqNpGpqmOTBwfWzSQTE+FbUnahDNv6WYKA0g4nmH0JG05d03gf/vrz2oGXudKH3rabf7iuqrm56f/xff4XyDr1/g6zUiFUmV9U3Far2yejVmpL1j1yt9tLb5Gn70F4Gr6xV11SDiCCmSUgRNvPgU6quOvt3x1ddfEdod2+2GzWZD17aEYBGEEMGJGSuqqqby5uqgeIQa8R7Eo9mQZekAAs6yMeW+sfDozkGKkRQCSd3A9wsOJ94wNCrZs2BMKwDFm0ARcRN5QbO9K4+H5jmpxVB53rweDKZA8kpICsVLOw1WMUSFvoObv1T8P1QTON7v0H/7Gt/5IXqMArUqASGKTtI0TefSKE6M3tCCkCZe7PvK9YcUXqpYCo2h18c+mEAGvkeFwWGLH1KQDiHSFzw/n6JOPVQEPjAnTpw7MMANR3Xxmg+lc8r6fpU/z/N0qrDdnOexne/gt3/zktuvG8Rl73FxQOTVmy0//8t7lKusbFjnppqHEQfzaGbC2wsD/FT1aQb/lahiKN7BauWpq2vi1Zp//3/0dDsLqxuTGe5fvWrxa4ePeQ9zFarJImCoe9a5VPasUwbl5zIYfVwz3CG1X7/km+0Vm5eOP/lvE+p6NGYAhAI5KoY4AyIkl6gqUxEUBVNRvA3PoCOQ65SeZ64E2itDDnRbD9Dy2jxNGXUuTT3xlqL1GSC0GqLKGFDCUppYlI8CDMmeeT5fZwjSPaXomJKpKO4mEdyShY1OMr6LgxI8t2fa9wW44pwnxIjLANYp2ENEc7QVhlQ+dd1Y2qFkPIKr3OChWO6Nalt5SQM09Ev2VJz38FSJa6Abv3duOiRTXuLYnBgizikDgGZ4L7WwGTLmmffVWJZIjhqzD9RxzqLgGTghWORGCgNhXoQlrdUQMWgybtOIjWPqJM800pa9NyWqDQOQWURJyaLEbHcb7u5u6bqOEAJN3WQgskwiOaXhaiFGzAAAIABJREFUWa2vdKjHe09VlUg5GY0jFqGrAIdKm5Na+PDGeV7/idC8ctRNQ9/1bO/v2PzS0f32am+ulZ62gxbpL0PF9s4/ZDi022vQJl80fWNzCR8QteJRJPO6hxNDW5yzKI6WkmlLCB3dnUOlObjruDlOCTHSdz2hl6Gfpmv/eUb25X6ZG8+rWvj5P1mxvqkBi1ypBFbr11xdg5Ma0YYUqnxTQLBoWd7b+qQpgvakuKPvN1xdOTQ19Lv10VapQrsbVcfWnsfwKctPLQvfjh+Z9+l8N83r4EJfPm3WfdzUTMPYTtJ0LYMlHt/+Y7LRU9++Y/c91DdPMcKee/3x646/S48p/9j9p6SdDyl/ua7DXx+TzpXxPla90/f6Kbzyqfl26tnm506tPeeW8dBd58yTsgLN++LYDH9e0ODjaL7m6MHZD3+zD2uy62eS65NJeNqa9Zjyv48yP2SN+13MncfSJz/6jjc/uWO9vuH61ac4WSNyBdKQkj1F0ghi0Ui8CMWv4PedFmXWBZqmGt6zSUx09U4SXgJ/81c73n0TaTcVu3t4npm6VMZ55a7XK168WHF7+x5xStvtqOsVTbPKenz25HMAmekopp/7MrLsyadOBHUug2Nattt7iwY/BRkJxj8Doe8tMqvIJMpMkSnKCnJII1BmgT99gh7jQt8PXQAzF7rQhS50oQs9QAPDdOTc/PtRT+fMECk6AA1cTp0RY2K3a1H9LivVe2I048xmU5OS0qxesL66oWmm+URH1ayQ7E8UNGZwhVI8WZ+LGTvWH6IOXRBkR5uGZJBJabeCJkL/G5xYKPTdfcNXX/yIhxSxqyvPH/3JNeI8+IaqWeF8Q4w5NKJgRpKUPaUTxOSGUIrOwyc/8bz6ZEVVN2hKtG3IxsGOGHvefrPh7v23bO7ek0JPu9ux2+0MvCQeweVw/9VgwHGuspFQRyrpkIqxBwsc43A2RsmgIpBQCcRE9lRPSIqWVqGqiCERY4/3FcWsJKpottIp5uFuxh0zKBUP8IKXMsf07KFdlMrzoZLp8f25PHrjK4kc6YUxnYKqEpMStx31q4b1Os+5d47+rx32z2qP5T6yYezItJR8fZktLs/wfVPaeaSMEW3GsudiyzlKGt27rxx5jGeXTP4/dc1c7DoFljld12ll92OUWucqU/av+zgqmKcoU/+u0vZ2zfZ2fXA8xR0a3+LkJRAQuSJRkajQDGSR6XwSnUzu+Zg9sceHhca0VWYEjmjq0dShqnz9S5e9mQTwrK4qBI+mwLbrSGmDrxrqqsFLhWpHjM+TjgmeT1m/RPPZ/zxzdr+Npwyzcbci7iDeK+32npU3IKeqgAopeqCklLR7zDhv6ZdCCBYVI6V9bypNQ9QRM/RP3vgFHuHgd27wcFTG488JWyyRSuTgmFGa8Egw7tVjNCVF1QBFqKPgjAz8bBH1hqgqOirkyNcUEIZIAbbYvmzRR5RINMOqs8qVMYIUaiBa2/tLy3MkmqgIDhE/pOqxP/OCA6XvO0CoKk8IkRCjpYEszzflXx22mRfwjubEihNk05yHnAJK5gDxcV3Z946ce0sOis0J35EGxaIMfE1Jq2TRXibpKcXSKcmQNqwwnDlKnhvfkMHDjzLG4/McU0JPny0/zjibpHhplmRGo0JUUyKGjrbr2G239H0/hO5WRiBy4Z8mvTqpb1Ts2vUGmHbi8Z49IM/Q1zFRWOCr18L6dY2vPCEIzV1FuIP2t2P6i4M1I0c/KSr1Az5k71Jd4Eum3NV0b8lREL8vwEx+DiM3zGHrw8zNagEqBZAei5LJAGBY4vXmvEwfekKw+Xn9YoVIxzjH8v+ilND6T36c3Abn4c1PauqVB80ygZjjgC1ZjhRsfy8etNhKgcPW9AKGiqmj7zc437KUbvEhA/P3zX/p7LvMvo30WM72dK0fBJo59+4HOnSp/cduOVXbc3Pj58yD71cC0Mn/y614Sntk4du83ONHnlLP8SPnn30c/RBsyfP3+inrzHPMt8fWu1zf8VY8pX1zfn+Zju1UT6XnWuk/3qqjs8/noI+xZv2+6Cs+znr9vHR1o3z2x8p65XHVFaQ1SgNa5bYX/WohefC55vLAKMvsO0E8JDc8pGs/x55wiuby9SmwxXLbJcsxChqAlndf93z1BXx4vtRlfcTSKnJqZXEOfCX4CpO/peiPNOsesuCt8x1jeUzmwJnJiaE8ESAlixhvQV9x3iNojiBaIqxGQNmPuDzKq3pEqX2uLelCPyy6AGYudKELXehCFzqDzmFmlhDNSww4g3ldaZrVqJAXaNuerntnSvQUB2QzKjTrluvrnvW6GEYF5z2Vt9ykoFQVxLAj9CUlVI3zqz2l+imm7UP6Q/byK4Bx5JbCoO+Uu7dCTGHwwFVVHImw2+DcDjTw/ttDoEy9Uq4/SSgO7ypEHK/e1Fy9XJE0se06UKXxY/qgSA/FaCMQQyLhqK8dL/9QadZC3ZihKcWO3W7L/e07QtfSdVu6bsd2e8/d7bvBUzuGSEJwVUXla+tb8dlgZWmKVJ2lKHLOzMNZCe1wWThRvAiaEkkjqsZ4w2SsEZIqTe2pqhrVnhDtOucMXBU1ITFmZj6RiJbySByqQohh8EaeIvBtoIoO3UK1LxnBCuNv3vBuFCZKOWKKYMXE0li812Nku+1xUrFqalbrBvlDkC7hMLBNDAH9ZjVkfJmYmCZNnBpzhNF0OQpGs6fan3eTb4PnOiVKzb5xalQuna8mWDKkPASaOWKeOnLd7NgD0T2OnZ97rZ5X3/G6ltVULB6RvWMTo+XJmh6nnDtd1rwNf/+o2ya++qKj8i0id6j2JGoiDYrn5jNPs4ahp5TBwGb0gUK82AphZRtQBgyUePtdy93bHbFXUqz3jEoC1PWK5Cx/dNf3+BhxKG/f9YRt4N03kedQ7izR1KuTBS/xU72yNNc+jipk/q6MprlF5ZQqm813NNevqfw6g0mFGAJOaou0gILoniG+7Kl93x8oEJ0rkTlKOq9lZeL8+PQJhu/5fNLldVS0pAZaLn+ZbE80o7XMjudvC6GTQRCXe3HY8tywR1gElBFMImJTfQoZLmAZCwYiQyTA0l8lXY6SRnu+IW6sf90IYhrfyDFFk5fCc0BKA5toQOnhlROSJvo+GA+UrLAS7EmGMcv3aa5DPHgHSRGXo9eRU3ymNCwTBTAzjkneacV4Hc0R4aa0n35oypfIAJ6V/LtE07H5WOG8z6kr7Rkt2owz/tcxKDmHlJKu1DGmmByi1TBGAxrA7LPGzpXNA7NSnr8MGZq9Gy2yXkyBGAJt27JrW7qum4HNLLXTodJ1rBfYC+sdQkAkRwyqRh7tQCmskbpyIEWp7ElJcK5hvb6hqvsMelamcbr23o4C7pB9zmHpTZkDeDXzszBZ+wVQBxMQ2lPo8UplYYx6mX9nYH95b5xXEEvLpDqCMIc1X07zde+/jYgLrJpECv5wvu+ZOQ+5p/pqS321y1yuzXOQvEYkmtUalyNXJoVmlaNK4dBk65pKDRLNo1rtmcXJMCetQmdODRm05Qp4L3aEfoPGMOGXzueFn4eO8K8fUMJkJd675mlPdRxgNi/vnBn6PPxA0SU8vszve3RLnYXO2LWP/ppLd0t0zrM9NI6n7liSmU7Pg6f09sfjGn/odGgC3T/HwdElOjXLH5IcD696+Or9Oz9WPz92TXyedpwnlx+v63QrHtabHL/rOft5Xtdj9Acf520d6Xe1Xv9Q1gtf96xf3lPVDc694PqTV5ZiuHqBSoN6l6NhhixLjHzPIBCxH1mk0BxwMk+TWmgqD0yje5+Sc5fALE/Rv+9HLB2PDdzlgv1hKaJnvnPQhQo9qtuPMtCF952v4HMI8eploLnqSVGpqtrk2tpSdqtG+hBQFfq+J0TTWxSZ0Bw/rNzp8y+2ZwFkZKlro8m32E6uMZHE+GEnWb5DCX2fHR/i3vibQ6kJhA8N7QUY8/tHF8DMhS50oQtd6EIfSA8xaIcMUmFxzTBRwgoOYfq1MF2jcUCcELvAt9sv6UObo894rq+vub6+ZrVa4ZwQQmK73ZiitWl48fIVV1c1o3czR40DH0ouG0M1ZWW8V5SepB3vv4z81T93R3jyPzpZ7ss3iT//H3o0VazX11TVFWhFUiGFwH37nkp7pClMtAwpipw4vApd7On7wM2PI69/6qhrgdSy223p2y23797y7ddfsd3c0bcdKdm9zlVo7VGpkbqhluzFLR6XwSSII2bdnXk/V5ZmIUdUKJ7aYEYy5x3FOV2TIA4qV+c0SQXEAjE64rbHOcequQKSpQMg0e12aEqs12ske5PHGAkhGKAmRl6/+oSmqXOUgDgYjIqQdVJJUQyig+EOijQwRngxoTKUqDg5PURMkRAiTd0ga4/773pqp4gLhLgl3G7R//0npJ0bUkNl09pY//BX/o2/S90cfYb9KDRmtlGLizMAAnSoZ2YiO1HqVAk/qkhHVdKySnjp/EMi0ymP1Gn49uP3l8r3Q70/Lx0rcX9s5r097eFlNdx5ysxjdy2rB5ZL/7tO7799wf/1z/90+G39EIEtAH/5P1d89lNv80SBZNFGUDPe2Ts/MdUfGY5je4mS0OwZhCREE0gkhJZvv3D88t+/OnIfhB6aZs3r11cgiT50oJH/+18G3v5KgcO0TB8ytjp7U+dqncO5utwZ8zQmH5vmZtjjoJlE6O9x7pq6IoNlIPZK1GBrpVOQMaqGYCDU1Wo1RJsZKfdVBk3Y/jZJVZN5jKkCb5wngvMyKBv3lIAl5cwB5XSER7zH9iNtTG8Tc1ebtLccPrmGSbC570xZpjpGVEMEUT/sB4rt40VvF2McQjRLBux0XUdd14gIMeoQbaRqqgzySLaPat7r1NI1+aqibdshLQ9YmiyoMujJ+jA4iyTjM3i6RLAxxW9OTZkN6QijB50zQ3wfw2TC2noQUxp3YFVi2E/jpGoApykYZRziEv98HN+p1+Z0DIeUSJqIUWlWK6qqzvOwALey56ha+6o6R/XzghJRTThvSlVF8b7C47M3YOYgdBxzVfCZ15oqwaegsNK24Q/B5UaUaEGqiRQszaaI0nctm809u91mAMokmYJFxj6e9kHptwJC00m/jmNiF6X8afymlWvvkgHURXRYz1RLilCP8w3iDGAtk1ZMVvgy+2evxhhh8BiNU6fPOEYd/4b0f4npnvIYmjsgDPUelWNKPdOnEgpgBrUh8V6Imoixy3NlVkqOVDMYJsbSUeA3/2HFb/4DKPeMPblXo/WbjFEZmZy/+cOv+ewXv8TLGi9XNM0rVB1t19H3gc/+6I+5ur4haUUfsOhCkmAAy4Di8l82UAi236KIRJOF1CGpzmCoZEB/EbyzSJkydaogr2kn+ezzSY/+ei6u9NAIM47BPk9/nMOflnacL30oXswpPvT08VFuOaeNY21P68O9d/33gKY8zbSXTrX/8Nzxpz7V5zL7PHXNqbOnV88fviHtobn93HXtS/tW87nzdmkNWx7jx/X9Oe/Lh8khP5yZMJctnkuSfsydp3YLXbjmqXTuu/1DGp/vg34o+8T65p6f/cV/5JNP/4D66heI+yzrtSFqQrXNui7BdBg+g54dUBn/KYUn3acCnNDixHCEpxzS00940blMMz22RMf42FP1ngJZmBg7tmUut0zLNpnTD30hKF4ixBaDBTw1xeYhzTWgp96Zz356zx/82TfcbTpubt7g64Zvvv6KX/7qS0JItG1EaPCuwbkGyQDy1WpNXTeIcznyuwPSYh1DZB3G8TKwC3jPYFNJIdCGe8BZultnugqNiW63pW1bzBm5yg6pZX/JTkN6hm7hQr9XdAHMXOhCF7rQhS70kekoaCYbXsbrGIwDTsaw4cajG2NX1zW+gt2uBSDGwLt339H3PQDr9ZoqG1bMwGIeuIXRd868dgujeFr0W1aPTA1fWn6nhHOKUzOMKgGI9N07+v6OrvXAZ4/qt0LOVTSrhs2mp48RdREnZtBVlOuX1/jKUVU+G4ag3dwjCE1dkxC6dotzUHkQF4l9y9df/ZIYWvpux3azYXd/n402xuBbvdeEnI7B55QAI5q8KKcNWGJDqoTUm5mgoP+lGJ9z36SJEdEVD21T7jhxSPbuV030fZ/TTNk9RalvuVwbM2L2PapQVQ11bUamGONgnANIyVJ0OZfnohtNJKOPgiBZiCqQGtVRiLSxcMP4p5STHGUQjWSB4f37t9zfvef66gU3N69YrVb4Zk0IPW3X0nWeiBJzRIOJWW1vxpVZ54Z2Cm4AgOyDYqbzVffKK+VbXcvi8pROn10ymO8bR0al+vgsunDXsfJHwXL4XDAuzUEzOouC8bFEsodEQJlddUydfb4C6vHGlYcUWucbIx6m5yzruehcZZ4CsX+H9orzDU5qYEXK4qEWg6P6yT6VZmCtYoDcH/USPtfN0qCBIOqofI3zx1MqCYKv1ngvhGhG56aubJ858YBPGY9T82U0As+jzJynXv1Qg+NjxnK8fh80M1yTEtv7b/jm644X15+yWl9TV9e42pOi7TeFJah8PUYhyMAAEYd3nhCDreXtjpQSvqR3wuVxz/VpSXlSfu8rBEeF3mSv0RKpZt7XZeWWoaxpPdPIIfN+maYGKjxPuW68fjoL8pgJtsdPozQAxQ8NAZ/TGgkOUQOEeS/UdQPkyHTRosc1q4YC/awqGc63bYtzSl1XVJW3SHYxDYCalBJV1QzgEec8lfMkcTnCnbXFwC+mwIvBPPEUxTnPer0CoA+Rru8hga88qomuj7n/Z4pZQ9DZPFBHipE+9JauK6fiKtFy5grkct9ceWlgoTi5bjInchm+Np5VBoxTGvo7Y33yuCldaEldBEnGW6nNx6ZuCCGw61sKN+HETXi3zGE4hvERcdT1qARdVD5n8JEddyPYBuPFU4p0XUff93SdpVUdFbXHo2GVyJPT/nBObK0rQKRkoLCqqqmrxj4zvzcAzxDE1SPIq8zN/AqlZFFIUk69p0z5KyXJyCMV/onSg7qs9p5LCSLBrtMKA14yzPty8RPwMk+kBXNPTo9UzKmWrMjjqC0O5Gytl9LgWaSZ+Zq+1Ddl5cpq+oHbnp6v6muuX/6Um+s3eLkCXaNUxGTAKN+sSOoJyYDfIo4xEk4B+BSjhJuMR6REdFMgqQf1tn8L+Aywq6oKX69zGrd5mw+f4xTN+bpDmh/9MPPjaYPutE3zft9vx1JbP6Rlx+5bOr4nP0zSm53mZeYjdLyOU6lcn4N3faiPzq3jnL7ef+Jl6eK8cTved4fvtf1/Lve31J75fQ+P2uPL/96WVD70rd0vZ4nm/bQsUcrCt/G+/bPj+zT+ml798Cw9tbosHf3YPP+8ho8lh87XzYfG7GO259j7/lxln7sG/X2k37Wuo6lf8NmbX3Dz6g2RN0S9ys4LEZU+Z3xOTEExmvUTtn4nFp8gyxLFGXAP+FJOYQ6UhYcbZC10DKI4CJWQgvHj4sao55pSjsR6PH3Sh5CJtrPUyLM3djiVTEZTIuo0R7N/PrDMIc0j9Onet7aN3N8GNtvI+3dfUTcNIbasViteXNX060gIjhjEopevr6jqGl/V5rSRTLZPkhDJUU1L9NBk3F6KJfXS0DlDy0JQ6qomZn1GVdVDhEdVpW1bttsNqnHPcaXIzNPsAUvPvsevDfLHEpW3bElWfAwn9UPTSv5+0wUwc6ELXehCF7pQpjmzXOgh5vYk+nuG8IZR9WJ8+kzo1aIAHbm6qXIvJVN8em8GEE1mMGkaU5xXGfUMjhiF3bYj6S1V1VBVltce1BDTSjaSFYX+5DmECVp/0h61UPICA7BjNHYFUtyRtMe5RN9v+E//zvP+7Su63eMFhF/84zUvP/X4BjQ51isDsXhqBG8GJfGsqpUBPfqi+E94hb5r2bY7qspDanEkNAW6fsfm/p53335F13V0XUl55MzrsvZ4V+F8RXQ1XmqqSYQeKdaDiWnBoshgfStQPD7HcPsKRFNeupyeqXSpaPb3zcJUYmI4rOzafLkZMc3LVJN54ntxOB9xYvNDkwknoQ+k1Oecq4mmWWVhbSJQFSNI9v5NCTM8ZUOpSAlUaXMgTkOUjvIhPve8xkiVFe9t3yL3tyiRmAWN1dU1dbVC/mnPu3ff0P9yTfry9b5Qx1S8GhWWx2nyflAMPeNnhvXYn0zNQMfLmdNxRer8mqmarmRQflipNnvLxmtOWJYeijTzUBSa56RTCsvjqv3De0+3WGf1HO+b51Lozukhg8f3TU99xtLW//xvV3z5N2NaENWeX/xFx+vPKtDG9Cq22FvKHkl76wd4i3acBHHe0rLl1czmf8irh0eywc7WMeWzn26prneE0OP9GucanFvhfU1VO6S2dDJOQDUQtrfE/p4UroHmrD45d0ym6ptjqRfOqe+wziVz3XntO3euL5e1z2sApFhx97f/gO0vK67+8D3XP37Hi+vPePnyx4CiwfYJglJLZZEpnAE0kiqVa5C1QzXS9y0p9cSIhVBWSxWYNA0NKfvO2KKZQnLYPnXS9ymnCuGQFxsiZSljAfk+ZYjIATJ8UsAkblpWGlMRlj14IdINB8Cw8nXQtA2fSo7sYdu89QNFkTYBT7oCvBhnWiXkdyrY+yOMaaJU0ZjrTMZTmK5TSS4SM0DJiVA3NSlF+r7HO6FZ1XRdS99tQWtU1UJbozjvibF411n6F0v/owNfaNcpKUZSspSPL16UVF46AGU18yfDe5O7vaRCUp3NgwVPzCHlYwYQq+QIOUNEEkh9tP7LlbiyZmHqRQMbe1SVru0IIZLy/HTeUdeNRf4bFKFigCM3Kj6nf845A5trtNRUeTxkSCtq7Q8xWJjuGAgx0nedpU/CWeRAIOHR7L15KGNMeP0ZYEmLclVBcNRVRVM11PWKuqozsD6hGi3CjfOoOEII9i458M4AReZ82eIkAygmoJmpBLDHQw3vnByocKe8y5Sj+uKvAl/+x8T1G+WP/9ELRH2ezxYuf7hSps/NWfS4qJgT/lzKU+UWi3kfpxSIUQFPIy9YVYcRZo7RMZ7mmMq89NMcWOP9imZVsVq/JsaKGFYoDVJ5cwkoqZZcxDlrX4qrHEXIgDOiILGaPDMIna0roggVSkNMBsgPqQcJ9NrTp95A92mf57Y2P5Ro9Phzn6e2/3Aubc5rHit1vp8Wea2ce4i/fyqdjBaZP+c8cuHtl/twti9NyjklP5wTmfJUG59C59T2GJln3v55/8w5g4drXtD3LByRg/OnPeanbVgCTZ/3bjyOTs39j0HHZKzD2fm0sqdlHOOeT8le45s9fsri1cvwueNlTp9rqdc/hiQ47+1zV+WHW/OYMTpV1u9C/v0Y79D39f78rulj7Xcfi3y1ZvXihj41JM16bGcyUQzmzCGupNjR/EBFtwmgCziFcl2+RshpLEf5iwxcDiGa04KFkiwcMsUVTwr/LlBVfnC+TDEOxQ3q4CP7sKbFw0f53kF2muodM7BfYXDEtEfLPLxm4LaqRUUVITF4Jzw7zVfI0ru+Tvz8L97jauhlw+1dx+39hhAi3ldAMGB42tGHSYQZ70ihp2pqPn11g/OevuvpQ08IiRDMWaHvE+BpqmuyhAiqJO2zasAkM9VkEeJxiJiDct8HStTaEPohsm5dWyT/FBNpOiQlhS2yP5/2aALmktlKU0DNpR2DNMbokHrglMKB7WkexfdCz0MXwMyFLnShC13oQg/QUxHhR8Muogxeyrp/ZnqNARaK2pKs0fYWar5iiPxhin0/INnHFAmOXdvRx0BV1zR1Q9001FWNSLVXq+wxzJIZwBFxPkQcQZFsmLLA5uZVW1UeDbd0/VtC2JmhJfW8+/ZzvvvN1aSc84Xcl2+Ez35SkdShKlS+KZ2Q9cLJ2lBCvasiGomxJ/Y7ut2GFANV7dhu7nCSSLFjt91we3fPdrsjxkTxyq2adQ6z6BHns0d3hcMPDO2gWpFiDLK6i6CkGLrd5KFJ+ODBizr3+GxqDKHUKUYkhrGc9lox8IDkyEMWMUiKYSrE4T6dMNdjqqpsoBrK1sylW/u9Kx6q07mYcttkYN7LJYMoZg1H1TzXi8dyjIG+70hEVs2Kpq7xroIfb9DmLfrta4TXFFhYmtVdfo0GnIdmTWl9ActMPaYP595hlJrjdM4KsG9wkCFI/rE65kr8R9NUtp94Rn+fYJmlJk2pGOHGX09v276YeVq9dY5C9/eZnkMZfftNxe03U+Vr4kc/e8vLm4T3VwhrHBXiKtKwX6WscADw4DxJHUKFist7h11gIBmx67QG9bmuxItXifpFJESofGNe7m5l9UnEuzZHK+jp43u297+BuCWln3IKMDPvo6eOt82f6f+Hc+pDVRLnGV3Pr+WU8VCTo3/3KT2g9dek61/TdzsqX+H9mgJ7RARxGQCb0woltf3CQLe2B12TLAKCVCTFIqNMQDIxxiGaCIwAmhJ5JuTIHtbIDIBIMuqcps+R550qEMfoeGN0mbxzDBdP9yS13PaSd1hRS+alJXpfjipXlIwP9PlU1zXsHqrDfmisycgfjMqtkScsaZQAvM/pahSSRiT375BRXfMeP6Qn2k/6pWrpBlOKlmO96/DeU1eOFAKkRN91xBQN+FRbCqgUQwbv5t03P3+JHqeqOXrQ+IwWjWVsOxSFnvW1lCguA5BjOuY6Xj8HJ+U+dzmvlSmb42T8T7/FhefdC5Oe+aMQhAqIEiw1Uj5flJIWtWcftOGc4Lz1eXkPRDAv0b5DcxpKTUoIgS6DZFKZZzkCzf5bONm5pl6geS4fyAtOsWiNdt57x2q9Yr2+oq4NAI9TUgwoMadvTWjqIfUIiRh6urgjaaDyQl17nGtgiCI2mUeM8IgpHza2fL99U74MRmDF7VcKRFIKZiAoTFuObCJo3i8es5I+bRWXAjoqTyWKvf1uqFbzGtZUVzTVYdQz4zsn4zV51vn6fc5KPQfNeF/hPGx2G3Yt1NUNVeX3KcPPAAAgAElEQVSGSGpKtLbnVFv7kohOGlBSFI7crnW9A0r6uISlY1JC6mi7HV3foWm3t1Z/PB5p2mOHvfXhKv79/frhloztOd2y/RaeU/7yncu/p7zF0IYF0MzY5sNyDso/IzLlOfzRU571XDqnzQfnZewN5Rio6Lno6U8+n1lLa8XHaPfHHK+H6jqUrz+8LafKeLj8/SsGfcVM7t8fi4fn1WG987f3ecd3LoWcW+45132f8+U56e+KHP9DoR/6PBBx+HpFUgHtUO3zdwPLFFlJdaJNlDjsF0dFCIUidNqdowQtCDhwOqYb1kEOCoNMayl6/B5g4SDVsCzw+JNzC0vI2MRZOfMyLaXU+JDTsZTJ/SkZNEaHZ00kjfl5Pi4sYM73ildu/uA91ZXn2293bN719J0QgkMrZ7rohEXrbAN17RDv6KPJNRp7rlY1NzcvaV5UxAi7vqHvoao9sYcQwPuGvjW+3vuKSkp62BxtUwW1rKV454kxEGMY9R05VXIhc7iYauyHJzp44tO/51TsNnkOZXnaOTfUX9L1jvMs8xaDncDqSUeCKV3oaXQBzFzoQhe60IUu9AB9jPCJhUc/Uasp6GWSWkHEorrkCB7qdDASFBFB1aKumF0pElIgJKUPLSE0NHFFWq2oqzUyRE3ZZ/qsRofXwlgqEICASsRJJGlg917Y3gkxBdbrFaHdsdtt6cPOADVe6C1zFNVKuXqdcK5CxFJ8qIqlFAotu/eO2O93SIxKzMCdKbBBU0Q0kGIHmgihwyLzKCkFum5Hu71nt7snxh4R5bvv3gKCJuj6QNf1OFfllFU1VV3jfIPPoRaLAcOiJqRsTMqGsYzgH412bjAUpcx5z5WaD9EgMI1PeeLqwiiPDPLcIFXKHMFTY+qBaZ3FmGXzykBXaShjohzOz1zmR2HolZLdKR8TMW9sl+eRKn3Xmwc0OZtwVZFSoq4bYlXleBRFPNU9D+d5j+jB76KSLEaMaaqm6b/9suaf8/KHPpqUBw8rdCcXDiU8p+TyUGlzoMyBEv7ZWvIwzft5pONPMc7o0+XK3q+lEvbPPtco/C6VSs9R73x2LPXJd1+bMqqqEuJ6nNgaGZMjan7fJa9/2TCc1IFWqHquXjZcvWxQaix9hCm1NCulzErpcK6irtZUzuOdINKDRjNyxsD794BGNHa07Y7NfY8XIbSPXFsPnvt03ywZAIqaWvZm6IeMyL455fg1h22atmvpyL5aaimmAcRdTfvNmt4l2NyzahTvsyFdPf3KQAL1dcvqpSBS59znFo3DVRVX/pX1gmYwTIzDfjL9BNtPQgjEOAHVSEdK2YRR9s8FTU9KJY1hmT6yt8ftK5BGfm3cjxIDGqIAWwtwIqXMN+lwmsxzHZs0Mp1Qmr/qwDXMrpX9thVjzKTdUkAilD11VIIO3mb5nbP3Tmx/LXygFKVoHNICpRSIAWTwkgskTYjPUQEnvELKDzBNszlol1Xx2aMyhkjX7TDFXmmfgbpHoNJ0xxn5kjl/Mo04U57V6nE5JeYEaDpTPJffcyBOGXeXIx86VyE4YixR9iw9lctRk8TJsI6Vv6I0FynPFbNC3OoJfUe33ea6c/1JiSkRoz2Tz16oKaZRSf9EGaKsmc57fFWzulqzWq+pqmoEJYnBgnd3ke69RXlEIyJK1+3YtRtiCvjK8eL6Be1dNaujjNpkP8gALtHDtWMYXbG5aqYJK2GIsygKLoHvYDLHJINmskvnrMSHe+P5yIAzTrw9p3i8q6n80jgtcTDT5JuPJ/HC6z9oEJe4fg2ocnt7x2bX8/Jaub5WRFZm/FHBQKj1pElqvZ3XjeHdktEkLJLB7ypoCqi2gKWjdS4Qwlvu391x9/ULYnD0XfXkffLY8TKyh6bkWX+cUe9DbVpqz1K5h/zwRM5Z7IHl1s1n8LG6DwxFR+4aWzEp4who5lTrRGXxuE7OPxY089x0rM3Hzs+vna4/p2fWSA8/48Oz8LHzdN6331dfH5v7H6Puh8p8PKf8OGn1VP3775Qc/D+FtJYrp3Lrqfhah618jKT7UFnHrjle2oeM7fmr3ofR973OXOg4Lc3NH/L4dG3im193Wc+a8OuOep3wbsWqeU2Kaml3snxiclYCCmhGQA1YM5IMn+O6UK4t8hYDrz+VOUq6XWBIizpNOVto0NFP/sq1MJFhswRZjhWay7dDy4855B5BBu2Xk7IiJxFTIKQe1fOckJ5CUx5waLUqIW1wWqNERDx11VjEdHGI7EgkJEUEhxeLTqwpElPktt0Sw4bN/Uuur6/MwaGqids1GmpWjePm00SKFRvZEUNEXImkalmpJIHDgYcQ9sP7VFVFXVeWgjcfK+NvD/K8K6TL0VWd84NzjfcVIm6SNniUl02+ZtCpjPNzSYN+oQ+hC2DmQhe60IUudKGB9kPefQygzJQeEn2LMWp6XQo9qUs452gaixgjIoS+pws9KcYxZyqK90JVCb4y5thSKUSql6Z8NbAHMDDr9udQnMacyiCi7FBpIQWcV0J7z6/+Y8UX/26dW9YBa+Ani89z/Wnkz/5pR9NcUfk1iEWO6dqO9+9u+c//uub+6322xDlLL2UMqoWdV1VS7En9htDdk2Jgc39LCD2qKYdPbNHU03U7i24SA3f3G6DB1y+o6yuuX77C+4q6aobIKykq4CwlhIgZQvreGGzRrDzJyuns9T2MS/ZUF/EDQx5SXDTkTYWlcm54zkG5Og2Av3+/0VQdO56fz9k9r9E8p4sAp6p0nQmgVV2PBstJOUUhWZ4Z9t8LEcF5PwiMuaIchlRIMdJ1Hc1qZenDgMqvQBOffvpT7l563jGKqyWF0Rjo9HjUGQ5EAmH67gxRaTgknf7J/nVzUeNkWqRjJ3QEuuWMCoPy7ZQi/xzaU3RMbnpIsTf9/rGVYcvjM6UPUx3P79xXWh4+3fOa2g5pVHU8X33PPUbnKMcE+OI//IgvntQOS6Hyi3+s/PwvBY0VuApIJAkTBYMAAQ9IhJA6Yrilbzc4Ik3lSMHzb//FH9DuzDsePsl/T6PHzbYR8Dg1pY2ghnJuft1DLXjo2PLcfehOnX2Wck69E+HtTwlvfwrAZrG9OwA+/4dbfvRfBerVK8SvQDxEQZNDqWxfyOl6ihG/0HSfSSnR9/0AmjGvrbWlzcn7xlQBWbz4irdXAdIIil9QJh4lzdH8yjUF4JCjwolzOU3PRFmmeQacyf9NFYAFpDMFqxbAat/3xBhx3hnvUWc+IXYD4MRYCgOXWVQfECeWQiWaB5yvaypf4yuP5WQv0XSAnMYlpYgmi8STYmCIxgc5/RQj8DoVvmPkMTTv5ymPVYFkW8SZHGEwR7qzCHYygJ5yVwzR7OapuUpExClf5L2nrmsQoe1ai3wzLBejMns6Lk5kTA21BKpJKUcKHBXUdV0P8zQlzem/dCi38M6gGQAzRsnp+57ddsduszHgzWSM66ZhXdJB9R19b2mbXAEtPEKWGPjE6MB5fFVRVQ3r1Zq6uTbeOZnRO6Vo/e4d3/7Njl//6x6hwlLwAKxQXudUlPtzds7XHOMTJtze3rGiN9Z8MJX5NXj0JlR3dk5dtlkUQL5Oiny8SfVsKtEnZ5xPAaJIST2nJWXgvtJ8CixY5jmmq+y0jmOABLu+bhz/8H/8lHrdkWJL11VoslW761qaVU1VeyQJ0CBqQEZVByTE3QERsvfroMjPkUWdq0zOUvOYVr0lhrekdMdmc0/SlpRuuf1yxa//zT+ePvHZXfuQUX6623/EET7annl9p86N9447/qlrD+WR+Vsyvf/0Dr6/l5e3Y1LiifRMQx+fATiZ3v9Y0MzHlBuOAXyO9dDQTs2gRuZuDYd0xIS48Ps4//Wx5+9z06k5/H3T+e//8i40n3/nAjz268188Wy+Lb3fScbotMtlLbd4qbxT79a5Mtkx+pgm0Yee6yll/NDpd/2efN/0YVqY75fefZX4P//Zbvj9B392x4/+y47rF59Q+RuE2mS9DDAuKYcKDyhOQN3sgfNaUCJ3psl+PYlMWOSYEPocdTVfMnFILLJtOT53lvBZTwosgloy1Gc4P7dFzHXGS04H5fteuZP7q6pCnMlNiRGA4b17jIjyaJqutaNYp/hVi6t7rm/WJL1hcw9oQ7tt6dodoU+EHrxbUTmT3by3iKDvb9/xzTe/5de//lsgcXV1xU//9M949//+Kbvvrvn0J/CP/idBteJNesX93Zbbu7vs9MEgx4oYcF4kTVIv1azXa7x3dN0Iiipya4zxCUytmNC0pL8QxXlh1dSsVmtW6xV1bc67KSViiMSoeQw9VVVlnbuy3W5o29Yi8XTt4B/0920t+5h0Acxc6EIXutCFLpRpyWt5evxZ63pAwVMYHpVJ/blNdWPh2OuqGsJAigi+qmjblnX2QC3qbENvZ8bQWUqnlD35DSDiDDSgJiyImDGl8kKMAdWOxI6+v6PtNjSN5+XNC168eAiRPj6hcyvWq1fZyOazMUFZNZ5PP/2E39Y99+wrq51XvMSsEI503Ya+D+y2d/TtHY5ACD3b7b0BY1KyUPkx0rZbuq4jRQtVv15d4/wa8WvENzhfEUIkxs4MPwphkrfU+woB+hjwtQd0CNPvnTGsTbPKQlQcwCbOmRErxJgV8jKUOU0ZYMO5b0wq1yrgJA0c7zD8OTWS8dw68N7FaFnKmIJi5p4JcyGsyYArS/O0b3Aa2jhIBpYyQRiNocbMB9JEcBy96W0iO+foO/Ns7Vqh2wo3L9doyvIDYzD5/SctnstKREiYKXGJ9uFFY1SZh9SoCpNr99/LPYXyEdDMkiJZ5v9rgVrJBJyzJDA/LOTsKfBOGHMOlfrLSulz6nkslbrntR+WeVxd81hFzn5d37+q+CFjze+a9hW/yyPxXOQEfF6fUlLwPUgcveFRvNg4xX7Lt9/+mm7zKyq3Y92ANo7Ur1D9hHNTL51D584pG8vx/+nRwSA8U7o/j0HwuLHmobsOjUb7YJ6ntq/dveP+/pbXtRD6HcgakQahJsVIDBHvZG8BLuDPeSSRouRRNVNESom23dL3xeCbcjQQHaN3ZBCphSLGog8tgCOAvb1un39LkMb9sLSxXKc5isp8b557Ck4VkiUEtpT6JyAO7/1+JJ18j/EHbjBux2jtiCW8c95bNY0ADkHxavxYCMHALUmocLRtv+fh6ARSBvg2TZ2BQBbxLsbMR+XdVkXRuBChxdks1zQqBYuSUxj5DRtbLR1gZ8VS3WS8Mabskz1FcWlr6R8wRXNVVVRVRUyJXeZhnfPjGDECjUe+Iw7K3hgTcQJQVtUM5LV2zIHLYwSZBINHowzzD5QSVcbSSvY57VKkbtb2TJN50IdIl6MLJlXIQJmEDH0xbduSt+gQ7U/Ms/Bq/RLnjFdt6tpSMbk6RwsKmHtkQEQJobcw4tZjzN92p8uxM+Y0TetYShpL1Mn3YTUcy5fpHaAaSbE3Ba9vBiMGKLgx3et+TUcbdkbrF2+cfO73SzGMOPE4qUArIAP2FlJaPrR/jFFnls4c8gdeBGGNcw2r1Qua+sbSaUm07smO0c4p3itoJMVACDu2m1+y2XxH13eIh2bVEGLERslRNy949epz6npNSkLiPSF+xXb7Jbt2Q10pV1cCN1f86pxufODZj11/Cmxwak9aqutY/efukQ+dfxzXOL9j+WmW5YbjpY979X7ar720Zg+W/9hnOU1THudjcdbH5KfDNoz9vi8x7tPyXNHFX3Jw9Pme7FAOO9aax509pNNtfn4N1sei02/iaWn+eGl7c2Wyx8lgoh5nWGK8qfjqT+s4R0afX3Ns7zhHJnnqfc9Nj3kzfn/m24V+F3PpOajya67WV6yaG1B7i01XLFTOUkGLGOhAU8w6TjebxPbkKZmjqa+FPvTDOYuSzSDLxmhOHVM96pJD5Ai8HynGSAhhAF5M75EMJI8pLQ7GVH4qtASMWaK5fKwxr3ECOI9zNVQNslDHh9DI88ri98p7fvTjHyNV4svfbAlxCwghdIQYiBpJCDEZVxtSQpIiHpzz1Ks1VWgRJzhv+oXffPlbZPdHwDUpRHZtz2dvPufubkOiw7lEXZujT3FgAc3RRksKJtNRdF1naY5DADEdxBDpBXkimyCDgwpgbc+2gZubG169uqGuq2Gu2F+k7wMpmkzuK896vc4ysqNpKqra5lPXdXz52y8tAu3zDuffa7oAZi50oQtd6EIXyjTlP5dCID4XzdVsD9KEqXbeD2CZqq5ymoSc2zIyAGyUEdTgXD0BUvgJyMZaoEQ0BZIWL2PzUMQ1WdCA2ld89vmP+fzzH/G//a9/TdcqVzeRP/+nfQ4h6AnRk5JDFbpd4lf/LvKzP3/B+pUidUTUUm9AIsdoR4DaC3/2Xzd0f65oZkj7EPD1d7z9uqPd7djtdqSYcOJIGgixpQ87du2Oru3QlJnYBDElw49og68clatZNWvwNeo8lsVVqJqa4u+KKt750eCQB8ZJDa4AipQUs8JFdECjWxQeJcYOxWVPejOsVFV1kAppnqZgHhmmjN++Z6LufY6GwSyYuBFycgwsMy1/ek0hMxTFQXAq4fanXt0pRBNcUOq6JqUctUZkMMANc01GhVSUmCXznqQdyoqUoPlZ4vXriHbK+3/VkLoSp0KJjPCVFz8T1j+JtLv3vL/9Lf43P8FvbiYKr6lyflS57pt+LHJSUYIlIEn+LDXNPLGHuxcMKIVKiPCpKQb25aliTLFAPZoNl6Vlx8ueG7CW2rOsLN5X1e4buw499g7vX1qblhWZh7P0MevmcXXNUxU5z6vynpdcaGFMPlq9T6fDuXHa5PfwkYfrMrWU4CxOGarO1kin9n4lM2ZbupiKVX3Dr/72F6Q+4V2OXKGO0H//YmoZw9FAfGgEFZiAZsZ0C8/NLSwp3ec07XN98M1+PG2+/ITfbK75tllRAti/+uMdn/ws0jSvCVhamMXVYqZMLBE8bE6Yt17XdXRduwcwMbAMA49S8nbvPfCkjqV69w/YKA77gSqilh984K0mitGy/09BnJIRzEIJyzweL8CJmAyUYsCLQ7DNNLLcFEhjBee9WASVDDLKp5ImNCWiRpw4ogbaTgdPR58BvzEmUggkAY1ZQZyBtEmTsVziECd4cWPcjQyY1ZRwjJ6GomQgyaRfygk105IgQ6Qauy7llEpkhfWMr1GdRBnSIVLier0mpUTXtqzqmsr5AbQTk+2WhZeKQ1hsJaZIDPYqDh6UBbzkLVVmmUtFMVkAPBbBKFo0Hk3EqMP3cU5bxJgQLEWZ8d8NKBbdJhU+bvw9dMbwOTP+LvBdxdOztG+1WvHqxUu8b/DOG4C9ckBHJYFEQCTgfEAk4n2gckJR7R3fww9XhuFamfFAMp4dyplEzhvXPvvlFJIUcDDcfQt//S8E51r+6M/e8ennntVqjThPF654fDKjZ9xdVUgq2Ym4hGkvSUPTweUyAyzsr7uHLXw4VUwihm/xzUvQGlUB8VSVgLP0t0ICSaR0T7dr+eaLmre/WmOp164IweeIkJayK2ka6n71eeLT/+Y76uqaPih9/zVvv2z58v/5B6QUDdRaCbFrzty3TvM+p+46dvUhlzzeNe29cwzKsvB9v57no7FtD3Ooy/z7/h59rAThcJ6dkxJ2DvQ/R5451Yaj9Txwfnr/Ma7kFKDo9Lw5l996WCI5bNvyk+nsmqVUl+e15mlnzyv5hyaBHKcTEvWz1iF7n/ualfln4aEFwWUWfx696Jx5/7FH47lljcfUe+6z/z7R789b83HoqbqW3xX97B9V/OHP11ytPCKOlFrqGnCKBgNaGF+UI6mnEl9zQacqCec0Y7iVmHamu3QC+FHOn/Dt0xQ4Rfc61enOAS5zJ0by9UUmHK7X8Vy5bw6MWYp8esxWsRglVYQh8iCgeMjAog+hJb5r1MXur7miQorKb399j1SRzX1C1CMoIZhOoAsGaEkIta/w9QpX16gIXR9JVPj6CrxFMVYRmnpF86OvcdzTXHt2uzW79gXv339H13Y0qwqhIcbIer2i7wNt29GHLB8Pcq5mYBRUlR+cdqGAl6b6guU+X3LqmTrNijiLIik2n+7u3rPZ3OKco+tacwJWxfuKpl7jfWU2h86iUG63G0SEq6urIdqM946rF2v6vj9o14WeThfAzIUudKELXehCmcYwd6PCdI4efy4qaVpO0pxZLp6xTsyNPyunC+NWDFIxJWLXGpPqhNrXg7EgSSRFM1ZZkaMRRAS8M7BMTErXe2JSfOWIETa7wHfftXzzq5rNbeBP/9Lz+Z8Iqo7KN4Sk7Nodbdvhtoq4mlefez75EcQAkiJ9vxuML8V41acdUiu1DxatJAaqELi/7wl9R9fuaHeWg9Q5R9JEn3r6GAgpEkM23IjHS4W4mtpX5jnqPJVUID73l2ReV/MA6KAEcM6MZCb0WJm+qkkKKm5gmlWycSp1qEaQRFV5nAdzHCiC0SjwFOHIQvSPuXALUr14n9uYHBqZ5sf3v+9HWCn3nZx/Ew/8PAzZUCKQdPAWLv1Fvt4uy57XwYxe3vtRGBq8t7OIpGpR7mWXvQUiMSkxNTg8/lXEvwqkndL9G0fobFgKaKaoO199suLVn1ZsNzt23/bEt5G00cE7zMwd++biEqWmzLaSTsWJRawh12F/5fmX6aTiOCvFp8qk+edYjgwO+aWHYVmpfaq+4fv83MH/4/FRKXjayL/clqWaZO/bQ6rppyhlnqrIOUex93edDvvtiFJl8v/h8aeRAdkcUNGGYGDHSpDKYQDNClSp3Jrrqze0t4Fu+8NS2Y1vZpnn4/d9tdtTTCen6Vyj36FR7SFDz+MobNaEzZrt5Nj6RvGSowR5T4iTuFwzvuZYmGiQIbTyCN4trWUE82o5ltV7T1kQJhFgBkBDLndo1wzEOt8/dY8XG8dbJvfuPd0AVp3MmQXF5xiSWUb+zjSKplgUq2XgJTLGR1Vxkp9HMzvoHNFPUjuqFaAZCJ1xNWhKJJkZjjSnUCox3VK+v4ysjlFvxgc/5FXKp9U5RvEZUsZMzo/R/PzEmy4YEDdanvqUPS4lKxpjvgaYpHXKb6mM7XHO5b128v4ejK8OfVlSflnI9TEnvIiBt0vqqyEyEQUgMwKEVJm8izIcGwBEEyDGVBFe3oMqR4ys65pVs2K9bqjE53oV6GjbO/qwI8YWlRZXtRZ9RAIxvmZMW6fDMJ3zuuxH2Zse3zdQl/VweoyJkVHIAAFRup3w7RcAkZefv+XlJ9DU1wgNFjns0Av3OH34+jo+18idWSh+Janxj/Z7HzAzNeqXZztcdw9bu5xExyilwPvvfs3r+qdU9Strkdg7HWJHCFtSalFtifE9XXfH26/f8PUXf5RLKH041mBjZ7+8v2Vz9wWtX5OSo+83hLbh9ss3Z/XVPn3Yvnx8/zlnV3tKHY/f8Z7Olx5v68gX7/MHh5zz87RPgXkEmmk0vIGeASwzvfec65auOQf8M6/rcdc9JJEc3vfQHJoffcxMW14jnpsebtH+2v390e+Ku5/Kp+V9NBu47B07HNnp53KZ59b9d4lOPdMPS4K70GPo46xHH4devhGuX1f4yqIC3u++I6q3dENENELoFdxL6rpBnDlzjprSIq8a1+S8cnf3Hfeb95kX91y9WFO5FUidnUgPHRGPyXRz/Wo5N3eYKDSkIk7jtTBGaz0GnHnIsXceUXxwEHEO1RLR3GGAmceP/pKec082Xvqd9/0UlN/+ekdz5XBuhQBdu6Hd9daSDFiqqoaqaZCqAW+pZmM0XVLtBImBlEJ2eki0fIUIdFvP9j+t2Ww2tLsuOwvXhD7ifU3TrPDOmbypEUmjnGr9xdB3U52AgZyOh29ZGq/FyLZYlBsrOw5OGqqJPoScblfwLhL6Er1ec3SieijXObcnO75584a7u7vFKEcXehpdADMXutCFLnShC2Vq6oamaei67sBD+BQr+VwC8ZzBmqfwSZq9CSfH98P+O6qqHhT+KUddSaLUVY1zCQMFJJwrBgYDxNSV5/63pvL2PiGSEO1QSTgvhBTp+w0xfMf16xVXLz3Xrxq8q+j7RFRPCPe0u1s22w2hherFFV0faXfG6IWu535zB1qU6xYKc9ffDSHlYwiEvifFEpoyGyVCCeFvbQkpgXf4qkYqU057qahchXc13tWI8wgOUSHm6CdIUfqT68h9h5KKsWoaGl8hpWx8IStWkhJJiCgxBUzBXtM0NYgh0p0TAwnl9mvxLi+GLnRgmgVrRlLNhqEy4ofmi4ntj+KdPnqA2+XD94li3xTy2SiXv88NI+Syi4Gs3DKI0pqs7U5IyYxLNk8FhlQMo6e83ZPnqASURMIARl3fIK6i8uB8QiWxxRNk7Oc0VX06oWlWOHdDnz7lXV0TJ+aanAwCrCVDhBrHCLwpV9u1SszH0iRN0rRP9sW8B+hIJJjSvv3fY4cXL4808VzeN1CN9BSgzOE1UwXh0JqFUh6mecKaY237XdHUwPc8dJ4i+odDp8dTFr4d/npKrQmVgLoAFO8cBbF0duCI6pAYcXjqeoUQPrDWj0OHavRl49dzgmbmpTw0OnO43dKbXY4/RwvDxtG9g/rTLeIqnBvX6hE4IyC+WPEYNjkSJXJCU1dcXa1xTnJUtp6+zyltsoIqaZqUyVmLy6IScQ94SlZOyQSQU/bkcu2wBe6VC1npNVGmlX15KKdEJ5GxPicyKa8o1PK1YvxF2c9L+WXrlXzMiR13OYWQE4gpghVh4aQHLziL8EbuwzQETJExEsoAbM1R+XIqLMlMgIgb+qL0/7RPhqg8851FC59in9P0S0thxFNKbDabPW/LKcCm8BQxR6Yp1xUgkDg3pFGwYRVTBjNGVcxTYBLFSCd88giQsRSk5RkKbyh5nltKysysDWCZvTkzPOPYhyWVpxMZxlXyeMoAGBPquqauanzlqbwp/83DvQxeT7v5httvAt02kOgQ11FVgItsvrtmnIXjiJzz2iQMQVcAACAASURBVKxuhPqGgTlRhfZOib3w8k2Ve0EREmGnbL853F+NC8xAZR26AIDNO3j760i42fDqzR1aveEQ5j1t9eH3MeLXnO9QBi6rMLD5/bX+Jc+Fco+CROJOuf1OQBOaOpwk7t6escdPU1adijwIzDjwgWJUvvzijtBvaFb1cN4J9N2OrtsSw46kLUm3xNSzvV+uazq+5Xu7UX7zt73JHa6iqhr6u5eAPjgXHqKn8FSn7ljap847f2yne6jG56GRT5+tafOaR1Foj7effzuHTs23o2dO3PMc9JSePg2WOV3iXCo+dtVTnnp/Rp0nQXysmfYw337qzmOy6GPKeTz9UGS/Oc3blch6GM1pE/NVyjhzTr1rpcxz+nC+Nv9do9/3Z/rhye3PQ+eMyzFZ84c+pkpCtSOlnhA6vvnVvfH63vSQKSldG7m6gpvXnqsbj3cvUK0Bj+Azn66gPULgu6/v+PUX33J9vebm80DTvKFqDJhQInhMqfDtKZn0W/TymgWBoqstcpvp403LWKJKgjA4rWqJNil7ZU/r2nOyOKef5s4cExlYAJKg4hFKOtLHj3zWQg/fnVOuPrnFVxWVXwGergvEvjhAWP+I69ncKd43uNoTupbt5o52t8XVNb6q8H5FU6/wvkLwJugiSGU2DKc1EoPZDlKgb++JfZsjsiaSvuXu9pamaQw4hafvI9cvXtLXnemUvcl2iEVqtEijuZlZJixzoMjAKcXsfJMjzOaU0aPuvYDvGfThU/kPzP7QB+PREai8w3lHUqGuBZHGxjtB6BMxJJwrKY7FZEQx3YkmRVamCb95+RLvLIXvhZ6HLoCZC13oQhe60IUyOSdcrddU3vPu/ft8zOVoMBMV14RXFcA/0lNqTwk8ML6jQnfKHAMDg6yqVDlce2H2+95CyZsRhhziPitgi+dsCFw1FSIQYk/SxDrnvRSB1ari5foV/+qf9bT3aUhZo/QkMeCBpa9pqK+Ef/K/NNRrBRKh3xH6nt1ux93tW0LfUsLuv/zJV7x9J7y7cwPjuWu3WbAw40UIPbHfUtQPMSa6ricGJUUF8Xjn8b7C+xrvK6r6iqaqLK2H88SYBiMEmgWYKXAjM7QUj++px28xEKAocTAAKQlNSgodThqci9kAlFDNIc2do2kcIgYI2u12AzCn8jXXVy+tLaG3eeI9RXPq1Kw7g1FGHBoT4JCcZmuOUi99OHo6y+ClvWTgM4NNFrLAUk5NBa3p94n3t8zm93jODEQ2boGUEk3TWChTMUOUIPv1CJbqQatsAIU+9Wz8e2LwXF3VrJ1DNNFJTWD04C4pAgQI7Az4tU7cuBfc1Y4eZRLbBpfTBaTJoxU/jqJkTQhOHZ6cJgom831uaip3nqJJUoJJmpZRhDwsEQywo5M6nMpRBd2x8OlzlfC5ou45dy0dPWXY+JhKpx+6ovHUsz+2X57jOYsR8byy5MSv41eeKjtpT08gVQq6o/EV4FA8SasceSbQpw5SCyn+oMZ3rgifh3EfVqWDyFL7xuNpeUt0ztyQ2bdTZpDpinJIo/HnMe04WMNU+PZvod91/Py/f4+rVlTNC3COqCMA0PsVqh5NtkI7BaHDoA0RlYRi6XiGFmZwh9MCasCyN6YMmlF5sNOmCsUp4KLss9MxSnsb5iwNiwje7YepHj3MimKxgEXtmhjDEMa5bEDeO3xWyJX0PaUdQ/STJJBxGMbD+UlI7wI+MR5ojBYjxkNISYnoSTHStl32NKtQkQHQEaLt3QVsIxn0KqXfY0TwFpUvK3iJFntNMo+UdD9dluZ797zmpt542TvSgMEMisUSmQ6x1FUhBjKWGVVlu92yWq1yPnkLjd33/QBqKZ5z43j8/+y9+ZMsSXLf9/GIyKzq1++YY2dPQABECiQFgocomckk8Rf+qD9Yv4qkzCSTGY0SjAdgOElhd7GzO8c7ursqjwjXDx6RV2Ud3e/N7CxYPtOvqvKIOzP8+Lq7omrz0JMVzQJV5TLPaKmZpmHUAfquo+2agZdRVeqqMr5SAPxkvkYls6QIqrZOY0nP5fJ6EuM9neAkECpLN3Wz3VDX1SSi0lwBPu1PoRbBizdeUyISE/v7L/n6T39I89WLsjqGz6khuazy5bvs2OPz8e84fvCPfF7PPajys3+X2H8d+Af/4iUpCSI9yp7XP235s/99+u7T2XtK8rFpbz7/8+/z+Z/Dpz98yx/8jz8l+d/NgPZCeZ3PQDQCOkk1qlZulDRGQBTNqYgcHpeV1JaeNqWE88HSASoZOJCQ1AId777q+eN/eZh+6eD9fwQMbU0wvu0Yj1Le2ssyUx/44i/+Lr/6C2CI3zXdZ54Bz/L3H62UvF5XqWf/9iV//Uf/ZOWqD7XTXmouXqNTe9n8qlP71emUXh+WIz21n5+SFIZjE17hVNlH77/wnB49s0ZH1vSkrA/N18+iNZ259n3qXxGFP1hf1vi9cy15zFN37trL+Ek9OPpNymiX1vGYcXjqc3Fp/QmLNOO0JBudX3dJHadWwJpkdXjt49fHd4F+09p7jL6NZ+JD0WP2jr8t83OMvNsjEmmbPV998Yb//P/8hL5ZN2t/9nd/yW/9gwc+evljRLeI3uLkFs8GwZPSPYk9/dfPufuLG/abntuXP4O+R7wDqUx+Wcg55XuhKbglJQPV4z1+kP1GsL5FSh/l0/K3dJI9jASuB9/PgWembS3OBpIi5qShaHKI24LsMNDMY2l8twmCrzp+8o/+lGcvX3L77IfALV98ccebr9/QNo05qkZFUqQOga13NM073r75Fbv9G9puT+ocz57/kOe3n1JX21x6SdOrOIlZ/rSoQSIer5VFoEkZQNMbmOr+7o67ZFHgb7a3PL99SXDQt3ti2yE+EHNa4aquqIInRmiaxnQq3ubGez/Ing/3D/RdZzJtCHgJ5qQZswOzuEFvKxPHCO9MwhFsPW3qzSSaqZhtYBzSrMOHTV2izJqdSlSJscM7h+Dp2o627Wh2HcHfcHvzipvN7RPm8kprdAXMXOlKV7rSla6Uqd5sePHiBW3b8u7uboYel2lO0gV/mo54So7RORakhkHITr4TYEz5LgM63Rg1C7cX1IxG+4cWEej6iMuMnDg/GpciOO8s3GDwVFUEdvgQ2GwDIoHnL25RTfz8b36GE/idP/xdnPsVQonKkZlgzZERS7tj4ssvfgG+ocl5NsEY8RRbNFr6jT72A4BCNSPwxbFvGgOipESMkRh7um5vXrg5HZQPW7a3Nc6NaZWcc6Y8F8HyErg8J2YsUjVI+AgyUcjRTMChWgSBMQx7UZMUpYdzIRuEzACTkuIchjaP2Ugm2ds3FZWKzpDkZtSymh4e7qgqj6oZ0vo+z1VZVxmcYohxZ6mBNAtewlBmCblY1/VgYGmahrZt828GA+NU8Cr3T4FXcyPiuqfC2jXTe733hBAO0kiFEIa+LYVHV1ILYKbJ/b6n6zqads9246hdDapDpJW83Ib5UWzINXq8PF8Fo8jkO2rC4FSZXcwRtsbNz6SsgKXBqajj19SNJxV5C+PKodqy/F5Rs+dw/6dobONlgIg1hd75+0Yl3lyBfnwMvqsKmrX+r83fsXGaGm0uVa69jxLulPHlkuttfRyujePr7/g1p46vtXMcq4SgBJfQGIdoD1AiEAjO14SNQzTQPuyxCDOPW0UfUjm/du/SAFFiyMyejoUhTA7ue9x6uHxW1u49TCA1p+VszY+eavfSYNz193z55s/Z73o++ewnbJ59jPMbQtiS1KEpp3wcEuMBUuLQZOWXGjgkhHrYu5x3xNgPUT9iHFMkDm2Z7GflcwrcOEZlbwfwYZ4uSGS+F4qU8g9HcQqSmZYr4rMX2+hRqDHRRQY+YijfuZz+0tHHiKbO+D3nSEkgg0wKIxhCGPc3sfFzzuODz4AQoev6DCyJqMbhOIAOsFAGz7hx/5/Mj0KfAS0DoGe4ZM4XFCopksbxsHNdjAZmyH1QQKIZqSQYP1CeJwMC2W+f7y+RHgtIpvAcUwVjAVmVNJhQ+CDj+SxyIVnZGVCNNE3mO9uOGLu8diSnZAVyJEdh5MFnSufcphij8Wtq9UrOl+W8x4eKKhhYZrvdUlcVIYy8UuGPprySgWnGsO8hCImevm+JfY9Le6I2Vhfj8z7lCcZ/559r76Xpce9r6nCT56LBdvs2811qkYukx7mEcwaiN/5KEJ3vJqd4AxHwAXpt8ASQgCbJgBxb1+NaG/ntkl7MkDJuOO8YIxKl/M7xzlHVFh3J+ZSB3h0pdsTUkVJDH+/Y7wG+t7pPLN+Ja2k31/bYY3vO+pic3qEuffPPS7FWHJ+DeTSFb5JO7WXrPNhhix4zpuOx9+HALq3j9PwfrB8YePvlXnps/z01P7r6fX1VHedfj62TVenkvekxYJl5e44fkROOBu9DUz5qfeS+Wf7zKXSqTbL4/DB0rLRL3m4fpub3rUNRkuSxy+uzrKd17m+tjHM8/9r+KBSZ4tsYryv95tPaXri6zzyCjr0zTu273wVK6TXN/g3392+4v3tA9YccM2s7aYAvaRq42X5KcMbPprhHCDjfIn6PuH7UremOtn1DCDeEakPRPXvvZ+mUppEwC42yaHYI6Pus2x7/lnLMFCizdJQt9RZa6m4fE3FmaOP0naOgqfDW708CpORRreg6TBYNJqtK55CYCMGxrTYE7+n7yFdffc0vv/gVUTuS9jx/+RHbmxuqqiJUAdPnms7Ap0RKzsAzSRGHORxqMqy/87gcZd77KjtL9AhK23V8/eYr3t29oQob6rrGhw1RAl3XsdlsePXqFbcvXtBvb+hjT+xjlkPBZ/msriqq7Pgbo6VWEucsOijBnKxVJntIdo7IkW+msvxSR786oCUKuiZSVPoE0pfTZv9xLgA9u9094iAtnYCu9GS6AmaudKUrXelKV8pUBQu/2HUWEcS8hXMY9iVDOv15VLI4woCKidB+gSZfMs4hBKqqQsQir8Q+YhH3czQZPMEHqioYM5o9dktZ5t2s1B6qquLly5f0bzf82f+5IwSDDex230NQ/u1/ekO3Mwbr5W/3bD574Ouv3mRGUIga6WOH0vPFFw3ilZQsDGKK0QwFopDM69ZSLJjnsBmlrOOqjOOpgnc1m+c3GYFtKTtCqM1wgOQURZ7itwrZ+JrvNz26lR+jIhKz4YHBAGQJIwy8I+KHeTGj2KjAKEAZmBrLDBWumFbFmFtnXqtortOMgmYAcoNZVUXpYm9eTMVAhxl4zIk7M9GiROJivYzfU0q0bUvXdXjvM9DI5tkAOMX4N66jYWnOPKTlovNTY9QSLDP1ii5GI5tnHdp2c3MzCIV93+c2BijzqJbKStXSGqCJKGZ4CQdemNYmV+ZdPcIWoWMwAJK9xSarBLIQJUxAMaXE8T+n2SN9RV0/rgCGb0tFwlrAbp1cX7wJ1hQac/VxPrMitE4VePM61mmtH8cVKqcNJwtVwPissOz1h6H3UdKcHuPT7T1lGLmkn+evedxorfsir5X5+BE71ddLj59qgRDx0iM0JDpUKhIV5r1kaZj6XtHUo6mh2e9ngIin9uFD0/K5EZagmfFKWVz5GFq/ev3oudKnbTu9Og6fkmnZs+dm5Z3Uvn3Gl//u9yxn+H96hvM1zz5Vvv8H9zi/xck0GV65P9lIqUVaK6m6RMQileUc3WnMH3TYM11XKp1SGJbyZuDklEGSw96ms3KsipJQPr/5ZRw5KdeK7fhT3sEikTjEK+oK34CBOBgjCZYxsMB4tku5ojybKNEMcDrfh1OM9DmajaoBbmMc+1nuU0ZAhvcWXcZ4sim/MII1bGxS9oi0e4bUkSvg21Nz4cT22Gle+BJtpoCb3SwKTe4/4xwXfnjKFy8BUsX0NMyPzue1AIqdS6QkA1gblFCFAbgzepCWyDE643eGsYljfwx7ZOMvWRkeqoq63lLXWzabDVVV4d3ow74cu2mUyeE8ivYRXI4K5ANQIX6TeePDvW3GH0yMyEugR7ne14kf/OPXbJ69ZPtKLL2XjQSqFkVHU6Rt3xJcAlqStli21JvJc8BKe9bfPm+/fsa//79+myiJ3/3HHc8/KePns0Lc2TMuSgG8K7b+U3JD2s1pO1XtOucjgqVXapo9mnqS9giRhzcVP/uTV7ZONJD0Od3u/O452wOG0PkT/vlEmsxLaT43j9s/Dvfe9ff/YYnLI09PYfO41h7b1757RuOn8T6HfPqSM1gCPAZD/YXtOlfnuftkcWxF4mAKpfkgvNajJ3atZZN32pkiD+W0x9Nla/vYCK5/P01P4+fPt2a9ruMy4fLKx9JyhX1zz/VhTZddW66fjbg8LWbrslw5+Hf92LL1v8533/En7UrfJTq23t9nvr4pXc43ST/9k5eEv9zS95/QdZHUV0evff03n9K8uyVshB/+/l9ys32G9y+p/Su225fs9u/YN1/ycH8DfETsPL/8k5/wVRX40e8Fvv+7kQLInzokLkErhUwuGGXKIrssZdSlHnYN+LIeLVWPlnMxjYpv42efUsaxohFSquhaAU20zY7PP/8lsWtN55qrb9tES6JtGx7u7y3KqUBd36D4IUWwakQwZ1pzhPAZwJIgRiSlLDdYeilNCYkx1+SwILYmG8e+o2327Pc7qtAQmsD25paXH/2AbY720jbN4IjscITKo5XSdz1t29qbepKea5Cdi6w4e0jnc+Wy/WBtDlfBMjagw+6wnCZVxfkSydbjnaOP2XEmPiVa0JXW6AqYudKVrnSlK10pU/HILeHip+HzZz4iBxKyrEosg/eILpjaAroQN2Oml39VVVFVVQYkmAdrCDntkEaqEAhVIPjiaezpuhbVhPOe4B0hwGeffELTPJBiw+4dvPt5QasLwjMAfvGr3dC8FO7pt78k3bzFbSyKiBfFJ/PMTREkGegh5vyhxQvVDF5K7BMxRQv/L54icIRQZeW4ZEOAx1dVHlPJ6QL8aC8zt+tRgadlXMufiXs2lnaBGS/GuTMj0prJoAgq69MouBxa32cDU6KEVzRPZh36a6CekaEVEXAmOEmZc0qgeskyyohAH5onc1lmWEvZkDgVrEYmOz1NaAKOCX3L80sv66WAWNpXwD1TQ5iNRbnWRlbEDOh97NDWUnRYSqXRCDYlr8U449EkaI5IUcbPPMUstVEhhyy0AYdJl0qNaZiblTGafZt7ixV14DS6g+bUTLJy/TElezmzqrg68KI8ngLgmOLkWM++bUXLKZXw+7RlbYzXlZQfns6X/ZTaLzEJjNeVq495ac+/y9Hzlxxfu25qjPEu4WmIXcK5QFRvz7tUQEVSi8LVdQ1dt6Nve5T64hq/TeXeocFrBM0MZ9/DzrHel9M9PPfcrTXn9D0nzh7pV2ormi8+AWCIL6IdGhuc3yKSI1PkND5RNb+P7c+ArLm9UngDRwiVpTVMCqKkzCcVUOqgbWO+dz2WBlDCRLG5VEpqBsyUfdvJmCYJKcem9Rv4MycgymVRNi7QNDNTFdCKiMvjUoAdOVc6Y3V91w58gTgDEseJMrWAhEPwOWIOeG9ed13XEkIgRqXXnvEtMIJtrf9pAJcYQMbh3JjW6RyvMOMRSpeRCS9dGJsCGsp7rhT+eOSXp7xD8coskWy89wc8iJU3RiIq6y6llEE/achFP6Z2kgGgJLnq2PcWHTEmAzaX57t0Kn8OY5HHbwTMWMrUm2e31NVmAmhe55nKuK15GhYAlsFEAuI8N88+I/gN3cHoH6e16CjWZuX2+ztuP35hz1rq8+tMibEhaSSlln1zRxV2QAPS0bQ3KL+1GJRDM+B0Hy5XtfvAr35m6aR+8vsNIj1ChakkFfCW0iq321KC2VjMnvS8wAxUb2s9xY4Y96T+ntS/Q6RHdYdqy/7+BV/+9GVujQfCvLxT47cYt8Lf8USwzJqha77PzPnJS8qZ0zjip7am+blS4+O3smPtXD9+ePQ3ESwzvW6Nn1/Osax8H84fSfn1+DrnvOCldG6eLuE3ztKiUafKXK/53Gp/DybsCbRcwcefgG+fzstlh/z/qXfEU2ltTX6Ts/TYfhQu6PwKu7zdazKnzGo5Xu63u4LnbVg79l16H39T9BQdxneFPuQc/aaNw7svN8DmomubuxuauxvCpuHVb39BSh4v70jbhu3G0XWvaZrX9H3edZLj/kvjUT/+niBEFAPkLEH+a2SRRE7z9tNzUyr2gLWoNeVzTeY9dWzplDsplfJ2Mp74ibL0bMcukVA29L05zeybnt39Ax4lBI/zAYfSdw0x9jzs7tm3DYrDh0C12eJCTUpK33cWSdVLToU8yqigg7OHZp2CkFPiZnkyAcFEUIRE7zwxRZNpUfrYsd/vCPdvCb7KkfI7RBPb7cbqdgZG2VSe4M2hmuCIi0jqOBtDVaWPaXBoKfNmsq4b9oLpnE4/DyfSdlCTN4u+IoOaHTntrDd5yDliUmvbsfKu9Gi6AmaudKUrXelKV5qQc87CAE7Cv6OHhuyRMsN51HAjo8GkHMlAGTMcuCFNTzEM2DUGLjEGzNrlg0WUAaHvOupNTVWFDOowQ0rbRJwXggfnDAZQVze8/hvH3es9+7cNm08q8+6O5mmrhblSY8PePHyJ++ILUKh8BWrRQFxh+tTC0vd9R993wzj1KXuQZwbcuUAIAe/DkFapoMTLGDhnYJhRXyiDoaAYV4zvWzB/Oh9yS5MwGqlmwmTmMS1Eov2YepKX8k1QKTcUIJNjTOFkyvli7BlUIeIQHKqOeYSazEiXusr1zlo35WfFuWxYOrKKFt4NpY6RyT6ikJkITZcKWsv2Lz2hl7+n4UKBIeKMy4JGjNlTWCWnIXN4F2ze1aL0dKJsPtrj+pzCK0VSVOTuYyS5LPQUTw/P9tOA0ONUcfRIiujXG1LjhxQBtiIEUYgC5GRjaZgJsg+C4IaVsU6jsm8c77nouQDN5CPD1VOF+CRizFSRuKZUU1iNfnOsjZde9V0Tpd6nPSurenZsef4SBenldR0/+/4KqMvNNnrBGpmrcd/HCLI24mP9+3eOr37uaNuOUDl6jSgJXEJ85Pn3PN4FOjo09fAdDx17yuA1jPkAkpvT49bA8fXz+LV6qE59ilL0mKL/WI3lfSr4rDiLKKboiuogeUi2x7sgOHzeI8lpcepBCRWjgTVK1Dg0D7OOeeCXIIRTNDsvy73zUGll38c3dAFjTPmBMRpO7qua59swbgMYQwZAyjyijUNiAByabN/wLkeBKfuUc0NqIhGLTKi+AHQl77MlEgtjBDqxSD4GpikR4cYQ4iEw8ibKUEcZAuegpHIyfmUcoynvUeZiBvbI/I3hgNSUfkO5c15kpthNGaikh/WV0OaFX+66DBvJKbIUi1hX+CMDDsUMlmbogx3P0QZzyqgEaFLatqHvJ6mkyhwyaSMjjy4lmmFeKUV+2Gw2BF8NY7sEZq1FmBl5tMxral4T2XNSpOLZ7Wc8/36P95HYwMNXbmZwY7h7fPoVYAU0Iwgxp+dyTknErHROxNSQEvR75c3PG7zbAy2qPbuvawqI7JCbmOwyKhk0tf5cvvuyQ1yPaESc5/kn94ivEakR8SNcTYuSufBTRQttMo9zgneRdv/A/es9+3fR3kDeo1garoc3xzisy+jg3XkQjeD0vY+5rvCPl4Bm1sjuH1fA8v7D2Vr/dfyuc9eeq0snLfv1RlYodJIXOhH1sdy7NjqP6Vcp71LgzLE6GdbMXMY4W/+sjOlROXH+cbSWrvZYebry7RS9D09/rsxLaIWTuOj6Y/W+bz/OzftT+dSnzf/cGeVD9O/ymk/9fjx3fmm7i37Bvi8lr5GWe/Wvc2zWzn8X3s3fNB3fD7/79H4y4nH62zjvmoT9m5c0TiF5dnWiv+vZ74W229Lt6xW9UQT6gcefplRayjBLAP9M3LwQ0HIsrfAawH7pwHAMGLOsR2R0VCi67vkb63Iq769nr/bUG/CuItRQb17gK4+4QAhwu71BU8QJBO/QFNl3e/q+Z9/s6GPEhYqw2eLrGh9qVIS2a3HO9MtpkMNLvwpYJqe40kRJh4wDvMkOSMiRS5WAsNkqVVWTYk9K9vf29Zf4bKOo6ooUt2i6YVNvkKpiU91Q1xXBK/f3HSC45IgJnDcnCR9qmjvh4W1CY4fb3CPegtHEFC1qqwOdzsMJ0NV0jHXoVP4lWfbP6X+LDUJcBRJQAoOX6pXem66AmStd6UpXutKVMpX0AFVVsd1uadvWwADuGCMpWSm8zpiUCCLFsAGS/8/gB0bgQwgGLnFizJ/LBhBBqEI1RJDxzgwlMVr0mXoTsJREka5riLGh3mxxLtF1Dbt2z3/84q95++9/RPPVR2w+vefVP/wZXdey2+2I+z1d29J1fQ6BaAzZpgm8en6LCHRdpNnvadsWgLZp6WPMYetHBj7cPMNVNd4HC0EvEw/ebFDputYMas6Dd5nj9gtl9PjVADrLkZ2r/UfRflQ76FQxp2C4p2IMSpnZPgyVaZj0CfBGmBhYipDCCPoRCyVf6kxJcroHMz4weMiPjL4x+fP2GvK8eOQXpvgQrFLWS/GStj4Uw+Hc8LIUmqbC2ClU+9JoeKkXf7k2hHBQpxnMBaceVRkEDe8FkiPS8vwffE4VIim2NO0dzX1L9e//OZIClUSEhq7v2dS3fP+fbkmpJWmDakPXv+Pu//iE+PMbJCtmh/CfCKKKkznwLeX2ipbn8bT6fmqAGk030+Q543yawGylJewVUpTFkiPGFMOGW9y9Vutyha9de6mC60MpQz6Mcun9WrOmijyvDF7edU59fenRy+hDKuUubfmyx49Rpq+dOTTCjfGzfvqXW376l9uVtimbZ/A//K/gaqGutgQXaOknRu3vJs0NEGPKgg83l8fX8NrIHAfuHV7B6vkLFOaPzGnuxFGHmtQLYVNhaV0S3pyfiL1aYAZf4cXj3BgRRMQMaiFUBjgRoe8zoLKPw8tNVbHMj3OQ1TmwzFNojFZSlFvTT4mcFAAAIABJREFUN/WoqCxk4OEugyimkV9k2J9TinnvHvdHPwHQDnyBYgpAEbwwuc9iq4kIwQdESlQZi8CiWESVlCLdvsV7x7Nnz4ixz9FPPG3b0vcx80C58Snl9o/8Rkpuxvsg8/RK5bqDqDN5L00yH58lD1OOzcKOCwYoTsd5njL3Q9k6/LO4JxGjkjOGUlX1MDdgPDOaSDFmz8JI27YDX1B4Fydlpx7597X+KEWh7vP6tZSk3vlB4b4G8FrjxRSIsc+8o0Xk6pPi3Ybv/2EEGt79PPKf/9VzWDzpFoRp8uwWgO5KJAv7XYDhOYmaZn4NoX294fP/+8cUDl2BiOIkERl5kpww81GG6//0R0UNqVTbhj/8F7/i5vlzvL9F3AYnNXAzcHElPdPoDZtlA+1p9/fsHl7zi7/Y8Ms/+95qfY/Z8y5p/6m+ru19l7VkeseHAM0ctmGtrHOt01lvn7brLcfkeEzHp9G3ZexcplR6bB9OjfWy7FN0jN+fzv2adLJW76U0NeyfOnb0/gUw6DH3LmnZf5kcGZ+cp0kYT+XuljVe9m5Yr/+b4ojP8n0fuK6nj//T71tqiJZXHH8Hzufu8J117jlagjJP17dWx5V+ffT03e3XT9/kO+NvA8Wu5mf/7r8HlrqRG+D7k9+TT43m3OEEZXTyLE6CU3lkGWFzHn10TsccGZeOCKd0r0+Nrjp0TrL2MUc3feraUeBHf/drPvuJstm8JFRbHrpPiArOBW42EekSze6BGDtIkX3Tcnf3jj727NsW8Y7NzTPqmxsDyOSo8jH27Pc7vO9MXxQqi1JTBFdRUupGvb4HTSbbKYo40OSIam9m52o23pNSJMaOGDuLKJMisd/Tdolmn3i4c2w2W25ubnj+/Dl1BRoSze6eh7u39AkQT1Vv2N5s+eijj6g3G37xufDmPypSRV78QU/Ymv6g7TqaplnVy5fPpVxdZEqT5UxvjpAdBBw+2DqswibboMzhyEmFc3W2S1zpQ9AVMHOlK13pSle6UqaUIvv9noeHB3a7HQ8PD7x69Qrxjq7vj9xlhgRm6uJc3iyFjwEJBgOBmgdkVVXDZwhh5q07hOZPprw2lHQCEnXw1HVF2+3p+5aUzJP2o1e3OA9Nuyf2ezT1vP76LX33GQD7fcP9z39BVZUQk4HNxlPXVofZBhKxb/n66y9oWwPSpKSkaFy1cwEnnqraEsImR5HxdD6gPuC8H4AypuiG4tHtqlyHc6iYmj2lY6x6McDMz4s1fH0utHh9yzA3xiiTU/nMyy9gJ2NkrYypUcjKcoYg946UvcjLPHZtb2mwkglUwW8MMOQ9Kmboc96N6jtlyG87/KcgycbKIUN6haFXEya7RPOZCm1Lb4ehdysM+MGInfB8WP4+hYifXjcV+Iow6WtDwCPZiJhZUDtmIKPYpZxqtoK4wfVwowE0IN3OwGD1c5LuUSq6BDEFQrilfvbMotkwKmOzKSgbc2QA0RQgmqL0KB4hIUPkmceATopRY37fxKBKiZ+hB0t2+saQRXQKHTyYly16rJFhZc5Xj344urz8pym05eS35XWXeJUv3wtrdT2ejt17KRDhEuPJKaPJ/PvpsTp/7vL7l0YQnZ5VQbUGrfEuUAUIGnG8yXvbnL6LCsBiIB57K7Nz8Nh1s/LuPlnG2vvg8U/1YcvfU1WsAsnjpUajRTfxXkASSML7YJEycDlVow4gXQOQ5DzcfkvfV3RdC7jMH+R3RbT0TsAhcOID00wBmiOclOPl2OwvKeIcla/yvcnS6YgjpkjwHs0ppZSR39A8BpKVel6M7xvSCyYleA8ZiGERBa38lJLlK0/RIrB4RwgeVYsy0/cGvOi6buiLgWUke+5lsK3CZrOdKNk0l9kNqYbKeEwVxIVPnQGYMlDc4A3KEty0jEZjo5BXsCoaE7UPs9DnKSVqS0Y/0DA3YjxVARjJNB1kVjJqUlMwEnDe+A4BuqYb8r1bBB5TtDqxyC0GqIUCApKB38/rY9Ie740nr6oK75yxMqrG/69EzCnfCz83VZCLgLiI94oTSBEDcDklxZ6mfeB+1xO5zbM1Gf6BH8nvhsl+M3vCBXxVG5i8B5UaUUfs9sTejWHlc5meSSwwdSRJlPfP5AmlRF85ZQw8eNuI4t0b0AaNLcpzhBegW6CkKNP8uShJrQPBR/wZp8rDPWmxVw7RLddbvrp3n0zN9HiT+XRspqCZobqzJRyjtd5fVuZ4fn2POGVEPnbujNR3ko4ZoD+0sfMcr/a+O883CYpYzpcsPi9pw/qKWZNBLh95gdVoM+facPRcTo9m8z/2fA5qvlxuWvLLl9P5Gh7D0X9IOW3+TlmTD8606kyUpQtK4NLefIhneG2tn5cER3m0fDsnW52u/5Irf30SzjfxvrzScTqlY3jq+++xZX3b5XyXaDmOa/qh6W4pQIli4rzPwJkxwuVSH1r495RSBsscOi4OpU9kiOmxqfPAsWumZR4r/1IyP4isg3+PCX/3GsQnts8Sz24dbx/e0aY9ziseR9/2dG1D2zV0bcP+4Z6m3dP2HQllU91SbzY48RRx37qV6Puevu/ouojPUes3m02OLkl2hgiEytF1DaIJ560Q0xVkkFOODFvsDd7n9L7R07f3SICqDvRdR9s2PDw07Pbv+Pr1r/jF53/NZrOhCrXJ1xJIePbNnjdv3/DwcM+Ll6/Y7V4AW5wXvvfZ97h9WZNUedjtuLu7o3YB1KK5dl03OCEfWyPF6dZJIAcDRRGSChqFPia8F+pQ43yF4EjJgEHirjCPD0XXkbzSla50pStdKZMPjlB5cNA0DTc3N6Z0SQ4nBjBJmiwtADk6hTdjQkwRyKmTnCV4SSkz3ALihJttbWEKlezdqlSVUNchg2kcKWoGXJhXaYyJREnXpIaITh0inj6Bc0pVZfSxWlSZ+9d37He77ElsXsPu+5+jH3+JugZfbagqT9Psh3YY6COnVuq7MeJMiQQSPFUdLP9ojqjixNIuOecQ5wg+oJmDHSJsmNv0ABbwPhQtF+O/acGsT37I4jejoD83xJaLR0FGsy6d7C27FJCmn2WeVM1AoWQ9HJYWou9bui6SNGbDXjbKoDgHKQOZfAhUlc8RggI4NxhjDGDT5TYytDW7llNMHOIKoMN6q6qomBHHjE1lIOxan70fpqJfMXbMpcRDU/bEKfyI4DVRQOr8nnM0Fe4s7VePkCxgk8upxuwr3nlUK/rePB6UG+pnnvT7f2Ve4g+vaP71x7gbx0f/rEdqi2iAOBwOp47N37tDfnxH+kro/+xTssP6gdorQ3dwCF4FjxDLXDxCajw0kyzMAWIpqCwRlKV9kun6mwB7DsYun0t5HGNWCheD1Zoq75tRX87vWX6/xADyIelUeGtZ+XX+ussUh++jWDxmdDlb5gXAmmVqAFgzUB0aTS6ny+619bS+qqbtUiBGj6PK6fmKkfr4GJ0yxp1qczGUFFoaDT4UFaPmt0OHe+Ha8XLkseNVDFDHjGvrNRnFFGnbPdvtC+NTBHCV7RcJ7E0rkCwxnrj5XlKAGyI58hhCUXaZ0qwnxu5AkXgMLDqAMiY9GasbUw3l4CnDVaO5bTS1mddaGqLfQAauWN6ivEdbH4Mz0OzA3aii0qPqIQM7LNWngWmdgBNdNUANwA+Z9ClZoPApYGhUtELX9XmztjbGqDnVlaXSDMFlQEhWCjuXo6CMYGEbEwPfJC0eewzAIMQ8KA0sM+EPhMI4MYBMZLK+RHL6T82A8IlyeOAVDxXEy8gys4gzQ+GAzsE7JULh2LcxhagmRfue1PfjPQP4ncHDTzIgWaW0h8yjjLUgBeicOY4cKVCTrQvU1o6VmzJQbLy/RLccx0Lwshmi20BEpEVkR9t9Sde9RlOF8INJT2V8hhlNx2PqpMm6ytds/C1BblDZZCWwEqoKX91Q130GcUEBCJby7cm0dTiUuQCOrBkdj33vW8ef/Zsf4bznB7+j/PB3IyLGb2vmnOym4oCQXyr0dE3LX/6bQLP/hP3bebTKJWc25bnWuLbh+yOja03vH+WTQ357WeMlUTB0KPE43/YUrvUx9Ji7jnOmh8DkNV7sMXWsz9J85zt97TpdAmo+PWfrv78tLmFJq2t8hdbaPbxaZyUs+ZBTo7HOHa1FvDrWpseO2+E7YIyAeP6eNUniXJsuk8cu4z/H8X0/Oe047/6YMX0fsMwp/vTUPef4znNreO2Newlk6ti+9Ria9nmUi9auOw8s/abpm6r3qe/1v0302L3s1PlLn9WnjvOva1/60HROR7GmFzqmU7LfDoscbungzeFHSibXHHlGR+Eny68CR/WklwBoltHFj8m8B9E9F/cu6xiPK+bEahEbBc/v/sELfvJ3Hnj31Z6/+g+PW0kxCW0nxPueh4e37Jp3ECKbjTmL3H/1mqZpiDlSate3tH0EH6h8oN7c4EM9pMYtb0XTD2dZKfU5tVGHqDmj1nXA+wyo10TqQaU4HGcnlspbJHiKc2mFuAQagISKUNOhyeNDINU1PlS0xSaiyr5p2TcNgsnEm+0tIVgUFx8CDuX+7h3+Zc+P/ukLNvUzvviTil+p8OrHiec/qqg//hjvApoYHG37vs+ysCemPju/ZHuJanYEgaQ5gkwVCNmZxDmTzetqMzi/eO95ttmy3WwJ4Rph5kPRFTBzpStd6UpXulImFei1p08RFwKbzRYQRDxBigeogV3EGbOMgDhIyRFCRb2pqUIgRkv7ozAAJl68eEaoKoRE2+7Z7e6pas/NM0/wjpQglUgjYtFpnHNEUfMSbhvu7l5zd/8GVEePVu+HrFFd13J/d8d+v6fvWrquy+CNPRqyMWSvNHvY7x/MEKIQu86Q9NnIjwRctRlCUIaQGTVvrIPx3RnYIVkpIIpINjzoaKIalNUiuZ1mNCnMqM+RdKzcBaM+ZfAXh8c0HlMBpCjX3cE9IlOVbUaa66i2KEzq1EglTogZ+TT1DPbe5/Fy+CDIkM6qI6ZEykom720txGge37FPGeTiLS0Vli4IKV7jWWDwZUBGgWmUs3T4bRFqTFhLw/V5fErUygMBbd1sUQAx83vm1+oJBeex9AtDP1QRUYRsiFEGA5UZhgLgUSpEKgiB9uN7nBP6/+8lzU8DcpN4/g9b6goCFeo8oh46qL/n8Z8E2kpp/kxJoibgTsKATxVnlrJJBgCN5LF+agyXYlSaG9LIY1bSuIzRbuyeiTFnVmoR10HVojHEPLdxqOeSdh5XuT5GGXuJwn000H0zdFqxcXjkYoXwkeMfwsjxZLDMBddoKV/m62FqtDulND9f3+X3XkIy/Cne5feTGpBuamZcu+8pRpP53fPSn2KIWNJSMb800lzW3vNXHWvrJQa7S40Mw9xcAJY53p5El1p83Bsowtc4fH4peGOwVPIeG49WYtuhw3vbX4MPlstcWtqkpL4bInKU6Bxr0WaGMZAMaplWUHqRQRoF46HTN5iOs2uehjnXu8IQESZfaimLHM5ZlMCS8sj7DEbB9nwyeLSPPSkm24MKAKCALBb78LDXT4DH09RJ1i4D6Nj9adImG28nDvGKkzArQwR8Tgca+wgUMIeNQ0qJmJIBt7WkkrL5wTtmQaEmC0PB+BvJfSjtwfa00u4pqLoApnxJ47jw3qyqytoTLUJO+d3HiHg38GrTqD+FvPczoE1KCY1jOqaSDsphCyGhkEEsSGFTJPMIpnw1wO6ENxMDjfVdl/lDj0he65pQjUN0wZh0jOCy6jWaAdcipNTSdQ80zWucfElKbxHZUYWXk3SOFiHPpmHcKUfV82xlD/c4eYaXAF5Q6Wnjnj7doekBTTWOLUtz9/KdsnwXjPUcB8ssKUXh61+8AODlJwZKRwKp8GMKoi6vvYhBdVpSume/f8PXf/OSdndzUO6Mb1mmozp17ZF2rvVBJjzmvLwlQGSt1MITnuM3Rt7yFDd/mp62473fPrlcAYdraU3SeEzp6/vuIYz10j35Q4Nlluc+BC91jo614fgKPPw+LetUm/XsdfO5mM35e4JmTo31lG8c34znooacfkdcSufW8nn+c51vPUdr/fjQ8stjwTJPgZ6sPdenzh/WeTk/frhHvQ9Y5jAi2HT9L7nTtX79ptO5d8x/CfSh+3rJvvHUOs/pc35T6Jx8O/13lHFP64rEFP1ZXi1RwqclGOedBv7MmT5yqgs/Qcu0S8e+L69f6smPRadZ3jPT62qOqa2WmunlpxXe1QTf8Vcci6i/TlGVPkemjzGZzBSh23XE5o7d3RckFdqup4uJPoGEmqquCVWNCxtiMnANSo5CbiM6Ot3mVLkoKbYg0OzbUb50DlxgOrsmcrvB7uC9zzoOK9McJwQkgSZzPo0RH4SKMJO9TfY055HdvsFJi3dm94ldy83tLdubHuqWNt3x7vPv0bWQwgPx5o6YwLuKTf2MerPhWX1L31vkV5czEcTYs9vtEIGqqrLs3ZujsjOZUjU7m4rHh4rgrc8lO8Fm60E6VB83h1c6TlfAzJWudKUrXelKmdq2Y79v0KS8fPmSqt7Qdz2oDMAR54UUezR7SDsB742RC1WgChWqjubrLU4C1a3ibjtSTGw2lQFSEvQkSC2xV7pO6FoLlT+g13NkF+c8sbdUUV2z493br3n37g0x9ogIN9sNdRVGI0MyME6XwTKxjyTFPKQ1e9ViBoIYjaG3qCWe4HOkG+9BKsRvZ4y2OIfz3lDai7HT7EY+1aWIFGPQcNVgJCjRbDQDZpYMf758IrAt1R9rqvipkskMIEMg/QGsMxpnNMXsCZwmdY+/AZwX+qTj/DsZjDbgBlzOmMYp5fRKNiaWZitHCsoxFQWXgSMZTCSjAWlMd+CGVFySwTQp5SQHmgbAjnndT9XENp9uSDU1naUytvY3F7yyufCI0DWndUFu6ul+cIeMApCJlXFsnGZBs6ScUAEJqAhIhQsBfe7pP9kRq46ug9AZmt6Jz2sJgttSVRXuZaT9ic1F37fE2JD2grt/mRMxjOpTh8U98Cr4bJxZrq5LaKoIk8lcWPcU1AxabqJMW6pmp0qRvGoRcpSZLOSlPH5xSHswKt4uNzw8Thk7Vb2eU9qcK+8pCpilIWupCv4QBohzqRaOkl4yKo9v42l19+hzPjdeHltbT6EPo3BfK9VJa0ZaFNUOSc1qvcfe/pfWs/w1mhzXFZDva7Arxh9dvAOOt/3pI7vW1mPK+Klq76RRWOfnDg3lemR28j0i+CB0sTUllQZUDQRp3nl5Q9eSKibvhzPl3thSl0EZznnjPcShmohdS4nuBkJM0dLwJM0KtjQxeQjgJtiXyVtzeNEXsOzIx8xGoQA9cgSRw5SNRt47wBRcMVqZlm/dU1IgheBRHD5C7PscbYUMqpzuwZMx9ZYMZ57aSDOoYuRNx/aMIcOn0VmcgKtG3qQodAUBZRZqfJyPkUcZB834OuNB3AGwRSfzbOPHWO4EHDxcX3jTXJdwGFFm+lnaWT6rlGz+BfoYiSkOAGVLkyXD3Er+z4lDXYkzlNeSlr16rMsiyxTgjJgiPKe+sne/A2c8dd/3qEIIgSpZWiZxFpWypPIs0WVin4glNLhzeS5dXmcD0hkQEj192rFvXpPi57iHDUFviW+fZX7G+uEYn9Hl+088PPtMkRy5SVUIG8D5PKN7ku7pmjvefd7Qt3v2b54j3AxlTPmNNRIVkkw5EhbfxvuX7x7nlY8+6xBXcfNig1KjbIjq0bxeRI17EulQ3aPpgRhfW7QdfZ5H4FjbSi+O02luYhrnZXmGoy/6S97wy9Qx69ccP/dN0dLoe57mHOipnpzv8eV0uM+V33pQ2zn+6NJ0mWv1P/769zNxHu7Fx8pbkcem6ZAu4HOPXbE8fsATTM6cAs0ca9tT2iSLmV/yyuulr3GM3yydlpUWY/KoUs/dd5orPdIEO7QWBe9kEeeun0swl5b72POXyaVPB8rMy9LJOj/2Tjx8Yr/dt/vj6BTff+y6Q/n0u93HD0HfZP8ufGofRe+rz/l10Hke7vCXHHwuHEN0XYsjGfiiRMzZwzPVQo2Q9GQy3AxMM9GzLWSq6bGlo+Ga/nQWNfOEjvV8ZJmhFCzutclkNgbDHSsjcUhhk7h91eGcx28TUcyRIRLZ1hWaoG8bdrsH9vu3OF/RtB1dpxA2bG5fEaoa72sQR58SqZccSd2bjKgJLXYCTz5uUpEmpc8ODyJicte2HtQMJiOOGt+iF085G0AyxXzWy26y35mivekXgt/gK5/bU2R/pWn2NO2O2Lf0Xct+/0DfRz7qPqZpdihC30CsQEJNE9/x1Zevabse7zY8f/6SFy9est1uQaAKLsuKQtcLuuuzA4cjBAiVZ1PX+KpCk9mPYm8yZBUcVfA2m0lBIint2e8faJr7i+bxSufpCpi50pWudKUrXSnT7n5H30aebW949uw5IQTu3+5omhbvhNuXW1LqEfHs9w90fcPNzZbtJhCCAVseHt7w9uuG13/0Y1ILn/29xGd/P6IC+7fvaPYNTdcQU4945f7uni8+/xX7pqHrOsAYvdjHnDs1gCpt2xD7jtoHbrcbnN+gKeEdOBfNC7Xv6JuWttvT9Z0ZC0Rod6NXbQJLn1TV1NstVV1TVRuqamPKdMUipCRFsJB+UzBE8e5dCx1JtikUWjO+xEl6ovF+BiPa1OM4X7AyU0fVneM5GY01ZlwqqQDSULZzo5Gi2ENSDhk5pF9wkoO9mMHLUjGRDTKJritGkJQNZAY6chkEBObJXSL0FNCMTtpgRifo+35mCBoBKC4z6g3OjwaocTwBiZNxkSHdhdmnpsYzMmgKirlo6eE8na8yR+doLY3CvMxi9LJ67XM0EpqhsByz9FKOmnpTE2MPP2iov3dvacb0E/b7lrp2hDwflCRLUrH9vif8i57YR+53X3H37heknwfcH//hrM0OsOQwo8EMIErkKTQqNGbqYEr0pQKaURgiQsnknhLdYalWLgm6BMtd61A8iYgQsVQec8U0w9+aEnDpp3wqVo3Mrpt/vj8dV8fMFW9TA8Fps9YldM5oMtT7xLQMH5aWarLzYeWPGy1O3zd+f5zx4DEKNVUl7vf0YiC5lHr6XQu6Zuy8VF13uCaOt/nQePa+KsH5017KLs/u+Xa8byum/Vgq4KcGo/nzO69/Rf22cmQKyDpU+DvxVHJD0zpC7RhDPkOJniJZqWgKrXxqBXDhFiDa4AOysd70XTcCInLHREroZlNwykTBOLPxiDAkA89G+HLY8BB5fybN1uQUwDHd16Ztj7EfyiopG9u2ywo6od/csNnUwznzajOln+qYzmfkqfIunXJ0kglQx8DOsgDKjIpV59zAR0zBvgXwazxIjhyTEin1BjZ1I8CnAGJSjgSYcj193+fohjUhhBmwJcaRf8oB/AZ+roQuV9XBf7HMb+ELnQiJeTS/Mh5v375ls9lQ1zWqym63o6oqttutpc1Mke1mM7Rjv9/TpQ4vDlFFY47BkvsyizazqGs672WMDTwjpNjgkidmkIv3gapS2rYlBGtPyErMXCHG36QMtrYIQwaqEoSAc5qjSxp5L8TUIWLrpNpU3KRb9rsN93/1X9P96pWB6sseJYr6BN4UrSLj20cRwhZ+558L1TZkvt54fVP1R2K7p+ne8fB2xxf/9nvE5mO0n74ry3Mx0oEKvkTyW5yb/p6+Eadvq2qj/KP/5TXV5lMSW5QbooYhUmMeQZJ2xIcHYrojxjtSeot2zUprDvfvU1LD9NvaPnKYVmN8v4/exVOw9XIEpvcx3HvJO//Q1HGensK5zDn16bwd3ykPucPxzmV5H4bWx3Wtv0t+fG2ffnTtF0bXGGt53yvW75qvnUtX0go3KeNTuD7Ll/Mpa2tjXtJx0MysnGNjfIQfX79+rH3KAx1Lj7O88xJ633V9/P5zJV/WwtNXrUU9Wdwj69LGWuv0zBWHa+xYSfN2rF1/XFad33O4Zo+v4mN9eqoEuHyWpuP8lPf5r5OWY3BqTOZzcPl76Tedvq1efsh6Ll3b3+Qsvg+fsrz7HH9nDh39qJvEnPNie3yFi3ZZdsmR1ZnKNADOnDkUVARNLh+XWTnHIsIsae3YQX8muvflfUu5dHB2nTm+lhnVcjNJIyaj9PTxtP7TB0U8vPqs5ff+u9dU4ZZf/lLY7UxW7FNP1BwRJggqiYfdjj49kNQR6i2bZzdsb56R1CEugDqLkeqTRW33DhGzQzjnZnaDqbxb5Fzru4PsPOGlODj77Mgyyspdl7IzhYFuHI4qbCE7qmhyaPLDEJljQ5anUapqy3a7IcaGffNA0+zxInz51RcoFlXeec/21R03NzdoVaHJs6k9VfCkuOerL3d47/joo1fUL55T14G7d2/58qsvLcKMg67ruH12y8tXr2hSj3SBKmzYbG6QSri7eyB2e0tPhVq6KhJdE3nz5jUPD3dn19KVLqMrYOZKV7rSla50pUwheOqqwgnsHu7YbGu+/JOK+1/V3H4W2f6THU2zRzXRtA0p9gSXuHt9x82zLZoSu31D13ds/84dXat82fV8/kctbdebB2bKHqdiaZ1UE85LTndkHtSKErx5I4tEUorUlYL35lGale0aI532xNTT913+a9nvd2a8EcH5iso/tzyXPntqO0+oNvgQEB9QcUTMkCXZ81ZI6IRxLgasKZADRobcrjkOuijfp0ASzcapYkAzDX7G/l8iSQ1FL8yfqoMRTSnt01Hdv6i/gGpiTINRo/TZ+Zy0JxshirAkGXXu/TRlwrRxJWKM5rLjJMLMKEylVIxsdkxVLa/ppD9t2wI2dr5EOcqGnhAC+6bBucyoZ/BNMYqJGPiEvPas/ZKBNGBZBSYC4sSDfgmMsjE7FM5mvT7iITGq3iytk8Zp+aXvkg2HJqAIgb5TYspzmdfnbrdjt9uz2XQ8e6YEX+H9uGYGYQd4cfsptXfcv4k0yFRMtDkCgo4RCFTNANJJYjadj6ClwaGoJl0GzYDmtErNvpbXAAAgAElEQVRz4V/EItA4tVWSY0bl0bFV4/KRApxxokSdeJ9gHvFpNuaH7VuqGmRxvcyOT49Ne/a+dE6NOW3J2JpTr4bHmjMGBd+FoeHXW/f4us/RfI5OqNZlOseH4/l4OlRHHRuXYwbSU9Q18P/+S4+4Lt+kqDr65lg5l5Uuk09ZrNtDA2D5Xd5Ia8bQ40eOv92EAowbn6fjRr3HKKLP0eEqGNfGdP5MdXT+OTpGUzNUAdqVZ+fd557/8L9tUeD3/ifP7Q/IAFtrleURt2gzBlDJkTcmbZ9GWYNxPzLQjEcz0LdrW4YYbc4i25mXlW0WUiLuARpTVobZJp0m9Vi0PCURcSJDmh3U+LRRp6izNk0/SzkGcC7RUSKCRdwJVCRNtN2OpG0GpYwAVnEeh6VtMp5QM3B3BHR4b2kxS1skA2SXe22JTuK9n0WAMaBLokTRG0zJygCQKeCZce/vrTyxaIchBLz37Pf7ATgzBZtMx8d7n9NUThZOnpACqgHwzuODNwCQWvu88zMeo/TRovVpju5nIatFhIeHB8h1JukN2CyO4D2x74l9b3unN29BEYsm16d+AB9P65oqsw9A4gPAOdHndKbSNTRNoKpCzhufiLGbrHPJgKcJmCiDoFSF5AB1EAsPmdOBevOWFBxebtjUib75mO3v/xz/X/0V/VfP6f/07w9Pz/a3vuDFf/OWmxffw/kNQgDdILoBAhKElHx+HhPG6cT8fUPtA9Wr52z+53tEer7+8y1f/emzycwu5vngyCGVa9besNNIEKoQdUtwW2CDEuw9lXrEJdCI0tE1PX/8LyPtbgNUKB+BKn2zrtK8/B03fyfK4l/rx3IXGPeZlPlaQ+ctr1znwqZ86Lzc0/vP+V6c36/OlXGMbzxd63opH4pbfAqNa8++HecF8vWPjLZygjN7xNHztGyrLs6enuO1J3Ctr5dKC6XGQ57jcMRPl7d+zZEWHZmb0+vyQ/DE3wadXklPeYZP/S4lz6NbPV5+OlyJ564/f+X623CttlPlX/4WvbTM9+PPL6/zN4mWksR0/1Tm76q/LX1e0t/Wfk3pQ+/hx56lFY3iE+89dFYJVc9v/bM/5+Z2Q13dUoUt2tT88b+6oduvO7fE2NJ2Hb6uyYnbmUYydM5TYkebuOgoaetF/OAwsgTkL+XJ8nseRXROU117cYQ41M/Oyy0y4/TYKI+YjtNJT9/ZsSpMIn8foR//t2/59Mew2W7w/iN2Dw1tY1H0qypQVRt2D29p2h1ds2P/7mv2uz1uc0N9c8v25pZq8wxy2tWij7b0UI6oSmx6nC9RZUYZ1mThUa6d6qlNn9CYbt57c2QQ8JWlVkoxEkt0fFU0JVweo0ocfdehOW1SXfmhzq5r6VMkRRu/qtqARFQStTwj1DV9H6nqmhTTcN9+90C73+d14thsNlT1lqqqqUKFo2J3/47U7/He89VXX/Lll1+CwKaucN6xe4ik2FgUHhd4fvuC2HU48TiU57c33N3fkWKkritCFbi/f2CzETa1PzmPV7qcroCZK13pSle60pUy7e7vuXv7mrquqDeBrmnp96+I+0D70HD39iu6rqPve9q2o+s6vv6iReiJsSMVUIQ4MwS4GucqQnB4XxP7HFlDPIpHMSNLCccXY6TpWlPFpsiuiXRtOzB5mswwVdK6pNjT9R0x9mjqTUD1Hl/dUG0Lwroi+Fu8M6bRmGGHeI86i1Whmp2ugSEdgabsbT1SYeyLUebQqDEXBKbXTO+fHx8ji+jSI1Ts+JJ/L7cOgBvWz5vhoSjvjDkejGHZCGfnx4gyh+1nuGcQhPLxAkQxQ2lO+SSSjWFKMXwMIfYHU+70rwg76xFZgJzWqggGDKh7UPq+yyEqNdcJJd+uiDcDoZaxL/WQr42kmNNCYEY28zJ3K3N7mo55RkznedpXsuGqDKYBcZIBtorwqGkAmAkJxOasjz0ghGggscFrQkF7g6JY3lqHUFHXt6Rtop2M6lwRZimZVJzF3MknYxnPiXFjqnCfGp6XvT80EOUAqDJJmaBTU8rEI1fAoaAFNGNnirF7bBXj3E5boKPMWzKqHyrslr6ey3afm/Pp+UND2uHR8dy6oagotteVb2vqDFE5DOd+pN5jdIlCfq3e1fs/ME3X2rKutfl8DK2poZaKauC0l37x/p9EODq23oZbFJqdXXmsXYdnjq/FZZtX1wnzsdTFmUPl7tq6HH+NZS2folzKAjRzaEA6BkQ7vp7mbTuufj+/Ck4817loa+dxM820LcL42GiE7j6DEmPZ/+xlZP85XAbMJCGDg+d8BIzg3HHfHMk5R1XV+by3FDwxGu+lihj7NUv9WMqWAqRRJVRC7KGfAETIbZHSphWg2DLSzEka3sHWlhB8BsR2Q1/MQy7YklEdFG5lvx8Vg4mp498I9FhXoBbgbVEyju0tYzx+H/vGMK7OuSFanuRwaDFFHh4ehkiIU+++qfffsOcrw/MhbhJ1DiZjnCO/lAgzzpEW6ad0wp8cDLHMy+26Du9G4E3lA03fENXCj6sHA0BL5jvm4O+lwnqqkFaArGQm82IurymL5kNWkKcBJGblZxCVJvpYoiOVPtrTZGOuOAVEkVSi5zlQA5qF4Hn58reItztS7NhJxS9RixSPsn3+ihefPiNUW3A5kozWkGrAG+BYjd8d3pYiQJXTYTrURW5f1TjXcbeByMivFMi5osO+O/BFB/vwYVqU+XkWbxghqqdXQCIiHY6E9zuQDiH/uUize0b7IMAZhfAKYHBa/5R/O9w3xjf9Gs+4ekR0GKfLOAOZ/Ds/fmIHXS3jFC35iONtOb37LPfRY6Wu7aNrdZ9v+SGdAqAev6dcP+e2H1v/4ToY18epsk6thLkcctn9a/WdX23zmqbP62EStWV71uSH5XddjO7825zHmY/+ufF77HWlvm+SN3/f+vXEr1NS0rmSDnnN9aumZ9b53sO6l21eK/Nx63Cs5VQfS/sufSN+U3Tq7fghyvmu0aGMcloOW3sn/CbS+7zPf1PoKXvvh3inHqv3OCd0aVmHJSx1FU6Eze1znr16zia8ILgNfXA4iUeTeWqKxNTgaREJiIQhyrfxnybjqkaSqIWOHkSIUa4YjrxnVJljZRV99tSxtdy3BOjYuzuhWc7qI4hm+UUcigOOR5m5ffGc25cm0XdtR7Pr6PZ7uq4jto6YInd3bwww0+7RrqV+/jHbm1vqzQ2+2iCuJlIx6ECz/DbqIHSQz0pfLeWtyWhVVQ1y+xxIZDJY7BOaImjEOxkdP8gOhprwWa7t2oZ39zv6rh/AOIVMJ14PjhPlb7MN5nRcVcQUcV2PuMr0DWppmUljRNa+6+i7FuGBECrqqqLe1DSbChFP33d0XYuQ8AikHlWhT5G+bUkJfAh0+z11dnbe1BscESeKD+DoDKD08Ia2bWjb3dl1daXL6AqYudKVrnSlK10pU9vuuL97zT44NptgYfG2b0kfOR78nu6Xb8h8XFZkGyPnBGIPFqElhwfMIfymholpdA4zrAmx7+n6zFjFaN6wIjSaLGJM15uCScwINKgWNOfgFDEmPpjS24dAqGtcCEN4fTCmbDCiKxY+EmEWWmPC4AtzJn0tDGQ5V44XQ88xpn4KtJkz8BkKcFQ6WjmhR44zAksGfNCg5idH+bGQjOaxPIJlhtoOgD06AIqyneWw7sHQOH4/BJ1MxntmsGDxfWF8mI29LUBLJSV0Xcdms7G6hSy85blUS3tibbZ75vOX149aioK1dFn2N3pKQ4lOM1F4ngDLTL3w50LNNJWQmHFDlSJt2r1ZaMoCnoGPJANrhK5vYWdpmqqqZrO9QYIb5r/0wbsK74+HiBcsno1XocqAMlXwJDPsYhFhbH6LatGAa+X+Uu5apIfx96iKsfmaXJHXRWI+JuRIMnPjzqjwl4vMM6dAM5fRU4wtx9p1/OrDX/kpOTxewGsroJmn0iXGC+BJ0Wgeo+xfu3ft91P7vaaWWlM0nUtpUeaxzMHUSHLK5HdJ+y43N47fnxY55Vxth8aLqeFMJk+RncszLZqjQB3O/VGl3pnWrJ07VFLn7yX6jx4+O6dIRXE+8fzHX1Nva0LY4HxlkTUENHXcfe64+zxM+nU4RkWRiOR3phRjvQzKsTThOYZ7VwCaZT9OKVm6SFXjdSqx6Cwu0kkHBYCQ0rAP2t4Vx7IB8QZUwSdSdMN1FACHTjZznbdhiAqzGMyx3Q5IoyJwwq8Zbzjps+Ym55DKw0HG8ku0mSlvphlgarzdvA2Fx5qmGhr34cIXjV6Q07ZP+Y8xKo3xnww8xGHUuWm9OuEjhicyI7I1M0eFN9KUiKU/OTLQtO1rNOVJSxsHXi2H0FMSONudfQYlpRxdx4kbgNOSea6pt+Ih7zMZF13u7rmcgd+0WEV97E35KSUUuJBSpO9bmqbJ/dMsL8z7U9aWczG/R/0wZkJNCC8I4RmkiPtU+fQPQx5PePbDmqrKizYVTiGvkQwYGgQYGXlEG4uAigc8oU6kCJEu8yPlKbfeJykcWV7NR/ahy0Az45mm73GpNaU/EPvIL/48EvuESLRjrSN2q9Ud0FDfDMB42AbH4TllTLF0qvzp37RMOOzv/MzpveoYx7beist2vONXXnL/OFun7pPZ1adLewoNPMcT7p3ft4RtnL937cicF7jkvuPn1so4dv9jx6CUU3iUSxJmXdKnMgrH+zKVmqZPwIcBzZznE4/zb98UXfoMGK29FU/dfa73y5E/T6fuWLBBw9FjNZ+vaUmPkUCPPYW/XnrMs/hdaO8ldCijHO/h+oo9fD/+JtFT3uf/JdA38f48tr5OPVNrfMhRGXtwdHSE8JIqvMT5WyCDLrhnIa0B1s+HX21589fKx7/XUFU1SGU8eY4wTo4uA4pzFi036Xq6pQ9Jhzr08fiUlhFATQ8LSo+SI4Qm4zcdzkBBDmDOZN+8UL732wnvKp6/Cogqse/om56+7aDvoe+Immjblt3dW9q+RVMi+MDNzXO2m2e4UIM4ogoxiyJgMo/pCYybnjuAjjLZtB+Fpg6pxoynLHImi+StG3NmRUgkYgawlCisOJfTJDtC8JYWWBMpmgOnyymdxJmdp489XczOrwIWSbSmqkLWISST2VMixUjwPTFOnFc00bUtfd+x39ktXdsiAqHyJO+J0eEchKrCZycPUk+7fyB2LcFXxLah2d8TKo+IEmNH0+zpuh0xJbp2/9hldaUjdAXMXOlKV7rSla6Uqev37Jt36D5yd5fMU7lOxFeRPiZ2b8H72lLAuArvK6pqi6aOECpcNqZYyHjLKdn1/RCCXmfevlZn0zTEvs+RaQTvAogpi0u0GpejZ4gbwSCq4MQZytkHxAUzIjljAC2ChwPx9GkKliixLoo5w1RnTgrzOnqUFkPC0nCwjBIzfDJnzpffp2XNmeDyt0YrgoHCXM1djBejekdER6NWAWNkJnrwPp8AfKbgjrFdUAAbUIx2ZjwajAgyMv2KGdJ1kLZLhJlRoBsUCKrDvYdGk0nbcx0DYEWE2Ee074fzVV3Rtq0h3WUcVxMGzcN5Cs4YowFlQ5dzSF6bxXu8XGceCzpJtyXZEHSChv4fKvemRjlLY+EmfV3MtfQM6t1SXgbwqCZL19QnRBpC2CDe/f/svVmvLEmSHvaZu0fkOecu1dXd1TPs2TdgKEoDQYIk8EF/XA960stAgABCJEiMiMEMmxyyp7qr6i7nZEaEu5sezMzdwzNyOefe6u7pSbs4NzNj8S083G35zAy7MIKchRxlEDI4R+QoM0ZMqscKPzOceHZAEdSoSVyQkY+uN8NG7aGlQ1Kz4IYiuVcd289apwOXuiSDk72nzfxs2nyUPIq2jTXXmGBOKR3W5WyVsa2AP6XePaeuP21E0s8erPJM68FalXeqRedNS9eCVfpoNC81FPXUegU/B5rSK5q2nvcpj/xT5bHe87lBM8+59hxY5po2lH5sXn96tpo5aAs0I6CN00a5rfF+DgjqtDHtdA+uITcwfvgXBzz8gDCMO/igEfDiE+L8EUu8x8efv9lUWlr98kzqum0pkwCGAQ+KMb0DJ7RecX30j8IXAcLTOIC4pki0PUL2EmlNTrTiPQgM7xQkECRyC3OERRHhbCZFV7rVe7O1gBbrAzQst/AK0MlR+yOYkBbQKW1MTQQYYd0UvIN2DNYRXEQRulYinuK9WqCqdUiwQWwMyGofJjA4S7SbzBIZxTlCGAJGje5j42DKyva5FQBKifKzFX2GS/3c3C/Kyq22H89gK6soTxUcsyofApqJzPCa0tLIkUShIaINcNF2nUQVoCnFi8I5E8ErMGaaDgjqmei9B7PTVKkHHA4HGAhZ0kNJ2Pac18+aiOCHWCLzWH8zC+CH4TC8Zfz4rwJYIbVQgA44FU5HJuGiSvLSi/I/K7PAmoKSKcK5BUt8QmRGpqFy50eR1bgpZ5t60Mzq+TVtMFByxgTOEeAF8z7iP//bt5j3DluwFj7zq22BPLeNVZGbHbD9juN1+NTefW6HW4/LFuz3NNkTqmNXVs+N666na3iQyzvQdfzBqV2zv/YUj3h97dfTS3mw9bPc5iCv3bnPXXe+jHXrX9KXtg/X8N6neYzTZbTXnHrn6910NE8+F49c6dwK9f3SOTmnXnF+7Xr+k67X92N6SeoB+Owc2J7z143tdt3rvj2Hf//1PNFt2pJtt879U6OXOSGsZ8U/1f6v16obGb10NT237587dnz8NPh59ZvXc5eIMAx38EHSeeZs8ZtpFVy41QU8fX0PFwiv/+A7hCDpQu0qR6b7M7cY3c8ciYPAmUG6GJ30xD3ndOp2zD5NrmlJ0jAJtw1E1RH7RsfrAHZHz/jhDfDH/4OkvZ2nhOkwY5kOmPd7LIcDkCOQZqRlwTIdkJZZ5OwwYLe7xzi+EccbeKTMSAyk4phCcBZFvAjOWVUFdZzalMSWJncddZShebFUXpE/S7XMzEgxIS6LAFTGEUMIkrLpfkSMCqCBRLOJGtXcxt57ib5KkZGy6A1MyvLOFxsQWGw9yAnsswnbYO1fWkWdiSIfZ1bbREby4uDjvZNyBhnHlOQ854gUZ0yTAaAkwlGMC2JaEAKDnNO0wDf6HHQDzNzoRje60Y1upHTYf8Dh8AHkgHk6wDnSiBYAkcdu3EnUGBIGOcUJ034B1IPZUvpwzkg5qTepKpUYyFlADhIOfs38EgjOC+NKmeDIww9OGDQyYwrBBV8Qz8wA+QDAg0mi23gXVAFdTFYQNHn19s2Z4SBgBUf1OJmyvkiKNdy+GGxIGUd3JAwIM782JPUMfkq5AC/av5yfI36pUEIszOm6FUDxLMeKay7GiIwjRtt78QrIKYnRTZEsxePXmTCSyzHpsxRPJMKZ8v4g+9cYqADxqC/e641IwryO/FLAMbBPEWZ8EONKjOLB7JzDw8O9CDGaumsYRnhnOV7NSrJWXbAy75K6SeqzUJQ2LluGuB5UZMa29eOx8UP9hBgTyzOCPXMFbvl2npWCRPAoRj0AzoGzGKxyznAU4KimuTgcnpCxwAepI0VGThFpeUJ8DHD8BVrJOHXmDBMTPQOe1MOYocFL3UmFrgFkWMvMYCSqInTvqSwzeG1GKrNBI1PYedectHrbyDYEwDEhG1CnMwytjRHnQQwvVVT3ddi389dtHztllOqNWc+N8HKZegPZORXoZfpUo87Z8106jGupVUs/p32Xri0Kpg40Y2ee086XjdtpI9Jz67449ieP1RlthoAKojlv8PjU+WzrjNW6VdV2G9dEgeECMNwFvPnijzDe34EQAM5Iywd888tfYP/0NR4/fAXG6+P7HcEP8l1Avk4bZ9HsuEQByRZ9poletgUcbRV/pvxro6iso4zIX4kgQqZ/q+U4IrgQEAZJdeMdYZ4Y0zwX8ASIwZmafb8Hy6wj0Nl35wCL3tJGdSljXtIN1kgiRBIlp74rst+Rjo0jgodHissqtZLzXvKYG0hEO5tSjZYnW6d8l5RB1PAEFqFQy2tSIUIVp845EGfxPHQAwQkIVZ+Z8XKmwLTIMm3UFqurByM758pzOxWxZks53H5f3dcAl2xO9M/u6JkpH2jvngF4re4tEI3c3yih2YGdjX1CSlEVqMZbS/S+w7TH/ukJ8zRh3O3gQzvfJfWkpHLK+gwZzu/hh1QiVRJkPNnA7xnCKzgB34C8vgI1eZIofIXPUtQaKtRXowIBACLgGEQR+6f3WOJHpDSCMBYeo4yAA8IofA5r/xQnVuZ6y1mhTrmGjLshcJI7gnvAMi1IcQ/wAfGQwPymFHyeczle9XtjHymf1PJaMkWpyAq2h21Fl+l/19VdV/om2l0P5t9u4TEfRNpO+84EHedtvoq7e6+h493oWn5iu4bn7Ld04vv5GrbpWj72c/G7hc9pnvlzJdfLrWpru3zsHJd6uW3Hd2/P8eeWe7o2wvH8O/V7q56+Pc99Br8u6t/edbuv4bBb2u7xehyPf12+5/y1x+deDohf110lvMv89W/+8/5Nb981VN/B8ym7+rt6Pcc/dfpt6MP3Qc9Zd0/vZHTldesjW3tA+b4RFdeOOHIYx53KHsrjOYI5pBkd8X2ckZYJ2CU4kEZnV5C6RRSt8RZBmpqJMpBxTL1e/LnU39vKXK1MJOpXWVlXTihFY0BAAlJk+NHBwWGZEqbDgmFUnljLG3YOzg+IS8a03+Pp8QP2Tx8wPX1EWibk5YB52mO/f8JhkggobhgwjHcI4R7O7RB1zE05TySRXJCTOP0RgxTwAmRkRomqT646Z0g/alpZHVWRu9UZoT5RFplMdQjLsmBZljKGks45YjrskVJsUuuyyromM9Z6drsdpiWJQ0iGRA9NSaKXenGCcCEDiXQ+1Pcl6NyLy4I4LAKSUR13ygkpR+QUscQIzgnTYQL4PcIYEGPEw8NrBB/k2pTUIUNTTHmHYQzgnJBzBKfqVHujT6MbYOZGN7rRjW50IyXKM/L0AeQIo3OCIl6qEeCwPAGwlD4WXi8hxQkFJOE83BAAkFzDBJAHkYMPQZha79VI4uCdP1KieO9BTjwqjZkyr1SQA5N5PisTjKhiRC6gHLEHqFI+JpgHNjODY9KQMg6s3JwYbtowgxBABRWeGcZ+ZzWEGKDA7BXCg66Z+Z6BX+Mt1FuaK1Pf4zEMpFLLUDGeshjd1ABk6ntSwIYn85hWpXgBuogRL6eao5WRpZ/eIXEqxhdWJh4pqt6fYFkQrDznSLyWta5qxLO2OjjHTduhhrjGeEmpMZ5I+9tnYaANTgkxRjjv8TC+QfAemRlPTzN24x1CEKNYjFFUulwBWs55cF5qnfaPmjmGKo6aV7ilZbB++RAwhFD7Q+b5a59yTMJU1j6DvY6P/CyRcOA0Kg8DMGOfCHMCiJEic85Ii4TYJOcwBLHM5iyptYgy4qzhKDkjZcbgR7x6NYDcjJwXBIgniQkwBMnUm8rMrmAUZ+3VcxbFxQT9VgHKYCSSKDSOSdqIjAT1QKB63bGhpFUHqtKwAfXkemG5qVdy1ud2LISvzTbAOdDMlvK0L+161S5t1tGq3q5Vzpvi7pr6ryEbh+uVsNerhvrx/ty05fm+9b2nU205Uj5dSMN0rnzW+7kxSvbz8ppn3p55yRher/A/V/PzlaWn+rZlJLm2X8fXH6nzXlCOPJl+jv7wT2f86C8zXHiNsHsDJC88AD8C/A847P8jwB9B9FA8q9q2vfpxxh/8LxnkAh7eBIADODoAYshnimC3AJQlDWBJG1MVYT24oQdOALJGc9mvhJVxCqIssSpys9a2QFfnNPpHQPAOvBsxhYAlLg0gRgAsW0rNPnJLq8SzuqTdddTllD19ril5wAJQDQAgfCAZ4Cxb/5W/cLKHO1U2ppgEgKtKSKfKTeEbnQJGGJYiVKpjVDCN8i92jxcvOWkplcgmonMjEAUQeaSkbzUJIJU5QZrn4IYKNCkzQ5WPrOm0mLmEwg7er1JHxRhLnvqgPEY7zsuyrJTCOedSVilDozm24Bc44b1TziUynwF8BCBdf7egrRZY3QKuiF3TPWHQOKUC1IrThI8x4vD4iBACvHeIccE8z8icQTyAmMFZ4LW2xzsvcgODIKJFVPASw5FGwmGJYmTRBiuPmwAD8pBxM/ZuVcZBIixJn8v80ffR54S0LPjb/3PAsv8CeSa4BrxhnMOrr2b83v/2LeAcUl4QU9TUYgE+DPBuBFgi6zhnqWFbUHhG8ge4/BYuv8Z3/zXhb/76W/y//8cIYAThwV42pMmA7cf7Xs8Dbf0qa5QCflwDamFAZQgufF977hz/It8qJKcFzaABLV/mWGp9WzFoRJ5BE0VwO07guUgAp3i9z0FH/MOLyr5013avrq1r+wm8jDurdW5xkce0sYOcObe+7rkc0OnyTvOMx/Wt6zxX5jVjf5kP3uZFnjOHtp7BNT3+ddAp+eBTW/gp8sbz6m7l1U9vQ72HN2d8o4k5We+Nvh+qsnd75Lr7bvTbT/27fu3737/lW/ec2rO3+I3yfSP9cHuEGHA8gKMCy8GqpTs/Y3NaEPffYXz7A6TEyOwBDIDFgmbRIsouFrVOBy5Ogmu58cjxsKF1xFKT06pMVSJxNmlk9c7ClzCbKCDnjfc2GYtZom0GP+LxO+Dv/p8FRPsyfndfZvzF/w7c3b3BEHYgx3A+gpGQ8oLDYcLh6RHLvAe5BS7M+PDhF3h6ekSKGQwPdju4cAc/voL3O6SkgJ5Grg6cVVCuOmiQF+cMIukEV7g4p4ys6YuD06igKQOwiPoAsTyvXKLESsTuu7t7GTcAd7sdgg8AE5a4YJkjOEs6qjrmUJuJyL3eBzgKABxyArxLkoILGSlFpJxwmA4ggugWghfZLidplxOnlJgTwA7wI5wfZTzM4ScnIC9AjhhSAnMC5RmcJjhOCJQw79/hkHN1TikRXkUGJ+/gra75Bpj5XHQDzNzoRje60Y1upJSZEBOBE8M7RsoMi5hBICjO3OoAACAASURBVOSkynEARF6U+gBCuBcwizKc7CQd0rgbQc4r46xGB0flD4QCeiAIo7YsC5z3GjremEvx6hUyRThWYIfqYd16P4sBhnOC8xClu3Oiki/GCOi1jWpCefBtpt4UXC2zfp2J0bka+r6CKUgbalc1Ig71v1sARhWJjDWWppsxBYoOlzqcs3uojFEZWzUgtH3ejKpC/ZioAYxzVVgX9LxDTb9Aq7K3xrP9zYyVgLQeQwGjAJLKoQCpIEY45xyGYcTj4xOGYSjI+pRmzPMM57wacbyIErwtpBmVPK/WunLOUh/U5tsMUtsdiOp4mKGunlNA08qTWxMgsRQqCP/18y9GMC3TvNsBgDwJHooIwauhak4gCtiNO9jTdiw+1wyGBzQ6i/ldsEae4WPvEGIQO4UGVeE9g+FYIhskvav1CDbvhBY4s02tYlANPMTQLGAQGA5KrBszsphZLMPWq8Z4o4Pe1vtc31hTcDxXGbqlUDk2OVym9g0pSrxnROU4rch5Xlsu19bHwnnu/afbcA4ocw19ikJ9iwwIs9mOM5VdbsNzzUTX0fnx6hVtp01K7fn2que0esuceioV03GJrcG0+oqdur9/TzbNvXrejwHjawBwWJYID0agDM4znvbvMAYgJoaFKe4V6i4A42vhg6LyTsyiZJKKUtkYiCxiRp+esWt/wyu0XnRZI9VINBeLiGJ7Z91vpNwOKAII8INJAScS+Y5T0TRqRJUTq0bXzuu8BaVt6ygsAiQQRzUbU1OzqjdgAtjCLisIKOeMJUYFsaz5hDVvpc/FbfMhrcLV0obaecrUXAfEGAEkbTcaAARJGkfiEqXOQLsC8NFn7z0GfW5R05SW54i6t4cWjKt9tb8aJWfd7qggGONVilLYCwiJ9V4DxbTjIh6Btf7CS3RgqD5iDZHxm+vYH65p9zxPmOeplOe9x+ADvAvIUZT1BAL5oP0yntHD+YAwDMKrrTwrDVRWefd2jm1T8/4zqlejjgEoIcY9cn5CmiKWpwcse1dAJrVk+d+HAa/e/BBwHrmkkwIIXhW4NZKRRb8pQHdW2HBwoDSCksMwJoCB+anCPk69e9x9r9JQ09M+FH/3yc29DOH/mNegEwM390CUlneqJopGJtMKLNpf33a7m1cjWuu0H/0WegqKe9T31bVVWmvreg69ZB9+/j0vadkZXuliG2hz3K6l7dE/HuPTO/q13MhLiDe+vbyMl18h9BwO/Roetdc4bLXl5bP989A1/Vivq/2seH7bt/jEz0PHbdlqHTef52o+3zNbXTv+qvvclitv9H3QbWxvdC1ds+L0cvLlfXj72vb3KSefrTszJ5VfvQRczMKnnUuFnHnBsnzAdHgH71+B3CiRrtmLro0IYAHIELzq7CTqp6g419HWT4FlTp1rgfvrSJcNkMYBOeYTMnSGOZ+mlAtoPhMjRsa057L7EoC7Hzh88eUI7wNSjJjnPeb9EzIvSDHi/Xe/wHz4CPCMnCZMh484TDNSUunVBYzjPby/A2eHCAHorHS5kHXeopxjBSjS3dAcLZKAZFbR6Uvo7ayypKYx0uPOOZU9vNodEpxzGMcBwzACIDw9PeFw2GOZF4TBwXv5E7GWNWonIcWImBjeiYwDIn3GGSDGMHggZjA75JSQ4gIiLsAf+xSdBQqABiZfKZCInIfjgAEJmRNyTkgpIEcPpBmsEWcdM5w6oMjtzdiyOKVmInHWvtFnoRtg5kY3utGNbnQjJfI7uOEBBEl/47LkjDTmq1VYu6LUd3AUJGIMKziBBeASwg7m4csQz2UiEkC0hkp3joCYiqaVOYM4AJamR48XwMyR1kAYSyjIAJouCg3Qo0ZvqcaGXMAWrWHkODz+90W1Gy9V47YAIuu/Mv2aHkl4cEaNG6J18xEUomuV9Z8LH98bobbAJfV4VaC3QtI1ApNF3OnL7I1e62eohpAs8ydnagw8cpxAcE6AMl4NWS1Ypq+vNQy5gmI3wBMA9H1owS0MAb5UNWAPfqoALc33Wu4DLLXX1pivj4lh1Axkgwv1dXAGfiPp7x0j/8nXSPyIlA5IaQLtX+H+2z+X6xU0k1Gjw7SmDUt11AqWXueg0/sMNEPIIAYisfYwl35ZRozczfv+KZjPcm9kkc9eQSDG5xLNozMY2aG+3tNv3rGq4XOsBs1sOFv7tVTAAGcad86E+P0oA69Rl5++81Ou+9Q+XRtdpp0d51J8Pb9lvTrt89Bplf+5Hh7Dyvr5a7+vaXUfIYkBvP6d9xgfMogCnBswjLsSpUKMphK54pufEaYPaxMLN38tvf1JwJsfE1KcNKJYBSoKkE74EEn1KMZt70bkDDx8NYDZInsxPGU4F7GkAw6PBzz+wx8izgvm9z8s71472zMYmRMIQXEndR8UxaLuAwqWZNZxafahfo8rY69Kw3YfRWawY+Qsiq6UzuzrahRnBmLKiKnJLZ5rHLECmBFNVhngrX3cjl+zr/dl0EqBqHPDnntuyuPKr7CCE3LO4MySerCrs98zt3i946g40oc2qgvQpyii0kYqY8mqhDUFX8YwDCtQU0ZuABO1PW3dgOSnt7oMuGLt7se5H/+tfht4B1y9LAGsy9Wtw+ZWm4rJ+m91bIGktsDV5bl1JOAoAsEjJ6jyswJkyDmEMMApoGYIg3o19uk6Pw9/3o7hPB8Q40fk/IicEr78c8DxqGAnp7yi13npcPeFB7EHsgMx4GUQ67yAhjInXfEKvyjfBSg36/EZgEQ+rLzGy/omeu7LYAhqosAol1+i8m+YG1bt6feEuhofwWYKX4mj64/X7Z7PIxwDCKo0d8zDnRo7u6d46R7177eTznFhl+bHNdSO5akxPj3e2/zFcXue27prePtPp5eWfU1vruWe2/dl++zp+34V9P1LAefoc3HQpznnS3dtteDUve31rYx9bY3/nNa1G93oc9DL16eXUy8nX96Ht69tf1/WWdRaGUDOCxhBZFTVgbbUy/sAsOzv8e7vfor55w/46k8Sdm8mOekCasQU0QhaREeC6NxWyUk3+Pij1nbyziknhwp4r86r3MiuVW+t/VI5Uu7TCODO4f4N8NWfz3AkMpL3Hg9fBAzBI8YZ02HCYdpL5O40Y5kPeHp8h+XwiJwXZD22LEBmjcYS7jAMDyC3A4sHI6pDb30abXQc02OX58Cmy46Nvt4XvTDANbUW56a/XMdEPQ2JRgCSmslkP3FoOCDFiMwJ4sySixOq9ySgE3XWIAqAz2rPkQiuKWfAEYZhAJAxBI+FxYGDHBDIq0xAmg3X2qr2HtbnYM9DI9oADo49ssvwziO5gBwHMM1VrtX+WQTzEumUtd+O4MJuc47d6Pl0A8zc6EY3utGNbqQUhnvs7r4onq5JATNEBOe9hM5rFKisHs4SdjwIO5gzkDJK+iRTo64ijgCgBM4ROTFSqoaYnAhZrFuNEcCY3E5xq8YeYRZdQY7bBcKAsnrR0orZ7o0ovcHB+rdF13lUn76vN+j0Ys45w0h7/Qqcwg0zXpD9gDDmZrBcq6uJmmthYRjb9q3VOG3bq4evgXH0eEYjIlWhpxd8Tho8qDK+/Zj041fakg2oIZ7HMS7CeLOlriD1vq4GMXHQPzYEbRkEba6s6z9OWWHzDc1Y52xjUOd/7U8rREDQ/XAwrw0zclmdpwA0bVoHZEhKpiiAtOAGZCJgmEF/8gHw3wH5A9LyAe7rH8F/+xcgQL38JZ0Sk3n8W/Qi9ewvb3MN4W/RZszQkZghsXsIDhkRGYlcmROZGamMlc4RbCv9+hnSzt5+hhKr10NTkglrMt76VMhq3KZLipRTbXo+fR4150tTFNUWXN+O65RM36+a/PMYKy735PpefC7QzEvNpOeJm/9PnW3b0H/vvfPrjtCr/47fyX6Ue9DMD34/4s1PEkAePjjc3SnYQKPPAYycIvbvMqYPWybW9TcG8OZ3An7vvwuIUwTHGTDDtQJWGCyeTJ6UP3EIfkBOQGIGskMYRriQMPgEjnvE5SPSkvD+7/4AcR5qvQ1oBpD0ePOyx/1uhEXByHlBygmgBEdiSLeYWEQk++UVgBM755s0PspIqeLM6Wde7RPM2n9rM7N4geUEzgnUKO1Add8SsEofSe+YN7kGLNGSc3UvaKP6rZSFaI30kkvdeypgGQIEmOKrGqfvcw8wWUUU6RSWNeLNmk/s2y0g8ABWpaBEy1FAuV7XRoxJSSKHVMDoul1b4N/2d9svZtYUSrWNBnRp0ybZfS1op73WymzHHlyvN56jzDG9vuVFeo/RlixyTg9QIhKOwNJ9eT8U0JpElHEYxl05LmAZSQvZjtWn0hYgSlLHAuQGuMHhJ38JjKN4PJI6BDAHpMTahyARHC3WnSrDc5Yw4gYckLReogxm9iB4XS8ycvwI4j0s6aWDORY8oy9Yr7nEZLE8j3alo2/Kv68kAovMZ+WyfduQUbrvayMvKYia2up0femlkOOyTR7Z2oVXssbqm/W7vQ6rs32t27X3dfXlXHfttfddR8c76ak6nvOW9NeuIrHR1tzZ3u95deRajrJee5qu4zjt2k8d509/Ts+r61TPrp1nW9c9h///vuncG3yqdc97xz43x7w956+/a33sORJe+/7aCnX0fp4p7/NIkze60T8fes7u8ilER//359ZHLrWp1XmdL6sn0eJBI4OYQqxKfVvrEBCfHvDub/8E7wC8+fGC3dsF5AJcFv0+W5pa5T6L3KBxq3tZYUvXbrSVgriXY1blOIecE2JcVuAYa31uUjMRkdg1UoLzhDAEjD8AfvovpbdDIAxD0GicEdNhj+lwQFxmBcvscXj6gOXwEdP+CcsyI6YIcY70IDfC+wHDcA/ndwANJUU3cyoRw2sfTK9s+glz5BDXRQHLpEaGasYE+ttZRFmRoat8KNF0EgM+eKTktJ7qLOIcYRgDeM5IaQHASDmWCKrmzCn1D6IvUJuO6DZEiCDKKgnp/NL45QXAwtQ8G0srBRBJhgKxQdQZaI4/RB7kHch5ZBeQ4RGGEUEdhwCJPi46fpPlq3zqw7g5x270fLoBZm50oxvd6EY3UgrDHcbdKxjr7RyDfMPgOQObSDi+zFl5bmUKwUiUwY5h+TehAA9HTrxKnRjTmYGcjAk2z1ZAGG5hrMyj2pi8qoRvmeJ1ygK5znp0rGw3D15j6nvaAqv0tOXF3NfTUxtW3+4xsE/vgdz+1RQ86DyThSk+7ntF/LdjJ7lE+/HRMVLpKKunuY2TGPXW0U8qSAcKlpKwj4bgz/pcioFyw4jTC08teSfe8udAQ/1zKKAcmVmACwh+3VczYImHdU0LMY7j6vn1uXF7L2ob19UIcu0rwPLemICQVfDJ8iwswo0JcSZ4pJQR/KCGJXm/Yoxl7EIIxQu9BcrYHAkh1NROsEek+WW16d4HfPHmdzDufoLEj4hpB9wJcI3iAJdF7HBF9D0mJgG9ZLAKSaSgGak0QLIZBzgsnLAQYeEa1yWZYZazKuVb44cJ3mulgCt1VKVD3zbzayEz1JTrqudrXt1r9W4ZH9ahsbeMMC+lXrG5pejsFTnWj0ttODZEtSWca8/nUreer6elS4rxa1uzNrtcMsCs67/WUPacVmy1mza+/SroeB5cd8daaUfNu3meevUdQ9J9uFXUgwqHuLv7Xbx6NQIYwJpWT0C6KABD7zIIH0FYSgtK+jg67mFGRnaAG18B/kH2VmdrikbQcrYHaxrKRfgMhwzvCLthwDK9A1HC/vAOH9+/Aycy7M06VV1jWEwxYf/xETv3BsFngGekZcZ+/4jECcMQ4IJH8AFhN4ARCs613b/bfV7aebzv1ePrt34LWCk7ilPFnew53gFwHo4AcMY8a8hliwIIAfO0wIktOgaSnqZyvu8PSACbmpLQaZTAnIVHyikBcGX/Dt5j3O0krZT1seHrWn6j5T+sNvM0tPYYf2WpjdoxlHSOEcyEEAaMo4SzttRKzMBuNyIMASlFLMuiqR8dhiApIWOMmOe58H/tnm18iZXXtqcHAbX7PVD5QQNRtfxCe531owUFlXHShdB4HgEEccMr5SO+bes5bynE7bqUEkIQEMw47jAMAQwPhqTl8kFTL4VBwfcKbnYyv9t6TwGa+rpPUXu/jdX93WuA7lXBTyAEEBw4yRqW2IGcJoQkjcTkskTKTEBcElKaEdMMUBZeG4RhHHD3MIJoBBgaxj5o5KFvsBwOADKWZQfiH2kDzxtt23W55UsssoxxwY7N8UBWXG4/tQ6LNFOTobX7ospZYJTwMyfa1Rp5jQfr+axtTmvdo2NaQ+dO39nwe7x9PUH6XVXzx63ZMl6119mv7fbQ0XX19/ln2tM253aOYznBq5+9o7u/N76poeeqe/FS7vFU6/jo//Pc78vAMlvz+HMSHf1/XP/5Ordkk9PvA5/4/uukylH2R7avu1TW5+Gln/c+XlfS886du4ea7z3VNX991W/K877Rjf6p0K9CGi+81FF9z3OQ6a+9BJZpdx3nE5xnDDsP7wcADpxVZ7HJb/b7abPqOsB5dbIkQszKV7LyiUzIiYR3L+LeOlrMOdrSu5o8YoCXVQRObW+McxMhdC07iywTEfyAV/dv8X7/Hvd3ksI4MzCEe+SUQerqxyliPjzisP+AeZK0stN0wGH/hMPTeyzTAXGeMC+LpF4GcHf3WtMwjSAfwORhaVmlP6YjzmYS0ciV0j6QyrBEAnRJCzhHiXzjPbyjJvJ644wAAw21OnYDqUgEmsfHj2Bm7MYdXr16jbu7EcMgTj2Pj4/47ruI/X7BMIQSLYbZwP+52GoElKRRN7XOlDLmCfjii7c4HGZwjAjOYdA0SymLPARCsX2As/TJe4AdvBfn1pwlys00zQDUKcbJm+P9KHN4uIOzcgCQ2qJsUAmmR2BYdoMbfTrdADM3utGNbnSjGylxZsSYihK+hq6vIf9MgR2XiCUuADHGXZDwjIo2ZhIGpg2dBxhgAaIU19B+rVGjGhTMtH3MOB+rhQxYcWSHqdTw6W3Ek0uRYk4x+L337zWCgBkreuOTc7ROQbBRb2sEMXCGlFc9hnuD21abqiGuDXUJHR8N5dgIKJbupwVpyP3raClSrrRnGJyCQNSDndYpELaitRyBnWjbSGjGJjtXDD6AGEGLgGao/dbgBMh8o9J25+TPhC9rY/sMeuOMGRQNlFTnHwMQAxoj1vK9eCqLsUTepZS4RLtJKQNMCD4UAUdAL3Vu2xj23t/tXCYiBAoKWLLGAuJRIj+YCR8/MHbR4/7hS7z6I0L+yd/jH7/+W+z+3V/Bf/uVGFxYhLlBi4iouWct3VECq2FEI/hAxBV5fK4YCQwTY0ZuKsccUgHNrI0RRSnIFbhjxmqgvvXtDLewnyBJEWXik2vSQDmdB0xWio7LpmJ6Xf6x4vdzKClVadGVRUffz5sL2rZsq0+PVfNtnVsGj63+ni/xPK3fluuuXbXjjAGnVaKvr7hiQ2jK/1QF2j81pfXp0dkyTZhqChu/gHOzgUleuvYdZwDMAYwgoZtpAbs94DSKAwcweywpNinr6rtvKeKO5/se3s8YhtfgNCInjfIFyasua1iNwyApv5322smet8zwIWI/fYNf/kePX/7NnwlAeBnQkq3SNnP234742f/1Ff6LAwiTbqsM5rEqTonw5l8Q/vhfA0vMqObluj+e40tWgFpNTdTuB+3+VSKBWGolBqAea6LMy8XrbRzv4J2k2izgV82f3oN4+z3xmna31x4RKVBW0DuI81IViN4DQcAo5AgBomgTz7f1njhNU5NCicu+zswYhkF5Iznu/VqZFkJYja99l/KCPjuHZZE0X8YjM2csy4IlzqXeEALu7u4kclEDOAEqGKbfy0MQZeUpMIhFkmmftQHKW1CtPfseUFt5ujVQKKYIpBqOvB2znnezdrXRZq59zilGHPIjlmXCbneHN198id3uvqTm4hLNKMncRILXcbeQ5OeAW8+htl8yFg6cBwC+vKctCBNg5DQDLkNAMxkgAV7/7V8nvPtv+u4RwcLSM4AvfnfBn/7rdyA3gHiEo3v4sIPjBfPyj/jP/+Z38OHnr8XAoDWtDCG0xZlc5gWMnHm3aj9yH41uxXs1vGz53wwjhWk6vreJsMWo3FTlBWu7pZgasZDLKG9HhrFSz4EEaunrPZyaUktd1laqLd3mSY4Bo9aWDc5hs209t2Vjeg0Pt009V3gZ5rxd1zbvc22bnsv3vYyu69819Jz7T3Ezzx/j6/n241p6znf7yr7M33Te87o2X8E/bJTz3JZ8jrH6Psf7V/OO3ehGN/r+qQKZ5RdWny8q8ZmRZd7+9L/hx3/2HV6/+UOMux8gY1A9YQa5mnwd+m1rXbY6Hj/usXtMGHcjJEo8wUnWIeQkMqn3TuRlc6ztdJXAWs/a6q7b860O22SblBKWZanyCAHOAa9evcLhsJeoJ9ZqZsQYSzTQd+8y/u6v98g54A//xxn3P3yCJ4+3b34IjwAgY54e8fT0LR4fv8Xh8B7T/IT90x6Hp0nSF80z5sMkzhLk4MIO43iPcfdaIpqQ08iU6njiTJ+bVAet7WMqkUfJdBmcYcmRDZgv0WlVBskMsDmCmPxq8rrcvzw9Yhi8goccnAPGcSzyzn7/VBw6UkqYpgnLEuH9gJQ0XRMLyMU5YBhGBa1YainT+TM8CXiKmfH+u28BSOpdMGGeZwzDAK8gIGaZQ15T84ZhAJjw8eMBziW1B0HlWpVfOWKZIwCR31OKiHGGY2kLua1UV6KnJtBtE/2MdAPM3OhGN7rRjW5kxBmcxUCVOIIUsc3GkSlD64nBngB2SMgSGSYrWj1zcZIkza9JamwPxbgPMJknsJOIFSyMofcBgC/Xiak9F+a4MEPWZFTwyslucVX4XwNusfIuAWaeSyeFBadB1FcgHoukszZwtMacei1vgIWsPDkv99Tvdo0okmVsrYwKjiF4L4w7g9UrQQQkIYUzsNUj3rmAgXpUeU7rcvvxWxnfwACvz9u4mJfBajxVqyrjkVegnD6NQGsEMk+E3hBkY3zai/rYoCWXKuNOrJ7nWcdAwTlkxp9qsJHQk6TCICHGpOPr4J0vQhSAYry0dizLAvO4KGMLDwdNg0YMogimpIYoAtgj5R2mgwMQwA8B48OIN1/9FHl3VyInOBACi4fAAI9ImlqpAHmktwnVw4PhYKPN5a2UGeEkmfFaEagTI3UCup2XqBQ1xUD9vxrcsfpcxxlZG2uatgAFNMOQ1aWaeXpFaG3xKeX9S5S+p4wfp65tVeinFPnW+q3aizHuxPGeTvXgksK7B1oAKGlrzpW7RUeGmg5YdYq2DVXb15RPbudLndHn2karX9sVtG3der6/qUaOvs3Hs7X+Ote/VXkNaKaMIE1gOoAxIeUn7Jd/ROYIcIDDHZx7QPBfIDfiOgNnwDLAtH+Hd7/8iDB8gSG8xW73CmEIuv7pu678TFkn9D9JBUVIacY8f4sP7/8LPn78EvHwxUZUm3aGyLecCfngZb2DRVmwf5X27w/4xT++w/2rr+CHO1gUOOCYR+ip5RHM9FxBLMfXAoDjUNY7VjihI4mWUUCPJKCVsjcyI+W58SRLK2DpuXadopZ3OTrO3OQ5Xys9cxKlmbd0XQCWGOGcLyCQtr/rVEKS9932SUAAGasoK3rPFs8nwHGBgzJLukfhb6gBLTuAgBA8lmVBjBJpJqVcwNAtIEdAN9XjbitiTIxxxav0/Iv1z56NXWc8QjuPjG8yEHx7zrEr4CgD9/RR9vpnfG5u9s+5jCcJ6D7liGnaYziMIAcMw07SL/kGVOAyJF1aA5TbmDunebQL1IOBpLDmfbZIi1yU1ZWnVZ6XPMgBy/SE6TFZi1ZR86anPT4e/g4EjxB28O4OnANymuH451gOP8L0pIrvTXCMlVr/3+yO3m8p1HJzOXd/q7XcDC8FSHO8u27xDauV7wSIVUWKY/N/V6BxX+jWyfXafm5sGnmgObbezyuPJ6w6lT5zc8VWX9sSjsfnepCttWVrz9o+sr77uJ5TnODp2jdp49atyG0Xbrm65ku8G69+neLgrivxU/irT7mXjv7fOv+Sms9ynaszl/jk59R6jq6d/78Z9HywzK+LRz+1FvU85/avG93oRr9u2uRH+HhfOBfJ7RyYtS/nmFT2GDPuXxMeXu8A7EA8CIvrEpyX6B+qDb1QEjBPGTESxl3QVEAQPS9nkSM4i66TGeZYsCpngz8vjh0nrjXgi8keVRdK8J7gPMBIWOJcrs8pYVEZigCE4BB8wPxk/ZhxzxlhlDTQaWHM04z377/Fu3f/gP3+l4jxESlNmA8zljkBmZDmCMqEIdzBhx3CeA8/jiC/A0iiZqZMIl9DdOukBhDT5VaQBzU67CrDr8FFJmfq+HQyqlxfr/Uul/FqnSxTsuipzhLJytwIAd4HeL/DEERW/vj4Hk+HPUIQZxtHVEE9KpJJk3Ppk3MEkANUXhed927tcKHvQWQgLdKXQaOKpizPTBw8pCjiDJh4hARCAnMEZ3EAInVwKryOdqvaVD6Pg8WNboCZG93oRje60Y0KETKcJDUAJ0amrAYHajSfZnbJEtYfEqKPk/IraiBwmiQFWYwvYhNSwIwDgMpkgwhiOyA4xx3DqHWuQkdWdZBca0xj7Ulv9uuV+Je8ZM+BJlbH2cpurKR2YoM2jTJu7e2cs0X0qQJC7+0rZZ1SVlt7XLmGuaZbsmsq467GANequGsfBPRhatuarEcenaUxEoCN5R/NnMEcAQK8X0eoOTv2KhS043Vq3JomrkBRJnhQ8ywM0LMeoxqtp6XjKECtNzKdnRsCVLHnpsw/VaCTlS0hMaVN0gbo9aRRcGwoar/NU8IMlxae1OqWcRYDHpGF/hRjI6MaemJ24Mm8qEcM/sfAnwTQTyJy3mO//yXy8ojh6z/EsH+DgR0WBc2YQSaDBUSjaQycikOm2s/FnKszsXg713HLrOZaA1aZknlDqWAG3BE62AAAIABJREFUof7Rm2q/GmSqcCc/1++IvhUFNGNttfL68luTCl1U328rMTdmyubRa6g18PTtPGfgMHMRrY7V7+fvvb5taJ5kaWsDmvlV07GJq/vcAMts3XdMa9X1ufl2bdt+s+jYs//YwPpp9M3PIp6+y2AkZABzvNN9yoEgiqzgGdNHmUn3bx1++EcBs4IWHBGAhCUeVCmVsftiAucFKe7haAAwyL5WlnT1lIKC54jgbA9QxVDOwNf/YcDThy8x/fJVeb7175Sxoo4YdX8tLR8J3/yHgN0D40d/BoxvoGkoZb/YtvnXUkrEN6urAca2gFv7tH2rvpuMXDYY2QNHTflnUUvAjJgs9HUqIBBgDUixvbCPHHeKtpSisndnkPKQFpraPNNKuGmbftSAOrDev/vyZT+tUQx7AHLf5na/bfkAAy/X0Nfra0PwcL7yCcyMaZpAoDKudn8LWmkjzFiEl2VZCpimjdyzdV9//NyYG3Cm5cX6Prd1thFqzo1xO3ZtGUfjiQQkiTw4TXuABIAk0XXEOzNl5ZvIYRlHeCKQcwLmWkUF6vt7uX16FkUOofqusoFkiAEk+TOldyNXGJ/L7EAIK56kXfuJCfOHEf/4776EKPYDSMO050zw+Bc4fNyV+7b2qGtX2XKdhmIH6nJXQHUnb1rXaZzCWTKx7Ow1rOvs+kkZaDmXM9schnFcl3fh9S61DS2p9bSgmTbSoF1hV/VtOh6fl0WkO9Wvcz29zEO89O7jii+BZc7Tp/MFp0dmqx+/Xu5pq0V09P/le15a76XeX8tffsooXisfnLumX/t+U3ji35R2GPUy32/SWN3oRjc6Rcov8JZ2FSej534aWKa90IEoABhgUV2Ft02aanRNzie8/f2vsbu/wxDuJcImEYg8xi/vwdljmhYMw04d/xZJW5uFMxLnV5E5zXZAMP08rRrO5oRXIsMYt9bIsiwRKpNFUTXZwklE7pQTUp4xzzPMadLK3o07gAjjOODuq3vs/vsR8zzh/g0QhoAweKQUcTgsePr4iO+++yXeffc15uUdcnoCY0FaEtLC4OTAEdgNrzGMD/DDDuRHUAjIFMR9kAEBv2ThI83Ri1BBL7X35VzviGDXg10ns+nY5NpHk0vkGgeJ0ikRfrxnlTvkOucI3jsMGgUVBHDWNFpEmKaDRprxUlZmTe0qcrpFpN3tJLVXijNSyhh3O8yzOIk45xH8sOoXs6TCZgZyIsBZ1HTtV87NGJncSSBmcErIKYNT1FzSpl8npLx2ogXUEUXtTjf6PHQDzNzoRje60Y1upGTpYNrfkm/SlXybDICbsPCOJD1PNoav5LsXA5R5aJa0A1q2GToEkW4K+WogqSCFtoWiECa0HtVcwTIMHJtEocY0O8+iF7cSrakwBLey7LRWvNuxAn4oiAxXwBrOuVYKqvWVppiy3uquptZq9Gr7aqAiVKGCWpPcKYbQjEK5jGnTsKb8dYomr0bDPlqLD0GY1w4sw/p8tow4DDG0OV/NhlaueGVvtb0Nhd8cpbWBo/U0aA2HNtNklDPYQFutQpib50qA1/lrgo28AzrebMKMfjZK8mp4U4YfrIISIICVOjYyZ+p70xoYc04qZDh47+C9mm9KWMxq1DNjWoyxGDbrmGRF9gNwDpQZRFkyMhFgIQbs3YlLNCsthoFw9wczxjGC8xPy43dIT9/CPf0O/P4tPAiegYXMg5kRdbSjPGmk1kCL9o2ncqSGxJcrJcGBzPs+XYA9z3aWZwVeXIKtkHoQb88wgqWRKvK4CYQb11fzwfPVk+euvuw5e7oc7n6dO98q16sprF+L6x2nxmCr96d7UNeaolB/LshipSw6375LdMq0WsEytDp3bR3cfV7VFou28wmgk2sUZfWZvUytXueL1Oaa59H24VLp/Vi39M1/AiR9iXq+4e3qvrp+yPf7N4Tf/yuPOGsaOOfAHDHNs0SlACHxayR+BbgA53aQnOq5REcDoF5Suhc7aMS0jMwJKS+IU8Q3f/Macf9ax6KNLtO/fdv9tV9rbkT3yf0OT/9pxBOAtz/J2L21qC4Olo2SqC1b+Ixq+NX9IgQgEYBYQKuy3xHWAOOuxYwCjiWIAm13d685w13Zl3ziAtB0bpHrSUE0JW+4rvWOZH0/o6TqI8cU4EqrMGTJ2e7Q8JklpZY+dw8E55E4q/eb8Y0JNuttz/ZeeJcYk3olMpwTBaJErFlHU2n325JCk6Ps4brnSZ1ak/FWOvTeeVAg8YjMkkbKQMWWctTAMxYuvAXMMDPmZcY4jsIDxISUK49ceB/OyClLeGuNXiMKUgPGQsatGWdTTlOzCVsUF0vJZPzFKVDwNXSs/CVAvU85A+wd4jIBnBHnCcM4IKcRgMM8L5jnBQzg/m6HEGS8QggYhx38MIBQw57X/cx4IVa55Hgtr/y9yRXNXNHRAGeQn8E8I/MCCaWesSyT8rwOYA9J3zSWEPC2hzLqq7d8vMc3//6Pyntbw603bVoBFHoefetXN9ZHv+uItPxwzyWci1nS89MAlbX+dL0bbbP9oQFAE3QvICv/9P5BF8737a4tOT9v16N8DBBqz2+V1I7PNW3avu545+yPnOJbWqq9fQ5Hub6350Wu4Sfr8W2+/SVk7dkemfP3/SrpVGvo7Nnvt+7jK9brQE+fc8wuvXHb43K6BXTxipfS9mhsr7q/frrU/1/1vL/RjX6b6DKn8HK6tB4e1f0Mh6Jr5f/ynR0ye3WH5aLHBwjEHgIQr+RCxpd/+gv84Ic/wN1ulFRDDgA8puk19k8L5nkGeY/BD0g5F0dJQGRHZ06WRbUqAhnpJ7PyhgQBRGThjn0jj7VyBOeo11WZRvS0GTlHLGnGskQtR2SiMAxwPqisPODu3uPNjzLmKYPcgHEIIDgc9h/x+PERHz+8w+OHX2B6eo/ME3JakDkhJ0ZaBCQf/A7D3RuMuwc4H8AaVcYi2Ug/syoZuMjyRKSuhcKnVTCQueuZPM0mnKg84yCRVCz1EuvDVbuAFiP2ErNFmIOm6Nu99/I8XI1YSo4wjJJBICcgO3lu07xHShHj4OGDWzls1OYRQhjgCFggkcx9cPBJHrZ3hBAIKS9IiVXWDhh8wBI16mrR6YsjB+ckZThCTEmucV4AOynDqycRa5qvlaOOzjsDzzuSiK+XnHdudD3dADM3utGNbnSjGynFmDAvSZXnoXjmpgT1AW+V4cYNi1c2gSta2Dxxi0G/8WClJo0DMyjXHJwGTgCoGDUM0cxsESzEcJRL6HlN2tKEJVwTA7Q0hhVlpLJWygxLmyP8rQFaWBWJCtxRYxFAWKKkw3GKwiZScNFKE26MPQqTKZRR+TjhQC01TyWJEAKr2dnYyPXrOtEwtNXoU5uholEzNgY0In121ha26Bx1aKTPYkeoyvjyTKHzY1GGvraNIPlMyVXGndsx2SQJAWntbg09rVc4gBJlpYad5NU/mWdqQNusj1SIgQooNj9RwCi9gU9HTeZgSTdFKhSJZJRTQsqS9kHaRUhZhEJrv/ce07QvRjRmydE6jmNJOeHsHQOD2QTKDO8J3g9qRPIIwcYLABISR3DiOi4cYMZWETDmYkibI5Ciw8OrHZgnxDRgNz7giy/+Fe4fJhxe3yF/BIiz/C0eYCBBIkyJZzRjJpaoVKjRWmxEPRw8r99LYjGSekhMK0BCl9q9Ms7yfy4iph4jjXG0oWBoa+ECmjk2FFXDM/RpsgJ+tgWsxhS2ef40tSaFtdq4V9KeNpSc9/feVv/S0fl1704pjU+BjNo76Ko2FZBU06Jn+WRfCSi5pIYnB/ihAbfpRaKK0Hs4gROQoz/br1MGK2BtdNpSwH8KUObSqG16opWoTe1TeAlJKVtRgswz7qxycCtaVDcT6Oiz3tMCbZgj5jzDjfcg7JDYIfMOtLuTdjIJuA8QpRUyUiKkZGu2ROCKSQAB3hMCecBLGqbD/hH7pw+YH/dI+cdg+NXzVX3Rdj+7PlLTR9qc+XIkHmakPcMPd3AhyDpODLikewwD7OUPBFGs1ehiySUsIHCovFmfOikjgTmhpJrRlH+W+i+EAcPuvkQ1AWTf9yR56kFRsLo+wROBicAxInFE5iS8CG/GsVhRu4/XTyA4UfSlBnAbNex2myrJgKzMAjJl3Xet3xXs00RGcYRcAEQVlAM0EWRU2SlA0qW0z/K8mzrZ9m6LmGd9AoAcZT+04zKuAoIZx7FEj/He43A4YJ7nAkayNtu0uLvbiaI2Z1FsrnjxWK4NgxeQchsnW1pVQTVcx6KPSMfMWJZUxquNoGPAnlMRbdq+23i1v9vUloW3NkBXZizThBwjhmFAcEDUtFCHwwHTNEl7YsAwmHekw253h/v7N3AuYBjvMIz3yFnf6wYAxinDBQ9n81KV85mzpHosYHZtO7vC2+ec4H3Ckp+wTHvEZUbGAd9993PkvIj3ZAhwLoDoDkv6KZgedNQrj0JcE0PaGkzgkhpNn9LasIG6u26vGRtr/dF+UtT26/KNvd0ALhZJg7uVWdNLZVTwc0+nwCb1dyNjaN3Cv6nxZjUePa9xXO72Hqx7VLmm5YE2eJ0uikqzw3Q80vF+t/q9UdYWtX3qudGuZSf3iWvKvsQn9ON83J6t688/37a8c8/tWnopl/J90Vne5uorPxfx5gzZrr1JcYf1uP4qx9jWje2ZXiWj/lu9d/NN/KT2bK+YN7rRjf650TVanedofrb4pCpDougeKrxia+W7TL1e51z7MnkkN4ADIaZJwScConBpAHjWshQ8TAQ/vgLCa2T3GhkPAlTIGRQIu1cONC+Y5ieA7gA4kBsa2S3Ce9PkihxuDWT9T8DrovvL6lxJlBFcAOeMmCM4VafNnFLjQJGL8yCIwI4xxxnjeA8fPIg8QhgRwoCUGX4YAPJ43B+wLBPu7nZ4GB/gww55XvDh3S/w+P4b7J/eYd5/A457eACUR+QlIyWAaUDY3eNu9xp+dw/2XqK0AqLbzhFgsYPUUELm6EFwSXSw1Y4h96Ucy3MikyBMkGDhljNDHUhUdCWNPoMaId2ikucUFKvDALLw9sxgxwguFJ3zPE8aTSbCO483r99iGByGwFi8xhDPqcjKAEnWAI0Kk2NGdgC5gDEMyJzw+u0rAMCyzFiWBdNBADMhjAjDgDAMWOJBIsVyAjIweI9lmlXXA4AdggvynCODE8HRgBCCPAdQsbV4JzJqlU0JIJX3WfxBb/R56AaYudGNbnSjG92oITMUmPHElO0lBH7rPWqRL5pQ92a0aMPgG2158rbltoaOrXY1SJN6TEquyr0NhbJ5m67vuUBqwCmqHHKaEmAd7cTIqcL+sof1hgLXpIiuAXW8uJTNLEAeGT+P3khh9cRoOUurgUrSa60NJm0Iy6wRRyq2iSqYqOmD/FVVWAtEyrnmIR0GL177ycaRyjhdI4KuwT7188ggqEa12mZaza0TpWubj7nqred7fO86766g7s0gxatyayScSmaMsnuICPv9XoyXQzhqOxGJp0AHhkqa97WMDxEsnKbMmWqE0Zv0+dnzYswzgxFANMDBg7MD0R3u/2eA8gFLfIeP336N8H//JWgapE8w6BrBMSGRpGhqQS++mIokRZuYe9eqUtL51s6ItXGhqn1NxZCBck8Znw1jhrSzVy7U1FGlTnZgysXIdIpOq6vbGuvVx7+Pg/1fa2TYbhWfOH/czi3/8GsVNJdMJpfaVo1458EV19F1sBsb5zc/WvDH/9Med3evAbrTSCOSTnAYIlLe4+PHX+IXP0v4xb/746P7a/tbc9x6/M4ZzbZAJu09W4arq5Vzm2CU0igcg2bKyaP7rjFI4kJqraO+NcbZrbu2jRe1T71xl8jDuQGORhAG2ZtYc4RD1rKKHdCIHCDdq6is97K05wIqWKYFh8Mjvvn/gHd/+xrMr5AW17QJMGNva+DtDTrWZosF47r+9MQAfv5vHL7+twmvfnfCT/9XAbBU6KDu/WSQDXuSdX9r/1qAie3/FknF+3av8gqICAqc8SW6TGkbS5Qy75OE22bCYZqQIiMnAHBwFMBEuucDJcLNZk9ZIqjA9qsKzJ3nA8yDrgXGtpFexnFcpSN0zumAd+9XA9jOOZeIKVam817GuOEzU86ISZSDTvflzIwUJRd70H23lM2a4NB4jZ5f1WezW6VyrPu1cw673Q5ZFb8t/8Wc6/qi/UgN2LbnkVftaiI/Wr1tRJu+PuNh2mff8hw2zsarFABRx3Ns8UrWFgMDSYqtZkboWBARlmUpUXZCCCX9V04ZsyqQGRlLfMTHxwMAwt39A96+/QFev/5CNa0ZBnyWrJQChhZ+GQLyYqfvby8jAMCCzBEx7fH+u38AY493f/8W3/39l5C15ScNb1wYZMTZNzNcvsl3sviOsFWAgc3od5XfqddWTuTMGt+UV74flbq+rgficNPqo7WqACKp9ArrK67gIeo91KRpAprUmKhr6CVA6dl9qtmfTo1vsUU057dWrZ5Pa9d1Oy/P8/q2r1tTa2/54eu5svM19HtTzykW/vtsK8/xwud/X0/9SF9/37k6X9qek+/Zs64+Tdf09lTb1zObuuPX13+5tk/n0k+VVtbBrvb1O7Bu2+dpzfNknnWbbnSjG/220rW79nP0Dsfli/OXIwFQbMfSvo62eZtzFAAekWLGEiek6OEwYhxGeB+Ub64cgSOHcXiD4F6DcA9kSeFEqsMTecxhCCOcc4jKxztHmrY3IWeDa3ABra/lPpNBqt45eMISJYX8siyYpglxiYgpFmDEskSVfwQw4YIHHCFoSteYVDfNBO8CduMOYQgAGC4T/M7hzcMD7u52CM7hsByQ5j2W5YDpcMA8LZjnBAYksgwz/HCP+/s3uLt7BR92jW51HUnzJdTaMPqZY2PT6rPbe/pUuTmzOvMqZ0fimJhVvp3mPYiAYRjUvtOkCAbh7u5O02AHLHFWXYnV7SER5l0pL04R8zIDYLx+/YD37z9imWeJiOocxvEewxBUzzAgRjluUVXPjZ/Jq9JHFJlwt9sVedbkUZNzq2NNaze50eegG2DmRje60Y1udCOjhuHow7K3SvYVk9MAFNo/u7Y91jNJPcihRiBpFLJNGetq6z2mvqwGmzWjlLOE0Zdr7FzGWV7XmE7UNgJrxnU9dH1KpY0ijww8jbb1SFFk9dboKeWsAh0IeXMsW7DFkSd0riKWASdqmVlTKFl/cjHwWFtMWHCNR28NB6lGSxbDz7wsADRtl3Pl8xwfW0Ef7bhD254LkMuMhERUmOaerhFmTgFj+nvPlc8AKK8NVtT1oUI0AJlHzu4EswgE47jT90Q8yYFaTisc9aCzaiSj+mdRXVjmTjs/LQqQzee4iPFqnicMA+Ph3mEYAsKo7VwcFpfhxPzcPL5q2mGImTebkb54E68FQfUBL3eTtvGU9qBX9K/jzTwrZkmnYq9vtweB2IEpbawe5+hc7Z9X6VzpUhwHu2pNqyg9V94j9z3v+u1z3M2Ca0o/V/Lp594quRlAGHZ484M3IDeC2YvXCTFCAIgmeAZ29BZ3r+LG7FiXvNXfHjxzjlYlnogKIx/XjUuzmqxatKqD1mN/2ihxbJjl1f9aSmMUPNXOU+C1rW9bysXewGLfJH7MDikFgEUZZNHXAM1/TVTGdhWZRPcm4w+cIzgHOMfInBAGUajlvavzpzHAlvY2Btm+rQaQMcNqe+fW+0cA8iSgvjSxRGNrUjlW824TbQ5r/qoFTtg+EGNsQA1SpmyrNh602vvt/hZ8IQrHnQAbfETOhODnApbJOSlQJsOgkWj4kdrJuqIyW580Bz1ZP8XbsewnHQi4pEayIhUtyYDmPq/85arqZt9sy2StPBdr/TEAxdpRADEkTzAzIyuQxuoIIRTetY3kEmPEPM+lXGZeKfZaUHnhHSD8U8vDteD10ofmvjImHW1dswVw6QE3Pb9hskDL2/T1bNXdHVkBoqyeZVkKCKpNVcXMcJ7Ac40iKFGMIgBCGAKm+QnzdzNSigjjgLtxhxBGMAcwJPVWy1tnZqBJ/9q2DWCQy/AE3D+MOExPiAtjfvKVT1ldX9/KPv0ZwZaghlM5x/M23zaeImz1eB6v05cta5dvapHZVndMRl3DClyHdRvpSn++KlrrsgJXLdyYP6tenLqqbxGVtJ0O6zIysAFoOb13t/U5bjnrdlVn5Yi1NEaJRLbdxpdRmVNN285du65rG5xFG+d6LuFSHdfQ5RJfygO+9Ox1rTjmhp5Pp97ZT5kHQH12lY75ra1n3vPkl2s6LnuLzvHixyvH+opWnjx+x0+99dethi9ZpXq6tO7c6EY3+udBp9aBYxn29IrROnsJi/jyPebaaLV3u9e4v0s4TAsyERwFBC9/WKpGoK7DDrvxLYbwFpzvkJnAbhEZTWVKRwA71n4wljhhmiYsy6zRNCPMaVCcXav8V2UDqvpbAM6NmA9PiMuCaZoRYyyAfUupm9UBJARf5DFhUD0cBTgylzwPsENKGTnNiHGB84Q3b1/hbhxBOWH/+A7vfvk1vvn6v+JweMI07RFTRqZBZJXBY/Qjxt0DxrtX8GGQ3ubqENk6nL6E1rLUel+TCKpYyZqn9fommyWdXGQVgFwCNXr/GGcwewxDwG4XEMKIMYwFpDTNE3IW/XMIGu2FpUjWVMCexTHzbvcA5x2c8wJI8gSn6bHBDjEmLDNjHBxevbqXqD/pETnHIou2kW1NVl07TvOx/N9R7+hR9T03+hx0A8zc6EY3utGNbqTUsiEtUKIHy/SAgJZaQEwPuOmZPVOS91Fo1ijhtoFUuPrKRK5/A+I13vKezFkY684Ud7qMjfYyCrNfmTlq2tsybdzV05TfNMGaJKEaq8hSwTkKPtGLV2OuVbTgnd7Q0/al9qkcrUPatNuMGtZP825uDT1Eko6qHUNjTq3tzGI6BCRNk6TEstRAOEEmSdKqzW0/euNP2++zz+9UfZ+DWE2bK2T72rDZiMirT5s3lcHPJU+v92uAVm/Ma5+PHMtiDAUDzgyGljbM7lPgDtXPzOoRDgY5YEmEDI+UHLx3SNnB+4fGY1rIqXHYw2maphJU9GicSa9X+E5jQOaLj2FtMKie0O254xqP72tmeTEM2b1O25dXV9aytmv4VdPLVcCX7jtn5PlcSv/6ZmyXfu2Itp74ffv6dpEL8OMbpASZ85pmgslhSYCjgGEY8MVXC5Z/mfH48ZfYf/0W8bA7qndTef7CadAbkp6rPKsryJapp/Fe6yIabBsl+m/t7zVE7mgXtSgEF9t+bDix9eLYvHNqhjgQRolsYrxIzgBlSb3lHDgT1GGtpHW09dc5AnOST2RkjkgxieF9+oi43MFhrFGy+PzYrA1Y1ABmbLVvV8v6XE4ZaIEIIo8ClGFGAZwQAHarq22ftv3BAAfGU1XAjCneoHuGpm3SVJDOVQ8tKxeQZ0vKS4wjsNst4AxMGhEGEG9EqUXBMNQ+MdvD22ds6307MscKwZb6qCk9H1XKocqPtdcWMI3eV9MGym9u+MqafkbLdDJwZSpomJTy7EmVtnovmBGzKHaJ6jNpFYNtfwCs9ndmAXBZCqeW34kxrvrUj1l7vOep7XxPLU/fA9xbEFbP12+Vswaxo5Qh/PMxZ2D8i5W9ShkF8fDk5h3MXOGJ8zxhebdgmg5w3mO3GzHuRgzhDkN4wDjeYRhGjcpnc9vmXgUPO6fAKSKQkwhWw/AAIOHL33XANOHbn+0K11LafjQC9Wj9v0mLQlhFgxE6tRocl7q11z2HbD1yoJoai2RtJ0XEnOOS+/3jupYfl8kA0ESaacHTjLqfXKKtsaht3AKJ9jvN8zgYav7WR7s1/Uz7t8fs0lOto0SrI/U7Nr5vHTm9y54u4XPRtfPlMh1zDMdnn0en+J7PQZ/yzl5b5rm1iTeOPW+Uzvfgc/Rta33ZPnt9uz4nfb65e6Mb3ei3ja5ZiaoOqkaXEV2o8ELPXcku8Ug+AD/5swznCG++GgAO4oQnii4lahtXiIgQ/A6EgMxOo7ZSSRcPczSAciacMR32+PjxvaQ0Db7oME+B8w0ob0AM5zzCvEiEkpjEIZQcyIUqfzmUyJ4SRhIq1AoPb84KkqpH0uFO+wNM8zTCw+WMtCw4PH6HD999jXfffo2nx++QoqR4yuzgwg7kPPwwwg87hGEHFySCDVKGRUlt5aDSTyIYlP4ckKbIVP1u1wwXNQdOAWVWZbFG220B/GyyGRr5LCPnhHnOyBzg/VB0BjW7gDi9ts9PyhCHV+c8nA/y6eR65xghNLr7bPWLPSBngLHORjAMErG8jVq6Gk+YLudY9933HejtISeH/0bPpBtg5kY3utGNbnQjJXJ0BMBoQTObDCBXlu8aBrFVqvfpA8xg0EdIqSltqtqyKMBhZdZ6RGFavbKBtTe13F/7uNlWM1qhN/iYd6xTQMu6nBZ8QsVAa0eOzYbSXrvXmDzxfhe5hIC8NgKhyCtUDDJGBqDY8gK26DA9M1pGRQ0bBpppW2sAoWYIpR1agKRdQrlG+u7LOLTjaGmhtsiu2Zpv7VywPrV93Zp/l8Ay13gHnC7j+LoKjrlU9noOOhdg3gp2W50PKO+LeVsDKOkRinGruTfDoig4FWjUkJa07vIs1VhCDPIM+IjECTECyQUEjPCOcP/qDfYOAGpKI89AMIOpdps4Q2ZgoxRABdfI2ynAnjbXr1F5e7pIFqeUEtvK7rUCFqu3uZ43s4qds+g3vQL3fI3r9p+mtUL7+5Ll+pacqudTFcDXKJGvq7v9db2pgrsn1LeHmutSXiARB2RRzeyQsUPmAKKA4Ee8+nJB+Ffv8c3XH7A83m8CZvpWn03FdOH3qePn5kZ/jrrPepzK9QwNAX3G8/1Sm9ryNq8/FWnmQj3VrNk/va1RYN1vHLwLJe+5KHUsD5Mo9YjFuJ5SlGO90s5B86BHJI6YpgP2+ycsiy/RYXrg3LZKk8s5W+ta0MzWiKyNndzcmwE4e3uvAAAgAElEQVQsENVELbfOMNp86XqQqO0FhYcirVXXWQuHLAASwJEraXuACrRwDciBiDAEj7vdDpwz5mUqx51zmroSsp5zD9RoQaTA1qxwBWR7vN+3+94RWMStgdVbkf/acdFCdb+S/dH4yuKh17VD5sI6DVY/9qx1k+K0U85IyBjDgGEY6pg6j2WZV21uQT6Fp83H6R7tswc1bSkMW8Dz1r1t/1rwTp/usY8ocwrQtEV9vW172s/++ZZ7mCEYJ1G2pqRvo665h8OEmBYcpgPu7u8Q04L9YY9h2OPVfcYyHxDCgHHcYbfbIYRBADFgAPqgwCD2hXlhBK3jFXbjDrvfm+E445ufFSmijo990jFvUc+v1zFJb3Se7I5+BSzHN8CJdAbY11wl60yJvkLlfwdomoC6lh3zEXWfXfNYLRB5+/pz1Paz73cf/ebUve3KIvvy+oZj3u9lwOOtXcnWaGpa04N+LtV1+cp2DOrzOXffNf07vSJ/P9TP5+fT+bnwEjrmoT7/aHwf/H7/7LirZWutan+d5OU+T/OuKqeuQNsy1+Vnuu7z9fc9n66Rd250oxv986Rr9tKeJyzyH/Wr96eTG/5/9t50R5Ilu/P7HTNzj4jMrLprL2z2wiYpNsUByeFIpKAPI4yAgT7oBQQ9miBBzzAvIAgQBEmQAGGI4RCzsMluiuz9Vt2qysyIcDezow9m5m7u4bFkVd3b3WQcoCojPMxtc3Ozs/zPOfCN7xlMIwQv9D0IJsm1UYkk0ERhUw73tkCIKRJJ5hCJEXzfjdFjBJyzxODp9jseHx8AsDbrigcd8qhTLnx/16WoL0Xfb62jxw/gHOvc4MShqsk2IUWmFSKVLJi8FgBYrVoa1wLQZwCOMdA6izMQ+h0P+3tevfgpbz7/GdvH10kPECFExdgGt77DugbbtBjrBr15zGL0kghUy29KrQc+lPNqG8ESDXJadejUem9gUQ7LpoEsh9d2GRl+L1HiU8QeTwhK4yJN0wx2FGOE3V4T+MkWp6N0rxE76AxELORnohlElZxic58Fklohzd9+3xHV57GMMubcgeQQjAQpHffUFjX/V89frSe/0rvTFTBzpStd6UpXulImyYxQYWRgZMyWvFgHJuUIoKA2cBwaBqY0z8dZK9QHZTsmZ1Etxo/St5xeaQj/HykmLxCsbRLTWISDGXO2aLDLzCWZMR9/Tm3HGCbROy4xJmhUVGqDUmIUjcSqD9O5LUryOVNoxAyeszXDeQylfQmJGJDaeKGINAeRhoAc6rKE7x/7ASO4JsY6+gkUI9vJeRpAFIdjma+P+m9t4Cl9OM0wl/lamoeni65TQBiH6Q0o0XWm/S6frTWz0JQhCywmf4947ydlDuohpbwqQlGa6wJmqk26lRFRAUNW8IekaDUmK/0BLNa1rG9W7DYQYo94gwSbE3HkcZEM1SIpDVMcWhsNMTabheNwZXwSk7dvbmzIRqK6jKnuXyJBMAphsDPrtF4tatr0W5yZUU7XfcxAdopKa6OR9Vjdh3eWXh6r+VSrXxydUlC/jfJHJ+rzyzrQtJIN7rknCr7LAj4QfMfjdoc1lnbVEiMpcpLLEUgihCioOmJYs15/ymqzIqzT/hyjTyvDN6DmrOK87vk8nc+FQ7qs7qO/y6xcMumV6LTFaHtoEJ19P5EyqtDcePtuCr8lk8mUUoS3FBlGiSABIyl1S9QEgDHiMNYSNXB/f896tWG93mBMUthAioYWo4IYrFjaZoXGG/zKEdoU0rg2K6Wjq7x/Vd/yx9gbJM4izFTPvgZWTUdWjNggqgTdE3uHVNFeElmGFHuXzGTFayGZz8jnkfce70eQZQ2WGeZZ0/7tpOzNEUSxzrBaN3R9g0jMEVAKv5VKJp4mDKkZi0JzPPuEMVJO4R8LnzXlM8vfOVBm4Atmi3gO7qiva35+EmNub8pTFODPcF7Xbc0BVzNeZElZBxm8nFMzpTRDEIJnvV7jXFJBxZjmcUyBms+jzMukCCmHPGYNNpl73C2BbZbWxxycvgRon8xfLjeNYDSOeSlF1PC92tXnz6nIHH3fV3UaIFCDqxMvkD5pZlxubu4w1mQjADkqkufx8Z7gI+v1Dc/unrFZb3DNiigjz568HnNfjBADqFqce441oL7Huj1u01dbn2bDwdinU+fyND5XuXbZe1zvF5fccayMHLQ4PQHSnlUAzuOZUZctfRGd8W0yr3W6S17S79LSnFsfeYG8t5ytrcw4jKmfntCRhfYvOcHns3k5h7BMZ6TIC8tdTofn0mk6N8Jj95S26u+naMZtLLZ5aT+OvxvTX4/z3+eunh7RU+f4UprP0fL18cq5+XrK8zk9p9M6z81/9eZO7pnuJsdWwPLu9jbr9MukpXm60pWu9OtLl+hCamefwtU8XVOwTMYpxipuZQlxTehD0v+JYhxZ05X4Xu899PHgZFWN+HCfZCVI6Bs8fe959eoVu90O1Yg1hvV6jXU2pwEuTgdmiOJpcqTrEk2myDjWupSCPs9B0teMoJgSoQaKLDBNdV/kFiXV79qkm1mvVzjreLh/4OWLF9xu1lgL1kaMCYS+59Wrl7x++XP2uzeE0ONDYN8rIRrWmzWrm2cpMrG1CELUQMwRUAzF0XGUDwdHh/JUJzruJIPX8mT6nGDrRUU92DCoZbll/fRJGpbQCFwZ5dcU5SXVbbC2pWkaVu2GzeYGzTqUEDzb3SPOuZkdJmb9clqxURXNqZvSuEbdfcoe0FKcHQa9g0n6AZEkH2+320HOPXBsGuR+M6yjuQ6gzGcdAX90wLgCZt4XXQEzV7rSla50pStlKor7Y4CBOfhFmRoLztESWGZubJjXN/HGHVj7UiYpUgvIXCkesz5fl0E5jo53FyDB8b7nes2ykaoYmKaGnPPzMKDhmTLaS/04Zfwpf+uw+6VcESSWmM9zlOo+7E9tVCl1FYEmGUmyukvH6DH1s14ax2L7ZQ6PzMc8j+kcVFVfPz/e4+XOAp+yYFNVNdw3B+mMxr3xfTlmbJt6WRusTYJUGVcNAloyiJmyXifv6dhOKSpDf9M4UshMTakJTMSGbBjD5HfJ4taWj/7lG15+/kP6f/8R7offTm2qYIQMhslRbmS6LnMrRErsJyVKXDQ26YWRMIoJ5ymK3drzd2z7sL3iw3uZSnzZw3ypD6NS+HivR9PUZYaRXwUl6/s0BJRnconhollZ/uhffMrq1hJjR4x7+n3g3/2vHf0uAaR6v+flyxeoCh88/4j1+hbnGpwzdJ3HGpfWRRSsadncfMhv/xkQOx63n/GLX/wNff/I9gd/hH/zKVBSd43r6DIz3pTOm+BOjXwsNzdM1n9rg0NSz6RoM3PQTN3aHORTv2EJZHb5OEpN9Sl67I2tDSc1TfuoWamTrdWS4HdRszLLWFSh2+95fHxgv9/Rtk3yagppxOP5aLBZ8WVtg3Nrbr+9Y/31BxqrNG3AmoiIEnxkt/OEXjHWgRgQRZq0p372519n//Obk+/3qTUgpD3ZSA3qK5t0mb1lXuQYTc6Y8lenUUOMsVhjj58pku/O54Qx4JxJyq4YCNEnzz8K8EAxRrMnXtL2FaCMFO/AhbEk/kGX+3CGTgGFDwAmuZWk+BPQiKnM9PX5G3WMCpP4xxpQWZvk0h+tr0gC8TWNw5oR8FoDY+s+llDihcIsv3sBo9R9LLx6uVbGWJct10rbS158c6+9Uq6kg5rzEbXC8jyfNM59ieZeg2rqMoXGeVn+vaQCE2MQU0UGMoIzObR46Nk/PrDd7tje37N7uGfVrnFNy83NHavVmsY1uKbN0aoiisFgEg8TgCgIDR98zfDH/02LsMdIT4h7Xv4k8lf/z2Y+2uU5WPj1GPRjaX84vV9O25n3wCyUjJLeZ4Eqe9phfyawGJ3v4WNdsfo+jWoxJt6sahrLyTSNjAABJsDo6Zhm8syRz2P7ZYCHNI+hc6pUOQ/LaX/I2S60y5TXvORZT0ue5oGX1tQ5uoRHWS53CSe23JelJ1bP5rH7LqVL7r2EP7mk7OW9OcXbv492lutcuvqucytHvj3t3svuTG9kzbFO65m/H8fa/XWhY3vCr9MYrnSlK70djXqOQ5jgpWf1En30nQe+9nuBzfrjBFbwZkhbrHHUWqTEQhEJPsv1dS8iu/1r1EWsONBI3+/Zbnd0uy0xJHB/DOB9z2q9RoNixWbdo5mcqgkMk+RGsTXgZCrXGGuJIfHiQ5SUorfXck8+FbLCP8mX6f62XdGuGvp9x+PjPd1+x/O7BJgRAzF49t0jr1+/5OHxnuj3qAb6EBHT0DQrXLtO0b4xue2UGjbGpL1M+u25jDrT6Q6/Zx1rnt+pjJrHk+VK1SIH1xzmcafPZdmrQOPNbI3MdDhK4unFIKTo4yXqi3OO9XrNvlvR990QkRZGR5DkcOSJua4UqbWoCUq0mTKWMglj5KGIDPLd1LnDTOS+uVPpXIZ1zlU2iGodzZyvr/TudAXMXOlKV7rSla6UqaR4qZHFSwCEOTghHmHhlxT0cyDI3EBS0MFzEMTAMOsBHp5iSFNKqoExugwKIRQP7ZrGPtTfZz9XgIfSV6VpmuwRHDNYxxxhYI/NR2XEyQx1zd/VwJUyrrmBQsmRPGaevodIdobfdClqQPW7MaNhJF1LEzGCVWQw1sSYUimUKDzlt5H5nhv4xu/HeVmBvJrmfV/q7ziu6fiPzcGxcS/R0edZntmCaXfsy9RTOwkQWZip1zJFgMlxVyRiZGq0C8FntL6dCAij0bNaezI+h3EeZDB4kNMg1SE6U0+Sf7EqRB8JNkL2ErFGaGyLc3eY1SMbcwO3zWAoKZFcjCTDqSWtM5XpHCXxSYd/If879G9hcs84U/UKqlXCl4NmlKkho5h15qbQ6afpL5cYqpZovmedNkMc7nC/jrSkAD5lNFgyrh2j8gqtbluMS5FGXCPEPnujkJ61FWHdCuv1HavmBicrNELXPdLYlGJGY1IyiDRYd4NrImIsurrhjjtefPYGNRVYjwyaSQvqoK9L0VmOmxzOm6gujrizcP98PScgwyFoZn5/ebfnZq58Mi20d3x0pZ7yTGpaWg9H3w0BYyvTiZTexCEVoe8Du10K97zetDRNipqGCtYZYlS6PgFunEtghPV6Q+NafHNHjAZnLKoPCB5rBGscdx84+j7tiyqgJmKaSO93GNecHFPZc3R2bTJHef0SbQI1KQwxF7RKPC9zpdoyTYCUGEKOZleUS03TDPneYQR0DIAiIEX4yFFPVEEiYsA1FtcbQkiKs+QdF1E8Kh6IiElzXhicZGou4xCGpPSQys520lPn9siTzb7PPi/ORx6jGEPxbkzncqlyCsA11mb9bNpUjMhwb7knxjjcFwE0J3EKHpFxbSzlYa95YlM2rqAzsEpROI4hymuQzYTPAJaA1JfwOUMfqjrrcnOvvrlMsDS2eu7rLpzi6ZZpyqePumVDjIIGxfc93XZPIx273SMaI6ZZ0e0i++09IpY3n7+kades2zXtaoVzjs3dHW7VUjTrzq2IIbdhLM2NYo1D6XDS0L5J3MvBXLJ85s3LXELT/be6XkV4mf467srD3q5jajipSsVhrdet1dzHuMdOAJPz0qrEE2mmhndrdu3YGZL2wdlYFtqe/j2xTxz9ZbzvJHjpyDl+7MpwPhagTAHbyHSm69/q61Ow5CURBXX2fUr1CXOM/6jvrVfB9KnPV1rZOZd7V4/2GC9Sr7G34W8vuWe6Vs7IgU9qZ/oEDjma022d6/sl3N4xCeF9ygrTkTxtpOdn4ZDSWhh3qiVZqy75bq396tCxffxKV7rSP2yqgcVQTsZTe9np3aFZNWyeOYw4+m1Kp5R8GFMa9KBJhDSiWMl8/kyHEWLg9cPPuJEHbjeGxn6Axg7fb1H1ybEDJYRIiIrvPfv9nr7rsa5BSMAZBqB9jiAjkmXZMkqTdecxRSEJHiMFwM9wb9EeJKe+1HdEsdZhncFYwViDayyP23t857FOePb8JsmkMekeu27Lyxc/49XnL1HtAZ8dPwyr9YZmfYdtN6ikdENJ7k1AGUvR9cPc+bbQCBop8lMpf+jcSpEXNQ6fNX8udZZUxcMdF9gYRkBPdSZWoO9xrSmoIQZhu+148eIlTWPz80/6kfv7+wGAYq3L+v7RoSLEOAJmjGCtDOAZEZPmNkRiUMBg1FRyY0713DSEEPL1w3GWst4nB5GJU0scdRq1TFr6V5xNr/TudAXMXOlKV7rSla6UydhkSIiZkROSwUOkMLupXFGGx6IQN6cV8vPIIMkgk03V+bPGkIwZQEpkmv0AdVR4ZbaZqiMMJjytYk6opWYYR4T62Ifye/F6rhHP+dMAHhESKKgOUT9hiA8MWMuGhQScYLAciFgSUGJaJjGAY2QRKR7tQ+2lzzWzvqDcnQNGskI21iKZjHNZujYorYMSNeS5qIwhcVTU1szvhKqvpd4hPtDBs5jeWIM9pNSlFSOdLwrlGZjJ85vM9xHh85QRqfw+NwKJFEFpatwbR1nanKkzNYerLIrwhbUGOni1D/EgdGrEDCEseqcP6Z8W26ugLSVnUj0nkkQoEZAY0WBQn4RaYwVJrg9J0I1r1u5jeuvYig7vZklnpOPKxOaXwxSgUP4togSJA2CmNqAcpGKqP8/Sv8xV1lPF/PjNqBBlDPef9gKp6jg0zhxT4s+V/+fKL9G4Cqb1nTeO/PLobdXRp/p+yoBzrq362QtvsDbg/Rt2uzd0O0/Uj4Ak/PtHx+d/85y23fC17zS45wmQgEY0Kj70+Ywz2AZUPUiKLLJq13xw9ymvPnuVz5QppbMGatDMYiqjo/TlKPnHc6NqsQLNDOV0vsIP70/fT6/4uaGq7DjF2DvvT13TLFnPhPavIz/5iz0gfOW7DavnJB5Ey2mQ0hQ2rsGaDauVw7oelS1Re3wXefNXt/S7yPqrhtuvF/CGIk5wYtBoMdh03mkCiIh1WNOikhU71iBWiNrz5s2eEKqzLY93/RuPrD9IUUaMESKeVz9o6F6bxTRW6cjNG+ok/ZKgs3Pq8O7ybdxZamN7UoiaEpAHiZpSOooMZymmcFZapgTFj+o1iUSN+BxVRkyOFpY25+xtlhSiyesvgzDHp8/As2gek046T/J6qy5Ui0OhKp/P4VjvBGX+Bq1bwofm804HRjJ9N2Iz7zmdQ1NFhElnqhl4ARQkA4xq7HOMRXmaAC8aAZPO85KWUiSn8cxhvkeFcIrO45wbwa/5esoZP7YfcjS/wtdYY4mZLyg8esihw4d5qXjQJSDxKRB7+V6iTork93cGlBl5n3om53xQ8ixMylUDktdbxU8aU9c7PwvqUzrPzQB6SvtAqasLASV5rIpYYszPSAJ9t2W72/Ng73GuoW1anseedrNGnKVpV5hVMjSk9SyAIWqb3iFp2TwPfPsP+yxzeFQ9uzeRz/52jOly7tw+dc5J9f/k+gJY5mhb1V475zNqB4fqSZ/p8dhWxf3DwMHVvarbq0c657W0qnd+yhyOSw7+vvv5uQT9EARZABsd0vTOY898CtI+5BGGXXtyJo8887TF098XWp+UPcVzTp/UqTuP0dON/ZeVfzoXfOzEPF/28r5Md6R5mbdfm+fu1iPfvghZ4d1G8n6p3utq2Wu8colE9atFh+vmSle60j8UuvTUnINmjmtHDsk2ytd/p8c6y+1XHKih94rXQNQUcV0MOGtxUTC0GHE4B8b6g5aiN7z860+4X7V85Zvw0W9sMQ5ublfsu22WB2ySRWJKUYoKxjQYcSR3oixN5k1bBllTBzkhDnr0FAUnakqvPJk7GWUnlRTlVImoKK5tiW9WbF85xMHdN7Yp8okPmKg0RlDfEzTiY8/28TVvPn/BfveY5LQsF5tmg2vXNE2bZLhi+4iKaEQ0gXuKnqHoe+YOsBQR88yzqx0uR5lJKj12rf9ejrpfR1SB0UnCjgr8qtmprCDjJUKMdF2PEVBtCdETY0qfFBU0pjRM6XlFNIbBMSRqJCrEmJwlxdiRJ1eIISCanC5TH7ukr65sSrUTxsGMTZw0Rj12mZ+J3E22ScXa5vKrwrn8+tMVMHOlK13pSle6UibrHMbZDNgAJIMrMiM4MDhCVt4nJs0ZdxT9PPc0Hb2Xc4oYjQyNIVhjht9VScr0zFwdGOoGA1NWog8M7Wk1xAikKP2a/p5Q71PDApXXbI2ILqAGGbjQJc/aEXyhuY+DweLARKhJOKgMHcaMxtplz91LGcMc0SPx/CM7WWxXMSQDTdWPGEIG9pgJc5+nhPQcZTIPUowhk5anRpx6XuZjGUN6yuT+Gi8zyfybhYTD53hufs4oUufraOjAXG03+32BVOKkuWJcS3LksOJRiQNgCR29yutIQtZa+r5fAGPppG+SQS2aQVkcBQkpoopRARzat0hORyLSo3GP73usMVhzhxjwxOwBQQa/xCpiTBIwjZKjzpgBHBNzAoSA5pD+SfiapkpaNpWMxpfxUzKTlzVdrQnKvGoO858AQ8lmPMKehqd4JHx/3f7829uqNy8xpp2io0ayL5C+CMX5vM7aIHesrYmiXD277Q/ZWKXrX7PdvWD74In6T4mSgAm7e8fu398BcPv8gdVmh7ErGuvY+/uUs1k9IhGjEOIefMAJNFZonUmpyRihZ9N+SKUoOf1cpuM6ZYZbesZLNc/rKO/JZaaDSdqIk970x9o+vF6pNCY9NBOwzPF7j5EC29eR7b/eo8CzjyOrZwIEjIlYl9LgCA12tULUpfddPiPwmi685vG+48Vffoe4cxgr3H0jpZELMaUSEik5tn32ysuKIhRVT5SAGEPjUmqdvof9riOG5qD3N98KfPgtYb2xWKtEArsXjv7VkRWgAsEQiSSwlxkKpUdTQLnK9JjJMzpR1smwnYmWc1ay0i+DabQ+M8b6tXo+oh6NgahK3/U8Pm7pu57ee/a7Pb1PfJCpw1RTeJUcmYZRKaiZVyg8W/GlnAKa58q+8XO5v/BPdRQWMoDb5EYTa5LTampdb5nQ2WrL82Qk919knAuVsS86TQMpImjMfEsGvMSS6klIEeJ0jEAjOobLLqCPvveZxxJSfneTFLWDEjXNUgx+iKRUxh1DJPiAsQZr5SDdUYlGU77PIxLOo8bU3xNgSCZjtdYM6ZUOwcFa/Rv5JyVPYeZBjLFZkZ7Wn0qSMWJVC/na8t6jGFIqSLI8IfkFUAwhNkmWyQxWAs/IIM+EEAh9Wse996gFt3vAtpbNzR3WNFjTMLyHmqLYiFg0WNa3ju/8UYNqIJKAMy/+PvLZ35b+LcVlOdzX65HJ5O8MADxLkzediUMagYlJkT0tfxzUUPdhqY/Te5fqmcYNqc+hObhlKsstQ1+mJQ7rOscj1PWcKleMVfX4q7iZVT+Wo+MctDcDyJRrx0hn5c6BZo61O9RR/T/9NL/vcKbq+a7nZCla0LG25zvCnCtZlp4u7ePYzrFf5zzlKXoaT3tCvjuoa8KpPpku4+/PzdL7oaVnePjb+25xmY6vr8P7vog5eVfZb06p/1+2NHelK13pV4umO8FT9gTr4Jt/4LGN0vuGvhP64AkaCTFp3iyCE0tjHc6sMMZhrEejZxolV4nBcv+3KeV629xz8+kDzt6BCjH2eO9zuvjiLGBxboVzhXNS1CRt4IhbGISG+s+gD0csJfotZFeLfK9k54OU8jfJI64RmlZ4eNPw5q/XmDbQPvsMsT6ldcr5gmLo8f2ertuy3d7T7bZo8KSsqw7brmnXz3BuneXjkGQKiWjIoBQRjLjBdlG4wCR2jvr4QoMj1ZSxy+OtIraWslS663zADTrhSh5b+rywGvL95WlO5TqqvlP0GtESokuOZBh8iHS9xxhHVF+JwCUKTpLlNKGXUCTpcDHZGU0HucwMUVEj3geKI1uK4DPVa6fr03HXn611Q4SZpSg0aTzXtExfBF0BM1e60pWudKUrZSpKeGvtNNULHDBohSE5Famj3FNHyBjCzkPyEJYRJZ2AEpX6o4T6VybtDCUKDz4OIP0xWc05MF+nQvMdGk+S52i5d2xhHgpwbLbMWWF+ZfLb0ueailfwEIpxlrd0THE0pRP4jLNUQDMDA50sRsnwwGhAYWKYOsynOn/+AzMvAgvlyz1L3yVz5gOeKTP7B8JHEUiq5z9XpDH+fGKe3kbdd9CZsb0ZI7/cm+qrTJXbg4d1FjBLBJkyx8X4paqD1zeM71mMATEyMZBdEsZTNQARwYEKoY8gPWn+DSH07Pd72qahXTnEJIBMiWkTUDwxXcvKfquCIYENLAJEPFU6JimgmdEkUIwRS4ak8m0Q+2QUrvPqXVRRm+q3EnSntBZPgnTKmpr3oBhYlnyin0bvoiZdWu9fNC3N71PmYKnM/A281AimpNDBP/nx39BufPKUMh2xt+P7MDNavX71M2Tds17d0K5XhBjoQ0/X7+j8nr7v8aFDY0CAddtws1oTQ4dmoFet15iaN5dn4N3XxmUGzmPmmqVa6me2FO3kWF9Oj2V8knV0k9p4e6y/c+PceG157CrK9vEN7X3EOMWtwUiT0gPFCAGUkMEMW3x3z+P9Kx5f7ZH4bYwKViLWeYQG/MzAXTEYg1pLBOtKvm8FIsZYPvjgI7a3gj6kdHQmj3Wz+YC2TQqlECLGrnAtuPU4k1ItG9sahAaNhacqe48AgZJ+KpU/fWZleOBQtwJqBDVkAIkQiRgNab4ACTpECkxsQURjR/A9u92e16/f8OLFS/q+H6KcONew2WxQNdUhK7O/RTk36+PsfD+2tuYRUJJONY1vrhQrirL6vrG9BGhJkXHMoKyryVo7AcOU6G01n6sZ6FPXX1IlFh43pQISjLUE3+ODH+o3szNbJIWlHteV4FwzRI0pwJUYx7RjpZ0JYIgxnWmhUqYuPwdcz3n4+fcQAqvVKj/3SAwRMTLUV+Z8yVNwmE9K9qQSDSalnjQ2KU9tBjt570fPSTkEe9SU0sf6A0WyQAJwqZ0cx6cAACAASURBVBAzuAod16CI4JppCrWHh3vYgW0sXd+zaje0zRprGoxxmScuEApQlZzGzyavSrE4t6NddyhK6Mi/M94DlFgmx06Lsk+eo1NlpCpjkEOghujQjymfNd+7R66sfkuiKDW/Nqfyiy5crftYWjt+ptQlZgCiyXCqnbuAP4/WudTC4ffy11SzUZ7Z0lm4BI55WqS5U/0rJyHVt7EHromYwXgVEJQYmmH9He/FMuCp2rURAddW7w5QgJw6WSWRfl9HZJ3Nz8lPS+Uu/+0pfPC7PBHXKjZtK1k+NbOzeNqLGJXQDZLHO7R8jI6/g9MSy3SMbz/FA8rs0yma8FMXlD+2Mt5WrnifdGyvfl9tf9ly3JWudKVfLSr84ZwnOnW+GZvkX9tC9I7OR/reEzVFc4zEFA01M1whRqxJcpuIJWoCjaumM904xbhpe9vtnlcvtnz88S2fffYZ3occcSRFiww+UNS9JWUPxqboJGVkk3OykjMGJ0zJfLsQowdSpBkxqe8qStu2xBgGG8KqWWU9XATrERsIfUfot0lGyXzJ4+MbHh/v2e+2+L4DTWezisU2K1abO25u77Bi0BK9M8vFGpOcKRmoASRbggJyGIF8yV4y2g8O5aME7pjKgygHMtrBczcGa+008udEP1ytH5m2Oe9fAbN0fYdzhpubDSH2dF1P1+1xrgBwTIoglJ+9RBCjBRszUJJhk4zR5JTBSU6LydnC2hTh1pR0XAvR6Yd+LcuptXNHXaboA0ofvxi+6x8nXQEzV7rSla50pStl8t4PeSKtHaOazBXthZbQvqdoYGhEKrFAhpDsUcOgMJ8DTQZmSQ4TIA2/k9jSGLNRY4iAM4Y6rHpT1zB8qpHYc5VUbYyoxz033MwBJHUqpzkjvMQYT4wzJ5jn95qjswg7szqTYSkweBebkcldQoNf1tR0HAnclOc0lnHJ5WtLs1r/QPt3Tq21LI6+LTL9FHjsVJUJFKao1gJB9tWojEHFaKaqw/vZ9/1QT0r3UNerBwLJYS5dQIqgOEJPYlCCD4hEBE9HhxGhacu+IBTgCNWVElXGYZIX+NJcLM0Bhyr8YkAylYd1aVNhAM0MKaFEMEX4Z9mwVNqZR7Q5ZfwZ/8+GBOp7/3HTpeaAd52npTc59I4f/9s/SNg8CgBBCH2z8ESFn/yHr/Hz7ycQ2ACk0jHykaoO6SpSfXmNx+8QfXOwWxz6pU/VXeXXufHoUsPDcajM02k8HWXWh2P9u6zW8e6s9MpG2qKumBshhcM5KS0vGdnm5cp7+3f/uuHv/w3cfPrA1/7pjzFmxXYbcPKMTfsxjVtzc3vD5/e/4OW/czz+9e8nhViXjOWqO4gB555hG0vwMSv5TKXIy/3ShO1t2zaBFpRskBRu1s/49n8eSWm/0zVjHMZBSeuSwhrDb/xZxPcdIfSIKI3T5NAWBbGCaoM1LXGye+U9eeKRtrSrKmN6xXGyh31SUp53lUjvO1xrUg7yGIgxYA1437Hf79nvdvR9h0gk9D3b7ZbdvkMAK4amKWkBBd91oPmtUZP7PtKcF1pSMF66yo+frXLwfQ7gqIEqIQNYStk5XzcHjJSw1DUvVPjNXOmQEtFZi2kczlluVmv2e0F8aiMpfSO+T4ptKLxh6W8+e+OhIrUAa8q8zSPFxBgIuW/1/A7gwZDBNWaqiCzg+DKmMhdFMW1tijjZdR0AbQU2KWCZOi0kJD4RRt7EWpsUzCFmPs9grUkegxXYJ3l01uv8PM3B5TC+BmWMNQ2Rc+p1Sep733f0XceqWbFebWiaNW27om1XWOOGNS/5wFFMMpxj+Ohryj/7b/dovOc//F8bPv9JU9Vf9Ydxj52CQPKIdTpylRKBpwILM0ulNx//wrWybxqKN+j0nBpjw+jY7vDbIS3t1TVNpasE3jEVeHK8rwLvLEb5O/LOLwBSyrU5gOUcHStd5uUpxvGnAmXO9VWq/8tcpTWU/v/uH77k028onff87Oc/Au35xfe/x+7VR0f57Prv0u/l6bgV/MF/tcWtIkYs1rYYsyLGNSoptL7Kjr57zV/+Lw3dtpJhF0/4422eo6cAY47d/y70+3/yyFe+6TBuTe8NKh8SgiNFAEvRWMWmSJo+Bl78eMdf/5/379jqEunCp1Olnvb70/i/5bJz6f4cLY3o9Fr5cqWuUyM49Y4tlX3b53KlK13pHzYt6Zum5z+Tb598+zVf++03iF3xsGsJwaC06TzSgGnWxJBiOjtnaGwDOaB713X4sMdZM0iUX/1dz1f/UzBmTQyKiOenf/UBn/3HO27/xIN12CZnaI8QfAbk5EiMSk6RHAJqhBTt5FAPk8C9KdbzALJBEpA+p/t1zuKcGyJsr9drrDXs93tev37F5y9eYYzBNxH7nciqsbhWkCh4PL3f0e0fefPwMslw2ekkRpOi4axuaDY3uPUmtV2iyRiLLVFGR3EkR31PutoSzbJOhzSXNyd2hEG2q571oJtddio9RbVsV8t7yYHhsOxk9mfyeLoGxpSoPYb40NN1O6wVNps15BWiKinSJimlboolFDOIuMQgTFFoNEa6EIf6C3CnjLlETq112XMb05Lzy7EoO6Wu2rGk/L3Su9MVMHOlK13pSle60owGT9kZencJNHNJFIvFfJvFQJ+Zp0FRnoEZBcFdwANiGDkvdGoU0uS1Omp7svo3G1LJhtQnzUE1vtKvufK9VtZPEdvjfMyZ6VpZX8q6jMSeA3Bq7+JCbwvmOBWKHWqD8+z60FczYc6rikdlew1sOqzqZOPjuCql2RH0+aV07v63q/9Y+XP1HP99aW2pKqF6b2rjVQ3AKgLlcP+CQFS3sfSupt9S6gHBYs0qGY5Nh7UpVVvTNKNhLZmKKmG+TpCVDCKWlIrpmJJQNEUzGgLFlD4fmaMpAGastYBmBqOPRErKDUMdRn6A2Qygu9pgc6r9qZHhUKn7ZSg531Xh/z5prlR/F0PIUn1MvteGzamhUFXwXZtLnTOxKr43hD4b7XRar2YlybH4Rukcqfe9svrnvR/XW20cXZ6L+tcDE+fJ0SzR+R1o3pOnmALPty2zz/NncukavuS98vtU2/1P1/j/++sYLD4oBoczgpNA47Z4/yH+tSVsm0n79z9w7F9a7DrwG/+Z4FpLQIiB+SrLEVUi1kIIY2oaUIxxNJuArhKwRrApskbMe6oIGgNgkCaFORYMzhpi2ONWNischaiGqHlnrbow3SOPmWiOn7i7fs++27Pf7+i6PQnP4IhR6fY7uv2O/f6Rbrcl9H0el6HvO2LI0cyi0jYtPsSkEB0Yq6oXpf8zXmGu1BvLjzvqOTDM/Iyce5rV9c3vG3jUAngwIz9b3zdPXQRj9BhKHbkek3nRGGOKjBICzjlc0+SzMnlIauZVC0/tfUjwATkMR136m3jEwzmw1h5Edin8QAG/LPE0ktG31tqhTLlvVLSOY5/Pd9/3E5607/0k7HXN19b1DL9pZIjQkvnFruuQDKip+1HaNsagcnxPl9n6G8Y8k0eOKYwnsk3mf6ImJev9/RseHx5BBGsdN+sbPv74E5zLPJAxKeUW5BfTYMyK9e0dqoZv/pMHvv47L3l8JfzwLz4d+7I0DsbzaHraaFX/SAPAogIRT40rpc4RuDjfTw+jyOTdYwFEXNd97rSY96OcOHWUFjv0beQcS5TB0Sv5aTTnRc6BVmqQypz3O6iL+fwd7+G7gGWWOIBJ3cP/yu2HO77xe5/jmjs++Mot7cZhfORT16DqWa0ifv+CxioWw1//+Qf4zrA86kP66m/BV79rMHbFzUcbnCvAMIdqC9GiBIzxGKuY/R6ROaD4/Fwc9uJ0v47zUefueneS9QbZOKK0qDXYdUP0ACmdrY2KdWBFcGJYvbHV3eee7qV02RN8V27u0t6eL3Me9rg0olMy2JxD/2XTkhx0/j2elr/Sla70D5PedufXE99A+Opvv+STb+5w6wbvIXhDjA4kgVcEM0SDbFyDcwUUrwNoPkZFnENIEXWb1YqbO4fGlhjANcLH33qg/eCeEOD5s4948eIlMXpKSvnE0xdusopQelSrk/SHSd+oCaCSARM+A+qtM/QvNjz8YoNtlWe/88jr7hW+77MDg3Kz3uBsg64C/X7Hfrvl9atHQtyy7x7Y7+/p+kdi6IhRiUEQWtr2hs3mjmZ1gzQtmiOylOj2qhA05JTFMAf8qGaQz4QbzhzzxNm0XFt4thfIJ/MIKvMyzrlB/ivl5lkBTtVf/26sYbNZs16vWK1a7u5u6bpn9L7HuqSvQA0pkqxBjMWISaB6lZwuK8vEKDFEfIy4pknltLL/DE4Ho5xdO2cv9XPJmbge2xxQM87hQbVXeku6AmaudKUrXelKV8p0jBkBJkb6OR0DzNTMX102sdIyoKsTGKOguJMm1YiMyGXNzKhACZRd9NUF2DNEPUnWl2k/yn9a9/V4KMBCi9E4TpS7JG/m3CN2CcRQI8iHcZ2o9xQQoq4zX1ysIymaD+8XFCt2kdE+2dYZA9h7p7eQTI/15SyQRmWhrcsbn3o3A1V7k/VRAZBq0EwxmtUGpnoNzIWuMqbj72kpm40Z+XsBrQnQNA3WZuFHGdIlJHNRAqCUK7WxvI4ldcwAUz87qb4Wo48Z6isGoCyozRasLvybXJe50eNysMyxa1+G0vMfo9y3rG4R5ury0ahVTpXxOrM6lhQ55WwY150clFnqk05QDDUwq675EDSzcDIxvjnTvj+FnrD7DC3Us6AH15bVXaeMpZcaCi7p4bzu+re6H3Hv2P7k2fBrMsSmPcPiMWwG42xN3WvL/jXYG4h/pNhGKoOnGY6vdBaUqB6jAuxAMWMKzCai4sFIVl5KDl0cGCOnOUBQbYlqs/IQtIoiMY4815sneLrlHdmJJPFLMQR88Gz3W3b7HX3XpegqjWW7vScGz36/zaCZLdGn0MmGZB/t+zCs8ZJKM80F1aKu3jlNvw2pBeveHTl7TvEKaW6XeZ+lM3pM7SkHf0OMyTUyK2hrZWMps6RwLJFkyvUEUB1TP0WEPkassTjrsMYgqmhQurCn6xIAyWJzDvexvXI+j2G0854h00g2S3N4MCeDwnI6P3NQ95yPr/txDLwzSf2UgTm1nFA/i7r+ef9N7mf5PXl+MqYFK+CVus95VmpeZikK5RTEfXwHXeZjC48liBq6/T5Fo0KxxhK6jqax3GxuWK3XONOgWu+iFsUiugEMH3waEPOGVz8ZPRyXelT2qToi1/xMKGdWzc9M+n9QZ3WPlKy3QpWDdXLvyBsNcGLmYJnDFg7Hcexcrj+XdDaFtyu1GZTIOAfHTOLvg9c6BpZZvjY/1Y7MyFukX1rqx2UijNCs4eNvKO16jTG3KC3WCje3nwCB1XqHak9jPHjPD/6i7vl5wMHth46vfbslhIYQHSI5QpTa9E8CQgD2xHBPt3+N6g3k5Ktv95zeHye9NI9vIR5OKJoVvTQojmgsiqMnYkaGAKMAyQPdHIznXXtwet1e8tv7oUvH8JSxXvpOfhnS1uX0FP742P2/WiO60pWu9MumY/qlkZ9SNh8GmhtD8A7vBdQiOMBmHtoi1mKcxTmLtWAojg6Btm1wzYYYHrNeTVPydGmBVU5rCjfPPXbdJ7nQpChz3hdhlJS2KPN1A2chgjWWqCUSZuLXrS36ccGJ4JokL4EQYsBYR7tyWGt487MV+88a7Cry7Lskx73WISSgSJvBGL7v2IYdu7Dj/uEFUfeEsGffP9J1j6CBxJc0ONeyWt/RrG5x7Ro1llDLPQNAf7xmzFRuglHWSBHBy9XKBe/AgUMX7h3lr2nZqYyyJOOIyBA9ZepQK1g78hmLsuwRm4cxhhACDw/39L5nvVmzZo0q+D4Q/Oi8DOm5D1Ers7w2iv0WG2MCKmlOsZWfs0ZN2OtaUllweJn3b8mRo5Y55/N5iS3mSpfTFTBzpStd6UpXulKmJSV6uX5pNI5TwI1RKZ/AMjYbLWrVQ1RFQkRNDs8ooBqIEQSXATeaDQQGDXE0DmTrZ62MHTvGofI/FxrKLwAN6uvHxjv3oi5/lww3SzSPOrNk1Dh2/7ztowammOYsMbnL/ah/qedgzAm6bKhaNFxU9uRz47+UToJ2JFkw3ldbx2iQrajXdfmR8cexY+NvC13SWK3fBTDVkoAwN+wN62cQ+KZ1pD6eei+H3qAa8SEgJiAmxV5V1WxkzDmGoyThOt1BCblfDDWHJobR7DOCVuoZKsKTUKKIlLe4gGXMBJKQosecixo1PhYlyhhj6V2Usl+2gvNXVeR7F/X/fH2cf4r1kz/+DOagGTh8JYd7ZQSzHL62y3UctCfK+pmwuavOjRjYv4H9/bhngrJ+LmyegWpkv9+B7vHbFX57Mxnb2OZpdfpoYD28ftDPhd8Pry2bKuvf6vrmJcc3eN7yeS9jZqWmfZy1dOKdnxphxz1kVION/WyfKc1zxa4NYiUrd3JpqZUxqW5j6hC/OqSsyfo/SmTlqAHVkPfiBHpQIWc6VHI04wQwNC4pGqv9d5yGfPZnC3PxfhtnaHboSP6sSoie0Pf0/Z6u69h1O/rinaeRPnr22z6lh/J9AtGIItYiatCYIqFo6Wzuk4+aBjocadNVWDwMS8TAmh85xk/NeZYlXuqQf0xUh3KeA07nZYU050YYADPp+Y7giyWlXLk3eSCCydFzJPOxBmhMMig7Y5EIISZgTAiebt9hXUlxmu6JceSrxvmajnfC2sgYxaWmeowmP6ca/DIfxxLIdj5fNX9cvtcpm5y1OJuUq3Ow+lIkxLH9xJ+U+VRIwBgFtfnZVWur3Fu3DSlt7DGAz/isTvPr9eeiwBcMVgxihBCSgUAE0Ij3e159/hLf7bkNz7i5uaNpVtmzMoF+UEuMbZJrXETkAeWRAiap39hhRvSQtxlBwbmPA19ETj1ZjaXaL+q6JW0zBNJ6P5LALan4J0CZscVjdG4vP+gfKdz7s098ilQSAoQeUeXx5XM0mqH98Qw5d4rN27mMToFl5mfXmAbriBL/yL2n+rKUfmmpH3Ub9ffbD/c0G+HZJw63+hjMh0RZgTqMSbF7VMC6lO5AdEffv0YPknCdoahE7wl9IKhFJa8/BVWb6pc9Gh8I4SVh9xr0q4Bd7PexNXOaw3k/VOQTmL4jp+ju40i7FhBLSohocJsVahxgELXEIBBsPhM8xIiJPZiYP/uFmt+Waz4vnXzR8yjV/8d/v7R0ork09i5y2Tl6yqxf0tIhtzr/du5Z1+nVrnSlK/1jp3P7gFtFbj/qQAXbWLw3CcAaDcqY5ibxzbBaNYgxGagSM1hBidHjrMMZx+4xRXkWFVCpnCEMGhVjGlarDSEEuq6nXa1BUqRrGyLb3S45CSATXaYYQWKqLOnwlRJgxBhhtW652dygqvR9h/eKtQ23dzdEjfgPIHwt4lphs2lo1w5r0kkefI/ve/b7PdvHe7aPb+j2r9ntPgdC2lmjUiKjWLfGuQ1Ne0u7usXaFWCTg4qSBPCia81fVRPQJ4H3x3GAoJrAIGksRc9Ta5KovmupflEGnsudw91LNhdNp0aRuw714ZEa2nBMT1/WyCCvaZKrvO/puv3wfNbrFX3f0+0f8CFgxA3zkfQcpGitRfmRp8GIII3Dd32S11Ccs3kSEpiqUB2l9JjcNv9tLvfFat1Nx/o2vNaVlugKmLnSla50pStdKVPJ/1h7kMKS8nv6uU7XNDeOLJKSmacSrm+MpgLJ4BB9wFqDc4aoqV8OCF7pOo+itK5JoQnnaWlmfYwxeUrX4QtTSoVazbkc2n+J5kagAwZ0Yc4umpdj0/XE+xaNU4V/1FF1moplYSAVfqv+PZXm/ZsYMb6UHiSaA5WWjHuLpDBOKIPFc1TIHr4n83Qyx9ZFbZSVGWCt7veS8czI1Mt8sesLBslBSlaDxkgMPWIDloh1DMJk8TAQBJsN11FStJnI1OhT5qN+w6LoYPTRqmRKWyHJaFspW+f1AYM3r4gMhqC5cn5qzBjBMsmMcGytXWZQuMQw8o+F3kb9Py9/2f1PaWn+pi3VsFwGmKXGqO5fMHYBfPpbhm/+oSVGxRrwfs+P/43wk7+szZTCV79r+PYfC76P/PSnP6cPf8ebH36dNz/4naHMTP0BLBvsLjFHiMrQ5yWl/LJRa7pXlWvlb9nl5u/A/G0/byo40udZP+TEc5rfV98lDAlgmKcuKW0//27k0z9WjFiiphRKo02/2qGk7L0l5PLYWlGaic0t1oo2QAnDZIz8iRnmMf1Qz0h1Fs8nLIN5EEklqvUoZEUkgo+e3e6R3eMjXZ8iyvi+G6KSaYxJIel7YvAoOW+7NcQYCBpT/QOYuWplAlYqfEVJ0FeuLoOt69DLNZijgCKUUfFVA0fL73WK0Pr6/Fr5Ny9PPhtrAEYNEIF09h4AVAuYlfQ51vVq7odNyuoYU7hukz0pfZ/SEcU+gU6apqHve9BUvkSNK3MSM9CmBoqU32qqo+OMY07Ky9rbrtRRwF313M/bHvliO4491+GcQyRFlnHO4oyh67oJsLvM9xzgMvAuOeS5CEP0lvoZjrx6TKB5EVbrFU3bDO2HENjv9wP/s7QmADScjwxZ81QiYMSmEO/5tYwEkPwex8ibV694vH/g8WHHJ58on3yyBlGi5KhBKsTYJqOAWRGiwfsMTprt40qJ0DdGVRnAfdV+BUyi4gmS07PpyIIyqOXHugWiplZjtYvOgQOgAz9U/p+r/Y/OYzWWpev1WG0b+d0/vef2tqXbv2a/+wWh6/n+//HHhH178v6xnqVTbFbmyBl98p7Jp+n5deqcmn+vz6Bzczj/bXqOHi/3m7//OZ9+29CsPsKYT9j7W0RsdYSYZAQSixCJoWO786gexjs5Rf3+NY+vHwlBiArOpXev84GI5fauRXVH37/B6CMrYw9AWU+XJMcZPzf/NV02rjn3N7a4RN/+Jz2fftth7AqVFq8t5XwHwagQfKAxDqsRGz3W7LBEGgtY5Y1dAsxc3uOn3PnLkEUWOIHh27lnf6m0X5d72zEe4fJPtrjI/y/eKQufzrVR//6rlV7qSle60pdHT3337z7u+N5/+RlRLW9eW7q+xVqHiCH4iDERa5N8mPjAFO1MUNBIjD3GGnzYpzSrVgdZNfUnfQ/BJ9CDLTx5ShesCOvNLesNGejSs913KUWpMUiUDLLJsmQMiEDTJP2IsUmGsk64uVmx2bSE4In5eL65Sfy+957n3wx8+K1I2zqcucN3D/Tdjv1+y277yPbxkc8++zn3958T/A5jIn23RzU7v0RALJvNB7SrW5pmjbNrkFVyVEGIITvQWsGY5ESR9J+eEDyh74AE8HEuRYu11tL3Y1rcJMMUAP9h5MsUlVYJIVLLp+Ve7/2BU8KwPrJcNciomiPqozjnhraKzHZpVJUic40pfZXdtgciIaY5N2KRzPOEkPvoDCIhtwvljKtl6EFeFos1gZjltr5PuhPrmoncXUd7LeOpZbNTztqDvWgme473HpcDr/Q0ugJmrnSlK13pSlfKVFK+FGV6YWqOeQcf8/w9puifUAFu5ByYRallcnqmYngKIdetmqKkAG7GIGqMWfGblfzFIAIHFvQS4SZGxRgdlNkHzNUJxnM+rksALcc8Yi+hi+bzfC2pD0lmyfXBILbJeRXP+6KlqDjj2L6cXkwNJqOB7F3m+pjxLv86aasuO48sM/xeGRvre5dCUA71XLBulxH7lSFcSe6kNhsEZ+/8aOQBVIacvslAk0Ap2c9jMBXFbJwZ/kkd/P9Yh/N4iWMEmxwhqfbDPvycb6/+xur7QTMnfpsCeJYBDKdTGPzDpqkpYkpzo8f7frOXDFfT/5f7U6/LJUOlVKtID/5n+tmkdbnf97Rti7U3g4d3aVVQjDiMabGmQVgnJVRcNi/Ua01na642ek4NS+UsKwUXohHM+j8a+eTg2rQvC+OetoZMZm1e9rDeOiLVtD05+HZY7nBOaoOl1PdWqbOmEQYSSCYagzE25TKP0z2yNqgvK23KjBkSEGa8tzaISAYMgAzbsyoINQDnqbvH9KmkCDSBvtuz223Z7bdZkRTwfY+GMBz8hogVwTTJA1EkhcSOMXkVpu6XiCh5LHo4w+Tahh5J4t9SJLIpoHiuFKuv26z8K8rDMofzaCdzoM08Et8SqHRQUIrACRDKHKRSyoQYKaejKau89L/EoNa0RkIIaGnPCSF4nLFp+gblp6ZsXTK2kXjdsV/ziH7zsR+L6FLaqPtfA5CO8Tnzf3Mev5YJVJWu64ZnVYNWlsAyoxdjSqla0i2liIeg5rDdAmzyvh/mroCminJ53na9Li5VGtekCjHkPqsOPHIUBYmZ5wr0vcf7gIjBihI1KZoRB1pSIE15imWeARIYT3LZDGqp+PA5eAa0AsvoQf2nzcCFTxl5lWm0v/PGa5n9nd917LqKwZgPMW6Diw7vd3S7e0IGUJtqxz7cDc8bleeRY57CZ9ScY33tWNmjfZj9/ra7+qn6bXEQMS0RS8RhNEUyU4kUeFbakxNYr/c9Sst0fMs80iiBeYgPBO8TiM41iIl0sWPfRdp2TYw7vH+kdZ6Vez6s20vGe67Mpc/vVD3186j5h/mpudSuczdY2xKlRdWBVl7b2WnASMCIItrRNj2ffrTm7sZx92yNSoT9PfD5hSM5T6dkl18mzWfw3B50/tv82vsGy7yvuk7LGceo3h9/2c/uSle60i+H3ubdF7E4t2G3C6A5xU1OD1+fcYV/jhohFP45pcJRjdzfbzHiaFeWbvuGqHfUp6WYFBXQOSGoEFWyvmKMFhNjpO89SU1Z8eAZZOOsRQRi5tmRBPKwNsmHIfT0PvH43u9z+qaQ5Q2HsxZryGlSA77veHh4zf2b19zfv2a/e2S/e0TwWBuBnhh7oo+oBxWHadc07obGJrCMmIY69qwxZuCBi7w4gl4MCeR/qKddknHm+ti5frkAXMq1cs/83lrWDSHgMw9WMjjL6gAAIABJREFUHC4QJs4n9f3l+jH5Z0lOTmUTYEhEKdFhvQ80jaYIRc5m+aw4P8QswI4SgWqVlrzUn2XHFJEnRSS1buRF5/alOVBmaR7nMv687CWy35WeTlfAzJWudKUrXelKmayxOadoZnRnjFz5PNWK1krxzDIJCCWU4ZJiTkAK4xVA46AwNtZgrSAmEqNHSYp2a20O/QgaPFGV4BODqzGlkYmqWGOwxo7GDGC1WadOxBJKMDPnxuRwgiaHtE6AAyHzfLLs3z4ybaP3eWEcZWAkp4zpKQBGCcmfGM9Sb5nvpXbLfYe9WwJSDN+VgZktRtnpPeW/mC169djeL82Z4AmwRGrV/DCCYb1VFoVc11R9tay2k4qRHwWFpOidzsNpsExtMKz/1kKIqRD4MlybqAFjNqZmD4UyF2P7JvfNFvGOYpwUmXrG6/CsDDIPO6/VvIik1CAiec5mSr+s9RYTQDLkRVz2XO/TzxKy90G6U2bv+PgUdQCxKUogEhjBMrE23ix5Bk8uySQyzDiz06e+RGPKAYb26jrmLderrvwdRGyVwW48v0+GMR+nSxSpT6FLDRRfJJ0TT9+P+Hq+lkkUohM1CNDc7vjgW6/55NOvZ0WG8ubngR/9RVGlTO9L71E6s+bzbTA0pkXbFTbnCv/K73puP/XsHwN///9GQieEoPR9xBrH17/xm/z4Jz/njVqWSIb2Zn1YGM+h6UEm38qnY0aJeUSnc8bDemfW2b31v7EnZQ9Yrmt+9fiTPjTNaPVL+dd87Uc0X/8x4BBpMHJL4+5Ytbc0zQ0ijhiF9rkZkm6HCCNgdjzvxiNUh1zmZRxpLyz7Qi4WNXutBWojthhJ4aSNHedG01M5PMKrO4eHNsC6xnkYACyljsTT7Pd7drsdXbcjxhRJRvswHqsTNkCS4jUDXXCKhkD0Hh88wphGaFxw87ej6rkqqlXUj8y3OesGBWANTBFTosfEMQLODBSTnsMhkPUAKFpdmysgCxC8TEDUvHI1RWVLfGC15gtwAxlewyHwdpwpN0lA7sQDp8iF1uWIOMDts1tA6PuemMdvncWInShMrU3rsvAkqlNl6Hych4rENB6N5BDsJilbY8Q1bgCa1PeniDYpAuMYtS6BuFI61AyDVbLSM4F0Qt9N2nfOsdmsAbKSN1TPM9XnnKVpmqxATR6XqR0zgH+KchiS/GHVEEJHr3uCxnE+BqxLWtRipjBCU3j4ai2MPCUZJFZqUGJQvO8JBVYrcXi/0zI2rFYNTdPSNC193/PZZ78AGzAtyXvVWCw3lEhQGnXM5zbZLce+K5L5hWnUrsLtDWmBBpBwKTByQ/O/wygHoOAUSKn5CY8pKg/PhuN8xdud5oLBtXdELNgI9gMe9ju8jn0q79chR30IUtbJZz24Pufxzvdv4Vq1z1066qU5u4RHO1e/lv/NiogjepOjMEFKQdAjEhAsih36bq3h+Ycbfu9Pd/j9I5/9XctnP7qZtLnUtsYejTsaAze3G5w1PDzu0PjIqm1xLmCt4xc//Bo/+v+e4cThO8fITRyO+PQcPJ2LveSOpXVQrjWt8r0/ucetDMgKkRXGOMQ4Vh8YvHcgDUiSv9L7lFLUgtJaj6HDNT0PLyP/2/9ucU5w7h5EuX99LMLM0+nS2fnNb/2CP/sv1vzzf/4viDHyP/9P3+cv/+0r/pPfu+G/+++/gg+epnXc3mz4/n/c8T/+Dz9YrOftePrzkWUSafX/0i/TK28r31zKVZ666+3bXHyr3qnuK13pSr8+9H70Hom++b1Hnn8iuLXw+CjcPwSibxAcqgaVlA7WOpeB7Zl/jJHGOZq2QQR8gKZt6Hvwvaf3j4S4ReUGFcOLHwQeXkZcE/itP93gJUegkaRPd26FkSyv+Y4QoG3WKDGDXYqcEBDnMA5sY2mbJt1vk8tBCJ6Hxwe877HOslqtWLUrNpsNMQohA2T23Y6+37HfPfLm1S94fEhAmb7bEaOn328JfpdkTtGUJtG02HWLdeucgukZxjQoFtRijM2pJdM5LqKgmtLoana2TVgZ2rZBSBFWkoNATrWcy0CSd0uEnCRijLB0kST7qxa5sRIqNMkutUwWk6CVHICzfrdtW6LGSVROMWaUYYVBTpMs4xxVX8/kY83XRATNsnFxYk6puG4wJvXn/uGebr8nakqda2yL5BSVRX5J+mwd5K4k67r0vSfLfFTrZAToDOdj1ktoxaGKMOjIq0KjnJ7ncHT01iy/LiWjvdLb0BUwc6UrXelKV7pSphE8kJgukw0lo1EtWVumwIJkMDCSjX9aGDgDmj18YWTwBvVtMp+LUYjFyzbpmNPfMNQv2eAhIsmgo2FUGGa0RAqukQxTRgCpvEQLM0/MgILUfu5uimozmMXHnKRCmAg+Re1cDA2jBlszt2jLxYEui1RihrmbGizHNDh1NTXAZI66npeZoMlnSvtiDEk2kuRZkJ8+KUZIyDy2Y6rOvoyWohEd62f+lvsVqeeE8nyq+RZJz300dI7ezVLVPaxfSR4SlJEMoJZK4a7T74edrQBhk7EV+UeG7wfj1YWvxfqqDMa8IvSklTiCZJIRphgus3CjY0D9dFcJr5qFNDQ7dpssPAgiJS3GaJzJrie5lgA2oniCCiaDzEQ8xgLaobQozQCJW1K+D/sIOkScCShBSvSZ42CZPBPD32H8gwJVq1k5NMbrMKe1CSXfeSJsf126HpMg2ZM3VZ68UmpDTW28f3sl75Xeji5V1Zen2qyFj78hfPoVg3ORfffAfusRns3W8AVq7ihIbGhNm0prT/ss4u6U7tHykz9P6//x8XM+e7Fjs16zuWny+57fxUnvDj+Pu/LxfpUVvhy3ZVpuXusI+kiGIeX0uIfXa3b1eP/n92dFx4k+nqtruYzg7pT1b4Bzaxp3izU3WLPB2hbnksJM1eQ9kQy8Lal4CoYmgXTL/liULz6HJk7KKc1KLMHvtwM4oO96et9lby9H2zRJaeQa2qYdI2yQlWkJOTOc06ZW8gzg5FGhNY46KdcKDxSjZ7d95PHxgf1ui+87ogZC8GlD1CkUTMekVaUqBuwvUqW+G/ujOfKGlL4tPhclaA7bTIoe6KMHBR984uMYFXcxZGVgBZRZAs3MqU7vVJcv12CMmFhS+sQMUrX54ZajoE7OWR8PAgOQJvGIEIqitYB+UFQixqZ0KMamSEM++BwNYoyGWNoyA3ij8DIAceAbRBh5lSNzUMYWK1DGwDHkM76coEPo8cKXaF67GvK/mOaDAv5R4gAkSgpI51L++iHCQuXJKEhK8aVaRX0ZJ9gYwdjEo6dpSHxISUs18Pn1WEXAKxpDlg1yfZL6RwY5qei4hxXeb1Auj2tyYIPLGilrBzIoSiHLIKaAcCpFtLVNAjWp8rjd0ntPkD2mUVarDTdry93qQ6xYDJYQlND76o0bd+3J3iojOL7evyMjaGZSnFo9fWxvzLvjAWhm5LlOcSlLv0z5obHcRWekKJiAWgWx2NVz2nUAMUTR4ewZ30EZ7jvg7Q76NXJcF/WlGsepcb5Pmrf1lH5O7jI3YBo0tmgQjHiQAOKzASLm9zk9JSOKa1d88HUP2rC9t3z2I5k9y/Fpln55D31vaNwKuCWqoWlXPDPPCSJE7QkhsLt/xuuffjwZ1/zTSMdW3JfDLc/XkbHw4Tca2psWZE0C11oQR+8hqhlkmBh6jFGQPL8xQNhh2fH8mSVIw99+v/tC1s65MdX04Uc9f/CHG/7rf/lNOt/zr/7V3wHwwYeWf/Znt4iAtcLdTQJBXUrvb1xP2XPelxz1xT2V5Zpl+L+WEGtKp91pPv1KV7rSryddsuM8hQfYPIvcfBTpA7x+7dl30JgGK03i7Aw0K5dTwYKIYiTibEPbNDjbABCDIDhWq0jTdCCenfiBT9++Vh5fK80m0O33NGJBWhCHNQ61QvCK7wN9F9FoWK9uiNrjwz6lcifSNGCcYpsmp4wSiEof+ixnQNu0tM2Kxjla19A0DRKV/eNrum7HdvvA9vGe3faB3e6R7eNr+v0W7zti6EEDIXRJfhQDtNh2hW1WWLfGuRWNS59LNB4kR3MsyleJSJYvJu43Me3PQ+TDrO+LWWla9Ma12j0BOor8WWDwUOwJmuXogdsq4JbCYyhQdNkKWiLtF85lzAg54eUHWVzI45M83sMFV/Pt1Hpyir4/pVc2rmW1umO9eYZzyQlit9uyi54iLWtM4OECCsoDz02N8kyaG4OxFu9Leqk46BtG0baS+3TmMENpoziQVM9FC+hmdFaun8WV3g9dATNXutKVrnSlK2XKGIRBaQxMjBAjOHr0LgWwUoWyl2RkEYQ4qOxlYKaS1242oWtM+T8lgoaEpPY6IIQH59AYSahnUhnR0biQvZQHj9jBsKQDY1wU7kVhBDIxIJjBkJB+0xxNQKrxDwpFLeZxzRxhuR7BljqYzN3885yKt7fmL+cEKSkM8qSOBZXTQUSa4lmd2jMyQpeKdzJDqpykHBTK8zk0kZa+LGKCKoZ8nubgNMXcvzgY60RHw5FqCu85CC2MTLogg8FxaEcZjFuRODDYpU8J5S6V9Hqe0Z4DbcZr83J1+oR5eRmFH522mow0huThL4NwobWRlOSRoBkMZq0BwkSg0JieqcLwfgxS17CEc2jSHKlJTQbMxIjmNqIqxgScE4h99moZDT2TcQ0jSH+H1SQjWCalZWIwiBzeX81D9b0YewCiJrFxfNtnCvsFYMz8ynmFRa49P58iQE/AaxQDVPHNfzpk5qo0PaTTxpc5Le9Nx8jZltubD3HWIewJ/Ru6XY/OADMHhs2llpO7PlYaQuwTmNP4fEblPNMqPL7sCH/zmpt1T7tq+P/Ze7MmSZIjTexTM3P3iMjMOrrRBxqLmQEI7M4hQ+4KKSO75NvwL3BF+MB/x32gCH8FRygUDofLazkjWMGAc+BqdHdVd14R4e5mpnxQUzNzD4/IzKrqBgYILcnKDA93u91Mj09Vt/s1wn59EDmpKA4kukBZxxN1x6z3x1Tztfo+7wrVPXWZ8/ErwJmlkS0xHMon7Wv+e9YOt+nhLgYABsQEZxtYYxEHg+0rs/jcMXJXdzAr8XQ3ppFIDCB0L59js16jbZ6haS7FCMblPFBjovyNsl+S6p1Sr6nEZTCEFEY65uh2kVlSHTFjv70XgG+MGIZRoonEiFW3Bq83CdzgELtVjrJB1ghwh+pzn7NibTJw2tg00gljI7tTOhdCCOj3ewz7PcZhQAgjOAFXWBVpKFOWz+Q0Bhq9g6OALg0lIEO9oFjbWZo14WsS75dT8ZAo2zTaiF4DlbORmWGNy4CSOo2PRh/RyDRaXw2s0Wf0uxosY4yBcw7OueIhCAn5zVx4IWIAUQEb9ZArmJcyz2Agqa9EOS31GSJYV+ZNQ5A3rslgFbBEcMzfQ4E+WlfEEp9UKw6995NrmipJ+mIBJrCRU1P4WwNDjJhALKrY5MxQCNAqewNak/iUxN/HBG6NEWyM8FHWwNhmIheM44j77T7Pm455ZjIg0WxGH+FDBaw3NgFyYkqxVIGfQBKRJ0o6RmMMogGiYWUI5R0lTamqBkhKa8ZnHotZeD9jrPAdzDJWqXUa5Y84RYYxAjCmlBpLznaD0UPm3jCapgWzQT/sEaKBJY/LzsIYgoVHP0b4YZT9kErb0muSXythx6Q95XrVl/J2TfbHOUg0zVq+o7CzjIIgnpbF+d7HcSCEed31XqDA5aXSGEw9kOa7bS/w7EWDlx8B+10Pf2/B921qbtWzI1HdDtqVo/DUNT58jsxP1MnZr+cvpiN3OJKny54/Py/nWBsvnm/RrBgwFswWMA3a9TqlFbCgwDDsAQQE9ggxYBw5pRUTGdYYwDUsqZvsBs2lx+UHW3AA9l+tgWjguh3cag/lcI11cB1hHNcgWmM/bEAk0aHalUHv99htbxBCD7Yem5d3QHKs6G8vEIdmgZOQqax5nafz4ofj99Tn6nlmEAJtEMwGBEnVEBhAlH1FQY0CQBqS7BXR7wPuvhjh/B4teYTnDvd3FsDTIsoca/djudil59frNS6vrmSfN4Qf/IsL7PfP8P0fdhhjgLMGYfDojYUfnhoB55is9/Z0mqN9Oj1Ndnj3tFTrZL8/S3xn+idGD71J5xUt9K52nKaLuHoZEu/KuLsPGAPDjwBgQWwSfyQyCdTbVLOys4DnSQ5eCPyjQfAih6xWLcgOWSZT/jEC8CHi1S92aFct1leM1fMIa1twZIzDCD8KOMYaQte28AFAP2KMLPxdZ9HfNYjbDtE6BO8RfIBZR7QrwqpbYbNao3UtDAmfv7/foh/ucXv3Bfp9Asnstuj3e/ixR/CScoljSPKMRL4xrgVMB2Mv0Kw2aFwL6xoYY5PjQNHtFi0dQBQhTrMBiCHLmmorYBanAaDIgSqvlWicwsHJbUUenDpeMkAGPHOO0tUSFVwzc/yYt4WSvJOdQDPwf8q9Gg2Pc4KYoziA5PYKD0mwAFlQSh9OJCm0um6V0+A2yQlE/EbSeqsAOpTHg1BU3pLyyVqJMsPsUx/ryLCU+bJa3tYxJFLdTTV6ZCZyc7YXzT6f6e3pDJg505nOdKYznSmR2EMqc1pl2ED1XW2UUGZHGEhK4eATQIDF6C5MWWJUjbJGaiApvL4as6zVUP0B4zgkAE3xFhZldTK2JKPBPOLHRG0yQTOomrz+fDAKIBzmw6z7Xd+rnqpq9NI66+gpDwNFlNtTI9UpleKhivfxoBSdQyTgUorWghLlR420BJOUr2qQOEw4Mx/7up6lZjw4Dmk9EFUML2nwekXda7oCBc/YGYNd6jqIsnMCuPS2VBv16vqXvMSX2jqPtlMDcwTYo9a9JJTEYlwUwaHJxhn1jM52UvX6TikSUg3p/mTkTKE/xa6XvMCT8QgkQg8n43KdSqAa3fz/4RvHiIgIiDlv8EOknuOH15ENQeqjQVXdKshOlZTpO6aUjuDxxo/6RgMFAZX6YvXOnO7P0xUqb/LMN0mn2vf2bV9+enneSm0P1WutQbdawTUOzEOKgEB5nU4jcZSfpXqNYTgbAZL0J2JscWBIahIFocZX72P36n3s0/qJ9K1sQJoa5MraUtAMV6kBj62yU9enyYvq79Lekt7pegnPT8k50WycCHgwjcX6kxs8++ErgBpwMNisnqHrOux+1eCn/9P66HNLtPn+z3HxSY/V+jna9pmA+OBg7BrWvgDYIUYjEbaopH7hKPtcrKLfOWuTqlBAooY4pcyRaHKBGQHA2Pfo+x7ee4zeY7/bgznCjwMAAfn6EBB8ys2NiBBG9EOA9xFd22K1XmG1WqNpGwQYuFbAIinIlwBWSKGC83ljABKZgcB6FBTWIe/3ym/RRNF0ClSbATMVj1OihUzvXVbuTSOEFB6pPCc57O3kO5NSaCpQRlMH6X16TaPEaFkhhEk/5uDkul3eewzDkMq2GdSj92q6KK1jDshRQIVGi2HmWR+m57vmmzdkJ7nqNR3RMR5oev6Xa/ozjuOkDuGFm7SuCcGHKjJNipSSQl6X+VHeiiFDWBaQ9MtCuybrXz34kIHs1rkcpnwcx/xb21WDnnT8c1RGaDoo4Q8NmSpaUDWGZGAiwyRAEmCT4V0iDQquxaJtOxAkxRMrSMg28P2Qw5qTNTBgGOcQva/GwsCQjnHqdOInQVbes6ykdvAprHrbrnF59R5MyxhCj8iEprmAa9ok8xgMY0Q/+MxzTEda6pnwJwugmcTxTtaD7rN1WXkboOm1SdnpuWMR/R6vW6bJ/3P45ZwjVDLEIGYYWJC1WK8tfvhnI653r/DZj1rc/G17okYp8+R5NOvb0u55ukeHNClvBp45Fakw3fBArdN6aXb/J//8M7z3nRGmuULAGuRewFpKWYHU6COpBHwcMYwj+j4gBEkxJtGuCG0LMEaQCVh/6x7feXmHcc/42f/6XYTeYP3+F7j49s9AcDCmw3r9AtZ0iHyBITggtAATdkNEZA8fAsbRIsYG3cstPnjxJcA7WBvw+V//ALtXL3O/6lNLcalzjuchPuMpY1jTQxKwyAwBBgFAK6Ck+X16LlgDGJGN714F/M1feIgJQc0I/ZP43Me07SFaesuuri7x8sUz9PsdIgH/7X/3Mfb/9jli8AjjgP12K3tp205SEM7Lfde0NOdLf+uVd7MeaPb5OL1NfcfrP1bPu6ztTGd6t/Sm7//TeIgzPTRWV+95/Mm/uUMIDl+8ukc/EFzToes6DF6AIyCJAkmGcHe/hXMOXdehaRyYI/p+QPCAcw2skxQ64zjCWlGyMntwHKF6az2Lx4Hwd3+1BgP4zp9s8d0/ZRAuAHhYE9C0HsaKo0PTANttACFKdEVrYKnBzd9tcP+5S7yqgGi//V80eP/bLTbrFcARxCzpme6+wqtXn+P65jWG8QYhDAg+wI8ew9DD+wBW0D+bpO+l4izjVmjaDZpulaN6qiOn916Z4CQfq+ZS6l+SuYCpDlccSZLcZgSMrDLkBCCiAWK4/NbUT6idFRLVMuQkokr+W4HPlOUqBeSYXJ7Wr32s46UurLslnTTrdfk9DAPu7u5AJuLyciXrjCRNLluRB7mK6qJl1v2pSZ1XVKegzgwi9xVbCicGcQo4yg2cpWw+2sUzfQ10Bsyc6UxnOtOZzpRJjUbK6BHUe6yOyFGYFlGgi3fomAwKlMqI2TNYDAoldU7NDCnz5Jw7MI5YK55tc2/buRGnZtiWAT9Tc+OyvSJCrFblyhzsMjfWqPEBEKWuGlyfKjkeMn9ztTcyo6+XFeBQz00GUhxpgEYYqY0wc6CNgFCQQRKMlH6ACceTaCwQJxb40UAeaT9gc5+m3usSNlLLibFEIiJDExmh7l9t3FKGu84b+66oFhjm63XJAHcMjFXKA6YAJc5rS8EvISRDEas3v/TNkMmGwfL+qUqjvANEGm0n1ZdAUWrMEmO/gbUGxhKsZQx+RIw2Gf21ZWXFTeNEqEFefnjyswyGAabGiblXav1DFZBAheLy/6ESZ0mRP2/B1AilKk7KqQPkOk3KmL9vT1EePea+eTvn7f91K6qOGabe/u06NntTs1wZn9KS+ZNlPgnGOnSrFfb9FuN4i+32DkOyRceDp1MZR4ErA2L0CH4HYxs4ZxEAeD/CD5q+zCQDDc1W6GEP9DNrP3J0gqLQeoxRYXld8OKnmMojqksvJtFj72ndk2ORZepPq9VzvHxxCWMcDDUAA9vdLe7u7hGxOhidU3R58TGurhjWrsHcALYRQzdbcJSUS9YkgKWel7HeqUQxtN/vEYJH27ZYr1p0jQURYxz3GIYRfT9gHAeM4yhgmdEfjD7HADKMyBJ9hCGedv1+h77fwxgL5yQC0W4XsNvdywi7BlfPnmG1WqXQ1XouVbPDwk9NiVHzHnJvgPJdMYZJlJYCUCjtrqOTZI+6GCf3zL8vXnilrBoYMWlhul9/9N4xReVRIiKsuiqCS6VY03vnfFh91tZn6dK5q/1SflKij4RFJV8N/p1HudFrGahb9TOECArls9YVOZY3eVZv3b6lsZ+D0okITdPAe48QQgYBiYJYQEcmRYIwViKsjKNE9xEenTMPru/DnGcCTEqFqiAFefs3602KGCNyAcNnY7K221qbf/Q7IkLbtil1VEoPpuUyJJoLauVtDXomUAjIAN+cysxkft6QQ+NWWHUrSX1mDTgyhsGDLyVNFEHSR4GAfhjgnIxJqObX5CiVpf0xlPDfzlqs1hcYB1mP1rUYQ0CDBq7bAGwTyCDAj3sY2iFwBMHlPb/wPMvntbAvjBo0sxQLzCYe3KQ5iuAMAI48O0UqUMe74BEIp/fmqbG6AgQxw49btN0KiAYhMCwcXNPi/e4TbDcjrjEdA22/jsObtP9d6tSPAWSOtusRAOpy69zMjwTA8nDNJbrVS+yGBgyHFAkfANCHHt4P8NEjBt3P0tilYF4hRPgQELkHGQZRlxDeyqmvYez7cG4FYxr42MJHJ2c0G+zvRkD3SSaE4EB0ASIxnhF5WDuAYw9DbUlszFMemSFJACW6JIOJ86n2dhCJOed0/Nr8IWc8LAYEtAAauZij+smPAl9N2qOOGYXeJS3JJUs05yKvLi/w7PICN9evEDjC+wAED4QAYkYcelxcXaJ1Bhz9k+p4U1qSj07d+TZ0+BYdv2dJsnhqaw659sMn+cR3b1rvmc70ruhdnpG/CbqI3xpigxgs+sFLhI8ADKPHdncLHwKuNs/Qdg6GgH2/w/X1l2iaFuv1Cl23QtO0aBqLSBEhSDQVA4MwRsAB0Q/owy2++vIrxPiduuIJ39X317i9+RJkNuh3PVarS3RtJ7oOazCOW8R4D6II6yiB520Bj1T83NXFJS4vGhAixn2Pvt/i7vYGX3z+GV69+hx9v8XmwoGjh/cD9vseoR+Ft7EtyLQwzsGZBs62WK3WsE6iw0USmZ8jSfRpI31RJ0PmxEdWG/KSqlxlF2CqH67BJUZlFTUXqCyT9ObWKGhF60VKwXRIMYOfl3TCJQqLOhMrWERk83kHaOFa9e0MlKNkrUTqYSbEICl8d7sdBr/Hduew6qzIuEmGbVuT0lcWfbfK7QdAo5nMnp0Y8o8CdZDlLZWScjorTlFOFXyU+wlMdSNF05cn60zvhM6AmTOd6UxnOtOZEolBIIES0v9FqQ9Bjzs1wAT4EGE4ed6SmLaF8RHFOhmJ1CKpXSS9T8xMDzKYpVaWU2I61ZBfjD2iOM+eqUYM+do2ZlRGIS1HFGCqYKf0H5F6lCZjBYekaFRmLPV5Mjqc75e2K9OZPifkebZzLSDXlwwiUlbIDGApt0QOUXCBRIBRz/GlyCU6FmV869+cBkoBF7XnOaOkB0Cax5yiKh5nQB8CnczBRkvPT8YCU2OSjkldno5t8SYQHfDce3tu8FsCrywZ2U619zF9nQtB83mY11Mbx6btqrzoD7QRXHlSxDK3EYiSYyKPm7wvWq94YRPKeijvTXofQjLozyxsAAAgAElEQVSaGfHqDiHCjyOsJUT2UFW37hHTN2WqRiyKwtqjmqvfp8zx0y4Xo0Wtfpyu/3lpSyZ4k4VYUeAfQjDmdXOKwiEPqlHgWDtP0ZJC/7HPzd/C3zQF1WMV/V9H6Y+p+zt/uMfzb1msLpu030Z8+qMVrj/7EON+vmZPV6Jj/6t/AG5fR9hmwPf/sz02lyu01sJYQg8BzNSP5rljpI1NlQRLPShPFRPOkX30kdcOulSl7Di2+gGNrHSskFSfG9H8sx+DGsK6e47N+iW67iKFcyasnndwVvc2C9cQ2hjgmn31Rh++sVc/vMPmAwPnOkQGrGmwfv85XGMAtmA4MBsBymi0MeE6xMhLyOMHEF6/foXb2xv0Qy+pk9YrPLu6xEgBfojwXjysxkGiZ8QgUWZiDKWvxsCQpL3wcUT0RclGRAgxgGAT+EMi14yj7vnSqHa9xn63AzOjcQ7WOrSteN9xZWqPnMrNE5vCaCeAa4wSwSMkpZIo7ZwAarOZewo8qb21gDrMdKH687Ezq/Yw08+qFMvLI93rnDt4FgDG0ee/66gyc9DI/Nm58q2ua7I8uYBkj/FH9TjU/IIAizQtYgFRlPbJWeusS8CQWIAk8TDKnvIt2v7Zl+k8jgeG2dIW9dIT0IzXiCkoUXCc01SO03NZQDK6i9RRiEzFP2vUH5c8OE2K6FjPh4TXdi5m5bLOkQJOdEwVpFRHgmSGeI1WCmx5ZjZn1k7mi41NinoHYx0a59B1LRrnsNmssVq1kjothrTkEz9A0rdxHBG8x+jHNG6Acxar1UpANSzv9dAP6AcBxykg2RqPkXuJiGMsOA6IocghzgVE3KHtIogHWBtyZPT52f3QuT29X88HpDeZYdikZJ2Ulf6RDjkYqoAn9e9T1F3c471PfgXbXMC5FZqmg3UOBGD09yAzgHmP7ZcNPv/JJyfLyu3hiLG/xs7co3XP4NwVEAMQGcZ0+PB7LZ59K4IQsb2/xu3N57j/1QXG1+8fnEqHBurq+pEUTm/Kl7wNb/XYZ2nhbwKhbS/QdQBjBT8agBuABRAm7/+Ivt/CB59AbiJDM8u7LKAahg8JOQOXoqsxmCJe/idfgoNBswaseyGpnsiByEEjSzIRIo3JYCGrL0YLawggK/sHeTA7MBxefr/Hi99LaaK8AIn3f/8hxts1IgiGOQHnJV5opJglnIdAUUtc/en7SnkH7wWAsQf+5n+xMDbig98P+OAP9Kn03pAaqGSflH2E8PwD4D/9c8DhBj/5fxyuv5jHgHqYnsq3P3S/1v9Xf+nxi5+/xouXW/w3/7bD5aU6n4iRr3WE//F/eIW///vP8NWX4USJx2o4/R6d4h9PXz1VRy3rHaf508f5Yf2/lu6Ol/dQvfO9Zen+4+UrT7fAszxQ75nO9BB9fbL46Tp/29fukpT+rujDP3iFi+cBtjF4/WWP0TP6PsLHonUzBAzDDtHL2exDwGrVwtoGMcbkBBJBsIghYrU2sLZF9B7OGhjD+PKnFl/8wzOM4/cQR42udtiT618+w/5mBZCUZW2THFHkR/hqBW9ICncig+FWyty8JHzyLwyaxuH5BwYcRmzvb/Hl68+xvb/B0PfY7e4B9iBE7LbC0/jRI3oGGeH3m+4C1nYwlMC8xsG4DmQsyFCS0VQehMhRjEr+UtmxRNgGA5SdQGkiu81lQ5HXkr6yBtIkvaBcKtFmavktcsQYPE7JqXNd/tx+MP9bI4ceEB3XqC7J5FmHANFXgArwxRDgR49dGND3PRicHScESDxte+0Ys1RnrhtR+NWkdy5RZ1WXIHJhBlRnhvZxEeOXbC9nejs6A2bOdKYznelMZ8q0rLbSSCHqwSbKdSRjDSU9vzA0MSnes9I/GfQFiEMHjJ+1FoSa+UppFCxQpwPKCGsIelxylBoJQ65ggVodzYpUpsxXcjY6JQNhVsbHzGwzp1FgngR10ZHIZrc588n6/WlGbRlAMjUEKeK61KffaYh87QPyd1Jm/bkYY+sbNLSkMKoFeS/3mglDygzUIR6XmPzH0CnwiTK3U0/y2bOkgCFtmwhlkj5ArRJTD+0lxP5DAKa3YbLnZdUe7LXB7lh99Thk8EpuNwAu3gXpKhRopmu4jqCga0GMjwxjOBvUjElGGK2L1Xu79gpI5pj0jkSO4jXCAYAaZ44b8st3xWNleXSnsWZE7uaDEPW8YAjRpzF7fl6P7hzFw1v2m8gSKVWv5/onf6vBKpWcQDNaZn3XUxQnb6JkeYxy9tdNb2qcqunh55fVcsfmXunihcd7n1g0nUVI58n9lw53nzVv3LDtjfw0q4Df/+MtOAC2WcE4wNkgBrwESonVSn/8Wq7X/dR4cKqv03KPf3fwni3dU7Vtsew0HWQYqw/2aNYWlxvC5UUL1zhRxMDAWFPxCgQQ4FwL19T9KvVobasPCM++K+kYR89wzgDUIEYgRtkDAZvrAaPaJzn/1ggbkT1GL975zjm0jYE1kKgy/Q79foftdjtJSTRRDoFASTEIBjiGBBxQkIWRdPKGADLgqNFS0q5hCGQsYvDwfoQdCxwpBC95yOs6axVYTssHlIiAEbGK9iFGMiMhp9M4zhV1c6DDHDCj3mQ1wLRWiNWpk+pytcw8+gsAmboOAMl7rJyVNZhnKeWjlqmKzazgqwCy9b1VjTi1a9bg2uk1YM6j1TxSjBHGxjyOp8DBRAQykn+rrou1sIXxUZqDUYApwKcofAs4RUDlMb13nIehfj30PGRIKjJrLKx1Vcong3EMac6RgGKHvLx6GdZzWCL16DyZHKVHPF/raEGz8TIC1lb2mojgmgau6dC2HdrWoXEWzhq0nUPTGLiGYJ3Frt+BQ8z9tA7YbDoEb+C9QQguyzVtIxGgKKUG27sAaw16YgyjpLnqWkiqNTAaF2CNT+NnpY4E8LcOiOMOoAFEJcJQvacx0r67BO7QNHzAwW6b76UUmh6yN2jkjqP0hEPZNgHrF3dwrUXbWLRdg7YTEFaIe9jGIkTGKzvis5/Meb7jRLRHDICHhbUtrO2EN4wW6yuHzXMG4LHeNwifDdjfNhhez0ucvr+L5987As38unkrZgdrGjCt0O8JbAghckoHOGL0Q0pXHCSSFVM6/5B4di0nRQjNsgVAFLB5qeeVA9EKIvtZMUCl6KIqZ0kyVT12CIAF0hoVwKqcc80zD6IRQADziOBHjL+M8LcEm7hsq3sNMyIMPBgeEZE0CuVDI//YWVSOvzxVrwEOwKtfyD0XLzl/Swogzs4kejJL+rZuQ1j9HqEji5//GLh5ZGuWevGUNfaY+z/9ZcCnv9zh+fM9/us/X4GDgXMW1ggPcnGxxn/80Rb//t/3j67z1OfjtNzSx/T3UA5Tie348zT7a6mdh9dKiQ+V/VC7T+0tj5vjw7Y8dX2c6Uw1/TrNxb/Na/ddjOupsVld7dBe7TD0BtvrgMgWo4+IzOKwaiUFU/AjPA9Jf0dYrS5yJEmN5Ni2IxgGIVjEaBFBsGTB0aO/ibj/tANTm+XuQ0mJMNx3GO67g97PJJOj/bFNxPpbHpu1QdMAfhyw297j+qsvsd/eAWAEPyJ6Dz8OCNEjeC+8gmngnESzadoNrGkTv+KSHrNJKamEXQmh7MRqE5iPeK3rq3fbIuct646FN9Bn5lHmCIYqOTWDbbRSlRWnsuXD+mY6lIlU/5D0v7HWe9NEU7AIuKllVGZ1nBAgtU2yHSU5zjUGzjJC2AOQ1NU1YEbHbcmZ5pjcT6birQAg8a7Cf874VlJwUx3VVfm06ThNx2j6+0xvT2fAzJnOdKYznelMM1LlejacT5ihEj3DJJSx9+LlpmAaVTyJYV494sSj09qCTq/LzlpxUGL8UgQYCJraVGCBhCcoDK42Whngik8WMcBUD2LGSSXDPkOUZQdiQ7lvwnhnJjjmrx+Rtv4I8exvNVEm2AFzxQROmfHJmKQ2klowMTX4SFGcQuHr2CIbGMVuUTy8kaIHSb7SEvEnj86iYPEwLRnOyjrQeZyOTfm/FoqQQ38ek0LnabpyqQsAmXeJTH9M2fN2TYQNqKET0Dy2CpipvdPL2Kk3ZFmnpbyQjFcE55L6cVaHPKAjqyAp/SIZtShAYq3Ua3RZ1NbYUjUETw08SQTK10oJFQTlJEBmpvwGpyAZlNu2rDQtV4v3AhAJUDgNzXpT3hR9JoUR5br++ufrVRUdjvQ/fTpUc/Pkm+VeTqEntWqkrNrZEyQ5rwEnhhBidM/2WPcDQm8w3F4ttm/JM3/pSoz3CB7gQLCOBTADSUFApAa9pKCh4+DUeqU+bD6aqn+WRvHYlbkRCVh+vgaiZsipYVy8P8A6k5RFFtZZXL38GE3n0HUv0baXYLaIgVJaFCNlEYBkOAdZtBuLzccjhmGHcLsGjw1MF9E9H9A0a6yuNjDOgqkBGQaTRIOIzAn0RtCUPhmIQAwDhuavkPdaFEWrrsHlxRpDK9FDrIkYxx2Gvsd+ew8/przpBwCDoqgCU8oWo2eu7rWxinYmIM/IESFFATBkYGAFqBejRLwgQvABznlwZLRNm6L2JdCDsTILLH1QAKlsSlLn6D188BOeLXuhkdEU6hMwQ63UmkdWWQL2KkBlfu9khVXPHQO6HCgNK0VfDYQ5Bpg5dkbXSsGlNqnCU8/QOYho3qcpgLXUIXyiAokENB7CdEyMMZJ6JMSDsRDeiqf1VX/P27XUf43cktseY07T5L0XhaezOUXL/KStCsv4K4KkfRKPvwJGzjxk4rk58YfqjangKW1PDb7y3qfrlHhlk6LjBMQg0ZDqOS4ArTRhRnkbI+HYm1bAMl2L1arFZtXAOQNrGQSPGEf43uP650AYo5zTaT42G4mQESOB2WVFcQ+Gsyy8ETHMZovGeZh1RNswQoxomwGjEwOFs0DbAZ4HABaMBkQBxngAEddf7HH7ZYP+7iKlciwndQ2yTcvoYJ/Oqf/qyJj6XebASgyq8tx0fik/X7gaBrC6uoNpPCILCEMADxKzprnwiLQC0woRLUKUH4MWTWdg3QATJKLOQ5TPjwjcfrECGYFENG7EamVx+TICpgFiAWw3zQXWFy9w+Z6F8x7BB2xft8j5P1G7V+Se5v9VlotU+jtvz/Sp4+1+KvGJT/Oap/N2CBD3AQhBztVx8Ag8woeIMYyS7pEHME/TA+r7JVVQkutKJFVJiqQRZGI6ywRkykwqesv9MaazJkKjrDAIZC1y6kZGOt8IhixC0D1MeAEYB/ssoON7xIHgbzf16gdzOqMJCCxn6GHywVpOODbzx8dZS5mPfr0rUk4aq8NmykICQRwKbH5WBmqDlx8ExDBgdx9wf/1I0PWDrTt9/2PuHUfG3/z1gItNSrdAkp7u8pLx1VePiyzzdCmYF/56ej3zz6dn/9STj7mzSBBHTscHS+bZ7+P898Oc/Py+3xb57kzfDL0bzdW7oafubd8Evcl++9j7TpX5UH2uDeguJSrMEHqE+wHDQIix6MiNSTJCjAK4T5XKdzbx4kVmkKhzSScPDx92sCkiNZFP5/xyesE6/fQxqOJDfbp4wWg6oHsW0O+2QBjQWwHM3N/dYkipkDkGDLsd+vt7DEMPNhaAg3UNmnYtEQ6tg7EJLGMsFDBjU3QZ4W+m6eunzU49IUJ2MJwwhpz5nlrunEZKrewhB5oWAKTR8ku9zIe3lduLI4rcW2S9iV54yahQgVWy1qeSaedAmZPysyhbYW3S40CjlDo0rQVRgPfiLNO0bRkL1VPNZPQlwEyuk0RXw1TAMeqMSTFguh5Vo4rZtUlP0u95WqbUxgW9/5nejM6AmTOd6UxnOtOZMjEEzYuK4SnMoSjBTfIkhYRsTop68RgVxrNtWyjwQhh5jxD0x0hYR9uAQDndgBKB0LgmXzOpHaq8H8cR4ziCSJT7NaNJSUlY+CR9doaAr/nRzCxrv+tUQMtsghoBaib77Sgxh1mIYdGms8yHtLMoM2X81SCmzPZUZVPmj0vEHzIwmSktg1DS9cjzahAUkEwLY+t6Ui00r2dGKuQt0FHATKXgJyMKYDGEyngIeAjTPjMvGh3m5U+8uY8YouZ9fArVgkntYV/XcWr8ag9xZhYv7hSRQcBMU8GkRAMo9U6Mttmz2+RronIMkyhDxli0zqEqDsQaJYoRo8yHswbAiJBCwOc+oYBmygqczW/+EWOHfl4Sw9UkH2fX50/MZ05NBfom6Oe5IULJ5DzNlIxqU4XssqjGqewCmgHEOFNDg74pMe23QRw8NAk+5vP8O37UE217AWNbhGjgo0QfeO/7r7D59he4+6zD5//vHz2l6TOKYL5B8B5hjDCG4MwOjOf5/Ujba1rfh0ac6SpbAn3V5qbDvtYmRaSSajrtp6umyGNq/gInIxBsy/jOf36DzVUL51ayN5kGRN+D94CI2E5KtQkwAwVrANZS4hccNh8EfPxf3eLVF/+I+//we/Cvn6N90eODP/sKz1+s4blDYJKoCtakCB3yDlsnRj9OEe8YERptTPoSsjEkRklhYyigbQgcI4Zxj9ubLUKUKC2IYmSfREkRJgXFq6ooajSqlygmOUfN0Po08p7wGSalaSEwB0lrOQ4Y+x4+eFjr8OzqOeJqhaZp4FwD61rYdH6FZNjTMwEpxYb3I3a7Lfr9vkRdSWGOmRkhKQjnQBBN7aNnRTkfpXdL57fyYgruqJWKNRhH6VRec21LDZbRazZ5s6ni8mCtUkn/o33RttWKwzkAR3mceVlaf/1srbysP9dsA5FF2wI+eXU2TVOAJgk4UkfCiTHCnOBD6vvquQKE76zboimgmCWKhLXCF4YQ4EMAENE0DtYaAWxFzrnglbe31gkfnt7LpmmzF2EIEcMwwlB6j40Fc8AwDAghZHBODQiqwTLabulPwDCMKSqUpg2TSDbaR51zogS2ZSAypYiSDq7p0DQtbOOkv43Fs+cbOMfw4x7juMd2+xpfvvoC1//7n4J78YytZzvCToycOfody/5nu4BP/vVnuHjR4GLTwRoLH4Cb61eI4Q4AwdAFVu0Vbu53YDawZgWDDmDCOA746V+/wOuff3y4ZvNpl5T8ifdA5kUOqd7bS7vzaXKw90/KqIAYagQBgPe/+zOs37vF6B36MYLRwLoLgJxE4bTPYJoLGLcBmxXG2IJ9A+McfM+IMaXomtWnbZyfIeNg8R//8sPJ1W414F/++R0urjYgcoghStQ3avDs2Ye4+uM9wj/fYnezx//3F9+C39enGk3q07+Vx5RxFaAqFoAzyOUc8glP5amWVPj8wPdLJ/z8SgiE3S4gxh7bXUTf93JGIYLJg8kDRiKAmRwZtPSq7GlATEAWOcNsAoWk1MgMqJevpB6SRkZOBjeb5ApEMGR/sSRgVY6SVi2yRmy0GXgDNgAx1t/bwsQ7jF84XP+H7wGQ9I65nZB2G5Jzqp4zTd805/ufMkdz/pKqa3nNEAPkMfGUJwXNSIvBNkW7kjN4CBv84F9GfHe7x89+co8f/dWLJ7TqYZpK8/P+TO+Z03YL/Lv/XvmeGiBzNynjceO4zKEfo8fOzXzf0N9U1XfIiz7ciqU7ptql5e954e9TZR+7Z/n6slx5GgB0pjOdprfVOn4T9NT9+uuo/5t6Ro+Lp/a5u9rj23/0c9zf77HfjTD7DtauEh8MNI0DSCPHSEomo2ARMrCmwThO9XJEAaCAtmthHQO0BxBgHKNtCU3bAWgnfGHdcp78pfSYXkkZH/7A4+W3JWLq3c09br/aSVQcP2Icegy9pJTabbfY3Vxj7HeAbUFNC9us0HVrtF2XwRts1GnTAFn/jQLwDQp6Vf5DHEs46j3KH0l0z6KPlJRJAA5kvTl4hVkdVQoXoSRg4XggQ+Yhqcqty5s7qNTtOHQe1e+R9AyobAG0qHdeAsxIe6u1YiRyJ0dCjJI6eb1aAxSx3++w2+0ARFhj0fcD2naFEAKMQXbcKLLxYaTYquUAAUWtwLkf4nRhk3NQujf/5uTMewgG0vGIMWbdFJI8G/lQb3CmN6MzYOZMZzrTmc50pkSR44Fx4hi4IcaIYRCPy65rMQx9ymc6Yr/fT5hAay26rkUIGlJeQTc2K9hVYd62LYwxmaHT+tSwI9FsYr5n6gXLE8axgEyWVCIVk8qqnFGDjhou5urqAt4pzPoMEa4FPglEw5XWKCkMqyIPQEGJYvS5n1NjFFXVk6SwgE1gGZJc9jGI0T8JHGrMjLGESJRcsSmEfjXG2pb691OoNgZp/8RwZlKo+qTaomK8k7GPACV1a9XnnEP2gaYse4svo/yfSvWz86g2qsiee47P21ELGsjzoobI4uGv1+blqTGvlFXeZQHjeEQuRjdZ5yktAmkEiHqdyY/O/TgM2Pc7jH4Nzip3UXLL26oCSxWJAmKsEcW+/IiCfNm4Ul+ZGmSm6tLp38lYp+HUwSlNAcEsRAcpIzul+S5x+P3U3MFZsf/Ng2W+KXqacr3c+5g3iA7+f7iu5fvo6D31Z2tbGBLAjKYpubi4gKEt9rbc+1i1UN0GMbxswRzR7wNiAKyRvWm6njUByuEIFUDKoQFN38Z4pIXzcanNDlRdewg0U5ex9Le2jYiwWn2ItnWIkeBHAOSSAdwgp1NEBBMQOMJQejqdsTmCCjFW3RU+/uh7+PmPV7gDYO0aFxcXCGElwQVkgAGCGP/B0KQkSKBJIjHG6Vsaw4D721v0/V7yovsR4zjAhx7MsmOF6NPnCM6O5mlzojJWCjiFKXtnTjuTd7+SilKjeNVntLWqOWMAYgQd+iHlfSd0HXB/f4dh6NF1Hdp2haaRaCGNa2AbC2NNMmYqUESiiijP1TSNpGdK6ZRCCJMJ1LOhBr3MwaQPnYNLIND5GTZXBCp/Vz9f2mLBkTPPpzygnoVLqZZ0vMlQWldSZp1qqi6DqnuUv6t/5pFslq7Lup+CqUII2O97RA4F7JHaqvOqwB7le3KEnuqcrPk3BcLUbalBQYtth0RvbBqHcRzhwwhOKZRW6w673Q7393t4P1T9MnBOjeglgqC2TwBV8lJIVBwAFME8YhgFNGOtrXLQT3kbZsYwaH0C8La21K0KUucc2rbFxcUlrHUZOBxixOA9fOJJiQghRlAIMJYQo0c/bPHq1Sv4cYcQ9oh8B2v3mS+pDRnTtVOt5+q3JcKqC+Cww/1tSPIGo20bPHsm7xPHa9xcX2M/jggg7LYWXyGA/R7rlUPo/xSO1xNQ5NwvlUHQhE3H0jMtUdnHJdLM0hvK9Z2z6CUE4H4XMN4FkG1h3QagFjAdyDgQDJgBHxkUGK0hWNPCmBZ9v4MxDuv1c4wXnLm+uZFl3o/FXYQYzgUweyAGAUAZB0ZEiI183xisNqtDGfRInw2oGksFY9RQZoApgTIyp/ru6dQ5W5/8x3lNxjhGXF/vsNsGhODQrq5AlCKTkRFe3QQIOF5H3SRhI+15Kc2S7INpL2aRLYk5A8VBQPKJEPmAJdoLmYjIY/oM8UBmBpsmdUR4GSJJbwpjQLB5vvL6d2uQc3keaPbjYEAcRTbIkniRLWrOnyf81NNmr7znBFO9EwaAMeLwE2M5l8gSQAYhABxTeukoc2vsBe7u9zB4jvV6BcA/qS2PpaV96tjn07TEb9bS1ZuUOaWl2XjT90vWRkkV+JBMcez7x/ZnLvst72E0+/w0me/UGXSmMz1Eb/Nu/jrpsbL911HfN0lvWu84eHz5+g7jyGiaDs6uIZHgGE1yGmBESJBWkYf8GACW9EzeD3LWG5PkKA8fRuz3Bs4xNq7DOG7x6Rd/h2fPG7QNsNt/G4RvT/QC6i5TADSHJ+xD+iA9U3bbW5ivBnAM2G236Ps9YgwI3mO3vcWXX3wOHvokF1usr17CNWtYdwHjOrimgbEOUJlSvN8yLxAhaaoE/MIpECUDM32fylKaBhagHHVNVKw8kalUfqntEsBxWTj3m6T3S3pxIspAkLmcPS9/oss9sqJUptS/aycRpboc7Ucty9Y6aobIW4YsYogYeEAMifeDx3sv38Mw3OPm5sskl1Iev1qu1XapbaZO6SwORahAXWqrEefMAxNKuqdIOws6/vT3mGRRrd8ad7AOzvR2dAbMnOlMZzrTmc6kxAxQzMYGCc+XQBYVg6eKdFGAG8SYwjBbjSqjodYpM0Lyuyj41cghCvIRAKCpmjSVgfB2Ytz0Xszz1jZwrkWJolEU/YfAFWG1DIXUB22PA9glpPM09DRIPNTFMmYxBSlru0p0GdE+StsMKDFxSQRJIBDk9okSE0Dqv1BEgDgLyHOiAE32wRRSu4wrIXIyZBAnoIOtGGZNp1O1T/9OzRPnOfFynxu8YuT8iCDZQwr8wrlPpW31uHOeX+3aEs/KEO1qMR7XqqeQmWswMEXsmzR2lUCS+Oms6JoJKdKH0oja0HWKauHjmGBzjObgm0ImvwOlnvxUGvuQIsnYpKAuqjstbgo2qkw92QiI9EzMdapxWLw1bAbVEImwEsIIGIaxFgSJ+mSMTXOQVP+jxd1fvYTfXiLclfDjRaFZrbOZyjGvSk4hOSFeqZqTYG4GxeTp6bXD6DXTz0wMZsrGsnrE6zLLm8GzlDtTv9+6hOlbVSubj3uI/1OnU4rq+fWnKN3p4P/j5Z4u43HfMyAewlEilTjTgKjFavMc4D2M7fN9DymFlsgPFn/7f/xBUoxIChwCYewP9xxdd0tjcExJcqwtvDjqS2/PMh0zPk4+V0C059++w/v/LGB19RFsa+EjgWBhnEtnnRopxcNN0h0EOStg5YfEg132LQOgFWOcW+PDPwXe/yHBrSRMMFmAOIhnfRWBC0ge6OmcAKf3MLKca8EjjANub2/Q9z1iDAJgKG+9nKl+hI8BYl5NhkhImomyhcteGxgQVqKcdSASgEpSxhHUE13XksnlSAAb9ZtPobWB7KllKIC5Rwge4yjGZD9K9K+m6SRaSCOe+zFGjOOIYRikf3lcGCFFB1PQhszHlEfKYJ9Yzth5ZJBTZ34Dlo8AACAASURBVN0cDKPnBHR4QLPzXyL6KBBWz3RDKbVnSgdZgMsFbhA5pLRfaY4ZGTRUXw8h5sUbEih4vsKVZ60Bp3Oq+69rmSH8mXUu824kCC0470DkSpqkavwPAEmpb/K81OWDB1II9MiMYYwYhzGlVXKHZVS8BWUQWpRznhhEEdYAbAxC9Pjqq9fwPiQP1cLfKI8/4dlI+htiwOhHGUOu9oTIif8MaJomR9RRIHu9nuofedflfRFeV1O5FYB727Zo2wbeS90NHJoYMfoA7yMigLZbgYyFJQsLBwwO1//3C/j+CpEjGB7gCB6bifJ/csJXxvLCOyZ+d7D49P/6A8AEibDHUq9Nyuao7wzUqzEx1cwAR9xZwnjzLIH5ls5P3e+nYJ45TyEvifBJJl8htB3jB/8mILKHHwBEC1CDwBKBaBz79LMDERA4oH/9DH7fov3oc8QAxJVBNO+haVagJD9AU+TKAKEzAdbswGGH6y9v8fqnz8AcQBRgLRCGGd81+z3/7vBNY8DsQe4eTAYMA8VkwUjqxBg9otnhW39yjzCMuP+0w/1n64V6OI+P8JmazjedEVSAGIEFrF37o57icR6iN3mu1Cd/ffC9X+HyvYimuYKxGwxjANo9tv0AJkKzsiCzR+aWOcmo0UBTApZUqQlcQATiCKQ9sEgLOsemkjkFiMaQdS78uaTklfci5jJBAGv0yjS2IAG8gPV9Sz9GRjmaBuZ9h/f+9V5kfzAQegyvCTc/fgaCunMkOHE+36mK3pjGjnVOp6NYr4jZW3R0zor45UERcLRCJIvIRiLfmghYD2tGACPADgQHYocwGkRuYa3Fsw8c/vi/fIXGAX/31xY3r950NZ2mp/DXhU7dXTjd5btOnP+PqPldyEP1mp3P8Hyel97jp73b01oOy3m4R4cl/DZKhWf6pujr2Ul+fXT8DXvz8t7mmbdpy5voCS5fjvjOH96C4DCOATfXe+z6HYzZoOuSkyI1IBLADNgkfbA4syEYBAbAFhlBQBJ5johATmQUxAhjGMYEXP8j4fpnz9H3P8CuEXlpvF9n/vgU7zanpXs++v4tuqteItlFxv39HiCP/W2U6Kd7Sbc0jj2GoccwDOLc1rYwxqHtVui6DYxrYcwKZJ3oIinJ0TTlj6c2BYlOF5O3S9GxFsecWnaqVcAiLovDwPR05VxOLcPEmPQHNIWqxyT7GkOzBakyuJQlsmTR1RojDn2cDqnJowQBraTIKxpJRr+s7SPSTpFPvB8XgTO1Q0MN6sljhCi8sXOIARh9RNO22Gwu4RyjH/ZwtsN63WG/G5IeuUR4jTGiaZqJrGpdcixOPYsp2m69ihQ0Q2QAlsiocs3KOCdgTghTnYTaodQZRgFEIoMn2WwhMu2Z3ozOgJkznelMZzrTmRIZS7CG5LdV1LJ6/xa2WplQZSjHcZDnE7hGGbwaSKHXAUUhi2EJQAbXSC7WAtgpzBhX95kU9SQxsFkhr0aDaZ9EplCDH5CNdKwGLzHoCR8rYeyFIQZKhA5p/7Rs5XAVYCN/ZyAHijqvjrZR2jVTo5tiQKnrNUbrLp7SOVy2RKmUyDGZsRegQ5w0diphCFpbx3WqdpIpk+9FA8qouiT9IQ2HqSGq5yLXCbG41nxCfRpq0TMZxGJliEvzXsYsW3dE+EjGhfm4zg1/SwayJZDV29IicKsSwMpn6a82i1k85lVIkOtlbJiX+5DXNnO6vVKP56GiLFhoCE+pP8B7De0OMMRgXIyT4sHKgeB/uULcrVN5ybu0bp/0sJrTqQnIgGAYyTgjXuOR6pUFLK+duqz6fSqGgHolK2iGcolUrdBpfaowqHeqSpxb+KvQRIhf+P63hZb6dsoQ8RDRwf/vnpbLTcqD/B6KN4oxDYj85K56XT2GYjT46rPnxRjD04gCT217Xfex31PSt+/UPW9OCprpLkY8/9ijuwQ8E5g1ElkDTeuQtz9S5ZJGYAE0rHLZK1JkMbIgMDbfChCPsbSnswchAtEj+BF9P0zBB5EzCEXPyBA8OIwI44hh2GMcxfBf0ieJgiwENfBrewvoNKYGl6+KokYvqgJLon+l6F7GpPOr0oJxMeyplz8RwRJJuipDSZEXMm8VgvAfHpLmIgZGCA40CJ+iEf7GccxRVWrAC0N5AE1vw4f3VOfUU87BucKtfn6J18mfZxusHkEaOpmM7OghqtLM5DqYuHqW8/nJiAncpACZxCewnpd1tMHCt9R9WeIZtHRdAwwWPstM+09R0wm5xNPGrOhEvWa0vPRXOdtjBsqCMAHb1BF25lSDnMgAlIDfMSQogCFYI9ERVLGoPHtRsE49Eym9c5Je1SOEERqJSwc/Jn7cGJNTKAFV1JwDME/6ncKLcwJLS/AG+d57nzwEBTTTNAzTG0QmWCaQCQCNiDHCWQeGEbY7MCgaDK/W8LtyhmfQVT7bp7BC6eYC70CMEAl3nz2DLtc4i/xSl4WqTPlNGKrPZvYWHABilHcgjaRRf5NipKRok5rGxljg8sMesBFjD/gxIHqJjmH9CDv2sH6PJvQgI4CZsPeI0WH1fg+OBGPWsE6ixsz7kTCAcCaCsEcII/p7h69+2eYxWTZfnz5zlr5jHhD5XvZ+amCsRYiAsQ0AMQjZFnj/uwFxBOLO4P4zHMxHPZpyqgMKM4ppzQpoRt4Tz3WEw9K+d8mLPMQ71Fvh+vkWLz5itOs1jAW2u4D72wAeAeMMXGsE1F41Nu+2DEmjVRiPBAjjidyrooHIFrLXmDTZwitT/j4xxnIeQrzb81rNoFOTqkvR1DQhKqd6ocYlgMmBOgu3HmFJUjpZEo/m6x+X8SrcSzpXIcYmJsrRalQyZsZMdigjPued5vN68BZGDw4saTCMQQx6rgn/AgrpPEnRuJhknZoGZC2aTcAHv+fQmICf/+TEpC/Qm/Bpj1+rT+HIj+1qb/ZevGm/luqbSf2TuZ7Xc2y+n9KHY22flzPdr6ftfBdS4W+zTHmmh+nrko1/3fQUufqhct5FGfPz4LF0bF851bemi3jx0Qg/jtjvBuzjHt56GNMBSOl+KSl21WkgV5T0WEHP3yTbEaBx80yKKGesFWC777G9XuH20w0M3oeHnqE8ActolGSmQ/72IXLrHbrLe4QgsrS3e1jTAJHhhx777RY+DBjGPkemBBkY5+Bci2Z1gbbbgGwDJgdVhrOIcdK+nDZJB7mSPXUkVFedO1Cin6geXfgkkRmJlesB6tOl3tGn8lG6c+IJUpxwNGKuXs+6cYbILKgbJ+2ZR0/NEWCISipNlIipc1JnhAIiKo4a+rkmjTQzvxYhUXstacpagrUNmqbDOGwlYrJr4VyDEHs4lIg8SaUxKY+IYXM9SZ6NcTY/Rf4moqyPMWrYqMqbv221fKyOKpP+HKSDOtPb0Bkwc6YznelMZzpTIgWsa/h1MsLdiBFKGbpigBDDTmFylFFzrgHRPDy+zYp3Dckuhpxp2Pv6GaCERtTPtZGmvlZQ4PMwiqp+nqtjlAmWQNCRQ1YMigFCQ1iXcoqBrALpHIzivB6uGMTlkI05tYQ+UTG/c/ErX+JiAOKkqBSFnjLo5dkMyEgFHI4F57oo/Z89wG3y+5sxurlHc+DPzAB1jOoIKaKkNdBIPaXvi08uX+IjszETIE61vX7mXVMNfpG/ZbynBrqqDXndcPVcUVTXYCdSzwoCoGsAlfBlNArUdO3rO6xGErVqljGL4Cie6TGGySo1SRc/XblIkV2WDSpas0aaiWAYTn6xE0/wOeymbvVMOclF0U51GZouiUsJ5TWsTZeHqs3HKE0mXq+PuP+3id5UUUVv9fRjyl66UkvyEYZiUgoxYBghjohhFIVTrQjhY7FeUukp9/eiAv3Es/SoT/oGTVdp0RXNzwQ1/j6swqvLObzz4ZVcosCFaj8Rbx6ulFhlQ6mNaarYUfPYtNW6F6mpMwaPYdghcECMIUVQGFIo5jQuzDk0c0xRRUIYEb1HTGGB555mMfpKScViFNSDNZVLk0Nz6UyQ8/bYaHLVPlGUVcq3dGuMESZ5RmnIaGsZgAWzeM4RRRA5eBZQQUSQNZui7SivZlJ0v7qtcyXSPErJEqD061Qyzc/bXBc/rg3z68KT8ASsMT/S56AgqsJ6Q+dCDcdA+Q5U0kOmZayAnrrcEi0m8YY8DVFdeD6uDq4pcLbmU/W5pnF6cwZKz/mYPN+RYUyKUJMVxBpdDrDWQcHcBThUjUFVXkzvQYwlYlHmoVnHGZln1zWobTwKTtYhWFh/Gk57GAasVpKCxxhRGBMhecrmWYSAdTWyZIRCd/X7mgRGVK4p8ER5pcSF5V5S9XVMvHUsE3dQvl4pHEvZ9TJfkqPpaV2Un9OziFFS2FBVXmYbmVM6S8aw38M4YOyBsSeMw5gB5sIWOpDpQIZhDdBeGBjL6LpLib6SozWWfa/mTw1JOPb+2mHYO+xvHI6faIf802MoBuD1py1sy7h4tsfFcw9jWpCxAIJE+ADQuhYwV/CuxcVLxviJRKXyISTHgZQQlCIcgPDlCugdbMVt6LjJPBkwiTdt4QPnfVju7dJZP//+jXZPIhhnJNoqJ/ClsbBu+h4nxnYiT2qEo0m9lE5VZrBhieiZeJVJ1CdWfkCcZABJdcBpr9M9UaPB5ug2EelFMdW7x7lFCpqh1DBmC2aL4FN9hmBMA9MA6w9HOAvsv3QIezMZZ527qGtf30MSSV3wQA+P+OIdNZgIXn6oTbU2YDYpSGeKwAQ1tjGYoqxTUwA8ZFqw8Xj+LYke1+8YN69PRzR9m5N2yum9C5767cp40748VKtGA5vIfvUZjppPnrZl/r4e54/LDsAH1x5Hp/rx1LH5XZMnz1To65GOf/PoODf1+GffFb1JecYwrt73yHJgipY5hiR3xpBlAwVrxMhgN+L6qwFDHzAMAcMQk248RVOJUfRixPA+pBTHh/VPdcMMpuSUko9og+3rBt4R9rearlx6W/Ocyv8CSMBtLVHuJTBcF7F+4eVZBfRrGh0GhrEH7gUqLmmhAB9HxBAkoszYw4cRIYpjqjrUWtfCNR2cawUkncZBgpwrYDz1lWe7POt+XssoKk8h/z2Vd/SeOFl4S5E7l67VstWy6vjIaqYi19YRWLSseZ0qW0l00Sri/wO69Toi+9xBppbLanlSomQmhyNIpB7CNKUxAFhnEaPBbrefjYvwflP7jcqxyLzq9P66r3YyduogbUyK8l/NbT12tZ2nTl9cj+XToV9nOkZnwMyZznSmM53pTIlCCBIusUrLo7yIhLJ3qNHVwq9EYXgrxs85l5C/BaygeS2VISISA5u15bqSKuCVjnkAHwNrFEMQKob78F5rhSGPUT1zJS2TUfBNiNBUFBo2UMvTnJyccnpm0aMyAs3bSDT/rH/XDPjUkKUCgEbhEYa3tEGMlwlAUUWmKcY5BdLoOORbqvrLRQltKJ50xlg46xA4FKFqZrSZM/H15yXDF5FJTPXUuEIaYkdBS5N5PF5eaTpng8ySoXDettOCx6Gn9GOfO0YKbqqFCX0mK4Q5VkZYhg8RlJApaqguwkkFxCqy4EKd6lWv6zwkKVLfs5BSP1gxuspiAiBzFGNAiF4M4qgVlcXcrf6pMfuu1AoRPvDSLs+W8cDEqKT31M8tq1i0Lv05UHgueMwsKUcPxm7xmUP6XRTJjqudvx56jKGq/jS9n/L/4B6GRNnlY4QxHsO4g/e7ItnP6pLnEjhGDSzEi4YaAg7AModjVRtWj+Wp5tyPg7W7UG8NNtNAHMdoySDwGKOF1kHpvYw8pCNVwbQRknddvNIlx05JJiIAQAOOJa1eBi5BlD0GQYwhFBHDiH7Y4+bmGsMgkS6mUcaAuRdRjBHee3g/IiaQn/ceEiWDclQMucYTZVpOoYNpxK8l8EkeP5Z+i1Gfqv1WQIslek0ak9mzzAwycj6rAtRamyPwGbKwtoG1BqOXVE2RPQKHXIbwMSU08hJ/VH936r7689cFnFkqV1PzaLs0aokqxurnpnOyPEcxpX465BvTWAvzk/ij8jMHfXACbhhLwi9lJ8FKYceMtm0TKDVO5iQ/gLJW5O9UXuIHcjSi1CdjDKxxU1AUDuepVnjGwOktkz6EEFNqrzHxigabzUVup7wnJapWCEHuRZgoZ3VtKq8gYBkHY0yK3BRz+UrL66n8Xc+TvpNEhLu7OwzDgKZpZE3rfaywFQYQYIjQtg5d58AIiLA4VJlOjQHAlE2K+T0/jO5SNsQEZCGepBdb3rEruWhWH1EtIZR7NbLMvO18UErVHwYweOx3e+z3Ed47MK8hafESvx4topc5dc7h8uOIGHsJdw+bgIVqUBAgFDGyPAQwhuEGX/zkO9i+vgIToyQ5wqSn87f52Gk2p3Gw+NFffgwC8N0/vMXv/9FXsM0KTbtJe3EDywJW8MHAB4cXv2fw0Q9aOOtwf38PHwb4MCDyFmR6AAGf/28foP/UHbRFz1mJLZaU+5zC+afZKSNeTujC7WKSyoug59fpfj5EBIns6hoD6wA/jOAYhB83ci6FEMDRIq+oDPQwks4qmvRViXQqnHoAEpjIkBghjJE0doYswJK+DwxQAoVwYAA2vZMGIarcm9ZGiAg+CJ9jLBgE7xlkZ1xPHXmULYgdLBmJ7hcZ3g8wmwEf/dkdrjYGP/2fL3D7iylgxlQQh4icZFaKr96pp45+DbyRikawGeA5gkwA2SsgGoRIAJyA9VjWDRFAJsBYizF4EMvYMgjOdvjBvwqA7/HZPwb8n39hF2t/TGsf5nNr3vLr5ciXSn8X3MG8zKUelD27/J/PEugeesgpn2rf0p2H7/FD5rbl8Z7u1k+j30VZ8kyFvkmZ+jeFlmTcU/f+ppBtGd/7V9dyLnkDaxpY2+B2d4O+36Hv9/C+ByiibVqACOMYMOwD/vEfAIJLsh3BNRppJBXOgA8ePnhxPjV6AgJ6GpYo5Ik3TkAHSXcM+H3E/d9+BB6VF+JKBZ7AEfpplrZUwSpa38WLgO/92Z30oY8YhwA/BowpuuF+u0O/58yzDEPA9v4ao+/BMcCHUVK2pg4616JbXcCYFsY6EDUIUdCntlFgLgAFf8QUxZ2P6F/z7VzJGlJXSUVU93AqF87l4fp6TbVjMFDa8lh5eX6/ylX5c+SsMlHAjLXLfZ6XVadYntcxkUlT34ojEQPEsI0FIoFj4kmpyHNXV1fY74FXu3tcX9/g8vIqlRGTTppymmN15BQ9UC3vqw2I8321Q4m0WxitGBneiy1G9CEm2Ys4t73uZ20vqmXXug9nejs6A2bOdKYznelMZ0okmQ0MrKGKIbOJwUFWtgsYxqFtm8SIFdBLzagtARcUHEFkQaYwbwCysUivqZGrZlLr8hSEM0cY1967yhBi1p4CXmGACK5JCkOW9A1gzmEyawOaMH7FQ6/mZSdGqPy5NugJUEjbmBHSHEFGI9hIiosCkhGmLwSf61fDj/cRxqjBSTxHTfaGKyp6NTSoMYBAOXe9psZRtZhE3EmhQVMfSOOXz2gJhb+EmJ+S9r/MlTC3qvorIKEyV1StgQU1mxrOUNozNV4W4aL+fYyma7U885BgdPo7TbchimRrTSXMqRezgq/UPBEAzVVLYlylvB6LsHFKlVDeNxnTyBEhhmyMY2bYpOw20SAyECKLAp0A65wYsJzLuYRnNUz+BVJlfeo3kIJ9HjOuzI0V5Tkk43z5rNdmY3tQ5vS7WhEwv39e21IZpZWH9f2u0pur6KdPPr6cem6Oz8CSEl5BMyHuAPYwFOAMY7//Crv9V2C/Q2NWJWrMHFwJMZadmve5J+xxY87hClX42MzkNFu7h4qtmjJsMwNbcNAPzMoo+rNlcE5NGQhEAWPcYn9LsM0aTdOhsRtY24ohzjhRiqT0OMldHQRJhUSmiN4aVYVYvLKZR+yHPfrdveQ9H/eoU8cseRbNP4/jKIb/KJ5Osv+JoigEVRQBcs4Kj1ArfpCANEtnW/05e2qZAlys7z0A2qQy5wCQvpfUipKWqYRnNkYiaYiCaUwGU0AAAiGXXUfim7dzCSg6b9+xPs75t3dNdZ3e+8lZrUCO+Rl8+GzNz8k5p8AnYQtqr7x0rppppJa63tqTTynnRMcU1D3hbYEMTLHGwHVdVg7GaiyZi8dcDaAl0gh+wqdK/vUCZlmKrqi/FZgTQ0AMAdbaCvxl0TaFnw4+ghPI2pBD4+Q7Bc8oeFejR+kar/lYVbwqYCakOq21mY+fj1Pm23jKR9XvQ83nxxjhnEXgCHFAJAR9f7iRNRMIIQCrpoXAe8u+BxzuZTL7yqVM+RIF9EorI+p1lTkTKnuqrqYcbQiVt+5BuHbk/bVeLzVYJi7svPXZUXMnBEb0AW3TgB3AgTEGBlkFzQMMC+PWsBaIMYgzACOBFQEBMyZmTg0RRuUNwBiPGPcwiLAgSXmWDC5x0qbDMaaqraUfp4E1lgYYXCMOdxjGDrZ9AWM2CNHCB4u2ewaiFQCDyBbbPWMIHSI7eDaI0cBRC2MJhGYyfioB1fNOTAnkIBEIFfCAah6RxponvanTbIkMVq+dpdk7RjW30A9b3N0HXGCFbnUB7wm73V6MTJEBNlkuAwgwCYBJBoEtIgvfDgQY6LkXQCagcXqWBHAcEKPsU86tYG0DgBAiC7jOhxStqoW1nQBFfHLUMDbLjxwiCALojBIDBhSp6ljioWSwgWgBNir5wRoLZy0a28Eaj8gRrHFWF0FJRT5Fns/p/J4a9aU9oX4m8A4hXgO0AfEgjiLuChENIhsgOjBJqkjmCKZkzGy7xC8QmvUG+/0Ojggrt0azYkiCtnm7ao50md5Mvnhzjvxdln7qPX8M1feXvXbKWys0lAGgen/rMZ06W9TtW+bKj62Nw+enMsgpefMpdJYpf3fp63tr/2nQm/b/uLYGOMajHKv7qe9fDBG//MUNXOsAtuC4E/25yoPUwdlGQOZJdjMAViuLi02LmMAJoAGgJDtYB2sJfhR5Yb1eC3uW+e/C1ZCisHOKWJGznXOwxsBEwpbqVOSApym0UM/OY3u2/ramRePex9iPIPZwNoLYI/gddvtbxBAwjj3u7gcwRwzDHhxHhFiAMgKCb0DGwJgWbbMBk4VEOTT/P3tv1iTJkaSJfWpm7hGZWYUqFI4+Z4DZmT1kOdzZXaEIRfhAIX80fwL5RvKBK7LTw9kZ9olpHAVUVWZGhLuZKR9U1Q4Pj8gsoNCD7gmFFDLCw91uN9PjU1Ww8g9xjiBX0x2nZLKRASaqPv5YLmx1oiLbC5DjWJ4vZ8rK8lk6aD5GHj7vSCntX9NFt8APclU2ysURt3fkaNvWymdVF5LRyoml7AWAxq4752ApnhlOUl9xRkQEDgk5T8h5wO7+FofDAVdXW3jn1S6ExnYjUUw7vUJq5EZnehiRa9t0y+13u9aOg8mc4giSim2olUVtLDt50l8AM++KLoCZC13oQhe60IWMTDdcDFTAUizxzsO7AK/ejAAEGS1aYGEOlXEyLzBj/AriVxlI+7UFWSy9aVuv3a6pC+bPnmmNSHJfVUeLHaUywcKMq4HfGPQsoTDBhHFs61oPx2jMeL3GMg5L4aa0rx3N2m7pa29k65nJoQAcRJiwXKPmyU+wEPO1LXX0c2PQNXCOgThE+autVQZV2iGgCc5VrHos2GR5b/3s4H17v85FzgD1xqN23tfBKFQLoV6xbc8sQVuP8QY4ZRg7d99RyxbP9Z4OxtCrwJOgfTbjIWBqwbafNlciFDpUwxuhpmgyobE1Vtl8OFAjXBkJkEvn2EBaLP8ciXAUacLN/7hHnu8x/eoJ5l8/l3RKBDGqALBgnPlIod3/Ax2L6WZYag3+VbQ9vnc51/a8UVsOUI1S9f+dahamYOmVrqfpXSk4v63C5odAb6uif8y4nqLe4HjK3LBespkoOEku5kx7HKYZ0+E1Pvvb93D39fuIB0k7sQzgYrtmZ7Zp1mlp0yKdE4BuPfWrra63eq01A9nT9dPy/Xhcz1fuW0slpekJHlPGN797gt2rLeAdnv7rN3j63CF4MbLHlDV1iu5NMM93ffMZYKRyDhJEOWOjtbu/w27/BtO0R0oTmBPAGZl9OVNZwQAM/ducTZwZOSVND3VsuljyC+32Xa4vhvfUGVQ+Z0aJjNUAd0x5t6T2XJA9OENSPNa6BAQsYbnZAURB0+Won73jEpmjVTwtAcunQD/WjlOgmbc5H7t+PXj21++t8i9nSYdmSrE1AHTnEQeU8TKFnVzLqlDVaEKt1yZ0ahkl3YtzBFagDRtfRgKqkbUqqVGIGKRAkhK9Bnqms+R/l/DZdQzkTHUI3iIAJv3HGoaadZ0CkhLM0io6OHIn+d7l+imA5qIo1t2OWt6g5nlvx9w5h8PhUMAyknKqzjFzVcKa4tI5AQe1IPZWsbnGLy1libX1Y3NZoiVB9wfUPU/4xCQAjgzMwcFdB/zV/8y4ff0Vvv7lBre/e1b4AwnO55BWIt+1a6L+O20qbRLHrZRiJwy6PbpwZMTdU/3OdIaHXHkmM2O/n4EpYZoJKQeQp4b10c/l/ba9WOWSYlQQOSbn+v7IPAu4QlLf5dIOaN9+/m8Z26fQdAIzxjGAIZFLvCf4kEHI4Dzhy99u8PKzKyy5tToWMi6f//op3nyz0TXiQW4o7WdO8P4WzMBHn4z46JONvLeaEsBRAPkrOD+CiPHi33m4v/IYfEaebzHPb/Dl//sch2823ZhazC+2cVmL3FZmVj8Rl72jjHYTGbHOJnWf+hntPxGAr//x57j9DHj+owGf/k3C1fWgwJaEFLlEa0UDZvPeyTmeM5AFdOqDAE8JCaCI6ZXDV//wROoiBrh6pgfnizyeWdZV4gzOwM2P3uC9n3wD57YIflQwbNDIUgM4zUhJo1GRgPJSTjpGpNuoAf0JiTMyJx1nMY5lFsAaQeRtyoArgEIhiypjcPv6+fitOXdiVamov88+f/HLJ7h9uQHBAxTw87++nLv7NAAAIABJREFUw9MPExjXYIzw7kr4RhbZjBzgHSSvmJYeEwA3gAFMGZib6F2nuNVTbX2oH6evvS1H/nZ0rm1rO+Kp306X0b8fVWPR/5+b/Xwp5/Vv3oL/a+7jxV/7tn4di7verdz2xyj7Xei70/f3pv7pk2ve+FPjuLbX91fb/eY0R+ZDxIef/BoJhMwDiIKAi/0gYBhLNUyMjIyUs5wRGh1D+OO6b2RkAb024HXbr3IGyDmJxuZqeqKuX4wa4VyBJC54+DBg+uoJbr+8FqBNbPTglqJcvz//OePZTwHOEs2UswBsQ5A0npwlQiUhYLwK4CSOJdNhj2neY5oO2B92uL97g3mSaDoSiVrSuZKyAkGBMj4I7+AogCgAbhC5Rxon7eIMpKTRthtZgUiuke7pzXCY3jQvAClFPM+9DCz6cyfFnJGPpWwqf8tzi9/6eTnWNwD1JFr7/ZR++ZRd45SDTL3PnXz+XNutnc45uKL3NTuByLTeS5YBC24ka1c+exeQcizzXmVCLTgz5hSLfcFJyH6NHmTt5hLNj0jlHY1oyA3j3c6LOIhUoI7Ju8vowxf6bnQBzFzoQhe60IUupFQZLkJNE6TmAQdNVeSUUaqgmqqYNQYUaggwAIcxaD1owBT7baSN1qt4acRpDVcnjTYdtZy1fW1UpqV/0H7nYswEab+7PmYRaEjSeiyNcvJV7ltTj9exPWr48bXyk0Pwg36b1fvawTkuwoC0VcqWsakpIo7KA5rx7ceyAlWk3eLxjGKgbMf4FJDlISZVUnpVocbqsHGyJn9fzO5DwtFjn1szMC7Hpr9Wrsj/i+wl/a5jnpt3AOW6rT0zVDknb1cFYZmxw97dE/1ZXK7ClFOFsaV+8mrIE+OUcw6bn05I8R7xa1EMOwCeRZA1/1dpSa1Ke9cYotY8f6QvonN4GDTTqUhOaKPXQA0obbC/x2rdpTL0+1RqLWv/lyLeVX/Qh2ntrmqeXFd+nSon8x5xnpBiwH4/I+c97l9+iDefPwVgSXOqiUy+Havil+u07xsgafDaumllLfVX5dO7WQEPjezZtj9Q7v52xHQ7wo8Zw88O2N6M2G4kjq9FUKsxGGrBYjQ2raETBQgYjnRkOWO/32G/3yGnGVAwDQMaMYMqWKZRdB3tw006SYBQwKtsSqvTI1aP8/NnWlcnuJu32qYH1iP1kU7sOQMe5JyQCQhwCEHuMYDNMv3TWhvbMk+BZ1oe6zFA0sfSY5SA3X0PLNi1ftj1PjSzjHsLDikgJptcancOWafyFBlzpNf0qo6144yUNc2N8+op6TQlJwp4KWmkFzDDedIoDAa2sT40/FdR6BrPjALetj62a6UFRJW+NxECbUBbBavkg5d88TU1qqQq6zz2DFRNbTSnPiKSpPKpyulWgWvjvpy7pRJ7ST2gXP+BxPAAiHVaecWcsu4xBpbLeO8nDLrZ4+4rZ5y99BdU95tm75a/C979gd2vnAdU56m0X/9fII+L/XVZ8uItKKvtaFwWnxgabl8jZcVIAHnFdzVrxupgFMNDuzballQZpvVsTchpeYYJPXmf8OQDxn7H2O8StlceQAJ5wAeC84zgZO++e83AZzUxX98XW6+M+9sR97fjiTFgQCN1PHmhsSXIAN0CoXCO4OABBjbvE8ZAGDxp6p+Eb37N2C/LVU9lkfpOQ3BrK/UT2fmyPM3be9F9avt9vG6Aw+v3cHgNhBAxx71GfyH4IO8amzxKZAGBpB22P0FSFYXgQIgAzwBm5GnA7vNnpR9rHC81vxl3Hm6+xjy9RE5bhPAEnq7gwgZDgAAAtw6HKSKlCIO1cFbUf8dFmYzCcCoT19bKqs9gZI4wiQOgCm5XZxaLBJW0fZYK6xR4+BytzfPu9Yj967Hc8eKTb7B9toP3Gc49geMtLOMxOUnPJnukAcoInAlEA5gZMSVMEWfo23P7D3MW71JqeXwb+yQelR7bkiVYpnV+OH5zcHb+67u4vrPy4q99W7++Tu9qlP+lyHwX6un71Cv8qVPL353ea/roKtVtsvL2y1JPntyOsX3vDbJzYFzBuQ04e6QchJcHaYQ+RkwTUk5w5OAJIOeQYmxYBjvJ5KxzVFPTCN+ulVMTaZsX7aHaStZ7hzBgGEdM8xaHl5vmbi5baVvG5gnj2Y8lnVTwQZw2HDAMWRwac0ZMVBjJlCQ1+/5wh/vdraad2mE67BHnvUZAtyicVKLNDsMGwyDRAUmd78TZs3pNMqHhQ/vOSvTZJsVP0xMdTpiDgve+3/PLOJqsYGunKB1Oys3nHBXW6Cz4pllQj5Wx+zVR5aOlreTYFrLOW6w5spRyYAKNOTIJUMarI0Zu9C4SjddGkWwxamFWf/lS5Lmcs8pupl+2teWavgLmZFXmm1CioWfOCCEUHXir+zC9yXJsLvRu6AKYudCFLnShC11ISRTqktKnei6LgtgQ/cbcMJvy/JzqYE2FArQM3dKwsTQQnLrP7l0D2/Toa1b+WJg7Y8tqXvbWkOLgvYT9ZjZlpDB3OQv6XzxzNX0VWia0V8ijMKht+9fGotHBLq8vgDA5sYbxtPZnMQQxgVy9b1EKinrHNP2FeV/URcKsluF7S6Zz1YAJdPMpfxeMu84PFf773TC6awCWZXvbz2tGw1OgrbV6zlFZk9pHAwvJ9VquLGc1RjWCpKVyMsAWM6oXJ6o3uKUaWaaWKGh/bUNLjrz+CwA5iUZEApZJiRGjGvnYw7sB5HyBhJngJCvV1OGL8VEleBt3Zs2IdGx0aJt6eozXImQwcAJ805a9vnetXT3zVn2r1brWm2+vRv/noe+m9HtY5XzuVzPItOU81J7bl6OoUzIhzgFE14gHj+NVtvKOo1+Ta+v3ZOP5VNuO1+xj6Nw6Ka/4Sjqm7r4Hfm/LMmpnjDNweDniNjqMPyaML7xk+ih8gn00daUYuuUMTogpSVo6IuSUcDjscH9/jxRnTT3HSDHKPpQUMHMCNGFUvIrYTHVVtVb4lHOD/Iiz7vg8rHm7pd/Wf26M1evlyPleQaJdeGayfN4GahBvK1CGp3AElFnzOLPfzyrzGlqe029PhOVRuOThHmrPkg9s+9DPO6rBsvCGuU4h23qobdMWFv7piD8tYJnSYOWzbP31PA0RiaGQKkgnW8ovXWo5W5qjth0V2Fz6fKwrXh2bdny69QIoL+s6sIwMoUNKkubIUjbFmJqIhQ0Pjbqe7J0hsgh5te9LvnsZUvsY1Hb+XajgHgPgJEzzLKAj9gCRprjK8E6AdikxpiliGADnArzzjeexkIM023T/PXQXJ42ux/xHvd6+2+3vp6EvfZnLJ2xHX6q9yTGevn+Q1HGWLncEIhFSJmRVPmfrjfGCaN+tujd1bWGBIdg+TVTTwnry8NsbvPGhieUAs53oA9pO0nOYCJkdYszIHgh+g+0Th+cfT8iJcff1BshUnpf0TtXMbtzh+V3nANABRB5D2CLFpCHkGWAFd5OkQgvkMA7XcC7DubDKv9nQ113gtIG94x9Jdom11I0rtZy90pYx74CvfgWEwBieZngvUcWYJGqPpMySfYNJEBnee8l6xAmcExgR8+st0t5j+sZ34wv06b+WK9jume4D3nwhEVfGwSEE4Pq9A9x7ewAbDKN4EzOyyArZgZyMkgVWs8BrTAy4rEATkw6c7o+sAJMZ4Cea3EnWQdbxThDATAbr8jGoW//X5un86B9fX1tvt19JzddPJjz7aA/wFRy7Io875qNnxQAobckM0Cbi+U8Jw+jx6vOEw/0jeIsH76j3nefeHr7jcbW83f3HoJnH8eUtLcX/5tTua6PjN5XQvE9lX38Mh/12YJmHSrvQhU7Rd30rHyrvT21Nrp2gcooQXNH5HLloFLIzwhE1Z8Zy717WJmdQ2O7gxx3IJ0hu0AGS8nEAw0DYFhlbeRoWgIrJcMIverSOgm3NkgonS7riyowJO0eAgesN2lv3dhJGRHvjXID3I4YbYHx/AjNL5Lc0Y955xP3Y1ZzThBgzHI9SDjsgO6QpIzvWSDGElGfkfEDKM+bpgPvdLe7v32CadpjjhJRmSTtlEdg18o5E1wkIQSLUldRLqNFjQCajWyy5DCJzQGn2fOY6lq3MWAQtBtSxTx6S8RMHGpMVlQ/S29/5e/gtZealvNQ7IvQy5xodR1J5XBs6vUGxgQDQ9UbOqf1DAOnjuEGKG+x2E4YhyHqFL+1j5etb3X675k2O9t6jyr/c6akN+NQ7UIhMKPyttLlNXS1pS6uT6TLV04XeDV0AMxe60IUudKELKTnvC0NTGBVVUgsZs9t6uNawfUbrAIKqclx6Ni+NP6fQwct7l4p7Y5z6tqA34hTjQs2TyuU+goODd8IIEpHm6xRlvUX5KOCcJn9sNTyIIGPPE/mOATzFqq+OmI7TPEtkmXm2/PMeLghiH1lCXVdDEArzWse8timLJUkHhcs8m3BmY2Hjwsxv5cl3illt+25zZnUC0PDgomX9QzK7S8PcGlhrDfizRmvX65pWgwSZgFDThjhXDaQGKiETBGHGQkPnWxtVICFoCg8rL6txL4NVydsav9o2wWrSlF+AhZdVj0knUWdiBO7uDxiHhKurQcKyqwLbcRVvHRw8i+rYwRQUIg5HsoDqzdiUv40Ri47vOSfctr+/vYpX/n/q+WpsOPX7sTHlIXrXgvo/F32XfjxGmb6mCDy1cz7WMPKbv/u4N3Dycoapu7+tmZdrlxYGsyYNxxq1NTxGhd8ZKRdtblMqrY3LY8AwACqY7MT9ayaHMh7RY/fffoQdgM3fjHj2gUcmAeWVaB1FoZhBlNSbTkI7Z54x0hY5Rezu7/Dq1Svcvn6NIRDG0YPBiLMo0ASPQkd4lqWXVeFJuCpGl2Dc73K2rD1PQNnH7R7bnxcPrxeq57B4ceUSqSN4S5nCmKZ7cBY+woc23WTtcwt8aMm5Pr3PUfsXvNdjwJ+nqMENL3ie2pY2tVLh16ifp9Zb7HQbRUm3DFNt92ZmINeoLN55UXqTB5x6uSngRWuRe+ybKfKIkDUSS01LVJVyRMAwDAghAMxILUg1WcoODXHtq4JblMzKczVKx3PDb/Xb2C3HyfpBBOXjoZFIJOXSOI7IOWOaJuz3e+ScsdkMZY2Il2gF4lQFKDRVkqaQoh4c45zDMAyFV22VuHXOTkRXXOnjPM8AGId5QggOnuWUTolBLoG9l7DvmLEdgXEMGIYthmFztuz2rOajX5afjkZ1Ze/uT38rd82Yu16mlMvK9+XFU37I+OQ/fAE/ZBwiI2YPH7a4u02Yo6THDUFTs5KApS2+nwGs5bPVtlCUgxEGr/YZATCOY8BmGHC12eDVuMG9laFnRUwZKYlBhZz+QwbIIYFwmB18IgyDx7OfzHj/x7eY9gm/+N8/EnAqlaOy9L1yAqfPULnnDqA7DH6LYXiGSYGX8g4NiInANICdB/kB43aLeZJheYiPfIj6lpmcxG9V5to53fIR918H/Lf/4wk8CJ/8T/d4+uMEcow5SjQo71VGKHt5wjCOIA/sDzu8efUSRBmvf/HvMX35QlYCGRfOxdyGZn22wB+b4/uvPsT9Vx82/BHw4pPP8P5f/B7Ob3B98xyJI6CGOjdsMXBd/0n3SwHEJHCOIJfh1cOcmTDnhJgzhgBMh1tM8SkSNvI8GJkYCRmJuAPN9POxnJ/22+l4fXXHp9Xrn//t+/gcwIufJ7z/v7wG+AqDvwYge3zOEUDSvbp6rrMa9TI5XH/I+Df/a8Lz90f83//bHp//YxtyZt1h4G1oKfe8W7niPC97imjx99zn8+Wcv7NdBYXP0yeNNz4Gzth+c1zCKfnuQhf6odO7eve/rQ7l+yJa+WTfDCxjcFBqdgzZkuu7r9ynAFlQHbeY+IjfMrJT/ebFF3j6o19iig4ufIAUR6TkgQRND0TwHnBFt6XAlTCK3tgJbz8MDqkBlZjsAgA5R3CK8F6eJYgTCUj4MgmaqVDSkrIwA6x8HwOMjJQIcc4Y39/j2ZOEnCI+eP8a8+E1Xv7jDb759djpqfaHN7i72+Pp9Q04RdkbE2OKETFKlJycM2KcMOcDUp4Q44S7u1eYDjsF0uQix0jKRg/vAsKwwTCOAMyx1sP5AMCp46k6TULSUzEqKLjg8htUSy9317Ez0UdkMlqk5yXV26fyuchOKZdZdt/i5Tmn5/2u1Oua+76bbNbqdE0OXAJPHpLzeycU7mQbS2ccggC0r6+3GIcb7O43+PzzL8Ds1C4SSvQZeReC2kSknHmeUJ1YCCEMBexS0gBTE4Em5yJ7VgcM/cxV/rV5jDFqxH1bA5KmOoRQyrjQu6ELYOZCF7rQhS50oUIkTLsZHRYeuhX0QM13bgSBpqQHUL5r3qhLAMzyfqPWSNKS5bO052tUl8oYSpqHlnkUVSJlUU5mzsUjOMYEdlXZL57EhaMXhakKRSkZs0edcc+5amAQOh6TcwCM1rAUQtA+qdCkfUZhJp1ECOqk6ComkdMoIARlxqH9UMEmJQX4qEGJNVrPGVtHC2KyMT02ltDqM+19KQnS/V3yuMt2nPp9Sa239LLdy/Xa/rYUStrPVLy9qzGj9wK2dddGSTjdHwGpZeQcEVMCWABg4qlSDYiyfsRwJx7xNWqB9bV4fSrUxZGDSD4BgAcnB3DAOI6y9qosi9wo5AHWKDOEQX29RQGe4Zgwk4ZvVyOp9LwxNlFVgDa9xkMJfMwI0Br+uQEwLHaSlRpOlHmkjqpmhiUdzdVKmb3y+Nj0tt66Hx59FwUdHf3/sU+tr4O1Mh66VlKPNNfsJFh7lsFF+dbNTbPm6EhJV8tt66rmlXqd0a6A4zpKGU1dbeSkrn4cr6EW8Nj1XctZgn/a59ejN1ndut9lViCE7DnBG/BAwDKSVkJCNjswPDkM2xH3d3d4/eo13rx5g91upwpCxv4wISVJ+TCEIOkQVkA9rcLIvpc9EgBWeJCHeJJTtFRClc90XL4pkDqA7Eq9oihKYDZgBTqFEiDGYKIAr3u793TEFwA1JVDbNrvW5vTuAZTH/V6CQ9+W1oAua+diO1ZLRd/yfF0CoavRv+cXRBHb9KsBqJIjGPrDwDKn+JJW+ZhSTUskUWTqvRYCHNq+FriaUwRrtDfvhS9jSAonibaE0nY580kV4qdpCZCxdrpaEISHF/7NAFg5M4ZhwH5/wG4nkZxyTri5uemUlcwGjLF5qe0TAI5EqgGoAruUJzWeIsYIIipKyzpn631q+abD4YDD4aA/AJvNCIJDihkxM1JiDKPwSo4Im3GLp0+e4PpKpjb48+NXAS7y7W2oVSiD23D/3/20tn3UL1pFIEzziBwnRAbYBUwRmOGBEADnkZ2ZjVi9b/U0YdmP6x6khgZ7r0neFdt7htHDeWCOBxwOEwZ3JftuOffkb0xJoshkSesVEzDPOyRmRBoReYvggcOcMbiETfDwbosmB+ni7DoPmuH2vrxDnL5AigFXAFwGBiJQGEF+g3lWhw4G0pxxOECiI+bHGuCX83L8Oy+uPDa55No5Xcpo+Qi95j0h84zdYYd5njDPe40cSXDeYRg89vsdaM8AJWSe4dyEIQQ14DU8OiqPkRs+pqzpI4cIqte1XSEwrjYJcz7gzd2XYijRNETDGAF2pY5U5IuMxBFME0ARRB6SSkssgTnNSHEPUASnP9coMhUgE4kRkQuAxtbg+TeYj+Zo2bO2jHM7hneMzWbG4f4A0ADvNG1YVhOt07EkWQcZDqypqckTXGB88fU3OEz1HTzdsrenpXTy3Upafvru9dPib7n+wDvwEBHaNW17k0brs9qIJQLFokwGSqSiWtoPXeK60B8rvZv38zy9y9X7Q3gbTmkHiuaZLYG4AGfkt+OniKnsD073fQPKZNazoOFvlsRMID/iaryBsL0BcAPEEc2pbtdSB4usFoKmH4KcccLve3AWfZ0B0I1lJyJQqE6qcqbqPzg9YzSdoU6ORWkheHjnwJRx2E/Y7yeAHLwL2IwjYgQ+/ugn4K8HvPpVL6/mNIF5h82gZSZIoihhDRGchw8DYiDQlLCfJ0zThMNeePSUJLLH4APGYQPvgpzvkEg1yF6AytpeZJs9B5A54WplyAAlgAR4jSIzSJ+XDh9VjpTB7KLWnKFWvjznmPCYch5z7W3KamXlKv+3doTKqVga3TWZWPj85bWH2yiyQiMDq+7AOQYY2O12uL29xTTN2O8njEPEELbwPpS2tXIzEWMYRrQgsVaONz0H0M9ve91IynTlN5OzTe8zDEOXDnjdkeRC34UugJkLXehCF7rQhZSoiCEkCHMFbFfABzV/5QkQkHILfgCKyGUKd+Hy63UDbSzVwyZNqIgArgoyif7SFLpCSyNSKbcgPqzGBPFjExADqaEBTCAe4ciDkZDzBGYFkMCACKRpq1TMylkMIexR4lEDdXxKSiX5XPxUqRXyGnNqaboof4SJ9J3RkzkhM+CcMP4xTcjMcOQQXIAYNKiRfBXwgwCnaTAYGXE2Br1GWrCIOGxTRtJHchIFxgRqmxNrq1FmEYCEAa9MvoGrRFiam0dYh8mUiU5VX7koa9e81ZtZ7+a/rY/t2goDzs39LdIdK9ftM1epwgrS51zpu7weZrjMauzNGJDhdX6pWeuW29VMCMRe54HgPK0os0svZL1DDR8AfJDQr5z7nMm2FomohPa3KBCSimmAoyD9cIyMGSAH5zSqjXdgngEX4EOE871SuvXSa1eErZUlnK56BNW7GOiAAFbK41TMVUn6mLtr6Q8ptJZKmPqJu9+OFc7nFclLAMIPQU31eHqson79njP7N47XT33qtALtwXa066oZ5m6lld/Xlfnt/d1qV0U/1Zu7d9b20NbIurZK6hvRR48pdy7TP7SgGT5eod04rvVpUa6NpR+BH/91xHA1IvgtvAt6ltQz3RHgncWQArZPSQEd1g8xwlZDfIbXVB+BGN4JUGR3+wp3b15hOuxFY+ec2tKy6NecR2TWPetYCXTqc+3Xot9M8FTD+a7RGmTvVB3MrJtbO/+lBXWflwYtSiOI8dDOCCgYMWu+9aRK2YAhOI1CJgARx0kXB5dzmBiAKtFKqh4nylOJFEbgnAVo6TziHCXdh55HzeKuneCEVeo3r2bc6t8agWU9+uBSUdi224A+rYK0TT8k1yzmAKnyVdYfc1IgjUQzkJQtBAfWtCGQ7+RKX1lTWkpUHyr8LnPGYZ5l3MmBc8I0TyAA47jBZuPhHRUQCVhBTY6QOCn43MH7IKk+c0LMBoqtynNhUep4nAIgt4pFA+zY6OecAGY474VnU+A3KIEo4TDNyCkh5YgwEBwNCIMo9VNKyOrx53yAZRhjbatzroQ2F1aeyzyFEMDM2O/3pZ0toL14RaIBmSxAWa1XYdvn5CLyrCBfEDwFjG5A8JIuhiMjxQRk5Y95eWLLKdKo6ps3mwrbmen4HG/v6naSla3hPFf68P0MYBgZf/Uf7jDljMNMSCwh/me6RuYtYspAAsIw4Hr7FDGK0hhqYPHBI80RJaw9saa3E0/QFhrQOjrknOGDQwgeKc+4+5px+6sXeDV47L4JTZuNT2MkJMw0YfYHxDgjJULKMrqOZoAlDdkBERMSiCKefTqDyOFqO2LcjEgz8Mv/xyNOx+Nto7LkBL/41TPcfr0FMsFji5/8+Rtcv5fgRiBcAeOWkOGRkkfCFdg9B/kbEB1AHRcqfWmktTJj1HxG9/n0XD40/10JS4AlGD/9y8+weXKLxA5h3AIgfP27Zzj8/QfIZhzgrHs9imEhpySzqh7uZvWYXz9tgDGsXvVQYEdtt7XtuJcN96Xt/eafXmD35hpgkjRMhR1wssZa3ljPpgpxyTAwg4MTCY8hZ50CtvLdE2Qyf3MB4mcr4Yj/6se974PFLTo1HxVUUXilE8Y2jxkbeold3GO4+hAuPEXMA5JzQBoani0DSHD2lxg5T4j3rxBwD+ItBA73/dExT/5YLv2YK33c3Wu1nK9zDahenjoZ5fC4fbzyucLuahvykje3duj/3wXY8UIXOkWPeft+aPTP/Ua8zZgtz7LlX/tsvKceSyqXSVKlzLaHVPBMKcdtwO4GMY/IPAggxDOIkwBl9CwhDOAckHNC9n3kDHhg1mgsRKQpi1xpnGOPQCKj5ZSR2BzZ5Nx0yOIQB01f41S36xjgBG7boRHcQggYhg2IIq6uR4wbD2Duxm7/1Qt8sX+G+5uMv/pPE9gT8sGBaQMXBsAzQAyXCD5O4CkjHSakeQdOOz27GXNieH8N767hvI4RWPUigIP2KUeQI3hNucTGrCufIJMpkWJykSNMv8qqP28dapsVwAA49fNuTiOu1ayY3FFX+Yqrb2OHOKbi0Gjfa2MWspvx2MfyXampkY3bKDi1JRp9XPVMohsQQYw0FSlB+MLShmLqqKekOCwBNsxUG1C+5MjwLsO5DPCETJKGLAQPRwmJ98jxAI4TgjreMickBgCvEVxl3BgSGcn5QeaXWZyqeC78HtRRKyOL6NysiTJjZZ4YjjKCyvfST0YYALBGefLcAMoSgvd4wH/iQm9BF8DMhS50oQtd6EJKFlmESAxg4NShuVuAhGEH0AgjetsSn1Ce6T8vDICqAeuUGKTqSxbQBog0hOJCNdQhx49/k7bXuiveoWj9UFVw5qvEYEyiEFQGVCJ1SOjBvt6m8+gZ4j4qT3MPW6eBOMeSlqcakFS4K0ID6nXUe8TgkgsjX3K1sgFhzEygc6tjwbnOk3litO0lzWsq3sNcnrOxANe8smjG3TsC4JGZxSsDrZBAqKmIesFFhCKZH/HMruPEaq0RYawd62ZYT6DpS2Ig66utz249UJmWdp20AoWATeQaNakbjhXjNv7cgI4cwBKeEoCE7lZFHmcuuVkNcCUe8SIctzWsG9JyY0zU/hGXxxScD8tN6zQikoCtxMAX/FAiS4nKOolCwTMcMZxLiDPj7m+f4IAt9r8fj/rN3ZvLML+YGqy26QfEgJmLEaauhCKuAAAgAElEQVQqudfNJQ+pYqWMx6qIrbxz5fbKl6pibZ/h7m5efFqnIwNc8ws/sow/Blqfh4dn523mcE1BVk6rR3qrAujBiKro6bb0U8/BzhYGWmOAgma69azl1lUkJRx7xhGOVv+JxXAEolm758Tj2ycTnv/8FfZzFiWbHxDCiGEz4sUnHsNmhHcCpMuNhz5pWiU5h3Ozr7KGkra0SChKSQbgSN/5lBGnGYfDAXdv3uCw3+m5Kvt8zmJstdRKnSsx6r7+cCQUKkq44/FZW2W8OBcWv54C2HD/CC3qO7dnlV+5ekeXHVH36uAlqp0rCjUuSqiur1mNouVs1j01p24RkPJUBRhirSbhGeSv7XPrgJm6Ypt1ysd79uqzREfACC4KvvVxPpV+KHjxVrTOCc9Qo67IWaetJW0klJd0DY8Bi85m3m21LTbu0mQPYCzjm1JCnGfEaS7AEVn3VCKyFPhbwwZyXrbZDmnUep2ELy8R2RpgyRLgK6Agi1qnHojNuMnzYoqWflABBMF+K5Htmn2VCCCJOJOT/k5UFP7WhpQS5nkuXn7MXNKHlvsKcPxxawQAcsoSp44IwSvwiMTg7p1H8F7lA4tcp4B2G0eQQqpk7wGogAdKXRDjvfCix8b2lnsvHsuLiCDKtcHeAHmPHm+Ovb6J+PjTHT7+M+DNLmJ3ICT2SCDENKihJYKRC68memPlNZU/t7Ur4HZS/lFGYlXmcqTrjzFuBkk7GzP2L6+w1/4S0JxlhMwCuspIyJSQU0KMATnJ2I1eI3MqGEKAbQzeJAHmPLnC9voKKTKe/SwjzxO8z6KYx4Df//IpUjSAfz+Guzcb7N9say/yNa6uM5z3CKOD84T3P50QnkRwDpjmiMyx26Nb3s3mraQlKsCMx/MOzmd88POXAGU4N2DcbOHdFr/5O0Js/ALW1oL17ub5HZ59fAuELYatR86Ml791+Oaz7VFLlvyCa773syxlGwCFifH4FVl5Gytvf7/B4W67WO9tu5a8csOLQdaS0/a65h2VNlo7uUSZMbBMC/w5Re188uLaQ2RrvF0fRnevAv7+/3qC+73DMM4gf49wE/D85wHBjQB7FINfkUAEHOSQ4J2k0QrNUH2ffP3xG/54bvox7Tp1z7layllyAixj186V3cp3sPVcVkQvky1b1EZIXNbR7jB/7PLWhX5Y9PgT5IdBf6j170PGz/7yNXb7PeYYETzgKeDL33yEnEyv9vaj99ATtscbXIMUkFx1vcq3hYj3fvY7JDDoaocpipMZOS+8s56jxndm9iD2yFmiL2aKUA1mo88VRwXSVDfGlzlygnvJIudKehso8L+NHqonbuc4KJG/C59p+6sjSWNKHt/82iO/ZLz5ooeFMIC4v0LcM+I94FyECx7zrJGlVTuXVf/PWfn/JCDslCa1EQhAxzlJ005OADPCc5nzIIAcATJdh4Af2n1XRNoiiaosqbK1FlKdBrQPSxmYV7g2NvlKZaZSo/7c6HdXF8sqrUSttTk5AtrYiivibf1lBZCzGvEUKt+wnHxV3yH/nPahtImOz9NWLnULwE6h7IqDRKYZGQnJOeQQkHPGYXeH29evcLi7x3j1tNopINGCXNH0tOXXFKIyDub4q3JhO5anAErGjZPwjhnVzlPl34Qcc5XBWFizP7pN+AdMF8DMhS50oQtd6EJKLRNqSv82L+hRBI8jw83b1dUyPUvP4/ZaaRuMiV4vs3jenUk5cD5aSVMWVJlKPfdsTHwL0unHoFXZLa+132t/xdOTSvomu6dEZWnGoC2CATVmirc0MyFJHPXjnphxjGqIRGioT1OG08LIa0amZfSVIryocc4MPO3YtsJJvQ4BvWi5rXEKMA9xKvNowklWUIkZjJbqzQ7kskIt4Ki77ux/WF2LfdnQQD2ND6zNf1NP1ggBtQ4qYJsMyacL7ZNKWmU9ZbZ2WEqlvg/t53aNt973FUBl6xSokY9UwMg9uCzGKEI5SWSfTBnea05YVRTwTNj/1yfgg+ROrqu0WZ9Akxe6epUXIAhDBTZdoySgmR48c5rO7zRrcVqOvQtPlXtKbu4/27uy1k5afFpT5Fbl/HHLlir//pcfEj1GOfWYO6vRqu/92pidKnHNg/ShxnUGtIX3MqFunw+txaO2mDIOqIC4DowjT5rh1UpqjWCtUq9tM7ivr23b4+ej0vZpxJ/9d3e4jwBTQAjAOA4YgkNOW3gaId7kWVO02fkgucZFCdNmgZdziFA9ijhnzYWeEJmBHJHmAw77Pfb7PXa7nYQWNoVlkqgYBTADFDyEKVfO8RvlN7b/rb9PxyPYXvtDvm3t+WUzb2CLegZmBQsD0PQ/9WCwc6sN2UzNmWLjm494gqZeoq7bdm7IOl4bj3Zc699lxJ82ykxbdvu3ac4RT2jX2rPOzrjaZ4VmMuka9eU3Uea29SmApWmDRUMxsMySb5TUQmKic85hs9nI+ZsSpmnCPM0grtGUCBBFsnNgNiVkVVgueYs2Cl/b39rmynctwWGV/1QvU0IJ1Q0ch7puy7Hfkbkb2+V8L/npOrZShqVhasdsOWfOtcCs4/m3SDlt3UWxW+bIS/pTSLSNzeBxfb3FZuPBmJDTXIB97blSYiKKdaT8viQqG3rPs8hv9YyRLZxW09h1XIKWt6yrlNM8e/2U8fN/F8Fug1SiLAWAnc6XU+MEYRwJKUYMARiCR8oZh8MMZosspABkTd1jKYqWcokp+C1a5jhukdkjDNNRn1sAaE4JOUUgJyAncGIgkYTgJyDlVNLpVbh01muEELwajYD3/zzC8S2CS9hsAgb3BF/99qnYV1A5un4MDWANvPz8Go5regYCYfP+AU+uZ3AekLFHjDvkHOCUY23LMumn5UHaOTp3EhgP50PCh5++ggsJ43iD7ZVHjg6/+4cRPPftX55GhVNmhvMOYXDwnpFIUhnmJnVVzy9YeWJAqLxBBbi0feijNh734xRVKLvdzIWvocXoGNiznGlNSwmQqCtce9KeHgUwY+kytG5+FOis9nztXTstedd7yt7U9BsAbr8Z8Xf/5wcNj5jw7CcRNx8T3HijfJGVWnkHgux5Q9iIQdidG+XvRsv+HPOlp6Sb/o5v89vbUreHrso//adeFqgmVgueewwBK+a1fu5LhIJljX9ssT0v9EOn7+9N/9MgHzJ+9OlL7Kc9ckoIPiPPhK//6QPk9PZm2Yd3t/4stHObUfUAbXQZ5zOe/fwzJJex2w+YplEja2u6IVg6JdWhKSS7lKRRJg0tQnDwnuCdRvd2rvC25BwoJXCjY28ja5ocIKnQa9pTeVbB73q2RAXXe5/hg+yOX/9qiy8P6rZGleds900GI6UD3LDRqJwKOGDh23ISfk4iTRIsKmEIASGMcH6DEIYqE6hDR3sWHk1GJ2ua1FvlnDK3R7JQK/P0css5WrNbwHSly+Y9UBbQp0c6FyGm3IMqvp+q49SzbT1L2exIL79yIq7dv6xnadMQHTLreouYDgm3d3e4u7sFp1zLWOjCxalF3rJOHwEAGmGYcj3HpS5uwERr+p2GZ1QkTGOxAIgxx36dOE1t9pg0XRd6HF0AMxe60IUudKELKcV5xjRNnQHBgDNEhHmeC7NsivQYBZ3+bciAFmvX7W9rEBLd1LrRbBnC38r23jdAi7cgUoVzZjAnUcmqAUbKR/lbUPCmKJfWQwQsDdcvhWJpyCMSQ2UtrzcMtePRf24MIAgASUj+nOqYWZsBB0dehSxWTwnAZbtXhC0RxghgVqCHpZAyAAc3TDUVFTQzkHPq+iCpfELHpFtdpIKXATtk/io4SYTDKnQ5J2JpLoJlqxKuY8Vc22Nja+UthQvAbGy1HOvXMv1DJTECmzy4ZlyqjVLmnZ22tvGL0/Gy1BGtsa6i8jPi3At6LfXe49LuGGMRaFvjlMxpHd+22QLgmWWdEMEFQhgdxnGQFE/eS+oFEHjMYuxPDhwdEljDvGsKNdTw75rwTBNsVY9SYkImRgJDXHd60IzIW49RlB/TaeVJL7yvlX1e8WIC2lI1fu7J1mSA8vy6srhbzaXcU4aW75seK2YuFfXrzx4rwvvn+ieWSvUj48a3EII70AqAtTRna2N8uqZjk0T7qSijThiquuts68QUbFKCedNYeeYpu9aC05Chvj0EIIwM8sB2u8XV+BM8fe8GsUQjk/Qd0wyQ87JPZAZcgnlPQ/dtMJcWMwwAyAX4F6NEkZkOB0zzhBQjcozIcS5pJmxPlpQTspe0hvYCNODGE3hN+dX2uAPNnBiVU6Cbd6xfeRBMzDrvJHyCKb0cVV4mpgjmBEvpZdE0WrCH1z265ZdaXijrGd5GsAN0/PSsAauHWIlQp3veW47JmlKv5SOXaYVE8XaKxxFqeVHh8+SsTyl3ZzyAwsN4D3iLhGLRTQpIoAePSAjzAYfDodQhPK/li5cdn4gkX7pziDFinmc4R7jaXIFZoqqYsZSIQC5oG52GU5frKUXlb9bHzjlX8rQvAeyroHWY3ZY1zVZ9pu1rjBE557JuhGeYO/645cmNxxDQEEpqGCuj5T9CCN37GEIoQJgYI3Kq7V6O/1IZbspYkHgBMykQAwBywjgwhk3A9fWIqyuPON9jt7/FPF8j48ZWezlv7TN43UzrVWmPsnWIKVX4m7qHdmfT6jmk0UqA8v9zFEaAPDBsR4TxfXzz5g77mQAEBDdo8hrhkbzTNe1mJBDCsAHngPv7iH2c4beEpOH6MwOcs0KW1zkO21szAZuNGEuQGZ7yUdQNApAVJMRxRp4nZJ6R0wSwx+AcKIgMM8dJ3xlLIwBJUzYISMbS2gYvaQMcbcA5wgWHMDxF2FiaUkJO1or+hHXEGAbd1cjBq3+rAyHyhNv7exAz3nv6DPMcIYmAehm19K85Vosi/2hW+5mUdzzDeYYfGXBPELYe4+YGkT2+/OoOKQ9NmTj6bN8ZjP2B8OZ1BNwdyN0jM2OaPuzuW0JTu/bpBdfcv8YrFQ/clXLW3gtqPhnPu3SqKM+3MsXi9/qsSsOL95Cpyg0mRxzzTo3M3PVn2YPa3np1vc9297nr1o4wMpwHhjGDY0TyU5FvS7tUMHSQPcWD5N1oz9yV9fVdaTkfx/PzUC9Pl/su6BjUvsaxHo+MGbGX8hajzujxLiu9NzO2rQVayADVbHehC70besfiw58U+cDwgRFG4PUbxvPnH+Jms0GOd/ji919/ixfxvMZmjXpOSHnPYS78HgNAyNgdRviNg3cjxmEE0QjvN8onCJiVIGmDJXIagbOzXMWd7OWdL7ywgExC4eOZGciSys9koxhj4Z/sn/HWxr+bvtM54R+ZAE6iSwzBYxgcKK/s9it6NeaMN3df48Y9RYYDuVGjEzoAHjG7Up9FHXeOEMKAzWYLhoFlmjTvzknKIKngeB46natxzf3vbVTR1gbRgvGXOv81Wrsucq/U/W1O41OAl8c+d+75VhYiIvhGp2xro5XRlrJ+OhEVFkCR24x68FGSiEcWeZVE359Txt20x363gwse25v3IE4pUAdSqP5HgVwlJ5R9VlsCACIPCRwsjg8VEHV+DiTqUJUFim6QbL1JeihAUoV7H8TBAMe2pQt9O7oAZi50oQtd6EIXUnJectkzZ+x2d4gxYhgGbDYbZfTNI7Ea671f+pp9i3oX3r1Lpq4YWaChxpfqoOa5JUK/9YhtGcSUUmHC10iYf9LwmdQBZIClRwAj5TUFeSvUqdqn5Puo9aYUi0KxGhBMMdkblKwGARBpCgFKYFjUkazpBQIcWVxCrYvM6Mlo88fL2GTEOKtBjkqKKICQoooVpXuSJqL3DJY2FyMKSFWH1bAnIBwzfObSXqAat3K2eXNanpaZdYCKYaMVGGwe0DDhdSzNQzkEX9pphibGOnLfjIVLQI0IsWYEo2oMIwJnGftxHEvaLhP8xCA6I8WMlMR4xbkF9xAcVS8Uch7kQmmbCUrFoGTPLLy9iWQsO8FF50Hu9+hTfzE4B0nJ5AjkGPBcDGwAwY2EzRhw+I+/RnAJ4Zcfgv/xQxCAxO07qe0gUe+b569jMVkIKMYi6egcNqCZamx6e1oaNHpaGgr6720ZD4m97du8VLvS0V3rRrW+VctWtoqdd69cf4geq4Ja9rUaVx6mc3PVlvvQKH7btbJsw2OoMz7RcfjfJaDlnFf32nO9QbYqBsqaPQmWWTdQ2a/V51a+f/qf7vHipwPCcAPn38O0J1AQsJxlQbLIchIVYEZmPReoyd3OpJ53DtGibcyTKnUipmnGPE9IMSEzYwgegSSFip3vKSWJQKN7XOZmX9Z9XMAjdTW0xvZuHI8AF2fG/w+o2T4NmqHystc3iBR4quNQzgcPcOvNLueb8Tet5+GyXlEqyXkiilpLyWeK0CY9UnZlbBjoQKun+7R2dvbn5hqPZfXL2d57DS6fNXBGe2blzPC+plCStlJztlmUHKrzzeo1mROcDwVoZLxh0PDTtY+kgBoDHrOAapq2DcOIEAKmSSJzDEH4ZQDI7EBkHqGVn6jdq58rn9DzLQX0tAB9t9czJ3U0ZaSiuKy8gUWBSSnBOVcAMCkeg3JacJPxbba+2jGpoIg6vxZpxvjCaZrqPSuALeuH8C3HCuMMVYZSZf2cg6T2CQRGxGF/D+cO8G4GkSVykX2vAGVKC/rdsLah/VZD9BMxEnMHXOzvPP5uPPtjDOOf/g8BTz5ipBTx1ZuI3T3D+y28H3T8CT4l5CQRdGLcIbuEFy8+RsrAb3+R8dnfB7jwFJu/2UOiR6qp2GtkwJhXt8Jx3IAIOBz2GMct5kmiDG43V7oTLeEIMnI5JXCKAGdQznJmIAGckEFdhCMZ26oU96owPxwS9vsZKSeEccT19RWC2+AQgZ/99S1SfIOvf3ODb377vIwomk9hiPg3//l3AjYabzBst4g0AY7BISFjC+Qtpj3Du42eU7rDNinabL5Yj27HEr3i1Fxb/QTC9sOXePqTb7C5eg+0uYEfr4GwQYoJkSYsd86VXbTc85u/+wTO5bJXEYA4he7Z9bL6Uquvu/63Cgxe45r6ue5HvK/H3D+OSqb6p+GCOrBEFR+5u8f6xwCWEf8Wxa/0Z+3Ksgxa9Ke2p7aNcaJnAIB/9R/v8dGfjQjjFTJdAW5cMbg1UhBrSrkhwJwlvk9akyOwuLa+Ch8u7w9ByzXSrYlmPk/tqmvrt10Fa7Jeu/YudKHvQn9AkeKPkj7+dIef/dsJYXyC7fZTDEw43H2D+ze3MND790+1DgcBy7z33/8CNGaAtkg54DBNmHjEFV/Bu0FkIg5gDsoXavpTSuCc4EEACa8chDkRYGgWYMl2e4Wrq6siZ+ScMM9R+W5tR8P7Gjim6tcr0Ld3PGx0uyxYnXG4wrjZIHiPuNe4LQudxBEvkTPevPkacAkhDCAKVlnHZ2ROmOMkXYfoC53zYAS0zpuizhXnTeOCq4Np5a6rrFF55lKG6boNdLSIdL8EzKw5zpSWt3Jw87cd07X7T5XXOlS2z5jctJSl9KmTcvFS3l3+ZiCpVv5tdSDLCDwP0bK+lj9nlR9trMfBYb+PuL17hZxmtQMNSKnyqZaiTAIcmcMnIaXeUdXsJCKXe7A56FAq+p5jThfyvawJV97gWrYGWVI7jegEgJQYi2m60HegC2DmQhe60IUudCElZvXYJWFrxfs0FSANOdLw85I2QfgUDyZCOoMkXwckoPzWMpstw7n0PJXrrmNaW6a5Zc7sOUNVtwaG1jizRsbE17YqOEXZtVq3GaRUsZ9Rc2wqR2lCQQHBsEX/cIXpTNkMBr13OOQJVX62jDrVv4xiTbAyAAO8EFAMZKZEYiSOaphLIMfFI5WcKJQlN68kMAA5FXr6KC0CrjDtMpc/VTBwgBPIRAtkImfzIPellItg0AoVBqDxnhEjISE34BATFI8FpdYboV07zBkpNd/RCGYra6AFohiVtQr7J0YVMjUyS+qlw16AJlwfBGEP5ln7jiZtUxWChmEohqrMQEzVeNeOva3B9r2p6769t9f+V9BXXvStWbMw4x0jpiRtYEYAIw8JCBHZ1zQqPdVrYtaVMiUrMhQyI9cdZzDJHZJFbFneaeX1Gq0r/PuSliLlWum9Er0v2xS2rbJ1/dm12tbvqt8aQfpE+f8cdGTsWHw/D5c8Zdo5XRcdjUPzO/cjdapNR+Wqd/xj6n8MteVx/8PJdpw0+Cy8b+saW59/6v6ux5Zp35zlHX4k+I14kKUkyi5iB/PyymBJpTRHHKY9pmmHOe6QNQ+5c9LCHLM8S4ScLOVGNcDbWeW9JsNgRuIEZEbUSHXlTAAkFYltVxpxRh7rx+HUuX3q2tIDa6nUau/7Pug0YAZ6bh6fX6ZMte9kIcEJEOBlr9hrz841Ih+g8FNYRBtnPEi7PlzfnHOK7GPFYOUBlv2xe9s5tzJyM++nlIktqKW/JjxrBey6ZryENyqR8oQJQxtpZxgGDMPQ1Wntq2CRysMJENkiYKSisGvblXU+DPDQ8jTWvTq3dSyX6/oUj2zjuKTWU69tP1DBtu3z9l547y3GfBlji7BTo9BUz0YGOoBTy3e37U0pIc4RDCmPVfFp1BoC5CEgL1KNMUuAKzMIMLgA+abpgMOBMIaMlCbM8x4pbfsxKRz78uyudMxl9Ab8crU5P9ainJ0ywJ7kAojBLiO7jDlGzFNEyg7BV0Bz8B4ZGYnlM3HAPE24v3uNzfYGyAPinuBHwuFwQHazgIy8A5LX83SdFzGDjvcDUsyYCY0RxnpyDK+QZxyIgcQOwTuRe3KGBBFilYvEsaLdp3JmxJjBHKsxZHRg9phm4LA74BAPuNkGjONwgi8CPBE21x5ukFSBCAnOA3M6YDpkABt4MvnBARYxh2t/jDu2GFRglVmYNRXS8Vlu/AkB2G5HPH1+g2FzjXF7A+dHwA2IOWN/mJGW59baGtC/cQ5d/2hxx2P5wMp71yQR3+ZUW+O81/qykCD0uUWNCghea4vuViffy7WWtXfyytpezm//Pq68t037lq1oebzrJ1tcXQdk9kAexBhjewL1IyL7FgEJ2B+iGm5Oz8S75vPX56e/dqrOd9eWhezcXOUy8/1KX+OlH3oHlnvEsr5jert36kIXutB3pzB6bG42oDBIpMUc4RxwdTXienuzGmm8JVp+eeQL3HIPR/oEAoYrBx7UiYsJwQ/grBFlkjiFOD+AvAcj6cFCGhE1wLGHY9FueecQc+U6HXkEH+DIYfABDCDFKLxaElloO0rkmRYAstSBt85yte0BRJJyk0AYxwHjKGBr4f+5O3PXzgSjed4jpi18SHCOwUmAPSlFzPOkji+xASiIA2JKDHKWPpUa+TSXFJgESzGsDgHER3KPRQ9hrrLJEjjTylFtxFGjNUeLNSpjuJDFTt73lr+tAnMYVdhr7mttFa0do6lII5r3ch3Q6387PYar0XmWeo72c2sLMTnfO+H/RTYQsTBGWQfeOYzDWMp0pPqiIr8TssayNe7LHDScM+ebo2GAzPtSH93/fuplZxUpzXlVrlWH4wu9O7oAZi50oQtd6EIXUiIFyogxIYDzUJS3ST2fO0QzEcBZDTKuY3DP0fL3pcFgDQRhKZmOmEpUJtAYxdZYYGEul0LIGkDHhBZgwabpB9dFm2mYPzNgEQNmwCGSMOBUCxHm1C0YugoOqfcdAxraMqQNriienBOhSQAhWSKgOMBRQs6mHPdwGkqUOWpe2kbNz2LEIBtH7STnaixqg35LhJga1cfaRR6wWI1MNbJJ2xURigwp74sHs12zEI6yFiRlldRRr5V/uV0zVRjqRo8ZKUco/kSNtA/5AB97uwMMRyYgSgOIubSLFFyUWmGlWAMjJLoPlXttLbR/OTMSK9RkIXytCRUdiKkxynUjQISakqmOibWjlR6ZuSiK7Z1IMeGAGUBGcA7uxR3yv/oVpt0e7vNPwbk3flXjlIyymfIIEnGGIRA0kZU16kzz7PdDSyHqcV7gfOLTOYUzLT4B/Xpc/tZ++zYGju+LaPH5lNHnIaXMeWV3/WzvSnf9KK3AOn3XdfPQuDNxzQF+Ahhzfjc5rqMCgOoI2tpq/y3rXz61RidVBm4j3tE0glnObXvvLWrE/rDHfn+Pw2GPmA5i4ISlApJ2EtcYBKznBHOWdAskkawMmJizGIWRGci8MOBTiSxT2k4kCpliMT9OyXQM2MDiuo36kr/Qlaa/d/U2b25LD/Ezp+j8c7z4XM+Lyh8I3LCcD0Axha4pFU9XlUsoZBlbBjtVtpb9v56dUhTr5VNvfXO95K0/7UkHVGWotbefE6GaDqkCZpYgYinTgbmNemL9cHDkgJJO0tqjqQ+pRr0zUIi1zdra/jZNBzDnErUtRgWUKTgMDBCLF6D3XvKnK59MBeSrZ7Nr+SVT8h0rQ9uxORUBph1XTgJwJrCAJZSMr7LIL62yGU2ZyzFuFfe2J5R2EGRsqQK4l96P9qwPFXQDXWvWfyvTgMIAQHnBkzudUyKQd/DOw3lC5oh53mOeGAcHvPz/Nph2H+D+q6vFKq3ney5/2/fd/vZnMWB7fHNvC5LUvdhWLi+eLXP6AFBzOkSEfUZMDM6uKKwdkUTk8gN+9/cR8+ThaAOCR5wHgBzG0SPlhA/+YtIhysqrq1dxVrONrovu9GGS6EJOoiflzBjCBpvNiGkgAHMZv+VJ4t0A5zI4R10HASAPShKGv1fgizJclPBSb05qBNC9N+72iJkx+BFpZjAHkAt49nHAMM5Ic8SXv9yKV2uZL4cE8f7O7MEJyB5IcMjZw7kNQFtwHpE44urHM+jqNeKbjPTFi9IjA3NDedW2u7kBQSwN/I4JngK8v0IIVxiGK/gQ8PqLjC9+k/H61YicHuYH1q6tndtvc/r0a/AU//kwra/r47qOy127Wq+d/kU/n3lnrIQKWT8u+xiMcZrHL9dXor4yGE+eAz/7y4zdHrh6ugVoBPEI5wJyVueEZpeRNSQgLnkHMuZ4j0/v29YAACAASURBVBc/PeCDHwfEfcAv/ktcb8P3QKdm4tz974rqyXtcR11bJiGim9O1GVt7L9ZX1BrxyW/f5/hf6EL/EunDH8949uGE3SHDhw1c2OD5j67hBgemDUARMe/wzcuAV5+/gKOAlNYBM1fPfwsabjUtqkcYthgHj8ETeHeN3T99eFLv0FL72+b9b3D90T2un76H8N4NDnPEFAMIA0IwLZU4BI5DQAgj4BxSnjAniRBj0bnBkrqYwICTVOtQ+bWqyBNyFp53mibkGOFDwBACNpsBQ3BdBBVmLtEZQwgdmKjKAgMcBYAcnPfYjNfwQfSkjgjOMxz26OPEtKOhDnLJ4/aznyB+fYVnPxpw8yIhs4DkY5oQ44SYZsQk+j+pWx1s2M7Z9gRnMHK5BwC8Ex7T5A5u+lEdB6E63SrzVb3yYi4XetBvK5+fom8Dllk63/Ry+WldTSvLLSPeC5+M1XTLBqRa6n8z9TL2sq512wmhLLFco+YfDhNiPEjaU9/K6N4Go/JbxAAMyGTl6npgi0to7TIZF6iyu7VnReVAwHEK3N52Y/UxQ51aLif7u6QLYOZCF7rQhS50ISXxoAUAxjCEYiQQBjBjnmfEWMO6e+9N1Xhk8FoDxazX2adjWkONF4aoQ6kck4FjhmEoYefJOczTdFS/hZoviOlG0W9VWL+YLTWE3VOZwdaLsr0GVK/a+kw15BGxKJRhOThrGQasOR4/Y0ABhoBaZFyg0ToSMoswRykhQyKV5Mzw7AGnAIYsoBoDociwCsJc2ppAnJE5l7bUedH6OasQy8U4Kv2q6YAyxFBShQfxMJB0WNWT28h7J8pLrQMscyqe4CPmeZZrZYwAcmYOqMAVM9SWSdR5qMYgmQenetI1IeIUOMXZzHIuSnepSgRF2O9luFpxPmh7NJ0JEciJkQ2AGBMaY5EfhrMC2lJYsvlpOt58robW9nciqPBL1VDKYnhzagDMGZimBCBj8AHDix3o+TeYX36N8PJnyJNbUVOb4lPWhGOG1xFzaqpgSKSqRJCcxx0Q4fsQeI7VrucMFMsRPb5jndYNCcta+7LOi9XnS/nnFg0fGr/lGLdmnKVJpzyz4sX/mPpbYMmp9p2jJSimK2ft2tkaCP3b1tfRXu/HSN+ck1EN1ss9Rd14uw3IbwAeJN4IMcAJOUfM84zDYY83t6+x290jxhlEgA9aH3ExmntViBnIltXoVGFyerDocciJkWIs56Gd+wLOrKlUANu/UQ372oE1HmNNKVQBB5Y6zxWF3RIQcMoMs6zv+yE+3iyoKiELgIxsKI/72v49XQsruEQjpICRskUV0dOT187P9XzojJWYALZWF8DMJT/XpzzC0b0FHL1QOi5B1XJdBqykRYQp/zw6IGgBHSlv0qRRBI699VrA9TzPkEmSVKUChKltAtfQz957yTmv/JQAlS11YwXMWHQcoOZ+b5XDbQqkJW/cjstSgVrBVihglzYVk4GAunJz7njqFqiTW2BQO9VHCmGUPrRKXyIq3rNEDo5q/W3/bLwt/LjNrfMe5D3C4DGMA8ZhlFRCcBhDgHMZ+7sDfv+LD5H2T7o2LjnyGo6+rlw7cajsPP2zdk8JvKTG/PWzqXChR2UAwDI6GiDexjkBwXl4lVfAGd4DQyAgE774B+Bw70HwAAYAAgpiYnzwFzt88OkBOTscJgdESa1HICiCqultv9GklEFMGIcBBIfN5gqbzYidTzDADICj/pAfJCplZjA0iiRL+ldOkqagf6+MxzeFtq1PeT/mvMMUJwx+g8Ft4GlATgHXz4BnH01I04xXv70CYiMnsOxfmQR4lhg4TDPIQ3nWAPHAFiDW1c8O8B/d4f6ziPTFi5XTWtaAg647VdAnA44veRM1FqXE6qQg4/Pq9xG//9uMjArcetsT5F2dOEuucnnM9N+POdaHoeRtPT2PYf9vx6sdxbWaumuPBM1Unun4DGf07/dD7Tc5sX23b54x/vV/znh9GwAKSHkjYCwW55OMBInaxmAFBQogM4BpAHuHlBkffhLx/nPG/UvGL/7LSt1n6NzJ/pjn16TBb1POOWrn+jFkc2Nzdywb9K4M7fpdrp5zMhCf+Hzq/gtd6E+FHnofv8/1//7HMz759zvc7j3CuIUfBsBvkDEAHMC0Q8wzXn4Z8Otf3Jwt68mHX2Pz3lfIHADaYLzK2G4IQ2DsvszY/dOHpUcWI7k9T5Z6FQIwPnuJZ3/5Bd5/8Qnu9xsk9kjZAzyAWaKJQwHwIUjUlpizRLDTiCtAhldHRcceDAdiEXbFKcHBWfRpTjjsZ8wxIqeEzRiw2W4l/RJq2h3ji/f7PeZ5hoHSazonAyQ7eBfg/QbOe4RhwDjeAGTRSgDyDI+pAMSzypotEBgAOHncf/ZnuAfgfcT2uURES5zUyXBGzhExzup4qs6TBRBToxJWqnJ12evZZIU++nqVH3pZtnUeOCffrukAWjr1rAG23/Y9eEjWPvfc0tmh/dzKo0XOg47fiq5jqf+1SC/Wr7W22v1tdP76W9XfeJN9Y0SMCT6IvCoAHZFnxfcpQ9LAGgdQ5130ChYNF+UesXXYNaicXmWU1v7Sfjb+zKi1hxBZtFnod3vucsq/K7oAZi50oQtd6EIXUvK+hrYjkjRMRikJE5JzBDPBe4JzAUTi6TjPM5zzBRFv6OeWWoaxNVAsle7tPa2yno71evU3RWibAr5cIwKNIwBhKud5xjRNRblv9y3JDHaFL6OWya3tE4MNYIab2kd5MEnsZqnPeRgTJ90y44Qxou6IqV1rH5nyn5OGbNT0NpwgoJlUosoIMw6EIcA7X8LpEwV4H5TRtIF1SClrGEYx5NiYMqfGmGRML6sRqWXk7YMCQbgKPjZuNZ1CZe43m7F4dM9xVq/jiqTP+YDD4dCOAmpkFtL5r0ayWjbDUjW0Rql2bXVGPTQGVTNoNvNAFnaSxYtk6Y0NQELOUrtGgJrnV0WHpu1t5B4BrYmX4mlDYc1t3Hs0VIGlU2OWRxkW/ae7T+dRMiJksMsqe7NMKBOSegbPPmM7BgS/BdGAuFBsakwEjUeRIX44uVOq+gKZcQhgJGZkEphZPuOR/TZ0Zqt4izKOFfFW9rehdYPBUnVMXc3tTB2X9dg6K71N29+luElH/6/XDRqwBiR5qC2rinKLAHAmRdIpWhpqvovBixZ/AXQpmJZ/lwYEOmugfbgdzVaMMGpqP+eRMoFzgnj+RDgkpDRjmva4u7vF/f1rpJiK4k8yzpk/PklaxsjiTA1RnOTM4Cy5zitIksv+JgbfBG6iEMQYFSwjlDRsc2oADCEIyNBG7SFgrlyvCrphGAo4VsADcfWZo/FbUVB9GzpbFzNqdJZWAdTUxb2yUX6vP695Hx5Xk7tzSECSqUSkAKC8S3suMkDrgJlT/ZQmipH8FOC03luVeuSom19rQwtmblN91TDWld9zTr1COx6Nym8MaBrR5oxFjUoIoCimjf+SczagxicBgq8h1KMqwB1knYYQ1GNS1t00K2/GXnmm3PCnfMTjtf21qIhrPHIZNxtjUr6ruWU5xgZKsbHMOUvqMw2F0dbTpjFtlaumYF4DalkdIYRO6e291/IkYoqN7Waz6RTFBs4xucE5BxcCxs0GV9dbbLcbbDYbPLl+gs1mC0fAdP8aX///7L1tryRJdt/3OxGRWXVvd8/O7BNX0i5JEQa4NmXJhgXYgGG9NOQv60/gVwYEw4YF2KBlU4AoypQokvswMz3dfasqMyKOX5yIjMisrNs9Mz3LNVkH03OrsjLjOSPOw/+c85dvrzbp/tzeGk2vjai9Yn/tL9uiH9QV0CLL0N23V9YyLh1QZnu6BREeBs94OBDCwOUpMse5gNUn0jzjDpnQ8dpoNThY7L6U1IwzCE7F5pLCz4lQQn51rez3lrI3i+DEkxPMU7I9fblFEZdxIQEBN4xkURIR9QGcBzVAjxdBuve2B8f1stGyZ0liCJ6siZjOaMx4p5xV0QQPKozhQCjpcGvrPY4UHT4IzpvMcjqdcC7jw0BODsKR49DW6DA+MD4o50NaeieSTd8/t7Rs65nd8Lbl7HaARmF6ikyXJ8CcEeaoDEewNLZGaVZS3F+Pv0na7sbb7336skpfr63t3el5OVldX/N5ii3BFoGyq/Vrg2ZW5pTuuqzuWfft+r6+NylnnubMcHzB6axmPHJmBApOcSRz3qjtxaF4UEfMgAace0S856vzV3z+xRNw+ICx3Ofvt/24XqW36btad9eyzPrqLd61STrr78vTWvYuakTS6/tu0+337W/q/bvT3276GPqGj0X772RPursnfnD5AuOxRFihB2nbv5iVSzzy8PL7IAdUBrJa9LesBupNOVvaulLecEiFP2YxpjsRHl/8Dp/98CeMx5eE8QEXRuCE44I/baPSPD8L9QxKMTKdz1zOZwr2Be8CZE+ibjuWsnUcR1SF8+XMm7dvSPnCMDi8D4XnOiA6gjos2nqNlC14AYdFoTw9PZFS4ng88smrlwxDIMbE69evefv2zQqgXyPLHI/HVYqiquM2IM+A96bDDcOAD870Z0UfnDVbJDytfTfnGNFM6tOfiyLDbHK+s/Q7qCMEh4gnx5qeaWaeZ3tOSpJ18biSxrM6D6jkIn9ncrZVJi6XMiyWdJW/FscMO0CvQCA9aKb+3epB67+vK5/XdfY+yMxW1vmQeq4cG7p3ZAuK6aOcbnXSsimrT7XUO3lUWTSlhPiWJWBPduydFNp7mxcZ0PTO9nkYR5xXlNlsFNh6NrB8r7PoqUaUrLLiuu7mzNKire7ZitpYUtZV5QTo6qxzr4WZaPqR5dqdPgrdATN3utOd7nSnOxXaM85D88B1zjGO4+J1GmPEe6geu/Xe+nfrbXrLALXNX9szwCuP2A9gbkMIV2Hot4aJGoFmz3t3Abv0v7l23cBCvgAkihIbJWsVFHQj5JQ+dsxrHYY95rUygfW+CsbpmeTCFlraJCz0f80dq9m8PLPTJZ2F1eWLUNfqt+ss96SUy7ymjomVpQ/9HFbmvTd69MANLWmFVpWJ1TQMAYtQ07yM5zkCyhwnck5ljHtjWV6tkxbJxsastXHbNwoDXQSD9uv6mcX2VPpbw3Qvf1mY8m2/V2CZK6AM3XXp1kNNV9UDacw73TBWJnzu0R4Q7fr7RgWpa2G0lrM1tPXjswhwWRGLNEtKGQiM44FhGDkDvUFxa3SyFarMUoSyclf1S/EIAUdGicUgJfK+N/1D6eOpsa5NYd+M9tVX62/XRr1v1osPUbp/l7Qe/X5d9P9fG1jg+b72ZS5i8zPRYNYi9rW54f3zcVupsoa+7N1TQCpd39zquffVfD0u/bt1PWLXfRbg5Y8iv/tfnwnhBcOhpsszpWnOkZQuXC4nnt49cTo/oZpYDK3S11G/uGXfqAqvRdGpbU9ewjCjpizLVs4WCLt4et2YjKyKd7IY37cKlq3C7JrnaP9EKADVCrjs98+Pr2G5DZiRRVFY7uz+be7r/y/rM66v5yZghsY7GZC28Cu09VXLrHOWc0ZcNWVuWrQ5R1r7raAWGWc9J70BvW+vZbq8jihTPy98z6Z/WwDsdfvWaQ9N5XZ9dlaASFVG9wCOEDwttUwbqNqelBIpawOKxwpihjmacnEcR5wbluXV0lsaP1l5nL5fe+O9HZflXwEs23jkq/GtIJY1/ySFb2dhlGp/tkrofmxr7vpaRgMsNSBO374VuCm0tlQgG5iRwCL5NCWq92EVKbLOByL44HACl9cP/OX//vdIcwP2b1Wq9fP1nr6mwt0DBXgCyx5pnFmF/bZ7ZWff3XsD+52z3/2D8wze4QXiJfMn/2JiOmd++PuRH/5BxAn84X83IMDT0xNfffWa07szx+Mj3hUjSbaojFr3EgUpQYOUlg5zj3LOnM8XQnCczhfGPBQ+tvSwnKHH773lx3/4HziE3wU3MkXb213wtq4Jln5WlZya/Jez3be8e1pOJNN+2zsyT6gkvIw4b6mAzcPV+MXgvPGHvcxy8fzl//ojfvCPXnP8YSRpsogfOiM4kkZinojpgncGCk2qyKczr/6bX3OZ3uDchRDeEr944PUf/2f7c1aM9tdcA5z+6iWXX7wgC/zSCVmUz/4g8/P/XjiMR2QOeBz/4V9f+Pd/cl6tE3a/fXd0fVzc5hd62ut3f/19p6Ws/t0GRS+i1bZt3b3blJj1TbwFjutbuy5/++v63V+9q1mJOeJ8BifmbEJCuu1Zyh5esGooQsoKOMbDA5rFQLoEVD7M7CC7n9f86l4Elt80yebblj/dv+/58qSf0wJQ6/l7dwuAI+vV2q/sW+v7Tnf620jv13rYjvFN943xmPhv/4dfgLvg3cAYHlD1nCfhdIm2bcsj4kcgoGqp10W8AY6LjqvWPRwS//if/TXn+Uue3p6ZZhAGhvGRTz79EcfHT/DhiLhAzhB8JniHDzty/3v7bjzoEAKaE0483ruSrj3hxAAoWiIvppSYo6UpttSsnhCKvjuXAI2mfi06yhqx0RwYU4pkNWe+YQiM40DKkfObJ06nE09PT1wulwU8oWqyxDiOhBCYNtHRK0/uvRACJqNJBImICs4pzoFXh5cuSgksQCDV5pjmQuSHP/9XfPLZpwzjpyAH42ydkHORo4TCyxUdZ5PwdvmC9rkBYrai6SKfaHtCtXfQ3AfCbOWKZx1SYCVXrcrB5ivv6mmvP9fvz9W31Uk89/st2toEbsm3VfbdjkPqosLW+9YpsPfb5rylMs5a9Da52hQ6Od05hjDi3Mg8m6Pj7X5QFlyJQKPszmuvh9mO38o+g5VXozsut4rUhV1u0qK7eu9Q3+lr0B0wc6c73elOd7pToaSYZ1RlhLUamUo0DRGGYAxtTIkYLTxlGI+LoaEp3a2c6sEI1wxRNQT0YJseeLBFnBtVL4RcIuIUxje3CDlmhCiCUEqoNg/lWpYZSaQYL2r7mmrFcrCONhKrdEzK5XLuwuqbccXy8E4FiW1e1ibcBaSEJM9dSosiuxgDmHtVex8thRLxJRaEvjG+znt8GAjeW0ofp6hauMyUiwIvZ5wYMCMlJc+RFNxipKuGwurV0YfTPxyOK5CUD0OZ11iEJuuDeDM+ppjMg3gY8X4o81OMk1Uqr0KTKpJ08XCm3pciOUUT9kJAk6XBCiX/bcxpiZhTle8VSAPN0NKvr0Vs02KwXQAzZV05WcrsQTNNwGvCXhMRbcy1eExUME7N8Wrtqs+4arkA38AyIGgRFHIdExF88EWQqwZOVwwQxSDnPbl4YRsAxnWSQ30P1KLxS2lxDZ0qptRNujb7mPCbEdcEjpKlBYtYlKlgmyF4kibOc8QNwuH4krNcK9ZdAb1YpBktby0kUeKSz7aF4iz+Kvga0lwtvGj1ev1Qpc5WWaJXV/ehD30dt+SsW899KN0yPlzfo6sWr00b//+l3nBSv/d0K5KKHSPXIKK9dbEd4+fHrF8d10H7bxlibhkwtsYbWKuTVkaj7rp27ej/7q2Ra6DNVmF1rQhVQHzg8OIl3o0W5UzBJztrv3r9OefLO6bLhbmkTPIhlDOsG4MOhGdgx/pLb6C3PcgizfT7LRYBzRVlSWmYCrYPlhSHPT9g269tvha1JhOj5XYHSsrIsEQ7W4Cu5THbkz0pReY5Lfv/kjbPebwoqq7t9UXR0gxotPY+97LfAKvsKfzW1NLQtf2wDMxCUu7rzradxlSD3Z55aAVVk3p2Gp9C5a80dUot679s2lW7WM+TrvtNEYbiPNRQyxWAU0M5N/6rzZNzviho9yOu9J51DUjtcWKg4UWxViaqrocKqlW1N0+KZ6PxT77UV9Ij4kCbIjKlyDSdWTwiS7s8iqZo6XRyNr44uKLA9ngvTJeJp/M7ql98jErKxiurKsfjkWEYSKmWaiCFBp41/rHNfwGooXjfAOS2pgsPUyAdmnqwtaxA67XsXKJLiXMlOpS9swj4wS8glRqNMMfCCxZeQjv0QgmGtyyHGGcqf1X3AycOKZF+nDOw9OUymTcrFTyXy9xUk2lkns/M8czTE4gTi8JymXl4eOQwDpzeeeLkr87I1VmxMqTq1f/p9n7pnhGVVZQyuTol1rv7svfvgX130jEBDGPAB+OzclLmizKdAfWMwZW9KvHu6Ymn05mkyvD4QBgfEAmAeWxbWqKIlhQxCjgpgBeJUNK1tlPR4QeTSVKamaLy1dsvOIwDlzkAY9mjrf9uGDl+71NOTxdinG3de+F4fMFhOODw5AwxRuZoe7IgDGOJwOQcIYzMc2S6RHLEeOjkeRw9OMXiDQ64Ail1fkC8I6lf4pP146kXIcXEHC/kLAzhiDISZ+V8nrjoV0w+MQyOMCRUEilnkrOoPeNhsDFP07N8QgXN9Csoo2gSJDkqGDGXNRM85DxzOAi+ROZp63PNlXwd3vbrUs9vXNM1b6Ob6/23uvL7HalxA/3dfRqBAlTR9u44qFipnZY0jqovv0pCK6BNjbzXtWaPF/xQ3nkrN9RWiHhwD8R0ADE5vvKjcam7rAGxyEVCxHn7TdVbimQyqmOZ/+mq/lscQr+/bMdsu3Z+03LCmkO5BsPvP3PF9a9+aWByaZF7oOM77P+VN1n1dbPH5uXLx3K+uNOdnqe9feS7oltv0tcr4Zu+GUriiafTawb3Cv/iJcG/YBg94RDIEkgyEJPteUo5Q11EJCOakfCAuMLfK3x1iYTxkZc//IwQHhAGS4cUXuHcoezFghdLCy75RE7ze9q5T8fRcxiUp6cvuExCzAFxL3HhJc4ZoD2Eo/E0Bcyd4kSovG42Bw5LGTpA9uSkxKimR4OFP48p4tUvfPv5/MTbd5HT6Yl5ngl+4HA4kKLJXybTBmIS4nm2KDLBl6jVhdtQNT2ZN52gqnKZnjgcRwYvBtpxpv+t+3I9T2v0Z1GL2uG84/u/830eXr5A8wPzPBZ5IJUz16IdzvGJ8/mdRbZxgSWCeJG7q+OoouYAgdr8LjYEXfTd1CiNuuGH6nNicmOM1bEF7Dxt+uqcdfmtyp+tHNn93K/f2q7e2c/60QAcy710oJQbgE2RJiH0jkKLHBbWp7npny1yYtaqvxacCQSAmk48r9PUbh1HDMiUF5tLGMIK4FIBM7X9W9BKlRVjSnay5qpXN52LkcdL4Hh84HuffMplmklvT8RYd7z6zy1/F3BO52ci4hddi61nS49sy6jaYqxPqDlqatECVztMnTVWf0tdxUkma/n8AQClO30Y3QEzd7rTne50pztVMusFUJnD7qfyu0PA2e/ZCTFl4nwhjCPeBWOdFiaXhcGF5iG+NS71DF0fWeaK8V2M/Vqa6tYRaDpGsEdeV1BEQ2uD9+s21Ou9EsctHmE9U6iFsTNmsRqCqmHNFc/dpY9SjBRqjF0P0FCArAujuIx7NyY1PUIf0cQMPqG4ZitQPO5F8OIh27zkVAxiauhxXTy1c2l763MDoNRxNcOqouQshTE34dc7KUyuAThiMsBSBZBUoxVS1VWFeS3rICddQCjifQH2KOpaOP95mnDB2/iImEdIVaZV79VSia25PuJMG8ve6FbX0RIRZwWwYRmfOnFXKHcRvFTPDVuPtr7aOrb7LZypCVGWtyTntKjumsf72qhZDcyLUKwtPYZFdhFSysVQVg2O67VT11lVXlfjZj/XVcht1Repphquy23UtGElelHOA5nM6ZJxPvD48Mhn/+lb0iVx/uUD51+1fNRVfKzmL60mmxIWtir0651OLX2aTWkFzVjagdqcb057T19fuyVe3ar7loLsOTGt92TV1fXny/4ujSvfPcnqrxlSqpDbGW82oBntfv8Qo8dz33ulUd8iu7ePFtBU7LdWzXZe2vVmvNne0/4140J9pta35wslO59uUXt7uzEFLJLEAbWDG1IizjOXpxNvXn/JFC9l7y4hgsWZYat47my9tExhVT+3iBJ1hGOJclbfe7shL9/Wo2vK1GX8pUXTqJtWNdyrVoBiG/W1Eqnrt1L4jZraxpSDtT8NIGnG2mV8hU1Z+t6hX0A1X5euIiPJ5m9PLVf4zeQZsvleSxPXvXn9U3aI9OxY/1kI9DuP9nNWLZ/a1t2iEKWti8qrVR5j2QOW6ZYlgt+e19z2DF6u55Lur1OWWprC8paJ68JdW8oZXKnL1aguNU2ZKwDrGjlwJsaJrNHSvtQ6U6botUkxghhIZhhCiRiXmeaJ8+XEPEeyKkMYDAQsvgCGHDHOpBSX962BzCuvsl7LjdesY9fWsPESlupTM+BM6ZtL+h5L21PD59c0S9XjsACaECQYj2jpIEv0GzFjRg96rcrwfg4rYL2l/qr8jZTIir6k//SLItzGIHVgG2nrEQxDlBK58GEZED8TkxCGtzwcjoR04MU/cJz+6hM0rXk/2Ds7GuhF6zp+D21BM7efLHv/BmCxtKOca4+vIj/+3TNTPHJ4GRaPzozwg9+LnE8zh1dCTiYrvXn7hvP5YqldnY1jRpCyRkRMuZwBFSmKYizCJAaaUSkm5nq2ijkXiBjQBuAyX0g6k0Pgk39oQBdVA7yPLxNTOqIhGDgMYQyeh8OBIQRISpwjuaTkomwNznkIUsCLFD7PoUHwLhCDQ70wvR6YXx9JhqBkdsLFC6fBWTqmuQHWAMQrh3/wluEFgKWZzbMjq0V4svShE0ki8+wMwFdQ2Znc0tgmiNHdPO+XM3pjJCkj2532ds3jGV0BMMWZKc9mRFtW3c762qn325Js/n0d+tC2vK/cuoOJKK7KfbAaie6E3WlvjZtqz2x5oz3QzLb9t/jzZ9stiixR8lwBox2BUGqxWJhGZd+VLszAct5BKgZdkzMPPLzw/O7Phb/4NxMpPs8z9OOwvW85b7sTef3bd0tr3nYfLLPmr5+fhy1vDNWw2++72yf06srzd9zpTt89fZM95+vSh5Tf2vHdtKgCBOY58nQ6MQSPG16BjKAWdQ6GIn+WdmhE84WcI+IOfPYTYfCWevPFieRa1gAAIABJREFUqx/jB8cQDnh/RCQUUPAIGsoGYZFPc1bynJinCAVKu+3vc70+f/4pX/6pMOfM4e//NZpnYMDLI6E4FVZ5wTkIPhGC6Va9Cw2EXvVvTm3/zwZK7mUV7/wSVTHnxBxnTqcnYowLSKLqsqueXGn6Q+cHhsNoqSc1EuNMjBHJGV+cRE2zNuM9nH/tefoFaFLSvD8Cq/1bHI+PP8CHgTiPODxKiVKeImmemKcT83wipplhOOBcwEkw/k4ATV2pRbfbAWV6nbyuBcxFh3kdYb1Fq+wdIZsuYg1s6eXAraPKGjRTZBmtZ3U5Q7X/va6e7d9bo1i/t5OqybpFxiy66d4pyBfnjW07Tb5dg1z637dOxs1hZD3G/bj1EWv68W6ODR0YRarOwKDqqolxGDgeXyDOM81vSTmuxqU6eNh70cpvXE5zoqg6Hqn2jC5dsJVh6bxUikyrrBUTRU5E2hvfDeL93P8O6A6YudOd7nSnO92pkHRMi3aMaTV2SQUKlOgsQwg4lzlfZoizGQBKZJdKZuDXJYJJAwGw+l4NJcMwbBhoIy2GM6Exnb4wm5URrHk8x3EEtNSdcC4sAIWq1PfeN0PcDkNclfg91VQ8PfCnD5ePSEHdN+NQ7V/OCs43IaMYA2sUjV4p1Ie275njHjAj3gSsvAgWqYBYigJYzQMzkYsQOpCzpdLKV+mNZJkrM/5ZhBsp6PQ5Jmu/mIez9744vGupLzHnRIwJNFJc7AwEA1T/0H5Oq3HGFcV+1WgLlLQGRbBJGR/My8KAOdqBZVgx3NuQk/3a6gWV5V5Zp7rKybxQXYdOvxJYxNrqq/FVcwGz5JKqTHFuKAaJ2mchp7mk7apruxnBlshMOq/WQQ/eqWnQ+pRn2zG1Nejo359af13TtyIh6NK2epGmyVQtBj4rY46ZyyQ8PAx8+vO3aD7z+f+lnH71uBjFr+rADG8JxYkiqiUtk4llAVdNekTNSAkPmsSRPwpoZr9NlW4pV95X53bn2FcZb5+55fW4p/6+3Yqv27YPoY+vXpPV/iZw5S0MnXGzMy7qTmSZb9uWrWFlq+jXzd/6WVb3t1cDLX1b9jpZ37N4vsryW70u1H5Xr9m1CWR7Lmx7sv28NRnV74IBNQ0rE0nTxOXpxNPbt1wuZzOEO98BUNu+0c6vfr+RBTBTFVzrv5mkqbVg9fv7V9fWW8x0k3bWjOO42uer8b+1rY1c7UeNBue8eelZmOu+j2UP7uqunlcf9kasQSffjp6r65m2LEt7u2fUsbkGFCylrsa7K1JWcR1whQeswNr+nHHCovzt02b15/L2zKqR9JZZ2/B127N3BYDVXIC3TTnYr7O1XraeswZelbI26K63tEJziaIxm7HXgZRw5GtQSy5jaoCZCoSZ5wvTfMHekYyqrT2LPmNr982bN6SUGIah8Lt1nqrXn0VPXIOlt+G5+5SSxktqN4ZkyNp4hlqWPV+VrAXS6hwheCrwxpSOWk7rqsAXqsuqsG0LNLhf2eEWBWodWzMA1HSpxu+v01pmTai2PrPEFZFlrz2dL3CeiFPi1ePMy58q51++JBfAzLLqd1Lytb2+AfTWr+3tvbZ/fntXgzlL+btXiJ1rx1czP/ujd7ybBrIq86wFIAXf/1lkmiacc0yXQEyJN1+9Q5xFH5TgQBJZJ9uz8KDFGQBFF17ajPiacxkH82Q1ILLYdzGvZZY5V2JWZJx58bszOUZb386B88Q8cnh4wLlgRiDnGMXjHCVSUMaJR52QNZZ3p45VBr0gJIYAXgLB2zs6C0z/ceT85y+uZmBtjG9/Xci8+L13DA8ezSNRI3E2gI9mj2gNJx+ZZ0Vni+QlXnBByDGS5mQgHB0WQ4FuG9DNfU9tTa1/ceIY3IBzgdPlLdN0IUYHjDulPF/HN6WFv1it0711rVd17/Fa27H/UOpPqu3n+n1b71KXdm2Xev8OOKQDzezBkpY5/YA+9LzS0kIFzQ5KFKdWjlv2RaMadbVGx6XI5glxZmQlw8NLx+/93PHX/+9MivszLlf/X7e9H6vnQDPXffs4tF4P12CZ1fu6Ab/3++62fXtzc+1WsF4zbX4/ZBe/051+M/TxZehvRt9VO0SEx4cHjg/K6SkSp9eonnkYR1Jx1lMHbjiWN9jA21kzOU7klBnDwPd/x/GDnxi/GoYXaIaUxfZa9cUIHzCjfYNtxzwzXybmeUZlbDqED+zvu199ytOvPsUfJl7+7Jeou1g6R0kMNc0l5TwfBkQyYTaTcSgRGFWVOBvgG9EuN1PhAbWksBnGkoJeiREDSTjPOPrGt2eL9lhyWRUZKOBDKOmZjgb2nSHpTEymQ4spIxJBEsMI3k88/WLgr/5Pc3Qo0tCyizaHlX7XFBwPaHZo8pUVtHMllSiP05mUYyfPucJfdNFZi9wg0vQAlFqaTNlxJNJkiDV4Y+ssaLRNv9s/35e9lUuu72MZCV0iyuoa8HFF1/qhrcC/eq7XvyJL1KEtOMTSe7WUs30626xNx12fXcvNfrFHLP+cXN3Xg47qGPa68OpM1CDpeZE3TTZXUowcH44cDgculzPv3r0lq5jssEnp3OFYaJFRm66lynb9v759q1laZG3IXarvKu9Id88+/Tbswn876A6YudOd7nSnO92pkNCU71Q0cDFUOalKuMqqWBh6cY4hq4W7Tqkg8N1iVDEBoIE9tsCF3rCyAELcvnGnht/33b0rJnMTvWaNNHdUT9icisGBDZO8a3Bqhptm+EmLYbECGaqRB2FV58I8SycQZF2Mc6rmLbFlIGu7eka3MtVJFadaQup33tdZMA+M1o8KCDJ+VRZNpQE7mjFNBPPM1FZ3VX+F4EqZuYRRbeExK4ClAlxSslCKiLQILrIEVbS/YpF4pHrB5lRC+dvKsvmxskygaGm+GoO/NtpU4WErcO15p+fcUlFU8Ipq9TRQSxNCbzDt1grQp/LKqTfkuRLS1by121wWo1c12i0lrQEzNS1C/470xsYKKtsKHK3fdY6v11Ht+x71sl5/T8ppGR9rg1rqKRVSVM5PkYdx5Hh8SRiOKGY8yjV07DJ6a+WmI5c0TI4qegsOUSFKtm+aDVyDMktf1i2wyb6C+Tn6GIaK/TpvwRyM9uvshOONwryPGvJ12/shSqTtjvcxFG3XCvUPL7M3dnZv7o4R5uu3sjcx9G3s27016Fy3f7/e7dVq+FmBhVgbEigRCdZlb1v4ftoqwhQII4gX/KHsE6hFwDg9cX564nw+451F+KLbR3pFzC3ATEsZ00cA0eX7zXY+89uecktt01+uV+++5Szs8nOv98w2ayKUqCI9QJLFiE+nzLH/6rl4pRe70Sd2b9xXvn131AMxt3R7778GJ5dfrvq/Pm+gnWH2u439uq6ef1m3s/E3LHNQU0Pamd+f5X0kwXpu9iHZr3kAaesYU1x7X1IXOYPwtjUDoCX8taWqEikA2jkvvIZI5TUrz5BQTXgvZT0JwxDIeSRnZRzd4mHar9tKPQAnhLDqY39vbWcPml0BuzCluxZQzML/aAOmXxkey5i6En6jcmg+WEqdlCxShynCKx9bFKBLWsV+TTS+pgS3uZrv9r16P/ZhwbXIHSzlWfomSPV9dA5cwDwYzQN5GBzjgxBdIkUhxT512TW5YpRQ0W6ff/7E69Py7KUNFNRSj1YlPG0PqRQGS2PkBojJ1kuMkXmaiTEX/jsbcFE8KWUuFwvJ77yzbruMSippOgVIprTGWZSL1mAW0MwSPctDVTqrs39Z0GxtCSEgzpTjU0qIDIxhZDiMDKOlWsXZevbOWdrNXMbTOdQ7lAgaLfuCKJITJHtfNCd0tpRhOMUFJXiHGwJDdXygypg3yCviFRnUDGpZSjQZyp7hyjsCdTkpJUVgTpamNptpIIwDXgA3LmtlC9Dd7qYrM1C3HurnGCNxFg4He+dHPeC9ds+vebg9vuPbUD9+23HcOZ26T32L+veiL/e5sm61peeB1mV2yRpXrXDdvWVbJkuDtz3P+8vqnm86pkXCNcOUaImWVyO71dHpRkUNOGnf87L3Wao8Ke8bJXLfbeDqFuK0fyqz6d8+aGb7TO3Xt6HNLt61cc3f3qLbEkwPNpSrq3t3q7SoQ8+5HzwnL97pTt8VfQwZ+mOUXfeyj0kG1X3B8XgkTW+4PL1hzsowzmS1qHmWYtEia1t634RoRFNEshJktDtSAfWWtCzeuG+Q6pRR+Fu1M9cFCpggNd3vZjyq88lzYwJ2BsUzZPGoM/4ftESz9hj7Up1FWWppToW+RaqUEu0Pt/DJFRThfVgihjvneXh45Hw+WaQYMZ7KeOSiFfOhPOc5HA6Wor6kNnXUSJCeHC39JEQOn3rylMjRAQHTxenC09S9sCYldgOEQRkOQs4ekvGCjcsx97acYkkBX+W74qiZ7R5xvY5bQCjgpl6DsTMHnWy31q2vdbb9Pdvnt3LFVs9bZZxdkv4s7WXgLVe2/b5zG+tTTTvUSAWy9LaNXq/ft3Upupezd5pe132LaL7WC2/Ho6+vB9A0ORwqYKbqibw3h2jvBR1CSSMcuEwnzKlhHZ29ynKr0drRK9R7bgFmel3OdixaXU1XtA+IutPHpjtg5k53utOd7nSnSipmMKoMcWVmK/tbGBNXgReF63x8fOTt05Mp2X1alP2uRJuxnLB25IrIYhyoDFwVDlTVvAY6pqk39ueU8K4xWDlnpmmiIq5rHTHGFtUFA7i0ZJog4lfqnmuutIlUjRmrKHRZ6rbIItWYk4tHZQ3x3QkCUox21QhiHOMyluFwWAt8OwCPLfOLQE4mzlH62WyYlgtVaAxoXmIbyiL09Fx/NYD6IhSZ0jkRU4JiIFMooeCt+YrDiXltBl/F1pJqSGoKDGPGpUAjqAo+1WLgyXVazIs76zJVKUW8N+NBNosUS47ZftL0WilW10Qdwyvmva5tJ6A1nRYlck8uNqFiRPKdkFN6UQE+VX3QR2dyUiIJ0RmgnV0XqR7VfR7euq6u+3BLmFp3pV+j38A4WgBN1fiWc26vd2cQq14ytvaVNAMa+fTTR1IK1KQrK8NC+b6AaLSAY0qUmeK/jhSRLagF45aS4gK1dRbL83JDDb69sjV89J+1+7T+bat2+XCle6/q3hO9b7Wz1bQu67rN39yksmeg2f6+NWh8G6rq874fq5Hdpl7q0zLdbOG1wv6btKu+sf2n/ZpuhcyXq/kBukgy2xbu379XajMQ9GtobURZGx3qu7avHvz9f+r43t8LuBAQVeY48+bNVzy9fUuaI5rt7Eo0gOFWudLO0j71Ut3nae1QZcljvqO4uqX4Wvp2Y0/TXC2fa+N6H6Wur8eUSBXQ6sm5ADGd4JwuoAOLuFPP6aIAktaWPcXTLfpNA2NuUQ/QXJ/tt5/p+Yp1WRQeoPExDWDil/t7haSWaGspxZXCs66fHgTSRxZZlG07a6A+V3m7noJvPGVTsPnFWF7L2O6uToTgQjnfFTST8lz4xYR52WUQC6GOagEBeIahRjgyMIf3FfQN03Rhms6oKo+Pj0VRbnzo+XwmpthAPK5GW5mX/i3AF808PB5J0daqXTcgtHWzgJUX3jAv/EuvULRQ8DbW0yTLs5UyxvdZ+Hkz5l5iKpGCBPHmqZrzDGoGDO8UX89vAQMJt8hUIIhvKc5cF3Eylf7X+b4G47mFQzSWyJUokLYggxs4Pr4y/kocx8PID3/4ip/+c3j39hf85Z8c+eWffna1TiitcX3kik2Er/6+VQS07v6ra6vRbKaGPRPtH/yjX/PZjx3qjpxOntfvPiemzDSZQSL4AWNxjW9PKRNj4vHxEQQSkayTRaQUXbxWKeCuGi2Toqw3ecOBBlDPCjADTOcZRTmMB3xwzPMFBYbhgfHhgPMHgveEoaQcc0KME8E5vPjCrSmOQHDgQ8b7mSgTqomcJ379p4HP/62zdwepOB7bQ8pIqkCOO4r1zZgCHH7yjuPPTng3oD5wPkUu00SKqcga3YtPiQ4lDvWBDsfP6AfG4QA5MOfxiqfcnrhXvOUmjWRtZ5xnLqcZ7zzTNOOCJzioyYhampmey7j++yG0x1cVznrT+uvP12VJN97XfW4gnEZX8hZAByz7MNoHKC3l0fhSkwYacKb+vwKW+tnrASRfZ0zrzCx1q+J1JssJZaCBz0C76FfLu1X5CWxvDN4DvR4CpkvePY+veeX+DbhNlVOVzb3fpQlJ6Nt7zfcubejWQh8FYvu7sKgw2CZT6b9p97fngK9TmW655N8+eo5j/G1s752+Pq1X8ndX9jddL9/0ufPJ8T/9jy9BQPWTJRq5pVAS/v5/MvOzP1QkHSEnskZgRrgwuLPx0zER/AEfBsR5wIDDmqXoz0aigg+2z8aciRpL5NJswI8O9Nz3aXuOtH/r2cjTwK//5X+BKIw//QXyu5/z9A4ejp8i8sAcYZ4TCAX0PiwRtr13ZM2cTmcu06UAnxOPD58U3hW8H6ip4kOwdJU5v+NXv/oVFkXS44NbnTviHGEYGA9HhmHg5cs6zplh8AyD43K+IOp58+88b/4s4Bj53IHIgc6HYCm3SOVUGIuK8tOfT/yDP8yczy84HB+IUUhMaD6jOpPzhTg/cT6/tRRSU8QPhxKJtkSj9a6Ao9b6x1z0upXXW9qzAcHsUQ+CeO7ZNWCizHV3fw+42K2njkZNHyS9g8iW+xDodP/13nW7+7pZopS7BTDToqz3bYrR0jtWG0iVkVNKJEp6640svTdWVXc7er84L9fnenDMlha5Xn1xAgURxZc2H48jL188gibm6czhcODFixecTheSmpMIZY1D1c3Lqmxr61oW72X7VTu6dpqepvL1JfLUwtv1Wq99nupOH4/ugJk73elOd7rTnQopxvgVvU/H2FbjlamsJLgSPcTCBtb0OillUkxF4d0Ynxp6vYZib17KujGctNCLPRp7aZ8zoETPVG7DNtaoNXa9esV2TDW9h/QNLksKmyxrRr0KBBaCnKs2OvEguRiOWBTYZuywsfM+FFR+G3QtHu9bIaIfmxWz7ARHzR+rzQhRkexFaYh33bPFS061KObbnJlCT4uuvUWPSSmTcjahdRmTrs9lfGp0GWt/HXeWMg3QUtWdlre4pZLKOLHn2pw17/CUkqVk8r4YeEpEmzpV0il7u7naCk/9mltT/Z6XcbIyivJOKlimRJVRJcVUvEPEUhmUaDPFVlGtWotQJUWC76Ekdf01w15ZeNvWdfPeg8f2SFVNZy1ude19Bt1m7O7auHpGO4GohWVN2fHuacaHict0QBmLEnRtfKhq5ExRknbgNRR8p7Kvig2voEt/3aIW3Rq4mvDUf9/070a/tyYwufHrtoRrpb7sfr8u81aL3ucj+uGKt+dK+aa/bX/fa8v7enxV3ntBMrdr7tUZ+2/zdob2DEytrJUSvzNmtTtvr4y9a9frgWWFrwwHi/fXdZ3PGSJaW7etXtNw9Bxe+HKmqxn0LmdinBDKfiZc2bgMGNeAMuszcF2z7WEbPkG1A2j258Izfen2qev6uNq/90At2whzdt3aWI5KVLV4BpoCy4DBdd8uc7cz6N8ENPPb4vlUAZlb6kFMWwVjPf965WYPktlTSC5j3Z2327N3F/x5NXbXIKsr5eByTF0r5+p5XZV3qr2iUwqIwzc+J0dSmrHc6RFqKqZylpkC1EAafV2tX7nwUZV3yFwuZ0IY8d68Q+c4L5EJa/sqkGR53+ZcolREhnEww6sraT59W09Zcz1Ul+dBDWy8jK8BcMVV8EQdZmlKSCBmJWkGFYsKItL4B7G+el8B7oIX8KSu3sZj1xRZ0qVg6j0HDTCTFqD59bqq69RA0xVgC2ZIcD4whAERz+AD43iwiA1DgmFG3dDWVjHe19Fwq0gXVoc5MK83wFU6GL7OuatXZ1p/1vjBMRw9mZE8O3I+M02XErXPlzZILQnnHONY0+M5LCaSgbSqvAU10pdgXtzZvmdBXA2HXqLJWOeWFhnOraQKLVuzdwZuSTEzHkbGMTAEX+7Nluqoyg4iiFYgPMs7EvwA6ogxoSkznxtcvs2BlBW0HitdfWu/LQvdC24oEZGyRUCyaJRmZMtq/tM15Vh/LuZyJnkCKSnTNCOqZO0iznVrpgfV9qfrc3xLjDPnU8Q7z5wzox9XxjAwXnc/ddfXPyt6IIsgCzBpW6J+AIhlve4rj1L5kjVgpufwtzwO3XiuuQQ21645N8WgRU5sXioHVEEUfVKk1ehpeYZ9nrBvZ/t8PQdbHk7ISJ5xYkC1moKgAWfWva9l1qs50UW2M1Dl0KWU3Gth259q164lm+2Vft7W124Dkr4uPccB73MXjSqvu3u9/JV+D0ahW4/bdaQd37xX6h6X+ttE7ztTPvTMqfTb2s87fbf0bef9m+4HqnB+6h0m1qlbgws8Hj1zPCOakHxBmRB3IbgzTjxeBVFFcwSEOKeibxSQQBiO5ORKangQSZAtMjHO4YPH+cJHCjv7xbUbydV7pUK6jAjg1OFdRtOE5gnxI1U4Noe5gKrp/VIyPj7lyPl8MsC8E8ZxKLxc4YcKj2bRvIV5jouDZ9WzGwtd+LVywjnvOR6PHMZx0aOKgyAOVcfs1A6X5NBLWM7NnuNZn8HX+6TzSjjCoAM5+6aHxMDOKU2kdCGl2SIaSuPpjXcvkfvU2lZPaZP9E6gu+o494Mu1g8bt73u6214evDqPNrqBfaoA/7VeotkGts93+pgaaXN7x8rmsY4EvqWqr6gR9itYpsnqupSzdlZqz9Y6a4qwen/qovT09W/1IyJiMvTSsxIZqaSqUmCaZp7kxHw5M8czj49HxnHgMkU0scjvVbasZV6PS28LWPelBz9dO82YbJq3HOgq0ueNud6JBnqnb0Z3wMyd7nSnO93pToUWBh6oinBjTnIJ+W4qipRAcmFihQKaEVIxSDnnikdwY2h7hrcaCKpH+FaxDmvmsxo3KpNYPd/rs/Vafa55PRuT5URqVOS1KqoyexQeT6thQUDyYrBYmLxcPMeG0D1jiljNmagJzcnChZaw6c57ik1uMbiAKXrrc5J32PMdJnvllbuUVHslZaqqys0mU3PsUuuslXzV822Z+1yyOlUhTRzBd4Lx8ptQEfdkXZhaqQNIUWkuQJo2FwaGUbR4iph3dybFCGXtsICm+rptHm4KVhtj3C1qz2s3EuZvIOTOW8ZG0UlJH6VqoblLePeKfletivY2jhSAkGoTYk2OKGpMrWmzNurMjQZjayzsDcr74JneV7T191nQjLYP2j2zHqtu3ZS5lJIKYI7K23cXjp8N/PifCEknzue3hJB596uXvPnlJ10lxUgl0INmVGWJMkOrqXjk2vy4oiTPnYGrGVquVT+3FOH9tW0Mkf5bb8TZln5b3b1Vuq//6ubz9r42Ss1k822U3N+GbtX5XN/3P31YudfK/3qtn4XrMd0fn3q1jePNNleFgbS7t/7KV8+svm+9r6+9sa/fSlae6Xute5+o34xW65X08EnmB78XcX7g4RPLi55T4nw+cb48kVKJjLXoNVwZrbUyZhX9YbMnrUd9HzCDbtV0z6/kfTAjZVt8/3hswauyeD25YpARRHQJk10BgDkrKSnelzb0fejoubPlY6lltrzPtaLx+ZoaqLedYf3fPdqri6Um3dxb68kFhNIr+Po0O9fl175VxeD6mls1Mm8UftvQ1XV9rfgDWObU2uKX6EMpGighDAPDEAjDQAiBGCdizEXBm5imEwaWMf5GxKIECG7Rqy5gnYXM+F552TpPFSBSP1e+0rqZS7ojGIZh6XPOloJyLEbVqgiNMRLjTMrW1jYOmRrVqSpd+zXknCCu8eRXoLbcdjw0Iyr4miKrKjjFeFhZADPrKBZtPNwSIS+EkXEcl3kTEaZ5IiWlgowr/9+vg5bqytpl0RhLvQWkMc8TqkJyA0Nw5Hyw/PYyYpEj+6lpvMKyRqj8flXx2336HgPL3rndV0P3e71neLjw6gefEyM8zWf0iwOIEJMyzwlVsZR4LqzLNrSapXAp8yLOE8TjqjdlbuvQSd3jKv8tC0+aNQFp4emX/rg1H1kbIAwchoHgZoJTvEs4yeQ042VicJ4xHAjOEWcpgBVnhhat0aAGglc+/ckZ7ybIwq//dETn26O4jh2o+E++IHzvNc6N5HwkZ4+8UFIsMgR5SXNgZ5n1096JtJpP1fJZhThFEo55ThYt5xB5/OkXDIPn7V8/Mj8FetCMLivlNn9p35WnLz2/+DMYxkzCou48/brsr7pZQ+Ws2XIpuilzb70JtJidSpfWdF1HlT22PHNfDhiYrL7TbvV847mu+BfWfCqlTU0ebX1on95zfgF9hJGFJ7zxHteyM9VZoYf4dPLMTp9bz/bHWIEcJ6anz2GM4A+IBJABJwE4kDEAjQHSytlTjWSorUmtUVSrYWzYac8WzPdhtMdRra99HOlhj5fdk3e2pJvPz3G8V1KstP2tvRv6fIXd+/R3if6mZMQ7vZ/ez7X/zdC3WS/v60+OF+I0kZJjms44n/jq1wdefz6aLg2PEPj0h2deffaOy+WC88HAIBGSBotwF464oDgOoAXkKwLiCcPIix8IP/6jmRxnKKlU53eBN3/xaunjh479/OUr+DMHTpCffsXhhSDuaBFgNBl/kzPzPJsTX9WLqgHKgw+EMDCEY5NxhEUuuFwMLBNjZBhGUjKHO+cD4sOyqzrnGceB4/HAeBgA5cs/nbi8zsjDBD/8gpQix/HA6AOD1lh9kKQ/bRttdVmokBLE2aEaio4gWlSZ+Janp9fE+cTp9JbL+WTg56rvpTvrKLyVGlhcs5LJi+60Htl7svMt55itHmBP33uty+zOiu7550AzdsZ0p+4Cyunrradz0SUYmqQ4C2/atFdfsS8oFKfYdero3oFk4WVZ62D6a9sxqDaTZSyB2DkRb51V9sbPztTqvNHkPk3ZQOmzRU6M04WcLYXY5Xwp9o22DmwM+7FrtG3+yKQFAAAgAElEQVS7wgIWAlZjsQUaqXmA2ix09y3rXJuD7m+Lg9LfRroDZu50pzvd6U53KtQDZpzBxo1pSQYCcSViSQurDy7YNe9DCatbmDmxKDRWZlFsdUjp+m+eW0j66/a052roeQpgoYYy7I0plarxoPYJsRQvvRquZHI1HtjcFurNVDtMyvacLgUZrKKFmE+kAp7I2ZTKOcXiXW/h1cnV5E8B+DhEZQmbiCoBVzxCmxBRx/nam1lLKP4CgpEW7vFq/EiWVqFGuClpgqqhyfTyVWCgRJWWEvrf7nPekXKiGsIsNU8RnErkAimKQqT5OUAFzFTVa3smFU9QKcY9G7dEGDzOl5QKJYpJTYe0Zfgbw1wNaLeFsr2RWQagGp2K4FdTfgmYkUjK7KkuYe/NMNDX35R6IpTxK6kUipFKnN8w9U0gWwxqSzqvrqXPCAG9wWPpq1QB4/azK8BNZ+Bso7UjlGpTkkum4aVy5nSJPPzA8+kPQLjw5qvPGdwTOf+Et7/8ZKMILsFQpQo7oCL4DWimVLkaKaEa9ywM+755a18Bvu7fLVqrq9fAiQ9XMn2IErkTM7tyV77M0P322yAK7vXr/YAS+/Sh7e+VXG3Mpfv/8+P7dZ6RraVzCREvV89URZP9qfvHsnte3fvcuNwGy3yIuaQ3CqzLEZTDK+Xv/+PEEI7kLKSkXC4Xvnr9JdN8RtNcjBGKqitGpqa06qPK9OCExRQlNZ1cXrdJm2d/VRZuO/h+r6+d+7VsZ+9RhvQeVg1IUUEEpTHCBnxR+1GUNDQlZ1/m++r8Okaubf+siOs9v9/XmxdWnYf9+gyMmjv+zC1hlp8F/HRKtLUBve0+FegBDexp49rSDFZUSZ+mqXrI5ZxXIIo1sMOUkb2isAdAbZWrdZ62Oc+tr64o3mzujYdSQggcxoEweLwH1ZkYT8zzhZwiqokUzxZ9yA/4uoaymEJ5xZOVGZD2zoAUIG3hIaWkkszTEp3OUl22/PNAAcVYmSEEhmHgeDwunqjzPHM6PXG5XBZwzfLea1OMeu8JBTBTx8siSOniEdva1+bXiQGFXUl9JuoXAIiolqgiFn3GaeH5Suc15xLtRvBe8CEg4hjHkcPhyBCGhT9OORKd7bkhhAImWq/ltkSLotQZWCcEC10vAvN8AfWoy0wXR0qPxCxkCSCh46qs9LzxMtSbJ8w+N7F+9vr7NqIeHSxgPF749Ke/ZJ6FKQ9c3jjgjJa16t24yFla9jlVLeeQFt7M+E1HwLsABFKOiwIeAS811U/xUhZnqQ2cokSQGaSASTDnhn6/zKp4Z1GEhuB5fFDEPUFKFplSEl4yQzAeLXDAuweyG7hcIiEcLQJSSpBBwkAYBj77ezOf/BjSlPnizyHOO2dhm/FFSlDAffKaw8/+Au9fEOcX5HwAHZjjiAHc63ubQfLiVZtzKu+ToGKGKDvDBKeeOcXCjSh+cPjHxPGTL3g8Bi5vBuansAJouOVuSO/hYk5vRk5v6swB5AXY0q+w5TjbHJM916FFQu1BNSz3mcnRqeBxxWwhHY9iBqyW8Lbs1asoHuWvbhPmXs8N7M/bNmbcbc77mnoeawu82Z5wtV8i2xpaGst6T4umcw1zunVK7/JnKmieiOdfEtwZ8ogSUBlx7ogfXiEyYKmZzPAoGK8hZb9EIgaaiYgkxFP2KV31v9bvVmPStafrx6352fZHdz5/WxniGixzzSffoi3Hu9eWtQTXDHB7YLVrMNnfTbBMpW/GgRr9XR2z3xTd5ti/e3pfvf2e+zHKAyytT/wSTRnHhYMX3n3+I/78Xz2u7vuDP3rHq8++IKUTYXwBMhBVmC9KvLzhcHxFGAdCABWPk4DiUTLOj7z8vuPx05k4KWjCEXn7l/DVX/SnaA96vc3XTV+8Yv78E2Sc8N//czREhsNnIAemaTIZOEtJOWug5RAMeF9lDZMxDgzDiHOenBPTdCblzDTNRWctjOMImCyk4smYfOGcMAwj42HEB7HzI0fe/LvE23+vuB+cODz8kmEMOJkYZeDAY+H9TLO24hmuQKZtLebsiEmKjDJzmd4R4xecTr/iyy9/SZwn5mnifD6VKIiD8YhLWvkCICn8qekIrCXeC5JlYei3wOznABXba8891/dsz5nwWZJ6ftUojlvup+jJtereLQ2VeEG8t/EtdXlXbQT2v5yrPqTIAqpXgJm+T1XP0oNmyoK71sX0LdyCiYC5c0S4dd82qj+AOJP/ar+ocq0qKZaUyipMl4yZXlxZB73E0/EGOzro/lq1bbRIr2ubR5XtnXOdE2t1yGlvcs6U8f5t0pT+7aM7YOZOd7rTne50pw0JPcoXCMJQBAMt0V1yzjjv8MGMAMNgStIUE5fLhXmeORyOS1hKYPEqDSEsAJne87heqymVLHWCM4EFUwzHFMkpLcaX6tVb0dZ9mXYNlmgmSweLMm1h9J0x+VSDTV5ALzWEfAU1oMrT07srAIf3zgAyoUspJR7EomTMc+R8mWx0S15e7z1OhIBbMbFxh+ltTa/Gl64vFcACi/FCNJMTqKvex4WxLYht5xze1cg91UDlLcx5rjlBlZxyZxSwehbEfVV31rFBiwe0RY7RAjJCC3NNRnAF7FMY9BxJeWIYnBmExBsD7LbGT+0EG1bMvXbG2x59v+etsHxXNQR9jIvhyTnHYQgFFGR9zlnNEGBDXdZFtnGvHi+08bexMFBTTfOkmoqBrQGbDNAlu2lEvg09583R2rcGIC3zZFdWEZrMM5cmSCElJHZGSczpgkN4d/L4rwYejw/E/IrLaeZysecdJjurmNGhKjyt6ExGMHWzw2nzcr3qB1XILYUtP1wrVOuna3NYLWFrPFgbNNblbVXYz9Oet3q93iuyt0ALNi3rFT0fao74ei29XUal55Ty7/u+BgNZaR9W3rUAfuv7rbK2ZlFgDZDZK68AYFT06t7tffVab0TYKuX26tWN0WrfXNt+2zM0rI0pbH5zwCOqR1KCeZp5enri3ds3pDxbJJUu7SL0aW6a4uY5BU07M1i+13Ng+0zbZ6oX2NdTHUu1891Qgm2VSWuAxfZe+2vR6XLpg2Mcjrt93AJYr9u2WHQ+Ou2No94ah8KnNZ6tKpak8Eh6NRYfQiJFUVVWVlZZ9VUATZEKmC2400UR1kdPERGGYVgpxCqoOXfnYK9Iq7/3/FCbX7ma+63ybc1bekSUeT5zOl2Y5gvn8ztinBGxs38YAj54hjAyhBFV+Oqrt6g2JWNKcWmnFpSD71NnlgHKKZJyXMA6tS8VFBFCBV3PzPMMWLQZ780wnNLM+Xzm6emJ0+lU+vGyi+KjHRhqrXhtfDGIq/z0+h0JIZTIIRnNcznfpUWAK6SqJdKJkGuKK3ELn2h8emAYjsVQ4Jb+hhCQ5Jh1wnvHMHgD7/iiXN/w7Tan5ZNzjA8PhDFY1BsK8EeFwzDi3cAQDLARZ+F8zkwXXe3Huvy9de7svNPLP+nu0N09NxewYd787oLxt+qUOR0Ix0dGdyDlkZwtJWuO58ox0iIF1XVW68xFdsFSF4jx3oNkCC1qEcykWM0mlr5JvMcHIYRM1ok4T8QLIAYKb/XAZZ75/o8+5eHxAVVI8Q3Bw7vXJ86nJ8QlXjweOb44cLlMnLPg/CM+fI/XX77j4fGVgWYKGH66RIbB4/1oxoWcCEfj92XhvyFNbrUv9aAZ4YDklyhHUrRDwFKmXYoX7QWRojzXjOZIziVqp2ox7AiqrshvgmCe4EI1TlnaMiUxpbTIfNCd2QWYnbF0ZAwZcQ1EI0Ccyju4WVFFAtjhPktftfBHoiXKS7tDERJKkmoG6yUw+zvg8OoWsEtPuUT8rOC+XPfvCgruwL4OA6z3JqNc2rUaC7o+SuOKb5kq9uHfe3z2+3kCeyU293VpzNqo9W25Bs3stW2PaupYiRE9v2VOMEXjr4aHkcdXP8GHR3ABNKDJwDOazfiZRfE+GVCGiHg7C1LnkFH/LnvWJh1clbu3a+pDePz+no8hE/Tl2t91P55rw3N76K3yv157vw5U62+W3rfSP4Q7/th93atTb1z/Luq/0z59iBz+oc9/6L3P1fOh5Y0hcPCe+fzEyxcHDgfPGK6d+kSE4+HI8eEV4gaEwDgIysSb9I6YZuaUMTWqAwnGh6qQ1eH8yOHwgnG0fd9JJr2JjA+zgYpnD7mkruT2Prg+0xQR47ljVnx4ydNTSa/qDgXUbtEMF3kjQ07KrMoQWOQF54SUBlQjx8ORyTlitAivh8OBYRi4ROU0RYRM8J7j4UAInpQvTKeZeXoizg/Yaa94Ei7C+e2JfHrkyPcxWGYmoavz7vr0aOehkwFV5Xw5EXXidPqSefoVp6df8PrNr0lzJs9CikLwI8M4MI5HvA/UyK2VY6h9ct4cLJdR/ogHz3P6cOOD19Hpq4y5duy5erqWzkrruOgpyulcUqD6EHDBL/r7Knc1pxCLLK/k4jxsumlRzPGy001UObfv3xokpJDzArTZpmXq5eS+jMWptosy09+zN6aKgjYdtzXL+OUULaq6ECxqqwu8/PR7vHt6yxSnMoTNoff9jEnjcVomAha909Z5R0TAe+a56m/afNg9DtVY0iEL62Xy9XRNd7pNd8DMne50pzvd6U6FDDFsYc1rXtJq6LJ8pbAy3hXDGR2DqhlSOpfw8qkIDn5hcEIIHI/HBQhTjR/VS7l6SdcIMjlnpmkyA8oQSjtlCVvfGwl6IEA1yFhOz5mWW12XthswxvpVQ/tpSZNknrGpGNZantFqfKlltLGr4sga7V6VuKBLjltXEemlnds8r3tRZXpm2jsLHZqp5RdFqrRINRad3S3RZ5zokjJr0e5iH2s71Xj0K5BJr3bURRCwMqrSvo5l7bdAidbiOkWnpTgqn4BEKsKOQ8jJlNGyjGEvULQ1pz1Ypo7L/pJu7VmNYwVL2efaB+/dKq3B0tcaCaV8r+Ci3njXhAaKkWNfjbw25n43qqc9L4v+3dgag2vkgNreJmO6ZS6qUXFZGqrgMuLNaHQ6X8hZuByjeZHLA+JGW6OdIntRokrdTyBSlohmVAQDLghO7XremK+2VBX62inQ+7vXXuXr3+rnrYeztXUd2P22j9I19V6z+wp7u+fa2NFC9T+nb+iV4Vv6NnqKD+ndhyt1dfP9tiL2/Qra573Etu1a1lsHbrm+fzvyNid7wJqe3DLCsvLulpWHc6t/D4Czbed2jd4yQl0/vd7/qmIxJmtdSso8R+uXYAoYoHpCt71tDQp5DvzS9uKqXLkmRVf7zbci2c5UraP87UCHvbLIzvN65jdf/b5vlU+ws6+V0yuc6t9tP+o9fnNWfSzazsf76qhgGed0OV8q+PV9U3CtqKpRUFpZix50iSizHicpkfLoFInQxhhaZJVhGFqI5dTGvfJYlU+qdfRj0cArLQJfH9Vm1TZliVoXYyLniZQncppNSR0aeGccRhQhzpH5EklJcXikhKvOasATS+PVrRWnRZFcAM8pWshqyQWwrSsFaa/ETSkxTRPDMCyAotevX/Pu3TvO58pHW+SZaZp21kQhDy6E1RyCKSEtmst6XBpIwyL9UQBZqpWvK2u68AqWUsZSJBmvU40CBnQex3F5j8D4I0vN5BjSiDsrqnNZk+vw460fblnDIQQ++973kMGT4sxlOpNjJEjAiQGOfHDMF+Xf/8uRdPkBGmssj35v19W3ZY2U/9c9v11v54V29/V3rX/bkvCDn/2Sw/eeUCdIOCJ+IGUhVoAR4AjkHFf9rpFlbK4M1BGCgag0J3KcUE04V3lQSvQix+ySpfnSApjBM3gPTKBn5i9Hvvy/f5/Kv7Zxsipf/NNfMvzkDZqVy3QixxNf/vEfcPr8Z2QyWWydJwwMrmV95PyJyR0Sefkj+Nl/qcxTIs5CGAJ+DMjo+Yf/bLYUaPlM1gvpAn/1L35Iuvhllmz0bGRTdMTZ1r2lQFCQTCYT04yTOnYAiayxlNHv/W1/yMk8UcNg68c5A6uleAEiORuwZ70+1vyDjIkf/1ef8+p7r0jJM0dF0oE/+98S8+UWNKOcPMKGB7BV5IqSvwJXXA9OEYvwlKRFnjSJSgjq8Fpner3CFTP/ZCAtwJlsNXagjDXYt33Xyq/v8DP71EvWm1863qfxcWtuevte1ec+hAfu660yQ+7APOt3/P2ccb0vo3z++Sv+j//5P7f1Xc7Qlz/6ip/+kz/n6elL/Djjw5EhPBKGoaQ0bs4S3hlYLesEOhEChPHInkuAbZu6yMq1/x/GB+6PzZXs+Q3KaZzNet0sv+3wtbciG3w9ur3D9gDIbzNG30ZO+ib0sTjE53jh63uF/j3fo547fm5EftPj9XeRPkS23dJ2Tt63zp6bw4+xRv/Nnzzy7/70wcACztZenDdpbIA//9ff4z/+21ddrXYmPHz6xI//8ARY1EBksH8FkIh4lERMlirJM5Z+ZV78SPn5P3/H55//P/z6j3+f6fNPu/2hTzLI6uqytp3iB+WSZlyeEI2Yhsp4a7eARSyK30qvVPdubdFCFieUbE4o3gcOh5FhCIU3T2RVGydnQGfxssgN4nThxeMXL3n6X/6QgRKlLIbSawPM2KlDieB8Pcuy+r8AmRgnpnQixhOX+S2X6S2qF+Mq1Bnw2A14b7p3JwYcse/CfDovOgQwfYDxuH26nm9Pz0WNMbklb64pz4Fleo6fzefrqlr6o0WWlRb51TkHyZxrM1oi09eIsLW2FjWlb+PWbtHabbxfr/evjsTAlcOxc0X23tG7bPW9W12GEwFXnWM66UmrLqA6ohgPPQ4PnOTU7ut0B++jre6lph2u11pa43742/jX9suNOrc6jDt9HLoDZu50pzvd6U53KtQMG80TcEm/IyWqBqaodtkAEpoz+GJ4S2aUe3x8LOX5kv804lzgeHwwhttbblbztA2l3oAIzPO8RJep9PDwsDCS3ntcCFwuF4Dlvj4NAbQoNdVLs4FC6r9MCEPxArDUUJb+p3lnD8No4UBXgBWYpnmpew2cKMYkMFtDNmNeVVi4ioanMPnFCGUo6b6eNYNoTCIdOMWMTLkqv101fmJ9zVgofbREo/FkjeYp7IWaSinGkke3AFsslVAnnBQjYtKIknEScM6spK6TFRePayB4j/MByOQ4LwaUamSphgAbEV/SXwW8U2KqBi5nilYx9aoq4ITgg7UnGaiJBbjCKsrM1kDVCw4LYAiLglM9QapQOs9VEW/zUHP3LvPvPd55lgg72t6RGqKyCt/NxmlAKrcY9qQY3tZG2Q8j6f5eC3u17b0xe/FY6K7vgWrsd+nQ+gYi887j3LD0rxq9xCneCzEnECFm4csv3xG848XBkbIzA8uSgqYp/RflAhY6XoBZIJQx88WI4LVkxShGmq3X6q0R6pWoraa+p9sx66/2Cv6+vH3D/R71PZbVtfXnHkzU2r+jhL66pymL99r0dZSbz/Xpum37T+y1Y63I7udNbq7cvXLb3PURd27Tysj1TA3vv7pu+dpw0KUx6OvT/fZt0zDtrYntGr3+ft3G7VrxzjMcjkynGcGT5pn5MhFcUbBQosdkKYb/tGpTycxSDDhFrVb2zHpe2V5e9/S6t272sVLoWvnxvpl+TqXfP78UvpyNNeVNBXPYXi/L2cqiTvQMg2cYiidWUqZptn3ZtfpEaj+tX73urZ4jFcjhCu/yzak3+1z3tw1h90YJ1PQbtU1V0dbAP7lE/zvc9DJb+pNZojPUlVoN83sKql7pZUZ78z4TCajWiC1jURzbeZIzi+I1JeV8vpiCFTs0a9Q7KaDVWDzOqtF8iUJTD1bxZpQv45+ypa6Rhb+wIVKUOc2oJnI8k/J5SQlkkQFtHJ+enhDxBD/iXMA5i3uGtAg4IuC98bZ1XVVFYl3D3gW8A9UIYqk3a5ScPrpOXacVbDLPM9M0kXMu/GiJ0lLGvVeSbr0O6zPOOS6XS4kyE4nJeFU78ztvRS3etOiywDTXd1w6rXF9L6W8Tx7vg4E4tK4DWcDvx+OxAGcy03whhMDT0zvevn3NND8t819lhJx0SRNlKThDAQ+NxDxz/uorzucnpvmCAI/HR1JM8HRiGAYeD6+YzyP54ldmaFn+ydXbtT7dt3tof3asoTTdG0NdXCo75QWHHweyc2RxnOf6m0MdzDnywgXEBXygjGVmruANTeQc0awk8QjC4zHw4jNP8EL8/9h78x9JluRM7DN3j8isqu53v7m4XO2QS1FaLQlBgAToN/3tggBBErTASloQgnaXS3KGnJl3db+uyiPC3U0/mJkfEZFZ1W96ZigqrZFdeUT4He52fGaWTsiaJtfWlEXMYiakyBJ558wIHtgFILtPkCbf9bAdI0oHxPN3YGbcBYf9XcYBDofTgETivRxRI55UWIqVxsjRY7fzOB5POJxO4BMhDAN80FRIjgHbKxlgtw0mlVEPyHnEeRI+P3EEksghPmQ40lS6LAYKRgaZc7M2zp7XoOnKHI0IwWM6HwESuXCOZ8zTEx4PCZh+1rWjP2UZ3jm8+uQBfu9AyQGJMB0S1rTNfS1PsXb8DSzTjoTX84u4H28PAcwE1NRMDvV5zaDCc9fKHdCAUEj565ZHunj6LkAvlu6JFy+7dtnfZfrUwsvxss4KbsndtWtq+d/2cwHaQzvZ3SF/tySILb6LMyGfh8LXEYBP/R7//Cev8Itfv8XT4S0YHs7tMIRX8G4EuaC8UMYwEkAzgAg/ZHBOeHr6Fsw/BeC7ukt/FrJS7WPPP7c92qblXS+XB4y2ucye1928rwFavVQOWZf0PEOlEu179+tlpX9Yeh+58fq1l2TW63d4YON5qyUwRM625/pyee8bb/VGL6XLY35Jsn7uvjUt5+359fb+FGdSgEwvc9Dib5zdCkgDAHcf3eHjj38CcncIw2sQ7QA97bxjZBckrSQyUmYkdkC2qGoJNDr4nfIHzbm4jD/WtqsdB+8zPBK8kzSUIThY4BSC09RQ6hjgnDgwKoDZyja5KGfRWe7DPXjHwpPHCTHOCpgYcX9/XxwxQ3BwlMA8gWgGuROI7qSN2SGdB2SqrWaaFSQjPJrp27bgb+08p5RxPp1xPD4i4QyiGdP5gO/fvcF8nuB4hzih8OMheJGJvOikj8cjzqczEjP8IBElvRNnWyeK2x9O3TTpqX4VMMMFjLQlo27fJHoNcSQiAE7XVC8ZAKgym4JbLH2pLgCdGxbH4CzRDZ3T71kdBFSXarrXFiBidSwdZHPK4CbqSvub3dfpkEkiPBq10TuXqY5b4AkIyOrkKWIs6dmuADHVvYMcODEOhyOgslrm9F76a0mTnIruqaQ4duIwa47S8iyEMgcic1Zn1rZOcwo2ebS1xdzow9ANMHOjG93oRje6kZKBMjpViRmO4Dpmjx2pot0hGdNkljZalKnMaM4O3g0AkyiE1WAhtjcRfmJS41WLEC715sI0tgh++9sylO1Lftfm6kva5PSzedc2hkA4OBq0bjM2AKIwUAbWwp/L1wI4QS4SWPURawAvaqAoytIMkBkfco050YJoBAFT02gUJaG6vTkSLXFBjjfGM6s3cx1PAREpQ8nmYVENI3XyZGyqIdKVS5be+kVtpbltiU2FmzXpTiPAUQMTIC9AHpB8TxJulVXxS2R3SijWlDUKjo0THMAWg0RN8Va0NQkkEXHAzXciCBAq8y3GuOYe2HiTrkcCkRgFjbjpsyhZZazF+upE9cvVE7gy+lvCnIGEqhq4BXBVD2xUI6pabIrnKOlYNwrLEuGHa05dKWRLdV8/rwA3bKA5VbazRKQKJGm3UkpIOWMYPBgBzNXju1X4t8pum11LKJCsdlKDQbM2zfu9VwKXCSt/bD23iuh+lO3ytbqoKPNR+7lUyV6bwSX1Avjla5blLxX473P/75auqVI/TGlr2Ej/d+seUeD3K1j+9kriZRnXFMiAxR2qtZS1X+qkrqxra+7S5y3jyKWxfE4xzpyAeMAYAuJ5RppncMoQw7+eMTlr7mcFyDSlMjMykSoEyy4vYDWWfcV2N0urAgC0HISt1nJvrCLqR0HOE7uv8fojG4/cDZyBO8pWRtKmmleGtSjdQ21tWO5tljIzJzEBazjlCpIx5aeAQUCk4CG5VyK6AXYObgEQl1SVeOahVsfCed2VDECgQM5pis3Kg4BWm+FlZOUdrNsCiJC5lvlmWsIJtDTjs6jpR1n90sfKz6gyFKTrQBRq3nkJx00BtjKYgRirER/kkXXMrPACDvZU8oywtQPC79kDlQFZg3oOOxLAgfNBo+pJFD1LxUI696Qh7U6nA1KcASTtn1MlnAGsAMYMzoSkBxBpS0TBJwAkKnwvd2dOTgIgLwBmIoCVh4NFDZNTMMUkoA8IX+m912eyeqEOCua2dSLgp3pqyti3nokZiRnMTsvJSFlTp2pkuBakW8/8XB9ej7K25RLd6VwoEUWAAOZQgC8o4yzPzDCOIMeY5hN8djicEp6eHjGdDsJDJ+E9gpN5E55P+Ldx9AqgJ3Ce8fj4DufphDlOYAXLx/kM8AwiD6KIMzHClxFIXsH4I4ZwL+vRZZCL4j3JAjXwNGLwAxxlnA4HvPlPI0qgl8V+tf9swu7zCcwOftjBe+FLU4qY41nTeVrnLd0kwT8QkhskdRUrT+98eQUAd3zGODB8yDgfAr76xT1iGiCpTFXBXvhGwmnncdh7OJ8R472sycYD1WQFm+co+WMQnEPwDvF4350zgOEDZZV//4tPcPhGwAFDCNgFwvlxv7pnizP50Z/ssXvlsXsQWSaMwJBJIzqROGjDy1JzAYQRQwC++LMAzhlPvwEOvwHcAHz2pwQXMuJAmLwAscIooCFm2Z+dPZsaDVPsEdQ8Gc1fTeXkSNaDrNcMolzGK2VCSsDw0TdwDyfZSzggff0lkH09jZlU9gBcIBnXnPHJnwBxlqucI4A9vv7riBQZD58D958mxHmGAzB4j/N3AcdvLbJO5VZpd8Lukz4qUWcAACAASURBVG8l5fBOnAmm44jT11+UpEyaEFeAMiCMX7yB24vziFjSGOTkjEinHY6/+QQq7UiE0TJKMvMPX0a8+jKByOseTRIRleRZ/fY/BKR5zSObxNcCFmpUlH61bPFDBANL1SfPrt3i15a0ZfpveT45P5R3L+dkX5e9u8ybcSOPCMDn3fcD/uP/9SW+/vYJ55jVyUSMib6kgAZADiEQJDqCl2y8lHE8zohzWyth6+lafrOWVLblhq0yfhu+vOWfr7kLrOZ41eBekmqvv8TP/67od1n277a+SyN1XVpwQAHVbYFmJIqrHvz6/lqJv195858GbT2/LV1/sra++3Cz8Fzb3p+ul2b1vfoi4+MfSxQ94XMBMOHuNWG3fyV7JwagyKLCuxOrjhUCjqyk4AEXQG4v++6iTdt9rd9y8jj8zc8xc8LwpYf/grBzA4gGECTKDbHo9gDAkxf5w5FEg3GA8wTyhJQTztMJO42oni3tI4kM6h2BwgAXdgheeGpHjDi/w/HtCfM/7BDzA+Z3vkgP7Rlrfyt41QDN67VBkOyBn/78DBcI+88y5vmEHI8gRMR4RjxkpGNAnhkZopN1IcAPNX38HGdw1midnOBDQHAVICLqb9IGVZm0dZZbc5ALjqGRrwye1+5a/Tlj40DF4YXBGhG/jzBjevvyWeX8ygdQ+b7lRKrOVRyJibNGcDceUyP7MJsIBRgQRO9n8iiycTNDRX8CoOpCVRbMCSW+NqNZO03kP2p4Ke096fqyrvYRWgk5sdZmdROIg6ykvFxdWp9jiOhLmFKsTrpJo8n7oLaHKrO2TjYm65c0oU56Os/nAvaxFL8yG0l5fdGthyGoTsZSIWtvnKQBs9m7CpK60Q+mG2DmRje60Y1udKNCjSihTGL1JJf3OSZl2qtBgpOGlGRGTlFD5Utx3olHKsHjPEWB/WdR6ppxQbyJRbkPQkGxQw31Mal3LvQ+oDBiy7yXSwSyGEOkHG9MrxldGqS1J1MOWch5B2bXaJ0qyx681/6pOolrWifWz1J5ZTyN/RbAjEadIUlXxFw94gFhApmpCgPcRDhBY+DKAMBicLD+6n/ZjJnK2GvmLBCZFzoXMIpEZ6nhRjtyQKBBAFKFWg8GRem7KpBm00uXYOFm6JH5tcglZiUTME8AqcEwMyvIxqmBTuatGuBMiNFQ5WwlLQWieq8Biew+p+0Vw0Nd/wV0hZb5tvXiAQpgVO9yezbsemH6W2FB1ph3vYdA277a4Co8LftQ2yCTL4KDGgnMWkztva3gsKE6Lc8XAG7nnTQSUi1JjAC5iq2aus2xAzIhOPHuT5jhPMEFp6FknSrpqlBp/bMVUVtFtkJgNVGjUG970iro2+/rSOl4oRWDX07UvACNgLChRLTfLyl+f6ii+pKR4Q9Nz6vBLl91zcDRf1obD7ZqaucHkGfA9oC+ROquXa6Yfs0I2e7E4I12b4NlltR9L/kYNvvzPmCZq3WUxs9I8xn3d59gOiSkGFUHJWdbzhJRLUuALUAVY3W/o/rZWkZm8O9HiRuvpRqVrFFmNPupbNOEEhWlPLtctiEDqBSlC9Bdt1Ks2WFn+zyW54P0uSrF6shZ+kDyEpmCOWm+7ihGL7gSHjj4AcMuFIUZsxouS576pGcaL86fWmO771v72UCsJIpWr26MkTMkLY2saOYE70fYqrR86FZuibjW9pAtdZj2dRnNjO28UD5Ex9kC0di82diZEhIKMCnPVknj6ZQH0nlijfxg+k9VohkItgWWUEDhKTMznM2tk3MuxYg2ZacAmAZ4N2q50mbnjF8QfsR7gg8eOSU8xUkinniHIQSYkk9ArAIoCcGLVx+TnuE1Sk87vy1QobTJoyobtb/GT5qC0IAvcY4a3U/LS7Hwuo4cmLJ4rer8KuoGcZ5LP5frytTmGax11Rz35Rks89VwCfo8Gq9iQy+PMYGcGNKp1OnALHyQRHWCrl1Zv+NuxDyfcJ4O8MHhcDjgdDqCshgX4ixzOWFSD1yN0uQcCAPACfM04Xw+43B4ByYBabmgqUxzjZwIJEzxAP/5UQwQ3mMcH7C/G+AHjzAkuDABPoLYgzBiR3vc70Z4N+PtNxMefzEixm2uaf/5jI//5QFMA8Z9gPfCL87xhGk6YDpPoOw0GpGAuUGE0wQk9sIngSUlGADngWHw2A0e99P3eH3vEMaMrx4Jv/mPe3uiUIL+cwUNCmixGjNboEJ7jX3Wldel+el3QFYOW9bF97/8HA5fyDVc+Z2uzgvpeX7yp3u8+knAPAv4yQ8Od27APM81BZtzJeojEQEBuPszDwkHknH8DcEH4Mt/5eB3jO/fOnz7DWHOs4BDnAMMAAhIOgRb+xngLHy2gBip7AVVKkklwigV44IDUYDzOwAD/Kdv4PwbWdNph/zd58i5iQTCjPM0we0lKhA5YLx3+OLPGFEjJREBnIBv/w7IEXj1OePLf5lxnhLSPGEcAt7+9R0O37YRRhQ0szvCff534BSxf72D8xn49jWmr79U3sYVHsfpOglfvIX/7J2MSZL+escYAxC/e43zbz4tIyAiYw9bePgi4kf/aoJzOzCACK9nYwSfIr7/mwDM1K2558Ayy1WyxRkacMciNBnnYaBa2ri/LaPlzSq/3j/H9jRkbvmNJX/dc9rLZ6ppGYgY373xePO/vAbwEZZ0kf9vxiaXvvfjsM1HcvM/VuOyvm796w/lJVveuf19q/72t0Zi3uRk+2te1po1797+dllS2r7+90svre/6dc+Vcn0kRTZy6oCycTUDifTZbdUCz9T4j00+/adDL1k1l67Z3m3buy7pMV5e13Mr43LL2l8//jHhj//CYRwFaC+snQPYwAWWzl0kcuFhc3ECMNA+wIZFUP7Fwfm9gEAvtH45OuYak2PA09/8HAxgDG+AT95gcCMc7QAakbMA/4U3lgge5I3HJ1AQR7yUE87nEx4PT7h70GiK2kA/BAwhwAdJnyzRTYDBOzBnnOYjHr864PB/fATGiIQsqf6Uv7ezLcO0r9oPuq498APwoz+f4XcCmjg/RYAneCKcjhHp7EDpHkhnZALCEBBGidiZosguyuQCBOz2owDnWWWVXNdebeV67E0PW8De7XnIy4h967OtdZItv5EvoyGOj30aX0BltUb+LM4fpWyLAlN1oa2DokVDQZZoLCABSTmNAigvhieL4mn1OjCJDGBg2qoNtV5a5FSVnTmhpNGERXCXdb5MP1xfUNA0YAAfia7fAliq7aXIzkTyrGiaXqIMcqz2DIkebmuN/KBgFyrDZil0szpisfLZrmmr6XaK3QgirU7zeT1HamdKKWo64rHKn6VfVf6GPns6Y/X33/dh/0+YboCZG93oRje60Y2UzPjRM5qtOoQaI5CG9/OqTFLFJzLALsK4IgMReOcEea/gDnIQId55ZM6YzhNSTtiNwhxlNVa1r84Yqg0xhqwz2qFnqpfvTUHfhjMsYRDVI9fAJX0YT3sZs8jaxzouDcbihSSMaebq12MgEANlmCKjK7f0q/ZtKzRiBdJU0NMyKs8zzauZH17Qp7J2iqVM61gAmtYiK3fvhXFHARFV0Etr+CuD1Bjxap+3og3VdVK9BrbR8HV8LDKMc9WQXOe7z5XbenAXwYtYH431OuwFnrZ+BrncyFUVPGXD24v6y3W6PS9bCPxqVNhWg4kSrVclM7MYUNj6lpA4ITFAZ4dhF+A8MO7l2jg5JG7r05ZS/2QxsYbWrfNaFAOm1Fukt7mkGDWx9LIKYeN5ad/rWDtY1I1LKttrCqRLv11TffdXbAXB3r7uh9ELH+1ny2jfUfN/S5e+Wfa1XcVbSvvyvhgDTRm8BXFBB26xdYfF90Ye/drcaj9dUj5foXYWefF/p/ha1NXX/fyYEkl0iZgiMkcU9ZoqRNrBLeBA+dCt8TIT+pxfegLaPeXSPlNLXu/7qy2pGahiFCPbh6yetr91ZRjIoYAWCOszbvNBkX0+N4pZ+8414IWcc9MOWuXcbvf0NUimJzlXVIGk/ASzpPAJQcpIiRGCx27cSeSIkkbRaXrCmqqobUN7dpWVUwAnTr3M7Hyu6Sqtz+V81bFvI+60YGQDTaDwLFvzb9+150jzayZYjkcDtJZ91TnkbKklTdEpxnBHtWwpyOIBSFscPJyuPEeE4DyCqyDcdkx6/rEdyzrXmVm8RBu+sb1Pwk3nOv7NWpfxFTgokYJQScK4L/lWScu0Hkeb02W6yXLNxmbU8iftuuzmBSgR+BxJCqoSr4OaZ4DUVO98SWVlfQmDK3xzSgnzPGOOsl5zzvANcI1ZUqAa2X3n8wSg3i/AZgVA6LqQ8NuyFucpljDszhHYojJqBMXMSTqXvAAjMCAjIGV7JgqkqYwDNaOSMyFxQAh7xOQwzQkpScpYpkGA7eSQndezQgH/QRTnzhGcd8iccXrKcJ4wOCAQAxkIfsB+dNgNL1BHNnPLsLD7PRl/aedSYcWpRsxriyPbI2G8kkVoVPAa6r5d/663T+8SghOf0BZwb2ngmA3g5LDcG+MckSwCDZE6VwAWtcNREIV/luguWdP+IltUKOWJ7bC2NUqSNpVKzw0UnmHet44ynBvgPQMcFbSlz0tiZD/JmJlhZZSzJc4zUkwg5zGMe4TBITjCPEnqtfl0lEhLIITAGIPHfnzAmzdRN5QEN4iMnKJEDQJlRMw4niMIwBQByow5ZbhhFoCMAtDlpeA2P4LpDpLe1sHpHps5g2mEGxI8xEPY5jOzpMOAzr+lnZ1jEnC4l7GcphmOJZqNnYipPB39+rvEw1ynltegwv9vSyF2y5J/sLvtHTQlUH9FweKiAnSX7VzyZFYuK1daJDu6zvdt8khlbLZ4qP679+PFe/iN3f8+ssByX2jHs/19q11bPGqZlSY108vbsV13+75GxLU9+9KI9SPzvjLO+87xS+99/rrfVhrrS7K9vjgVbVzHLMDUJrH1i8r+oTLnjX5XdO0pXe8Pz6+095Vwn7mCgGEnvOhuHzCOck7nbGdA5c1eVp/wgs54QxbHuiGMAmR4YSvb/cF4nJgS5pwxhh28H5DZA9nLGaQRt11QPtiJTjsof3p6mvH0dELKwhN4b+BpgqeAYaiA88xRnj/HmI+M+TAhHmfYqcHEJd1S4cuaSDJ29i57ubU3e+8xBEndMxEksiVB9QJVvrP08aRR2IVvyAjeUrNXPSqwlvefo2ty4supnkxLPf+ynqUj5VInUPpCtNmMVvYCLIqLAVKUOyJ7VS65ADqsLWwzWOvtnR7a9tOqOVv6+i2dusnyGz0p47XUN9cIppfJe1fSKjl2CMHD+0HTJQE9EKgdc/1sm4/qHFrdhaUqbvUXJepM4+hh37fzvDWfz9o2bvRiugFmbnSjG93oRjdSciSeuy0Qw0ALBBGoWZWNpIYV7z182CHnCCCDXQLFCUSsRg0xVHjvMc9PiCmBsilShIFUm1FJshOnucvtWZm7anhZUstALRHILajGqC3X3rfABwOxGNAEqChvSc8gDckrIA9QGd1rqqa27VGNfJaSxxkupBpXOnV+L6xYf7b6Z+8zZzV82PhkAI0xMHMx0rTUMvqXSIanGm3q3JpHaRkYvawa8SpZXAM1wgAS/hIqDLJ49WuiYLgmlYJE7GkE3sU62ALFENnYuo3f+rEzxT+RKY6TKOs5q7BqQpQDOV0zzsERlwhK5gmLRRu3Ptvzl1Jd77L8Calogq23rqw1GwvuhJbFXG0KEc+rTwxkVoWsBGRZ/5nFA4ZJPG3neMb93T0++jnjk3/xLdJxwlf/+08Qz2a+NOWIKO8TVU+ZrF1jttgXAphJxEjIF0POtuLhlkp9ec3Wu+U3axXEJXFySwW1VGP3Vy/bufxtsTouXveh6OUKtHU72p3puWuvqbeX5S09iLvruogytUy3aAfptat2LIAyVkqnNLOQ/s13fXsaBQVqFLGl0agFeF32AKt3XhofVXWsrmhLnOYzvnv7NT7+SCIepHzCnE61dgVmViNkLqCZeuZzNw+6/co+ZOpEWiuprgFECKTlGG/RP5lm9NYDBGakbCN8tFvXFji2tsP2935Pr7WxdqH+JiDeAMCDNTVOSUUIFCBLSi3I0aIKsI7PWjnX8hSXlF1ipJX33jvc398XoAtzwjjuQE74onmeQDSszqgW1NMqoIhIFaI6r2SR9VIDBkEB4Ng8SHl9JBNTVA3D0Cm2qsKvYQMWvEjbtiWYKEVpCCkQJjtoiicxDEvqycXOkTMIplTWZ7LwGgASY06M6ZQR5wTiiDGIgo8053mb333J+1jbTEGaDWzWrpdm3I2PsHGU8eCSNimlWFIuSb54BXWUjEhc1pykO6rRm4xSA9ZZr6P1ud/yxFv8DRcFsTLgkEguBjTQi+Gc1xfBuYBh2CtPVHlWR9Lvp6cnnM9HTNNcxi6EQYyneR0dxzmnueqB8/ncgXu83zWGb/U2NiAEy3oJwyARh7ykc/JhAGMGQwAWiB5EA0A7MHZIYY9TZAQPDHcP8AVkoztw2fsI5ynh8Rjx4KVu70cENwBIYI7ALgBhDybCNJ8xH9/BO+BuF+DyhDQ9YT4fECjj6a9/huObh6JAd/wjjbAE5NQYlrmJaEfcgXkKj1QiVtTv7OZ6dkpfmC0qiXFdOq0gON23XPdbPc2XdVzicB7f/AL7j0YM46fIJN7UNs8xRkzThJRk//TeF346pYTzecYcHQCv54MYvcbhDq9ffwJHHk9PTwrarybfxKn221HZp62nSaNYCnzGGk6QlKp6LTkMFOD8iGM+Kr+tXrKcMP/4r3D/6gH7/R188DqmQaIqBuHvfZzAyKCY4GOEA2P/4PH6vz8jpYw5nvH9m4QQRsTTEX7cY/zkDT7+8zNGt8dXf/UlPvuT70G7t3h8esQ5jhhCQOJR5JpXEXf/5b+Hd7bWA7wLGPwOMRJ4GJDwCVIWkJAg8AAgAa9OuPuLv8F+NyB4TZ0Hjzh5/N2/eY04iaEyRSDNCVNiRIamBkw4HWcBfikPbuvK+KTCNVwFRWzxwZdkkC3ufHFVW9cCBG28nv21Ky04aptqpl3b11uylieMD1u3kRbXPcfFb9Oaw7vM8W2V+dJ6lrTkaa9fV+t6mczQcpjr8grvvQCitzNsY++odxHZrqnfuy5duyW/XJPLrNxtOe3l8tPl6347ye63v/slUtwPXWE3ep62Z/C3lferZHldxty+8/pu9D407IB//T8Qdg8BfvTgTJijgEedC71e0yInX3siNSINkVfMvehndzvjUftd7bmW172DQSHA7+7gxzswBxAPGN0ePkiaKCKC4suFTybG4D28Ixz+g8f864wv/tsRrx4GMKeaApkZRCK7nI6POJ8epa33d/jmf/sYT//wCXL6WCLKUG4iyegeeCFa7fXzU2Tp4+MB5EakmJHmCZxnHE8nnE5H5CzAHkkjCAWna3QQlmjxa7luAZxVucdkmkt7xZb+U+RRt3n9egdu/7ZlbOt72zqXdbc6YVnuzelT3ovuRHw5TCZkleEIc5yKc4BgVWo0c7OXcFZNcWUiEFSOFvCIceA1AowpXpZA81ambr+3KDi9rqEdA5Ty2nEw2VQA5cbbMFqZcRgG3N89YBx3YE6Y5hPm+axjoI5KxaGIit3CqnHOqezb6yfaeVjqZCyKb+skspzvtcMLsJSdb/Tb0Q0wc6Mb3ehGN7qRkjAnvjCvKIyv8ZAeRDUFUlF+FtBI0guFofSqu5M0lIx5PovCTxXknDPmbF7BcmtKBh7JCyZImd0roAOja+CR9rvltWb0MKMeOYi6tTD/BoxoxRcUw4i0adUaLBn7dXu5XCogjlbRQ2gR6y0tDXRbyPq+nvJrMXR0zbzYwPzMBU2bYMatRqDq2nJJdLVwmKqMJC7GLwnVXcebdI2ZcLUUhGzttoKVGHta4QdNWf14bRmXqpFJ4Bpi1+lzw4rhVAXGMhY1HUI7DJcMvvZZ8u+mOkdMaNMmdXUuBLtrkIQtQyaVMWvnuTGcsHn9W2jcZlVzlly76jEPZqSckDJAY8A4BtAD8OV/8w3S/BaHX36Mwz98CYBqbTJMkkYMQAIaY5GMeIJ4VZuXzRYtFZ/L3zbHY/W3KtzLvbS+/lJJS0Vqp0xo2ndNgdObI36/dM1YsNXa1ghyOQbP+n3diuyA2b5XgHNb3lLUeUwuQTElvVlz71YZ9n19NfPevNrvlv0wFeSm8aXp13Llrtt1aQSXdV82ARzf7vB3/+uP8KthxCf/2RHJz0hpbpQXAtwrfeO6Z61r4o2X/mJ7rXwo322fO7Tq+7KuFryxRVvAly2FiEShuBa5a1thxt36cXr+CHBAAA9Jo8kAMvYapcBRs3eiK3/pBXWpzS055zAMAwBREoUQME0RcZ4wz3MBbVwb6+XLlFkSqaVVsMme68q42VPQjlH92/KCzskZmLPxg27RDntTnykDJjAXlIiCLTxMAQ0QUpJ8YaTphISlaPpLEq46L046ctWUG2NEjLN4UDIwBAFUkPdFab2lhLMzrB0DAwxXsFGraFyE1l4obOt3uSolSQBBUl27/rWvGgo7Fz7G2pab/aYMr84OgzOv1rrUUddCxzPa+wIoF/6/eJDaTkN1bpymupJ1X3kbo5SygoCaaB6ONJXOAphsbXOSBoY1X73wah5MDcxD15hX8I49h2Jk8Vqf1/KVs2BNH4UBhBHsRjg3gEhjobia2oZR+TWjEDzG3YBhDMoDMTgnHL9lfPf/DGAifPGXA3afOXgwhjwiOMbd6OBTxvfv9vjVX30MAnB+t5eoHoU8ltTOpcDZ665iu2/rVZwXu+qCixQulGoqTTkn5dfCzWmlBTNV2tECZgSks6zBrv/7//seX/0t4eMfZ/zxX9Y+GsAr51xAMhatyJ6PYRjx+p8xXn1BuLvfwQ8SWj+EHfY7Ro4Zh8MZYJOx7LzKXSvW2yqhAi8dGE7BdwSCB4gVSCFAE+8isoavJ/ISkt6fcJyfkNyMHe0wjiPmWZIaPf1ywPk3dwgj8JO/OGI/EmBh6YkRBmCOGfHdjPk8gVOCJ9KUfwnDyHBuxh/96xP8LuE4M/wYEMgjDAPIBzjH8EEijIlHehB+h7z8HjMSxOgo2XklxQMRxLHFJYQQsH/YAZzhncfgR7iTh2RTZUzzjMPTCUBAGO/AWfhvGU8q/JU8I7aO1uDg52i5Ntv1w4t37a/XTkuJcFk5agZr9ku5qzzXmvfJrrKok5e51Qqy2OK0LkMwltxhreN9efntGnrp4nclH2yP+eWZaNt6rU1bMlF3fjdgmcLXl93I9jx5c2lu2rra6KVbThbLNmzLYtfeLXtzma5zfS+74n3v7MfxJfTyvvDG+xtdp2vr9Rq95J6XltvD/LY5yR9W8prGMePP/+vvcI5HHM8MHx7w8ac/wd1HBD8IrydAdVdA2ZKSj3qlyybZNXIeMoT3JIUbpyTR3Ki/41ppAAA/zvjyL/89Jib4168w3r1G8DukRHC0g/ej8pyWA0pfYOXlJ5GL5oTTVw5f/88O34WkvDYBCLp/ycmQ8mvEtAcRIXiP87ce+WSOZZaGSc7kDFQG7kIPtvr76R99jU/+6C3Iv0IYCd45sJY4Dh7nQ8Q8nTDPk8hzAMgHTedanQWFb8NCN09lyfQy48vXzTVHm/ehS/Jw+1sr95mDRScrFX5yscurfoJA1fGhkf0s/Wh1VjEdAZf7WIVmiYTZOjMoN9LI9gaU2RqbJRik/91029TxxNQy+lhHmGG2clhl9r5O00vs93vc39+DOeE8eZxOhPN50v5nHRNLBeyKDCCypbTLUtX289S2U+0ARAraUpmi2ROED3boNWaNPmBDJ3GjH043wMyNbnSjG93oRkreeXgfiqGnhsKT31vvUO9FiUfkwJmVQcpIccI8T3j9+hViPON8PmGeZmFkKIMRkVMGkzCegDJGZEpxjR5iBhKNHgJgJURdMj5tG9LWoJnWK7s1KJiByTwWCCIkCIhBUsZAvzNGOpeQ3w0Taqq/jborsSpqawqiGtZfGUmu95tXrqTO0r61jOQV8Ix5/JrSGeASyUeuW6s/RMHcK/Obpm8TVWOIGXLEmAM1zlB/f6lAGXY24dPGHrDcxYCUQayhQrOskWzWOGraWgxC2gey8eYV8Ko1JHk11C2FIutPF3SyLk4ApGh41rXRi68tSGdp0GrbYQY2UCyCg6l/a598awapYwq6+Fws+9kavanc2/epCFGdkGVr0XL5ApKLTZ9f53CaIsIpAm7EfneH+5+dkGNE+j5j+ntX6hSjmISDrQpOMfKYV2sGOrDMh1bQNSMnI7kEaIgWvoxVP2Y9LRWJyyeq3mfq+3U5vRHs9w+c2VKAv0z9YSbW565av9+6qwXLLCEznTJ4I1oMc/90tCQquksK8GX72uDva1rO3/Kqul7W89je27bmef+xy/ORzgFPvxEl1/jZDLo/IaUJkrLB9DCkZ4p9tmccNnilhWLDt+hf2gsGUlYTxEKhYwCN9nP5fXF+87Ie7pU8dj+xKBC3jKJtfUsl2EuVcK1Xo6UpASQFhrWzKsL0PHFybpMjcOrraetdAizWyi316HI1EsnxGEuecSKH83mWtEWARh/BaszbPd8i/9UvCDHVCHIG9JH3YsB2yk/U1Ey9Mt3G1Xa01KTMlHIswlpVOG6dQ0WpyDVimYOAHmyCKSXhaTRVU5kdUp5LjdIxVW84IgJ7VbwTgZDhnXAQTvvMumYL/9alGSQdKuoANfZ8mMdcm8qz5cmWYJR2jy/p0MpZyd29Nt6m6OwUp4trW+py2S/O/S2A2daa4aKgVAWkepFKehoFx2podln3NR0Ts6VlIoTBw0BBIYjR/nzWZ4Yc2FXATO9ZSIBzIM4FSO+dpJfJtj/pTk/kAHtZfylIm50DSMBQyDPgPIgdiD0II4h28DSqjCOeonme9XfjfgoHCgJjCBm73RmE73G3v0OcZ4ASpjTg6Vf3yMT4xZaZegAAIABJREFU9M8nKXNgkPMIlOBxRsAJJyYcvn21ega2qJyDGk0JANLiPGX93Xbiwoctyuq5B9L/SdKTkZyXuYyqmv8ri7NRZz2/2p3B/j69GcBvGBSa9U992PQQAkIIKx50HPcYPpe9YxiCnikOzgWMwx58B+x3J0kp4gSgdz6L40VphxnGuvUPAY1AoqJKqrEAUBsbxIGcfBrGjBjF61uiVwJzVOcFJsyzpE3g4DEEj/nR4elXAWGfMR+PYmhiM3ExHO2AnOGRMHhgN3gMYY/zacKcJV2cdwH3HyXE6DDgDrv9gEQRzg+yT+nzwhSQWYAxNpMxS1SyjKiBl8SxIyPJ/hckCk7wI+AzmKPw0OSQHCPTCAaQMiNGhvfyrDvy2n9GdB7O5BaStWL8liu8er9Wrq/H7c+rs6as3GvQYL2zAc205tEKFNB1q4C3bs1faTOaEnW1Lvj4/o71k1qvWZ6mH4JeWt5aot8u69IYU/P/+7bncuShOi6XQOtUflnf2/LMW7JBqYFNdiyn8OKqeiev/u958ktUV+tlepns9MPoOdlla3z4wqflafKStXOjl9Pvah1slbu1LpZ7Xv9t3efeV+q/1CZyjIdPj3g9EBLuQeEj+GFEGEcwVOcJSUXkKKA80V1kmUY2A5Sbr8knDcAh/KA8iYkjYjoi8+uL47Fsa7nCZQyffAuEAWH3Cru7ezgaQREIfgdCaE4mBlyFs+Q8Y4qPiNMZp/Me6fSAp38ALJFhv7fZmI9gDIvnTPj/TKJrrCnJlw43xttd6pNQ2J/w6stH7O9fIcYROUbM5xPm0xGHp3d4evoeh6dHxJTgvDi0+mGED9JXS9VTdeTadpVPRE5Y7xRbcnjVdeaNa5svFsX1Z1TTu6JU3ZZvruve+zYt77X11VaVUkQ+W9rnyseaXNs7W4qcbXKUcw7eSYrWnEUWBreRWcRRhCGyKgi9npbXsuBazlv3pTzfjay5GIHS3ks2ALvfADD393cYdwO8pyLTzfM7gAhBdRT2fXsvHJpItk5SO3VRR6UdNQ2zRFxl1e9btCOQU367Oiu3c/chAFg3qnQDzNzoRje60Y1upETOdQwOs6QIMKOBMDC+fO+cIPudcwiDhKieFERyd3ePd+8mTOcz5uncBKBISIZQt4pZlF41FYAIRilGpIIGN0R/VfC/Dz3HQBkQxYAuzBnIIsyZEaOmMUh6Txt+UPLogpoUPDBB41Kl0vU2TCGAYtgqgBksmWXfpK/YUN5tVUgQ4EpJbVEZY2NGKyK7N7K4xpBJDfPdNRAK8NGrnNk1MjR0parHGCuGtii8rdzcgqTKDwCnZt2QRDbRdhSvbpEyFsYjbV8z8HUs14JWSytvcfSGH6BNL2EC01oNa8O1LNuMRz1YpoJmDJVvKl4bcmIzTm6t637+tqjvs4m99XYTgtdLyYzbtY/kuBkXD0cO5ynBnWb4YcCw22EYAyhM2H0K5J98B07A8ZuPkbNDbvaC1iCk06bRZ5bq+b6n7Yi/RIG0FsGpfL1UxDIklK41KHclXFY3y+xUBX1bc3/NugTr7XIl/S6Vr9foub5WWq/Jl9zVl6BP+AIs0yuDr7fA7rMoNK3x4tr6aMe5V0Gs1fKMXgm/Vkja9+v5X6g1mv9tpHnjV+7a0ZYxfvSIsEtqPPYgOGQ6Is2S5oQcwbHtQ06BEaalapQojPLZsHE1PoymD+IeSLikpZKn78VyhOp1ltqozDrZfkdNu/p6gKqAkXPHZi53e3erSFkCHax9dTxdiXJRzjXKJU2QgUJyTpqaqPIBW6CF0tPVmCgo2UHnJmOek0aSYYnG5z1ijCCEkgrJzq+2PjtH7FyqZ5Omzcn9b9WTS3grUV4BQAM+1WlzjQHcuZ6/McOm9Bfl7O3BS3UMlopF7z2QFayhkUzaOCoEyZsu0UpIo9oI8HeeT5L20OpKCsZwDk7Lcl4NmczIKYlikhSw2c2Pjpm2uQUtW9+2wMj2uY2aUdNcCuhaWZ/Ch9i82xnfAr6gCmoiA1rZ+tviUxZn2Ibi19rXg750/stLk6GShYRU0ziRzL+3lEyagtXXKCG1TAHQVK9AlPksqa9IZIgQQknpVZ9djaxBrqyxaUqwWBb2NzMhJyp1JgtTl3WfJQbnqOtd+SQa4GhAcAMcJXiXAJqR0hmMHZYnTDFDHD3mrwhnnkH3I6YpgogRv9d5B3D8epJzxhECJElYmhM8A4c3L/NwXJ1HZCaTC7zbi0qt11bOdctAbJH+rsgpaE+I9v++zcB6jVrKLYtGmlKzv5GD8wGWNKkYZiAwNx9G7Mnh/v4VkCUiTIwzYkzFpmZrqD0DSnuoAsKgYDDj16V91RkkDHuwtiMEDyJgGBJ8IMBJ1MR5iiB9mHevGfzjGc5nvPuNcqbNZjHsCQyP7Al+ZARH2I0DpvOkwH+HIYyynpng/CBe9xMDLqiRnwXcxAFzWnIjmpKKEpxn+OAAzuCUBeDmHZAd4uMe53gGwwySjDRl5CRz6HzAOO4RwojEsv/5IOktCARJkSObmG4HAt1nTekFAExg2lqx2yDh9v2S72p5nPcBzVgKJntVtwzdK8DlXCGLFnWhvJZDWbZrCRCq7V//vtXnPwRt8aRLek6+2OI5r5Z3NU1XO74N/1B2ggqSbechl1GubbE03lvtstVDrEDB1fxU+aIFBK4ltJ7Wa/YSuGerx9d+f76Ua7JL25IiA/E2/Mj62Y5vIwVcrM+4suuxMG/0+6CG81vN06Xndb2v1c8917193fV2rGmePR7uX+Fu/xnYPeBwJuz8HXKeAI5yNFspbGCMrdZffi86Ta/yY0LOZ8BNytls3Xmd0Zkmghv2GIZ7+LAXMA8B3kmkQU4SSd05BmMGEAFKQJ7w9pcnnA4HHN84ZDxIkc1eSFy5Wa1uBYRpn82ENiLampYcXfmeMvzDt8IXjCfE5CVSzgwcD084Pj3h6fEd3n73LR6f3uF4PML7gDCO8EPAEAb4MCCxjKnpNFv+PGfjGdcta2Wd7hRtZN9WDuxEqq3oQqz7OfWzly9sm9fsA72c3qz1lb6Tms8ih+UckZpIrz1ApsrURW+hC7zKsYKxisxgkjS9FTRj75tzcSHDtW1d9tVkeZNb+/FtOf6LIyP6ZurLtrpTFLC69wGvXj1gGLyuDUIIEx4fH8Fc0zubvcgARSkneOdLatbSbhAy12ivLT9v8kNWp1tWp2UZYNOR+66PNb30LcLMh6IbYOZGN7rRjW50I6WWybXckYYCljDrFkFDlP3ikUfww06NKsIU7nYjUko4Ho+YpkmEBOcQYwSY4DSfOlA9lTNLiH9SsIR813DRykjW0P0oRpza/m1WcMlstt+191i0FQLUq9bYSzMqQZlmEwKoMaT0ylpDlVtd67a1ZtS2HJuDwivrey6McGvw2qJLgBkh61dlholU2ViGqGWY9XMHjlGGvYBE2nulIPmJADWSiIdfa7Ts6+HMIjPn9VxJ8yvi3BEJAr/MQd+ApeFyOdc2dHZLAWkt7mu/2/JeWFI7P0tq7cttmZfKAsx7xtpeDaJbAl9r2LskWLX1r9sCoDU+Ngpzm+Mqf1RBmBtwUFVzS4PEYUIMB+Q8QrjHR//iG7z66d8iP834h//xv8N8GqHJFBBVEWeqd9buLZV7dYT69++vwOvFR7L6uFc8AqKYzaxLeqForCr9XpneKlSB6q26rdztFbHt/UtlykuV1h+a+r5eo5e30IwddtelObykKN5K1yS/VWW4BYDtZ2nZj8X5YOV3JS7vkKtsvZoa+VI/XtI3KyNvXEGgzXsA4NOf/xKvf3pAGF8hhDsQD/j1rw+YD1w8xi1PdtboV9wYKNerTPZ3Xny21zUA6g/17unPBC7f1eJodX2ruHOOYVFqZL+sgMTlnrfFDwBcdEVeQQKi+JEIelzOoJrmiPlyTKUtvqNtQwG4EJSvEuVvCOahJSCSEAY4ChiGEc6R8l21HGtvF1UGKGCZGJPyNtxu4h3PIUoqlJVHrWayLPye52Guhn3WPF/rs6wFzVS+xlL7eC+gBzk3l+cbw3nCMARN/QQ4DzAHECccpwpezZyRYuv154pHnwE+apttbRlPIG2s0fZqFBRZY1nPBTHO23UFCJJzx0PI2nFIcS5pZFyKSGmZapQVuNayVlzmra4fA5PbZNT1tfW+XwPcjMn6XtutBKKgOzwzJB2kg/eyBp33CD5gCNK3bJF+NNVSyhE55wKGEFB9KGvZwL/eO4zjCBAhRUnHasrTMAzFA3OeJszxrO1TMJW+F49eiXIle1qrXCWMoUbPsvGSZyyDaAL4AOIjHOayJo1qsHDG4e9e4d0vHhDB+BUYjIeOaweAX/87eWaM3WUEMF4DeP2iU/ASLwBgVVd/zcv32K0r23Nwufu/D20Zxtu1aHPbymwG5nOkgCfOnZLe6dbjnIMfRuz3e6Q5ynVg7HZ7zCk2PHxESsYnWxukHItQ1RoQrB3lebA/JfWYQ2aGDyNAEp2F4DQKizz/Dz894pM/PoNPjL/9n77AfHLdyZU1be/dTyMefvYW85SREhBn9TYnAnkxbszzjDkmzGV/kGfHnvfarra5CgZwcu4RkshagxcnD57w9NWAt//2s+KTL2lN+3U1jiMeHkYAHuc5CSjMASFkZI6oxj1q3muQfCYwtf7zPQ+xXBkv4YmMx6wRAF8GmsnEAjoFmlYaz8Rl52gjV1qb13xh35ueq7/W/g8LItju8/PjeolX/qFto8VfAOsUqG17roBltuSa/u82n10ALSWikLElBNd8XpIjIIOQWWNtdRcJiJwgIF0Gl6gObbvq1dc/X+rv+ur3n4lLc9pLBb1MVFzPeF17DxCCGu2X4/N8m7ae/Btt08tk9/6q569fzz+wlosvrT6mugf2v32IvYww7u/g/IiUxHEuDDskixKBpZ5s+eT33zHXPUL+mBMA4IgFzJDPYEy4u5PzeilbN3dfbDNjhxBewfs9JOI3A3ACuGdWOdDBewiPyjOcT+DE+PW/+RTp8LkWVTmson+wiJjlZKrPI9DzZABKSqbnAIhLLQj5iP0/+z9x99phHHY4n1/h6emIx3cnHB6POB0POB4ecT4fMZ1PyGlWYHPrNCsl1yipywgq1almSQt1cd82knLrtRbJswWoXN7xNmq78D2uyj5betfMuTh1mh7B+lOjytgYtDrtNkWoPlOmu4U4nTid1wwGzFFCI4+yOnPIfdarWsb76FRaRw95n1Bv3x7Dnr+0+e3LzCz2mmmaME1nDIPw9sMw4ng8gcgh5xkxRtVFkMr65nQNdWQxODPBe0kzmpPI995rBNcyByL3OSIkmHdEjejattvqASSipd/Qw9/oh9ENMHOjG93oRje6kZIwLDVcv6RdYBFInHneRjBneD9gHCWUvh8GxDQhc4IPHg8P93j7/Xc4Hg+Sv955AAKQIY3lLDkvo4ZvV4+vzEhxLqIEozJ/jToVRL4zVgDbIAWjpTf8GnSAhvEVoyIjF8OQMc8CmKlpjFpkvDCUxtBVkWdZV9sUAZ2QjI8KEQZQafnj1rgizKLkB70kgV9G17O4spfRbMagGBeW48g1PGRbmQkPIgXW/pCtE70PBMn5KwxyzvK3ek+zKKWziKoy5tutd0TKBDNiEiOgt4gKVYYu/bNxKyKpDqoYrkQY8uo5vVwL3QhwNbwWbX4R4qvRpqbRCHp9VdRfEurMCGfvOyNYBqApJhzVqAG1jfaqa2G5rrciQWytDwOHWXqkrMnii4GDuKRQK/2hdoxt/ki8cDkjzzOm0wlHD6TkcHdH2O9eI3PCN7/+SrxXVBHgQQjsirdzq/TO6oHj6kxujmWdlW3aelx461dN/+SKd17zZDAh2zN6oaTtmrfb17bppSLxyxRvvxtaGhWg77ba81x/ulRyTAKeab5/ro+yZckeelEhuLFaVOReqpgutHexF6DvN7qVauVcLsnuX7Z3qdiztX65JT3t7j7Bq48+gncjjocZb98+4nyK8C7AB1/ObTlTG9BiBiwHe2+6MI9y3dvMQK6Kk3xFs375/LlOJdJGV1YT9WwxIAW/k6HRX3yJLEIEFOjdMwoni7rCOSNHAQfPcwap1zxIQEf1XJH90iKEkH65BdJcRrip/RIQqXMOzpPyFgJaMU+0nKEAmgHjsC+AmZRCGauUEmKMmOe5iVrSKwRzlzoPavTNHSBC8o9zMx7Ck7QegSDWbDhcxsX2/HbttAq7lsZRDLM5u8Jbydlqe6w8S95TAdQwZ8zTCRLlmUqaTGbGsB/kPqcefWmtaLMnNGaAOQkIe2U0J6B4o+p3qtSTKEIagYeF52ijqxTgic6zRdPIOWOeZkkzw5Lu5XB4UsDIUOYupaTedcZ3W0rHmhJKvnedEro1/Ev9pqTuv5d1lLvIQtbuzC1km5FYAElEQNDoRkSSGokyA4HgvAcoY57OmqamKi8N/C7pWkfc7e8BMM7ThJSTPKPOYY4Zh8MB8zwDRBiGAcMwgCaRCaZpRk4JUD5KAv+QAq/RPVOyLXDZHjIDKcpYSNjziOSOyHkGM+FhD+zCCSk+Yp6+B/jT+kyul6yup+WZgmJgLHJKiYz3clrWZ2dge8X6VKqnSD03XnJy2XUkz0/5ii56OG+d65f5JxSFevXwlLm1MO62Pzl1RiAiwNIMUV2zntp6GOM44pwSUhQ5ZLfbYTpEpCg8aUxJwFcqH5iMmdRYwQaagUBRa4Sl2kPvA5yvKaMIwP19gA/AHCfEOGPwDjGeMc0z/NlhnoDj2yNS/hQMtzkLZhw4nk6YpoQwjIDzyADOcUKeBTDDAPwQ8NFuD+81kpgJEPqXIfKWAdqypqOlrEBPPTscQ9Z7NKDB5fP4fD7j8XGCcwMSC1DocDzDu4hxUNm88DQtX1Z5wPb1Puv/EklXKofGG9xabUdzH4njDZHuZc3zs3yqDFxjvHytm7p379OfD9H3S2XWJ/75euqe/vunpWF3m4ddSngocl/VoFwuI5c02QJ+gu0XGyCBCh4xWHgvi5mMZ7t5YkakLGvpqqT5MtqW7bZW1vPr275bGv6Jl5F5qsxao3TK79anRAXmWVqSNyLj3ujD0fs+j9euv7Q2AHRgmXYtbJ3nzP0arfLyGlAF9CvjuafDEWG322Pc3SFjRGRCylGioMkVV3pE6+/JibhfYq5IG3JOmNIZ0/l7TPMbOP+EH/14hrcUkRf6br91ZwN5DMOPEWNASAEjDYhRZABwRvAStTLGI06nExgHzPMTjofv8fT2hCn+V2AMzRjVsVrL/j1opv+/3t+n4WzvXIxUq0+BA9EnmKeEnANSdpjPjzgdJQLO6XTAdD4gxQnECQTpWwjCd6QMZEg0TkD08zWiTCsXXqJcet26/9iJLI4O7bgTwA41wtCl1b91Olw/qZcyUZsqtNd7mCxlNgXUCN+q52UWGwZRgAF/cs7KswWEIDqIlCRds8iTToCbWVLWxhgRU0SKs/J0Juvlei6S6mnQ6y+25Lv+d/ssv4lMBpUjXYn+uTVGpUhyRffR2kXmeUJOUubTYYeHhzswZzw9PeHt27eYZ0lPOwxDaZ/JneNIoncHqp4chHmeRb+s0yiYeHGqDmEAGIgxqg3B6XyYLJwbOVnSipqDhkWavdGHoRtg5kY3utGNbnQjJefFW22aI2KMMG9nM0AIoliEgZwZc5yQMsPHCT6owSlHpDjhm2++xRAcxnEnRixAGGIwOKfCIKJRkUhqAmXQ1FhUFKkNKtkMfmbMXxqjVv0qCPnKALbGA/u+DasvwA4WhXInHBCGMKIgzjtVohjVtjx/63eth7f2B6Q2KEsfUI2uRWnYpc+gRZkvIEInoHC1lur40gWZg5o0ELkw4v2YV4GjNYSZ0lzm2RDnpr4yP+8aU98UwttTacpT8yYmCMxCUmMQSA1nFYDiGiCNfKbGAIUCmFmunXZdtH21lA0lzHvpc/UAr8AgoDUeXrMhL+uycqX9rnjet+FquaSx0PEsAk9erem2T5eiHdW/9Tr7bPlk69zbfDTjRBZCVIyocZ5xihkpzpjnE8Y9Ic8O2DMcjxj3n4HJNaoPkhXCYkzpPODYFAe1lb1qr30GL4xx10N01/PiKvstS3cWCqfeOxXlfX9/qyjZoraty7YvFSb/WKnZibA1+le/2ejYEijTKoeXpRSl8UVPumpi2BrDawrHVR2L616iVu7XmHzaGqU1bMfuu1Qr8MWfv8XD5wnOBcQsYI7XX+4xxxO+ffsWb797RIoOFk0s5yj3F2WKRkbh3JwpS7/aCgixszqXyBcAuQ8vQrd7X3neVHF0abQvRYqxDXfLQ4sWv9ke6cjDDx6sSpqUYonM4kN9xkmVXylFAB4WdnjZpnb/3Wo3sxiZ0aRgtKh+FSRbQT/zPBWFm5VrIIUQJJpHy2+U/lnqEdKzj7KCcgycEUuEmQqgtfVioFfbBdsd14bZ6hTg63IM7GWKLQGHVABHBQKjtFOUYVa/FGpjkTkhxkmAJiCQgnAlEooCS1m92uxJZgCc4ZhL+Od+XbRphipwXMCvytewh99JGtJ5mjXyYm76JWMXY5QoQMw4nY6Y5jNyTnj1SkK0T9Ok4FNTJlv0J42mwK4B0Ng6oqL8LNNDFcQlz3Nd3y2oxCIPLZ8BR5r+ykBmhT8jid7CIg+EMJSISzFGPB0fkVJs6qgAIgORc2awE2XqHCN8CAgDYY7yTDFQUjARAdM0l3aFEMA+VHATMRgJKTd9hDNuW9P1eMAxyHkwPOBG+LDDEAYM3mHwGUNISPMjvv5rj7f/6WOk+QFpWgPEW+p3JG52R/nfvH+5+a69c81jrOlatIbVtd3/VUrYrmWrDYtTido+rUHA/Zm1bicD+KP/4ns8fAaM96+75x3o94H2r5HzDXdVruFSeE4JOUcQSeo6YlGqD8MOzsuz51ICh0FBjVUGSDEWY4Gkmcsa8QkSQbQBuYQhwMBY5YUM7xzYe7nXOwxuBxDjdJ7BOSJjxv5P/x7OBQRvEa0I4IwYE07xDd49Pskz7SJehQFh8MhMiCo/hl3QiKYi4zFmxDipsQTK/5ohxWQsPSvYIeQAZIcUCdkRyAPggHF/xsf/+V9jGAlRPcgfHl5hf/cKj8eIaWaM97IXp5QwxQkUBvjg4B2B0jWozWIt2qPaSa4/HHDQPkvLkiqQpm9L5WS4fNGu/eX1gOgbLOVrz4NT+X9Z1x+K3rcNH6rNWzLT+9MadrWE6RUVx0b9Iv/1+29urnAqe2IBEAF6s/yyfNkF6nryyiskMED5g4BmrCXbJ8v6ukufDfzQ9rECImq0nPa+pRxh45iRFTTT//q+fW3XxT+GZ+T/b7RaLx1oAqt1gg5M05ejXHh5SiViXsNfovI55Tmmy/NOBAxDgHf6tOeEiWc4vxf+PK8lbins2k5DzW9yuKcc8c2/Szh8PYDzp3D0EZ72Gcev7qoc2ZSw/9lXGH/0NaYTwOwBGvD61ad4ePgY0wl481dfIEXC5392j/s/8cgpYggO5IEYT4jHA+IU8dW/3SHN98h5REyvEeeEFH0ds2Zstp6sHgxdn6D2WWIAr/74V9h9dEAIAfu7EbLz7RBnYJ4TcmLMc8L93QOOv7nHu78f4cnj4f5LJHcGM+N8injz+B3m8wHn4xPm6YSUJ3CekdIkbVGnGIsKLl4czYnegCp6h72tp58b2a3qQE3HW1NoWnkqo37gTcRpmtltHau1s5FlGaVPArqv9xngRJxMaPWylLVS/ow1mWOlRJPpZGrSusr6t79L3nixn28cmC1gxuSz5wa26qnbJ7x33GB2cMQlewBRxjSd8fXX3+Dp6QlEhCEI/z0MA0IYimxoIBnvA1Iy243I/uJgUvUCrGNAcE00f5ujNs3v2rHEe495jtqrH86t3KinG2DmRje60Y1udCMjZsQUMU0nzNMsCkpihDAiBFcYxazAmHmeEZPkj72/vwMgBvLpfMZ8OiHc38Ep4hoG0GAAcEXBvTTiiyITGm3AvtMoLBDQgHhe94CZy12y8g04UJmuZd0t82lekjosC8WvKs/ZDBfUMaaZs3a194g1MsCBAAy0fFSGvWOCTSotgqvd/9tRYUob0At3zHqt3nnfKJIriKk1MJkhrMwjWuZeRfbmd5GeTGRcCgH9Z2oukagrUCCJGZqyovmFSqSCZq4qw00FZU/kO1G6RdMvv+s8uUHFwASY57OlGatGTFsf1l+LULQF0FlTbSeb5ryMbTUcyXVVmM0MWNoHMNQbgpoVVNvQG3mXUZjqoHPOkjajG0MHlDQJuch2Zutwml82pxnzlAAmnH2AZ8LoHYbxo04hQ6ghpEnH2MLai3eg9EfFOGmXvmcipKLOQfntEvGFT4xetcJgiWhQ1mONgLL2kQSYaNGG2s7lDHPzf6+ar/e+VHfwh1RUvkSZ3iqtqPmSwRsKvmb/uFgedZ6T164FagqWLeXZlo5mWeblvvUKxP4XFAUlk62s5d66hsWU8TAvWvSrBABef+nw2T93cH7AnCz6CfDuuzMevz/h8fGM3XjXhMJt1HYSBRisSgZqIGt966tHlIFQCrbmt1JELEern4G6Z7cz9fIVXgAPpOBGTii4IJ0HZ8+p7pVJkCLIyLKuGmVgBwAo+x8XoIQBElbPd7PHrkGz9l5BxqXfNfWejYucZQnguSm37auUaVFNlm3IWbylO0MwC8BAlFlY8DnKFzkDK1mbDeCy5j+qgbk98KBj5RsFV69cLeMCBb50irBcX0jK82nKJFXqcYamyLMWyp5spTLqWNp5nXOWIHttuxkAsoyh1ikgJlET5Sxj4b1HGAeJ6IOpzHGbj52NmQM0soYo76p3Xw/gsnNbUspAU0fkZh2slaXtuMkzaWus52X6c77l06jhs82D1PjXng81IE+MCTmf5Tw/H2B8j3MeEkEnFhBUTgmz8mWHwxHMjFHrFCA+w1JmMYsClojgLX2Thib3oQX65G5pCX/rNZZ/AAAgAElEQVTpygdTwJJzgBvgwg5h2GE3DtgFh8EnhMDw6Yjz2z2+/+VrADu9vT+n+x1KYBVt7CuD814Gy9TSnt25rl7Ql6qz2F3xkh2SV9etr277fKks43mWdX7644BP/ojA8PDe1hoXuYYhcl1Z8yBYhC4RgdqaZQ8h4/dyQo7C3ZGiZTI3Rh3lHHMnk0hpqXleume9LpvSM6eh4Dnr+s+MFBPYS3u99+J9jQCJupYEUDYSOJwAMBLJvumIMZ+PoBHISKDoEdwA8oOAxJwDJ+s/VbCM9r+A8HQ7l2cwwcDzzkl7yQV48nAcwHC6Zznd7x0oMPZfnOEDENKEMAwIOyDiBABwO4dMA6Z50KiqMiKjdwjeIc+njTWy5nlaKc+hNax+CNAMCqdduaieWzbOyq4x8Eum/sS52BLW/bJ76tHU2nM8l5+PPywv/kOJFn+36BKff23/2eLy+jLaJ5A277PPaygfIJHmZJ6yPAFgQpeiqeHkut2LF2W7pgXBrlHm4kOBZq7RSg7Q/8vccJUXur+M7ju7dxMoA0s5JanZfki/+ifi/4ur/Q9Dv43E9KFqp8VzYb9tPf8MY+VbflodUApwTWWjZh20/IUHYbcj+J0+Y5kx5QjGDGCA8Ndb0nh7uvQRRlsHLUDPfA9Mb4DTrz1In94z1s9QqWV/wvD5Owx8h2HYIYQ99vsRjjLO354wfXOPdCakn5neMwHIcJQwnR/x+Pgt4inj3a9+inQewConWIvbFErXnrBlEp92BNry7j+JePWjiBAAHxLm+Yxh/AgpeZyOE87nCR4eD6/34ANwAMGTw27/ERJOyDlj4hNS+h5zjJhTRMxR0uBwgqWcNd7LkUWSDI1DRysjEFogTE/tWljIeVxlmKXDqswlmpR7W+O2/J5ru0vd/Wy353orD1X9/0KeJVsxVWYyvbUBOiy9r8l+JvcUJxC9v8h5zAo0qW2VOhUkZPxyEby25Yaic+7k8p6KvoelErm+lx837lrof00npOOWqybTUpLO04QnTjgen/D09IRpmrDf7eXuRi8in0Vn4pzwlclL9FpHDuMwwnmvMmCV6WpkHJWLFbhk0V6L3YeB7PpoOECErdcbfRi6AWZudKMb3ehGN1Ka44xpOmOeJ6QU4eCKIjxnQkrC4MU54jydMU8Tshpf0uDhCJKLM2UMfhAfUOXrzBjAijR23oO4SRfAKMZ9KGPLHXPZqFkaBrBnfreZSOqMAkDLDFvbTFFZ6tsATxiZR3EbYhyo4RvJrDhMQAELVeObfN+rml7C3LWGtx/ODNrYcQ9MuahLtIg+QI1kovUXBt8EE9QxBRVAiijIa92CiDCVqglWrUp07ZVvCvTMDLL1wSTMvLqmVQBU0/5i7K3AqQ4Ao+3v+ryxlup3Xlpd6pD2yhIVY5+D1/RcltaEALLPjaqibWgZSi6lGjq/nSMyJTAZAElUGgSxHlJzrQlfpdQOwbOomstNCyCNCo3NWIJEKV+jb1MnaBIYQ6jrgyAAsvnMOLMHRg8Ph/GzE9LXe/DkSzushAwu3p9rqkrPDFZPdCho5uVqvG0lbwPUK9fYupRvXfmmp2zD3QqbTV2XxVVTS/V7wnNt/12qLK+191pbril+CVVpVxRKxBfBL2tVl37Pokbrlce1LQuVymJU61wuFYXXxnKrb3Vua8lbQKdafp2xrb51EXaaFFUAEPaMh88FnHr3+pVEe3NBBsIBcZ4R53dI0SG4HUKJgsZlX7F87JlVQaKGaDKwQ7tuG2N57amNeAmKskndXt8NFqNuGm0B7bnu+puoH6lylxlfHeDg1Hha22n/bM9yRRlXx55ZQRcK2Mh6NnvvJEWHc2BVKDKypIlp66A6HusxaOq4cJ5QMxZtlJUSSSVXkGrKBipBAWhYqh2ry1JFtnXknMGOFUgpKu/MYuyvQMvmSeD6dPRRxdrziLDNfsh6qlSjmwEWzQYFiFPBtVV1bOeZAFeSKKs5IycBsliYa+8qQIgacxdn1lQsroyvnYB1zJXH7PiRMmgQT8sKkmDWMNxOUkLllDrer6T0KvUCzB5TmmBedQAQY2oUk1o3E6Drr6wR7q5o1guZHlT4abD2o6WWv6h/q2LYwEMAyAmYXRDI+h3VaxqwTYyzPi8RYFNc9krJwovnqoCtESCBlCNSTiAAzgeZBt2PhuDhvQdn1sgb6h1qexIzQFm3DwlxLlyXRL4JwWMYAsI4wu8eMAw77MYR+4Gw9wmeZjic4N0ZrgmZ3wx3974F8gqH16YL4U6lzKtStqnl7V5Kl86yrd+vcQTLc3B55daufKnexU6Gu/3H2I/ANDs4JGQ43TMdGITEGZ4kMqPxmc4WpZ2YbHtHAmUobw+kOZZ9V/4lMEcUkARxebX8q/HJpZUsEZMkMiPBqxxja59JU3862RccOfgkZThI2rrgxMBHAMgDPCTEJA4iMU66H2UAEdPpqOnZBux2I0LYgVyAIwWncC57BZKmP5CDWvfJ5hzkLN74dq6SRNAidmBySAQwZWSXQZ6Rncra7BGGB71vh8QeTyfC6TQJL0IewXt4D5DzcH5A8Aw6esSDw3xIyKmOfAGJ2UouvK6QyL396mpBMz+EX11f33PLtrfbeoDyk+JXUVfupfV9rU0mvSzX/m8DAvp90kvG+9LZYbSWTbavvrSf9NevQUn2fV/fderqIdPjUE3rRJZqCYuXrZZajuwodableZf93ilPWIyaz7Trh9JSDgF6uYa61MDWRqCPptOWsTWCZfdEjYv8IVrOFz7d6Lel95HBl2tguQ4ulbO19pYcinEtFXhQ9TKMFqRu3+iPifHd/8veu/5KsiT3Yb/IzKruMzP3tS+CD2lXa4qESRM2AdvyQ4ANA/riv9RfBeiT7S+2LBiwZRGEKYogTZiUzF0u93XvnZnTj8rM8IeIyIzKru5zZu4s94rouPfMOV1dlZXvjMcvIn5ISDPw8OkZ00tGCoBk9g4QM2xcvQUoEIO3tT6hpRwHYMZ8chM/BsKLb1GPZA6W1J4/i6indcumTxfElxFh+hQP+29gv3+FaXoAVwGfLLnLArVmVM4IsYBwRC1nHL444YsfMurCqIVXK6nxg0MKpa1R2AIZNQ0TE2g6g15+Ial+dkCMe4SQsJwzHg/AnCsqE46ngvO54qOPPwZoQnio2H9rQUiMOM+YNM1kSAnH01tUOqMgg0MFnwvqUtfvhkRapRABiiAFS1i64LZrNn2qrnpCk8l7axWkuCEsjjpG77jpo877Pup8hAk27q7GDLg6DeeN8Z5Njm2yk8hfYOUddX6pqItA1G0Tbey6fGTyn8nlBm70wN7uADJIDSswN4P7V72vnHja2njRo/0G0+ubHcKvZmqr9XLv9u9bdbz+JhJHyBB6FNXj4YRaKlJISDGJM1JVBwrv9AHRWwQS/YrIzoQYJ5ijsdfdW1rqQCJzh2aL4fbZbEQpRJXNpdxDtaita33Ind6f7oCZO93pTne6052UjodHnE9HgLkxLLVkHB4XnGPEbrdDCAHn8xmHw6Hln9ylCce3tTGMMQS8evVRK7dWlhDvGnlDItUEx/z2cPxmFABpZAkW40mpVZSELgXCCJTZBswocMMBJQQlnV1KgNKigjQjQyDEkJphypc/vscMV5eROzSSjpIZv5ogbO/yAI4GBnla9XALNDM+b57b3WgSUCsa2EcMFE0V0/oOIOQC6fsQQEGYVgrclKOsABpioNSuwPJIfLS3SISaap6iQDNsCaMfQK7PRsNjKXXVzybU1GJeqB31bwZDK0c+F+0HS0lymbLIe4z7d3cVale2rfoc3UgU3XwIIaDUE5qH/DCG9lM1/Ulvd9jUdFiZ6/HnVjeQV7Y7acsLWrquABFOyNqogucIzooxglpUCgWFVctxrPV1xrEYGZYHl5mBSjg+ZtQyIReAKOOj3zkh/+F3cPjxg7UMXrkuD2+rdJtITF1WZ+o52t+V7JmuUr2ubDLFJbcnm7nWicLb77i2YrvSZKzL03X+RdFzFXZb93hl+JZinVrklfVTtPHMZdn9vgCAhrEa54DvT7vCroz1XddbNd7h94BRQXa9tA3l0ZWUHORAM6++yfiH/21BTDNqnVFrRC2EpQiIYFkYOScQZuz3U0uzYGn0qnmf16rRZTTvM6nSc1DcALbvXdaZgeb9vl1xGvZ97Rty6sWVBsge815ncq+FVO4FcSvPPK7M60gM+hq9gkTJGim2fQIQj/+gez9reQTbU6OkZYpqvNfzQvb1ikJFQRwMhIqUSO/ryriRfJ/6s0zS3AmfIde6Ms1CDNu+G2OCJqyDKINL70PTTeu1MQpJCEG3UPG7J+opCCzKB5EppJ2qnYBpTqu69TO0A4sbaKgBLrgxN8aC1CL3lpI1aiEhRmq/WUEq4AVcJaVJgPAHAlSoKEUAGyh2ZlorBJRrfEyrW2AFMDN6WjEdZ50TMayj/xDXtqtLq0Spd14yapE5EAJwPh+lLU4hCDVqWYQLScmkpwlDeRcDAhmfZcAS68MgYMDQd8DOcahBn9vr0LwSWdoS3Nj1pdef6WOlfRg0xaoD5vrz3gOBapVxjSEhhaj7i3jy2RyyNWMRtWJM+OSTT1FqxTmfcM5n2RuCHNoMAIGQgniyLksW8Ms0A6DGq8lmU0C6dmUrUWCDKmrnecLuYcLuxQvsXnwDISbMEZjDEak+op6/RFleY06PiLRbr9G+jNpu7ldyYNJoFeu93iLgXdvrO8c48omjGf46PfeM3+YV1if4ZTuf8/Zb9ZRSdtMDImfk4wk0FVAkjQQpgI4lZ1TTuOpmyRaJRkEmxAUSSSsDhVAzkM+MZdFIK1HlBKpgykhpbgA81vSsFmCr1gpCFZAkQyIkMiv/zUCdkIgkGhHZeAJZjSIpBEwImEiU8LVWVGYk6FqpVcLNBwKXR0QiIE6gJG2pdcH+k73IORWoJYApARxxOleZ43FuhvhSlpYSryqO1cBosl8HXavuMwdwDchgMC2yS8aCEgghyt4bKAHTDhQi6rlAUr1FTHupJ6MghAkx7gGSNf1yT3j7byN+/scRwEeNl7JokH3er/kdI1LvaMu20c1GX81EP64g98ZW+sgH2r08XB/hO+sS2D25zftfa8/zVvTXn7ZX/XOlgdt0yW9fgj625skItvGzrxJr1Lh+Zo7PukTYbb3b3DaNTHQzQCINwr31sgbvQttt6r99zcne377rgBkDyrRorBvlje+0M6q1mzr4beu5r0JPyax3ejd6zqq7Ij22f68/vyGLXuyVdpf81eZUE+P6XmhL0O4pR8If/E8zAOB7v/85vvv7j5jCRyjlARUTmHfQg135YDtVFoiDmR3OE0QvWEFBZRH9r3JFzRXf/l05v0QvmfHm7Vv8+F+8xOGHfuUDr37rEQ+/usc8fYb9/iNwJZQqWoS0C3jxUcSXKjcs+YBcMva7CZwPWE6v8fiDHV7/m19rPbL6PZyL13u2ky/Dr/v44kvsvv9HeHj4GIV3eDw8YEoRtUaUZYefvz1gKRLtI4SI7zy8wvm0IH7jEZ98Q6Nipj12+5dNN7d78RILjphDASKj1BPOxwVBw3bLXAkKPEqoiDAwcsniUFtrbDKgyKYq55vu0E8O0r1r0OECFr3W63J1qNl0iH3cmgxtvWh8EPW9fL3ruFnr9OBSTXWAgP3I/eYGJ2AZiRhr9RJghwCrJXqQ9CdCUB6y2yJqrUBhlGXBskhkIpFFC3K2iL2ifylV0mkBVQHOfZ72WaMymV1fgYs2Zpn2W2t3BULUvq3q+EHrKLUALsvUxVxrtYEBowARmCKh5kWGnAlTnDBN4oRgIJnldEJ1UUdTSohJ0pWlFFQWt0j+LBENdU6EEFq0UeiZHKOkCQ46ZsYfc62I6mxBFFByRs0Zx+Uktqw7fRC6A2budKc73elOd1Iq6jnrPZi9Iv18ljD0x+OxhVGf0tTuNSW7pQdYlqWXcYXRk7B9JrqzKkGrKkexUthv2aSeii7j7+uMewe52GdrT6OKlUHXv+Op6C4NVT0AYXwah602PPUe1spuAWqeqtP6XmBUbZjx8aoQTev7/fttjMb69P71SsiKuBFBxtNlflu63T4GLAdu9/gm53GvoqAb7/aj77rWnzZmck1NUrSed97TYJyPPU3GdUHH7re1Yp7rBlq71gd+nvmybtFoUO3vX9fH1+VS4K0gVkEx4GKct8BjzIycs86jABBjSjMqegj39n4nAvu89R9SGbelXFwrbS8V8B6o0VVF3bRJgChuyXa062r+W+3w7fy6KyC3jRT9u6YUHlIvsbu27tuuOPJkkWjg7hnBMmM9vMJ4vG9USnhTyfjbyhjLBFpg4vadV4K7yg8hmi9rPda5XW+gGQIhIWBCMeUUM/LpjDgF1OWMvCwopbRzuLhIGCMYxqi2SDPrdX+bbu/H4969Vlrd3gO33v2Uh9pGacpzENbFiXqtlJ7uB7C9NkE8z2z/NmWezQ0zYHZgDqAKn7JlNr9eXzkrtEbVTBeyrwKxhTK2mSlnlSiQO7i0m3F8uWNfN/CRjq1vQwiWbqiCBk9PDzDWjFUt4kxXdtrU6UpPtPMPDZgRNMKfnAvq38xVIy0AnIue4R6AJMpFSbdo5/X6DI0hAQ60Mn7vgc4dmBqaJ1qbFQO/5Z/za6iUop51WfnHNZ9n5789UxWAE4wXIiByQGX5fg1y6mPV6sRqzDPF8MX5nxo/0qef30VHsvoqEMbOZ6fw9f3QAeW6Jyh/laI8Y3np5f6y2jskSpOMdymyLxGCpJJx7fC8o81lC7+tW5wbJwKz+P5DU6dN8w7zww4PDzN2Dwm7hx3mPcC8gDgjn14jL58D+RGBj9g9BEwptbQt/r2uh+yNG3245km27vDcrv/++km5XcZ41tj1dR2339XftOZsPF+xRYNUcKVm6/JCPWNGxS5EMGYEJKBkTRkUQJTFCKFpOgkC1JS0IIRaSbc/2bOpADUzcmUUlmik0ueyl6Q0ARzRwIuA7jdSL9k/FbSjSv9K+sMVpZ5RqkZIYqAySeSZYI4VCUQRcUqIxKg1g7nqmSqA05ozQgxIIQApasQ1hfdVBiN3ow/L3O3h/J1My91wVCtQyhhe/lKeNGNRX0cirwuG3QCD4r27m/cAgnjLF4hhKARUzmp4kH6QUa1uboU2By2Ni33WE+Vi5niwe1C+pUPAafOpd6XL59f81CXQoPOSHcRjdXEQOJZUWja3r63hd6vbL4esx9+9Puv208XV96uLleGvXfDjV0DjF/c0Pvp575ZoMfLb5kYd9m+mKtFJuc/hSiNP9zyA1HPr1X+7+WqgW/Q+8umlgCt9d+P90haNxAp2/63veZfxHWXSr7uM+neX3n0NXaNrc8DzLHbPerzXgESfTsav1ABGoAJKwkcKdlV3Kab+nAdLtHWqstGN5lkKF4s+kTTCeXB9wsTY7/Z48cAIYR54X7knpQimInHi8hnn0wEp7HA6vEFZDsg5XKyda2TrdCsalLE8vkkWFQuA8jk7cAWmmBBDVB18xuFwwDlblNCAlCIeHx+xnDPM8UNAt0GjevToJykm1DShpiQpYrnLetYiB39at8fxH+ZUAgDX9QUqE27cs6XLDOrE6a/d0kWs9cr6N/teNoeELmNdlLFx1eRWi6jeo2QKXINCBFnfhqiAGu2LlgK5giF8Iwojl0WjaSqvp/KtyMJd/+Hr5OvsZbNRL/uU/ndM1bx139Y9Vra9k4g0amJsABkrK2paJV+fUX4GEdI0I6XY1rjYjQSQ5KO2TtO0et5SsBJBnW5Y0r/GCCIojy5pVHM543w+ib75Th+E7oCZO93pTne6052UUkpIqUdV8SCOZVkAYMXUhBDUKCDKCLuekqQzMMCMD1lYWnhtIWHIzHvaENheLWBROgCuQQwkzmD3HBDLCEgxY48ZkPx3AFr4xZEp7QakS6XmGJVki4k1YMHI6F4TJi6MOkM9x/Y9DZpRhpNMwezfZeVehsNcl6vq0tbv/htFsPOlQbUZg5hxCy8jiPY1+KQb+oRh92U278846RhIOHIxuihjzuJBEGMEmF1qMACxj6sXREYQi287NOD3Wi0pHtFjX9nHawKbn1M2P6w8//04T1tEBffj19o1Gue6vUvqeTlm3ti4eoYNwLYGBxkwxnuo994QAy1jwm73AFDAN36bEX6z4vg54Uf/Bqt7Lz12xnnYASxiqrDP766YvxCa0RU+lkrg2uryiqSu2PRGJR7KfPe6/bIUkreUqbd3m9XGcHH/1t908Y27x6cb0/sI4zV73fv12JZCfjRWemXz1uexBU11ox25Nitd0se/8QaffPeAeX6JaXpAKcD5nBEngMseHBK4iOq7lALOC3JhHA+PWE7Htl4N1DB6co37BRG36FIjaOXaeSJbxROjv2HwA91+bAQb+r3vGl3sgSyRQkKo6MnT7F8793tqJXlnQSmsyq+kBkTzwgcsb7cp38Qo2vvVovhsnev+7PL7p3hW9f60HYIITflmKbEEQKxmPkYzslo54/lxwc+o95VPoeOjy0jZXmnazyTfphDixdiu2hQFFNKA1yFpnwZNR6R8YyRNoRNBAajnoGmOJJS6eOLlHvWvpY7StJd6lgoveQmuvUYkFUZxoZpHgI3n7aw/U4oo7mybpgnz3JWo0n968qiST6KviOK7AWtYIqB1pXNo4BDdHNCVvGv+Uf3q0BeRmtZsfBrvdrnved6wK3/JGEAxGgDiLaltj6oYBTNKNuO6pXDp+eMZXTG6Sr9UFiznE3IpWHIGhYg0aVQOt8Z1SDQSo/F70topis+/tEzAYpLmJ4EoYdq/xGff+g5evNhhmoGYGCkVhPIaf/a/B+QjC7C3foRQX4JQ8YOJcHq9Q9XIXaRRgLaMkOM+bzuCN6hunTLknhvLo/aNGqDe46han1DPfYIurvi6Yfh8u/T1t3/0L09IM/Dqk4Tv/45Ed5mJUEpGKUAiBtUCybVUQFwhoc0KGBMKAioHMIcWJQmBQCkgBWopglmsO4ghYKmsthES4wV1kKEo5yssrVEiAkegUMbxdMTpdEY5FuzijBgnAe2UiDDvECgg6/m6p4hcz6hcJKKRS6dmy40QEMOEwAFmlq4E5BIkJXEghES6diSlU1bgnQACNbIOCKCIkAS4SbC0F7IvtLUVDCwTdDOUSKyyQAUEGoKk0wsxIhfgfD6hZEaKM2Ka5TyBOUkHUABSAKYUUMtrlLwD49WKB29zf4gK6HmeMf0SGkBB7vTffyhaz2Nl0rlDqT3IOjSjbIdQMzpwxvP4fY33K+u2/l2l3spbvP+1p4y29pR+8/MB4x4ov55713nTLUm7XycElrENOhtb+fDj3iOwAGt5bqsGT8l4o0xg5dkctRlrySWtTs+JJGN1v/zc5Wdpj0SH+rB02eK/2+vjF0PrtfYuK889gst51v4enE3G78eabH23XTZdjPfWWv7pn3+Ex5+8QNolfO8fZcRwRsEMYEKXim0vDrYweoGmP8RavgJDdYIBIHW0BJBz19tNny14+duPmKYZD9+Oen9EyVX5/ISu16wNWPb2r3Y4fZkQYkApCVw/wvmtAwr4XnPr6qL3HFgmvXqL3a//CCFOmKYZMVZUPmFZMk6Hk8ofAfMD4WH/CR72L3E+Mw6HE47HE06nM5gJFGZIZEhp6+l0AkCY04xpknTML17sMc8SiS+liHmewfQCMTACKsr5iJMoFgAWeTPnAg4ZhEUyYTHAtSLEgDnOrd+9bLtFK5WpniW2wXZ5nXS6ye4nMrTBBXE51u7aSr9upzlfKhhY328yrUInYRFmmtjVyl6/37cBFn0nTBLVRCOJm2qXq8h9JS8Cyi4LWiqm5lBgjiZdzvPpRLf6cMu5YwTQXLOHXPv8ruR1vOfzGQYyO5/POJ1OmKZppa8H0GxJJjeXUhCXjKDprkfwldmZvOwtjiUZpSzN6STnEwAocCehVAHLRYoasbcglxNqvQNmPhTdATN3utOd7nSnOykZ47I2BvGKCQLWESVYvUzB3ciwNrIosMalLTJgholmnfkNILJQ+oAIME7BQKZWGIwJN8EiHeW+juDRGc3QQnrXZsgw9P34ns03bLzbro0e+1uo8PH61ru2gQ7r558CzfivPFgGuKHk4Ft38AVTH1SBDVymsnoXGo2MHgziAV1EhEixeW7qC8EsHs0yNS19RwTMQNxyIW8Ydod6rP92z4LUmAeIMZZFODYDmbWjechfb+f493iv7wf7PYJ6nurna201g55/lxdafGoGV9haaHXz0+8Vfb3puDEjl4KJCQgJ86dAigWFA8oo7F4o17thy6uUvCLUUtjYPe9D5P5tJeke50s2ZeT66pYiygf2fl69/H2/bOXje6jvVrQFbNkyULafK2m4+n3XFchjXd+p724ok7viGe6HnQHGbrycPUBXK47qyHEe7z8GPv51wrwLSDGiMiEvAagRIe4BjgAvkoKuZgQw8rJgOR5Qc2nr9Fp0Ga84Yeab4/o8EOYlrYzxz9z7r4JzngDMWD3ttymhKlfJ/c2qhiUAsL3JlEisxn2LImCgolZyA6d45YvwPRW1aDQBvlRMjWfUdpv0Owog1FU5vT09yo2VE2NqYJIxqsk4voDmAXfRykqxs7SfmR0wY6BarR/IzdqgfakpB7E+c6J620lKQlE+xphahJmcswIxqP2oHlLOTbJzUnzC/dlm3mVQxah55vnx9/zCFtiqqoLdnhvPwpHHtespJUSWXogxNi874XG4RRtqkVFUCWiRefw5XWt2p0efJ7XWlp4GqzRNxvvq7qhKX6i3Y09ZWFVhDKy9LG0y9TLEIK++9waYcby7gdttXtl1a3tqPJimLGOZH+ZtKQCzqorMgkAAxXEdWz38ONn8tjtEHrAZJgb7CEZEDDPm/Qu8fPUKDw8JIRaAT6B6RHn8Eq9/8AnOB5MX5ga4NINkC+1NduZsnfvCT0hCKHthx3gAACAASURBVKCiunQ0/my5BgK43Of7b5cA5gMaMa/zILefec6Zee2+n/6NRiapFROdUPJJwE6Fkbkq8AmOL2fx/OaqIh2hMjS+iQBCEILy64S6ZPgA+pofSEYykO5HPTWeTDPbQ2T/4yjRiUALaiUUZhQu4ugRCaiMWgiMAlAEISAjAMiQaDFS31IlEE6s1gek93eQZQAhkBgLIggcgKCgxVoZtbCcHQ34yA0IEzTSmXTXZfTK8UfWta5PTZfr0zmVwihZ92+SdMayXCNCDIiREAiIAZhiBdcTLE2tzWszIHq6Dn1ps7rNdwEofHiwTCdpX1+T/TM2IhOyA0avWxLaXsCkjhfEKKuZ73k4v5N/fehd6nOL4+0cQCfjz5/aL65vadvG+Jt13IgqM5axJaNs15Fb/exsDe76iq+3WcG9tGtlMlF79pqM12QX7jKMmW/t/BnlG9p479juy8++LR3sVjf68UPRc+XaO12n58jZ5P5613V0Xaq+dd/zvr++HuXf0xc7nL4A5peMKZxRwgIuC4BJ52k/N9g5OrTSyJesPLze0vXKunYrkHPuUUB3jN2vLNjvE6ZpRggJzKHxrUTC++e84HzOYI7C872NOL2Nuh/E1po1H/e8vrHrYSrYf+MR0/yA3S4ixgLGgmXJePvmiGWRaHzztMc8vUSgGXl5xOFwxOFwQi0V07xrpXIlJ5Mpf54sPWXXxYkj64TKM7gsKGlGSjNCTODMLeplrVUcTrgqCN8cFXrU2oto7FeIq43b2hGn8WmgBtKXDnWzZtC7bgL+W/8GK3A1AsxdZuw8k8kENuv6I2s5K7Tf7PQZpHKzyTpSnukJCkrNmmIzg6Hpl1DBXJqstNbTdt3EeMKNOuMt/Y13LF3pFNo9olfojotW5zVtD2e3nfRoqsA6KmIZ2uDrW7UdfdzLwqC8yKipnCkAtgnLIuAbs8EAwLIskt4YGlHGyfgxRpQakXMGgXRtB+RyRq0L1pDXO30VugNm7nSnO93pTndyZIr9ns5mrbi7AIIwS0hrZ5TLmruyeRS7KBMWlr/WHqqfnTxE7ZqLcIOuNGyodFdXX8eNFinTySsDljG68s4ODqCwBv0YeSCLBwyNoJARRHDpTXtdrbAFQHjqmWvPP0XWJ7fVTPrRjDLNqLFWINq7RVlN7e8rtbypNrWx2TKUjsZfuz+EAHAPZ+7VYL693BRf18TdXofepnUqiy7Q2Y8HONlEtpCyvc/Mu+CpMfJAIbPfXQNPGXkg2mgE3DLkXgqjreRVOaOQasC3ZmhXJeEY2caHwlwZ60EiUB4PoBCw232CiopcGZwID98m9BCqAWUJePxclNgvPinYPxBCYHA9IQTG65/tkQ/itRsImmbBQ2quKy7fhUZRljeu8+b7TOUsfz8fNLNeW18H2topxmubCr+NMNFeIdzNFv3f9V/9s1cm999d/dGfu22Y8fc6f+iLcfFjevnTvTdvl+/aoIaaiydixYtvnZHShP1ne8RpD8YeSxbDXaAAigGg1PJe16wACQbysiCfl7a/mFJrK73Sc4B1wLudJZvPw/RXXZnzlLls3Kv8vuP3pWt73Wh4X40W97+ljM4LhCgRTsTQn90+bfVdK15MOQsIL7J1TvX7/PnY/5YzrjZNlSj3ttIt+n1cFEkS0ngdVcYrEsf+6Yo945M0soymttFKtXPX3hnI9itp5/oM1etuTEkVigkR3ECj8q6UerQWUbpJTncQUEuGoUsoEAKCGnepGZRBDsjDQKkVPTLhmnz/X/Jjfffx/WXvGvvQ2inebevId4Ap2jMCrYHmEo1HzPwdLCPR8LrSv8/NPqe47WF9/E2Jq7udV+qa8bdFZST3nDVcxxcOKIPQxovUM09SR1lkOGrn/KQAoRgjYoiImu4y54KcFxAB0Z3/AiLrIbyFTwgtpVQDAeg87H3RAdEEAnJVpacAn4W1SghhwjTtsdvvsJsjUqyo5YjDF2ccv8jIhwWl8Kr5FqnADJrGK0iCJ+EfOmhGnyNnbAQjq/F87aV/uav1E2V9Inqu084eO7tunfhP8wuXz26exU88+5z3bN1nK305Vfz0hyfkpSCkCbtXC3avFhBNMv6soDVIqpHADOYguysVMFUB4i1Q5jqgMtocBZvxqvT9ALYP0apCIdj6EGMPhwDmGQ+7hD29AC0LJqqYJgIl+XnzOSGfJSoMRcL0jUekOaIwoTK1utWFUSz6F0HBOj6hkU6m1lNixCuwcznDzpR+FrifENw8GcEy0LUsjW9vJIncRWDtLz1vK2OaZ/meJrQUdsyIaUKMACEjUEEIFWmqsCCeW/yOpYj0Y385Z65ffe5cfleytQRX3/ZZ98fVzthSXcoVkxaDng/MLKlsdBgthdsaDtH3k68Pp35Jz5Um1jy0zb/1TjLukZvvuwF4f1967v63dR9D4+Y28BQr69blMT93FL6sEWjkjq1ILyYdMMQRxM4LPyfWpzGtoslE27lWacQu33OrvZef+78VUMBnT/r5oejrPuf/faVb5/Zz19H6NHzX1Xf7/nepgye/Y4awABGo5YxaEwQgHpUb07tXQjRf9EubfwTZy3kNMCAE7L7JiKli+owwTXukuIOkYoqarpFVp8U4fl7w5qcF50NBLR5Ct92mLdl+jL6WdhX7z7KwArrGp1eE3fwRpmmHFCYwL6ilgjghElBokfbUiNOp4nQ44M3bA06nDDAhKdClVAIQWmqgFFOLEC98uEQC6Y6qtckNolOQtJMEASuP4IyRRIZZR9y+pSOwsvzvXj5plEoHzGWTkV2fOh2mj86+0s9a38NAG7R6vs8Ha7fIjBQ6V2N7rvFVHVSjvFmMylMFBcyEFjk0uDpW5g6CVmccw36t9Q+9T7d0/l2+ozbJvO5jHJfVZ+N7VH9Bxoc6R8KLKPLKU16SP+y7LkRSihbUKnz2fr/DPM8to4DVy8A6fjwAS4nNqqsKyHlBKRnLsjTAjLCorN8V4W2z6S5kDuS84HSSeRljRGWxWeV8RkrBpba+01elO2DmTne6053udCclrh0s4/NRNmM4K4upXFBoBvOe1sGMDmbkMkW7GfJSSpfe0I5/8yoMYA3CIDIVN1bGidukqmk2Jk7uFwSzefcKYykMlnj/MUuYbK+s7CH6hX0wL+/2pgvjTGeAR4OfofRH8IJ/dgQubAGXxvc+n4TRDOHpKAKrr5tQ4tUzNk8I3kD+XKCPjLMBMbrBysr1wJVSiirBuxc0IIr4Jhy1+VdRK9rYAxldAlB19GB0HcFS63FA86D395Ric7Gn5vBNF8+MvDl+o+HXUhmJ0amD1nxf+OfG/tmaM+Pz448J0zYGY99b+WMaKHLl+/Uxzk97rtaMJWfx2KSCjz9+gMxDIH5U8Z3fr+BSACZM04TDT2f85b+cwQC+8/0zfuXvE+YpY1l+jN0u44//t1/Dz37wSj0A/a7RFdsfQrG3Mhg4xar//ikyofz5oJl/X2jbKLil+huVwc9Vq5uaR1VEbpzJfd/7c9tUc1nvMV5RV7iz+3s9/v77dWmXb7ten/X1MFf8yn/6BV58/DFSegVgD0ZCLRK9wtpX+AyuYnCrpcrfecHp8RFlkRzZ3gNsTDEDdKBrzyu9Pqvs3i3lzLuRjpBTDvnfm/0x7CXGO5hn26g02jp7TUkSKSggF2hhkZuSxtJhiDf+NE/gGFro31LX6RMtT3yt68g9FnLYn+++L63OFpHE8yshECQ9HannWRUDMFk0L4A0xHjzElQlHPM6t7rtzdZPF8APsQ5pBBTTwImi1OZ+0rQhax5kDfA0nnALsCnzbb0yWPmqEHq7pG0ZOZ81NZLkeCesQT8ScUUUZClNyLkooENAmzUXpLkrxGxO97p3EEyvsxma16kxt+YfgMZvUBBgiefb5H5Lm1UxTXOLOCTjKO2IIaAUz3dGrWuBeSX2s5NRqyls2+6Avpb632L4jvI9MUBZ9Z7byuw139F31OhAKu23Ko5VvYtpnttcF1664ng84M3bL1FywTRP2O1m8bDU/cfmTggRFIMCCty6cqAo6ccKAwwEBQzkwhItngDSiBhIO8z7B8zTDrv9hN1UEfmI8+nn+Mn/Q/jBnzwA+LaNqO8BeLAiQbpNTDXoqbLg928FyOj3BYxCtRlFGU/v7caDjKdi/315Tj5n132fnXk8l963zK3zlQB88VPGv/pfKyQZUcVv/cdv8Z3fe40lAxRmVI4oCGCOiIgoFeCqCvIoayzEhENh2ZtiRGUgRDGqMeQ6o8uegK1DmUcNtKXA6zQlCRcfdngIM6Y0YeKK5e2XCPUtdmnBNANIGX/xJ5/g+Nc7LADSQ8H3/8mX2H2yw+EccFoY0/SA0yPw9vGM87liyRU5V0yzAGaK8v5JoyyRWolk319UdrZzlyGYwg5SZI0aRdC+GGSFUQ7VLU2eCRExRZEZ7D5SMBBFMcKx1JMDUDMwzS8Rw4KazyBaEEPBRw+Ew44uxriZe54dpWLN4dLq36egs+9HjAtoa0/xNYBm5JKvFRp/KUAJAXQVCOhR9gGpt6WY8u/9OtLI9T5X5vA7kt8vx+8237kRYfHyytY7b/CFN5+8VeblKDH1t437t52KiQMKVfcUNRnT7gMa5A0gSQdcub9j7Cc5b8xsq/OsAWXW587YU7dkDd++tbzi0wayW7fPXb9PU59Pl7L23x359utNfc5cri+vD7m8/xqtZ+7tVft8auVwxbJ8id3uBZgjzicGeAZhBwoJBAnh1sAnJH8L3mANiug8rvHGAroBVez3r7D7vQqQpAef0qeIIQFkujU5LUJIyHnBF39R8bN/HcEetDPUf+zjcc8agYIPnxb8xj/6EiWzpqmPIA4o5RORJXPF4bjgeDyq7F6xLKzpXBcQncAsPAZRwDTtEKMA0CWSd0JUkEwpjN0uOj4dTc41mVd48wqwpR5OYEWFRoqIMUl0bJVriKpGxOvy6TUd9OVoO00Qr+dUCKGl8DG7QJfNO8hiCzDTy3NvU3nFy+w2J4T3Ul5JZY4Yo8oCphtx8mED8VsbRQ8RDGgcJCVt1NS0URGkEolTxoUDwBWIUWRik/+29LWjXqa1hwDfzGu2Bd8fRISgUVvb7WE9VqIPcN+7921RS0NtOo3KSEmixTJLtNv9fo9pmsAsKZV83XpE387TigzZf47HI1JK7XmTuwV4JP1IHLQsTV8KkcWXZcE8z4gx4nw+tXc/PDxgnuftRt3pnekOmLnTne50pzvdSanUghEEAnRwCrBW2jXAzHKZK7Iyg2ttBi8zGBmZUUAYVF4x1V0oWjOJ7apTGvoyn6KRcTTjmoVKNOV90c9Tmi4YVV+GZ9DNELJlzPMGnK06jVFqRobYp8PxdfhqBs3nU3sN2Qf9uZXCxBmwPBExwJfI79Y3zXjSx8krjFuZ1D/XYVzE8OTfzbCoRlCFmQlYXhDzgoxvhyi4u3G9cmma2cqWmkOESxCawQfwgsiGmYHIGRHXbdgCnXigjggsfU6MAtfW+vBtXbXN1W+ce76MLSNcdGtgC2zjyxTjccQUJHz8cj4gBk0FF0SqnfY7VPUOrywpEAhAmGbkUlBqEe+YECFpKdA8vgl9jK73er9+TdyX7y7vqCTWmi3llPcu6ivkfZXqX09Vo/XIpUJ9bRS8Tuue6wrrwah44RHsvDGdctmHhm91G/ak22O8/iy/R8XzCJ55Ymy07lt3MfGqze1fIuymV0hxj0A7gGZwDajIFzVjyBwMgVAqcDgc1FAYAXd2bwHm/vapgxifonHv86lvxrNwC6CyOi9WijoPYrk0PQgIpvMvMYZmwBf+RMqKIaJybbyB7bHjmT2eeVvnGGAKsorKVp7d6/ffDtKUNBlduTaeUR7kbO9t9Sm1pwXUMOViAerRvMZxkucJlmZoHCM/z/yzXPocrToWMQIhiPLN0l/lUrTfC+aWtgkwkOs4VI03a+BUYIyCOM71LUDVpWK1k/dI8zxZQGhpYvxzUnyV9UhBsCuk4dFjQNQ0UsdjUUVwRVyBYUbFMyFQREo2HoyWPIgkysWajAfz7b40ifT2WhQLgqVtYbc+PN8VhnPd+rrWglzOWPIZACMm6RsDEslctghG+k42IABg6bSk7F5Poqhr2yCRTcsNfUy8aaeEeZ4wTwkpEYgX5OUNpnDCFHe+Z1Y0GulZXx10HI1vGM+ECqCQmMpL27/77+fQ+oxD64v35Q5+GXSLXzLqBjq582FmfPJwxuu34kn+4uUn2O1egXnC4XjEm9ePOOeKECNSmhBiwjmfMWFGjROYgay5UwIFMEWAJZVR603rOnGqFjBTMwoQQAEUIqZpwjQ9YI4JyGfsHvaI5YxYj6j5gPPpDWp5AUDmUCDGpw8Zld7iVAihSAq5FGbsIoMSQJWwaCoHoCrvoY4IbYwrQAoM5PXGZgYZIgHLtNgT5HqS1nz/aHQxQ5DsDwa/WvMwtDp7tJwoRjZwFdBoCij5EfGhQKLhq6ES4/7SZ8Rachhny+WVDznLx3WqJ2db13KOWgQY6sCZK+WsgAytNOE25Rxz6Zm4g2YueeGvL71P/dZamNvljPfRxb/X6+Tlilv13Drp1t924Hvfoz0/vubAe0QYA+SzmN2djmKr7nYyyweZZwUEkOoa9KwwI3pPBahzzYFlbr3j2rULGcJa5mQMi4zmQW7X+vY5+/tz6Knxu9PT1GcsbVy/pBGosXXXeh1vf/+ca8+lm3tiPSPGGcwZJWeAIoCiyQzRAAusac7Z8qetSlzrZZnRHADkPJs1XboBstEA/P15UrDJglurI2ysUUaPRHW9DwiEhPPpKGAXSsil4PHtEctyxvm8YFnOTf40hwzThYvcNCOlImVRAhBQS0WIEyhKdGVx/OhAj54+SXSElRmlVgXLiAMCoSDFJDxw7OZwrpKqEkUi2nQZ9FKfODqw2LWr/eHkdkv1amV22aPLRxdy/RVUxyWwxM1222ed7ENka4mk/aEDa9YrhVblCiBFIvmFKLKeimaXZyRjJTsbuMTaa2PM7PvMy5XXd+QtsNJ18NIleZ3JU3aEUYbu4yEgrpQC5nnCbrdrczlnkXXlGVmbRMJTV5a5LkOv/FkAmIumXyqYpkkiyoQAriabdgcna6rXc4+f36U/7vQ03QEzd7rTne50pzspeUOMRVG5eT9zkzFGg1cT2h0zbEjijoDvhnjjyyioCsEUiS7qhRjDel7MLYPIFhlz6pmrWj3gAA6MwRqOvoMzRmWl97T2AKIxDcYtRLkHiIwRS4ioIa5H4+AvjKgrb1aMOqtQ2Jh4+92NHmtGes2QX7yG0Iw06+vbgtc4xj6qjAd3UZSw+s2Ls7LMJZJKEdd1s0w9NrzzGmCGIAabUqV8mDHW6hagBjKLwWnKchH8RVjr5VndLWSqzak+F0xYpVU9jCztkfXHreguvlx753ouAtY5I6jG98Nq7rbx8sAzmftm5C4bBnyiIOGtS8Xx8RF1yYhpEkGUAl7sHlCoIueC+dWCX/+9LIr9/YzXhwKuC+a54FROOOUMZzqBGWrN8HyNVsaEq3dtP1OJV96G41vWilp/z2V9RgXM9l1fLyWkV2rf7rtLr8kt5bv/9prSzhvitmen6yOX9mhrbDxZ2HX/bR+HSy/ULQMpmdA/3PeUNxoAfPO7Z3z7ewviNOPFy1dg2oGrAi+rzHXVAoIh4ApiUToQEZay4IvXr7Hb7RDShFgr8hAFZAR8XoZU/kXNrD5DnnNO2/kr0VwSZo1qAUDTv+RV/Udw3vhu+c5ADz4SnYysARAraxQRMl5FcnJLSh3Z5nOuWHjpzbKS+PLd/vO4L17yAhGoBc5ij2VZ3BnQ845bP1r0Dmv/mC7P18GfC6YM9Oe0fW/gJEnR5NsSumLLzrvW5xYxpq9wP5OIZAXEmDClCSkFLMuCUhcFCVUQCdi1lCwGYwIs/U5b9WRRXWLjLYgiphRwzks/fwf+aUupCIim1ANt+lhe8iseUFuKGupX4yjvmuZJeAyyCHGisJ5S0Og60t/LckZRvtNHPdIatDrWGjqwyb710wFAj6Xg+DB4gC61fuzr3HiKnv6FmZGX7NZUB1GFEBBDwPl07nOUKhAkhDZoQaAICiY3WPSY2I0ehVqElvafgmpCML4otr4mp0SOUVJ7VYKEgYkBaY6Y5oCXL2Z8tE+op7f48/8zIJ9e4fBGeK9x7986r/quitZnl+eF/FeVr1xHlnn3fdPtiI1ruWlY+gXQV3nP2KcYPlsEBTuv//JPX+LnP5rFQ1oNNSFMAAilPKDkCVm16RQCph3jN3//x0hxj3MVgNLDNONIUcAKzEAt4EIIUaOlyGQBWEBgjH7eBETElBBCRErAnE5IeMQUM+b9GS8o4+3PJvzff/gKXD/D8cuH1sblFPFH//w7qIGwFKAwMO8Jv/m7X+LjFwmHI+MAxkfzjMI6noGQueB0PiMvRflRXVPOY17WY9QIMkE8vREktTEB0GhKpP3iwfIrmRJ9nYKAqivNZDIAso+YQYchBiQmxDSjVIlys9tF7ED44f/1DXxRGMfXaeB71mM/8kVbs2p7nm1xZc+n5/PqfV0z90QfRB0Y4WtkBmf2z+r3tqMBaFm2rC/N/+J99oKvM9HGp9ZrV1jGDc2Be/byPnaf+UrBI/h9lKMuuez1s8w9+cQ45laW/9uXFoeyLeuhzRECXAo2e1rkz6LoZH/mmOzS98nep2PfPSW38DDjWCvoZU87q66V8Yskf97+3VoZf3t0Tb6+JXc/d3/cXqvvRk8/a3N7vWrzKeLP/pdfQ5wivvUPCz777iOOj0ccDwSEPeL8gDjNbfIY3xiUv12hI+xNetYFijAHTHFsAMTRQEDbUhvdDVSeyTmjVsbDr1d869UCioR5SiAK+PlfMD7/i+sz2PaV3Xde48WvPmKaHrDUgt28AyEiTAXLkjDPr7CcM07ljLwsOB4ecTodxXEgF5RiMkXQKJ/B7Q3Cg3vgLIWICgI3AEHANEnaxVIsOkdBLktzBs0543g8otaCAEnpnJcKrlKORJEJoJCR4qQR/wiStknOTqNRP+p/29+mwxT2zu7RM5hMT2rpo7ssNM+7VTlbDjEr3bHKNqKvVzmI/NcED8bvES4ZrLJZFwBUc6OFUIiIQfpWeFdJJQUFFBMqwKafr043AZRcNcqh1A1YRxo1YFCva0BwikXqqJ4nqcmtZH2tTicwQPX6BPR6Aps/12wLxktaJFXtKF0+3d5h6b/2+x1CiCil4Hg8aLdK/5QC5MpNPgbJvJsm0fOEEDDPcmqVknWuS/1i7LJ0b0tV5xKJwhQoSHrtWpHzCcuyPN15d3oW3QEzd7rTne50pzsNNBobRqZ4DW7o11ZoX6h3Zik4n88wwMw8z5imqZXnjU7izWvGHpON1HXQ1eU6c3fJXZo+1aOSjeGzcJX2nBixNKILSchMD4gxgWUENzTjW/NgqKs+Gw18HYRhedQvo3Ncbw9f/e6r0gU6H6oIWmt+3B+31SGX4It1+6+9377aus+n92qpJ4IqqwhNEPbRb7zCet1vJli4Gm6MA3NPOWYerpdCmc3/LkBJc01RDlFWD2M7tnEEW/nro6FvBGSt+3G7rBbqEhtr1hQPQ/jTLXATSAxhGOpu79pKBxNCEE87XfM1M85lQYwVMSVM04xSKnLOOJ8WVDA++vakUQkWHE6MQAwExul8wlI0As0VBe5zlHXPlEnbnWJz2FZEeuVrv/Y8dfqtOnwdlY5eKQq8Sz/6ErpCzRTJW3eZcjm4exjdc9I/57epLUUz3HV/L632vK0xG9bA6ivbx+27DaMMLtNxvfwk4Ft/LwEhoWKHUieUSmBL71azPmVAvqxbnCnBFiylYKcKKNKUOiNgYuvsse9/kUrtLSXaU8fWeNbmnNXzKG/uQ9sKO8CfwXLe9xzuFl46hABUIOei90i6KxCQQgf25iwAPomqFxVQa7mzu0fcCNq4OO+HPT8Ef+aaUqkDFohq+w7Mbas1QIEBbyyK31b/hBBQ1Xce5M8GOxdCU2AxUwNqdIWd1M9SBo3nQc9DD523+gwBMQSkFilIQKFLLqiluPHxY0QaicbaKgYoScVkbTdPPwLnpfWrgYes7ts8rKZ0qdszfjw3W9mQsfaAGTvrAQVaFW7go2maEWPAPCVYCkcJM51xXsSorW9cAZqsL5kJPhIL2hxprdHr2n/c1/vYFg/u2Wxv1f4eoxZRy2W5CpkeIoODAH9qzUCoYkysOi4URclOUaupjDz16BpeYW7jQqRRenR9AoQUxTAQCOBIQIyIKSAmSSE2xYq4LPjyRxOOB0mnytjav/s+N24/3J6yM8Vfl79q++uybP/3c86/sQ63zs2vui+P59zzyrt2F13cReMFuPOaCW8+n/D283l1hneK+tPf+OJVxd/79kd4XQg/fV1wWM6I0w45RORaUVgMXgKCiDLvNHJkn1O9vsGAWDFimoApnbAcvsA+EXax4LN9Bb2e8PnfPLT6NVV8IfzkBw99zAmY9xnpNz/HhIiACfM8I1NCrjpvAmGpQMkZmbOmia163vgIkt7b2Tib2Ja5GQnI0r+GgKiOJsFANLa+be8Ho9SMDjiUPZSJW8tYxSKWcE1iJItqNKnA4cd7LI9oUSm64R2N713zUM/jbfnK73ehW2tra03L726QYkhQtXEnBey4YjOBre6zOdFMmNx1CbYIepSSryevDjy/Xls88QX4m3iTV78sZd3XW3/bPnIxR2hrn73k6G/NDItU+TQ3vy7Pa0FWsgX3aKbjm62nop3H1FdHm0ND1Ezg9rwe6znKL1t9NQI7//bo6zz7f7n0bnKxp65zuOQZtuf+c9+1dd84n9+/3mNJfW+shfD5D14CAD76lbdI6QQQ4bQUBCpACKCkgGtyDpOk++7GFDMdr23ORAEGZAABkv5zbfKV3gtYFgHM7D4mTB8RmIumpw1485PtfhirML3I2H/zhDQFJADzLKmlMIYGaQAAIABJREFUSmYsCyPFiPNScD6dsJxPOB7e4Hw+oScEjegA9ShyPLxOr+8a1lbWtFUegNIdSkTGMB2cB3OUUpHLgrKckXMBIYhM5OU6ldM7f9LPvFHvPMqcY527Ht/KkDJjTCDqTrMG7BhlsFvvsgfZyRF2n0VN9U4EXdaGzgs0WdVuImHAmg4iRgFdp2kS3isymuzKtc07S7Frday1oqzkTBI9A3Pn77QuQcQ9LdM/cuWU2tD1kmNKtnS28tn6gt11tDl0m6yN7l0sqVBLKYixIMaI3W6HaZqwLAuOx8MqUqvJ9eaIAJ13zZkz8ErP7XVXpPxxew4AWHj82iI6S3xAm+8WqfxOX53ugJk73elOd7rTnZSIQguND0CZUf99535XBsCrBooeYcZHujDPcQM8dMaodkNT09IBPToHVoxxY3qBC0bQ1/nSmLZm3k04aAYpAHCKEgmt2MN5eubTym9tJEYt3NDu8p1L+YTeBlblinhPr41qqz4HVt/dZm43BOlm/Bou3yzD9ZM+b12i8JTW/+L5cTn2l0oU//m6guVSyNquGyDpKiho+NZah7HuRkUpy6sDWT0AurLLfm37rbGb731O+rZxU6aym6tOEAtdJT8atGQN+LLXovo1Y6gv5xqQzJ43IMul8bZlm7i439dxJcw6xTF71JG36kpXdNVdq56maSiEAjHWcS0gFJyPi3idZI3OI5KkCpuEMCUEmlFpxstPz9jNb5DPAV/+5IW84iJFxbsTbf7uKqqt0revfXWl5ddZ5LumdBuVTHRxx+XnMb2S+6YpnH2qI/P2lO1JFPiXCnb/uSub/XcSoUh2tAvDwMXT29TqpvUY54+VRUygxHj17YyQEh4+mfVMiOLpVbrHF3MBNHytWqTBLKGZK0saiPOyCPiUzNucXAojcgozvx+N/fLh6X1Bnf5+q/fxeEResoIUtX0aPWx8H6/2Huq/4b934FTmZujSGsAihPX9z0AlY+523QthGkxuZ/u63W3GwqJ3SFulnmbstPZKHvTm+tb2TwI75aXfu3nFX/U+cWcJh2YK2lJ4bkU6kXnpFZFSLwprMGRrr1OIhVU/MbgWFMgeX0tuUXwaWC4ooAcaUKkpxNDmdlPq6jgxLsGeW/xRH2uJiFgrr0BB45zzzzflHY0RDeVc8ryfB63EFDFPE6YUIREfSL3eMnJemlef8aC937XfOHajSNNNbvMknf+lzhZ3DbEr3yJCdoCp3xc8L9/WCzrv2ooDtwhB8mNzJOj8Co4f1B/SlGNB51HQqBpsvDWpUWMdaTEG5ZuIgBhAKWGeJswpIlFBPgCPf03dmxIrsWHVTyNXN57jW4ZG49L9PbfPmFs89XXaeu7Wvvyue3abS0/W7qm3bj9P4w+PJykuarDJL9WAw+ef4e1xQc5vkeYDAu0wpQAuQCkQEAlHJLLUeVIas+OZScBXMQi4McWAKTLqecHP/t0ZpzniMQL1IeHx82nVxs2oFXqhFMZP/zoCgUEhgNKEhTVVWiB8+g3CqxcF58OCsI/IVeps8uOq5S0FU0BFBGscFLHfqCMGRW1HQIpJUgEE8bYlErknyCYPRkUtqclOkhLZ3ij9IoBIqW+tFTEQUgCIM2o+g3lGBaESazoXWxcMn+ql7w5PE1/5/S50a9Zeftdnu31uEWNkK+r85HC38YASRdL4zp5eC9D0HNz5Tzn/ANOHXJdq//bplryyRZ5v3QLLtO+fCZZ5+qrQxT76RGSZp8jPNSLeftTkB5YP1k+rZ+1Md9/5n7FvCT19i82R9l2LKrPu03FXvXa+bJ09UnW/Lq8BRp9H73t+3aKv03r4ZdCH6s9rPMKHKv9ylW99+75vlFkwzoXD5wE//7cTjicG7w/IlYElATEhTpOk3bbdV9fT9bcryL4tjKD6WidL2Z0qXBBB9UzqPMFBI2lYFObLRH6t/qFi+uznSNMeD58SQpiwLBWUEpalgCtQc0VeMsCM4+GA8/mEks/I+YRcFgSSSO4hSGqlMAAprK4Mky+qsjcaKUd1XSKnZBdhxXSDEsWROSBGjapKQGZrHxBiANcA5tDTDTkZd5QLt+XbLi9t3TPqJkMI6jRLKNnk3uCe63JJ0zEO+sjRCahWkS+ajOvGvjanAAHSgISPJK+PhQH+zYHEZDSNFlaLRpTr8TKV0ZL+r0X0oCpT1VpXjhnGYUh9qfEj4LA+73SRdFHz8vzq+nGGAVg6OAymjmh9JePoPUNHHQCGMV19u+prr0OXeSYvrSz5UHPJGh0RWPIiugkSkDcRCUSeetnSFuHQqkVvh4FoejssvbM2W88+PVNDALHaAqjrKa5FS7/Tu9MdMHOnO93pTne6k1JQhG7l4jg2NMao4ViUmRXkr6UeWDPN3ohjhoiHhwc8PDxgnmfNSWlIYmHq5DYRDIzJNfVWA6PAecI2G4FKSVs8X2O6DRCjKgs1vlmdPdMuyGTWVDm1GQ2sbebRbWAbiSwDPDzsEchCY3fm33jMoBkPKAISgESZXK2fN8iNDKx5Ka9BH0NT4QEgjeNGU9U0LU83mrR7myfWYJqhAMsyZAIvtbHu/ekq0QVjCzG+qo9k/jVm2PLArkWL7hXgKqJ93aOstHQQXFFrlnmLtceFeE6LCsmi01hiF+bQVEsGDNoydkpdRQoRj3FJX2HPinBU2/OWEsoU4ACQJolOYKWKkc21jkJj+E3IGVN43TLumdDkjX3+Hrs+plrraUjWgBj7ezRKNgO8ppnqQrUZjN14qRLZlqd56gJAYUbJMpYUKmIUoTeGiDRJTlwAOC8Zy2kBOCHFGSkkzDEhzDu8+u0j9ruf4/VPZvzhP//7GOl9lHXk/h0/X1Nsbr2Tb9zzXPq6Khq31GZul+nXBsOZPHfZqi2lvP/GjJltuetcMxVAQF9na6V2F7LXap/tNo270DW6qrTjdR+MECAGkGbGd//zM158NAGYcC6yV/W0Q3Z3BbhahiktRvqh1ILD8YjT+YTdw14VOgYoSS36Ra0FORf0XNrr2kmZa5DhhyQf/cOfR1vk97FaK5ZFlC3HwwE9JG9obYUaFcFoe28D2rZX6A60sjTI3lxrQYZEDpNUMOq1T9K/yym3dBhEAXOaZd5xV0iKoswASRqRo2nCPPDG+sP89W3MM2LSaBwAamEJhx0cXwIfQUuVnhp22KKDSFjrAh+1QJ4XIy8CD2AEU0oK6CHn2s4f4UfkzE8htbKLRuNLKQn/YK1U/oWB1n8xBFAUZTOXjHM+o63imhE0PSJDDb4IqBSEJ6oWwSUiJDmvuVbkWhXwQSCqCHaeu/mzBbhiVWoWzYFuP1u8lvQhOd6un6lrG6FGl9FIMARCmpLTyzMoALksWJYz3r55g9dvvsThcEAuWZXkuj84BbHN2Ej9+taS0VfoOPQvxaCglfAsmSpQ2Sk/RQEpKdyqKXoBRIpNiWk61gbMJWi0FWrAd6KEGCeAIyzpRKmiYLZ5TQEIEQiTGvxDApBQq3iYcoWMd4wIhKZwjVETLoaEEGakNONht8OLOWCOC77864I//RcGeHiXPcyf535f8qfAGjjjP39V6ucgra5du/tDvHfrzF5/e/tK76vxhLbfnQMY38MX/27T4yPwT/+HDIDwvd/J+O7vvkVmBsdPEUCIBKQ6ocaIqGCtUgm5MCTRQHd6oBCQImGKAVMiTFjw+scF/+//8cllvS3fCi7HxRuklyXhj/71d+WzM3KYYf2//scJv/n9Rxxf/wjpxTexcMB5WZCXBbWIUSuXisK631EC04TMswLwWEBiCpaJGvkrRQHgpSlIhKWo90adswyAA5gjiJK+S7x/mVUOAglgUPdhpoqUCLtUMeGEsjyi4qXUq/FX22CZd+Ztr0+896LtGXj9Ppt5Eq2KV5Xf4kwIAn62SDN2De5vAdIAQNBzv0qaDPDqve8jg3xIeu67PWcwgmVWXONNsMy7vGmsHV+sq2vkVyjbJ13DlqJ3VcuN87ONuR6VlQkWK3Dc5axetiZu17CnjR3Z6i0YoW/Ploziz57VdVqfTx0ks127yzK36fY5cUnr+d0/rfr4iXfe6ZIuNQ7jvMdqt1nJ3RjW8401u6XfsD3gcqV+2I38R3/6gB/96QPiPuN7/93PcCxvkE8VHBPmEBApIUjMJjeBCOsWQnXTPRqFyLvGw6uOqpr+1vjt7hRBgbBkSf0do0QSydn43+39iqYFL//DP8Zn3/w1pPAZTsc9jm+OIM7guqAyI58zjo8HnE8nScFUMmIkzHNEmhKmGEBhkrqrXMKhSjRroNW5O2iqPBpIzn4SPqDWBafTI0KIiCkiJY1SUwFmi9CuYIUQQDFKtMYYEdMEUAUvIrMwMWDRcplQGZIKmkwXuV7J0odrGXvt/GnPdF6lAeubjjFqpFaROww4saWW8GU2p43K4FJUAIq6qYuet9o8JoK4G4mcH2JASAmEbn8QO0PsgGSQyEV5wZIXAAyKVYA5FnadLcKopexVdkAjxJqtBCBMKTX50zvvdLHV5HaV++He026RPlzrXFXPywSKYX2/Wy+9bib36pCI8L6qg32yKIlgSxfWbUFEJGlIy4LzckLOGTFG7Pd7zLsZp/MRzIxpmjC5NNP97JXPOa9TJ8k7ug1JdPkF5qQCUknTUvjmDNPNMFflj2Oz79zpq9MdMHOnO93pTne6k1IpFfmcATBCgoaHNPamqmKBm6FAINfG+NVmiACwMjb40Hrn8xnLckatBafzSd5BZpiXkJGdKQ4NlOEZ/2YQQm3MekN8X6gdqBnW1tfXKQyact9sFaqGEEPdGmFt6GdjK0Ow8IEFJZ9xOp9RStbvgkuZUBsowvRsQGeoWw03wA7+mglPWKl4zPCpxkNTYROa0AhmiWKgzwT1ZrCmSPmDQogrQohNGdMQ/LX3KTtvYmP+LUesCaf2m8ihx1vbDVmun7l2Iw1628fcuS2CAiokfQVan4NIc/8SUuqpGkCkRr4ARtB51YU8n6arjXXoaTdSSkhxWnnYh9CVsAag4iDCUmsHV1RkWNh4MwBzRVsn5q3tDcx+3vn5au/3UZpGAcGnqPB9ZvfbMzmvvzNgke+XC6N6Gydg7UonY5azGD4s3Ye9s9SKXBcZl5hU5mQUNWzmOmGOMwDGkhcwV3zy6Ud4/PKAmk+oNCPTDAoJMe3wtjBev+11e2dlPro4vxYZ18rj8f7+t/+0Urlf3IuNO2/d83WmUbG67r+tXutenJulke0jl+Ng7ys6ugY7sFQZwfU3hu9GA8a6Ruvx3aqbKQovgT60qmdXX1waGbzKOCBgN30KUJL9BxKxoVYBFZiiiokklY4a0mSPDCg543g84Xw8oZaCCGopU+R386dGjBPmOTTQQwfguf3g4lxE++4a8fD9FsDzspyuqLz2jO1xPvXcw8ODnlN9jwqkc0kN/eb17ZWqAnKwFEO6h9n5weY1TtD/9XkCcUTkoErD0MotkHOht11gsTAWyLVJzh95j98Feh74fk4b6EGUc4RaCbVI6i1TKtp+bIq0UmT/jMmlAKzds034jdQUgWhKJ3+W2JjY+VDQQEjQ+bIoMCImUDLeiFxZrLyPlFdVaRWJQQrGKcXSaVWUmpFSxCShQ1CKgn1AYApg8/4j0r8jAhFqkKhKOkSyFtn/lrW3mrFEAv8mCfUM4z0igLQ+F23cdrvd6ryz+cbMGhJeFHEyNsYLRsxzwjxP0hdqxH7z5kucT0csy1nBXwUxRVHUUnRz38bCjY2BlMcdZLXmAGKXDotsZnHrQ/ts/G/QtFxMGl2PRRluz0g51RjgNrH9NSJCDAJmjcH2bFGmCv9i9ethzSkQwpQx7UnA8oVwPGQsi4AeDEgsDJPwbTFGTA/QKBozIvaINOPVNGOXFpTzF8iPBzC+Za1u7ZV5ci1tyPqMgTupCQbCfH+QynguvvvdvPHX1rfvQ897+tp7t9tFq0gM49ltz41lbvFN/vlf/cYev/WrJ/zlD3+EKVbs4wNKSMgcURCRz2cZqzkh04S3Z/TUcyABO3BVKRIImYG87lvbN9omzte5AYWZtJQsq+90rv3ub/09/Df/ZcWP/t2fgKcjKO0VwAIspwXHQ8GSGYUINU0oYYczRzzmgMoCCt0lkTWIgqayiyBi7B8CQBWgBdJSSR8YiZE01elyBoh2QBUAKJGAL4s5n0jmJwgwpyCljIkeEfmIfD7Dg4Pq8Nv4m4t99gbZOvxQRDc+3b6316dC2r+1N/R9oM8JAm1kRpAINJ1xIIBlfAw04+vg5/+1ev0yaZR3/A65WtPPAss8vQP2/uh/VeBKGqbrz1/w9UMKpmtzjzbkjEDQQ7QDbthdK7b+3fwPrq/GfS8OEkBvU+cIn2prO8v8tSH9ki/rw0E6vwptje72GfB3mZ7PA1x79oo8tfWNA3x+1bfJ6XmrBu9GzxnzEIBPP0t4LAseTxkVZkCXVErN5YW321mLT5optxHi6uUmQwPm9GA6N40yUwkBk0Q9Vhkj4LrugJmwHCYsBwCxoJwBKhWlnlFyxrJknE4nHB4PyFkiwU5TQogRKUYY8OG8FCyLAA1Siog+wnuQSHldHqnItQAVmOKMFCeV8URXNs/iMGPgk6igGHPoYy4gzggoMKfFECfUuohciYzAZwRMAO/bPDAgQnfosz6w9E96cpjYQNwcBu0M1W+krkvG+fwliERPuNvtEENCLiIrNQCI6iq6HrODW0x2BBiBgBilPmQ2BxLwvajWQz+VTbcMBhd1rLAUl6rnbU6Z1HUEaCCWAkZWPbYAk2Rqin6hFlaQSGr9Zs5Qln7Kz6YttYmBON3BO9wARJO5XfRCqYPqjNzJFEiAQyac9Qi9fVxq6foYERfd+U8KciE0m4GciPJui+YSFCp6Wk44no9AAKY0IcWEyhXn06LjmdDTQDN6GlFq7ZC5q7p0ljqADLyjQB4J/rpKGUxVdfYgFOdce6evRnfAzJ3udKc73elOShaOkDXCTAtn68KRUCAJ8c+qfEddlbEVjtG8xlsEl1pRSpZ7AzmBAKtnjQn3yHZv8FsDRkYViq9DL8+X3csbvzPeckxdI3UwT+Sx3afjAaUu7bl1dA40QIOP1OHbtAlMGN4tRk8LNwqsumN4Vhh8p15SY5d43Y/vWnumtxJWICT0v9UII2PmriMIOlwFPBNSDNDE2p7+VitO6ieplXq7DRTjASq9z/rnECN8hBY/Pqt2MqOSn1fu/aqots/e27x7TYSLcgP5tBpoc9mMv1JWVSHFxs/Q8nYvVmPs2ziSb5+v41Z7x/k79o0ZZEVQpNU9JohYeevIM1Fz8WI1F8Y6eHCOzfv27rCuBzNjWRYsy6Le63L/6XRELmeACYUjllxAgVEJmNOMaAL8Zm+9K43q4qfu3oqZ0p9/jhLzQyoTfY0/RJm3yrNd9rmKtWuqdLs+Ak7G3cz+9T8gAX1cq4OqclbPr0vs9/lvbvddi+MwKO/HUjp98x8s+Nb3K2J6gbSLqKyAPTAqZ5RaNR9N79FmSHeAQ0nrIvdX7ntjX2/riFD+t5X5i4oo8xRdG3+jcU9vYBFV9oxghvG59qydM2A5eyyvu35XWfzOmvKvKaTU+KvKmwaQgdsDXVtaDdSqyGAgwO1xPDzhf2PdG+1YJYQBzOv3X+aK2s4QwEBmptAS3Z5GXKv6HfV0N+N+vNWH8rnnEK8561iQRn2xesmbLaUT0TodE1veCihYhQTAYgDiQAReKkrV1GjUz7YO+OjKMiJVAzK64lMYitWcMeVlcaBSVkaFNN3V1lzqCrz1uSqgXF7xRbbyJdVSARGQUkRKE2IiMBecjrUpmqdp0iiBbMtZKbjyet8/TcNNNxZXm0s0fB5LHNbfdlkAO6BOt4j1fUtCcEdVigqfEBOQkoxZLTIWwneEthb9/h8CScqYJNFlIiYEmhCJQLViP094+dJX4HLXNiCDX7m3zqCtVttTH3rH7PXY4PdvPPOLpue+gzZ+xnKsfVt8w3jFSXgAgD/54xl/9Vef4lz3+A/+k9d4+BhAekCuFeelosaKAgICkEHIJC4dEntK5ycL4JFrRGXGq1cH/Gf/OOO/+i/+I/yzf/oz/PmfPbb3S7QrBnuDO9AC8Hc3g+tn2P/4P/8N/tUfAP/fX/0DUJjFaAMCMWO/B/7Jfz/h4WXCT7884Ic/eY0vDm8x0Yxp3uGcxfBHNWA3z2AUpARME4ECI+CIyhm1Zrz9KeHHfzyDoYY3rVCpAGPBb/zOES8/LQg0YU4vkUJPSwBUhCCAGc4H/M1fBvzsLz8G51c4n8m1U8315D9fXyd95C7pw8/b2xvkdR7TzcqrgDobd7m3u+lcJsUjJnXM1nIVNCOxu7Zb3TmNdX2vyxC/2HXvtR8jzH1VxyejVGxTPymv7wfvsgf673i4IryCX6HbvcrEqzqxHxSm1Vj3qJbr967btB5XS+SyYi2VKvW54bjUq+1koAF/1u3m1T3XylmDkL7aTLo1T/niiv319YDx/G3Sc+Xh68/S8Pk5ZLPRP7v19GXZW3uAzF33/DAHr5V6a9e7yl8RIUwBL/Z7FJqxZImUQZqutusgNxMm3n4zb/HTowwmfddlIEaICR9/b8H+m0dwrvibP3hAPa+1FIEiwIRaAGh05JxPKDkjL2dkjawpwFdN9UMBoCDnbGWJbGWAA40sWplXIIBrzfU6TJMzTLbb0r8JeD3JHlRKk8MUnS8ADJYIKCGwggit/7ZlA99nbfZSB86PDJNd9050tdbmSGtpprwc6J0FmwxcLYq7yIchQME2EEcCJpXF5TQ3HbvIcwa8UadGyL4svn+9DU2W1ijzUtYCAcygyzdNngRMzWB19bqZrf67Tqrz2JjXa92vO7827ms/TM3WsnLsga2RkSPxc6uvoSab61whFnColefl6XmencOoOJuW0iO/rnTB1PXs3qlTrtXV+Pe6DfLeykZC1zvmTu9Md8DMne50pzvd6U5KMQakJB5pUI9qEJSxVyQ5A4bybRaaG+SZ3RhjYyxDCNilHcDQaBTG+FqUjBH0YOX1MknFcbnPGx5GtR41hnmonXvHtnDp62+MmGfiRyCLpFQQ4QlQcA18RBio0aF7FseoCO66Zqg3haVmVGo9A3IGv+vE+r8qaWz8dEzRGNBL1ff/z9679Eq2ZOdh34qIvTNP1a17+/1gq9ktimJTlAgJoEnI8EQDe6SJx/43BgwDnhnwP/DEY8MDGbIGlg3TIixZsGCRbIom2VQ3+3bfvq+qOudk7r0jlgcrVsSK2Dvz5Kk693Y3lauQdTL3I96P9fhirR5YI2XjKp8Xwa6WhUhPalmJVd+16apQkarb1E7A6EEyVgjU0xTOawxg2mCu23bdqE6Tn82nFSxqX9v7W/1kgT7MnA8vaMapGjOTupDVMVLHdw+ccW5rDNc26tvJlnlb4EBOt4YPsdQC3KIpRza+KmAmC0/Sl0AVeDeAPGcMtkSEaZogJzSG6jGHEtwg7ccuYsYMxHxymAYA1bNOr9h8HJ1Wx2w/3dK2MvHNVIZPIeqdUnC+TXrb19bC9pq21pb2LqgqmHsVW9+n5Q6bkEurU+K2hNutca5vHlIOarptyusToABw8y7whW/J00siMItHhoQFKdYwgLJX5DmtYd1Q18llWRB1vwQV7zHA9tzWOaR/rZLiF5Xs3hqj+A3YAsr0zwOmDdTJCxjimzqH9EHea/RdoA4+EKAnqJr1VP8zeeb/GCgnmhQ0YsvR7qvrOXBaAbndLiAN2aPAC+HLZK02Sq4CZK6hNIlpte5bXqbyFaUS2jiZ70JRXtW925441Dx0n4yIcSkn9uS0I2NZovHaJ8AJTyF7wiEzybl89/akpV7UU4xmbNi90350z0kQBai259b+3Y8zNs9q1srHqmc75gjnRkwTIx5mHA73uL+/gwJ7lJfU4VCM8k1ede5/lnQKcHZu7FkSr1SZJ4J4YlJQFhgguOYUITnx8kdYME8R8xwRwgg/DmDOJ3xB5fQikE8WRgY8530ecJzgCSCOeLYfsbwznCqiAGWIG8O47inbXC7M3fbaY+kSbvyx6X8eqt+H8li3W939Sf8ZI9slfFhvblGQ/0cfOXz40Q7vvBjxD379BfbveBxnxmFKmKaE4wwc5oTX90fcTkdQ2CMiIDIhMhDZgRMJf8AEgsPNDbB/fo8XL34CH2Kdg5lLW0VgyOWxYYn6+tjH/+Ivb/GDvwQc3gWB4FiDlAFf/KLHP/g7X8EXvzTi9WHBRy8PeHk349X9gg8+vcPr+xlLcmB4zPOC27t7OHfAMI6QUMQzYgbM8GHAJz8cwXDiLSrXRMMtfe077+PFu7cYhx2ejS8whB0cBRA8HHmE4DAEOf1794OAn/3QeqbcAsi0107RZzVG23G3nlWX8uyVp8w820ZYLej1DJxKmSkVHmQtH6xBM4RE2Qi34mLfjJ6aj7fp6t/eq8Q5rchWGufIcj/re3lsmb64tK68+v+ScilYxvRl5qWqx8B6DMKuS0BdK07JiloOB8BxWRXL/cQJkcRbJqGGld1uGzRgmS2ZSOflw3T5CDovqT2W3lQC/utL59v23Er3ZrnYb70G6dQa0IdTLp5dHvAYZvdz/c3md/82g8EEjLsdUkgYlgELCOwSIhaAxMNalQWebmRW3ZbMQtXzpZSwzAn+JuH5O0A6SkjR7N8cAMOTw3vvfhmOBszzgmVmxGXBdLjHNB0xzws4JQxBvMpkKQoMh8gCyWPIgVHvqMnbyvFbYWK17MuyFLlGQ61b3n6e5/J8ymFwAQl56kMQcL8fMuhDPKDL4Q+GhGq2XketHm8lDjfylz5r5TH7nP61OsACOGENe2+9XMvHhqgXuTEUmUq8zDA4GVkN1Mk55ZsteVOmGGPxgK6eVKuOpa644iG+6nEF4CSyj+bbhAV+A2IIz7FNre601o/qpgKs2r/XbffXt35vfRdAkR5gqR5rdbVn5qJz0nvO+Xwos44N8awt8LebAAAgAElEQVQUiiekaZryOybkVh4rp6jalaSeFRx2+p0rPY6ugJkrXelKV7rSlTIVAwKMwCM6oBzaQG6IraSKQJcq2pWxkccF7DBNcwHMCINFZ5mjyvup5YGAcqqoKTmKckwr0db2LFhGmc8tpHvvdUQZ42EcsxvIerK5lIsr41oML+oaWMPalCpUBWVTMspegEpZWsFFQdUVkNKqoxWMUvs2t4sRTNbtUAWa2i65MOpu0yoMc8kJGSSixLVndBAVw1aMWOIsY6xj7rfAFQDK6QgiCetj87IGPU3H9lM5AUFVKbBlkO0FDaIaC3lLgLXgmtWpCFSFhJ6SAFBCadi2rXVdqxekX9v21t8SEs01ZWjboxVsm7Zo8kUz3s8JXDrmJP8aw1djz2qeFvzjzfzp0xXXpeLCdBgGOaXgHcLoisE7piSK6UhYFg8fAr7y9QTnIz7+yONwWHt9ef5uwvP3gMQeTCOYAU8SUXc+HvHpz6h4NupbfGt1KytHXn+2lMJWUWVVhn16n6Uy8bNStmva2+q3Ndn22X4qr1Ed6GW7PdeKuaLQJs6K6vpcbYPTrXFKYX2urJa2ytOkmcOwxBx+AfB5XuQPayiAuvLb95k5nzxbRHEEAI4Q5+UkYKZXimwpsH5R6BTYT7x7oOwXFdix7pkKUjF7Fdm9QMEy4kEvNXsagXIfNeueKob6/MxPMfSraVTSTEkMsg+feMZqjT3ZLpR5p7xlp8iIJN5y9KSeDb+o73F+ye51GpLHwSSYeTlyUucaaz1XgdQzngbqQAHS6N5Y2ERmcEpYcpgwbVcNDVZ5vOxFyAcowLIojVmVkqkohCsA1UEXbMuHlfplkKdeU0BRSglLrKEHtY1sv2s+9qRb4ZFU1V32YAWVymea73F7+wr393cgiGvuZsCU91QRXIFDFXi0PRYu5bN7qors9ppNdwtku52fKP0ph3fKD+a5k0cTefgMmKEcXkr4BMI8RyxLxLObgGEYECOD01L6Q/sgxoh5yspzLPnUaAINAxxF7EaHm70HMD24vzFZXlhrsf0cUNXib0un94+/HqR76zl6sG/Qro6Zoy3fwA40fRnTpxNu7w44HhcsEbg/Mu6OMz55GRHdgq98K+B+mjFDQjRFDpgYALl8upYRHMNzxE/+6q9wuH8XjLHkLDNZbQ1mHc87+aUw016i1PrHBXj/3wN3nyaQ38O7F3gOxjzfwr1KcPcOgQYkeNy+vsWLdyKG/QzQAYwEFxw++DHh7jXj/uMKMkjQEJX12qsPFxAWjIPDYX+P/QgEHyW0mSMMwSEEwrP9HstRwg2e6rc6F56GZ3h7frSdVW8yv1ppLF9Tb1QmbKJCK5JyuoY3bfjSApoBxJKWJFo1Hq7rpXCCp+bjW/6YumtPv2ptrYWMdq19TP10TJ7i5k+NkiqDtNqVRAzHGrILUMCUKynalNaSz6psGSyTg6M10l/vfeiU7PHQfZUUfhHo/Pj8LKXQXyx6aOacvv8wf/ImZdkKl9jnYu/Zd/onOd97KNSZ9eDUvt2SlZHJO7BLEjLQAZEXgAnBj0U2ecoR1IPqrU43JcYyLwgB8D4AiCb8mtTHOY/3XnwZrw93WJaIZUmYlwnz8R7zNInXSecxDh7kPSIL0DzBCciCkHV1XMIIWRlG5aMle/fcklH0ecs7W2/cCpgpgAKwyJCO4EKADyOCD5jJg7K3WxahS+TktIDckHW8rfcQEY2tflHljCwLmnbudchaxmEYGtlDQ7aT8Yiq9dM8Sg8Yj6nydkLwAxrnlyx91bRfGe1W3lF9vewMKSlIqR4yEhlWdQpU6qllXJaY5VIBJb8tWEYKduIyF3EU/ax25MCOVzJfrzdpdb1t+r0eeFOvBKohfnUs6PxXnbbxaGPLYNtFQpWJ91U9LNnr4rfKY9u192xjPdhe6WnoCpi50pWudKUrXSlTjGLgkBPBETGiKAy811idovgGa4TX86pEy/QMg5wIXZYZyzIjGuNHNWB0guOmga9lwFttRq9+vYRpWqtzOBtreiZzS8Cy9zVmqWWYt4AI8slhFVIVZsBZkDQoClJjVkmj+5v/q4y0NQQ2UkYrDHNNhBkFnd88TwCQRNACQ9131gRq24nRrCqkJN0sfHHKAoltYy73oQcgTP7iQcY3wqAtXzk53oQh0cZIG+NB81UZXFXhRhDoBIoV454FNPusGud6MMoWqXHMuS3BxQoWVWjmDBRJKasNstFNjaONXEA1rVNG5R5AZMdL703HovbbdHWs6lzh1d/e9FQMj6bd+vmjwo4aM+d5wrD4clpc+pXlSAkTYiI8fyfht37vgOfjjH/5+zd4/8frk+ff+rWIv/X3Ew4pIPovIE6Mm+AwYsLLn97jX/2vHsfDqrWgI3mjiTdpSzXUr0h9Dlu5vgm9jXh46btbquJL391WeVHzhGiSuAjfVolvV3NtSz1dbdudG8PGVqtv91GjpC6ubs6bD/REvCqv27+WHIhdNvyKR7Gk61/irl3Xyg1inYN2/eZmryl1MQqoPh3rrlnr93kps9emJnNvQxEi64ErIMVtZU8bXqfZ+0T7C9XllDU/70dFyefy+CKUdbkJ4+Oo7jHd9gkQEidRqOY9HSRAvJTz2OaReNUXW6BG+wEpbxCBYmjLm1mO713byOwj3oHIN7nrGs5QF9y6NqN6alvq/ixFy6c9u3o0ZUF9nnNAEyUBdG4o8c7MMM7Kaz2BlqLUHT7zT6iK4/5vAWk6mW+cUgFJ9e1tr/UKPWEnUjacutajQG1ROSF3nHA4HJBSwm43YhxFKRxj9jYH6vKyYTZl0H7Wer5zysiHwkEKT+iLEt2Rriu+7Oue9IRfnoKUPdBFwFHAEITPXxZxc04O5aQhuMakjylhniM4TnDMcOTBEUAG0IiSvylc5Tu1ruVWx3tiey9+6pWwEU3eMo3Pkh6bR9mXixeFnE4TButxeevuQObqq9cJ/+1/90Hn4UVXGwLwHN/5NcJv/zbwwcevcYwREQlTWsBMoAyqd3yAw4QXz0d8+1e+gf1eoSaVMtyuyZ9RWJGTZb+kb1++iviv/5ufbj5b22rOH49//F+8h69//Ra39/cg5/DivXfwR/98j7/4fl7LqAJ5CqCH5O8P/uS7J3lQIEM7meAwZ+9NtGkkPeX1Y8tg+tD7Pd/22PHWziPe+Haezrd7LpOtbymkXCtHX0g8h+g7pV5M5X4+fg5QejIvM6fq0NNj8qHV/wA1I+XNy7FFa87htERwqh6Gyzib9umc7bhpR1UihmH7IR4g2fRza27t+ZZ+tugapb9Eitc5234s9e1r10X1TPFZ06Xz6lKy8/+vKz2+vdodr09nPRMv6/kyXjce3pKn1/k9UNpzG6K9b/ZsBQau5GwAkRl3x3tgx+AsY8Q0AyyAFQl5Dqh+9KmoN87bDxUelgEW4Jwvcj6Kx7EUuR4mTXWtqOCWfHCSJBxTPRMo/HNMCzjFpkylHTfkXS2fcwSfw5ZboLmCzfVZvUc5FBTyAQvvsl5VDyNqHgwpIEcwEoiTeOo4odPcarvi7bSTdWy97KHYpt1h5F1zv7+mcmORZXJdnatt3uvvtd1FjchFP1BloSo/q5cZADm8ccppJ5CzBw3rYQ05YEIgvw6L/WbAmdM7YZ/e1lg59ewaxFRlzi199HbJzO5Jdbz33tcvoRhjDslVD08rFc+w5jCM/bvW/7Ty7ZWehq6AmStd6UpXutKVMmlYHJGK1KhueGnmqj0kOZ1MzgvgAbRiDnuXi0SEZZlxPB4wzzO89xjH0ZRADAvihrKGZ6qMlzKQyix5yKlxwxw1J7ph3t92DdmmW58XJnDN1KuRq2csXQ4mqkwzIOGtlIEHuEkPYAgmQAxrLQjG1pGykUpPHzAiJ4hSLochKoe17envbFwlQM/IUTb+idzJJr/cYq4au8R2lplwl0DqkDSXRb1xiCGIG6BF+SChiRtfGNmqKNBukNPIyLF+2xi8SlX4W7u8jLMAZFzuawn74LLnGYKjAOerMVAtqiof2r7UUx0hBIQQihAqzLwIasuynDS4WQBYGf+IeQyI8FpOyudxXsEmmmbKY8RBtXgafqp6LkI2jLbAk3NCt21DNZqqMa+fAzbOcA8OyxMECoSqMYXXAq/0r4BgUjaEWaFZ21fTt+FjxGjNSBxFeekk3AMhu5h3exySx3KcMe8T5lbeKjQ4wo0jLJGzIdghzaIIH8MeoKVZNaqipyo/zxl27Qqiis1eUVtVtU9HjzEWPE3OrYL9MeXQMrQrtFWpmedMKA2bx1YrprKabefX/2K0xhFr4EtNrHYBHPgzCkKrvNfvWsdE+ouwxIRlYXgXEDBgYYdlFoNwjAtG77NyrlVjimJIFmRHhBA8jkdgzqGZFuN2+ZRixAIw+pNolIFndi27VNFxsk249rAqU2pr1Wf68lolmq4PKSXgBNByG7AqCswFCerKW/e+xIwlxgL60HRSjABTVpglUPb+A+UB2DXgC2T+wOcQebwo6CH3fO6zWndX1mgtpypke8BTf6KwCZtk2k/e0X6XsQXWfcM1z4XQ8maaps2XmVuFFQOU/c947/K4QebJKj+i+zyKgrRdy/VZdW9dQ24ip+fyfih8Cmu/oCqthxCAJH5NyGfVTeLm+WVZygm1LTflMsCE9yGuY0WVy/340rbX05lRkBoCqFLFa25T4VeB4zEiccJ+fwPnUIA1Tb8ju2PP46G6g6/91Ssv307puv3+KWV8D5jtldtEDkyEmBiOOLt2DyAz5rwPcF7CM3HhGz18GLAbxzLWZGyqS+7MZy01hNX+2TNM84S7wwwPxvPxBtN0D6ZbfPzhPT79IAD4crfGW1VuXXG2jLP9Ksfd36ekh9J8uxX37eht6rtVbpveqbA3p8px2kRQn+nvf+Mrz/Gf/2ffxZQ8/vyHP8Zf/ugD/NUHn+CDTw8YxhvAebw7OnznK1/F3/vb38bf+pvfxD/5p98H04cnys3N7/bXmifZvgMo8LflJdun2rQr/Ue//R38zu/tsKQINwSACP/6n/4V/hy3xrOMvJeAAqDZap+2vNlsWcLQ5BqYsL4tH9y2yinvAlv82qkSvM2IM9IkLp0166da7vNUHypIq0YfFoieeo9RMLUan+UwA9VEWAyUqeS0VZ/TbWFreF7yqGldyutbXrr+3Ur1ctqWDGrpTv/aTmu9iq9/P7RWrNNs39UduZSbjJc89VSIrOtiFE8TZP7aVMvfUoEtoF+dvxYI2IYOrNesxw5t3YT12Dm1n/1i0NvN+190eowc/tg3VRq8fHav37WgVuo+MPcfBMNckGczno08bQ9MNDUghvOE3bMdyO0QE7AcFgQ/glKWHx7a2M6QPWjXG9eBlj8u3i9TQlxEs0AcQOzgdF0AgAS8fHlApIQlLpiOs3jUnCNSFOCH6PYIcB5J+QAipCh5MESW6L3KACpT1EOmtuwiFzM4h2RSeaXVpQP7/b6kGyNATvSiHAFOjJgYcAN82GMYZxynOyzzlOW+ASEsED1b9mYuMKGaQXPNhCNOay/stp2t7Nkf7kk5jGaKepjCbfY7c7v+aRnbfpX2r56j9ZBqBmAZPYKOEy2fbevaJwmMGZS0rjKDJGRT1kekhIi4qv8peav/u3puy9sT1YNPVQbXwbmWZ63O3OpN6v1t2XALqGRSheWaRIcsdhvVmesBWbWljKPP9p3azsfjBNvB1XN8q0e2OmHr+dWGYyr6nPzMlmx/pTejK2DmSle60pWudKVMRZQhZbLWTFPhq5RJK7xOZaB65swCHDTkCqMaNiqzUz3OiCvMtTvAteBNKKEWGoPCtnGgRybLd0nnUnR1yYG5FcYME60gnRi5GEFCUGNRVdNVLz1rga4anNQwiCIUCIBFjRtAUaGwSpYaOkDbIYnwQdQ1oSkLd4JPfldPETekclJiMGI5PV5Po4tBRUBWeuJcyPt8OrgYh3Ob5xZZj7naZ71BpxSnC0NUn0OpTwu4yR4e0I5xa2gDKmijMOogIANerNDXG5ZsGavx1Y4x3rjezjNGKuExbJ20XJp2LYMrgmNfBv3eg9jsPa6S5cr7ga2rc6o2rAKKFYyru1X1gNMKbPYZK9wwc/EkoGUgEuE5adswsCwTiCIAD4oO5AjsgCWFqphAO8wHT9gFwt20YFqOcDzmccG42QP/yT/8BL/2q1/DH/6xw//5B9XVjFVSbqno+1O0reK9KlO31IVb+p/H6oQuNxs8TmX5WNVcXqVWpemvrL+3avZeaWfV2wlqbl7vANx8MliBVZ3TKsmtkhpZaV3WX7BRLtLJvLZanrsPzLOsVpe8v0r4mryGJJb4YFxVm4z1qR9yDsMwYhxnpLhgTnIyR5UG+qx++lBN9n5RtJVqPHWoprUr3rNPbyjVFOQCtC19HtyjoE7Z51zxQpLA3sElJ4qvctSPAVLlFsoaqGsNEoOcMXqkZNZsBZGYEuY+rntZqusqCUDSFrlXSKWUilc1ey3GCHGnzXDers16st1l4KzuI9UbEadU9G6VP1C+Qfmtbu9KLO/lZ7QOAji1/WUVcuIBJpUTk3Xfco6yoiyXTfcBZgTv4EHF4xL0Q9lVdozglOCN5zHhgSpf2StgSx+ijhMZT7WPGy80VE/H2X5hZgPI4zxkqsK0zqVYlNZEAzhFLFFOjzY8neV3Or7qaeff5bSlzN2ar5R5R3Kyrg5DyB50XAETF88yJCu2NLUApTwFgFXBnOC9w263K/zWNC11vjsHgWk7kHcIbodh3AG4Fw81HLHMy8b+xCfW4DW9TWs/dU+d2sc/6xHxWdQDxcvM41Pf5InI9mmbKoPx/T+5x3/5X/0lGIS7+wPu7hmH4w2O8w6UPR8FB/yrXcL/8s5P8ezmJf7o+6/O52l2+f5Osxchr8AdOKZwfSuPO31Ptznor//hv/8Q/+R/yvu6IzAB3//jQwOWqbzFqX60ubbmSgbl8JW1RL3xX98sHjFo3aNNTU6AaZ6aLLe2zXVW2ljFmnTa9Db41YYX5SxFl17vUs73GGCS+4kdEunREdNnD5azpVauOPfEw3N6ix9/MP+LAVHnct2SzB6i0/V6E1lpXaJeOpM5WxwQ5JZJRaaQuWQ9z7Sz2c4XwHGFLzM4g+jrOvb4OvCDrfiY1n1KuiTfn1fZfhHoIVl9W06uK932k/VaHY/UjN01WKa/v5a77X1b/q3c+xna3FdPr2XvqKlyXi/53uNP/uevgAIhJgf3IuLFrx/gdyOYBliY2ptQz8tanVV/XSmB4UjCznBi+Bzrx3/9FfCVjzEtBxwXkRnmecK8zEBiLClrELLn68QALwlc9G5GdlU5pyurLYceGrHlFW+gtcwq3yjYwOqlK8AmYolRwpknZK84hOADMIwgukGKE47HCclHcIpIMcK5VGSdsmIW+QeoM7rfTVu5ZkvG2O6nGqr3sv6u7Snto2Ws5bPlZ86hl8jKX/q8TQsQu4IeGsyAGW7rmhIauVHfX5XyzFg79Y6Wf+uayPf6TnvwpZfjHnvgwqbRA2z0d2Lx1kqO8sFgJ2HISLylMouuIIQAPSzTy+jMQIz1gJDag7YOivRAt/7ZLY/+l9hwrnQZXQEzV7rSla50pSs1JGof5yoAI8bKfIMhTCQIoAQqHmjWjL+SMjJqwAthwEADwhByemp8caBsJKleZnqAxBbiWRhtffecaNoCb7bLq2ChnnqjnhVixLBfgTuW2VPhpXcrKCVlrI9P1N/2HS1XAUVQfp8ZChpSIxPBMssaKokBFiODGjJao02rOmSt45LD4ADQo1Mq6y1LLH1FRE14JA2foyeGFTTjnYP0VxsZWAouKqG+bS3oStujZeLb8CPe9wJbLYOmHZNVP9V8emCVBXswUAIB9M8qWeZdP+rdRt7THmoBO215LThIT6Mvq7x0jgKUQWYAn1Bs6hxczx8Zb71wpSCWpnusYZG4HWP5WetZx+at7Yfcj30YKxX4bdsCQIwMThlAExjAIl6PiLEsE46RQMOAwwx87VcO+Bu/usN0HPBH/7aK8+//lUNMhDkRvvGdBT5IjFsiAel889sez77wCSiM6MWDfjV5SEHfKpa21bJbouubKhIfUsSdKt/pZ6xKa1tRdjrP9Z2tZ6sqb311+1c1M/BmzoQuMAze/eqM974qhlxQHj9OXBNzjjPtHGXAQ0JcJhyOr/HpD19gut2tlIi2Ltz8AlatSv28AZxniKtjOZEU45JBCQwFbUgyotJstqo8R0II2O/34pLZ13B00zRtKCR4BQIonp50HY1V6fJUtKWokDquFYT2HV1beqUH2TQ20u+VKciAjBizUocF8BETQ8IKAURqctTY5PWEWquoiYicykjVfdQ5h+xEIys+kxYGBYXE1nwi9xJHgLR/fVG49Wt+H36wlCkhe5gTQ6Er8d5d4c/q+FFle8vP1DoqGLR1Zw0w4AhjGIxylMt8UaCnhJ/M/IGWiDmDHsjMHVdPhWWPahYgSj0AVeus89bsv8h7yDLPkL0vlXf7EGR2r+NcLvGG1ipZdQ/vx5UCvHOTGoV3VbAS1VBpIRD2+x2cB16/fok0CXgoJRP+y6Qv/d3yo5+Fju8hJXV/f+t3uUYkIZRCQAgeDEaMM+Zlzop8D6QkwFWjxGYeAHZ5TkYMw4ibmx2GIWBZluyxL8l4dmJwmCOB/Q7OezgKSHAYx4DgCIgLUqxzq+ee9a/efdO99fOkx+zjb5Jmv4+/aZtsSVArHuktwBP9u3ZPr1dq+T/+ZMG/+INPu1SGVf2YEoDb/NnixdbfbBoPt2MFxDV8gvEQofLTVj/bvL7/R/e1DCsju+FzqLZG32pt2bnLNcuXpKYkKZfj/gnNZ3sOPTRm+3cu4T8voZpvXl8eKEfNffs5+/5v/v2Ad78ILFEArrsx4Hi8w93dK3z6QcJPfvAlILfnOl9pSc+mbWW7RCJkr0DtyFmPsbaf+rXtbdYIOvvtMtrq08fmvpXOJXk+5Tpe52jfJ2T0HUCdHdkDJdc5Q2ADiLF/uXh+SmWkKsd5+X6ka6Gd91tEq/5cP/s2bdeIIg88d7qMT9t/nzWtV8unS+/cPduT5/QM5ftW2ODi/ap95xxY5qF8t/b9/ol+RSvPngxtTEiR8Oovb/DVv3sP3h8w0Yw4R9AAUAQoUTk49pTjR71GW48VCjCpsnXCzBPe/Z7DcpzBL46IzyfEuztMS8AyLzjcHzBNc9bJeoRxzDow41GZ8/zlrD/kCOSQR8BpHl115itZcGMjWLLHGUBkjWmaACAD0sWro4DYWUAzzCDycD5gwAhP4lkHKYE5gpPw5DnXNv9C1tsKg1l0ahYctEVbMry5az6XU3MwqEnDSJSkz+YVsgPA9DpQ5irzxhTz71qHOm5yuXP6Vu/S6PsvBK305e2vq/5dylEP4Yguo+azth/UBKvse74UOj/aPlPv9nowR3XsXA7PipwvHmljjJjndnwSVQ9K59qlt7dY3YGV4e1zqQu/fKW3oytg5kpXutKVrnQlJWXAHGUDTCwGifqMClokp/dw+vR4D3ZRo4b3Hj44BO9xf3/fGDsUUb8sS+OeT1Hf5fR4Q8pYKuq6v79W8Zwqs0U/n7IznDIoxFjjpm7d17ZomUOGusduy7pGVSsoRPhTa2CxoZj0WZaTvpoa6SnxbKA1wJfMf8p35BBAjGxgyqGIVOmreqScv4aUADLi2w/ijh8JnJKc0tDQFYwsUFEx8lWADRVgCYOLAbhnhPvQT3pdTshn16EZfFGf4XJPnudSt2SY7S3BRo3UhTGXVlu5T+3fXRlx2xFRDW1cDZFEMG4s9Xcshm9ta61f3w5FcGICs4MpYnnWnqgHdI7WPLVe6glK29zOQy0LORHGhzAUAU7KFlrhtRf2iUCmLJq+NeTbPicAiF5O6SDCDRGOxPtOxIQ5OozDiOPM+PLXD/jVbzvcvtzjj/5tjc/0/o8I7/+IsNsTvvr1CeHGwXlxdZ/II+1e4M/e/xHe/3AP4MsbfQas1fSnqVUuVbWsvruV8udFDyk16/fzp8TPtcG5e3UHWee5VQ5Nr6bbpl6XTqPoBvDiawnf/K1FciJCCIDz4rlgYVF1B0/wTubQMs+4u7vF4dMbTLfjRk7bZaHu+lbrkmMBoXIEUsxzK3vioNYjCDZStPN1HEcMIWAIXlwrxyjKsM74bwGFqgjUtOo6Sug9fT1OqfMIemDS6Npi131XNUCl7FvvtGCavHZEFuVfkr2PmTGEkEFTCcgKMYYCR9t6p+wFSD3/KOCv7CkpKwcjV96JckXzWCy/AeGlmDO2huAdiWttk62ugbYNGt5BzTsk6z3IgeDLXLX1Lypyglm/kxkfzrgtruXQNTgEb8aC1EX2VWkz0a1KSLGUEhyZkIclJoGG7SPjuU2VaUXzKDkU8FjuvxyqUkNXadmYOQMsKuBS284CjvQd5QV032fUOdJ7hetJQTfkCNUTUVXYVRCag/eE/c0e3hNuX7/Kc3xplJsSvqr2j/eulK2O7Z+foq/fq/sxCALgAB/Ek8wS5xxeKSK4IGAZqHcFQDwbevEWE30G+hF244jdbgeAsSwzpmnKyvsB3nkwHCY4uDDCuQCOhIgonutSQvDAfgwnjYIVdPHLAZZReoiveIo0n8b4tzaAPUXZLVjG7rPWO4e99ybp9mnbb7zxjP3dt+O5+ur9Js3OU8epGW/HsYZfadsBBsSyhhJtl73lnjS9husgrELDnALL9PW8lJ5qlXuoPx47FvX97/wG45vfBaZF9rNnN4TXrw/49OOP8MN/B7z/gy9mnlL2+exToEmLADgmE1FBeQIFzehT261Q2+ghLlxL/qbUjsWzPP0JLzN2PPXtf0nJHgLX9XP1KdfzWnZb+jpPnOpCcj+k3O8CMKj9vprnaOeWXmXznOhTanqrsjXhYbdKbuXLtez2Zj6+3o5+mfbax9ClY/nc+2s6LyVfIhev+7y9XgEy9nsdL/QYXF8AACAASURBVARcBJZZ52dXqHOrGHdPoykDcv5MCd/4zQPwhVv87IMEjnt4cnDspHxMGoX+SUgPhGkIWisvqy6KwFiWiIVnvPe9HY7HI46HGekoTPA8zZjnI47TPY7TBGaH3e4FyA1wfgA5B44RlGKe6wBSyl7dslDAlefuwQwq21rdeJHdUN/VgybCQ9eDZ8fjsXrhIAF8iDybZZAsSKocWWRcBcxAQD19X5Z+K21WV38jqj9IVq49B+p/IBVtsaLLLoCKfChT9eu1XA6EhMSqrzfloVouDTOfUtZ7RvHtV/XFbd8V0Ay2dSin9Msna3YGzLLlDdXqGvQZHedAKx/bcpAyfhtky2yjARARyNfQzvWAD5VnnfNFVtcQvH2fjzlErwLXTrXLWkff6o9t3Q6HQ/bc/HSHwP5Dpytg5kpXutKVrnQlQ8p4CeNLmSlHNqwJ19nYZGCZrjYda7zQ58RYQvDOw3mfT/xqKCZAjAgegKCXxVgh3iDE8MWFUa3MFVDFv7WqsGPzNwSUWqEVmMXUcautinBFhOQoG9FMHs7BOwkLYZk+lkSBotZoEekWNd26XxRSEAqy4ASqdWVmJCRQihlCJIY5cIJ44eFs9DHCLNf+kftVYNNT+LXjq2Ckhi8F8/igICcHsC9GSINbKYKN1nXrlLPtH22rXjgpDLoZkLWVaj1qeq4IVKQAI+ZSXpcFJguAUaOe5icn9x0sqt8a7HqSWzmUhqv1TPmER0oV1GM9w1RgShXoHDnAZWQ/qnBXQDalHwFSEJYOETW2dgKQLY8IITYklxXG7CkGKmNeTpXLMz73BeWTOQqOghH29Vlx4bmUtDS9YqA0ghWY4cmD2AFpkTHNUeR+JgmZ4gCQxxSB40xgItw8k3Y9Hgkxaj0ZLz+5x/PoMAwOzotR3vmAl7cjjvO6D3Vc9Uphq/i0pEqoesHO8+20L6U+7zehh9+tCmOtNTX3akmqAsy+ndX8RhHsPCOMEa3aLo9hrunqGF4OQXF7Z0vX18e2j/cjxnGXtWwOzgNwDikSDseIYRwxR8a8LODkQLTDzfMvYnw2YrhBrnfKc77mQDqfOCEtBF58U46m6/W6uCYRBQ0SyEkoH2aCS9UzV9ahlXUcJOAyay5zRICXU03393eIMVWFhO6VJ8F6uVx5DkbOp8pQJ33J9+Tb56kHH0Lr0pgL1tSHVWQWgIOzo88oTLj0AzfXKZ/5JahHIVUaxQIQ5ETFLbWGM9T3AWSXw6mZ8Hb/IaIc6ijBMZUxYvCf+dn8I8+FxFyzI1VCtek39W/ccYsLZB8yfwQCWNwjCzk4r95mtC3qPiHpy9q8AkKg7lWcB+E0TZkvo2avaMMfcn0HcuZeFGXalDLXdZ+LKZa9T/fWMA6F19M+TQY84zs346roPOWFzgJDARtWMa/ApGu+b97plXWNItKpRzLxgKJ8pLaLAF+qpxuGnnTrTy3W9bHhE6nyss3UuVCRTLQ9s07xVva+9BKtxvnWM5z7SPpRTs/avkzMoAxyLTsFSX0dOQwhwHtp82k6IuWwcsr/O1d5CB8GkPdw5BHIYXQe4FscDwnD/jn2+932/tCE8Hk8bUkRnyf9PPO+hMp+vzrFXnfmFU90gaVry0DceFM5seefKmOfrn23z4m7v+tfLb9znupTlm/UVDgDLU69qWW29bZ/2zo9wlsFKt+09nEjdxPyfGV6wGC/XW7gaXjUS+hcP5y7d6qPiYBxz/jk9Qz3M8KSRH51dIt5vsd0YEyx8np1TFI3B/I94pU3kQ0pF+txWMeP/X+r9NtXLqc6l3UPOJ/aw6CZLuzgZhlNfR8Ahazn5Wc3qnrQDDXzoZVzsqogG7+3pSO7zmzJiEAOQNKEbLNladNYt0XbzudHydPQupyf33z/edOb8gVvKkddlLbZg1WqduWaHR8Pg2XsvQfzxXrNv2RlMpJ/cy0xgSMjzjPSAgwhIDgPjwDK5tqUErCtnrmIik4tH1iphwVMWYT9FN49LojLDLDI3ClGHKcJh8OEeV7A+aBKSlH2VSLMiSUEEyJ8AJz3GDSsUvEWI6CU2jxU8q6yIBo9qZZfAS0wIXSLzBPNQRPnclh0ym0ncllcFoDzukMEJgcmEpmMCMiHE8RbzVDzc3WW9/r3U39rm3b6PGzLurUtLuOy+jxsXkTqzTQU0Ii1FzBQw1ETGh0PZ128Ah5VJpUDqFRkSTR6IVuXddm2wDIWKLSlM7H1atNfy6r2u71X9evbaWl5663TbV/tOBnyK9G9ctsmWC/vmpcchpDDXEMIcOYgq4JttKyOtj1I2frIYYpWt+Wdl9BProYhLzaIKz0JXQEzV7rSla50pStl8t4hhOxhBKLATkzwLogxe4nQ07VqXFGPMHp6SkgNENXDA5HEAHWOsCwJS5zBYCwqRDhBLDvyEhdzcIgpiRCQkhjUnRicOIMcxEBRmWDNe0UcTdmUQ84CZDGYZEbUPIXmfjXY6PXeywgRwQUNiyNcqAOqYUbD0JhGUZtTMXKpxRRq0NP2TCWGqgAMApyTMFApiatN4e7F0CfGwghHHmCX2yl7mIGGCLAIbCmIZbr1owAm5yqKmxk5lIOrYAggG36E6fY+lP5iAOK8hrDEmMM4SB9Y4U5VS2HI4SC0r9SYowp5x6X8epKgyD/kcr5ACXUCSPxeWx44BO+KR6WixBpC6RcFdDliIIcI0xAMmq70hWsEgGr0q8Zo9diibccsLr9DGKAgHBvOKUUF0VT1Wz73VgzJ5ByC1/pkg6PRoLAC0nLf+uCruoJQ3rN1YpaQViEMpezVmJ2BJk7mu/YvkRhroUZuF8SwD8p9kw272TDmvUMyAlwqbcMIw1DAR44IyxLhnKwniWN20sEAIsYgwtKSjvDDCA57/PTjBePwMf7RPw4Y+IA/+D+e4/0fi+vPZQb+8P8OcDSBaM5twaLE4C8j1iXrBK0Fyn7NgPktgvm2IvqxyrdeyWTTOadieEw+NZ1eaW+/ncpxQ/mfFezvfOUev/67PwG5PYARREMeI168VKQjmCcwLVgOhP/vn/8KlkPVjqkB6Zxydq3MHZBIjPFgxuF4xJImJDgwApYlAx5dgAuc5/gzfPt3ZszHCTHOACcMo3hzUbAFIeF4vMXr24/x0Z++h5d/8dXNMlhTyTwfcH9/xDB4LEziiQsAIyJRRHIeSLL+ydos7t8F/AjIiagKKl2mGbe3r/HJJx9n0KZ4S2Iwoq4NZf5R6dPYeC5B1hA62RMAsHOiLrKau1Uv6z9TYc4rd97n1u/kMZORFFzeVWOgnAhzFkSgwAd1x13WVH2ZdSsvI0/AFEULJiFe8t2UQ7u1w5aADOxjYjBJ/PY5iottiWOvgL56ZlgBU5zM2gtIiEptJeeKIo5I2tWxq8ZQVTLltTElXR89fMjtwHlPzPt1KrlVJav2s4ZWAmTdVzDrHGdEzh77iJAgpzatcUt5vDJmUPkV4R0YIdT9CRDvOzHOjdKLnAecz4YkUWY5J/xD8B7TtCCxKGbJOXBi3N9PmKO4//Yu7yMug8hI6h15LmN4WURR7eBLmfWUmnieYYQQEEKo3tCo9oOCPL1Td9F53/Gd9zrlCzNfxeRAqijV04tIIAQcliOm6YjXt58CSLh9/Vra1bee9Fhnmo5948FRwaV1aNZ9eq2cbfkiLZXOQbtml6mMyqMX/jZ7JypZkexVqtBUPptsRuwQZ9kzyQWMYcjj04B/dWw6mT+7MGK/e4b9fodlOQJImKcJMUX44DGOI2IigDyCHxCGETvnkDhhcIznO4d3doTlk5/hj/+fPT752TMBvZ3YVy244EpvYoJYk7KV66tPR/3+qZyGNSADOOmVoveOspW+TYnN9b4UbZu9SQvKO7y6IuVv+EO9b4Ay8jx37QADMuBV2peUSL+1vJTl3bbn1aX08JtU8r80l7cfZVsptLzquGf83n96i917X8Hr+RnmSGIk41sMbofx5l3sb7jrG+Uu1iPIjl17t+dh+3bQ3t0CnvTjqX//Me251SJl/pzp/4dAM6fyW6V4Lo/N75/Nmt6Xu50jVOYcARnET3A6f3LF3JkRyhstQydmX1/v9fhZt0AV99u17/xK+HT013WfPSXhXkpPuzOeT5tWH9r4Tu2zm2CZ7VJvrhXY6vuHRkOfo0lr8ZjvgeWY8HwnngU9e4iHQtbNb2PnLrvqdnbERSe6xAXH44S4LHKYMQxZJz0jpgVhCIADlsOEGBc4B+xv9ljiglevX+HVq5eY56N41VwWHA/3WJYZDIIPhHHcg8hhybLDzTAgBC9eYKcJmI+Y5xkEzvKP1KmuxyKXcareNVM+ZADoYTaX1xsq1XdwWT+esMwL4hLx7NkNYoy4u7vHEifs9gNSCUHl4QcHBI8UPeAY7rgHuTuk6YCJ7+HJIYQdGGNuWlf5kaTiSd79WPWW0t6u6F3zYYlUD12qLL9JCsbgJACePFLqgb12J61QYpVdpEgS1pUwDEG8lfOSPZaqPJMBMKroRS67sSnY3IhEftX3LehF9Z9VFrW6e5ysaw+SaQ+vnPa6swVAElAQQw/DgOTwgfMeQNX5Fr1+kx7gHCOx5gsw62FlPeiSgVMQj7EgKoezgnNg5HBmpKHCgel4xPF4QOKE4AfxQEu5TBnEdH93B+88hhzGrIRSSgzy6tlHDtp553IQgdbD0jxNkk+2F3nvMQ6D8Wh7pbela0te6UpXutKVrpTJeTFWCIMux6AJKCeMxUCUDTgJhqHnYlwi1xqUapgDBnNESsJoee/gQwDzURikzOSpHqYw3wBAVUgq5ilH4FTzE/6JAWygiguj3YlolGvY2CUIyEyj69Db7clqW05h/pwDrAEHyCduM8CHvBfWvEOHCxCpioHMLVMM7YkcS9VlbyhZ/sjeZvLJeSNIqScEykx0tYFqH2XFZRZs5H41plaQkMtgGW/cgnJ+t4YSqQKUCA1LrPdV2FHhQtuhgHIys80Z3GFPA4iN2DUKKiHtDwe10SqynDma/q6CF2u5S79mo6YZG9a4JWmq4Z5L3VTA0jqrZxb1CFNBMSjtWdtWvMRo21YQls6nbBRmB+9Qn/GtgKTpFeUzi2ehlLJAo2CvXt1GdXwRTDnLUwoSs+X25ruEWxBjcW4jq65R4JMqN/KgZmb4bAglQDwHACAFl1H2wMBZwM7emRaeMMW7UgOeogBnmJDCEbudQ/ADIgPHJQAuACFg9A4xzUXwlnYD5knVzr1S+vyJBKuWuUQZdk6x/SZk87VKUTpz/zFpa3qtwvg8rRV37RUZbwwXPPbPn8OFZwBuQByAbPAGA4lnJCxgLJjzmD9Xzj7/rfpGZkyRQTm04DyLRwM4D3YERwEgZAGdkIjgaIdhN8IPN9Awd+KFiEFYACxwFMCBsXcL/G5cza++LAwgphkpTeJVZhHgIiAeShKJ+2POaniGE4/JWTkjaeg+lUExUdwrD0PIu2LK45e69rB7TQV/ljXPZZBOourjzLkKejmhtHGgPG+3++NBUqWNloUYsG5980B0+lUBKqyAGQUZ5PXRiSInRoZo89Rj1VI804EZMS0Z/OJArgJwWNdmx4gUBfiibEkJZ5jXDaNko+IGKc+VrMzhvP+ieDWra6ascYAfpB4SHlCVXU7GQg6VpZ43yJGURwHLObSPdIEz/AqXEFTqmU7aT5qMvCtrsOilOPeBl7SL/llAkbKPxbyPOah7nFT6w4YnJAHDJF1XKSvlFdDqQC7kcePy6UYGk9kHHWGOC8AJzrscajEh8oLsfARMETEtRWFneSVVuvWeY0oZCTkUVkJcYvY6k3kPrjwJDGBEtrLcgCAQfOl/TglzEuV6jAt4iaKcTQu8H2ROqoIv94MFrtRQmmbl7djUOgepu2x4V673K5iqKhbLS9zyrwpSq4/kPd9lfoQcYqz7JLPymvq0hzUXKt8oY4pBSQBKgw+4GT0GD7x+eQu/cwjjgN2wE17FEYYwZlf2Xk4NOgExeUSMmBBixPPnYqw93K/3BzZ/32afvdIpovK//VxCp4zs9n7zu5hCKh/O5tmT/fuAEd6m1I6TrW+X83qnaV2eeiWv12TvtWUrHPYmkGYrzctHvl0Wquwo308ZTn8etFUSOvvtkhS2W8wNhAUjZn6GhRzAEcElRPJAcljSUnoo2zrLGNH9X7Lsx/O6RIaLQDsy9Z0s45V3qHva1o0r//YGZI3pb7p2GikL53rjofS1Jfoe+nzW9Fp2zbUBomR+T+eK4q/TSlay45Ka/rY5lTWgLwa1T62/27V4O30pLpW14zH0JvLtpXffVg7+POlN1v/180+zljZsIdv+Byy/bZ/v9+ny+4RnmTctab9XrR84J6kLzQdGDA6EAOfkEBkTyqEEJtW9aUG3emctfRd9IqUCoI9JdFEVZCECG5HIiOQJgTwYCfMyY5oX3N3fYZoOIlsVMILww94FeD/kfOQyQ74TEYZxgIRFmsFzAqmHmAwOEJ2XPEs55C0nKTO4ri2i99U9QDYfgsgpiRNcMl5FkL2yJ3EF4tjBwx5uJFAI8IMT+WoYATeA3QIQ5XCyC7LgmJuJS71EjMnrVwbKg6q4Upewqs91BuR/ikQ8NuspQQAuq/d0LdbnjZwF0YlM8wGHacKyyOG4MAxQUA5pZkU2qzrdXl8idazls2Ww5erBMVvAl3MePx9L67SoAIGaslD/VEuc61FAwJT7mVHkfMuBql7eUYVRpaxkSFG+H+7u5UCE96LHBiRkL3PRyQQvsp6VKCmPJ32GQMXeIV1hONWsK0Yns+vzV3oaugJmrnSlK13pSlfKFLzPp3LF8A+QGAuzYOF9QMx++NQtvSjHiya+eNqIcVEepjLQ2bDhcxijEAIOODb3ABhmCeVl690FVN3sKyBDGebyQMfUViHulPpNCmqFeVX+15O2VdBQsnE00ams1ONIHye3dcmIwpDb95S0PZt38l+VW5zzohRR5Lt6KshGOAXRcGGH+7pXo5MFBmmb60l1fdZlkJKW3QoFLp+qZyYsSYwm3lNuW+GyHVF2YsSloQXFXk+vF3CSioc6FnKdBRCibWbbvqL8LcAjS3ewLgZa95FsDGZtP/ZxX2u7ofRJ2791fFaXmLntScAn9r3a764DzXD2aFPVYTaE03ZZsgBpT/2bfrWgrzrOVBjkpr0qAAoNgKGAxGy97Rwv4w1mvFu1jInBy6oWru8rUMsB8EE8KR2mAxgM53029jJSApYY4ZdZjLvwWJjhmBCSw3F2GP0O3/qOGEd/9tPWn++WquUyIatdbTbTMgai1hj0durCtTro/O83Tb9Xb63XjPWvrbb7yt94jWfvMp6/F+DdOyC6AeMGQADYFQMyUYIAUiLCyPjmbyWkDCzhNON4OOBnf/Eu0uLw7Esv8fxLn4IREcYx5xzAGBDngA///BniIp6sDscosadTRIxHODD8MMIH9SqU66jz1AXIGqc1UgVMhBiGHVIieD9gNzo8+/JLHL/753AMvPrRt5GWsKX+xqsP9vjhHwbsb4Av/80EBAWkZq9RimiwoK3cNrmAWVcv61NSBZRzzbr5WF2MKDgJoG7/Mkb0nqqiKadh1v+TJ8dqspknoLKON+XReuie3gEfTKnNnq73JeSgqhML2CNZBRkgp6dqOsqjiOc1UVaqp5YKFBBgjSNAvem5vD6alqhlSXmndVQAMwXgqU829dE+1Jj1KL91T4NdWzmXzjSfhOpD8VZTgC6oexKRy17hclinHPIJicqYkvEvrVg81rB6amnLbvcUZiCytomUOQEZQKPhBR2gHuAMX+S9r8pOVYJlkEpKEUucQQy4lEE+jmuIpA4wU8vT8lqA7Isp82V2XCUi+Dw4K3+ReYniNc+MPTPulMcrJxeBfMquao/7abF9spArn6MD5RQZsMz2bd1tqxK5zatmUMNz5v3VkYDni06/ApCIRb8vaeXQlHk8Vu9EQPE0SAqQTTjezvjwA4fXtwPe/VZCGAGXvfOBHIbxpqy/xAClO9zsPEaXcPfJgn/3ZwtGd4Pbl2v1nVkJzjTalZ6GCODz/M9jqO+znruF+d2DZc7uUf272Hr34RFzCV/42PqzyZnOlItR+UfGdpmfguejkm5diz4Lk8NWv1zy7Pa1Ny3f6ZznJYFmRvIOoIDEQCKPyA6cPMZ3GN/9ewlfeNfjL/444dOPqvwi6975XLTHjcSmUteGbL5FFRxRU9AwaJ/P6ndJeLXN99Dvnu3f+n1dj6eWcy4lLU8DmjF9BjASAY4J7TphZd6iZYGd120e5veDAJcqSdtP+0Qdl0/RVo9rf26eafcJWt3/ZSfa+HbuuTepd9OGvB5XFjTVl6l9tn/famUuWX1OrWsKatHxzW27qIcmfZ/rDPED4+t/9zWwu8U8xQyWUTBKTnMTcPPw6FZ5mVkM+UsUTyMg4VdTFlrU+zJIwsg4qJ4pYToeMc8HLMssuVLW0ekPZE+1PoNW1Nu60WsOPpQDDSIWiqyhrZWS1K96sRXQgeRlWrLoKhUEZOQcrnKGI8I8z/kgpwPBIy4RPcJTvYL6EBDCAB8C4uLBHHPY1YjsBsesynVmqzyvna0lTSkWGVB0j608ZvUF9gBBaVLby2dANtqkhZ/iVrZalqWEzRIdvitjvtejVlkxt6Fp9yorSv1reXr5zqaHVX2367B975wqZUsnXT3HUEnXhiY+lXcFCtGm7JxTR+FeVCfN+aBPlkUpF7oetAVCyIAYM27FK77IlOM4AkAZp845ODgsvFQdtq2vMSipLaTI6vmAkTfho6/0NHQFzFzpSle60pWulInBK+aJnC8AgmEYACyYU8zyABXGhzKz0xroLWMqHmys9xJ1oa9eQSQ9RRW3TI810AAaN1PCBGwZAUSWUgXFBYKgAaX0Qomtk4IYeua/etqRa9ou9m/T1oY5X6HBm/trhDrri/lXNf61zH/1cJLD/ajgo4ISVca6hCoAihAkQBkBeChjCmMccQQN5FENoCKFASosaR3z+2JDeigQcQ0RVOtSQ4mwKbOUdVtltMU066n7Wu+qOrCuNuvztY3OGYNtGa0xrtzLwm8d/5prfd+ehPc51qsVYDQ8VA9Sak6Mlzav6dlPX+YiYEqjmjahrn3MO2hGGuqYqGVQYbGsJ0D2ZqFgmbYePegI+bny4QQmhiMvJ3sciXWWCJEjlhThOMJxAJMEykjkALfHN79zwOuXjJ/9tLb5qRXhEuPIpU9aoEyvJP1Fp752qpA/Xeft61//TsSXvyWGUWAPxgjmEczZMFrSZwAeoAg3ML7+dxYQFhBJ+K27TxZ8/EMgLsCLr874xm+8BvMMv9/BOY+UAmIaMR9GfPLvbxAXwjwf8fr2iLQIaCJ4wjiMcOThyaF17mzWKrJrlgrqOr4DOHvNCH7Ai6+9hH/xEdI04dX7vwJe/EqlBwCvP7zB6w+B4QZ475tHDM/FQC/6q15dyQBTZ5jQ37IOyKkyn43X1VTy0Nht1zFTUkI+jSqwoETIirIN4jo+zu1Tm6/aLE+sLf21TXBBeZVNLHpdY1V5xlBXMZQLLe+nsj7JOxk8ZQAz6l3OnqCTdTynkdfLk2SUOlWBZQpOGRRoADVWGVf3iQqeqeDdYNLKitcyPlseQPcAArIXtLQC/1YAooIsHdS7jSpsU5L44KoUroDOWrfaTVR4Bx2bzLKeey/P67qu+7jVpDsiJEEmIaaEmN2IIyVEkj4JIcDxWrnXg4u39nO7V/f3WhCt2RuhTb3ms2reEE9AcAACrMcnS6fKVK5/Bsq+rb1cR7gF2xFRDmflQQ4mnFWr/E6M7P1OvSMxgBrWUfgQAcYPwcPRgrtP7vHjPx0A3OC9by4YRnHF7dwAkMNu2MlYTAxKES4d8NwHPN87HH8K/Om/IQB7bcXStHU1+/x22DJc/wMjQgYzNdfW37Y4hZNeZlaXtlt27YWm/1Y5FPtXnngzsMy6XBsyxaPSWNeu5w0LcBB4I7DMm4xLWzPbrk8LmrE9cn4GbeW6tXo9nk6NobyWLxOQJsCJBzNAfPcJb8rYv0v41d9O+PqXEn76Y+Djj3TUVbkiS08P5FzrUcENW5CXFpy/lnK3efVztNVy6yMAJ+hE4pf2jd5RznKD41uN76358nlT08aZ17GQFGHN+/WvvpVQx0nHQbT5GLBML0d0EIQyzsrYKN5k2LzzeLpkZj2Udt+Hlps2nMdF5ft577OXSb3nW63fL0/V6aF1T8EudT2oI8B6ndG/tnxk3q9XgPath+vQl1/HM1P2umX6NXPRJa9yPfMCDEYYE7722y/x4auXmG49wjCiHoTcKJuR/dpS9AVmqAGfU8I0zYhxAZEc2iRIKHCGyCXeueyRNHs39h6UnBy2WRY4RwjBowDMOUlIdR8EqO8dRHpMehtLXBBTBIGRst7ckYYub8O3i3zkjZ4u7wqdHjylCEc+t4OURQ5HtHrBaZoyP+/BSQA00vaqy5bDB54JzgeMux12uz2WZUI6SsgpDSMPSlWublpdmEECbcpeVTde66plsKAfwlo+UbLAlS1SXbSV6WNMSEm85RPV0LjiHciV+vf6R9vOqldon9FDrnV29UCbOp8u1Yk8ZjXAyTTVfnJuxerHSF+GLZtLA24y9htOEpIa3m+WScEwJsFcrFYu17a2tpbe9mLr2I+hLT14L6df6e3oCpi50pWudKUrXSnTNE24v7+HnHJmhCHAo4JghmEEMzBNcjJYw8p477Db7cDMmSnnbAgSsI0wQ9UOEDkhTQtiSliWGbvdvrj/L0y2GlJQDRyWgZqmCQKYGTqGqVctVUPQOdpinPs89TmlIkygZdZijPnEsTyrQpAYyFzDEIow6SH2oArY0PfbE9wtCIIAxLhgWSLE7Y+iuyXmbbV35hPcCTmWL6AeQ6whRMMZyPUsiDiP4EMxeFkhB5TFdWqZajHMieEFXNtMjVTDMBgwRW2jnlluQSfIwo+WV09Aq2AidbLlsO22mW9IfQAAIABJREFU1X+94HASgELtGDz1bC9gtQCVxfRhKvcdqSC3HqcWmKVjrS+DzUPz9WbMWBCbHUO2LTgb4FtjoX5H817JG6L0KOflyil8q3a3J2FIhHxoO8amHlsCl7rPvTsc4EePMPgMunNwTBKGBeL7g5cFCzMoBOydgx9HuHHAMUYEDIibrvr7PBnOM0LgYsgOIWCegONBQ+NsK6313ik6pSD9RaZzikI091qFvvPAMEqf72++it0uILLHkjwSuxyOScOeAY45h2Zx4GyYAAeo1onoBrv9C4zPIsgBz55/GS9efBEcZ0TM8N5jXhJSmgE4hD0jcsQcb/H69UukKECrF89eYBh2GIYd2IYRAcr60awPsMFGnISbYQdwEBUgjXjn+ddxs094/eknsF6YbBpNe6WE+1d3cG6AHwf4HKoGrO6mCQ75e1IdPEMANAIsoJQQfMAQRmjIHwUPXEJ1LchK68QgNrCdvJ4n3gYJlvF+ApCwNZd13bOKjB6csLWm2veb9PN6Uz2pKPBFw+jI2kQaWwkAOfUKo97vqhc9DbmjbRCXWOqqoBIA4qHErNMKkNT9s67JLnderZPyN9XFcSrAEl1v+j0RqPyEghfG0YCEue653usJuLrue+9lcHcex5ZlgYJkyRE4wpCUMaVY3vGekJJ6nqt8j5yMzPsexLOMcxrGU06JqlO3usdRKSNApf80b+cIDso7LgBnEE3Ke5Uj4fuSpG33RW0Xuy+6rPy2vJfu1WuQt41Fz4UPq8Z6DaemIFEFigPinFrbDOC0DZhJXV9Yj3KXwbsfR5YvbngbXbdJPRbl+eM9vBvBkRCP97IPEBCGQfbgQIhR+ZIFKcY8/tSY4EEkJ1Z3ux0GGpGmV0jzEcNe2u75i+d48d4OFAYADoiMAcCQZQ9HEc/GBTsseMYBN74DWZ9ppF+eHfaXh6j71KunaYt/6EEzPah4KxXunqvPbpvSrZFNr6xNa58lvOqEseLMNVuacu0BsMxWam9Tp4f4vacka1Tqy0wnvp+7elm5H2g9Zsx3M26eTwDusaQIHwbACUiaXZA9DAkffPIJomPcvCCkSDjeZ/gEbwaFPlnGXnY4BZqpbdXCWnqJ6xyZXWD7JmNzrj1Ejx8zVEzh7bzcAstszfunpa3y9+1qfRgzABAjcQ3im7D27qjjgWD9315Wh15u6OdmltDbdy4MvdSPn1P3Lk3nsj6hZvy9rcz8ee/x5+T+dU/Ud9rn1u9ur7ktKAZAF4LJfs8fbt+mLh0RI9clXv+/Tdv14zJHFSyTullcpcrK1+rsV2+MzIwpRry6vUNM7+DZbg8fQssJryaBNYjb7/o81+uckGLEPE1ISXQ6zonHlRTlUA4cIUVkYIzDMHrshoC0APPgAQTExYFYDqnM84RlnjEMATQ6kJMQs0M+xJKiyC7TJOFi0jJLeFENM77MSDFBAU+9TKl8enNQ0OoIXcq6w1ZOIZKDjjFGxBgxjiOIKJ8tI1HVmfTjkkBBDv/c7J8jPpswzxOOhyPivGCZJrhhBrGHiJKGdzO6cXs9pQQfhtK3VkfQ6omrzGZ1tX3aW8CJfiRC9SSwelSGz2F9W7nPcF0nwCraptr+Mmb0sKXKUqVW5UNkZt8KwLGdzzk6pwvZup5iKiGZej122tBd9HaPLVtJL1s3YBnUvrLPVc+0VW+TL5QD0o18XXTcEQr8UVlc/9q87Pd+fNSDlldJ8KnoCpi50pWudKUrXWmDGMrUCtM9jmM2EBCCF4W4nOxPBcChaO4KikiIsTJTRQVijDohDAghFIOSXifDgOo1FQKsoUE/lYlcq9tOM9otQ9cAKNRK0D23BZzQ7/W0Na3SU+awZ/4AFmcZsRqorLFni/lUA1AFxyTIqQYu1SciwAEEEebIOTiIS31yLRNq6VToqVPttvWcGgWBCAvE6Ou1Bm8oQEOZ7wRueN5WZa8GSAXQbAFueqBML8BVgRRl7Fp1BmVBTN261nK0ZBl7e5IjBGE11S2oPOcRwpDHrgdYBZUWHLV1KqP2+wYIjESrUENpredHLzQxZzWgKw1Qxz3VZ9IKLJM9ExgBUu63fVbb1gjEKZ1U7Vugk5Y3xggP3wijAEAO4JQNyryAJzGk7nc78UzAYmQVw23fXlZlX6996Wuf4pvfvcV7X3oH4wh873vfxv/7L4H//Z+9bJ7fUmKu6nLm1y87kflL3bV3v5Lwvd+dMYQb7J6PYAQBX0jUYzCZ+cVZ0VtcOet/RjlBDn7v8Jv/SMZqGAAQg2nBfLhDJPEylBKDfMK3fvc17o73mOIE5pSN96owkdNHgsvJxoncNUQMl40iqlIU0EXdE5gJngJSDmHjw4AQ9vIedQYABWoYReUyOfzZv3gB54BvfC/iq7/RnBFt2pcAAQUUxR9A5EFUQ+WxKhbceQ9YJV2r9DDgFb12KdEbKoA0z3797xUjeu2SvaimBQD15J40WAXMSPO6qvDJ/eyJSjQsIuSwM3n/QN4Ts3JN+SK7F28BL2XstDyM1L98gw+uAQorKNL7UMAm0i6AczJumc2eleeIpqkgIAscrWVycooyA0d0LyvtnvOSfbcWllmUjro3K+DFOS9qbxLQTOXftD71WeTfqgjTdqt7bR2LZf2nhGhAPApOEYWwK/sP/GmepR+Lum8qHzkMFWyt+6Lul8pzKYg4ZV96tQ8rvyL5o/ArPbi0Jzuut8r51KR1XM0hUvNLBcYC0hav39/h+ON3gLDg5m+/j2EQQ8MwBLhBAFrHaUKcpqyEzuH1yMM74XuGMGAcd3j/D4HbD9/BO1/c4Tf/41skeOy/MGbwKzBPE27GHdLhFWJcELzDPgAvdgt+/38b8OMfiQGitNeGQfcpW/Cv1079VNQaBVtO/HF0ziD/gBls04jaP5N3uCad9tnHA0se4vVOvfPw/W2PMRYsg43nLkn/TUhhATbtN+njLdI98ZxniTUn9HAJHi7fCV6l+z1PHv/697+G3/yHwHu/coD36hFT7kcQku5vyeN7v3PEF98d8fJnA/7Z/3iUcmQgRTUQ06pPT9WhajBqC/HqnvUfUu89NBZo45ttA3qgfA+n26d63h/lQ5S5gfL9s6Az2g2sW+wUKMLIv3l0E2rZJTThGh6kEsZ2mutv7RjYLs3WONA8tgBKtW4P06nn+vF56t36qZ5OADoJ8mlLa1t0XZafx35tR8eptrmkbS965iRYpgXWtPsxrdt8M2/7/2Vl3NqHLFimkyrL+KjzqL0WiRFj5h1zWCBsHD7Zzv0S4qxbTVW/liogQuQblZ0A5wkCslmQUv1M00FCw0KANcwJQxizrECICUjOYfCi84sxIi7CHwc96OU9gvdYlrmRG0UmyKGjcvggItEL1/tc5DbHwnNrD1dZnnJ9udX9ZblqiXORa+VZ0cmEEEBjxG43YhgHzEMAR877X4LjZPIzLbsBZim6XuYic1nd7Bbp/V43qX+3QhDZ/rWriLUZtLYBIZXzenCOff/UPbkmopPqD7apPWz45vQ4PUvIYcUswMrqwrfaA2h1KEX9a0A2to9VD9KDpfp0rdcY7b/EEaI/UM+5GibaHq5WHcF6zGzJ9Pb7Obn7Sm9OV8DMla50pStd6UqZqtHBibv1zAzGGHE4HLAsEcsSs+J8ByKfgSwLpukI9Zyx240YhoBpmrBERuKIxDEj4oFqbCB4v22A6tV2PUjGIppbY4lhYFnfBU4xtqeYeCLAkbAJamTpBZweFa9GeQECBcOEyn1Fqa+MlpzgXCrtqZ8Sf7Zj4C1gJ4GzAdoYPZyDhLQSDyaCLKgn34kohw4wbULWsALDOBOWRT0EEaoXhbXRE6Bs1MseZlx7KljL3Z+wrm0Ri/FNrvvGkNOI3bls9e9p5rrv3/qcehIRQYHVslcaJM8BctCoEeo1QIW4UwY3zaeErvBOwsBQfT/mk9l6wqQ3WqkBtRc6ttquzAsnhnx9z4J3bJltm4jhykvfapq5CTinn5irIFbapu8bbWsRrlvDbZ0jKXty2AJtabsUYcwRhnGQE0Izww8BYxYKU6rGS2mr3A/MmJcFiQ+YjjO+8M4Ich7qCaEnq/Db7R2evTMghR3cPuAHP/kZfvKRhthoa9vXbCvddS7bb/2ii3hbSuNTCjcfAm7efQawx8wOnADWdQgEQMFnOqaA3lTGdiqqZ5cstUUQ4kLg6JEWj5giIh+xcEJEArsINyzwLoETgROBmHE8TljmVyB3B3bAs2d7OB/yGiCulWmgOvidM3HHZZ1AVhbAMcCExEBMCXOMm50oSZlT9SygGQKQFgYlBlhCTYHUXTBnjx95nuW24NIodf2YpkkM/656i1iVweyPK4VDskqGqqaWvIBTNpQtRZle13vtvk4FtCH92yo3ttbtPn37rDr/tmUpacYEdvJMWjQWdgZNkUPKexTKfu6kzhrinQwQpqsXTL3t+tWXs55uqvd9HmuiFF2QsoLI1i2EgJSAeV4K2FjqRvAugE3blTmZyyKK37q+F2WX07XYrq+u7OUpJTgKZm+QYjvvitIqxZh5vNovMk5yCCsn9SPjFa22iyqDLbjH3GcGeKlgTk9FeZYUNcPClzqXgZqRMS9zw/PZMbAGhlUgsvIfus/080MBNfoOs3gVkLUqA4VQ9/2ah/FmRFT6SvuoL08/phVoZf7bHF/9u3kUrO7b53qFsOZApo90PqWYEGdGmh0cBdzsb+B3CtIjjEEAV/NxAacJwRP2N3ssUebZbhyx3z9H8Dt4PyClCfMELIsD2OG9L7wHvx+BNAPpgL2L4OPH2OMeuzDjxc2Ab371C/iNX/0W/s3/9Qp3dxN0r1jV7YHfj6Vze/kv+h792VM5xoB1Z5wef5cQd9+22ppXz55/bvv6Z+dZ5tIWsHXdqksPltkq8SVX3pSqlysqv96udyv182gr3TVHeZ4sV22vnUtlc91gYJ4I0/1HWA4Obvce3O5dkH+GmICY1NBLAA0gP+MuHnF7nEGosi4TVx6yG7Xnxq59un+zB8rAGJ3bXeD0/NlqAzK9bcvxNqTpopSmv98b1XvuH3jK8bxF1Pw9vbrX9W5jjAnav7SglfBqb9W0z/kHOrf+Ufe3p3PrRJ/KBhexyq/PV3/1JbdjsG3B7fZUiLeEBcojJE+V3tOYlrZdi7bL1krUn936vkVbfXOOJ7lkbjXPbFSGuo9co9X95p0OdLMlu2/VYWtd1XbW8EuJeAWWab3M6IioUEBb7iUlfPjRayQasNs9Rxj2IPJZi5T56s0GsfNKE1UZTeUQ8WI+Tcd8HRAZPhaZRQ46xuzJc8br1y+BlLDfjxiCxzTf43g8YpoOmOdjDsPksNvvEcIA7/IBB+cQ84GbeZ4R5xnLfAQnRnSEmRM8OQQX8PzmOZZlwTJLmChxtimg8wLu8R4wB/q0vqJXXMBgOPbw/z9779YjS5KciX3m7hGZVefSPd09wxkuyeGuqJX2LixftHqWnvTT9KC/oQcJgoAFBAGCIAiCBKywgla70JC7S84SnOHcm305VZkZ4e6mBzNzt4iMzKrT53TPkJt2UKcqIyM8/O52+cwsCp8uTTMdrMgc0zS1KKMWqbRqXwWo3iPtcLffo0RCnh5xf/cSyBnz9Ajou9AcKS7skyvwRHXR17uTxlJ3vfXcNeeHS3KM6DuLRpJB0zvK+EYXCV6cP7yuw9dh/a4Y4ypqbAfPrp/jqs+BITJ4B3zIxLyge9yQ65akZeqchsmIbR1RW0zMAgLzDrG+X6X+dXMMvF0F4MVYbYFi1u+9BJYxMtCNpLSWMQtNr84AVRDEicjaLV3HtqRbOVv9v+7PvmZu9D7oBpi50Y1udKMb3ciRpQYgMiUSa3SM7lmcUlJGujbDPiBGk5QGjKNEjZlnUXR3ptgzafKfZ+SWTA43JZZngoyJ7e/tiPElCUPHvGRK1+CTtcGuM+udIVszl/6+5bWuKNhCt6+NbM3AV80rfJnzdSsiy/rdXoiy/quK2g4GgoCEG6UGWOoCs312RaFdaUwqIJEaLL+uF2jMGOYZbUaISybdG0gNuLFumxmXZJ4F9w67b/mMpy2D1NowtcX4S51VLOHl/Dwvc6matXY0UMxGhIQ2NiHCmszs0fcKakKPguGNnVa2CW7X2i+e+QRyCgYPTrJylm2iJmCCujLT6gkbM1P2WZ+oQNPVfVp3+6wKY6vm0rgntF6zW4I0AAxpwFROGm60ogbxUiAIEAJV72cGqhjMa6ngWnCaJvz4TyM+/dnzUtakSEgpYC4JmUc8fPEF0ouCv/UPBuwp4N/+YId57iq6pZh4rtrzyryl8nTtx/t1q4gv01NyZdsrVtcIhP1rxrd/vyCEAaAA4oD7VxEIo6aAs6kgQjEAjQCiOeOoK9jYzz7ukSosHVGtTknABC4MlIRaCJkzChMKIKAZ2/dtkrJ4a5U8o/IkBnBYzvCImCJqGmFpYkiBB1JH2ZtFeBfPMzlfajOwT9Ok4MXzUfQj7ntToGfclguT5OKuCuAjRFXuydqorDF6CChm2M8ZQ0qLtfmUEubMYM9d8W3/WTO+6pzc2u/X+7ftgR7wAixDAFuErkW5WIN8/F4u4yRADgW6Km8BiIKmctE0dADQo560GHiBEOGUMdxT+DRF7+LMOj93LMiNj6wVgr9X3sjw54Ttzy6SDAL6cOqsWSkOO3Xere3Hjb9giUjUxkPubfUmi2ZmJYm3mnlfzi0y2TIEMlFoe4EowOw8PJ8P68+9fyVkemUJ81xJlMY569hpBJxAhIAAsIte4+hSusKmrGtppHrkNj9uNtfOQC1uX/L80rmisIICyznPzsS54iO3QGZ9CN0e8cz1LHW8vo9fUjb3d7mbtQqsex4FcvwIMA4jwBVcKwIYw5Bwv7vDz38YkXNA+u6I8fUABmHOM+4/zghDxn5fwXXAmPaoeQLjhMNDxS/+PKCWjIEIAyXsxoAfvyr40Z/M+MUv+cm2WQ+86/n56zp//ypQF8u2953FPY6eM3a8+n3+zfXnnv/UN2tM3a5B/+tcisMGWOZaGZevvG19Lo2RcvZYm/rfjYTb6Nyw/4YWd23VZ4suzbPn9Ayv/iJ+BJUKlIBEO3C4F15UDkxUAigNKDnhMGc8ThlQwIzVo6XSxPZY2jfn7W+1eNa6Ob/nct9uPeVr2E1xz9lvn1O3t5mpvPj/61ynq5OvfVq3mTbuWtNZSjle3nvekuVKurQfLJ9Yv/9yz27tKX18l2Qzha/Ol+2ZaL3in/VlXDwluEtBjf8GC79EW/U8h4pt1QMwPs1L3Et6H/zBc9aF74fz0e/3vA1du582z+Quo9Pqsy9x+9N2WlAnZbXfHixTF9+dP+vBMgzCi+88YP/RG8xlxiFPSLs90iBOLC1lMzMaYGbBpC7lPhF/5fvKVWWEgpJnTX+UYXI9QxwGhpRQa5WoHAwwF4QATKcjuBYEKgAnlJwxTQc8Pr5BLRm73Q5h2Ek6pgbOkCgZFQLe4JrBCjSRed/1aEF1DmBIyllLiR5EFuVaNd2b6lo1r1sXPVifq4ixAhp9uY0ai9zJHJzzmfWl6htYCgshYkgjduMdCjGmcY/9bo88jahlQlEgiDyzHU3Gfnsn0dmlM7oU5XoLJLMus432WmcBJ7/ZPyfXmv5W5Fdpd60md3sZvNNapl+n5+332EAYBFDcAL1OWd6xXX//vuv2BRl3bjpcbu1idntoV1O4v8+jq18bO2/3YMZZP1xqw9b1Jz9rZZkkJZns2uqR2uqt11m+9emffNu2IuY8R16+0dvRDTBzoxvd6EY3upFSF2U1CggBgCGFhflMSbyc8zyjZIkUIAh5gkUEMTBLdihzAQOU9qa1UaBfV9qQLP29PaJHPGOQOlPrWrYqxwMJgCWDaJ9rXTJma4NLf9e2t70BfHp59ew9UMa9G/+WDKZnqhfMonLKknJJhDLLXRpYPrQ6MS0inG7FibhG8n4fjtMb7VQUdkIYkYjpXijybfF/r4Uj6VruBu82dv5eX/cO0jEv9mvt6P0rgjjDG3GX/cEmldiYca+bN/KuBSw/P5aofZs/7OYvmrC/TrPk++g8lRfO+hJqVK987hmwJRz5vqx9ADeJXRlN4iYR4pb2Pv1MpuhYAp9IOkXm62rt+fnd5r2uQUmfU8G5oDB1A3wRVEYMASEwas6YjidECggxoeYZf/HDhIdfDVstOmsnoQB1RuYJx2NFYcbLjys++a1H7Arjh/9mbIAZX0JXEPf4A+tVJte7Ou3rVAo/l54nWq5VmH0PuX8FfP8fRFAYwBTBlYACyU1sxm8QxMrQ0wsRm6K1gxuq6xGuGiWDATAB1TzG+p7GBYg1grmAa5G5T3KP7FdWmE5t7sqAWgtOp5NbXxHDMKGWgnG3w5BGEdmZEQmQvaICVNVwEpqyglm8j5+j5vdKTOvVygClBASAg/QZcwW4aP+IxxlIo14QQQAOBRLVTdL6AXDprtw73T6wPuOW+B6dm+9pYvo9Zyua1NaZeX4GL8/aXlMCyJ+dQFOiOqVYVw4u75U55N7bfnMzjjkupe+b1E/PLUXXojDw4n2lVNcn8i6yfmGWCDcsIMq+W3YvtbZ2yNJWyuHR+6k0xa31uQeRrBVhnkotqmjV91GA4i81apfWve3jbo/W50wRthzP6sBDWyAjA4UKgI5II5y46DIB4o0WqJ+vtVbEMCz6fUtRd+3a1tm4VU5T6rVzFspv+HLapOvvYKl9K2d19n7TdA602l6PArxVMwWzgAHpJKkRIyGgoNaMPGUENTwEJLz5yUvMJ8I4Ftx/eESphJIr7j4OePktYKSI3W5EIMYHLyJevnyBn/+o4p/9y0cAg/4YFRA+11pun1J+zb5z37xzCX+9yPM2/vf62tdZg68yJtc42F/3GLuTbVGXNo83wTJb1953fc65YS9+L7nadyfPM/c3LNf5pTe5nfa90LosBvDR6xGvXxxxrEcMdMJcJlAlNUzr3h4DOI4oqCi8BNNaT62TwK7NRpfacamNa5niqef62C3rsAWAsln2trCoa7Pi0pzauu/S529qzW634fm90eqpUWfethcvre/1nLr29nW/sZZ8qcz+N12cjU+1hFbPbs1dulDKen5erud2/bwsZVcs2XOXLs/f9z7oqXn/VZ6/zJn1a1vX2UcwXd27/HE6mI3fy6f7nLJPfT4pQIaAYn9je64t6ul+Exj7T4746D/6DKcJYLxAiPeIaQ+ihBbJmeDS/17q9XMeP+cJOc/IeULR9EdARakAqWyDKBFPA0mUm1KyyPsxAoFBqKhlRq0zptMB0+kAMGNIEblEhGkSfQSCpJKKEUcuTX6R8lTPDIOzqKymMoRVvXIF1aYRkag0CnYxMr0eM6uuRCLUErFG5l46+5hetJSq+nlpu+mc7XOMg8iclBDjKJFCodGxpbQ+My4ALs4iv69S765BG2v979vKRV4XSTC9h4CHrDzmgpy7rWDpuCmjsn7/2oliLbOJTL3i5DRiluiC+moT+8HlNix1HU207u8nLORpEb9X/UVuXZNFqD13DLG2rMdMUiGJU7RduwSwWff7tcV+0UGjNdTPwd6ms77XRvZkh738rWjpyzpcrt+N3o5ugJkb3ehGN7rRjZQMpW2AAkYFc0FKESkNjRme59wilnRGXErIOYtXNyqmaYJEJpH75jkr0yefzd9gbfi/xAD1988t1cx+f78RXWb93JLRv8QQtpQA1hcucohPk7QG21g5lofTG6nsOZ8GYI2SZjUY2busTB9VZJ2LlCg0j4SACIneY2H9CZaaoYnKQQw9b6/yJB0vduUJs1sb6rszuz0KDeBT63i0vk9DYf1k3gk5V5TC7b1rwcqTCT5mAN8yhHl0/JIhF2MdBR/pxAQdSxmD3tcEgKiF3rQy117t/p3+Wq/n8hkBBdicyVin81qH1twSPJsQremIqq7jYRgaYOsaIIeZdc0uy+3G0cV0UFmJm0AoZXiwErVrYLSoUKVUnYPUnvNpuuy31bm1lyuoyg8CwFxQoFFmWNcYAhACpsMRdZoxHw4YdiNSChjHHU4DkOezGdTUGEZ5qji+OeGhfonDsSKOCTElTCfG9MUBYcgYOaJkQslhoQTqhoVtReO5wu5pZePXSWsF3SUl/fnnfjVQwkB7FB5QCzDPE8p0Eu8qcEtx09RFBMRAAmgCgZiR5wzmAqYqCjIAXDW1GCDAG9sTgnhnEXQtFgLXisIZFUXbEMCcJLQx6/5UTbmq4JJAyPPUDN8MAaI8pgd866OPkF4lSPoVIAQBFHDI4EAS4qVanvUAiiOG8U72hwt9aP1mPkmBTdUsILdhN0oud2SUmlGoSiQUTV1FxIgaFycCkPRNDCKJqUMAQLH181o5sj7nAFU6fMX5d+0+v1fZ/hUs1RR3pefac2m9f1tdN8/rpihaAmHa/h7MYOVUxjoPAmme7426B52vFjuYggA1op29OH/XWV9r+qlaGKX0PrCocSnJGTnlWUEpMpcrDGRq575FHvOpDQW0ZYCZfq70qC49P7jWz0X38X3p+z/PdjaoIi0E1DppGk7j6RiBqClUS6mY56JlBzFXVCs/dp6lKal7uOV2XlXWfGRV+p6Nb+Q2fwJ1EJDNH+mvy4BcP3fsTLHvWtpP7hH9LqU7FKWdquvI+IPSvBXXSkZmRi2awvIspeS5AvbXSswQxFzn6xr/GCswzOCY8fj4CMQZBKBm4PPDEbnMSClitx9BTJimI2jYIXDAaXrAX/7lIyiMEnFyd4f9/T1e7na43xEiHfH73/tt/K3f/Rg/HB/xP+GPNo1l3VjT94z1HvUb0pN/rehSn24b2jZ4xI3yLn2/fhe7n2t1eU5Z/uo3M08u94LVYqu9AM4i0/HZ/++XrMw0AGnQlKsAoGdc1DPg8KDnqz71tlCAy0To3NLKKPPkk9t98hz+9RrZ89/5+BPcv/oMv/j8iH084vT4BSqPIJK0G+CKEiIojGAQOM6owF94AAAgAElEQVTY3edmEAWAUoDp1Gt6rb5bddy+tgRa9zJ4VdZ619x67+Vv3zdo5tq1tfzkV8g3tbdfknF8X/Pq7+eUs/zu8hxf9sGaH6eNOlzuIw9aYJzvKwSI88lZJMzlqrq2q/u5dnmMnt4L/T3rObE+a9b3qFZL5ajlF+sz5Hx9fPW5tdX2ryK3b8+5rfuWwP31vZ5HOgfEUBvvNWhpq38vEQMOiKROKWCN0cpn/f3cvqh1QEgf4VsvXwJhJyk7MYKRXFsv72PLGmLBsx8ODzhNR3HmBLr+CeJkWbkizxn3u9eYjxMeTg845QfEEHC/36OWCbVOmKYJpUyYp0eEANTCmKYj8jzhwCL3BEqS2jlGZBKQCTODS1UnCaCWhACR1BmmC1ZtRRC9Z609RazoVyt2u7Hp0lrUTa6IQwKRwGYkFbmAgEKIiCGAQsQ8ZZUJC5gFGIQYVK+gkcA5QFIAV0llDEmbk2eN4B5iS/GzGR1d9YxerzvPs+j9XUp2rzM3WWvtTOrv87TW3Xt9u3wloNWc52aHKEV0qsfjUWYQd7lurcdezKTVBd9OAiEk6rK1RTwmKzvAADPmMFFV10xn+21vW9fHkLAXC9CIld1/VwVTGbjLosD6vjU7hfVTSmnRFhtPG4PT6dT6fw1o8hF/+3gQWj69K7SWzxm9Hb6/TX9ca1/LC30QE6B6kUu2gK133uj90A0wc6Mb3ehGN7qR0poZIRAqAnIu6l0qISjBypjH2NLImPFvznMDL5QiRtMWrlIFghjVdXmDrhkTPAM1DEP72767xChdRkl35nQNYhDrWn/fJVDPkrnUXnMghjXAZgvBXbJL+bACQmzl7GwhLrFEsF9iJhftvhC+9V1obXwyxphdu+0+/4z9XvdJz/16Xv76WhsrdCbc95EX2DroSMdahSubr1tMdxc4xehXGbBQm1tgli2BC0CL/kNkBjt9j6pD5Nq58c7TljB55jlBAFydPABr2WdewCJYiAoWyWxRBitwAaT+8oQm0AeytFS8mOcCVqBFBCjxrDHj46p/aNmn6/7rew1a5AGwpmiTPCswbVmeM2oumOcjPvjgFf7eP674iz9l/OkPnp77P/nxh/jZTz9AHCu+/49+hmEXJe9zYez2e/ydP/wCsU748b97gR/92QdWS6e4MlOA/fU0fVXl3VdR1K3f+867AYvChoiASsgzY55mELJ8H3qqm6YEUyUMAKACdTLlLoDAqgTqQJZaGbkUEBNiZCAyWPN9l5oVMFMlRo0pTGvQP0yoX61LmDHerQkG5umE6XRE3u0whIiYJB2MeFtVPbcIoABGACEihAFD2i9Ge60UJvcTzCMJAIgQYgITYS4zTuWIwhkhJIQhiXcXM7hklFwQ2BShpvwDiKukpwok0Zs2zoD1Htz2AryHOfAEWRo/UWJJ+sZFHTaAMl7xc3a2rzTkvW0ugls1Ja72OlsCrB7O2ANtZGC64rcp1vW8uMZbrHmDfm3ZzlqNT9E9latE2yYS4GaUtEal2LjwqjytE7jVy/cXs+3LquJ2eydRaIo2uTac8T5yxnW1NwUBy+Sc2xiYorBP36CKwt6fprRs9daUSv2sFjLATAxoHpXCLwkY0oCWpuwzXorZRVRazeet8fG56HvEw2XkM+sXf62VqyHRuTKYs0TRggGJjQcIOv+g3y2Vib8xIJk12bHp5mWpBfHDz7C//5WAnhMaEDqwhLqPJAZ1QsQ8Z+R6wLf+4A2AoEr25HgeAqUKGmYgACnO+O//2x/h05//BUo+BxG4ap0ZhC714m9o7/6Vo6/Sj+/v/Nh++7lx9zm1ZPf/0298mzZsnpkruer8vc8Dy2z9dfnKU09sk7/v9/7DjN/72xMeDhNAEfPpgIEqvv2tl/jOh9/Gf/ffnPD44Pvy+Xzt09RX9NuOQzufn7jvEn9zPhb9yv/4TwHQa3z3d17in/wXhMcTULNEMEQNAFXUQghB9CEffpfwn/yXGREZKBmBK/7ypwH/6v/cPWu/WtfxAqfReUg/12h7/3wOLcEZl+BLzy3rLe9f1Pub273pwidqv8+vGW2tX7ryeXnveSomOit1LaMA62hAC9707MlzsMxm6RvG27cbc79mu3zj58+lM91/v565bV5v1m9d6hoAovoDlpS2do1x7hRz3oZ3ofXIrt9wTtf72s0/Pm/h1nzzv9elLMEytPjOl+E/+XGpbmZVyJwSSVhlc/RxfJu+ZAAp7bEfdxiGe9SawJFQOaLC0rwuZjOw7gE3zl0GE3CCRKis/bFagMpIcUBKA2JIKCfCj/+3gnqMGH4nYf+7A9IQEEgB+WVGnk+YJvkR2UHkrlKrRM1FRCAgFkaJBSWJDGCimQBPBdghzgQMpmVaXYI65RR28ozIOTmTcyBjxCjRc03GYi4Sx1kd7UxH32VrNN3lMESUzKgqC4MIORecjjPGNICrOrxm00W3jl5ELvUyo8lWtdYmJ0Lr4wEza93q2nHAIp1sOfX5323+eHmqKX5Z9EFen0+ipRHFpc4jjeDKa55tU//r5EpdZOI0aSvfvjDdvCgSRE62d57rbY283QGQSEEN1BKtPOszuUfSK0NlzbpwXB3H+zP51Y+Nj/q+HrN1v2+Nne/yayLtJX2JqJu5tafrC6Rt1lcyZ7vWbG0X8e+4pEO60fujG2DmRje60Y1udCOlnltUGQ8Sr3tjLM3gYcYG82qOkTCOO4QoEVim6YRSZozjfoGKN6V7SgkUooIPPEMmKVyeY5xaM379mXOxfGm8svf0MoGNPJ3M4JrPjFWXvJE9IGF93T6bYGHGLgMZpGSprMri/i1UtxnJGKx2QALYct12vW03YFUABGJCoCheBo6eY8gxRtsbmdbph7ZSBvk+9QYpL3gt+07GzQAzftw8g92j9FhdfG37c2bA6sy39JwJNkv1ElqZJqTYXJE0MNYubyQ7B/ZszV1m8TbpgoIBZrgNmFxfRlbx7/EofwMYmbDTQTlLMJr0q4z/EhSmwByKCBRQWdKANMGk5QHWcemdse4xJ1Uv575EUdBczSA1Ntr3qnjhAp+eytpcuUpED21jDISq4W1DCEgxad9I5CsxMkt0EctYLFOg4ovPf4WRjjgdPwbw+mxs1lRKQCkAo6LMbzBPI5h2YB6QaYfdLkl6oJjOFH5dcbVUQz2l3L+kYHyK3oeaeUvZ9vyn9M8C5FKQC8BzRS2yd4qsS03dZYobChLhoyqwoWSNwKTzgiBG+aJGfz/nZO1XSGCKjFglihmDwBQhQBaSlE41yj5umwB0DYIRQ1xEpQrBgKCE0/GEL/EFuDI+/PBDEIliqKj3GCFC4rwEAAMi3WMcMloUjwt9RehgmQCAa0HhipAGHE5HfPrlZ3g4PYBDxX6/E681EhxMAjBoX9ZaUaYJh9Mjas0IcSfntP4AS0XTFpCy98n7J38Wyrkm4B7pb0n1aACKc6CiP+ft/LYu9Ge4Kh/be0RRZd5W4lXGANWVYlWfZa8e7me+V84aOKQwt0FtiujFp6p7plfo9PpY84ahp1DKuWi8oO5VxRUIacAwRDRFUUu7RK0v2phCAYS6t5pi1UdIA8TzLyjSsYMkJTqMnd9D2kkkGn2KIXtyB/wSYiQFr83StSCEMPQIOCQqRImYJul67F1Fw49X65t2/jFyyahlau8ScGQHWlqkOgO1iaefrL9zngvaJwa0im4+rvPM98ho6x2781vcFK/QyIhZ22IRkwTgY7zW0hDIuvGt+cLfBCKiptT24KkAAqgiDBWIjJQGtDXDhBR2CBFg6hEZESIQpZ9SiohpJwblEJESADqhxiPSjpDoEYfDHT7/fJ0m0chWZj+b7Fw108+ij7+uDvprRss5vv39NmmvN2/+c97m103nZ+7l9rxPvum5d6/f2XahDbDM1wUl2CprmjMOOYPGHU4TY7x/hV2smLngL37+U5T6Ggx/LtiZCbR58Ra0XM/L61+FnsO7Xv5+S6YBDgcACLjfv8A//I8/wv/6f/wQv/jJL5Er4f7VK7x8/QEo7sB11IiIEWk3IBIDJYNLAUIGG2j8WXW5Rk/1s9NvPHM/XPe9Gf+4ja4a6N/JweZ8lSzTjvX/1/X+qvP+2nzYagkt/nb9LLlgNstZ1v0cyHCJeh8v39xH7nm13t57ngeWudavzwOkXtrJln2/lnnbdU2Ze7kOgAcfijxobb4O6rKzKbDqF2CzeKtVTm9xsTZP03IHeXoWPDUHLz2znGO+7jpnCSq/uDHcaNjWuy6fnbIqmdBAMuo2sliv6+cvDa8sJ9eKMIIooeQRoKS8sso7rWUFIIPtOLmhL1TlqVl1gxlzzpjnaaFvijGBWSKcS5TMgApGOTHyCUhZ+PfTcUYpM0o+opYT5vmAh4c3OBwOiBppBYymzxrSiBREFilgAenoUAQSXZVEjLbngKJyVaAAiowQLQIoaRQc0cfVmhdRur1Mv0i7DiDnWVMvzSo7mQzVI4nEJLIYldoi9qaYmkOFOZcQmQ5RnIIAdc+ptcllFnF+HEdkjfguuuykcoXJp9z0etIvS1CM3V+KOGesHRlae1dRTnokbiDnCafjCYDIkgRCTBExJNH3GHCHlxFUJHX3xjxd6VBsPEl1pTJ3qaUJ7rr2ztkQ5PxoWJsrMt+2LpzRI/JioSu5pLNnZhwOjyil61J9tO71HALg+hV6v40TFutn/Z6mn9ho1rp+i3mLDl/cast63G2hlyoRaA0Mpncs5tPaZnKj90c3wMyNbnSjG93oRgtiOL5PjSI+LyiLEUpN07UyKAAxBsQUIQADY9iiPpMBiEeWGbqJgpTA0DQrS7BCs3ywMWzUjFLGLwkDb+AN94gJVaaKYTFoiWFEHg4BiCkhEC08rwEroywFd8fY+fCGUtWl8U+Yz+jqgVY/KUsAAbWIIJhiEsbbRE/ReIiCOpCCliDRF1iZXhKGPGhaBhEMZNyaMdRFMmhgFhtaVlWBXhAGf2s6cDMoMbvQ3UYOPLOYIyDQWaQUvU4mFPXrzJrHtz1Xm5FQR7/3EXU1B5MY4aiV55RwC6NwWDL31JVjZJ9V8NZmowsF3oCmygJmBG2H1wJvql9I3i/pN1QALbW3V0E0y7QZ1ufVpYESQUyEXRkLPwdD1BRpqiyrdda0ST09lwiOYvRvkQFUVeh6uo09nOAkBsGgdavtHgq+3r6LqQnDXLvhE0H6ubKPKiDppGIIbp2YMKRppdRzPcRB51wAKKDCAQWiKPfF0YNxmmZ88eYRnICPf/uA3bDDz3/0GrWEPjQbVEvEp3/+EcIY8eJbE+4+PCHzgJkGgAgvv834/d0jUIEf/ckdcl6tL3S1jyevWutKwHdR2f166Lt/M+PFq4Tdy4TKhHnKmIsCAQwc1RQlrOFrZT/jWlEA2durGPwrV02pZPFoZH5UdoC8IL2WS0HJEoI3QSKWsM1x88hhtIixbQTaFqcgNFRd7+7MgShgDgcx3L969QoxJq2SKJLMfCTzPQK0xxAZgJ0h5+NpO7GooTSBTc0oZQINIzgHzLlgzgVpCBjHhBBFAVi5YmagZEaojAQCuKJyxlxmzJyRwgC3Cfa5tegAI4smYfpHOyvddunOzy1aAzt7fyyflUsaVUb3OW48hgE/9PlaUCsUMGn7hxseV3atvm7k9mv7zbqLBTTDR9vza1+f5oFGcubLuQ/Z07pmRzwK7Q16XvY+6DzHsi9UPUQGsuJ2jwEZJSx30X2AkNBBMdDzr4NJlXex78gAMNzGFDDgMyDeltFF6THwTdUw3j4FZZTz1m1QxH4OWNv6eUMUESIaCLcy9/SSVTx9LcpcrSxnk/FzqsAEF+R5atEIu3K48xIh2PloXWILW/tYwccSCSj0eUcAo6oS2vMbDozhohK1849srnRPTtPRE/coa6Qa8Jarnnqm9b4SrpswG3dC1PiKzkv5udWp82q2m2Gxzq8pLBdKYLCmpJSObTyVdpalIwOJO6MZMSRFljjYFhIDCccdQElWXRgVSAUMQ8RuBF7cB9zfVUQ+4NU9MKRNZtP1lG+Da+dfwbPyrwJd61XlHFe/0f7/JuhtR/3rmyWbB+rV+3nxyf39TLDMdlv4ynfb79skimAeMZednAFEQGJkOuLw+Lns6e5Q8HvbOef69KxYr2rPL1969qk20DPuuVTated+9YuK//1/PuLf/lvCL/9yh1KBFx/NKH/rF/jgg1fC+yhfG+OIwhVgOef3rzP+5t8/gFAQI2McKg5fAn/yx14m9j25bMulPpS9+dKM4E2O7anZupRZnni/gY9XoIbrpS8/rdfD1rWvQkvu7/z61r2XrlyaU9vQt5WMR4ynI/k+9ySzdb4ETW31Yfv7YtQhv2dsr9V1u7fP48u01W99Xqk8THwViLX4RtNHPTUvz55lBVEAZz23Vc5T8+VtxupSKU/Pw3Pw1VYpvY+3Rk++qxDesTKa5HF5T9lao8rXoade8pFlbB96m7XKBMTE+PYfMOIY8fK3JP0S1yjyFpPMCyL42DW0iAjCTQ9gvHt3FBDQxTQdkfMMELf0RBQCgjrqHX5FmD4VufXl9wVcQy+PyHmSlNJ5RskH5HzA6XTA4fCIWgtSGhFi1IbINkwgPSM1nTSbXokkTThMbymyhshIxnur45o5gEHSQMlqZ1SdDSY7mSNhrT1FrNexETFqDSCqIKpIKbRInF1wjQghwZyMbMJVVOQqUdQoRMQ0IqY9GAEUBhAliNk8dLBIECfMWk89QjqoXQc6mKHLr9Sue92B6QHJ0gnDyYKAjDl32abWgmmeQIA4XFTVNamORiL/ip6ejGul7sS5nO1rMiDIUm5qDqLkoqCrHCp8gIxbIOlnIkYwufLKQtkCslj7Jap2XUVAXZfQCzewzEUnqU3qEV96eaIjWL5zvYvQhbbR4jY7u/pefA4E8kCpZb1Vt9Pkc3byMMNSI/d6boOgbvRudAPM3OhGN7rRjW7UqIvezkFZwnoGF92EGWLkke9r1VCIuWKaJkzTDIARqCIrmj3EgCGNLlVOaIy6qd7YgRUCdfWPGS4EVIFWBwOneAqhR74RxZJ4RCcS8I6g8NXY08Ao50hwYbBpwdT3dwRnzO/P9c+a5kaZOzP+TOr10DzACSJUsb5RjT0iqUq7RUjQ9lb1zl/Ui2AghsbTKhfbVCLkRHHtQ++ZT2s+2JMacog0UoQBNOxvcsAYZWqrjssarNOBEHCfhcE1ox4CIVjbrU5qIKscmoBHMJ2UgVcMSIQFX89WL4u0Q0v1bBttkkhJAJzw08skfWGFGE8NPBRjH6N2r+t366sAl3+VVXguaCAa8XboQoQ8pMAa84oI6uHAVQTLSGrUVIEuqLKMJYVULUUE5DYODFJPnu5hYYZUFX90/lgvdfCVGj65gtq6lHfbejsHTQGsYT8bCMcKVwGNgihJiNQzrAUBlo6LyYBAqQnBEqFEPXJUCWE1pmhzRBQOlQYcCyHdPeKD1wfcjy/xy5+8ggQFuKx+4xLwlz/5DgAg0s/w8sNH5LDHjAqmhJefFHzntyfwqeInf7ZvgBmbc30adl+ptRy3VgL+uuS8rTpcVq7Jd9/9fsHHfyOh1IhcgLkIYKaU3KKU2f7bDfOk+0mBGLoBsCniiuTWhqbtIpuKVdc+IwINZDXnrPNb17DOf1LjtSizuJ1Rrf6610pObwOMWatrs8VzmTUU84TdTvJ8M/TcCroGbQXwTkf4DQxIttWP3ugoSWoKgAngE9LwEnd390AgpAF4/eIejAOOp9oiWgQwYiVEFo+byhVMEokHUA+crVnlFE3c4gnrQmdVgX6Fybf0wHK8Q1v/PUUNdK3DPIRUSdLUQyzeYVyrnvHGJ7Btvv1dtbrPmjJL9/fe+XpQnDWMwXq26GkFAxTWymhaIgObEoECg7nvX15ZafsgO6CwV/pIf0v7DdgpnccIIalHYgdrAD0ij1V9qZQi1KpQoOCVXP4mdn9XlwrK0irZXNac6WBUnhdRwCQaXh9XZkaxtUUGULb3FAjqWdeubvF27rKCIYOq7vv5I2dVrT11Z0vp2HiuZfSTBqzm0r9TNT6jtrDnIFNY167kNNCNLvLOG3AbG9/XLeWS1QPCgy33Rl1P7rAnfZaVMTCQL4HcvtiZIeF7Ynt5TwHGsOh2fidhqMHJ8VhS1Ll33bWINsYzUMuz6HgzEEAGlLe11HmcSkANakyhCMQ9Qtgj0IgYElIkpDjjfkfYjYxXO+DVPuLFeIff+84L/LN9RgcYWqvOyZ+hrd6brfnq9Os6d/8qEF34+30TX/m09c21O37949k5QF5dbX//JoBlIJ73KQ6Y5oQQ7jS1JYMjgdOprbs1L+vLX3O+jOfPFTpb3Vv3vK81enmWbZX/05+c8E//hxOAAcDHAIB5+gLjd36Cl69/GwkJYiAT/UbNRQ3VAfcfDPj+K0agGcNQsB9O+MWPC/7kj8cLb6fFX8u+XfboOb/eYZnP7adLfWoj3GAFDtywmLN6/RJY5lI91nOdsT3v34V8GVvzqsn8b1neVj3Px0q/vwAKeZu1sbx/ufbW9bC/t8Ay27vF26zVtxuVba7b74jLeeWfWz8vfOQSNPP0+8nxSEuAjJ/dW7W91BeXxvkyPd2z69Yvzlru4JmtmbqW8nzH2JqyNNoG7LAnFvN0sQ7lL596SaW4ZZnAEyC5yxQG4Lt/N2G4G1CRwBapVUU6AzeIyOt6nKy2qhu0GnFFzhWlSurYeZ5wPB5RuShwQR6fLVJLDDh8Cnz2x0DcAb/1Tx4Q+YBpOmKeJuR5Qq0CujkeH3A6HTRyyiCAGdUZmENDKco0K8A+qXNpcyzkZSRo0+2Rho5lEGoxWTq0tlEgxASRySqrXs/0viLPUH+FAGMITVcMqgimcwkAOAjcRSM+UqiQjFUVTBWZs0T0pYA47LC7ewVQQKkA4g5x2GtkZ3NmkaIlzTok7RTaMKm9AF2nbfUMpM4aBURoEXV61PDa+wgqw6lCx2awRQ4vc2k66BTlXI3qMCfRuru8KTpdoK8Yk3V5IV8ZsMeiYElbuwzVo9n3SLYmg1q5oICmyvdy/AaSYx2tvl1vAJY+zy0yu9SD23fL8pYRZc6dmbD43keY6RFYDYjCrl7nuvPnMRwrDqaJvb1ePjLMubOHPeTHx8jsNsuxu9H7pxtg5kY3utGNbnQjI2/obsp3MZQEdCNRD2Pf75Ecr4x5FsElxohpniWKChNiSNjt7jSkY2dCZw3naKEZj8djA2esvdhLLSLwUk+L5MErEqZx0MgaRWSFQMjzrJFrWEP1E1Ii5DwJsKCyCi2h5wwNASkOC2ONB8h4xq4zutsCMrNEXpjmk0anqYgxYBgkUkaZBHwUwzrFgOYZtQgcyqwP49DazTZW6MjqEEJToZlxCCrgeYaz1dv6+zmqkyXapYsfvAyNuPZq9te6x7vNJ32eq7rGBMSWFokXbd9Oh2Te0OfGoVpN3G+thjH/C9AQXKScuGTorQ87+l+9StQjw+615yWlRBeEpG1AqN2TsFYTeqgJKz61GAVSA7O0zcq0+ljOXz8PxWAoqU9qkTQY4xA1360Bi87H38olqOzPOrwmlClgxqevsMhOYKj3Ay3qR6pAYAZqYcSo4VfFqt+iBqSkQrJKX/MsYDurW4ykET4SLA0ONUCapKYuKnxb2URVvN+ZkGkEUUQhoDCQJ0IcK0KMCE3jAEzHy54JnBk8MWgk8cJBxBD2YNqh8BHjXt4JyD4yTS61FrBS0PV52CJruJn56xL3Lr13qWzsdbT0P90LraghvoJZADEhEHKR86AUi/4A8c5Cj/hV7X/qaXsWhmAwwCSKMQ3da3te1RDOBFKwjKWOW851USb19YtmBBajuilQ7GxiBeZM06QpSUjnXdTINaqMYgIjgYkw3j2CiZFnRp4Xr0Z/m5QSGBhjwJgYpzpjGANev3qJOEQwz4hBzsKSJ1AIGOMe+3SP/TDg9OaAzz7/DKfHgnG/Q0gRFhyEQN251QaVNUIKM2opLeqH9OHl/NqXNSJbRnh/L2H9rJxT8h/rWo0p6jyoUi/uqYS4soJp+/sazsfVIwTdZ8pyz172eu+HpmZq4F9RKJJTvkgapuV5E1URtVBqhQBQRS15oRRjZqSUFuGmxYuq1wMMpDSihrqqtygT12nqLCc8c3AKLn9GWcSa0upmvJlEsqursxMIKSBEVdC6M8hGLGe09SjwQ9mXazsPWSOjRNn/WBV9gRZrKBtohqzfe70tSqCkr+rpk3xfM8u54L3RiJJAKwnq7QgAccEviNI8tPOmp1p0UWVcH66j5xFZilCNCcVAJbdeGK0vBRjE7fyX43MZBY4hUekacKZNh3Plp+e/XY3ae0EGvzPPvLWCE+1v4xX8vLW5vWiM7fCqEW82EfOabeMBFMi41sBACIhxB8YO+/EV7oYB96lgP87YDROGdMIOJ7ygPb7/7d/F3/jkJfbjTwC8ae++du6dn5I3ep/0FM/xdff4c3me98EbvUsZnhd6zt0XeaoVWMbPb//M+fNPg4Hetn0EIDADlVCZQJQwlYLKhBp2GHcS/azkoKDwp9bhMu3M8/rr6+B8t3rvOXddJ6KKGE7I85cIoWCIg6SgCwElqoc3IggDYrgHQkXBjC8eMr54mLC769CWPBNKA9pLTYZRfhqvw0DNQJkB35/sfveYjG/ZlgvX+wir9HIJFLO6fnnuXprblwFlb0vrfrl83/Pm5DJ11PlvuM8XTumroJnrdVyVc/bk9TZsrya5uly95+Nyjc5XvncEeZvR6/PqbVN+2ftWot0ZBZW662ZqLWu9cyp7Rv3fvqbP//by3XT2v5dutp7lxq3rPyJEDs5laTmzPNiu0pXUSxsgz0ttWIPsQqoIAzDcJaThdRe7rU0sEWZgQHEFc5A5TlZWecPAFkHBF4yHxwecTkfM84xSsqagDS0leCniyDmOAwKLDirsKzjNeHj8AqAj8jwh5xnMFSXPOOJFk8cAACAASURBVB0PeHw8IOcZu92Iu7sXGNKIUqpG0ZX9mShIVGPl61MawcyYJkkVTSngcDjKXCONxK5peudcUCuBq9etc9OtpbTH4XBAcwpQecNSwHawQ8Dd3QAm07+JPFBVFiIAkRkgiTgTEwGl6NwAECQ9OgXCMO5AgZFixH5/h9OUkTlgGPcSkR1dTmQwUDJSGlzqnw4Q6vrFeJZSycuH8lvk18rmMCClVapOltXZq0Aog5SFIOmXpmlCbM6bpneMTbfsddQWkZ1ovauZPIgmZ9lia/p0cB97lf3MGaWXWds7JdpVj9Jvv00G87Jo1x8TSpl1TnJLd9XaU3Ovp6uzj5h8CSTjnVK6zM/qbOyBMV2ebCApR2Za2KKtE6qDYnqdPXn7wbIkGQBz+lm3r1/rOhyvH7nRu9MNMHOjG93oRje6kRJjydDZ1bUnuTE2xtiLgWKpsCeSsIyWtialYcH4CtI99vyqynBP89yAD60cfQdRgCVG6MalJYjFcql6MoMTwIhRmCsvoJBrizGHWuCCwffMrZEHbtj3y/6zOhCGYUDzZNe6czXhygALjoGnnlfUG7rIhAUyY9fSQCL9xWq49sYXLO57X2RzwoNgehqgJa0BNL1/gcChGUm3nl2H02x9teKLtwxHCyCHG1P/29+zNqj5ezyApxnIXFn+sy9z/c6lINjreW2sfLn2uf3tzPICjhGwiUQLEGHCPDzaPCIxJFqoWMtlY0I62Lw+nJAMBlgMiD5i1FrQsTGz9S1Art6H9n6VRgEChmHwvdHKqpXRw14thabFuiC/NiXtGuu+UQFwAr7/jz/Hh69fYDdEBKqYj4x//r/cYTpur4lf/eQ7+PTnnyCNwO/84yPCkFGIUChgGAP+8D97RKAJRI/45c8i/sX/9T2YX9uWgs/3UVNKv3eDwfNpS13o69wVi13ZJmm0NB2SKRIs4oTNH4Z6feW2f4cQ+jAqWa7t6oAc6zVjwIOcBYBTq3jcRDfv/JmwaI8CJdAM1wBvKGptPppQX7mq8qeqwsPUAMsRZQbSEPAP//MPMZ0+w5//YMZf/Gu0e3ru9q7iJFj0KMaYEmi3w+lwBEjq/+WbN8jzEQgSsePhp4yf/z97iSjDdyh1hzwm4KNPJeqFTyG0MZZsgBmXLsvG9pskU3bJXm5KDqmPhOXWeaRtse/Y9gmszg9I7vXlHKC+r2zQMlKefXZjQ/4clx9TUHXepgNXJIIWI6bQwYeuPpZybg169DwF4KKs4ZzfKKWI8pDi5rnR+lbJ9mVm1tz1K4AEWbu6cnJ5D0EilfWzxdaHrW1b+0TWT7Xt0SEs+9+fqTbmHgDTea+g4cWX4yVtsYhFfd76cvz+Yf1n7bE+9Of/mo+7RBK1pi7m2daZbL9buHGncPS/l3zSmkc5V0w+l9blGa3BxnZvrQIc5XX7ybWLIOFk2gFAepYSAA07ngYMw4gU99iPO9ylgBdjwKv7COIJKTB+57c+wuNn9/iv/6ufIYRf4OHRR5c5p8u70nLvfX9c7DXaOiH/ehNd+fH3PLesf59oi5cCtg2O/vxlAOd3XJ957zorJaFpRS0Vcb8HYsCcMzLPGGPB3/3DX2EXgT//01f4d3/y0r3Tv5nc/9dqfsnQ//WurUulf5W33t/t8Xu//QkOxwO4AAURRAkh7hDiAAFZRuXv5C1EAcPuBb73ewEffHRAqRmlZPzo34z48Z/sF+X//t8j/ME/IuS54OHhEVwDfvTHA378x8NmjZ/Thkvyx/kIbn//nPXLi9/X5+775jyvy1jL++z9b9Oma98pB+tOiNVaWIE1ngKI0Man84goVwyVG9FYlnXbXr1b5T3dR73ll/a88ydW73UpvvwcOt9LzutlUVgW1xbPiHxtZVu/bNXjemufM1Off8qtx3h9pvboMk+XeekOD4JhKPAAJnn6+9b3mhOLgGcAwEtH1/Z2/9f6rHv1/Qd8/LczduO3UUMGFY0sgy6TiJ1ewA0hCCNcWVO1BhnLUrtDTM4F03TCPE9NJyAsfQfLiF5K5IOcZ3z2gxfYvyr49n/6BR7ffIkwVBATamZwnVFLwTydcDgekHORaIlphxRHDMMewyB6iFpY9R89lTqwlOFM/goqm3t9lxn0Y4xA02/L7DWwzTAkjY7JCNzln1olsrU4X3adR/MQ0vfEGFs6KuP3maUPc9b0SzGhckUpDC5ZHCQAhBgxhlFSXRdxdhvGQQApXidYEmrJKHnGNElq3WEYxAl1pZu/pFMlouY8mktu0WnkOSzu3wJc1Mrgmpt85+U+ey64PrYoOQYJszG5BrDodQgaFbzLclvy3DpV0Jq8/WH9nqpRdvt8xkKOtXroE2g7GLEGyN1+sbdT+LLkGi3mZ3BjIPK6ya392tty9swQJ8yFjnYpi2/q3PU/4a2Wu9cycvxSJ/fvm8z2ddINMHOjG93oRje6kdEKDGJEWBoDOljg3EguyPjU/rbrZhBdghYEWDCOI4iogV2CoqitLDH4S6QVViMj0I0wwQkEHshg93SmzOoioTRj1DKalO0YQ6e+3GLwt4ANVzoWAByQoht4uveAviMEJKlYqw+gKYfMoIge8nM7UK0xv2a8u8xAvysKews8dA6GWQoXW897AcIM8GtwyUVAEotRjbGO0ENnhjRfn/X4XYsgtP6xsfTGvnW7PLgGhGZk9bRuo18fl8A7vq7n7xWPFWbzqA9d6GTzeq/igcUMZlLcFQMt3RIBqIACZAKgATlcGjBm5FIQGYtoNxI1JiFn8WAJi7GTMqRNPrdxn+tt7rN5hUhKNzO0ymDroF8TctXyGFPSHNOSACJXgCOQAyMlQhpG7FICha5IXK/qUgJQJKs0SgYHRgZhQkAYCPtdxC4NIIoYd72MNWgGrmyvXuILq/ibpKfev1aUneYJc46ISb+xyAvU1W6lVMzzrKATEejneQZ4bnMyhIDdbm8ZtpzQvly/tdaW59rnxZZQxWjGPAYkTdlqb9uaJ7a3eoVym9/aVAODpiQRF7wSofecKOUoFuziDsPIADLWs2k99nmeMU8T9juJ9FF0vVGU1GtpFDG1VkYpjPlonn+ESgEYEsZxJ4rBEGEp/LYa2qPKaBQXU0jRFaXrO54NayIiIDgvaVagrUYxCUTgGCFpkvQeq0fbF+NiH5b9br2nXqwB/Bm/qBdkJlgIaRINjaxeIsTYFUji9SgeZCiQvnVYFFHO5nZOrM8tm1M+L7kHxqyj59n3gPAAwf307y6fvzGqqtytCeYOlrE1173kPCimd90SJLJsLwBN6VRVcdcj3FjfWRhpf57J+1pJEJCOnW29U6UMBQLD3hPaOl/ylVvnolcOhs17rlHb092Z3PviHPhiCmzSDvbf237mI9H1PnlbNeRl8vX0gJkFP6HnOkzhSAxLKdrSsVjURWhUMQ5gIlCsCANhGEeMux12aYf9OGAfgF0qGMKMITC+8/EH+A9+7xP8lCK+/PIz9PDl0rPrXebSrrM+g2R2PTeKxfunX/eZ/VXo7dXcauDxabnc/++TusTVPz/3ubd74psjq9GlqDLn7d0GEnxdLeOagZoxpBEpMSYuEg0QDI4JcZ/EUBGvlLFhfr50528KfdWaDDHg9d2AOs0S8ZAJ4ARQRox7BIq6MRBAQYJ0FpYoAmHA/oMBU54xMCPtjVfulGvFDCDuI/Zxj5or4hCe2BPfvV/9vsCrT0JPr3c++x9nf/s3vA9aG/+fS+f7oMqTG+U+Vc6lkjfPB2IHoD9/1/pqP3mvvXvF/zrQjK+R/329Ddevr++6tofRhdOCVyPg69vqfAVctPxu+Q7fVi9fW2onf++lNtKVT+9C63LXrViDZVZm4It1Iffj27RO+EqrWcPgFiX20rkEXJ8LJj21s25jvsYxYHyRMA4DCiuHSXQ2jtWi06qTIBeLfhEa/x0CNNX3hNN07CAVFgcKyXYUAVZHKyKMuxEgRs2EUmcgnkBpAiGAqILrjKzgm8PxiDoXDHHEMO4wpAFARKCIGBOGhAYI4Ra12/R9EwA0MEspuTk99k4R4EHQKOYhDE1vLRFyMqZJ5UCLdMUVLVuw6u2ALsPUWiV6pXNeSymCQgKU9xcHIwJZ+qPiddgddEB9ciDFiJAi4jAIqIWguhhujk/7/Q61WIT42vR7PmK21dvrT9d62fZ9iAsZ/ZIjQJfBtmen2QTOr4em8/SOU0s7AboayOmiQyB3nz0b3ANruXO5ytey41rf2wEz5uLXnytF5oBF55brXU5/Sl+z1icbIMdk8G2bSbdBnGuwrksTm4AgWH+cn0T9XX0cyPRT5M8UbntXWx/2lO5l1K7e6H3QDTBzoxvd6EY3upHRJmPqGaelYcIAH1BDI2uITUlf4AE1tPgtinsgKyr95cuXyDnjcHgE1wJEYe6HITUwTc4ZpRYMQ2pRMwDgcDi0lDAUBJTQDPjqjcCxG55EcEg4Hk+OgYS2EY2PM6AA0ENf2o+h4dcghjVaWkuV+2C2CUJKyUVoAO7u75A1nCggqRKYa8vvaoYMMXCo97RIXIs6dEbXGN8gnhpWk426vg/QjPWr/y1jbe89TzuxBsSYYcnXzcpbA5S2BCkf8tKiKHjBxgRULxR5gWsTKNaEpG7UIhBSHLS+kLmi6UMs/YOMm36nAgAzqzIArSxgiZC3Omr3tfW41WfrfupCkCgOTLgHQ4RbnYNcFXRAAFUBYBElFZClwk1p4lIwEZFkBCaS9BpS6yZ4+XknygQBahH637K+LJWT5jg2AZQJYAEGeAM2s80nmwdYtNm6oM81rbsMDLjO+h6JRDGVjIeHCUBCrQmMhCGM+J2/A+SZEahiFzP2gfGv/l9gnpZiV0JB0v1lmor2GyGEAeNwhxDXCmNTVnURbnuH/fVGmXlbMuN406woyCEEOQdqFbDMNE2adiWCWUIj93WBNqbmQWbpubwiqFaJ9ALYulmDIN16d3vDWZ1X+7IfJXu0lAI5WiStXfcYW3sEMVqiasgewzUihB0+/O6Mwg+YTxN+9e9eArPuTSrKm5KyVEbJBfOc8cWnv8SbacJhnjDXCQgzPniZkAIhFJaQ/zpDJGy2nmXDKIARZ9DcHC/bQ+RwW3TDNzXvGAxJ6W2D7/Y63aNlTyGdB/r1htLN/ra9BisF27ZyRz6LYsXOjV4728uFTEGrSuZ+PLkzR37G3QB2YGDbw30ax2UUFQHgrEEMPXXT+ZnX29LXxbIuy7Oq82Zonoa+D609pNrR9VkodSH3HTfAi+/T6sBXsvYM8LKut6V3svNZlHVNmQw5HwwYJ31j0Wc8yEPPJCJJwYf1ub6lhFteW/ddA7hYbVfgFpsLa/54DUzyPKIo8KXtG1vRos6XwK9vS1t1s3cB0LR4XTkqP6F5oMrakzpLgzrvpC0BKIKRQCEKWGYfsb+7w/7uHgONGAJhhxmnL0748x/MiAH40SvGn/3xI7747ExF+laGGX8Pbfy+0dvTVn+7WXSBV/l6yZ/Ml9LB+Ht/I4jkDD6bz6vULvL384Ay30Tb7nYR33rFCI8VEz+AeAAFBtEAxBEVGSUwOAxPlmXtoLNr1P5/qk3ve35tve9d+vXN5xH/5v9+gcMRaHhXCgiREcKM7/5Nwv3rCi4MRhT5q0ZwSAACagio6Q4Ewgffq/hdysingp/98IiSGbWSpF+qBcQFn3z0IdLfGXC/m3A8HLHbERgZv/oJ4Zc/DVdq+q5t5tVIPn9szuf210dfpXybh0tOBu3Kep6er+DlXL7WL9vfnQMlni5pXZ/+aXMPX4FD/Fn5rnSpjO21dg6fWMvGW59IdV4GqLgEnnleFBYX7c/1y/Ket6dLz1zqnyfPVV7e95w6rXmfrbVXLfLrxrPy00+ka/Nja55uzSnaGPUYR8TB0reG3uAWNYJAqAhkgPgMiZBdwFxQMjcB7HSaNLrMhNNpkpSzTadgTps7kRvUxSSmAOaCu+8dQMOEnE9gnjBPFaXMODy8weObLzFNM2plhDAgpj1S2ovsRBG5SJxJSQGbMA6xtRhQWXCcNAV1URksIOfcosx0PbQ6kkVxkAxhUD13RM6iC2auTU7runcdU5++XQEovf9ddFKNPttkTRsz1Zt45wETfWOMmOeMnCeEmDCOA+IgOvc8T5imE06nE0rOCBSQ4l1zbk1pcCl+5NowDK1PTO5IKbXI6mvbgtV9aV9Yyt0yzl1OAc5Tz1q7jEwel35wco3TJbV3bKxCIuFuDNhhwJWljn3r3X2cNvXecPqZhV6s79yiP+v39GYtV+BzZEhzPAN8JFoXvZW39osN/dKVzWJT/+Z0TyZ7rsFDy7Y5XUV7oboyc6+A7Tb99N4+s2/01ekGmLnRjW50oxvdSMkU6YA3TCkz66K6GIMlRhVgHHfNGAJQY9DNyN0FIlHOxyjlzvOE4/GAu/s95jxhmk+CkicgpiDgmBRQS0XOMypX7Hc73L940ZjwOU8oVcI4piQAG2bx8K6k3tU0av2g9+wkr6xjykMIGnRfiQFQZ9ztxwAza1obt+yz5br1ig0LD2nvHYYEy3kKM06xmleVWazGIJJ6mWskjo7K7oIEmoHXGG84I9bSE/t582KD+V2BVrzxb32fRNCpEhXHABiwahJCC2vK/RneCnO5FBLbD6QMebYLz76MrQg13eC/3ea1IU5+TEhSwyT3eSHOhUuPd0DSd9DqXQtDrZIPI+prZfPF6rHVL0uPAcmBm2LSupT2Tsm/3NOLMDMCSSQYgBUIofXrWghnVAMKxEsuaDhZbZGOoYSsBRO4AkXHoxRVFETA9gNmdp7LElmiliJF2v4BtPCgS1nY9iarAon3i429rh2UCQGEAPM4qjhVIIYBKRbEwMCO8L2/PYAApDDj1a7gBSb80Q8SpmkpgIU6YQgJc66YsgpwVfs8Dljr9bxycC3MLYVyE/q+eSFvrXR76jqANrcbSKulUpN+L6XgeJS84n7d1Vqx7qRaT91475QY3hOm5yVfrskO3TLhWr4LBDEGQxWCKnhzk7bdT9M5cFOo2LQWr57a9hkY+I8kIkcX3knOC0S8/nbAi48qHr884bMfvRQDCDpYppp4T5Iz+ng64Rdffo7h5UvUwDhMRxSeQSHixW6HuyTeXeYt2HPLMypJOrVEFhXifMxsRnXQjL/nfc23p9XxtudWAxTEhNhS92it9E9bwxZZzZ9zXnHUri8UMTY3t+tHgfQotWu8LAt9f2710LJNgenblFJEyQJ+6hH20JSmHkQDOLCEO5uM1l551qb2DIfmabgF8hCeYxlpL0Qs0lx24G1rRVNyWrmWQq031DgY6y8CNJ2H8IcClgtUwSjK9xiPIDuw57dszVgeeHtvqUWj8/R0fiFGgCWUeFVwtChHex1NYewjUNn4ePDQur/tnkug4XU0xSUo67wMdhNI/qwAL9/nowN55aW956tQn8tLRawf8wbIdpEbJb54T4dlRv8GlIU7dynoTwIZWOZ+xN39He53d6BCGImw44JPv5zwR//CeM5JfxY9drZbvM1O1PewrkR9Pkd7I+D5/U3ux1977rPvtzbfRClf9d1LM+EaLKM7p7vfP7ku65uhD17t8b1PKvLPvkQ+fAnCC8SwA8KASkClOzE2hi0jyjadr8W+RreIzu7cvufS829z/V379c1nEX/0z+8vvvH1Jxn7V1G5NEJzRiACB8ZUGSElBIr44DuMV98qOD3M+OWfn1AyIyIgcQXmCSnO+O7Hr/Dxq4T93ed4eAPc3TEqT8hzxC9/Oi7e/jQHdp1837/trvqbbppamz8753feZr+K+ex/LP5+mzOHAIDpwj66XdL1EbguLW6BZt59llyqyflf/tutqCPX2ta4DweaWdNzyiOcj/H7oGvjvtXDfpy36mjfrOfpOW33mtnW1+8+j2zW50z/fX30rD59zq+5r60aLr8JcUCMCVxMLwmgZjCAEJLKTuL0yFyQ5xmMDISCkmdJ1UNAjAkPbw6a5pk1Gho5vVzEMIzY7e5U75BR6oRcTih5RvrkhFpm5DyBecbpeMDx8IjDwwNOhwNqqRiGPdKwAyU5BykkhJCQq0RdDgEYUgRpWqQYojp+Me72OwXynFBKBtGAx8dHgCzNjaVyss6SUYnRZALGOA7IZcY8z+qctdZT8kKuEXlC0zOpbAdodBVS58r2OvnO60VRe/qt0OQjxjTNGHYBuxgQEyEGwvEw4XB4xPEoYzCmAQR16FHZa55nAD2iuo8m4+Vjr9tpYJbk9ImqDzC9mDksguCi6UjXSJqquJD9fMRuk826rAWVYc9Xo8n5Z8o87ftaNSox+ej23AUlr85QXYTphT1oZg2Ykbr3cTEZusuFy2g5C9CIytNrvXwf8z7+JnN6B551CilvC+qNsv6RvmGizQ3jHARkiptVmU2f4z7AwFHLPt+6tuyLZd/qU+eVu9FXohtg5kY3utGNbnSjDVogs1kYxG6s9B6/wg4GCqjkmTsfVcYAEXLdDKySfingcHh0IerFK0CYVsk7O88zDscDiALii5fY7yXv9+l0gqDVJV/tbjdit9vh8fHQDJ8xJozDDtMsaPbdboe7u3s8PDwgxohpmpDz7MJiQkEEahxQ8gYRQ8qvjSdbzGoHDKEx/TkXNfbI9dNxcoZk0rCLPUJIF4SEaQwayr/x6M4QurQSSnmBgKK5TRsqfzXW3tizZbDztGVg8v3R7lPLp0WNMHF9LSwQwQUb6J7mDdCxyke7BiYBEMO59ZUx9Tj37O9d1Jl5X5+tPvD9w+0dPS3MQvgEoQs2zpt7Q8mxNGr5d/r34LxfnXCw7gczMJufHBEQEMCwVGYMAycZEE48WQywxK4PrSz/bsCAcCFEUPReNtq/1Qy80h8xJtfO4O7tdbJ2d6O0zt0ga2GecxeYWx9xE3xb/7FEPSCIsT1GAqp4LKECwepfC+o8Yz5NiCEiQBUWFFAK8DjPqJyWagoGTg8ziDIygEKMwhF5yiBEgAsOxw1llv4EXAbNtPFyvfFN0tu+M08Jp8eAODAQqiqDS1vvOWdM09SUJqL0cam5Vi+smttY5i+dGbktqpcHiZVSRFHlIlAIKJMkAos83AEaZIoXgDQ1kQF84PaLtk9U1ihoM3a7CiIx3NfKAlpsehXVjrAAtkJISOkFxh1hd0/IVIGZgFnSnFQYOCqggFCyrL8PP/4YJQLhiwFfHr7Ap3/5S5T7e4yvXyOmiGred5CdtAKYmREYmpKJ3BqXmdT6MARJscai2OvKiusjfwlYeb7/o3Xi9jnS9/WiYxspoEL3Ha59B1FFDMH2TrdeyAMfpd9DWCpu/Jm7RWFxrlfXlq6gW7YLizli7xblG4O5p0o0/iDG2H483+D7Jg27BbDFlH3ruW/gBvGMC6iV0EDB1pdxGUHGP+8BnA182dol49KjvPgoOZqeijxILDRwNOl6ZYTuxdrylhkgtZ/xIQZXvvBsUr+CUgtKlXDktRaAgMqEUgtijao4LpJOUJWuufQIPgJcSq29vg+7MnKZPrDPFSz6ykd8sXbSYuyXz22VJ6cbN57MK/JsrLyy2J61KImdNubxhTW5BskY2RzzqaAk6pCcSAI8NGV57OPXW9j5HD3X0yCep7txxDgMiLq/7IaIXQUile26v0daG3DcKn7rMv59o+e0m9zP+TffdG2+Xlqa974i6UHlgTKLNYRlS59jqPy6aUx7jJFwevwUARkp7MAYUJgwzwwuEL4pMNJOjE15ik9W+Pzraw/Q4q93H4tf33wqZUYpBPBO9lOSqAohECgyWOyTLXptIEaNXV7lXFEeC0qZ8OI+AhPh9HDA8fAlQBGH44Q8T8g1YdgnEAjzqYv97yo/+L5nd+UaeGY9x39zia58EnKalI3r59+se+XSnkl8rgHY1grgbFdYg02Us1/tJbLvrMEli8/09ew3a25h63uXGEmq8kQ9rI3CkF8GzWy96+m6rvfm63Tp/Hu6Rus3XAJL4dnt6+Vu6Bksytkqgk6fu4yuibtQ8qWIbmf1O29b/79fSntJtRuTOkzGKNGzCCgs0WHGcYfT6RHjbg9iNJ2vRJnJyGXCnBWEkRLevHlArUBK4rgo0aW56Qnu7vbY7XbKv0ccTxmHLx8xz0fUMgMs0btKyTgeH/Hmyy8wnWYQi0y2v3uBkPaoNAAUEeOANAzIJTc5KNeKfDphD4BGAiqhloy73dCA/iYDmd7KZHLh+RVQApGn5hlIScAxFl1d9NKkzmYVPWJ7TxUtf4ueYohJ1k1lcPCRq7tDUVB5EgCy6jHmPAPESESgFJ3TBmu65AKiBAoQOa1k1VdX5JLx8PCgepHuuGdAGZN7LEWxl4Es0voCxJEiajFZKjRHj1JFt6QKF1kBLJPM6+atfBuDtQOKyT9yqcuHaOPTdcRrnUYHfqiswaZ3IJXx5G/TW7SzhLtOc0ufvV5XJhdDRKo2xr64HnXVypE6e8cy75Th6++BRNY2AQEFNBtDCAgkqSDNmabPpfAko3bmQIKlXGoAouocsRe7YxPm7Pul2LuUv+WBPmbtru3K3eit6QaYudGNbnSjG93oGeQZYQ9GAAg5Wwj9nj9VUiV4wbeilkkZnYqqglCMAcfjsRkOUkoIIaCUjNOpp+NgFu/jw+EBIMY0Tfjiiy+x3+8xDEmZ8hk5z3h8fAQR4e7uHnd3d3j54nWrnwkLn3/+WROq8jw3j2WP/veGDIsqYwh6n5LJmHMf5tDeJwAVMeKLx4Ew5Wb4MxCBRAWRCDPC/4UFYIEsYSxBGeogxn+WkKMGsOC6BTABhOGV31u0NrZY21r0FMfs+hRFaxBRKy+IIdMisBh5Rt6/tzHXZH2Gi+9ffFdFiIqUNDpRQEoeINPTdhhISZjvACLuYbUX/bV8/6KtiCpE9L6NcdB1kNEFW2+UVYbfCWgmSIjxag3MknG6JHCYAOr7pfergmDAqOwFa5kX47hr42sGtGHs6axQihhIVXJq4k0ILZZH4i4rw5Nl8AAAIABJREFUClguNmM4cxdWieKZQEhqiGWzq8qb9f21j2kz3gJERfvQBMGoRt7+vAjxZowV6ZFqQdRcwPY+SZ1TcfgiY358wG5/j/LyFV6+/gDjOIqhtgC5nHv65xzxwx/8NogI3/qdE1599wGfffmAYUw4HCt2A+N02J09ZySK8qWUSatPfb/8zaBLMvEP/+Uef/b/ET78TsYf/KEofpgz5nnC6XTE6XRqygmgC7Xy4Vx1bDeJIoQWkY7amVLMO0uAEykOyKZIgQE7KwKHRfhfAC00sYAPJcd5Wy9OhToMQ1sbhWdVbA0AE+7290hDQiAGBaDWjEoVoCShmoMo7yiMIFTsXhD+/n9+wnT8FX76gzv88l9/JMZ3lrmQEVBpQBj3GMeIz49HjC/3+OB738XL+Ako/w2Ewwn1ywe8eTygYlwop4fdiBcff4TPfvYpeC5ITVGie3gx0AAjEqG2/rCoHgwu72pieT4RBAwg+JJ+vsieVeWMY1XrakomRlc0QcExHvhI8PtIp2s4IEudZ7VSx0HdTxwkT0FVzBVztrO78wQxyh4ZdGf352LOuQET7JqPtGRt8IpE6xMDx9hzQN9bmStkyi/L8emcROE6tHJT2vW57/rHwDIS5W5AKbnxKAKM6fNHzr7S+j+lgEAJIYyw9Hq1TvLDHchDQc43ImCeZwGU6doTnksU5LnMXbkc+pkmfTmL4VHrUmvRiISdrzDlqIGILvEZdt0DVVokG73ugU0pJTAL6I7YlK3L/esa6GwLcGbp5ezZBoZS3rAy2t9aSvtbQKEXX3eRjPf1PIPodz24HV3jyAK0FvCiK2PYY3/3/7P3Zk2yLMl52OcRkZlV3X2We86de2cFBpghRIJGQYRMNEKUmR70oJ+rFxlfZDKTjEZCgsFEggsGg4WD2TB35i5n6aUqMxbXg4dHRGZldffZ7j0zU36sT22ZkZERkRHh7p9/foHN+YBhY2Edy3EpgJiBMMJPL+HHKwAPZnVo3XVrjsfXkWJXbVaqW+y4byRf3kz51cu6K1d+eVvym9CWxSmiY2/GKlP/b52W62V8NfKnf3qNP/9zwLhz/PG//CXOzs8xJsaUgASHq3GP3TjBfTDhO3+8A4UJP/mLrwto5g65/33ltax5itee4Vd5/taO+zLamRDBHJCSl3RWDDhLSIigFNE5i8l70RvBMOSReCq1+/HfAD//kQVwASLg/7K/wnf/wON3/puEzvXY7yxgNnjyzT0uvvYcgzvHf/63HcYGqP8m89RxcMB6+e2cfv9rK2fAlyfHxtWxOqyNv/vUtz2mrN5LEEtztIJhljqg1qBqJvPzl/OzBBqtz81VzSaA9Iqv3v51rZ0Llf+Xo2F+7n3afVnuMdDMfVehVl9aln1XPdavQbf8dndtluxFt10Ddx5Xfy/vaT3oZgmwao+/jyyZatq+0FWuPl9yj25g/O7/dI3+rIfrhxyUBDA8GDsk7DHFCbuXjL7fousMxjHg+voGMQrTZAhewBIQY4C1Edb26HvZM4cQ4VxmMjHCMD4MHZgl1bEf9xj318A0wTHnVMgR+90Vnn3xGa6uLuFHj81whu3FQ1jTwboOZAYY0wHksi7E6FwP1zlYW3WjaRpxeXWJEDyYGX1mDFe7ngJHQvQIQfTdaRrhXLWLTN4XPUAYa2qaWmFrUX24Mm9S1qFE58tsllyelnxdA9t1OThBdKGuy+AfH3CzHzGFgL7vYUjWKQODcS+ApXEcAQOQSdlW6pGSgGu6vpMAhTJBzdPatvZxtVV672esOH3f5zRODpvNBikl7Efpb7H7SBsyA33nkJiRYtW/xa4rY0MZetSm6b1HjBHT5OGcLXZ/ay0E36JBiSj6rvZHlWa+afTHVqUT+3GTVoy0DLW7mxwMujIHUQ2U0cAYoAZSLAFAAHIaYmFWEp28piMCIKziqLYV7Ye2PNU1q95p0DlbpvCUElJkmUtIgqGz6i16Ptcgn7tkGZBSdc3lLKU6/9qqy8Ct81Q7Q85X05O8HTkBZk5ykpOc5CQnuUMIKIZ03WiqIxMZKQxuN0KyGSp7JfWTFgCAxDnM0fISkSpsMbIplY1jKBHNxhhM3sO/fJkdoijHVUaZGtUdY8Q4jtjkyDgFw+g1FJwjG8yadkmrzLh7U7gWzd3+Vtvg+IaZYCFB8sIEAmbMmTjqZlD8nHMjVpvWAGZep3LePe5jbRO8dAYt0xm0586+SwkJ1cnVAjsqqrw2S72OwApacEjrTDwQygp6A1Jpow2W9zQvrx7bstAcAwsVxSorELVcmlVI73N+X/Nx0gKUWtBRPT5TXjbt3gJ51OlWGTz0fE2noferAKQ5oE1GN0PSRVgQ5edSFbPyP+WcR5lphlU/rvWUXLSpaVNAWV/KPSM/rGJtmf1WlSLktGQ63Wjbo4yjpdlnBvRSZ3pmsUjMsKB8j5rejJBEY5b5JQjIw08jLAGWLJIFagxoIwwEn9kBIsNYoOudsH8AgCWcfwB8/394jmEgcNiBk8flsw1+9jdfk/OkZ9H0wOIJf3/l8dci/uCfT/DeIKYOKUnKPHUyBx8xjVPOMR5mz+zBo8vLD+tAMf2OeDkH8LyYdt5tftU1ifNkk5iFacg0NMdUi6ggwPpzCAHjOMLZHs51sI4QOSCkALIdrAU4yvhlCHCnGPgGQu862MEigdENjO//i2vc7PegDaMbzsD9Bh1ZfH59BYeIi42DOxvwtY+ewo0TfvFnX+D5X18hLe7ZX/a4+sFH4P1j2A+fwWzGfB9yRMpgD7CkbuL6cFbjNzUNsOyiY3PuUbnrWCrztRzN835jXsykso6gAXvM19t8RW7mmXsYceSc9roo5xpoaiudo6Q/LVXgi4JoYspzEyjntZ/Xc/la89rLuHSdOTimBZmVOi0Y0mbzarOHaoG6LdsKg5EWBjil7TZmDkLSMp0zCCG7LDgV0KmAEgVsCpMEXcgKgKwRhokzyDEBgQlECTEmGHLFuKlzuzEEyyYDRVCAj7pOSRqvhPpscgb2LNfhurbWKM+6P2lfl/ud9rtlBJ4uerTYI7SAmzUpoJSmn5Z7xGXftsdqX9fX+qHu/fT7u5/TNuJT9r1AirHsaawWjxylnNd6yhttkw35XdehKwxKAlKkxHBGoGM//1mHH/1we6RGb99R2uyYgDK3vN9r6Vct9xsx+Ugm1BH35cvbHi/vQpajerlLuXX78xXKNDGmSVjx/tP/9yHIdnj6LcaTbwOJMgsYgH5L6AyhY8L5H3+Oj54+xk9/NOCHf/nmd9Lu3Oq4pOb/Vyvtq2zb3c0N6AXDOsKjR48RfEDkCEKCNYChBLDobp/82OOT/yosC36UWscgf/XOxXnVOcYu7DGOXtZhzsxnLuJ3/5lEJlkr66w4NYHOGjBHcEriVDYAOCGlAEvA+cUZnj59gu9//3vw04SXL1/iwYNHuLre4ZNffIIXL14gJcZm2MJZh3GcsN/vEUIo62vf9Ygs6Vd3+wnO9Rg2Z5LSBMK4k8IIA49f/HiDn/94+6X2x3wdkE+H42OhS9xbjo3Oep11vY4OjpVvl7tffcdNMo41kM1ddZm3Q10vl0fdVkJb1hpbjtb0eImVY2ZZk7Vr1iPvA5q5T98xUByvbRustce7k+M7k6W1735nHR639t3q93eAZZa/ztp7cW7XR/zef/8Jzh4MAHqxEQSLzTnghgzYYCCOET//s4A0GlDagtIGxARrLPBHHvFsB+/3gLJ2MsGQywF4BsaazLhC8C86vPzbcxARnv6ThOGpgXOdsJbf3EhK6HEPRI/BWfgQJV3S/gZXV5e4urqC95L6uOu36PszWONgXIeYDDin/VEdcOgcXCcsLmpvCmFCymw1AMNHsTNXdg9h2k0cs65l0PddAStUezoV5pOY5BzvfQk2ED0ulWPJ5D1ZtklqumdRohI0xU7RtVNCBDL7qSv7eg0gcM4CKWAcJZ2UXsd7j6vLS/Tew9oOUYNm9aksg6LaPAkE62zRkWraojQL7NDvW924BhPo9wqQseV+D20SEtBnG0YVBaEoeEnrllJqnnkNyKOZHnXM5CHXXjwjjS2i1c9ndsncRku2GwUNtWl5W1vAbfb4Vg9t62eMsPEcs0Os2Z2rnazunuY+jcN2uEvW6jb3D63Lmr2pBInonDNjTZsdqZM8bgfYnORV5QSYOclJTnKSk5zkLmk2fSI15Yz8r04HQDecZbOeje2t9qWbfwIXJaF1DDALQlwdVoA4VRRdLcqA/OD9VBydcxpGZJYaYTswxmK/FyXKWgtjLZyz6PsOfS/R1a3jrFUA5g7cutlvN7XtsUvgRU1JNBcpU93nupGdR79D2xDLujAk8oBn19djWnac+nq72t2mMVBpy20VnFJDmoNSZlHpGRhTHXLVCMh5Y0uLjS2V3LRzR9YSmFTBRqQ3XZDvyzZe9pGOK+aa3mKWFmHWZovNPkl/KRK+KhTclK9R27UMwYHU6C5tCwWDpaw0Io8JMgYw1XHaRqVrX1Qml1oWkECmyXVLrWIN6JjiBMQo0ePMOVUNACaD4jnjOjYZJs8D8pk4IcUo9KmsDFM2162mnEBzx2U6MKquJhRkghoFOJb2MbayDWlfogU06HflVgkF+MaZ7YbccvoRwAyJUW5KCeQ9ummCcRaUCDYyeB/A3OGYWEcYNgYuMw5NlLCPCc5EbB4TNoOBpQTieeQNUOuixsDi/Gz+3id1T+vSbxhPvxHgfY8EC+8tpgnwU0IICSFIVFcIvjj+63O7UPDLDaqRQue0lmq2tkJLQaytlLhGVM2NgnVOlEit5tlPCTCAgYVQPutiVef3so7l6+73O4yjRwxS7sZ2iBwAYviwhx9HUI5EEwphD2MCiKR3Q3KILOMEJmF4sgNxREg92PZI5EBdj0DXABmg7+HOz/Dg6ROMn32O6dpieuHmzQYgTQbTFxsAGzgzwjp5JhnKvlXn89TMoTQDThx3hL4uYOa4QaWOAwCFSarMr/k0AwOYZl4uQIe6trXXWBqF7jQty+ak1Kk0RfMEKmuM1IcRM1NVXce4WbsaI35Tr+V6uny/XKMBzEAec9BGXiuSztnze273JEuJIUAfnWI8LOuB7KemaUJKYba/MSUyLq/ThTWtrvWJg6wfCQACGP6gHMrPdNe5zEpTQZ6svhBDMKxsJg3zkI5fXSfzmhJjKkZfnTNaMJIaYZdt3+4HluCXti21X2RNnh+/7L9jgBlpKcrr3voYacvTpm3Z6eqxzZ5ksU9tjb2rdWjqrnXV9IOUX42RPTHyXgBEpS5qlLfWoes7bIYOnSVhSIBQs2tqx8QJV5eEF89bExuvvFv79c1kubu9fbd73+veXvdfZ1kbMbR4T3x7G/62iWps9f/DNuTZ+xW9753V7vUlJcIXn0qq4/NHCQ4RCQyXAffWWVgQHDMefLzDxx8Dzz5/u3cyX02re71+9/5LSpnZ0DB8HCFsuhG7/Q1CHGXG5ISzTY+rl4zPfhHvLHPYOGzPAq6ejwgpIgQCmQ6WBkyBsHlMMCbvR0iuR0TorAGSOHythexHOWbADKPb7kHDJa79P4gu1u+xi9e4CTfg/iXc2Y2AhQdJIUImYhgYPYvOZ2yCswkUAzo3AltJse06D9dJWpHO9pKShQkvns1TDX4ZLDPL9eCup69dM9aOpOb/u6533zHLzVXX3YmVQ6AFqyzruZyLtMT7tPKx3UO7+s1XwkO9gQ+OWy+P7t0TWrN6JpRBhW/rpfXSmHi1re4/tzQ6xy3nNRaJe9dv7fz19r2t1NvblZu/+9bhru+KWMbZ165gupcI3sIMW2y6J3BmIwyX5LKe4XH5i4S4I1gYOBYbigUwfu8KZjPCWcr9a2CNvGoaerIEa8RuPKHD9LnoS9Nujz4msRH7hN3+Gn7yQPSgGBCjx/Xlc1zdvMR+vME47cGJsRnO0HUb9MM5YAawcYARHYVVN+AEJMDHABjAGgNjlcHFouudBAjEOPPTqw43DD18EHu2stoeAhdSTkMVi92i77uGURdQZlhjjACMmhESk+jTTEl0u6wvhRiBnKZn02WgjjWwkDS8MdcxhgAkBa0ou09ECgERET5mwMwsqC/rCYuBwZC6JK4phpF191a30gDVltWTec74WfW/Q11ZQUbILVHSDTeigSN6Xg1GSdkmgmxjrOAltVe116l9Ciz1wKUOt9Qtiz2ca2Cm1o25plZuy2mDZtrxtPw8B7ZwY6Odn6O6nx7X2usltfI8SGfp01hr+7vk2DFVX63H3Fae3FZNez2bGRkAEgREU21IyPPHSd6OnAAzJznJSU5ykpPcIWsKvDpaiNCkZKmI7fnero2J4fJSnUIo9JW6kdaUBkK3mSkBpfAMwBAQgc90loBsqiT6qUYJp8QYxwmbzRYpMXa7HVKKePrhk0wFOWAce9zc3AAArMtI9vxvzQnXOqd0c7t0qKiII0YiwAwZKIioOGWL04iKc2XWzo0zUeqSyquCB5bsKNIWa5vbuxX41lHXKiSzWi2us7wWN45sY9ZTOLUAnhbMURhQmjY6lpaJSHPJZjNNvjVD2m6H99f4iStQhMUJlzjBoEbpL5W0oqCQKiDz72sfSKXkta0H5+vVbmhZjbTvVYEWp74yH1VnHpGkCFuCpIzkUMif537h4ujNddLfFTAj4AO9B5MPM1DQDOW+Kf3FBpyAxAFIqaF9bRVFvec8tpkBw1mZ0XZn7cBcb23zbDw0qpTqiJrnvq19yuAkOZVjBg0YsoiUDQtqYGvegrIi7gP64GFjD8sdRp8wXV/j4QceH37Y4+qyw/Pnc5Vh2lncPOsBa7B94mGSwfV+RAwR56kHw2Hbn8MZRr+1ePqNAHDE5bMO02ga01aJ1clVao2j75ckBkIAmC1ADpwMgo/w+S+EiBgTUkwHzxBQn735jdV75zIGGt1YjyrjaV4OL/7p98o05pwruZh1beHEsGzgvTCYKdMJEee1pl5LDUgxjEghgwC6czAluMFid53TcrktXNfBWUlTYm2EMQlMUVLHbAPOv7GHcxG7EGC7AWQ2SOTA5MDWwfQbuO0Z3PYM3dkWm0cPsH/2XIxad/XNuIWMpRE0XJdIKqNzl+YdyqmOSBuSbzf+3l/uqGF5xDkDX+VZZ6Cs55zq/qDdC6ABBihgoqSd4rmxal6X+xp1dOLVV5Q6gAicqJmDFGxAkDVYXQc0u0dmFMCSOND0HvK9ZkBHyxAmoJKaEqyuk0o/nQR4ubhnXaeX61QxirHu1Zo1nVrmmFgMZ0tjm+7njJFzpA/0/jQVVE6hhgBAc943LC8sABdrbTbMzfOvL035Lduf1lccfXPwXdvHS1DtmnFR++64Ia8aE2cG7XqZo+Wvy3I/dyjL/Vp7+CpYZlF+NT6u12dtT6pMczAGZBTApKmqssEdyMBlU9iTrHXoXIfeWRjLMCSDgDjBgGGYgTgBqQX38sq7ty86h7UA1Pb7tePvV+rx49+39fk+ct95/nA0vnoZryd3tepX3+q6a6v/Hxsfh99+9bW/j4jjz1CCJXU6CZsYswPRVoDS/u3sHFqZr9xrIQZvVu67lt3LXmwI1uASVwKgRsI07hD4CsMjhnMWQ38Gvqcb4uqlwS9/bvHsEtg+yE+m7UDsMO0DmDJLbkndIfO5pR6yL0mgHKCUMhscIeJ6x3j24hJ/96MvMusuYdzv4aOHMa4sycZGTGOAMRZd18MYi5girDFg9ojBIyYGGycBFxThXMTZ2YAHD87QmQSkPc4eTvj6tyeAgU8/6Q7SIb9tedXxws3r64w1Wnu3miapXa3Wvs+abk6hxEAGcDc67+z/dSBIPXbtWsua3zZXrTFkcSm5Hns/ANR9n8VWR0bzXnQ5xrEUVKtCa3W72x52V/2WNbi7tPkZy7sDlnd77LrLX99ey9921LHfIjOubzx83MFPFkPfYfNkQN9t4eyQdRCP5D0SanpvJgZTBB69QLKXcGTQdQNioMwuagVk72wJojCW0Pc97AOHi28FxBARMWIcZT8ajME47kAArAHYR1y/fIHPP/sVrm8uEZIHrIBAh2GLfjiDMRswLBIcCF1mSBF7krJbTtMERkLfdTDOgQzgOouBexAx/DiBYgV8ADJO+74HRtFrxG7csomoLTsiJY8YAzabAZvNACJgv98jpQAQwZLJLMrCtEOYA0rE7pqKvgXUVOXOWtizraR8sjWwjSiBQMKQk+2g1ASnBu/ho0dIXth7yBZ7iuiDDtU2nccHAyHb4AjzFENtkJ8ywShghshIOqys82mKIk3P1drYl8EKzHGm/+lvrf5TdT/ORDyVwVptoqq7VztxG+ypjDlznWpp51oGlraAmfYYa21hEiLIPSvIqGXJL8/eEhzTPpdZb63s7XNG5qV9YPY7A2zmuv9Sb2yvdx+wzLF61iCPwzJuL7ex0yyFlz6KhT3nJG8sJ8DMSU5ykpOc5CR3SlaMi+WKZiwvQluZUxnpjhlZfdb0nmgcnep8Z4NxP2YlyKDveljbAZDofHHCu5zepyq8y01gBeqYeu2yWY2YphHb7RbD0GMzDLjZ7cpG2VmHvh+w3+8Bls9kCCxkHeI8MKbZqpmDjSWAolStN18ToWwATgaVpcdUxxEB4AZgQQRkJQlFITHFsWVytNoMrJP9eBVxPu/HuawZSXRzr46yZdR647henslVOSDKkRiGikLFLKwzmjqHVDkrN5zpT5MoxfJ9znuc8zXUYzk76RpegOzHVABFy2yTEmfaVCqR85oKTBQIcQxZl1NhNc48HespJTDNy9XrVSVLj50rY+24LMptbg9AlNcuU6WmPN6lrNZx6AoQQPu3dawK6MzUOrA8uURZWWICsyqRKd9zfW5Ze/VAccopmWYKDcE6A0q2DAZ99mOM+Zlplc12vDBAjBlySEdA41iWQim3UU6FlYc4ERXlEizjlksKt/xMGAfOKVaKDpXP1eszJKe1D5K3ue96cEq4ubnG7//BZ/idb2zxN3/1FP/+3z+Y1fPZP/R49g89ug3jn/zPEb0l7AiYQsR+nLDdbMHoQMbi8YfA46d7cLzBX/7ZI3zxy6HUBRCuLTNz9L2ZIW9NXt2wd1gLeTaFbSglIEQxKPkQEKIvBhDtPxk3reMf1QE9q8ByHGQDb0nrpfOZjlWGECMIzXM7P7VGBeec5Oy2HRSIx5zzYMcI5gBGmy9ax/vS6MIAEnwYcX31EputgeksXGex3+3w7PPPJAf7MGAYBnSdgXOQ3N+GMfmIs697PPzWDhwCqO+R2IKMg3M9UtchMcN1HfphA+s6JCK4zYCHTz7A9vwSwM2tfXXziwsAF3AX19h+W441qKC+xAymJtt2ngObae5gjCwNHkuD7u2yYszNcwzlx39u9CepG9fvCtMFKhCRS9SariFzaY2Qd9aQ2nlcQSDSTkbn8nxsBQPq/VSwK2VgoZCj1Mg1lHshEMs8rGshgcXpZAWgm5p5fmbY0tWNIQ4CAqzJxrQUy/rRAmZbsIo4FRIiLVJWQlIktcAUXde0nBgrjTiRgTUuPyOMFBmJ5DlUm54sdZSf2/y8ZaBPCBFEIacZ1DY3dR9AarCsdWjXgpSSGIOhACSX6yPH6Fp4AG5F3aMtDXKSQqo1fFaGG13Py/6Ha5m6rt/GLLMYabMxJ/uW5Qw8XysPSlj5uu4t7rh68xy3+ycAZc/WGoiljU3pdwGIWzjrpI0QxXgPYRYiMAYLWBNBaQ8xp7t6jTtr+HZEXUhroBmgttSruo3Wjv+y7unLFFp5bf/a396WvFo7vj+tXp2Wh7uX5XG/bkKswFoP68Q5lzghMgBYxBhws/OYPAE4zsL4ujJ/XuegmTcp78uQT/7mIr9LAHbNLxYPPz7H975+A2sNBsew1BhHbpG//UHC3/6AMGy3+Bf/S4BxAdMke29AnK2yQ9W9hzyxzgDI66I1DGsk+CFGk/eAHRgG3gOjTwAiQmBY1wt4mfM675N8jgwfPEDiRHaWYSjrAoHhk4dxgOvE4QzqQGZASB6ULD76HY/vfPca7IH/83//APHm9WeTtTOXGsSa3HcsHK7Ot9ehWeHrnHnEYadzx8Kqgqpx6WLMM9AMza6yrMk6WGVtzVtvg2NP2BpYZn4ny3X+tnq8qsxLzqlStcQ3SLtRz7zvzHK8L+8v922FOgaO6Vzt+nOf+nDzB+BoOqb7rWOHYyKlhJeXe7jeoOvOsdk8RN+dw9pexm0KSHGHGPdIOEeCBWXbR3Ij4vf/M+LZQwBPBTgQUwFYuLwGRc42vAQkZ7B9YvHt/5FxfbXDbj8iRoMQCSYROEVYSzAE7MMez59/jpeXzxHCJAwrrhMWGQUlUGp0Hb3HbCPI+lxKUViZXXXQS+BaDvpgIOwnaEpcZob3NfU3g/M1bAlSaNtPATXKrlKCjljn67onJ1SmlhoskAtrBgsn1eOyPqZ2sGyEUaCGIUKKHomB3jm4sy1i9Jhe7LDf3SCmHpuzLTb9NutJ2S6qdhhwMSKqDZNYwPdtqqU2rW0bdApI0Ky2mzGmBAUK++mcAXwOjuGixy5BM+21ZmCbzECiNh85RYI/it6e7c9V789zMesTwJlJR22Zazqm1ueQ2VTrovUz1oDjPOjjkPm8tSkj2y1am8eR2X2hF7ftuKx3e/21gIvSvjRfk9YvDDW6lg9LHXRez3pvq9csha7Yl1Z/O8nbkBNg5iQnOclJTnKSLAwgHew1qP6om5ayYZIN5TxaWOTQmZDVtTaKm4FCdw+DFBl+9GBOsGRhYDLVO2BJIgwS5gZ+0yCjU3aYA1QYL4wxMMS4ub6ENYSz7YChdyAGxt0Eawx616O3vaDHYWBhkCzDZ0AFZeAKwEh5w5caJcTHINTFRDANnb5shjVNR40s5xQbxhDKCkdVgJYOHgVWyL7TIAcHgygW3A2jAXUwFzZCys4kzoqBJJuQX8RhpCwf8rtZABwSJ8kNy6IYsCL7M1JEnZhtNL2ezCboAAAgAElEQVQpjDuL6AKl/p9dQ2pElGPgktL7c1MfC846mSjSqamvgTGc/7TYGn1Q0htQREw5fVd2tlZwkKTbkAgNEiNhUWapKO+iISSAQm7vCsYwJnNcsI4SeUxIVYrowSWthLYlhMLaOhCstAQJQCghIXAoCrYAh7LzM3K5L3HsSZtyAsiaHAEiSpw6u/R5HEdf7q3vxdgdQmZpyvohpXYM5secM7tBbmKmChZKqrCZai7USJgKmsnTRr5/VTyLsS/PH9Z2OfJFlTsBxvmQkHRYE0MhdJwjabpOUuL03ZDHqtRXMBWixUu9ZbwSAGMtbL7WNI5w1qKjDr3rsT3/Ovz0K/z80yt88XILYA6YUeEUMb74At1Zh44YIxgpAvu9x+DOQE4oyY3pBESFeTSEGgQlzqdNzvZ2Df2NGfaVzpmLAWiAdWeYdglT8PBpQoRHZPkD5DnXaDABa+Xy2kViZZ3RGUGGpynnAc18YDSnt8zNrrMlz7W1JhvAEva7EWBC322w2WxhbZdBcxHJBJCbkJIBsxp/YgFhKG2yjB/Ojn1ko9cEQwxLDL/fwRHh0cWFPBsxIk4jOreBs73UxXtY6mEswTgDOCAQoTMDmDuZ84hgjck5woH9FOAmws044Wsffw0Pn7wE8On9jf0J4MAwzsEJ2hCRYgWb5TVHaKATGFTZzwAQcwHakKEyl+lztNp9zchVY1zb3Vz+y+s3o6xESJyBiBLVp3ACndtmoDtdH7Nhi7Fkm2oN4EeMwrr3yMUKY4yCiiQaO+YUMzpX2Bztxolr+pkk4ySwzpOyHrRru+ZVL9udbGhMMWHYDHDWZcM/I8WA4CV9pNofEwO8D2IgpQy4NUI9bohkXQQhJEnnF6PESNqOhLY7AV3v4Hj+DDEDgdGsBX15plJmDGuZ86Q/ZbXmFAozmRjAZD4nEuOu9xFdJ3saMZ4yNA1TTKHs+bQDul76PWYHoETsxWLMlNRmCRpFaMiASI43xgk1+iJqsQXPzGm6GTH62Rit13GoANW8vzDKiANUdr/WiKiva+AZahfM5viENvpNQUP18VqO5/pMaRkEnU/bsV4jB++SApQxnMefgIeU6VHvSYz/XQFaGUdgI8fGwEACDEeArhDjSzw5Z5wPWyCvc29zDbuP1HXucMW7R6vcetyXfS9fhhR79uLbL9vkzIu/d3WNL7O8X9fx0nUWnfV4cfMC3dljBGaEBCSyABmMycNf3uDmhvEuADNAO9PJJz4yJnnx6X1u844SHg0jNl0HTntQ2AI4u38BDNgQYAzgQwCxw/nmDL96/hwMEuB6SCDTIaUJ1o4gCHOccwYGABPDkqT0CGIqAdEgurUopACy/pRT7PkQRadklDU4MXDtR/Suy3tJ2au43mIYegzbAbbv4BOARDDUgzGA04TJ6/r7enJsbmp3fkea7y1ItY3Qke9aoMyxuq7VRfe9pj0zAxuWu41j5XDzjpunZ3kH8x3yYW3W67f2uf7f1m3ZF/Pn+dUlW2qylgy0YJFjrtPD3+fvePXT69Tw3prZ0fI5g6Pa/qujar12r3LVo7rQK5631qf6nrHFZnOOzfAI2+EDWHsOP3lJ20YRnRmx4y+QsEUiI2TDEFvb1bNncAOhMw8x9Aa9syC2iCkh8pjZYBN8CHCdQw+DmIDgA8bxGoQktpjdmO3HBI5io7i6fo4vXnyKmAJc72Cdg+s7uK4HYEQ/SRFkg8yDUexwwsoaRB8m0avBEtrB0SMhCoOtdUgmwluDfujz3rwCYortkBkxig3VhynbLxOUuZMZRTfzXm3EousygBgYEUGYXhyKvVeD5FKKMNbNGL012E8CLHJq4STpFkEC8kFkSV2dgARNm5RgNSU6R0Q/wu8Jm64Xu3zW+xJHsQMb0QfVnqIj3WQFyzRM5YkZ1hjElBlmM0DIWFvs19ZaDMMAYwy893DOzfQ45xxCCDMGFkD0JdVVFHikf4Dogt57iH0pM7HlNucUgcz+Y4yAtpwyvsYIY7OOpzGVDEQIc6/eX3lmUkLMqahM1u+kPmIPUwadcRoxDH0BCoEIhk0J3mh1MtXZAIJzNe19XUsZoDTzAyj4aBlcWcBYKQfOcAUcLdtr6Y9Q23nWyg/mDTlGj5/PWDEyrCmKLqyRTAEgZQ6r7RRTrNfjlH1Th9bRur5lm/SXrr385ssJMHOSk5zkJCc5SZZjytOhc6D9VCODZ2XxnOKvnpSdwsaAbZ8jrOWzAEtEUZG9lkFiZJr4CGJNabSsRY1IVlYCBRTEyLjaXQJATu9EZWPonCsUldvtWXlPlNVVIkzTiHGaMmUkYbPdIsYo9Jx5g0vGgNKC6QU4eJUNfzaAlPQ2JqvGrTLNpQ1r+zbOEEbT5jTbMGu90ZZEeYPdIOHbtlv2WQvUSSlkFNUS1Y9yb0T1mhr1T/nihOy4a47XyA5le4h5k64AHO3PCppI5fvDOqhiWSP7FVAlfamOLFEoOStpVWlAUVaZhYK0jGxlnTG21J1JYA3MXCL8aoQHH4yBVmnVdjJG8jcjKwCU2VNAVjUNGDAcobSBlNX0M6vSoYY1KuAkdfJrqgXmHIXIPEt9xoyicCrApb0fLddwBQ2Q1iMzKUi0BoOsMhSYbEC920BTnXuVEYKzUaG6Tigr9zU1BBFgUq6njIqiVEH7nqzgO1TR1PGhDu+s1MLmqB4AfhxxFRKGYYtHDzbYXHwNxFt89N2Ixx9/iodnG1ycX8B1Dn/9A8YP/0tCDBY/+8FH+PB3f4HuPGLb9wgxYdztEYYLpM6AM/OPcVt8/596/M73rvH8c4Mf/fBB0yaHJrG7DMCvKm9alrINhMCYfMAUJoTokSBMLWQAYwmAzQYVmj0XpR4HY0N/L4i3xTFUwDCVElcM+2X8lmsBQ7/BMGyx3Z5hu91gGAZx5itgJhox4htCP2wwTRPGcYT3Ht5ngGSeKsXZLwAS2w9wrsd+79FFYYTZuDPYiy4r/JyBZATych8mdQhsJTItGpCE/eLyZo/9/gUSE4bzhzj7xtfBux32lzeIDrBmwN/9/U/hnzzF1//5E/zR/vfwH/63HwEAht+/xPAho3O9pEMMCS9/2GF6bhB3G+x+/i1JT9aAHXTud49+DjNcSSQTAGMcUk7Jps8RESHqOlPmF9RXvtusfNjFAnyYbwmkD3U+a4GQBcSQ17fEzXUz8kd/W9tm3CaH63I2/1CeFwggS6CU1+Y8DvQ+AGVwMRmkoSBdykZPuQ/nHGw2/FRjFKHrMiiB1dhHsMYBjrORiPO6I0Y9Qw5gMVImikhJKb0X90SErhcD3831DqAdnHUlUk+fH+89jKUmyrExPpW1TNfqCsyUcELKoEZNVyZsgDCyzlt04JSE2cm5DGZrctmrq4ObdcZXprfa/8paKCAgBS9p3bQtAckBfxtIpM4NqYwXXfOrYQ85l7wMtLp/zF5FKPT1NYxxB34SuveYbcHhpZA7Bn0717bRlWXPlZKAi5lKuzOJAZzZNudIm2rUq3MOXd+h6zskHzBYh75z2BhGnxz+9N9cIAXG1eVhGs/b5G2vc4A2+XEH1fzI5btjR/z6y31aRIQyC1g75t+eIfqY4+1tHX/b+bcd8yYO3d8U+cWPCc8+68DG4Tt/FJFMQoKFtQNM1iUpED7+nQlPP3oBZy3+4s/OMY1v11HBB59uK/9ufeOrlstnDv/p3z0SoCszbq5ebZ70E+E//nkPEPDxtwK+8R0GrAeswxgivCfsdgkvL19C0/Pm3VUG9Wanbd7Hs9oOmBCTOM1AEc4I66bJa3piW45VVjYighssrHUCqDQWxlr0mw2MFXYxsZk4xJzWFzSAycPTGjfG/eW+s/rrgAvWZDn7tRpa+50CZdZmy1e5fgI38NtFmQ0Yh6m1HFX2FV6safq3lLvn1FrSfdbG5TFr6/p92mHZt4fzwPL32g+3lV9H3bFUeq8zf729GWYOCGr3MLVua218n9rdt5Zrbb3s466P+P3/7lP4uMf1ziMkg835OT786JvYbi9gzRbEA2IUHSjFHX7144Bf/bhH8B/CT3KXOUwt22sM/Ojx7ItnAEZ03QBrOrhe2DC9nzBOEyYf4JzFNF4L0CHrS1ZT/WTy7v3+BtfXV7i5vsT15QuEOMH2HayTFKQMKnt9Y4EUIzyPMDbAWAsmC+csXNfVlEEAwBHBT4hN1lFm0UGC9zjrNyXlkfe+gA/6XgIyVbe0Vm0dDGSWZ7VlCPOn2DT7fhDwQKw6JFBt2CklWNvu0bhMft4Lo6fNIJrd7gYp9eg6SdUXM6tNCAmWDWKI8N4j+D18GDFOIxgs7DMhYOI99tbJ+caCSNjm1D43D/eaS6uTqJ1Sv6e8HkiKYiptoe1HRBiGoXyn5yq4Q9Yariw2WX9pgR96nvYVkYMhzoGYOeg3AZQDtSToqwJGrHW57pJS0dp5GqaW+VsZhbpOwMTWWGz6HgAwTRNCCPDeYxz3Wf9Se5emPK5rbBu0ovqv1mOu00qQIme7KPK6TsW+jHxfks4ssbC+cprbrFt9sR3fB4EYVP5b6+3FaxmZIADWSLukKMx4znblnqQxcr0zUOxwTmpX98bvUOxd+Xzzdvejv81yAsyc5CQnOclJTtLIMcfDGvhlTelcBcmsXYfU6aUMIJTp+iUfblETyQBmqeguNmKlAkuwgjp1fP6cGlR1jUTuug7b7RZ938/Q+WwIJtqyce37HsMwYBzHUsZso9YCI7DcxKmDaF5Pdc7WFgWWppayCaTa2nrPhUKyODKbja6ej8xik5lg0AAi5PJUCpzXN+V0WLc7Z2STrxv+Jg3ILFVWU6MGYKKKgiomsl8W4BOgqRZiUQpaMEd16qGkbNA+BURZF3aV5p7y/0XJIEBjulqwjQBETGl7vVeAClCkKrBtW9B8DOkfar/DCKUq5ZQTyGOCi3mkqgnzsd2MiqwTgdX5Vx2JMaaieNbja7RBrV92lpb7rW28PFecZ9oObVuJJrZ00s3rflyWipmck5rftZzssKT2vJzeqzEWMOt4r89XicJgie6ZR/5IkcZJ6rcxjmBKOIfk4Sa+wNmjPR48jHiwAc7PEi4uHD75BwYwgRPh+sUWH0wRm4uAzgxIISF4n1lrHFK0GDoBLz14IqNtGfU3m0OB+T3d3Yz3ltdxTmpNDAljxjRFhBiLkb2wExHyWMimvvsMgPYajT84vyvPKVDHZsrML4mVhcnkdGUGxjicbc9wdnaBYdig67pi7CDSzOnCVuGs0jJLpNrEHikJdb22VB2TgLUORBbTFATAQcI+YckWJhZADAEpRQHPwMLAgdkI4JMNQgy4uZ5wc7MDgxCSwcNvEowypO0s0pbw/GXAGRy+/fgDPP5uZTjqnibYjwPIMjo7YDAdbn5KmJ4DHC3itUQtt7waekfuYVeeiZQY4tvI8y/EuAOradCWYyA/c2pQOiJtv5foOu3LW85ZAqvK3MvqDmjmINDB3PEqsjw3cY6XIl7MZxm4OTu3GuVkTFZApayFelwGD8aYgVemnGOtgSGHEEakmNCmAdP1wphsMIOkVuI8jyWepwWsf7rWMoCcrsnqmqDsZjL/mSRpoMT4yBkAnBl1VtZwbYsyO1ELypTnUgLwHJyrqaZQnp+6t2kZ5uperEZkmrIlbPYh7X6h2ee06x5As7W+pbNu+12NrPPoPL2/dp1rc8Lj3ciibm8y1xMdrsPzvSfPjKFiJGbAZOZEMKgxjmpRuv+1zqJzDp1zmLwApQgBZwPw0YNHePHFS1xexoN63SVvc31blnusRe9zzXdVr/dNaPGeVn75KkzPx9JG3Cavs7+ZXfNImcd++02U6yvC9RWhG8TBQ50ByIHJIBlCSgbW9Dh/kGAf7RHDCDJneBejpHWNVM6M9ess++d9669pNPj8k/61z08J+OIz2Wt89HHCg3OPwCNMzxiniClEEAfcXF3D2g2IHAooRkHBWb9KpramlM1lX8EExFTX0+IMNYCBLfsDjQRXdsKUdfkYZe8hwOHMdpoM2HRI1NdUuo28al+9y/l7ObrW58fF3JgvZhazxVod2jF9TOZ73VmRzWddoPXodpdery2+09vrsy6vPpuutd277ttleqv1mhy2++E59+mZ42ff/7z7r6vrNaqjo7E+HS3hYF68Mx3T4bv2GzKMs8fXuB5fYrsxcP0DnF/0ODt/hM5tAXaInjD5CW7jkNjj+mXEF7+wIHZQPu1EjMAyL2lg1zR5hHAN5zwIkqYGlBCT2ByE8bMDp4CQ5xtnhX0cLEGXwXu8fP4FLi8vsdtdI/gRtnNwXVfAMmIbRtbDVB+QwB8QZwyL2sREB5Fgm4AYg7Q959Zl5N8ikusLyKEFUbR78aV9UPtP7Z/12Ar6kMADtQEe2tq0PLGjJhAEZANj4ZyUF0KAcw5EEgTAGoUCZGbvVGwBseisFs51CJ4RQ8S43yMloOt6uM7lAMRY+hBkoKbCdpgd09W1LQSUlLJeKUyh+/2+BHq0aegVMKMg/vlsN9fNl4ECc9tEtS22dgqtY9Fr83WYE6YA2JkNVY53zhX/QYwRV97DlrpQYcipduOagqvVWYlMDtxIpf+X0urCVT+V2b8Gjda2KOOJ6meOPEvnvOyjtWu2emP1SQDzmajaZ9ak6N+c5yHmEmBJlGZ9MrchrpW3Pqbema7+WywnwMxJTnKSk5zkJFmO+Zzu44xSB9aaw/34tVixAtW4zZJuRfaLRpwwZu5CXlUhuXW413ozM6xz2Zd7iKJWxLkyxhSnLIsTQTevGjUg6PSK/NYNfYwxR2Qurt3ko1WlZb4JnjtpFndVvm+dF7UFxCFVNroHirDuPsXpqMjtkodVo7az0lc3mlVN5qaMubLWOqoAzaXaMgW0EePaR6KYVgBMW9dUFEjKjrolo4xqYQ1LiLIjUG13VSLqWKgsPIfjQ525FcykTj35hWYnJcZhnVAVAWVZyUc3p5rijAUopwaieRn5eSigkVSdTzJ+MisR5lKVPSmltoU8R5QtenOFc86K0yqc7fhcPsv1+VbHY72e9FnKxo9XMT61Y6RRALO1Qg2xAAsKgFBSgBnCbJwIjfh8LloDNbX31zITMRJ8Sni5u0SCpEyx2AAw2E89vCf4wHCdx8ff3iGGiC8+Pcd4fQ5QBIyD7T1ABO8n3NwQus4hRgeiBGwJvesxnAEffjMgphFXzzbw42G0aWv+fBvG/3a03be8tR7UOZGzsUsea54X2nSZ/KzRc8eNdQQFyNRv5mNLnwH5rXOdgF6sRec6dF2Hruux3W7RdUMGzMkYlXFuMrOCRdJUPykgRob3ETEwNpuhjN/qwK/zR2IukTGUGS44RRSMTW4Lo3O3ERYXzkAU5PzfhgCbgStxmoAQ0BMwhoSw2yFeA6bb4no/4nI/Ig2Ms9+zAtY8A4IBIiWwCTh/cAHjKpPHUmwX0Z9LHnDbc46gAxix9BvNppD87DT3A0aZD+96qpeGl0MAzbznGYfAhmLwWZSp89WakefeoJlZ9Sposx3CMgRbw2RTqXI9iQRr67QGNmypkNvPfScOLd3/MHJUFDePDsvFW+NsC5QpexnYwrRiyMB01WgrBt8610t0uYJj5G5bI15tf1MMmG3DaXsBYrRkNgWwWvcjVCIlZ8AeprIGyvSeQ0Ixn8flszzrRBmUlllnKEfOFwdSGQ9tx1bg6nLsmJIurjmaarvqHkLb5m0b4Mo4afZydTzff25elnmsntWQTs2xVPbepQzQwTHKKmaMMO2ZbBC3BFiecPl8wu5TAj29QHx1rMxbWdfWyqSV969yzXdRr18naZ+m1x3+9zvv2H7g/emB96cmX7YwiCOcRuRHRgwJ1jF6YwHTgxPDhz2efoPx2S+AafcuarF8npdP9YpT+O1X472SmyuDTz+xCCkhguCjRQiE3Z4RrgdsHo0gAhI7pIa5MWcVQcscSLItFbAHKXteTqOYUzQJg4wpQOnE6twihOxspZxegYwBGQdOjOgjiAmGHAgOQAdjEp5+08CPEcxRHGUJ+PyXPVJ8v7xd8x1FC0m5/VhgfQxy83rsTml2rXvUjdUu0v6SbSBQ5sTb63XbNRhtia8ub3LufWS9LV/N/vDqV3wHcrSh1ue6+R2u73QOVPIWmL/47dg7fd08mDCcTyCb4NmBzANhcT17jO3ZAxjbg+Bw/SLh5RceyUdstz1SjLi55NmYZuRdPyUkRCBEOB8BBMSQWVYy+zQZLvtzZw2il+856ywS7CEsMwTCNO3x8vIlpnEUcAsZWOcyq4spOoiA/WzZC1fAiKTFSTECSdN7J0QfEAFYKylxq80563QxYZqm2V5bAzTbNLGtDig6E4QZJ9tHVDWo6aKrbmpyEEZWG4tt2ZgcaJrtWVlDkiGldrEcJFP0VZNZPPLvRMipfrqsHzI4BXCKIBBMjJBUrAmGEoyJOSW66nJiSCDg0BS9kGUQVKtTAm3qpHqsMpq2eqwGP+hxCm5RgIoGiqioPUheayBnq+vVNpLjnRO2oZjkGiYzy1ZGbzPTsZagnsRcxkVbHyJC19UAJrlea3Oo+qh+XrOTqhSbSaMLtzZ7tUtLKiu1bSkrTly1qSw/1/fZf7IyxzZaLZYTGhmpZ0rC+G302cv112AhznYPLWFhVSlXqfXSNmAQUg66/U3fBX55cgLMnOQkJznJSU5ShFc3GbeBYBgMCztjdADWN3T1HOhuH8U7lL8TH5VBigkhJUCdGwCYTLMZa8rL2kTKSpRuAlVBM26OBldHim50vfeFzrF1BCcAXdeh73vEGEvajouLCzDXlE664e+sA/JmWf+Wxygrzbzut23sllEIsvFV8ASIDwAOpe1z/8h1kxjF1E5GtZ4pR5V3ncMymptI0+4oyKipN1A22i14SNP/HEOsqzLRAomKUzGPo1jKFQS6XlsdlBFJHNfcOsJMUXCIKEdTVAXVe0XuoyhMqkhyHpRSRgXQiBO/NRtJ+9sCipk7EVMU9gv9zZBothF14y+x3G2qC43qz9cgiLExyFnVcVVBS2qsrI5T7Vd9XhNiBIha6lOTFfDUlJtTGeVbXD7DS3rOWhYgERC5vwpjE4PIzso5JktFrCqOFZCmAIX23gwwGy+Mmu4sxQrWWuY91jEiTt6GqSgr4tZakANCSvj85Utc7QZsui3ON+c4689BGICYcHl1jbPHl/jjf/USN7s9/p//4/fw6U+/CQA4e3SNr3//BkPfIaRYFGUfPGIKSNhgu+kwPGL84Z/cwPvP8Vf/70d49svzXEsZA/MR92YmurVeuK8Rc1aH/GxLirqs9JZ0KchDV8Y2cxst0tzDUY8wZ2BUrp8CWqAKdp27UxIg4uPHH2D74CIzywjLTNdJWj1J48Kl3imvCxLd4mCcQQwBwSf4MWK/D2AGHj9+AmbGOE6I0Zf6xBiykyDAEMHHAJ48DGXjlEF+joEuMzEQiWEvGUIyRiioE8MZxoPzHpYD9vtR8pjvR2zIYp8Y+8trTGmEO+uwNx4vbm7QPWB87X/t8fnnL7DbjTBk4DpCQMA0AOkI4QsB6M89PvhHn2F/c4PoJ4AFgAAAxGI4K4aaYg9ZrM25I4qJ6ZY1aw2UtvZe+72cZ9rRrs9nnWfXDDpr4JzC53Vk+lHwSQUK5lmZkJ09YnitLDsL0zK36RWljmtzXbsutoBbGYsGwXu4TiL4AEaMAQwZ35SdXIkBQspATcprIWXDm4BHrDXoXCdGMAaMNbC2K/cn62Zdj621CDHk+VQMydZapBQRgof3HtM0wph+BiwG6p5J34uBlXP9JQJT1g19ZiuwEpA9muJGlaEmcWXfkXm5Ii/0HvtMaZ1SzEAcQDIlVuNgjcyTiD+lxG7HiRhd65pomn1rS3M+B6BoO749B8zaGC4gljd0yCyN0TG27dkYzBeG1fZ+Z0CZHCmr6VPTNKGnhM5M+PSnHn/9HxOA/UG977qLL8uJdt917iSH8roj/m09Kad++eqECNh0BOsMEltMgbAfPRwMmAwiWXTdBsPFBn/4Lwn/4f9mfPbzd+OkPnyef7tHxk/+3uInf7+e0sl1D/Fw+C9wG0bCFokJTNJnREDKOilyCkoCA6TOZ0m7SCanL7Gyvg/9gK7vQZD0FlfX15imzKCZIqwhPHr4QAKErKTrADOm/YTebWD7Lu9DErrB4B//SQCnCZR2sDQiToR/+6+fYL97N+PndWTN1nTsWxCyveBQ7hqptPLufnWr79MCNJN5NKEA9xraML/asm5tuW9D53zbT+kaLOS272+TeR3fj3HHxLO0W8tarYNc6jdr7V60mKNgmeP7Nm6O+OBbV/j4Hz3DNBnY7jEef/gUBltwchj6LWLet3/202v86C/2uisvALDWYqb1TJA5YbrZI1IGz3EnQSacdULOFjMCGAY3VztM44iQWV12+2tYopzCVnQjaxpbD6mNSFlyHchYGOtAMGJTzBCelFAD8LjqOy3jKrP0kdqNWsbicRwxjmOxP6nteGmHqjqVzMVEBkxAigEJEZSotE9MXFIkk80gRo5FtxTbrQFiBcQU210G7HiJ4YKmxe26DoYMwjRhnPYAA9YQetuj6y1c53Ia7ICUApx1uSzRJ4IPiCEK4MgYSKAcQRlmKKex5+aetY1a38CcqXs9HRAzY7fbleNafVr0uQnX19fYbrcYhgFnZ2clhdPl5eVMr9OgRjlf7ifEkIE2FikCIQcUJmYMfQdjxR4dgocysIotTFIrdV2HaZrgvS/3o3Z+ay04MXbTrvym9y7MM3Z2/DB0xXYNNjk9fRW1Xaos2YoUFLNqf8nfxWw3L/YwzG29hzriob7KhSfqlnmzOHqqGEOISdMoA0Pfw0+T9CULOMwSw1iGsp4nzrbBssDOV67WLyGSFq8neVM5AWZOcpKTnOQkJ7mH3OYsWKZvuI8wRFFa+OOa3zNoRTduRiIDmFloPmaV0xdBPNfoWEntYxr2k3bDuvwrYBkWkMbQd8VRAFSAx99ZEvEAACAASURBVPPnzwEA2+0W5+fnZYN7cXYuzlTvS65SPV8pJpdo8Wr8U5V/RQ1mjXiuoJXW2aHltcfrxrcFjKQczUWoG3djRJWV08UJWDfkakow2alqDjbo+qfIf0X4rylI7X3rb0CTOsHkv2xYU9VagSKxSRxMNGdCaTf/WrbWSftV2YGWSpl8Vod7J0pnYampAKC2km16jeWzoc5UBfMAEKWdKtikdSK2baPgL61XOx5qW7YsNuXsps/4oI0V/LSmDLVjUh1srVO0pUNtzy0K/6Ie9wHLrMmqD36mYNerLce7ODnzrNH0XXXCzp9/ZX5SJVaiWRjGOiQ2CIFyxFEA0YQUCfs4YjN0iN4jIAAWcHaLNhZQ26/r1EyZEGIAB4lUSkwYfQDvA7qe0HcXMDmn7y0QBBznZjkuS6PqmnH0VZyJda5qWYwYiRWIR1ACGObl1dvy1ue4+ipMMFVZr2NDlOgE5zo8ePgA3TBko369VvvctWWT1pGU+liV/prSabPZ5ggciX6tDGIBiT04MjIBPShaGGfheoveGWhaur4z6DsGUoJPERNL7vWdHzEFDzIGZ8M5Hj0c8PjhObp+g+3FFi5ETGHCPowIk8cXn3yCm6HH7sUZNs4hRWGT8TFg8iPG6wlTmDBFjzQ+AtA3rTBv75gSJu9hOKddyvO8YSPODeQ84iwMb6zAJlqMviNOgVZuA9genxdatqvFsW/dN9bOiVQeBEbey2SjGJpIM0s1HaSCbXQuT2m+rulrm3feGDMDywzDkMdWQkoBIfpMmS39UUCxVNMTFsayvM5KQGTKNOZJjNKmpkkCZF3UcdyuVxLpVSPsBDwbGjCrRd93ZZ1ZGvtUdK1QI5wCO7uuyznnQ1k/rbWZNE3X4Lw/SUKDrnVUUGedq10pXz532Gx6TD4gqWG53bs165ru62ok5iEd+tKIq2uD3t+XIW8TjLNWXhtxmVJCl+nDU37uZfwv9n0LQBFB6MiHzoD8CEp7gBMAi+VD+j64s+9yor0PdXzfRIMM1trt3bsUb+uRU299FcJxhGHKe7wOm80G4/4ScIDpDCIbhEQIUypz8Tury+Lz8Z3Eb7cYAh4/2MCnhDH4PK93umsFgOwkBmhBBSBrctanNWghMSbv4TM7rqzrHiHEwjhjrcUwDAghYBxHEFlYY8DWw8BVBydLkAOcAccOm75D5xIux+vG3f/VyxIWc2w+bC03ytx7v7KX79eAOIdzMZW/RudE3r3z4juS7wux7ewcKv/fVk8ud3k/eR3gyqtKccK/wbWPaaf3mWPWW+3wzDXwytpZx+p8n3tZNZm0729llDn87ba67vcRNzeMrj/HZvMY4AGgAc5uAFggMYyt0Jj5NVpesMM7m6YI2xtYGxETIUYBH9hOAAV+moAU0DmDcXeDFCOMsXCdpGEyuudPKesfToJ5kLL90gJMsFbAOMZKunZkYJnWLkHYs2JKJfAtxlgYyIHGdps/O1fnN2KpQwlGzOzkoq+JPtN1HZxzCCFgP+7hg4d1EmyZGhuqSgu2qd9xE/wo9kALsY2o/cPkCEn5nOBcn9NKZ0YUFmCIBvUZI2WmVPVIazt03UbahwDvlZ0kzwwKZGDOKaiFddWqIRe1jks7cBu4umRpWQZTtkGn+rsGo2nQZgvwV9te13Vg5sJWo7q46LwezITNZoNhGABAgDk+lnZPyWEchYHeBw8QcEZnB76Dvu/BLEwyMcaSnqm1m6oOXANp5PkQwFOHrpN+V98BQUA9Wu81G//hd3O7cL02ii5nbW1LtVm1wT3zoJE5w0155XaueIUZnww4VYYbBXShuY7WtwZQIRsA1Sa17itpg30BzALwTvJmcgLMnOQkJznJSU6Spd2ArW3SjwrXDVy7OTzmOOPGAbrcay03abNyE2tGnvk5qBs53ZDquXovS+BGe62WdaREJQsqBSkljONYylPnEGVgzH6/LwrRr66uQRCFSOsxjmPDvpFmG9NcKDgDOSoQBqvtVzfHc8Vheb96z6W9FTSSKmCm3KKhksNX0zFo+aUfrbZwkvzjulnmHLNkCL2rihinmA2s0oatc52RYK3JbECZVhVC/4xyH0kU7+wpjylHqWSnJbMob9bmm2BxKkrkeSoKnTgOkZUFA+d6VBMF5d9bAJLkCuZUgSkKTjGZMjU32kxZWrb9GkioIuP1+HyfC2WxBSvN65aVFNZnR+tfnzlT8sJU5WrpgG4BJGVMAjBN6jAdp1qflhWpBWDpq5ap5atCBka5Xx2TGqGh9zVvv8PnE0ApU8aIjEPO41VTZ8mhXBSqVnFWp+7anDZnNmAEn5CMA7ABAMSQsEs3mLCDg8FudLCG0bMHGcCSAwP4x3/kkeg5nr98LmMwRMQkrCJkBIBnXQcmKxFDEUhTQtcN+N1/OuIb37vGy88MfvJXj8oY1ZYj1FH7Jirg2vm3GQuXImMhIYYAH2rfS5cIQEQphVGAK1pyBRisX2nOegTU1G1yXWkRN3SwrkPnehAs+n6TI1O0bzV9UkvVa2FtpXXmRDmKSBz82+0Wfd9DwA9K+5uaegTpQ0SQYWw2HTgBhiL8L8+x/+UjmevyGFaWLIZk904sEWIhRYkUI2DMcw9AcFuLb/3JHm4gnHcW+2Cw218hGcIUJtykCB4GUIyIXhwgGkkmzBsE84c7uG/vYfYMC4NHDx9if3WFNE2wVnKWD8MAA0YMHsGH0l46r5U5P7cDI9P0F6MYysJNZgnYm4+TJQhBmuc2h0LL6FHLyb/UoxYHrRkx29RCdU5UgwpmZRWHEREMUzGdgpHn3+xAAgm1vaBU0I5V52raLzXItXNKm5ZRjaEKoEGmvlYGN+e6wqak9ZgBkhmIUeZ6uTdX1oWyTqCu+WKLUsaXJvVReTZQnjFhw7MojGtsivFblzBdh0HCwCMgoFoWUJ8hXUecdQghIvhY1lwxxqph0yNxC7gx5X4EUMTNvk7G0DR5UF7f25RXa+kE67jI7RLrfs/kNuO8dlDuV5OfzaSU6QfjbjkGjwzs5aBu6qV1m73nJdOWzmdt+e0Gem7MvE1ma3gSmnnOfdnWrV3jra1rJCnIKU5w5HFz+TnGnQPwqJ5/Zy2+XHnf6vM+SHVczWX2HdPqMW+7Hid5n4XhKGLbG4QE7H1EJIvkBIQp65BFTAYRwHf/W4tv/YHHi089fvKX/Z2lv3ntTrImITj817/+Dj7+1mcYNhMCDCJJJL1EbVjAtiyg2a5S7CdWtnoxCaMdCGHyiIVVT15cTtEnEfsOIUaMfgJxTu3BDD9OIOTjbAJMBgQbC0MdQgoI0wTTbfDP/lXApif87O8M/v6Hx/eX71Lolnft6/I74B76EzQt7d3zLx05Zmk2m9eSD35XTmZwE29P9Si+AxJTLU6vpn8eu8e3KUdMiLNvl216/Pi7f7vtmNta8XXaYX5vh61/rB8YOAqSqZ/54Df95li5T777OR5/c0TfP0A/PIR1WwA9DHoQOXCUvXtKCU+/Y9Ff9IhxhDUBKd3gi5/1ePazc9Gh+FCnOzs7g7EoDCZ6v9M4it6SdVA/TgAYzlnYzCS9HYamtKwMJS57eaaaoEi3zRIgl1mvACSOElDIOa0shEODGKBs2yC0NhkuDcgxISauNsrGHjFN0wwk0ep/1lr4FOE5502vxsqyJxdTSrZ7EoGUwQuqh6quF8UmAKCwSsmNzRg8Y5RUStAWjlHmdU4SIGKAGALGacyAFM7gIrGDTv4aMbV6fAJ8ACEz/FiTgzRSfibmgSRLe6kC+QUkEuFcV9pwzX/QAkdqe9YAIO89Li8vi03+7OwM+/1+FjypACciC2PkGGYutnrR6V0BO2mg5WbYAAbCfp+DS2qQRw2M6fu+AKhy92VdU9MYqf1AAlHbYIYYx6ZdJP3V0idzm91/6TtZtlf7ewUlAcyVkb3V3Y/plakaSY7awBUk1tq1vR+FBej8PJfDsF2Hru9LoLFxTtjssg06BbUN5GuRPONqV9exr49QBWK96xXot0dOgJmTnOQkJznJSbK0DvW1TdDxE6uDZg0FfSCMoqgsUy/rZ5vBF6r8gFTJWnNAqLNN61wvJF9TUWZUlEWgdcq3wAUFdCzbQTfEAMqGkDnTM44TCMgME7Lx13RPer4i0VuaTt3YSQ7YxiklHpy6OQQ3dak0lq0jqTpQ2j6A0GvSkrqwdbpUwEzrcGwd3K3f5hAYRSBK89+atm2/h6kR6/pnTD43qxOKhi/gFVJmhCzUOAg1sorlvcnRDVadZyR5Z0t7lBtr1N/indSxPHfE6nGUGWaqQ3jusKqOuaaVmQFDMJnCUpo0H1AxStkZWxtZWWiKmp71aVEM5uw2ClLQvpy1kw6q3McM7btsAG2d5SvOvKVTetn/rRyOl1Zhk2dVDUBrzs32tThCtS2yA5U5zW+x6R9jCJyW/XZ4D0fnNzag1MGig00RoIAYJkREJEOIbOGsFePwGCXXdQJgr+CGF+jDHkSDzB8QZg9mhoWwOoxjkOecGYBF4g0ePFE69DIU5n3Ytu/qt2/HedAaR49dJKoCvMQeHYz7CpJYN1surk11jDemIgAS7ToMPYZ+g81mm4EFDtY4MFOOJMtjhHMqmGY9qMNADRWUo8skH7lEF8k86f2EEEakFKCzERHgOgIxg80EcgEcI5gYcfcA06ebmTFN57AEFgNhuXJ9HxoTpdkkXH3+M3QPO3TO4VEXEJPH8/0eiQwmf4PU9WDN6z55UEwZzEKInGAvPGASzA2jcx02jwKi3SONE3pr0Jkz9A8uwNHj5uYauxvpL5tk/MYWTJGZ3+ZrN80IeNfmiTXDznwvcYvJ/S3bNqr9cT4f1u+Q61QrIACmuaGrgdCgPLZlvVzO+3MAYbs+LtlZFJQixk8BKSGI4TXXJjcK5RRRGfxJMdejXr8CEJVdxpRz9f51PSuGMFPvoxpza0RcCAEpNmskV1Yz5rqfMsZBQUeSypAQo1wvhCh1IgsiZfvS/YVGvdV5WcExdV8DSNpElLlR7eHMDOMqcEyNnNoX68AqKVdorZv9w//P3tv2SJIkZ2KPmXtEZlZ1dffszsy+cJc8Lo8vR4EABYEnSIC+3i+Ufoh+gAQIugN4uJMokQQJ8igub7mvM7s9091VlZkR7m76YGbuHpGZ3T1vu0syDajuqsx48XD3cDd77DEz7wp9CvvMAUkGsZJ/tZ/6lNen2azOyfr9OAcEL44/+UTQSpOdf1Uu6trd9/3vIoJsoDaBF64S1w1KabaAkogIJAkk95D8Gt/55i1e/nTAP1y862X5Mvarq3x+We/KvfR7Wa8jf9XtWcyJK9b9Kxcm4PkNgeQ1SiLEMoDCDXgkSNZ1IuWCkiMKCNvnEbckNXr4Kr8aKYXw8uUt/uRPRtzcvcRHL+7xOBfsj4JSCKXT5ETUKgV52RPfD802N2K8Z1oLISAOA3abETkXsy11X5znVPfukjNAml1GckaaJ3VGc0IkAUsASYTIAMIIjhnPvjFhO0z4+Ce/il5780pXg7L8R968QAmd3+EEy5I7ftQ7LXed+uzkm75NAi/DtLx/n/ND1Ve3tXSsnDTTt2d948+T4fSXtcef7mWnvXm6n73p6M97f/ps43ly/vnvLv+2OnY152T1Py6MobzhO5e79wY8fW/EZnOLON4i8BZSAkTYuBYFFATggptnjPEmYp6OEElI8wGvfk5uTaOQ4mzeZwRCjBsUzBWrE9FMrgXUgqIkKIEFQYNSAEAEkbnaFBANyiuOZeot0Eh6EUQRnlmWVbkHipZDEhQNjjMSCpkN1crINnuhwQp+XwBm+/WYp+PM/pNzKwkbWEkbZFlfqRQAXN9IZoYEgIv2WYhKxlAcZq6kjpw1SBFGwuhHvMckPeOnkhwZQ9CgkZQSUkkgCxQKHDCOG824jFKDG1LRjMIpJTXKpKDkBDPmAAngKEDgbm9odk9PKKp2iGHhTnZY4witmxs22OwSt+n1GL+WZmtVYpITYXoyS7OHBIfDXstMpZZh1fEgtYOs/LGNqZNlfJzX9v25MvbeFs88VMemK6HlZZYrYUzaPr22Gc/hl54pXe19Dw5aZsLpz++xAy/z3AcP93J6vq1btMbXvG0tCLe+m0BtE0gJY5sYkQYva5YQ44DtdlczMPmcblC+bYLkJbT9vsXmWntPr4SZL0+uhJmrXOUqV7nKVVbSK7bvFLmKNzsAepHul5NLF3dQqpEkMMcSFXMsVZXspL39/+s7rhVFFzdk1mzt4pkSVsqm90efxaayoM1RxnbcPM8Lw8Cv7QbTPM9aazcEhCHWzjghQZgh5o4+MY9RbwSROYf9/0o2EVMsYVHwpdWVbed7+5Q8UaRYRHsxQ5NQcoue8L73bCHazuaY09JILXNPb0z0TkQ1DIqxwwtSq7YE6Z7BzwMIhXtFWA09/44t2i2E8zVcmZZEMCIz4N3hVQ3i3lBoTrElMQXVAbkes0tCwgYNOFjVQLdiGXFaqTGpfU3k53RRF5UQ4E5o/x3mvGzvUU+0AoBcch2D+oh1PJsB2Pf9256tf/d1zLn2qd/AjTklVa3G4QxZZv17c/yWCmS40abrhAXmgOq8XZNv/H79+7x8RkKAOs2lBJBFLQgVgJK/IZAsmJJAUgHyjPHmAS9fv8KYZjAPINZ61BXAFIBEHQmHwwQmrRcdw4CUBs1UEwJunmR88N0Zpezx+hc7zIfhnYG35SifAnCfBbxcX6tdQzNs1DJ50pyrIvqdCOrYAP040Jk7+Bxon0lFotic1Ixx3ODJk6e42T3BMIzt/WdGSgXznBACI9R1J3fXPRUmS9lco9kswguClCbkPCOXDCIgBgYCA5RRSkY+Fkyf7jT6loD8MHyGfm09yxWCJiAJXv7ggOE2IWw2KIGxKRvE/YxZBPLsgOnuAdMhI1IEF0aEEsjSLCgxgyKBZgFyQQiEPM2QpK6RIUTc7HZ47/lTfPLjPcrjCNnvdNwKg+IDmI7IBgoVASh41hSLrLOmEsjAxLIY0vUe2xPUegLEWTXhZJwafP/Z8xxIff+JWnm8Hjjq15fWbj/GQSrf8wBIASTXNag9g1xcq/p9f00krk/JbEROMYId1WwqzMHcHAwRrkCokhasTGCB7u9s+18lyzhY296Bvl0AEMC6llmWMyeROMikOkDbd/r+q2QfZgxD7PqymDOm6ScEgCwCHSADJQu8vJSSd86t0x25FFQJev1+1ztmnUTXj28PrPrvzIzAcbF/N/IO1+d3Qp32qfdxcz31k/ai6rsCi5dfnc6HhQ690CnW+iudvBdvI8ucI7OjFIilJxdavobaFO8/uz4BhISAB6C8xB/8zh/g5UeE/4xPLt77bHs+09FX+aqk35VPZ5r+RSeffTn37X8/+fuC42/9+9uufZUvJqUQXr8YcJweMWxmbO8CpiIYxhuUTJimjJQFVAiggFQCKAxQZeFKmvlVi5TnSBMjzwnb8aglOTGAMaDYPiJVC1VrRVXhrOZoykhzQi4ZMWq54iEOGMYBcYiY56RkdQtQSSkjRDb9MAFgDANAKFb+IgM81yQ3kAimQW12FuRyxGG+19IXv2S5tMatrRYCPhdZZvEJCdYZvHwU3rbWip3bt23ZxlNqi2sMACqhhrDEjvycc7Zf04bfHeP7sveMzyPv0oYvo53v3jNfXC7d5/OSZXbPHhHGuR5bCevk5BLNCPXk6VPc7DaIwxYhDChFg+R0/dBy74wEgga/ERXkooElKRkRHgLhgt2zl2Bo9oycBRSy4VpqE0XPTEEFkQM80IIgCDDs1W2skpWkkqWuZdVucVxBFCtQ4n4EEABhSCHA8Eoln2QAGRwCSipK+ivQQDa8WceuvdzZlW53OM4LGNEEaLYKAKbQBar6u6q5oZiDZbNVe7vZeLCsGl0mD2jJ1Fbuvb2JIkDJSnCVouXLxzFivBmNdFCQ0gxYBpbNZoORRkw5Y0YBB0bkgDElZBHQdETJCSVnSJp1HLL2H0HAHAFqmXXOETYALAgkTirRZyuLY8/hkI5t6pwtJ5heSgmffvopjscjRDSD6na7tYw2M0T0/odDPrl+KV5q2H/XftMQgy6QAFRfsnPP6e3xrDY9WQqG5zv5xi/kbWeKFpCyfP4em12SaDzgBehXtj648hT78GAZwjzvkVJCCAHDMNj71TIm9/1OIMtOaruH+RoAs/eZNYszabllazGi+Tp072FsNlswz3h8fIQIEOOAYRghUIyjSIGHajUsu/WD+gm65yVgXWbyKl9croSZq1zlKle5ylVMemXvXYyDtbyNAX16wtmLGEGkgQIKUrRz1srj5TabgiXppG3+4+SXxvA2hyYHeJHYtWN9HT1w7rr9ef3n8zxXsgyRRlNoORzqFN5Tp9vC+QMBJKuTTUjTj5I54KrDTLofc1bS0pG0ZH93HWwRIE560FSlzbntJBN3QPVlL/rn14j1drw6YDpCxQkU3hR4L83gbffxdCKN36NYNhGN1Fgy+/tSDWvSRL0iq8FTTW1yh1kzPKrDCB2Jq47tsmZuIwj1BoY6+iphZuVwdeFmeenZYr9Tc4CKKKkpIJrR0caXvIZ6sx3q/YFWrmSdPcfd0u44vUSWWTvezpFe/Lh+RPt+8L7o5dy60UtvXJ5zdrf5DFSn/oX2r+/XS51bIgAlEJRMUSAoYpGZxZzYpUAKgbnga9/5CCIJAgbHACFGljp8zfkIKwdCAkYECnA8CgSM3W7Ee99MePbhKxwP/4i/+g+/iRc/eXa2nf5E54DNzysnY3XpvvbF8p22SBl4mlQ2QHb9ji9TItdP/cLU3o0YI2IYDOS4wbNnzxDDuDifmJGsFJsa2742F9BJ73StIM3sIaJZZDSjmBFnYKRB8YikAUUE83xATkdMLzaQv/qd6sjvZhewumsPpC5N/eURkiJe/813NWMN7IcEGc8BCLb/zSuE917g05wQOSCCwIXtPdJ5ySBwIQQQWATpOCv1i0MlWdzubvD//YDx8Q/GCqITgLvv/AhhO2s/oihAUrOkaNpcdjxEbPDPPM2l96t3/L9Rr6hfyfKDL4R/NKd//9n6opohzZ6pRuD6octMIvUZyK/t5fN87+CTNbH/3PcLyf3eKwqIhtDKzwmhFCPc6BUsi0u7pq/hy4gwaUMEK93Hy5J0zBrF6Nn52v5o73N3bb+P7/faX6drsP6uwLRQqeSUEAYwK7CpoGgjy2hrc9VFSpfVr5J3pGVbA1AB0nUf6HfLz5ff+9jqwK7Bzf452hguS8W1vaUfA2D9LvRyiUy2/k77Arbnr8Hhdo/lnvr2Vf8c0Ny/Yfps2t/ez43g2vRS1REEN6Ng3I349jef49nTGXgHwswVwvz1lNNVvMkX0SfedL9Lf322c6/yVct0JPzpv98B2OEP/2iPb3xrj5fHGeCMAkYiKx+XCigyQAFFWpa0q/xq5X/73x8ABHz9w2f4N3/8U8wvHwG6AYctNEuqZxPUfdGJ7gRoWeU0o6QEIuB2t8UQB92ISkGajlrWU6AkqRir/i8WQASoA1VEs9WVkoCQgCxAEgSKAA+1FCYQAIoAKaH2lyVnLM6L9s+aLLM+TuwYJzCcQzh0j5emZ9bPpd7dz26/d8eRZqlZfu5udllot337vDxTI83Q6p5SzzlvW/at/OVL/yxfRhveZX87R46q5BSxfvuCDtp33WfXd3kTMWs9+2T1v8v7v/0x7j64B6Bl2I7zjJyBQFvEcIsYtojDDjc3dxiHnWZCEaqlaQXZgoISikxGkJlxPD7i8fEBAxM0U4baDSEmfPA7fwuKwP19wuOjlmzL2UjroK6cjdlXFTsDzHCAl9ct4iuF6fUOIbhTH4pHSAEKCdiyeIvjefayeFlnoQISy1RrpZIu4UjncGfpvl8f7797yRtm1gzE5GamPQNTh0vq++qIYhEBxDKg23WXmVg0qALEivPx8t4ld9if6/uSFZNiw27Ig0nNRiQtuQgRCLMGeEKAEiE5ASUhSbZ1PyMTgDKCSOfKOaKM21i9vdVj8Y6jXrJvely3n9V9X+ScK1nmJIN8yRU7BiwDe4dpuc0H9CV+GL1/ouLNhjl6GSigEaN8TPx5/JmUpJUV/++wYyLPlOrlkN+CmfR3oYaF9v3d//T4vz53sGCTYEE3rc9Fatjwqc1KAOqsJHiGOrISjY5HOyzh9n6MwUgxA0IYkLKSYgTQDD5ESFnfjzlrqS+uc9ifA3V8GrZdwRq0QN6rHvplyZUwc5WrXOUqV7mKyVqJXTOS3yRrUsk5h1G7D9TYNN22N9Br/G42xY2CWQruzvQzmhPOf7/UTAX6uSqsIoLRamR6m+d5Xiit/TP1fQM0wsQ6DSOv7n/OUdIr1bB23d7dWhpNQs4Jh8MB8+xOpFzbFUK0aIKWPrInhYSgtclLdoVVn57Ik5csyyx5lhg3EooUU3I7Q7IUy/ajTnGN6m4kEjU88km/9f3VnOPSOWYsneuCwENqZHWM+N5h49fonZchqLHSp40+lxKzb1ffNk+T2QwtRiu74GPICwiNV0SqUqRFIUgrE9H6mhBo0Bq2FspNUszcaFAG2aDpVFBH+Ll3qRkK/kxudGlKWUiBJ1r2jAM9696JIcwWV1g8M5DOy3meQUSVQNaPRd+Xp0CCj49HX6z7X/vCjah11pe1M7b+7qU80Iw86laNRgTysl2NcOb1hxcGLk6dqf4TqIDlqKCu378wIAPAG4CCgbszOB4RgwCY9XtYJghqZW4KCJ60opSCGAgomunnSDMitggxQhAgYIgETFMjNa3B0tov+Gyydoz1f7/pHot5Txr9tdkS5FhQkoNKWPQlmMCLTBNlcfX1ushG0CADyokIu90Ou+0NttsbxDiqQUyEwWpcK5FAEOOAnEolHJbS5lm9ywJYNOJSERALONg+lIu9PwnMVot6M+L2dovH/SMeHh4RB8L45Aavz/SV95fP0TVo3cDy9q+30o8r4tmhZbHDffDsE9xMRwAAIABJREFUCZ5/i/D3x49xuJ8gk843jRaOKFxQWBAF4Cw4Tnsc8z1uNiOICWmasE8Z3//+9/H48BSEsY2FkGVK0ggqAeHmyQ3monW69RgnIIllHtF3UDqAps8itn7Pmh7xroSZvlOp6613lLpWlAWZsyeK+t/1psL2q673DQxSgJaIbRqRTTBz6hAwTwm6ri11p3YP1L4AWlRdEQGJZqMqIhaxpWQ7BTZtryNP280oknRNQ38PfxeirbtsgLEBhUGzIYUgXYQboIQfBZ/Z0pp7WQUl7GAxrufIOX1ZRS01ZxnALKITcKDQ5wWbfuGApzsdCCIK1jpxR3UPzRwzTanTcyLioDXPSzeWDkQDDQhc6231WWAk264MVQ/SLklPnmXF54eTdvyz9vlC2kkna97JlPV5Qu37dlxH+AHqwtIDhpd2hH4urvfx4uskteu7HskcTN+MNToSEDy53eCPfu+38Pv/6n28fxcR+WftGc624Cq/7nLOufoZV9zPdJ+v6viv+jr/kuVf/eYH+B//+x3+4acP+Lt/+AUKD6CbiPSQ8eL1PZ49/xpKhu5l5fJ6dJVfvgwD4dnTgH/86b0qmGEHdyyLEEg0O2vkgsC6hx/mCcgZm4ExbjYYIyPNRw32KepMDcygEKAZOQsKAdM8a6aBIgADKR1ASGrDcUZBQjpmSDpgNxLGgUE8qM4mxWOUfq3kXJOWayUtPteAJiVS9DbWmx6tdCQYxuXMitIdz3Lu3vb7hSw43r+VNCPq7Gy42uX39tfprf78bWkj8bYx+fwiJyPYW/PrMetlXa5rbaO/iZwji//lwufLT0O4w273BGEYUVCwA4F5QKQdmDaARDCPaqcULcWHDmM6TnscjgcIEoSPyHnGNB0wHWegAJshYIik9hXUVpmngDEMGAdBGiKmaULOBYEHy2yqWVIBwjx32UeM+CKWTpgNbwH88mQ2mtQSR/qn6c6iWTvZysQyqRs4pYySc7NxkSFG8vE3oy+9c86mq+QKogVphogwDMNJEIVnGU8iyCvsKxAMD1H7wc1OkJJcihFmPFhRRDQjCHQ91+yvBHLyD7TP5jmhFAtGGgKGGBAjQ2RACpPiOaXgeJyR8wHMAXF3g7jbapwYAREFYEIYBkhOiEwgyjgiI6cEsuCOnBI0s4909sN5e2SNJfZEFccW+szX6+OdjOHHAw2j32w2i3s6gUbLBZNlThshoti2l0Py8r56rmGsgeAkxwWiZLj+MAzVr/DixYv6DEyE4/FYj/Vrp3TUBCydnec4cIwRIqzZ3Vf2Ym+v+jV9TmlfNLv3nA9nbQfO84z9/n7hw/E+9+PXwadqdrZSz4CVa4xKy8xlBpFgGEI9N4SIYdiCw4Dt5gbDMGCeZwzDiBAG7PePOB6nauur7T9gHEYjzmiWXS+TVUoGKNdMswKp3wE97niVLypXwsxVrnKVq1zlKibqmlKjgS1bhSfdrL6lNSkEQCuN45+8WZaOhu6aDv4bIYKYVEmFOZQEqxP7a54zJM1o6VLt9+kfG9u8laNxKaWAgpM1/B6lKtZAr3iaM87d+J0T0Zntrpx66QOYMyuEYGUZ9J75fovpB98ERBA+/Cl4e9/VS233UpJHtuwKpbZD7+PP0jOw3ZMs1r/oCDetvBKH5myqRh+gZBn09V2dsd+caT6I+usyA40TT85FazSFXqMUWwaa5Vg76cmv7bImlSyjD5bzo79fsGh+/dznZUtn2s5fgg/rGCs1GjqCBfq/UftDna+A1bJBV5QFXv5LHWZsBnPr3+pPq4bQcnwqCFMvSKvuc2OM0TIiaGGYgjYmKSVM07ToPy29MdSUqW3+nWZAAkLXrvW7uizvcI6Qdu6aLKJlkaS9bxr1gDpObjQ3x2IzmPr50Yy3li52XYZKHeHF2u9gD2uKYh4AEQhpWShPNyrWHjFHLAGQnOAZlQABiRjArO3IKeHmbsRut0OMlvEJA1L2NMTn5fOCluvz3gyN+rxafsqBMI4aGZIyYFXGUd+Xut7QAqyqv/seUsdxSZIahgHb7RZP755b+SWNttHUuIBEA5Eoo1DBEAYMQ4BlhUdKM1JKGAaf//ae6cJc1+eCbM9mEbDFI+NmEAEhEuZPAn72/+yQ8wYp3eqcyG8uwVQfr3ayAufDNz4Gf/BTpDKDuGAcgPln38bxx98C0KI/fR4rT0PXh4//mvHwmrD51gQgY7PZYRt3KCXi1X5GnjRNchZgygVpniE5YzeM4BCBkpFywf3DPd777QHvf68g54Tj8YjHT+4xvX6KIIT49FMgBjx59hSHecL+cEA6TKAi+goUqU4AIk95bf0pDk7amuHHoAeBz5NffLnyjqPab3b9S8euPmtYsq9Fp+TdtpaugSgHONuFq/PG9CDUtaUYoKrfFSvfBWCxppwrc6fEzoJcCogDQuj3aEEuGSG0h3Lw1eOGiQjR9qwGsjpp01N6d3sRwUqoWXOZdP3yDQ+e+cV1ECdJ6ii6vuHP5Om/ex3H9wJmgG1vCUa48bblXMAcTGdpJGBAdTxCgJKDxXQaA/8QEKNOjJb1BJoKvNtn1+PYg6prgNBerxNV1T+znoZHVzJJ58jTNodg2ZdWAPqyFWccIiu95LK01XdBlumuc+7zs1fq7rnoB2lzQedKIzYqYcZJR6Ip4ZHx9MkW3/nmN/G//M//Ffv7GT/60fHXxol2la9O3j7LPptcfmMuff8u17jKVyX/+T8d8PffnzGXGd/+1zPCICAMlvHsCA6CnGZEFgQeABx/1U2+isnxeMQvXvwC47gBDzvMiFomRTobkhQTGSKDpOCw3wPECHEAc8Dj4wHzPFVMYxgiiBXL0L2YQYGQU4KUYmSOgpSzVjSVgJZFTqP7JzkgIKrTNcSa2fDr352xu3tEpIi/+k9bzMcve/W5LIR+522fvnsLZPkrdSZ5dw8Ap2V0PCtNLUFTw15O6A9VfxFt3TqzzLJFUm/at0Hsnp9lHSUQvvdv7/H8NwQcRoAYaZ7x93864uVPwxvO++Lr9RoR+ryzor/OKcq0OtaITGeFllhQNzL1yutv3962JdWmP+tdyDLrv04RLODm+Yxv//6j2pFPd9hsB8RhRIaYrRBBMoAQAQlqg2c37VRXTEnJ6vv9Ix73DyiSIHRAKcmCDwVjHJGSkt6ff+OIJ8+OINkjx4gQNoixgDmjFC2PE4egxDqg6qji2ZoFRhbJmvEasJLNhm0SLd4Xx7Eb1hCtxFTU0kzmfPeszJVw0eET3mlvDPJ4wzj42uo2U38tt5tSKSgkQIjWt4RAVAmHgRiFGQiKi4YQLa32DApUCTMxDihFSy4lI63EOFomE9EySiggChWPTDlhv88gKkgpa4BXzla2HXasliMGCEyMgQMoDhrUASAEAocBFAZQMRs5BLMNs5aeFl8X2srq+FbftQ07PS89QeSSv8HxydOM381ebvf1oLpc8XQnq4RqhBcLwrJgISMx8QmmIPbobDjUBEBLDBFr9ia3pwDFqfb7fcVVPUjBr0PEhgGdBiqu+6Nvg3LJlpjDEmM/DSjNOWOaEmI8zfITQqi/+z0rkavDXX0s6j2zv1Pajz5Hx83WbPqIYYhawlFHAjyxErmGoQZmjeMG4zgCQpYBCSglIc0zUjbs3ezglnXtV5cF7Z+rXAkzV7nKVa5ylau4lAKUrE6rXnmV3vho8EEp5mzvlFd3iDuJwz8/lc6YbLbJUtERaDADVT/cUqFE+0yNDf3bo8pVoWsAjX+niqlmn0gpVQV7QZgRL9PR7uHkGsAVx8bwV+02NAeXNADDwQ0CtcgeghJ5YqisdwBIxxHz61tEEMKHn2LY5ZrxZRiU5PP4+KhR5kwoMsGJBAKpbZayygwiUMPSyhn0z+MklD5zSuvTAufaVB+bTZXmkNIINe+T6qgmV5rbdfvBdVJMIx1RVX6lI6GAAApshrDPm8Z0L7BUpSBLM6okJC8T43OpTkfWiPYi0NrHQvBIlby4ryni2trquFwaCe25WsT3qZFNXNrcFp8XTv5B5RKQxZf5MTXTiPRGZkvjWYombM2WkcCJSWSGvxQAHSgmNhnJAAafl1LMzBCyLC3qgRYxYMKz7Pg1heq12jVXmX0qSNfStLM5PHtz18dV55WTt6jOHW0rLGUtLHuJgXB2bzaSSikOOFnWkoXR2c3pOobtx4HKIvpuavYdG18SANm5TvAMFCIM0LBYw0oR7SNPd8IAiVIiSm6pWoskzOkAoh1CGLSf0gCmJ3ibibI2CL88SPkUHG5/F2gZo6Eaw5o5mKBBxc2JXaQ5nK3X25X8PbG5qjicIIYBm2HEze4JdrsbMEcthVUIHAedl0aWEcoAzzqvWFBJSSgIoQCUra1Z3zMBtB40A1QgMmtEW84olDHnhFIIQ9xCrA53PjD2P/FxGN+xrx22644VAm2P4OevwHkCKAOxgD55r65oBa2QXr/KAcD+E4CGgg+/PWGMBUEYAQzwiLsxIIJxnBLynJHmAghjDANIIoAIEKPkhBA32D0ncNCU2fN+jzEfsH/5PogYmycJtBnw7d/+LRznGa9evsT9J5/i8Oo1JBekaUIuRjg1Z4kQYBmsLUONaGYRbnGylSRDDkKpiC9y3l/VYeBQle+rvuL7/tDWciXr2PsMXce1D71H2/rUpCfYtSgqzZCSACq62pGv/GX1VgRrk5LfQtAGe4Yu8vJBxEbksvXaIgOL7b+RWcFRAsCMUtjKaNl+XuxtMtBS02QbkZhaXzBI5zbrGq17hdSlTZy4BC0BCQMzyRdQaQTScTTdjRkpWZaxqksAKWcDmtnOLQpAizragGRroRi4JXUZzEXX1n7/1mNcn9MsU74suzaWcraMRqIAN6wMG5ou2LKmtZJCPh6trJJG+/XlnSqByqPpbI2pacH8GpZyulRF1I/3vmjzsa10ugY6uay+C28B4HsiTL83tgP64zrdG53+UXdWoJbb0Mlgc1P3db+c9UZ9dg5eSosgMoMogznhyc0GHz6/w1/+xT0+/vjqFP/nIr39Rd3/v9y7X+XXVT76KOGjjxI224Jv/7aAoupYHAriOIFoD6IRkAAp/PYLXuWXJvOc8cknj6DwFNMkmJFbPIXp7cSMGLUE6TzP4DionsoBKRdM86w+3BARYgRbwFEWKzOLBAZ3epXaX8V1cteFQEAhkChWITEpfmSZKosQbp5F7J5E5EMCf4VTyde3fq2j8zvuhfOXR/XZJasue+Yea1mvfufW4v4OiyyWpie5utc+78/qz+1/LpNs3iR33xrxtd8JEBo1kGFmxP/3zT32Za3wb+rHr2q/elPpozee95ajz7aX2vi+/brvev/+M8G4Y7z/GxvLrOEZniIIAkaBZ2KBBHiQG2CqIwRZdD1IecZh2mOaDkqYwdywlQLkOYNjQJozYiy4eU4YI+P1ww1CHCEoGMYCOkzIZYbm6FWM1HM6x6BZMwOzlfxJDsAs3gWUpd5dSxpZuRcmtvI3Qe0VCxxjdoudUSRUTEmoZZVeBN4Bil/4/5ZBxIND1uQErD7rCTOKX4raOYbbstkooWbd9TXJSvQUNbiZIjzAtZSMkq1MU1Fmk58rRYMQSDxoVCCSzQYkHI8ztNJQC34gAkJkhEhgZKBYJhQOCMTgEDAXUXuuCOKwQxwFWQgiGXPWDB8gKyZFlmmFoxFYPCCj9Ynf32UZ4NDGYR0AscCQwYtJ78GPLbABLbu7YZVCjDlZlhICYmBQUMyEOegeRUVt9uL2HlVbskgyYo7OtZxTzXAyjqOWHuKAIWhGVA9+FQE2my12ux1CNCzXA3HBls29L2PcCEA9UacXIoJDt2orG75rPgrHw5m4Yi8CxRPGcaw2dCPCaP95NlW1q5X0k3JGzmrPMlnml8LIiex+mg0qJ8UEh2HAdnOLGEeQZaomAGmeIBDkPCEGIIYRMVrGOWhG6TgMCqMGxVCQNYiSUZAsLTNDM9OzBKTcSHRX+XLkSpi5ylWucpWrXMVE3AECjYqvRoh5iauDy50lkGqpV4clAa2cQS9rcKF9dmLYSXN5VeUNa0PyUp3KztFlhJlsCqwyq5Vhn9JcyzAxc1XgAVQygZI2SnVAtYjxRvLo+04Na6pAhv+vpCJ05BptZ5aCMs84Hg9mvFlZliefIBVB5ANCYEsrqXVGjy8H0OMWQ3nA+GzCft8i2ft2oiq4XAkzKGK1h4uVMuidTP5cPVlGmqJtjhZmz5BjGJcZQi36uzk0K3emjp00Y9cdZ1Uxtz9kOTfqsUUNdT+sKv31WlQj1CgEq4dqz2uXWxtgWWDeOoETZhZltjqjrZFl5BTU6MFHXNDTSR2vffaVBsSoo6rmNBHvh1bztu/J5dzTdpWixKpm5GMxhqjONJufRW1vtfRathYCIYbTLBqeDtedvfqcpyVITh6bvHyFRXsAmkoX1Bx23p/S95/+USMl0CgE7U5tPP2dL+a0JyPAaYSL1PfD57D3kRqIrS/dIRp8PsCBGAHJDEGypuk8KcXeCR8Le19KKSARpT+JaFkbYjOm9RlzAe5ff4LAQCm3iAOjlAHj+AzP3hcQvcJ0IDy+vHsrGPgmIPHzyLlrTXvCx/8IzLNgfKrlrwobiMNWMq84zcFyk1XSWUfQ6ol8Nj5MQQkzmxvstjc2Rp4lK4J5oyQm0rJjwjMEB+T0YEAVg6BrO1NGKY84vhRMr6O1BggMMAU10IsgMsDPRMvc5BmEiDFuMM9HpDRhKo+YbnONGmprQetzPuxAxx2ECtKTV55aBXUuQJBTQqIHxIkBGVFK0jJIw4T49U8VyAqaavn4MCI9jAvwDxDIMSL//A4yCY5ZwYm4Kdg+T4ggjFJwyIIijGHYInrpP1tyixCGYYOSgZwTUtLVZrPd4MispIrACJsBzz94X9e/tMP+JwE4MMLuNVKZ4ZmDCjdihhNn3B/ve18P4LdFsvOAiNdvX67Leo7YumDgm62RJ+uM6Duoc8jvo6Ai+Xrtc9rJer7xdGtBu2sCwchV8Eir/o2wOQxfkwtCbHqDHyPweR5qH/TEwhAayU/3So0iDIF0vhlwrH1LumcbQZlh4yW+RhLCENr7VBrRUm/Arg7Ud5BDp30RIaUJRBHDEAAKmomPLLOfj5Bn56Kguoz3Ilt+JBEj1xZkJxpaI4jJiDGeBlzqWqh7roHZDBiEXIFcSXPdC8XewyJaKpI4VIIR2fzqiVAALGNNI0tr1BxVcB/dvOlToQOkfi/f861EZptPphNRA8X7mVJ1Uao9fXGfXEq3Zl7cV2l1hgKX/d/+f/973WNBAJMRjOvj2zsSQBwR4oAhEJgTiBP29wk/+LtH/Fl8gWm6prv+5yjNidqitb+c6775s3PfX+XXT0ohfPKzARQJm6cCukkYNwVzuscY70CIGKLgg29mxCHjk59HHPZXAs2vQr73vQ2GMWE/FUxTBCLjmAWZCygKiC2PGgExAhwFWRL2h4Pu+ByU4CoCIUYInhFXy9IWyfCcxHCHInW6MjPAiosUKhZsoMoiiVl0RZoxyuo+5rABCEi0x9e+mfGLnwRMh6/e+dX2yVP7523r05LE0n73/y+1/uy6WMszSW1Vu34jufTx9ExUM6Gc3r87JwjuPtwDLIBl2QAc30CF9fzqrkcSqY0CGoDNEzxOA3IJSHMBCyOXBLeJ3+UZvzo539NvG4PPMrsuP89nf1Ligt3zVyA2nFIKYhjx8OLZWeKhrM7dvPcSIMX7PKCAobYzdWU13e4QEJ58jbAZn0CDfZQYU4rb5sVsRp8XViYZbZ7kknGcj5imI+Z5Qg38KgRFdzQEJM0JkRkpFWQS0HaDm5sn2GRGSjOIGZvtDpvjjHnWsraAZVsVgeSCyKHik3PWsufc94Xr3TWqkoxk0mwe7SvLKMMeUClwnLqSUoQAsowatgpcGlGfM7o2NlvsXMZJz2quNo+gLxUTPKuNtVWzeJoNSGSYrVhTBSVla6uWrvLvsmTLFuXZQAHN2KkGueIielwRKDmoEOZ5RoyGAYuOt5bxJZsLCZg1yEuIwcMWgQJCZCQEpJzAm4BcgDkLUp4BZAQrnUOQhT3WStmGak8p0YNR8pIQArSMMesfl9bfjazZZ1DRgFjUH7f3OUTFXItgyhNQgy4Mg7f3R7LbiAwn0ei4RYTAyMVL12sAruI+BTc3O2y3G5ssSvw4HA6LrLM3N7fYbrfIOSGnqRJ6PEAWSBXP7zO/LOZhb3cSgeMyy5eh1vCAWrf/PdBIs8gwhhhPAoI12CV3OAN3JBpoiTaQ4hYcLTssLFFpqCWitKzSDpvNrs6FEBQLPewfdV4XzXAzxLGuV6UQQhwsQ1OGMKEkC8qKjEARAQUBPkeKZTVSMi/xsi+u8vnlSpi5ylWucpWrXMVEMQ5nGZOW4KllTdAcwVQqocAsEPMpNKOqz9ayFjd0LrejORj6v5s1L7XWaIV33ZkmBC+RowpgRqBWN1TTDx5rRpnKOMfK2KFGDulTD7oTrG9S/1MdpZUY0pTZ9e/HoxqcOScwszLJQwJ/61Mcj0eUEoHHG5Si0d/zzHj5/WeYPnkfu/f3eP5bH2O7HTDPGn2ec8E0zTgcDov7qBOfLONFqQ6gYGlAXcnPOVUHXnX2wCL9xZjkVibIletmkOs51Zls9ihRgyOcdKPHZUhvKdpYaj8v02dq2sxU+7/PBlTJIDZmfQTHOg3qQjqAoVnVpwaXS41oQCtftZY3+cI8a0o7uJ9Pp23W64UVoas5Bt1A8Idp87EiXicGphtj+h3q+WJtv+Qc6aM5FsaTQ3rd3F4bcOi+r+W0CHUM9btW4iPGaEZa3w8OtPrTLtu2nAsWtaLIJeIQF5EdaiAGrN/PvsyIgoPL9isI3PW5NHKNZ6bxtvo5/X0AMRCjA05Kxv7hAa/vX+PJkzs8f/4Mz57eYLO9w2/+4QvsHz/Cxz9k/ODP//B0TFb9UMfx7Ah+PlnPh/sXAX/973cAgH/9PxTsvqYGskSGZM26IWgZKSoJa5HFg07mPYqSiZgHxDgiDiOSRaYwjzX1e04ziBMoJAgnFNmD6ZWmEU4AREmFGvXzGi++/x5e/NUHFptlTyOw30cEEL7+Px1Rnk7IeQITcMyCw2GPadrjmO9x+NYr7HYDOCjZBiAkA1EEwPDRdzH87LuQkPD6W/8F2Ak4aJYKjRgSHB9eg1GwfRgxxgE5C2QYMbz3GuOHe4ybiOFmQC4JL//L+9j/3fsA+bqm/x9e3uJH/9f3FiD47r2XGG//HgEjdkPAJg5g2mAzbvHw+IghBCPHJDAT5kkjgWMMGMOI3bBBoj0eAuNw2GO+f4ltyHj1+lPc3d3h8ccBL/7sFhRHDN97jRgDQlRnCZWoY5IzUpmQs/aP1vmGgajm+K/LfL82NSeAz9o6H5zAUOdOrg4CWaxzPr/suvV0H+vlWtSv7Zf2hgaRKvFLHQotI4lmFumfi+DAVl2nTNY1xIlabXSb9vWddeAqxmVKZACI0QgeRUGuAifvtnbnnBXMk7b2+OeF2TJmiWZrgabSdiAthID56GvuAGLCPE8gjhiGwdrq0YfaNi+r5GCw6oMCJ6mWrJFsHpGmZSydKOTXoLqeKogWbGwyKpkF2mcpTZBSkESJvRwIIYZ6jup7okB53QObPuqOH2bpxl/7HESaEcuUH+Jg/aWD1MaoledczJnVh70O6Se8G1FGn7eVHjw95+J16Mwx5xu7uDabHk9G9KN6nuq5wzBgHIDAM376fcF/+LOX+F/xF+/4LFf5pyRt5QOwctoCiyn2pd2t7Qjv0rIvesxVvqjME+Ev/+8bAMB3fu+Ab/5+RoyMx/0DMI6Iww7P3iN88CdHPH26x3/8P+7w0x+Ob7nqVb4K+Xf/7g7P3nuFv/jrhL/5h1scEoPj1jKDCJAzYiQMQ8A4BBAK7u8f8OrVo0WCu/6h5Eknf7ojTR2dSlgFYJn1bL9Fp8YxtJRKbviKEjy0DWWeVcNjAkVYNs4BN08Y/+bf3uPP/0/Cz3/85Tq/aPW764z+w0LLFeVsOZylxaUmp5xZic5bZp023LXFsa/+HEe52rVLLQUsLePq6hayOFcljBm/+SefgDZZCbFDVOqAOTe19C2BSfX7NKszmmMAtgEUt0gl4OULDX6BEAKpvnd6769GllbDm4+jN/z9ee65/t3bIWe+u0y3aMeGmPD+738fcTNhf3iAyIzb7Xv4r3/6x5iPb143eUh4/gd/C4qzZhChgEgjBrpFoA2GuMV2e4ubmxGgAA4jCAG5BOTMyAUgimjZVgSafVXLxhbLTuJBgo5d5Jwxp4TD8QhIsfL2hJLJbK6i77NA33nLGhyjIMQNtlvg5z//GETAOI64u7sDACMcqOSckVLSa5dSywVx4JrR3IOjpEg395t9CZgNxmxkcnOqSzY7wY6jloHE1wHPuLwI4liRNmrgXV6S6M9l/ugxvh6HMnV/cRwZYQiwALWs75fi22aD5QSCEeWIQWxZahXI03alBOJB+8xsHiVJGG5THJezTM7GnE8pW18pacEDITMEkQviMGIcI7BhpFJwPB6Rs2CaCzIYT55uQciYDo9I0wxASVYlJ5SigaHjuKk4MhuRqbDO4ZxbH6ntmBf4nNvubuP2Nn6METFGjOOIEAJevHhRj3eMfbPZgC1z2uF4REoZIYY6RlIECGbzpgIRQghqC3s/xhgxbgaIDADEyGMzRDLGMeL5e89QSsHxeNCST7NgmibEGJvtxWw+gLlin5vNppbwYp4rdtmCteRkfvXzLBqh1Y/tg4IdJ/Vn8P7r8dn1vPZz3c5WP4MSZTVYJdR+Tcmz7VAlOm02G2y329rnfRlpf8dDVJwgxoA4xDY3spJtOATMMzQLdNaM0RwYYxwxbgaUnDBNRxxtLIkJoZbVusqXIVfCzFWucpWrXOUqJiFoRIIaEu4IaQoO4Fka3DjvyAYLWRoUl0TZ+cvPyD53w6Fm9cCSSFHyXFP5q6Eh9XuDnK3GAAAgAElEQVRiN3i0LikHroqjK8+u/J5z9PvzivNL6odqjGgtU0EfTVXTQV54ZL++O9Gr4imoSvTaueaKrSvUu90OoJb601nZIoLtZoMYI6ZpxqefvsTheGxpOgXmMnbHj/6zJFeg9nlz/rtTxQfGn0NHqq9P6vOjP8+JVzULgTsNQ7CoebTjyaIPyB1bDXw7R2JZjBWMvCDtuL4/W5aW/lyqjso692h5fj83ekLWWUfUW0S8k7t7+bXlzOfrv3uj2w2XteHertdlyemIR240re/JRm44B/X5Nf38vs02DU7eoZ4wV8tG+TjWLES0GJea+YC5c5Z24yzLMe/7x6+9JqpJR2rpn7u/76X3/5z0Y3Aa6aGgUM3scKb/+v7xPimlIB0PYDButlvg7gZE6iTX2sZLQPZt8mUBlcuVwD9r9+BgaflnBcZ0JXFyQUu5W8/t5uK5Oa7ATwPkxMl5ACBKimASrerDgiITpuk1aP4FIAUpaemXObE6xXkP4Ka2t0/z3D/R8XhAmQ9G4gL2Dw+4v7/H8biHSMIwjAAY0/Go66AwHh8PKFYP/PaYMUADZQ+PCWmaEOOAYRw1dX0AttsnIIvcKqJO+pwERAEhDMglYpANAm8AGmA5dE6AYR8P/4aDYLvJmKc9RBg5B2RMkJgwDAKmo2W6zyhJz2JYJF3Wv0K3z5aSMc8TfviPP8DTuzu8fjVC13fgeDhidxex2W3APKAkLYszz7NtlmTlbqhtnj2MTDaOdZPsYHyB7qfo9QrASUMitOiDUpFOc24QtfWVHLRVIPV0P8Dix2vYM/v7zbVd/remX25ZqRToa9GCrgP4GnOJ6LAm0ISga54TfpxQ2vZLfULXL4S1P04yn1UQUfdUzfjmpAdBzTJSm0VQJUl1ENh6LZIxTVPNHsNElQzr+82SnKjin+nzRbj+5zcsxaPkuPZZT6D07vL06cX2r/acghAimBto6pJzWdwveImkSmqy9YDaHqEgpHRkmx7MtrJ+1DIcshFJuBvjvg/OAeQATnTb/rvLYqN1QQ9Y/73Y+/1dpuZ404a7bkr1OPixdV91ch5qX8xpRmDBMIit7Z/X3XSVfypiM9pIM9B13dfDzzn+76qTfFm6y1d9zau4CEpOOB5nzBOQQwFtCDFEcBmQ0gEd7/0qv2T5wQ9/gqf3r/HJq0dMs+Du2Xu4f0zIKddSg/5Wp3nGlCYcHvfIuWAYTu2jta1c/xbb695gn/k1cs66ijAjF8Gh7DFNs4IMTBg2EXEgDBEIA2Pc3Koj/wu+ye+6cnmmiZPjz2zmpp2ebdklW3p9zBlrEeuVVrpjnZDTn1dIDbB1iNr5XiMQ3wJcMGfgOGekNFsWZgJEy9XEEMAcEQYtkRGCZlE9HFgj/0PEEAf1pJUDCPnkTr9s8fH4MvSUS6MnZ75987FLccuHFp+MCGFEjAH7w2u8ejmfxRFOri/Afk/Y3mywGXfYjDfYDjts4lOwDDp+YUApAwRaOloQkDOQkmZz8nFV0olZygu8FWp/kQc2FbN5RPX53ALI3A4jYkhhpAWeKsg5YZ5mzGnGNE0APIhLCRQAVX0+BEKMQ9P3pSeULHXuZt/5cW4GWk8vsK32f7HgQSfpL0rriGG6OM2gfAmH9L/XdoGTY/r//fMCtyFpdZ3u+mRZIOFBGp6TVQyHJnhpdjBpySkOyLlvOy1sVT3bMWwlLFCMKClgngtK8Uw8Km7blQwkZAABcQjYbDZISUk0213RzB9WbodDAHHS+VHxALJ+6AhLsAzWlOE4tPePlyJa45a9Lert8+81q4weN03TwvZ2DHQYIkIkFNHA1R5nDpadt/cVjOOIGCNyyZBSMG5GbDabajOLKPFlmgqOR0LqAkpIFGfJOWuJpo7Q0pNM+jnggTVr/PStcgGjPIdz97huoCXe3mOULn1bNChsGdRarxVCJS5tzC+h3zWfhvs/StEMMcz6bgzDYJgbkJNiVL5g+npUs8jCcWP1W8VoexBp5qbPa69c5VSuhJmrXOUqV7nKVUxy0QhkV5aKEwWgTqoiYiU2uiSdIpBcTEnX75QhnswYOp9pRkwDWuuArtyT+3eqQ0MzNJSsdXKd8JJzqcqWSEGaZ4t2UUUvBEIxhrYzoV1p651XS/KBGn4agUFWcoBOEQkAnrtA03264+s0sl27ShZEB1fMPfuI94Wek01pFxwOE4gmlAJsv/kLlNsjDrjHwwNhHCOOP/wQ94839owZu2/PGMcBac6YZ013qo4fbfGpJe+GTG/M2T8CaC1aO9LBMZMigpyyOTtZmd1WosZrsgpcSafqBJc+5bDV8NC6o9qHa2W9OtzN+F0SZlxxPg/yrckmflJzFuFkLqwNjDam52Gut4l06NUlg3vdRk+HK9Lq/urhZRGFUTMsoM2//rn7d3BN2CCi+k5c4oucI5L4mKKbs/2xvXHVG2bEzSncOgT1d09v2t9bjbGw6LdLbesBWkAwGzDTi2Zj4EXf9CQpsnXJy5P55VIqFlnJ1fhb3huVGLBwMdXDtE4yGSAEMMYiIMkACmZLcwyasd/fY54OENmdtP+rEgcDnUDh7e+hJn+UjEdQFITNgDyJpg4WAjiAIcgrEGAd4bL+AQBhRirAlATb7WCZZcjKPCVwKBCZkOd7HOZP8Pr1p3jxl99AmUOd/mzrKEMw32+sBJi2vEAqOcxyRWF/fETMR8S4gciMF5/8HDlndfqEETlPkMJg2mpEViIMvDMWIZCevsTD7m9BQdfigRQADIiIFDVL2ThqaTjNb68gVdC1MCVNZ7w/FFBg7I+4EKW6BGsFwP7VE/zwz3+3YlEijN2zPZ7+7s9xM2yQJsFEAkhGmgo4DEjHPYbtDTDd4ad/vwWk4CA/QXzyiHHcgkPE46t77F8/gLcbfPjf3mI3jDjiG3g4PGB/PwHIGOJW38vCGOMWkTPSPCNNE8Yhaspjm9fauNI9k8+q/v0HeqJf/+70r5l4hrTuXCYv8WOgLxFQqJZlW65NDbTTe+m73IgguhdrNJS90N0+of8t11s/tl8//H4ODom0LHf+OXPQTM81c5WXmXTAyt61LPWN9NGvJAfqSD0c4JGTKSn4KBCNDndSS2QtE0eiWVVEo4shqBFgIeixuWgphT4bX9UNux+XkhOkWIp24arfhdBSWfdgfCVO2jwR62D/zvsrJc+y1iLGlNQj1iFiOkEDYP1ezKqwuB7ri1jNcmMgOfFyf2lAtZXNst5/GxjZ6xNt4r6dALP4rnenrPWW1TXa542ISt2mU/c1P6cnkNU26z/MwDgO4BCbzgtSkHyWkyjyq/zzFF9j1qQZ3Uu/OmckgK5M6duP/SzXvcqXLyIZTITb3XMcjw84HhMeaQ8aB4xEKPuAXK5Oi1+2bDYF/92fvAKNwMevMvZpBA2Ex32CYDASrGWVgJb5mOaEkmcAjM0Y6l5/KUjBpbd0zu2NFx1uRW1Yht4TTEAI2OQR43aASNCMekPEb/9Rwbe/N+PTjzP+4a8vu25+748mPHl2wGHaY54fMWwC/vFvPsDrT95sQ61c1Vbdhd5wzPIzgmm5lczSa+rddbHc298kbmv1lkAlzXRH9LZZQ1tOr1N/J8Y4fg00qn6n2Y0TpKiD233bhIAYRzAPqgMVAc8ZN7xBCREIESBGKQlCG/zWHxfMv3uPVx9n/Ogvb9/pGb+o9M/Wf+Y27KVjLl3r3Y65jP68630Igme/ccTXfzNjt9th9/x7IAKe5AnzvMfxcED+/R9jHAoefvYeXv74a4sn2X7wC9x+6zV2t7d48v7vYBy3GMMWQxjBNEKrY7E6kcMAEGFOBZIN42PGMDKKqO1SRN/LlBMAzy7S7DG1J+b6u5NLVIemqhfy4v2X1h+mz5ei5IRpPhp+pRmxlZCwMTL9pBlYF7p802lblmrXxQVaA6YRaxY4nRBgGXQIDM/y2/CfYLiaZSavmI/aI32510r2P5kBl3GpHk9cBwFKxdSl092D/ShZx7PXaHBFR+yRApRsQaMEkWTYEqMQATmhFIKXEPcYAm9XzooHByt7W3LGOIwYbiMO+0e1WQtpVo8yKwEiCIZBbd1iZX8DWEtpjzsMwwaCgpQOyOkAGrcgAQ77IwBgGEYMFBDjgN1uNMKEEmq0DWqvaRCo95NlQ63Yaetvota/Tury/nUiSh8wk3PGw8MDDoeDBTNpSanjdAABiMNgBA+dL4oQ6TzIJSEfZ8wpYZ6P4Ee1h3POOB6P1QfBrFjqPCXkoliFBn6USiRx/0NPMvHPjsdjfY55nmuWJSfwnMOn+7Wl32P997fhpp6Jf73XO7lriYsuMWW1u5Vg5eOl71JWglFOyDlpkFge67gqESrX4CcRtvVhwvEw2+ca/BOHCDAwHQ943D+ov4EJwf05Zssr0ZUwTUdMFmh8lS9HroSZq1zlKle5ylVMOCjhoYhAUgKVZjB1LqqFB6tGu3fljdRJ9BYTlDwSGFWRXzpR7Qs4QCMgFI2GyQmbzYhhGHA4HE+c77IiW3Cn5PUKYG/ULFncBJjRsogKt6iPPtVf32YtM9QiqL1feulLQTRFfv3sglJiNZxEipFeHrHZZMhuD8kHlHIDogHzfou9gUKbIWP3myOGAKSgGXCKZEuzSZXcszRGL2TXMOXWTV9ij+5oxh4RVRDdnXYc1NHtxAEy55ODau6Moo5Y4P9pJLhmO1j38cIZBSzGEEyLPvTjeuN0NQEX1+7v1Rsa/XelNELPOTnbh1WU7HO+LeflNFqlwWPNcDplca0NpL4PzhFm9Jg3tHyVGQFwXogsEKlzfdn/re+NGkY+F/r+kPpcy/uXUhD4MmFm7bzsf0pJZ9t1qc8aWWZxlxrxpWQbAcCLd5vI10Kpz1Gv6f+Q/+4OS/LASkgpmI5HPDw8YJofMU0HhKBGvLbglydSB7W6WbvvVHLZA6RlUSgJwDoXNNOWR6vZ2Ssje70WexSROs/1fp7VowBGVNQMM0USihxRyh45HXH/8Q3yYbBWkhXPITvFHX1USTNigHjx70oGSJ3Fada9RUTXOmYtNUWwutdEgJdmchAtZGB3D3DAVoZW1iUEjEEjNOes5aVAunwQAUP0DGdAyYLjPAFBy4WXdxztPEU8/OLZYoSGoYDooKBTCeBUEFkQtxEQQs5KIJ0fMvYvNJInflAQxgwpjJIK5mkPIsJuFMQngJQDeAYCIshqoPs6mVNuRFRRJ1rgoORRc8SLZHe/+otiDfbyZv3co0pwqO6FxZ5tJziprpbJoTrniHT8sALRRJou0a8xTgipabn7+QmNQitVF+rn9XrdOL8+9aQZj+yq629BJdrqm8cWfeXPoiUPnMAgKFqvXnQNIkLXVq8x7qCUEiRArQSVRv9pdjpd07SfU84YLFKLWf/OJb+bI0FalKOmjy7WluYkYvbo0WWfecRqD4KvswKFoMCb3sv7nSEl13kCe5c9a42NkPYDhS6zWRurYmnePQuPAJX03QgvBsIvXFPtufvnWf/ubVjLm8gy/fHvTpah9rNui79HZz1+dg1qf3v5DQ4DAgfEEHQPreyJq/xLENfIzpFm6J3dvpeue5V/DhKYMMQBQlsETkhZMM0TxkgYh4hSRohcLs18la9GiAS3z+4xyQYvHzPuDxlCEdNcAC7VxoY5SkvJgCQQzMF4JjhhQZJZ2IGEc7qP6zj9d73eIwBC3VcFkhVfORJppjQOGIcRFAbcfW3G3XsEQQb++nLKoqdfZ7z3IeN4BFIuSOUBYXgOYLdYd85uhW/89tLx/Vm99Wd9sCC7LC2qS9LBMifn+/Uvn9f92xMPF+QfAmNrmE0Bc0agAgpaXqukgtlK1kTegilACoGkYCDWIAIQckeUADPu3mPgeQBE8KM3PN+79MFnkQ5+WH3+2Ukzb7rH8l8sfqfV3+9yve0d4b1vB+y2GwR+onZgmZHyEcPmEVP5CBRe4fBqA+C9xR2G24Qn35hw9+w5duPXEXmLQAMYEZAAClmJp8TIYuQDZ02YTeOYa6m2hDvwG/mkf8/nee5sdc8O0YKb+nF1fC/ECJCVki1aVv3x8REpqyPbbRUn57GVBOqd/ZVMYKQIv1evgYjdU0pZDEoNKuA2SmoGCUphsy1CJc+7+sysZLIFpnzydjc51a3beteOWWKWy3VRMVUP3Fhmgk4LbF1qppaGC/r9yQLStKSWZoEhw1KC2YZU2+LPa+WWima83YwbSBGkNNdxSGXWAIzCiJHgGN48JwgCPNN7YAYHAqGAJCOMims93D+AOWIcgWAlALfbjQVzajlnt6Vb8KvvH22UPROP2/v+WT1ihZeKyAKr77HPpDWkK1nE+0TLQ1FnR0olfbh9W0pqhA87P4RhMUYVG4Vi4ptxg91uZyQSz0pzgfjSvXshhJqlZb/f17JlHkzSz6v1e9sTtda48zkcenkt1PdDM+ovbU4zCep7SL6elA6Dodjh+AKiuQZ6avt9TdU3Woq+57loAI/a6DNSniEo2O/3mOep6hWly2zrpckCBy3rdbU0vlS5EmaucpWrXOUqV6lCZlBBDR10ijXUaQNTntyrTAbG90pZczqfB13MJ6pGLamjooiARDCMozlcO/BfxNjaGZ4uvzdTVTlsGSNEpKb7IwAchhPgZk0i6COlyfqAu/SZFx3z7oT169S0padK66WSDWsnvyuqawKIl2aSok7JwIwhBsQnj6DHgHwckYWQXj0BOIHGA4YhY56BZBETSsBxJ0ozPlzhbSIV2OqgscWYAGqkhT69MzHEUyYGuDWIaj+oJuzusQWQ4XPJ586a+HKZWd/PByzO8bGrxy6IDKckm0tklnPG79uOW7RHTzxp25vOaffz45bHL8pUGSiyvtYp6WYJXDbD/Hw7zpWoqte2+51zn5wrv8PMixTtCxC2e4eWz750cnr7LwG4/bFEyzrHl8Z5CfgayHLmeddt7u8PcgP+1Lnu64mDQf6Zr381o0NOOBz2OM73OL4eEbHF9Hhzcr+vUk4hXljLl/8//lwJGHFDCE8yCmsmgvVc6kkx699PCIx+V1KQT0uz+DwqEMkAJRxfAy9/MeKwf4KyimD2Vheo46CsSDPFnoDtO4/6kZLxuN9jGBwA0vdNs1pYimFf08hTvyqVhshIiGhQVmBgrARULZMSyEhzEAxxBESzsRVoxqECQdgUjM8nqFOj2HMnpImR7u+69fh03AhAmiJef3SH/TCi5Ih5EnAouPsaULL2eZozpnyP8U7LL45bRqGAPBcQE7IkDCFCUsJ+eoQcLV07M4YQUWBlpTIw5QmEiDBswENAKcHWKwVhQbpvE2kEkL7pxfphuXeGFVEC0DFgMrKIg6LFs8wAJNLNTSdoLteGxcR2jN/BY59rxUg0Xec2MKgRLDRqsaGyl9byS+tL/ZyAXLJGDkrb8xpYrCPaUnEr4FlEAcl+aSJq74xnulHwVckmU0paENz2+Fyj23TtDiEgz76HOnil9+8zvfXP2utaC13HxqwHqcXe4wbuLnd9/Vy6+6v0tdfneTk467bodVpZpdZnq9vZHHBijK47ouRwe+nJ9Vv4ULc5tn7efg89lTZ/+nafHLX+TM5/d+73pgtXxWlx7zqefmynu6sDxb9thxP7/Gklq4gYN08J3/huAZeEj346IOfLetBV/umL6+tKmlGHFaNPtEndv6fnEs7vVZ+/LZ/v26t8NUKk5QGlMAixBqYQARwiGFs8/7rg9paRE+NHP0i/6ib/i5AigpcPMygFvH5MeDwmEG9RJKPkrHoBB6jjOAMlg1AQuMNozthhZ/cf4Oze6E5u6pze6I5T4U6vEeQikJTBqWhWR9YMJ1JUD98+KfjguweUYmVAHUswcv2wHQEKGMaAKIT7hyPOr05vl6X1c/mYc59dWo36z998bb27rD7p3fWuSfekkHbsyk4nwe3TjJunBRwHXcMzAUK2pps9JoRUBJwts4NYgV0RsAgGBkAFUtw263RRYgTeYLdjPP/GHkSC+082mI9dcNkbn/nzy6Wx6vvni1x7+S/O/v6mu9w+nbC9mzFnAnEEgXH7fMAQRxBtAcSqczILxo3g9slTPOxfVpJ5L0QBMW6xGW4Rww4kI6QE5MLQsuQDwBqkUaRUvZuD6uLFiCVSileZh1rMntFY7Y+W1diDAFXnTilZBo9WbkcxjiWG49mzc86VmPf4mBBiyzx+Gqygf+esGahqNl8j4DelwnAa+63eVxo+XO0DtBLRLZjRM4xbppyaWad/hlKfW8/uyfi9Pt7PAEM2V+vluVK2fg2mtg66XeUZRZbYcbs/s+rvvU3l+2+WgpyTvsMKwtY2qVnmtkOH29u9QogYxy2IWLNPhYRQPAO1wMl3IppZPOWDko6ILVNRG3uQIIVQ+0TJE0qqCTFYcEXDgULA4m+xcaMZ6DF12JytOGC3Z61t8R7/6/tcoJlVc7c/OebuNl2MESKCaZq6zPDFMsO3Pc0zwNR+6Z4L0CCEm5ubOqZ+rf5e6J/Hrun392z6jg30trc/j2IT63l5/u9Taf6ac/gFCN3z1IvWwDGdj0ss4Jy+oO1X7Mz/J+g+hJo5ynxKhmPknDEdj5jShHmaNKi70ydKKRrIxqxz294dbW/be67yxeRKmLnKVa5ylatcxWROMw5HLWGyjLZWBYaFIbw0+xVzFzOMTkvpVCWoU/LcqZKlWDYSLQVFRNi4odARcFQx1xSU4zhiHKM57LIpZo2V78ojsAR5esesRzv04FCv5Kkx0peNcaWwOWX0Xm67abYVdAbVOZJCrxD3fcQcTs6ryntxp0yoRoIIEIg0iKgQth/+DIdpxvSzb+CYCeXvPgSB8OQ7P8fmm3vMgZBI0yY6zKF9EuvYqPRtMOATUtna2QzS5vRjc4sqmF4NN5hbVLrnd3Vezvh0FnOl1RU++fZM3zWHUZOetNCft5Tm2O/H/pzz82QenQma7M87IV+Rx+QuQcNLRI/+vkqm6NvfMiW0/lCne8nl5DprA31NZOn7tG93f+y6vX7tpWNRFtfrz1lmVeiIZuu58f+z925LkiTJldhRu7hHZFZVd3VPz0xPYzEDgAsuiBWKENxdEfKBwq/lK4UvfKBQZD+AL5QVcndALDCCAdAzfa1bZkS4u5kpH1TVzNwjMqv6NpgFwlqqMzPCr+bmZqpHjx6th1s7WpJBIIDCmeP7wLO26/Qm10nnY+Shfm+yvNsxIICOeexWA7sUhtfgbK8u1c8fBs7YKawslPdGOBOHHSyqB1/97cc4fP0E697Qa7frxuX2XcNH7aoZfSVgAioZ4cu//BAA8PSnC/7gf5jB2SMnICnQ1j97Kz1n48B+t2crIICBBhKezlrCiEyumDPYzSAkfP1rj1//h+cAnnch/v76m2KEBfoA1PJMCh+BwPBhANGCw+mEly9eIPobhDrPMwiSYQmBhkHQOudVMUX+xyVXn987jxCA4OWswVnJHAcujOg8iDVrTqWXb292WFLC8FEBfXQAuQwfZoS4IOc3uPsi4uUvn7bgxAPP7vj6Vso0dZ89/fCIZx98ieAD8pLBmRF2E5784adAJlEfI5IsU+fgnQS/yjIhLwU+m/qGyHtLeZ+EGAgzFTgqQkCClOGTtzuBeYERfirIVVjr3suaBmYFrjLgZV23TEgB2RiwsVMYnJP8hL7rddnlqognI0DIeRL0d1D5GzArSOvNvkAjwtS1XrKdLDmeqK3HuYjU8ppEImtqD3z1ZA8iquBXBa/ZIeVF349u5BYrjQQdt43QQ05BT4ogsnsVMFmQ70as6YHHCh5RD5jLG+C8Arbjrq7L0kceRKGC40BbD3o7i4ia/DUp+Kylx5yuXUaSbMB4A/0ARko2X/TA6tpurLae2pxG+JFrlW2d83XOrdlmmzWsjg42Qog+eTKQTtctBSCd8zBtH7N9toTI7bppjWzwdK0HSOt2G3CxiidtAMftmt1+d2qLNYUh/VLnQFvbjNCM+jssDKf3ltMi829meMdACLjZRxAl/OTnGX/484JheoP/439/juPhhwqBXdvvS7M3RkqOmG0g5EfXbdNsBNrs+23P+a7bPLz1d7WDru3xVnIWe4I8QAExBoQhgAJJmQk34I/+6wU//Tjg/mXA//q/XAkzv4vGDNydGOl0xGEG2EqDOlNgMOqFBsQl0iT2q5K7qfNbgMtBOAs8ml1TNhiHrSlbDEQPoElSxbx+IRCzr75ezow5ZTgS/+/JB8C//p+AtMxCmgErKXjA4EdwFlJ7CCNyKbi5nbT81MONuv9bz4ixqpjGaruuj+u2+ndV02vf90d/17noIfueN5/Zufrr1QtZXazt89EvjvjDP58wL+/Bu6xc9iIEdLsbAjhlIBUxwXOWyrPkQCgoZYHS+8Wf0VEiZdc8gBFPnmX8y3/zGo4S/r//60O8/OwfO2jZP5XzTy/50qvnemG/S9/w5hz9Xz/+F3f45M9e4fU0IAy3cDQi+hHB3wAcsChBSeA8eRb7mz3uD4xc0oVrtJfWARwAdiiZpAwtSI6hZYpcVUwEgCyTA8nVet98FVGaKdU/aDZtwz5LEaXr0+mEnBct25NrX/iqQK3zQZbz5ZSq35Nzwbgbpc+4QFJOHE7HGYUZ3guhSBQ2zQfwCKqyKYmTZYXN9N1Cm3+reY4NnwGErGdKJoZi2r1nVf22pMX+mZ/jg62fqH69In50898ZkcD5iv+K3+YrXmLHMVxJlEe1L13zXwEWYhVxxchsbg1xgxMKwCLPlGSsOKf+nt6DqKDIswbL3855pCWjVDKOA5xDSguGYYD34s/OadaS1g4gr8QT8WeX5QQixjAMWJYJi6rFG/YlJEtR/A0xIMaoyRILpmlShZFFkl10TDvFznJaK2a3vjvHJ+uaBvG9Jcmk+bTMjHEcMY6iwGvqMlKCaekS3CSB194xa+KHomI+RqghIizLUgk4Nj5ijPpuLRU3GEd5R6ZpqtunlFbH28YYtqpM9t1DWPhqTT/DOmwimnUAACAASURBVNc46nY/5wNClHJ9lpzsvZc4ETnE2K7R3v0K62i8qJ6aTSmdKnZoLeeEZZmxLBNySvB+lP5nEoJWzmDnVLlZ3j8qBE8eDms/+9q+fbsSZq7t2q7t2q7t2rQNww7juG/Zxwqor40YM85YHR5GcB4ppSq3J0GgsAJbagBfD8EasDHDcr+/qQYys0j2mRHpvMOT3RMM0UvYsmS4Ggi3IIxI/s/zovtLmY55mpEpr5yX7T8LaK0MRTCYExoRxBwuhnMBhRPSnFeMb3PYgPOyTdJn5SxYYg5b4x50GfbaWQRC8BZxBJgSuCTcvz7h7vUBJSdM0y1q2I9URyEC+70HI6AUYJ4LcsEmDN45fpaZX+1VUtCrOcUWeKmBKWiGIblaw7h3ti0Add62zubj7W0s+XrpF851OaC1vrZLoN4lZ4tRKjFle31OEIjqpLyd2f/oHYHRSGv1Uxu3ZS23aXKuyuFYvXuXHKE1cYaqMkF/31vHq//uba3Poli3x/cXB7gBIjU4iYxapb27lh7c2c43WwLUJWexL01lJDhwQa7ASn/fpEHgrp61gRP1b6GkCaGvvzaTG5ZjChmuiBQ5S2ZPcAHBe8CFCgpcar+rMKXBSFbmSCGhNcjMGSXdATwi+AgKARkOmQhO5zsBXNxqXBlpxlQMrJ56UEWWlAqGYazjwVEGeUYqk4bv4gNXbJmZW0nu9n/VOAEIWBbGqy9f49VLyeaL+wJRlVFQkr2q2BSZV6nAOVWlsCmZBITKWv5rGDzGwYN5QZoXOL9D8AM8kfZnVjARCESAdxiiQ9R6zCEEuEAgWnBz4wH6EF+ngpe138/nuDXguwaCmYGUGPN8wjILEDiMOwQfEJ3DNB2xlAWIhOEmAi4J2SdnpOOM+TBhXjKKm0DOozCQloIQB+xvnJJgJJt3HD1Kzlo6cYajjMILcl507NPqvbD1r5TUzast48n7WEGxfr6zfWUbv3r3DdAn8o0woz0jc6Ocw+YYA8vaP+mznPt3muu4smNZmSDSkj+2zLSxfU447J+S96TlmBSo5aL3HaSMkJPShmkReycEBxdUFpvRzZFync0mavNbVuUU7sC03bgTaeO8KBHHiEMZpWgfO6fAKJ1luFk/m40jQK6QnqQEHkudObR1Uew6AvPS9YXakK7ZGTZGGuhNqz6tsw8Rcl5AhKo6KM/b6sL7roxfe9b2PImcAp9e5znSrGnI9TOk35i7+YT12I891+4Jdy/lQwHHS9+TO992e97+cxnzVO91+93Z8c1ereC+g1Mw8zQdwXOCdwkxjMAwYjeOiD7CEwHIOJQTmNfXeG3/dJutJ/3K6ogrcaa3B7iGDt81t/9dQ8m/i6Nc2zdpRNB16gbPnj3B4XSH03IAgxHdHjlFRH+D3355wlef3+OyzXZt33fLBfjs6wVhcIjDDZx3eHN/j2EYEKOu2UWCnwwGSNQP2ek6omtw3x7yibnaUufrIKGtWb2f1lQNGMlMBSKQbwTXkguSlvuEc+C6fu3gQoAjsTNMyW5aIhwiAhyACY4OuLm5XeEw53d1uW1JKKQ3qhoaug0qSabtt7a7t+fcbvuwZ7zpe/Cj89vqO+KzczOAaWEcJlEFuLu7g3DYtf9IfJeiwXjAw8EjzxNqkVvP8CEjsdjXIC9qKSShtJIZxXnE8Ay3+xuUNMHROU7yrvP01p/5tm3bz1tf0D7dnoM3Px/arv+OLvxFAI5HYDru8f6zPwD5EVwcuARw9qh0MVfgKAE4YU53uDu8wN3955jn4fxelIyS5gXjWCBiI6oIzgCQK15iyt1Vf0LJIXIYOc48L5iXBVZcae0Lyb9pmnA6nTBNE1JKq4D9Fp8CAC5C4ii5ke3FnncYh7GWSI0xgov4/kMckVPCYT4ip4IhjhiGQVU5kiRqMIM07UWSMZQEAvERvJMRn5Kq31Dzl50DWJU4UTFQU+HJAET1IgSPWnzyAt61td371lWSX/XJpQStSjhUMIIhZMWU8mq+XBYjBwqRgrkgzwusZJFzBFeFXGQW8t5IIAAu4IibOwKRkxJLBdiNI4IfMGORfpLMTOS8YJ6PyCXB+4gwjIiDlF9mZICEaOe8KIN4IozjDre3N7i/f6MlmCYsy4Q3b14LKQkO+/0thmEEo2Cep4r7A8Dt7S2GYdD4gpBGbEw8ffoUy7LUkk+mKGLYa5+YZVihrS9ZiV7Sf5ZoUASHULwn54RpOgIAbm52cM7hcBBlJRBAziFoxxvJquEUUt5YsAmPeZ5XpB8iwm63WxFnhmGoiTXWB6fTqW5vcYpeXcbIKn2zBBfz8y7FHFb4aMVELoyMbr1fYeRIGHYDbm/3AIBPP/0U3nmMuxExDjI/6DxUuIAzAVkwBiJC8AHOBcQo+MwKT63xJ8aSZoAKdkNEDlr2C+Zn6HuYhVhodkjU8lgxXGke31e79uS1Xdu1Xdu1XZu2ash3wfSSVV+EmuSjBCsyUmYNxKxVL3pJSTNKG6sbmqlIKEyA1iwdxgHDMECMHq1RCVYnSerhGshPTiQLSy445VnqqzKQ84K0ZIzjCJOULAwMYW04A6hZy3af20CcBMLVaTI+iTojQgyyLHMyL/YiRPxYQKUes8ZnaGW49v1prXAR5ZasQaswIKeM8OQr3L6XsB+f4su/+RAledx99hTp5Q4eM9xH/y9AR3Wo6GELuQuJ6xXCkVPQpik3kD5INkiGOsiATQGgA5c62P2hcxNKdfi+SatBMetPrA39y02ICqXWxaWz/S45uY88SoE+LoAIjfz0zZo5Npfu4ZLT3gN622voj9nv/9jx+30ubfNNbqkF6d7Sh0QQIei1UovNIY9lkTwGZJyfA51z1hOIACEqnSMfdv6albVSGnA1OwkApDRNf212XnWqYfhGQU5FVbUIPgA3T4YzJ/fBe+l+vwTWvu27tz1DgUra3q5mXtpnGSgzHHtRIHGEQpK9xK4pf/XAdf+ZgRWBHHyIcD7Ask9kO+s/1nMnm24evI8zgLpTmQGA+Dzh/T89YVkKDniD+zdHpKXo+tOVrIPNbxaQdpLUhwLvRaWkSlI7AqtSRi4FS1oAJi0NlaQ+M2VRYCGCU6CLnChm7HceRVVnQBkEIASHkmRMlWULqJ8HJy49SwZwejPiN//xx0AmhA++wO5ZRnQefogYvKi75bzABYdhcFjSQbMFC/ywYHCM05ywFKCQAzspvcScapYVWGpHExhpmTHPJ+Q8CWkoTwBkjebSSGqo76G8B6vnVqSfC7NI/+pz6KWQjZwmGVdN1tq2McLMJZWR7e/r9R91fW+2QO72kX/NltAxonNTD8xt56M2fzW5dAG218S94AMkA5JQUoGRepihJLt+Tja1kP5Eus6yAUtWv176aIgDOIqiFZeCzDMIXR+clb5s7+123WiAZPc3FByDXYYQtWTdNYuA5fqIKtjLTJrx2NRSUjLwuif6tv63e5Jr9DVQ1xNsbJ9+7WEdaKUwMqgr0yS72RBtmfDfPSy/DURsv+ttwdXnb/ld7lPLjNnfapPZZiQ7aX/rGkQ2l2vfdLLvZusus8xl7AvYESg6/Lf/9iv86DbiV7/a4z/9csC1/dNvZgs0K0btGrQgpPlK9e+3HO/S7w9vdW2/T80RIXiP4vYSIAsBJTEyL8hlgPd7ZA4oOWJ8OuNP/91rgGf8w189w/3Lbz5nnNl1P3B7aOz+Po3IYSj413/xAvsnO7Db4c0h4+9/86XUBFUyA5g1kGxlTSUI2mwOh6IlPki3Bx7wI7b+Lcv/iNq7fsm/2u4nqn6yNomeHEG5GWpDZ7UtQ7WvLBhZWG10SlqS04GhiUHsQEgwRcKH7qO1y3PUCuvoPrNbNrLM41SW/izv+v2l69l69tvv2jE6lAVxKPiT//4FistwQ8HpFECUkGdWPwRiKzvUYLTZn6ylVLmUOl5SSlgywLxACDOiQujU9/XOwyEixh3gHYhOMBKC9du7tu/3HbOnefkM23P13zz8XWuX5yX566NfvMDzjxeE8AzB38BRRCZCgWsjjEW5dMknHKcXmKZXyHzAfgecBodtYTHvHYInlLSAY9JaS4qfARBrVhRTiE0tUQ1LNsw2o+SEnDKWJSHlrHOA2qYV15Qf0zxhWWaktCBpuZ96p9wUXPSDev+5yJ3akUJYq8ua6mSMETFGLCAQnc7xJiUhmIqouAtqL3dqk93mK//l7HjMADVfzvCmSkzw4o/LcY2YYtjAQxjl2i+65Gue+YNFRpnMcYqLOA9yNn9m9GoczhEk18ZUOtq8yJDkraLzbvC0nh1WD2nTHWAw90rOSRXjTdkUSsqR85aSwSXBDzvFeVsSkakU5ZKQl7kSWESFxCnJkSUBxEWM44jdbgfvHV7lhMPhHgBQygjngBgHhOAxjoMQImJAzhnjKMQZEFZrTp9IM45jJZ/02KGUZC4r3L3H9qZpqvsALQGyJloQNNEnbyBrTYBzATGOGIYIB8IyN6UYeY4NHwhK7DBM0dRUl2VZJR4+7Ps1v1KqG1E9R1X1t3n9Aq5dnc4H2iX8l4uou9j9TNOEm5ubDuPkuqZIkvEaAxSirhA4BW/p8dumdLVSr4GMrVzs/bJ9qjci9wonuW6/T4baf+HtSpi5tmu7tmu7tmvTJlnO54Y96+cWAIUGBU2SU5zrZvD0wadtE7DexPII5CWzXkotDZVpnIzM4kiP7VrQxzmEELEUIcgsSQzMkk0OUSQaCwO7cY/dEGqWgpUYuESoWBuFTS0CMF9THYNiRm/LSIdlG/H6WL0Bv23VicK58Wv7XcqolxITUiOW4IVd7xPi7jXiLuHZJwX7cY/jixscP7/FSLcI+BPsS8IpfoV5fKHX3p/v7EnpfVvtYOkLZu4y0Ki6jupaAp2j3W5Ly/fwQwCTAVFbYdvNFT1ChrDn05NMHiNQsIEHwGr7t7WeKrBtW6WTt13zW8+1Oc6jGT1silBroGDb+n5ZvwNr0lu//WOEr8fa9t0ycthj8KE5XOd4CdWfl0g/l897/kwfIgmtMig6ss52mx4APr+/Vp+YmatqlZ55e6cAhIQIZpSUkWjG4gHvd/jgkzfYv/cS033Ay9/86MH+2h5xdb2PfNd//rana4Ey24Mqg5Aw3UV88ZfPwRzw/BMHPxCS7tWDYn2/22f1OydlgEIcQCFIVhoXST2tF6hAX15QyruQiS7BoxrEG4D4YcLpzRH3L+4xTQmOBODYzlGkQBMr7GdBZx+iZgMVVdUQAE9UOhhpEdKEDwHeQcrVaE86DS5wkXKDTITdPqAwI+WEXKT+vPeE0+mEtEyY7gH3/gsFIETJQ1iTSt7RfhRUy2mJnAhTKyk+gh1wsw/Y7UcBaYhwexux293ixW9vcffrAWnwSPkJjlrvnouUWMrJ1D+UnMCiZoVcwONL8P6VAFCFkdKs4OoJOc+iPuNYwVp7FlTrVDNLv/oQKqbXyrdBt3N1RTJihgEzomYjxxJwLdZ1uZ837OfjBFZ7z3XM6aZtPwMq2/tQd8RawQ5Y165fAalkmXClAz+lf6FgkXcOIhvdEX8ISJoJ3ANhZhcwy7gqxKIIUqdcAllxoVIQooejgFIy0jKv3kedAUE4l33ezrdrcrQDcankJelLu68C76HqQhmNTMuq9KIE5YLufKY0JsHZdVm+RnTt/7VyRkaW6cMZVPvJnlUpRpgBAgUN4nE1asTeaSSfS+2ibffIdmsi5WaN7664fkfnQbTV+t2B5tWoq0SZnoRt28jvhqHD1ELqsVEB4cQJ04lRCoEHAF6e+UcfA3/6yR7Hw4D/9MuL3XJt/wRbe2vNb+HVW1aHLMw7UP8N7fN2nPXvTOu35op3/343LrJOOu/hiISECYeSFkzLhDg8g6nK+HHBkw/vkOYj3v/4hJ98sgflW/z1L3dvPc8lyxn44cZHN4NuvuHV/Pz7MD6dB37yM0a8SUjI4DcZw11GShFwXssoF8QYlOQh9icIgNoJRFaeA3DlMe9s3cyOqW5d11bEmI3tUJMNyKMQlPTSZpasWE3OHqVE9Us1yK6lB6WEjJQKks8DwB7MTsucEnJKqLJ/b2mX7vkyaQaVLFPOZrGGDVw63kPjhi78tv2+Xcn6m62n//Ef3mH3ZELOgIuE9348YWHGaXaYJqCUBc4F7dOGuRQQivYxiGrZ6aI2AoEAdqpMBDAyqAjRw5E3ox3ZOSBEODj89OcOTz484f51xpe/fvt7/kM1ezJGmtn2Inf/73/7tu/3eDvh/Y9fIrgdfvQJ4emzp4jxGYgjiCIIqGrM0CJXhILXnxE++/sdcgZAT8DlCebX7+nzbf8PjhA9gaiAKINg9rSrx9QiihWXgPo1KKpOsyxSSjWpOiQXFAegUxo2X4hZCAfidxTFZxeQ2pMqEAnbqS9LDWYt9daUvFNKWJalKorb55XM0PlMVQEYdGG097ifkTJMyab5ANWmh+F+NgravGT3Wvd1zlxWmB9o/Hsu5/gU9OlQ3xdYY2Db1vsUVqq8+pCFdQ5MK+ykkhDK2p+U2aEpdEgpY0ZVynkLtsosSqOuKqb0fW++rCQzmA+clXTF3um+cpa0iAJ6WmYs0xEpLbXcra015FjL5/mKAwSNA9zdvalKJCktiHHAzc1elWZEbceO5b2o2bsO8+wJWeM4ythNzWfWO6jPfot39qot1p85Z1V3IQyjqtfPC1ISlVbvTPlFxoFzXhR8wwBwwUlxQSu3Zef03mMYhAhk6k1GmOmT+foSXXZdvdKM+e6JW0kmO4/FO/r1tz+WDt0Hxue6bfvLxqMRZwDUEs3rtV96vSYzAZWMKf3VyD1GCrMxCH0vAWhy1hrZtD43X6NQAVJL4Lm2796uhJlru7Zru7Zru7baNkF0M0SIxNHqjKAKeqjn/VDQ2up4EjmpwalGnCMJ8MUYMYwivekcoXCqATMh5KjRSE1GnjSgtSxZg20q1UeSVR6CrwbzMAxI81GJMmvGtlxfC5z0wTTuHCpYjMGiT4TOANWtWQJ8cu+9saluuskQm/OKFnwl1zIB7Hj9cc6MYyKt22nBQwGOci5Y0hG3H814/sFTvIDD4fMRKAHuq58jwiE9ZZzi13Ietqzq3tHrnIeVFb2BGjYgGReWBGe7J8veIAMruh3Xp7EBIz8IoG9k55qj1J2hI4XY32d7UQ2h6d90/r06y6Dm7LFd5AZO6Z0xAqGVVdj+fLxdIu6sxyrO7tWuVz4/DxT2+7X9106ivMaX3+GHsmP6w6xidbptywxcH+8SFN3ur7SgC7XPz++39YlztHrn2ncN9NwGVmu2hYEBBhZCMxTowv3qtr2SQrv25rTmLvOiV0mpKidsoKsCGRIjR84Z0zRhOhGefjTj2Y9PeP3F/p0JM2f9ie0o/fbb9QBxha6IMR0iTn/9HAzGsw9PiPui2awCnoTga1aZNe8ENHC+lWUS+VpXayALIJQ1yyvBYUHmCTmfwNyyk+msNEgblOfwmnxfmLEsjNev3uB0nEHkEYMHKdGEwLBs2xp0BiRzhzxCDHDBq/pZATHAnCEKGnJOKy/lgxdSaZZ7KTmBiVBSwjzPmDUDa5rvUJQoWhRkJAIOh1NVLHHvFfhlFrJMWQBe4D1LH0cv0RMnyiQEB+dGEA0IfsA47MDs8OTJU1HSYakPDZcwjoCbnuL4d+/pqieEiUwiqqsrBDwIno120Vr4CcM9fwNiKUtUSsCSCGUWEl/wEUxFygNB5LfJ6t2jgSFCCiEtsSPgk6jFhSalnFWlR4m0lolktemFFLuozP856bSO+I6EwLyZD9HP500JpYFsrn5ngI3NMf28uyXYmVVRbYnVGVvLOva52FylWdZEejX2HwC2evUMkNplUDUmaCBD7Ys1PiZrlIOBa0Ez52QOdizzE3c20Wre7NY7A/QIAYCWjqKggJfNe6Ke1IPpVO0ofSalPQt7nm3J8Cs7swbR6htn27XeNbJbtVFhILqZtEUzMpUMrEeSzZv9trWE+vFytkTU/m17bQkya7LM2v6wubiRZc5tFOs3e45M1O61+7zfp/7eJrW63rUr7n5yUVUlxrxkiI3pgAGIYUAYbvH8Rz/F7dMM4NXlTri2f5KtvRlrtRlr3ajWtbSt05deF3E7+Pyzd7JKLm91hcp/N81BbNnoJVu4IGAuhNN0gi+TBI18ANOIjBHH6Q3C06/xow8d6PQh/vqXHz96/Me8pne1b79Ja7PgRQ9l5cv+EOf/Nq1QxLQQ7ucZr+8zMiLIBwi/toAJ8E5LDtYlwtZJKX1gbmFhhnvkXNaqn1o7oOFAq7WyNCUbp+uT+ZtQv9TsFTAjFwCJYQHe4H0t701wQqJngvm5FkqH8+DkIKRdLRNayqPPqq6Rl+5v9ZuqHYPOlGXWM9DauqOzT9/eHr+WS9906zsTPvrkhGcf3WGaGUtxmOYBSw5I2SGlgFQYPsiZDEeTIziwfIGsfV26/hWiNfQzVtsb6imUalstC3BkhvfABz9jPPeML39T8OWv37EDfqCmViW2SjOXnuL293c7dmvjzYKP/6tXGAeHm92H8O4GzDuAA1jHJlgxMhLbPfOM118Cn//npyA8rceis//LKxAcIej7DWQ1lHO9u4rfigCq4Kis72NmUanM+h3Ls005CYa3IayYQkfWUkFC6JCERCfAR+sJ/c6SLRhQ4j9X9ZTT6YScE5x3SLlo6VRflcqdE/XWoglIhjiYy7V9lxsJXuYasmOQqWG37+uzVbzIVF65qsmY72d4bnuygvs8lEDWruoSjnaJIN/2o5VfkHNG4YYhNcJMwbLIMyC2OVvLLTm2k618M0CfFTmQK9056xNr/QH1/bXUk5THntEUf81n11JfxcmYWZTk5CADrusj0rK43gfEKESTlBM8vLyLlDBPE8DAsgxSKrjkmuC6LFKabxhi5+tLf07TCcuSqz9k64SN2VJKTZDtiSjnOCavXmAuBQWttFMlfjDDBRsT3Vhg841tjMqzSklKBnOncNPwQJ111XeW60uqlm9JJPIuOjQSmW0v+Jmr5BQhLDmURdLVQghSkoi0PJZibXYv20TcS+0SDt2rQnsf6twg5R4HVcuxeILgOPK74Dq9Wpy65ReeSUvsMOUlqvGT5svLNZnqk45rkqQc+XehPtq1fat2Jcxc27Vd27Vd27Vp88EjRpE5XOZZA1ckUqvklVGekYs4ZsEFKSPi0EozQUEXBWXEYBKjuQg6Ak8kxJkYsb+50aCYsMnFAMzy+5LAmmktMv0kpS1yxrIsOB6PcE6uWQI5GcyE29tb7Pd7eO8wTRN++/XnlWXtva91QoGWAbWtAwpCzcSSW1HHBlAWPncs/KIkHwsQtWBWz4CXYGCp9rkx6yXYdA7pCBjRPjN8qkI2NUiYQVTgHCNngsvAPJ2QcALGHUpZkDLA7JCxqOFqJ+kMZzCsZm3vQ1itc3MazMGqHQXUa/HObwxx3afbiVxl1lQIksHohCs2XVFhgM2IVeN7BdzZdu15XUarDNzrof0+078Fw6xWOhFA5ZLTK/dqBnrwQSU/Wz+s+6y7ii4g2R+rjr/qhDNaFkoB2Oo4W1AVIJX5te0MGLUA4JrI1e6xd2zarSnExH2fNOd+A1mcdbL3zZExws56XHS/986qlUHrPhPRg6IDowEb7VjteF7BFjvXssz6DuuLTCSKJt0JKoxG8hfBw/kW0Ld+goI+KZlceHvfiQDnHXzwyJpBtajD7J2Hdw7sVfJWu7dAZE3JeXgSh/J0OuHLL4949t6I/c0AHweE3WyXjrx4lOQfDRJtXM/uLh5ulwDlS8cvaIA6d3sygJKykCQ4YBxE6SvGIMohrr1p3oeqmOErYcZJeisKyANJ60kDBaAFmQ843Z8wzxOW2Z9dWwcb19FY3Whe56ZxKZinCa9fvYJzhP0o9anTMgvIRpCsV33vAVHrKHBw0WN/eyMABzc1oZwtE0bqso9DlHegZBxP91LakBlpkdrj80nuZV4WIcl8lqu8sAsBPg7aZx7jsIePEWCPcRilr4vM+eMQpI+9E5ILA0Qeu90NvI/S3y7g5uZG6sXrRMQAXGG8vPscRHe4PzIKnsG+ZbLVx1aFKv5R/7YxsxsG7G+eAdmBKGAZClAcuEhmc4gOKS2YjhNSyogxgJxDzouo6ejaIco4bU4PwePJ0/dXc0dOCSUnATmLZoPlBHKyTuUl47jcgVyEc0MdaxWwdHKNteQPMwoDoKJELgeiAs4W6DGAOCuAY2o+2lMs48s5yxyTebSCfiU3RFLRXputvCcA8p4whPgClp4thVGQ4ZwEjRhyDXXOd6aSInPmnGYBDNHU0hw8PHkQhw5ggoKAphhUAGI4PYeNU6i9ZpndRE3mmouQn1j/OYhNR1pH3spnllyE8MaqRFcY7L0+AyjpiVHKov0l9ptzPXDdsjtLdoBrRCRyqvrEkGcIXtlqaxoMwSTYXZ1MtWSoM3Ind6Oc5Llqf53bGKjXdskeqJdR18seGGxrs81MFQLsSDHN7rFXwmZQrscwIhuTkKjb5raedUdZLwz6bpfeUpIxXYQmJza8Q86EhTRz33mMww5xCHj23ofY7+9xJcz8823c/ez1FSw0VS22C0Pw8WPy5u/zc1767qHPru37b8QRvDiUsiDsAKKEXYygssPd4YDp8Ar7HXDrdghDALkbnFLA/YGQltdwc8Gw+wDjGHE6OKTlW1xD9/t3fe4t7EJnn7VzbPyC7+G836UxgNOpgCPh5asTvn41o+SIIQQEDzgnZZhSSnD6XkogWf3Ootn6FvizKNb2PGd+47qPVoRNDZpDP2dWuwJUMQ/bryjKASX95pzBmcAlqRoKK+F+AJMqyBT1yevaDKAQiJ2WBfUoCfo7bZ5r8xWBt89HhrfYacwe7sLRF/Zov7U7ffwcstUlQsdl361breE8MIwZxB4FI6aZcTglnGaGCwFMAaj/CElVI2F+TtEMf++F1FxsDIjN46R6CUomxfJaz0Cfymt0vgAAIABJREFUmfeEXBJSmnE43GEcB8QxYLffIwaA8cMGLx97B2m1zfr5X0jl+k7nF7s+YLd7D/vxQzj3BIV3AGJVRmUtN0tUQMiYTwtO0wHTqcAUuWzcbEeOvWueCIMLcAyAhWAh7gUJSQEQG7owSlK1bPtbk+y8F8I8symCJBRV/jByW84ZuRTM04yUkmCaQUhsKSUlm8t4KtyXrM4oZYF3QBic0K1JCG339/fYP9mhFIfD64IhRhSKQvogKT8bowdz1ms3VQrWOUzOab0egrznViaIyQgGal1rQk7O0g8ytHWcg1SVXOxcw3FF4dypcojMmzlpOWjXsL1tE+LK+TtsCVktCa09UOfEF3RKOClFyBMAMIRYbfWSGTmlqjRqxxGSI7cx0/lrKJr+QgmUSX0mqmO2t/5TKZhVvdQHj5ubHXCYcZomcPXJ1ir0JROmJPWiyTstnTRimQUHof0e0ylgWWZ4cjgdj5gOJwzjKPcZCmZacHf3BgBQWPxAr2WKbK24u7uvii4xmhLNHVJSQpV3GIZYFYymaZaEpHmqCWxOE3RtvavEv/ooLKmCKvaalIAi2H0GEuFUjuqPmy/eqbzq816WCfN81JiHrIe+kj9dW7sAJQbNmGdTz1Ef3hGC8200kZSkHoZB4xse87wgz5O8cyxxmxAk3iCqNAzvHIYYAWbMWcokg1sSiK1x61kGFSc1X1wSkEdJGPOS3CQEH8KTJ89wc7PHOO4Qo2Bfb16/wTTP6te35BmJ5XgEHxFCFJwkNTJvxb+drDdAU6hu/WyJL15xk/ZKzktCTu0durbv3q6EmWu7tmu7tmu7Nm3LnLBMi7LzPcg1BrUjgo8eCKgBCzGepf6tlYXgokE2ArIGEpkE9GBoiYqgGVAxYn+zh3ceKS1YlhnTdAQAcM5AWTRLgZCXE5AdQozwwSHlGTF6YasHwjBEeD+qM5pxONwhpQWHwwEMyVQ3WUMjN5hz1zsyFQhic67EiiNyVUY1p7kFHquDKMoUpPtWh6kUgLIEhwqp/DAgARnJpGLOl4FfDcQbWiOEDXFzcklArW8rxmbhoio+Ulrg6U++Qnj6GyzLjC8+/wJp9iAX4V2AdwE5M4C8KceAyvy23znL9YplTdXgZv2YyAJVGqbSvjSZzAYx2UHFNelZ7iL3mmt/t/rqxjZvCjvQ/uuPJVAm12ci2eeu3cQD/WsBSBa0AeSgss9dloTeoxE9COe1YOUbG1+qBE0Gf9GD1wBYbeQ1aUsIZmuop/4kIwLZeKOu1AlWzkUfdJTAYwuq9Z81EgwrUQH1vejfk/6fEZssa6LP4im5kb3M4fI+oI4jgm6vwIcSfHIuAtBp9hU0t49LhiMlnkBIc/3YAJt0apGguzm8ml0BYn07xRFdAR7qNNeMSRJwp2azuDYvlFIwzzMEcIoC3xQjVmhAOwQM3iMfD0hLQoZcQywOYRzqc8nZMiAZzhNi8HAZWOYT7u8WcImI+wP++N/8Es4XhAB88auP8fnf/BQPFwbbQoLv3t4F/Lcn4tDGpjncf/v/7EEEvPeRwx/9BZCzBPtNVczeH+/afOYcYYheSAqckMuCZclYOItShQcYJxzevMZf/funmE8fo2z8YOp+bgFqI8v0zTnCbgCGAPjgEJwSUJgRozjwovyaUUBVDadkyeQbRg/vC5yLKju8KAGLBA0tC6bTDHBBTgsOd68xzzNSV9M5608iB+jcG6KQDUIMINcyechpTXEucDSIfD4DII8QbjAMu0pCLPqulew0O1eAjWURILuUjBAF1BqHgNvbp/jyq69wnE+VntnIMm08NHWhBlVaXx8//RGm335Q/y5g8G3A/llGjANAjOAZKEc4WrAbR5SSMfMMR5IhxjofhBDhvBBqnAt4+uw5lsWkqQG3dyh5UUnxGcyz3nSBB8EFj1KcKIfkGUBGyQTLUgpxAKPI/Ky2DZMQJhxsttFHadO2SSIrmCMBHiXJSIq9rjVGmpE+y0qaIQVFG4lR3xwrOaXKRMhCHAo1U07nHM5wuigzEYper81/OUsZg5IXRAVYc8nIqcANDpyLgsNiT5QMxMHDe4KV90opKYlNyHtEDlkffilF5nPN8Avew+vTzlwQvIMDI4E14yxLgIQha1QlKwl5qydO5px1Lna1b9yGdGv2lShOKUGtZBBFXeepTl5U1zLLUReScpfYhgwhzVh2NCp4qQsi6TMlk5un+tUl1bVLqmdyHw2cts/tv8YgaGCgQbZrDqm9d7YP1/Xf1IGER+rO1zV7d7vgZSMGCyHQ+oVZ7VOQrLulAC4DxEiZwfAgN4DYIcAhOIcvvvgKL19OZ+e7tn+erQ8iby1XWq0Y3/0cW4j/2n737e9+NeLTvwOG3Uv8d//zHi7OKLkgYMDNTcR0LIBLWPIRnMR3dzSCy4h5OeLJzUv8+f/4f+Pf/sWf4f/8327xq786J0JbuzRmts//XezXtzV64Pfzz5rWzPdx3m/dGMjskOaE6TQBueB2f4vT4QAqVIm9znlN4pD1IC0L0jSDiCTBA82SJ/VX6/v8iO8KmN/EQqowq1HxEaAFuqt9zoADg7WUqdfPqsiUloVMacE0nXB7e6vVWRngpGtWRpXPgFMsheQjiC/OFLB+ig95RtvZ6ryV+v163nkXf+nxQk3rayJcntcufWZ7PfvREf/q330J556hsMPdPXCcARduACsVQoI3ObN90WwRR0IOFlOIun7k+myN0NSPi/5K2EjRWnh2ygxeJAkvZwJ+YMLMY23b+9s7+L7eXTu+c5LkQC6o3RRBiJIcoEkRTIILzlPCf/j3R8xHh5IMPzlfJ/vfPUXEcIsh3sBRFBIZCXGiAGLgA6omI8mHVdUJABfxQwEgl4IlzVjyInNFKaJw6RqeW1ICMSPo/EFM4JRr4gyxIAKlOHOpVASKQd7BDx6BHDhD1D89wXkGPnsP+e8/wnEo2P35a8SdEDpSOoIWRgyEzB45uVpq1XlgSUKqMH/GQWxwRyTlwBwhqNqHkf69D5jnoz4fmYlSWQBycGz2upWgdepjs5JwXPUzWO3wii2eNe5McHmWVoIZMH+hJbSxvpPRezgnfhtnKSXnvSiEsioaO0jZQ0suZUa1+bkOG7G9PDl4LWFrvlApWqbXHFwFYdj8CEjyZQweMQZkJ4mVXAryosqwhJYwwQBzwbjbK8GFqoIRkatqP7vxRtSMUMCJUZYMN5Amk4pfnnLBPE8AGCEGwY3UHwVDCFuK5cUQK4HD+1ITV0vJmOesRBlJTLIySq76nQU5W7JpSwJpWCeqD0hF+lGIpdLXQYli9iyhY9o7SQThqsDUEkwJDnGIkmzCDfeSMQdVvk+KEXQ4PNTfZyHcmKKq0cViCFjSguM0STmrGCUmkAl5mTGXVlqKOEr5pGWu5FjnFR8uWTAbtnEhfRu8RxwiwIScJRYSxxFDHOC8Kckk7LLD4XDAPDEcSeyjZGCaMpaF4UiwrMwFQrgU4hxDcCyZt5qKD3Opyk85QxOns5bFGuHJi1pz4bpeivsu6GTmGYUUg7i276VdCTPXdm3Xdm3Xdm3arIaoSfcBLaiRUgLnddBcgu3Cml60tqgEkawkEgHkEHzAMIyiBONFbYAdwQePNM9IYKSckJcJJc3gnEXqUaUnCxFOByl5EVT2T7K3E7yy2pkL7u+PKn3YAiC55EqUMYlFa1uZQrtfy1pakSIs81rbuZwhw3lxvvpM374f18CTeThFjeFzMKUnK1hdVSPRxBi0BEZGzgtYHYFSMnJJWOYJKS/SHygIg4ePA4ABTgNN/fGt7Ed/bvvZyte0OA/QARDmrbGCEdaH/jI03ktdVnIHOd2+kTPW12LefnU9z651K+34NqDvodZBhXo9DsZlaU7FujlyoNDKezWyFS4+20ttlbVH5/fZLlADY9VT6LfbBCPr8ey7y9CbfN+ClqvT8fkzMYef9HenxzCc1LkWaCxcgFJquTUjCrD3FUyUmCnBkTpBKuUNLlIKh1ug76yvurvqsxfROcN2H0AjKPWf1eOpg3o6zS3IDQEGAFGAkaDxKKAJcVNEMGlzEkd7GHYIPqkTKOdKqWg2ESEEUQApKtFcCoHZw7sbLHPBi9OEEBkffLCHcwVLXpTk9vbGF357t+3frfUwr/3Mi4CtOc1Y8iukxHDhBjHeIKjaiYw1hZ4oA5iR+QCPAnIFnjOYE0AZYXDwAZiXe5xOX2E5PUE+BbAi6305phZurlDQ6qb6YZ1TwuH+XjJdFERxRAjjWImUjhysRBAgkvG3tzsM44DogTFI3en5OOFw9xp5SVLXXQMSrLXHh+ghZZsyHBhPb2+Rc0HKBUxCIHUKpMjYUcleneOdI4BlTvdgBJ9FVQ0ejiLiMCLEEd5H1FJHhKqCUkrCskw4HmcwClKeEbIHY0EuHl+9+ArzfEIqUoJJus1y+Lj2tb3XAlCim4cZnAklt3JUDOC9957jvT+KGIc9SgE+++wzxDhiNwaMuwFglv5yBKfywz4MYIgC0TDs4MOAzz/7QvpiGEAA0iLgUikERxHjGEFDxul01IwihvcapFHwE6zqb7mAXFYFKlfnZxsxuVjZqK5skCnKqD1RVrXjNUOvMLzOFcsixE+bL1xXu132sTXFRmNHKOmIFoDrlFZkbYcjwKuCi66fRef43W4n86pCSLWEFWdwykJ00NJdIcixhZwmmaPjOAJKBM0KRGXuQSxW5b+M5JyWIZP52UaCEcuyroHo5t2iAPCldYRB9Z574mjNJtN3VPqRqy0i72jYzO+X103bnpSMWQrD+QAfbE2/HEyzmunaDfWa+2dm9mW7hnp3Z2t/U5jp5kIlKFm5KHAPuq9JVv3fbV+A1aauwZauT7bjq/UJ15Dm6vpZ68AzQG6d885wyIiYlgl/86t/wGefE4DdWb9d2z/vdtmeaGvJ5q34Xo7/fQU+r+3dWs4S0AAtONx9hSfv77EfBkQf4ClgDF6IliUJkSYM2O2fyrqVANArgIA3b15jWQYodeLCaLg0Plo5sO2Wv6tx8Ls810MtF8bnn7/GlI6YMwEUkZcjhmjBMFvDmzpbylKeYghR1CKcr29mTwC91M5xj4ZxoMOGxKySRAbUIGRzEO0/8WWhx5TvxMYSeyHnjNevX+F4PCDGQXCkMEh5EVdAJMq05CCBQCuXqySFer31alvCErrPHmsNDfimXtX6GNTNf9tv21h6t7nQEBEC4ILHcDPi9esjppmwLAR2A9gFUYWD2mBcamkpOVNLfgIAlAewE8N+qp20uRa2ZybfM4lNPM0JuTAOh3cp8vXDt4oR4Js/v4fa9mmRkgZSmjEOYttmLbNrTqngaEKYYc6Yp4J5an7repTR2fX6MGKMOzjaYUlQEo6Q4xhCcBHM1ogl0kph5JxwOp1wf3/fbG3FS8mJDwRm8XvUx0g51eu4jFEBFqyWcUmK+0bc3IxwWt5T4GDC7ZOIp8/3SC9H3C0BxSUMo0OI4rcss8PrWfxV7/aA95J36DSdodrhmqi18fulHE5BDAFxkOTBeZ5XCXoAMI6DYjJphQGLGrkQZJraCEELEOrtXvAXiIXJQP1Iq53V3rp+niSGqacTcSUGbJPn6k/F04xEs/IBumuTMZgEZ3EOPkQhmigJg/WaWAkKIuHJklzBGcQFLUnQylEVxSPkeRcuiJZsSZakUrAsCS6ob4YCToLBcwgYxwGO1HerJXUbvivxBynRZaXCAIL3A4AEefyyrlhihaj7UiWySHKeQwhB+oW389raJ6qkkm6t2CYJWktLFh83Z6RZ8IZhGAFGjY+ACMG3abWdF7i52StOINi8ndtKSBk22bAJxQsgBFPBAhKOx3vc3t6CwerPy3ALMUoJtA0OPs+z4MHMdV1tScOq1krd2iggEsgFeB8QNEFoiFGSoPSt8y7CUQAg5bmWOSEn8V+5AMHHmrTlcgbVkk5UsTL7JwRNOzVBlKUkiSqGHZZlASBjQxJa2nuA+uRQz9f75df23dqVMHNt13Zt13Zt16bNq2ShGVRbdYmVokb9XKRcgxEfXABYmPIhSkmEECLGYaz1aEGSeTDEINkOOSOnBTktKGkRoz0nNYolGF+SyI6mJAYrAMzzjP1+X6/N6pRus38lA+G8dmcj/jTFmd4BgQbJKhCggZM+CG+fS5904ZrNObbtLHjxAEjVCBjtZwhawqS0QHwuVkdaVTC4KHlGHGCRaYwgChKU7YCU7bkvXcuKiCAftDHQBYbq8ZzbupO1NSWbdm7nrJRFO3c75jrw8xiodAnQ+7atOVf9GHA1gNifc00kW78337R9m310z7NrWF/f2omzxtxITMznoEivPrS+TijxwYJ4RnIRmVG28mRcdHy263LOASyqDQQBa4hJyGMdCNIC865e58PX0z0HK/vxwLPajvt+35Ila8U5C+Tau9cys9i1cZuzaW60IDypAo3r1G+Qs5SRgdTHrqRC9AFTAbBLyTgtjLkkHA+ihAKK2D9b8OM//gI5Jbz4h48qUeGbtC2c813eFAvQU4WDgenO4fO/3AFZiCVD9Lh9Djz/Y5n/izr+zKrwwBkFCfefDrj7fEBmLxmRnkCOkfKI+7v3wEllWPmR9/+RuWH8yUu4/QwaRFHDHOtGjiCQgsZWK1oADPk7eo8xBkRFQ46HIw73dzgeDwjkkJdFlWgS0jLr9QQBlUgCFkOMSJTho4PzAS4I0SXlgqTAtCePEDyGKHXHCy9wxx3S189B5BB//AJut8C5gCGOCH6Ad1Hkfp3opHjvQa5gWQqmWbIIY/RYvn4P8zRi9kKuOU0E4H3k+/eQV3m0QCELqNdwSi1YsyrLVbdrbXlzi+M/7JB3ER/9CeHNmzs4x/Blj/mzDytQT0RwtzOGn77Gfv8U3g/wQaR6l8Q4TQvAQPDyPAaVeQeXmnWc84wwjJhPJ6mBzhlB31siKeOYtKa1BQ48myoU1fs1Akgry3O+nlxaL23Msa65Ui4LdV606XRNluFac13mI9Lr7bdrxBo1RaT0Zc5AR/pzRPDOVTBV5lNX38lC0JKQro73aZ6wLNNKttiAZpn7RHb8DLhlUQEjWxuxXuvI+aqq0/eXEWaANXG5Ac8WFrC50GwKroBaq4deB57uSRUktqxo6/91kwCdPT2zBU2ZzOrG988bdWysx8NDJJTV37QOgKz36e3Cds/SBWWz/fouzs5NLWDQDFD5tXT7n6mSadcbCbt/g2uMoHuzmaXkW2KPKQF5WTAvV1Dy2t7etjbG2gb5brb69xX8vLZv1/JC+Lu/8vjFny148j6DaYCngBgiigPmlFQNTjLkw7MPUJIHSgDzEV98ecA05372eYez9jPr777pao2HFEF+iBZCwS9+8RJxDABFZHZYcsacEg6nBOcifHRIy4RxGHsrpgWldC22EiHeqSpqVdN8fD7vfdqz3/sNe2ezs50ur8mXzyXrsigGFC35TeQQvZat4bb+VZ+ci7qMDhLmcQ/MPdviRw/c76O/fbN2Htq7tM2mH8+use354Sdv8PS5w3sfRDBGvLl/iZwDGBHkXFWo5c1/Qmh6+N4v2biPtUt4AwPgwliWDD8WfPLfFIAScj6By4L5LuLFp8/f+RzfZ/u+39d+3iKIWunpdMAQTwiqCFLYaaDXzi6YgY/Av/hzj2Wa8Ooz4PXnfm0z6vzifMbtT36Lp8/ex/Of3sL7AaV4LFNWFRVSvmHBMp2QllSJIL3dbaXsj8djfRcrnpI7PydnUbcoRUvPQH3L7r7VZhQCu6VZNOzUqRpImk8gaHl6inC/+Sn81yPKixt4EHIm3P96xO5nd3DjUrEBUxcxP6ja+QAssaSRWRhgVoVhSYAhF+B8RC4FKWWEEOr8R0TY7cY6r5ivaM9GcLD2gEnnUMEC7Jzn7xCbxNWlMXLBjhfCfcOzehwKaHPm1g81QlPD3qyscY9poTrzVHG9tcUl7hdXp0pUyjOSl8SKi9i1I7SSOA0/L13fgtt2BUmUoa0kkh4DQB1fpiiOSkxqGLEo/jjAEUS5VDEnatdQNvNP7wOeYdPatsrea5V1fmA/uSdHlpQiqqltG+reqx4XaKuxHfNSMu2KvEOkKrcMKdWlqqCdHx+CRym+4qxWiqlXzbGEZ8Ny+/NYs/Lb8irJOBH1FykLFfwgxJU4YBgG5CWhlCQlHR2JalQlXMr7GrQ0s+uIK9RdmyzbMg8yWBOhhAAk8RxREY9xgA9OCT/iKxs2kbTUVhumliTpL2LE1/bt2pUwc23Xdm3Xdm3Xpq1nORu44pwwtQHUYDFggXQPHzzgtF4phO0tKi+M/V6MK+cD4jACy1INJe8JMXpMxwl5WVCy/ktJMiaY4R0hqHGVVbUjLQVQ429ZlmqUmdE5DENlUzfG+Jr0c4nE0huwEvghDaA0MoA5iJW5zOYmirFq5aP6PtoSKfpmRvHaO7v8XHpHz+7JgmrFHEp1iGRbgFTdR0qJeIBaXV8Aq37rjfe+T86ut/v8UrDoXYAWyzS3+2r39s2P9UO1S/0goODla7r0jLeBrXe5n0vO8bs2G06XnO2HAnzrwCw/eB+9KosduwIbCpC1shkCGimGIUFkFsncuh+cZlkJdOlYZKPTkhBCELKCOY2gpsJhQeJu7G7vi8gyHCWQ3JPo+p/bzJLt/RppQt7trA4rrVQm1v1FkDJZ6jjD16CjlZJizQ5KWcgiIXgpU+JJpUsJjoLIOjOwpAlv3swYopAFxqczbp8fkaYJr3774bcizLQn/91ay+xahw3m+4iv/vOAyA4eBA/C/AcJ7/3iAGbCNM/IaRHwgzK8LwAnfP3pB/jiP97KzEY2wwGMAYzbGrrl1TWgXkOHb11sw0ev4Z69RloIpbhViT4B2xuZT5TTDHTQ+agUzKcTTieRtD/c3+Fwfy/yyUME0aBkUyFr5JQkA0YzyCyDk5yVHooSoHCitCRldxyiZmIFV8BYBBw6PsHy1R+iMMH/aIIfXoFAohjiAwiSSQeVs7U5Nml9bOYspfpePcf84hYzDKZ436CS1ZioakmbzyqfkQAn/IMagCjdczi8CDi8CBj2wI9+zri53YMx4fjC4e7Xz+CYFBYjjD+6x/Cz18glgckhLYzjacLxNGFZFjjygF7/kyfPcHsrhBnmgpITTqd7DOMOp+MR93dvME0nhBhQipSKZAZoyRUYrUQtI2ZwF/DpQGBrj83DREZWYZhMeANw+kJW1pNmT/QZUC38VtgA3AYg1jmGIKDwkqQsk2VuaXag3QsRqfqK3vsgJTZFWQcQ4t+i5cGKkv4ychaQiouQeUIUu68oGdeRqgEVHRv63sj8KoQWi3+9zVZYkUq1D2w+NiIRa59mJTB630BS6FyaC52Rdvpnsz4n6rPfrrN9YMH2rddu7JPNMS8FDruRofs9Hpbb2ohm2VE93/n2/X713uwG61BjPbf17wNjWCdVG+JENsvaYZraDTMjFyHMzJkQwwgX3h50vLZre6ht1/Lvsv+1/eO0nAmf//opfvbz1+D3DuBS4GmEI1E1S8UhTwklE0IYsd/tQQjIMyHNX+P+fkFOnWHxj9DedtZ+Be8/66niP/RYDIHxJ//ygP2TAewdUnF4c8/4208JPowgVRgM5JHSDHJWkqj5PDm3EsxGSOnXuha0fLhtg4nAhfXoAZuJdV3ituCcbdP7VDmvFYINgxLf0IFIKCaFGaLkSCC1RC+RZTZX89Z7/T7au5yl32b9Jlz6RtoHPzvio38B+LDH/THhNJvtqSR/3YeZW0DUsKYLHbP1ke33S0Hzh9pqHKg9ON4CH34MuFCEpL28wctPh380wswP05qdV3LG6XSPGF7j1o8QMrSvWxhHAUTwkfAH/ypgXo7IWQgz9sxXj8hn3P70c/zkkxFPbp+iFId5zjidJiGwO6hCc8Z8OkopaMU9zBfMOWNZxB8E1jiHEccfwkL6v3vygNmrwHrcCHYiyUTMQIgewxDgJo/86Y8xTRGZChgZKQGnX4/A06/h6YAlSeLJEAYss5SN4gKQJ+Qiqp5OfRxyUq4b3Ah2zCylZMih1EQJw6JYy36byihXLNvuvScX2t9G1lkpQV58q2uRmAe+b/3Y+qmRG879gfMmz9TVcntyjR2Ox4L9CuFISzKxlafCCqPeXjsphlDfe1rfB5EksFZ8pmJwWgCXxK9NNYFT71MkWOvhTP26MACnCVI6bzFDy1i5qvBpyU3iNzukbOuOqKUS1vPXJRz2Uv/b9j3p7xIG2uOORtwMYej2Q+1nO36Pydv7NU1SwtZUhC6dp76HhJovaH6Y/TNcsr8XQkMc+mNZDGdFbtJzSNlgaEkk1LL1DEmOENVdqDLtgBhHxGGHUg4oaVaSi5QXN4KQkaGsvFR7X3xV7BXCj/j1pizT/H35W0owSRLYogRA76KaDC2ZaPtce/LZtX0/7UqYubZru7Zru7Zr05ZSwjRJkCqlBOcchmGopBSgMZOl5APBh4jEGd5F3X/GNE3Y7XYYxhHjKA6j8w4uO8QY4J2YdsgLptMB02kSE01JMTlZqaWIGDxKYSy1bmgLyMQYsSwLpmkCEdWSUuY4OeckUM2dUdk5KlvHSAx2dRZ467Csy9WYIQxieFhA9XGSQm+Qr4g77rJhZ0Z2D0qtnkMt0eTgHWnWgREJcs0i47LAW3D2giO3dTDsM/vZs+7tOh4kKryDkbo9X7tHcwoeJhm9y7G/z3bJaXroFrcEjHftD3N6qXMou48f3mcbEOyCY32gqx3ssoPf+vwcILFn1cud2vgSUkwryVFJKMwIMXYkmxbIZbaAoMqAsu0roIRknBTAW61buXSr/9srXxnYa+9Jf30SPCb4LqsIaKoCvextPydAe8lKqdjnhV13PlSwgEjIdZwUOtKUflYQBtxIQo6EdFGKgFm5ZDinJZrIQyRGSQO6Mv/lknE8nJATo7DXDAwGpwAKCZ7X40YC10BJHjnJ+77NgW0Q+rdr/b5W/7tQ/w3ddQhiAAAgAElEQVSjEJDUqWUAp2XB6xf3QCEcDgcsywSmDKKCYQC8A9LpmYKKysQgkypvyibnGZh2R+dtBVACKAVIc8bpmOAgkr/1PsiInKHOqYDNTVDnPmGaj/j666+wzDMIjP1uh904VhBDlLwALpYxLe+DIwfyShHxBPIil86QZx+GgOCk1nqMAUMIAM8GQ4FiwNF6uAQgRTAHGRPew0VCyguYM/b7HUIIOByPOBwOOJ2OFaCoc40rgDfgVMkEHUXJOQKyR8lSt5zCrMF3/Y98zXCTd7oL9BtoxwQXgeNpxjiOyLzD9Ko/i5zTU8BIT/Dm1YTj8grTMmNZspT0chGAgxCJIm5vn+DJk1twyZiXGdNhAlLG6G5AuwG5AEQe3hNSlvuTNUzuySS9+7m8jZJzuf5Lc7j9bUCnZEmaskyTG7a11ubV9TjtVfss4MYdmn5+PkdOSmUVUahyzsEpxGXnPieNADFGIVURQdTSCIwBzhlwqSouWdRrDBDsgXALdJEjiYMUATttbi0ly/vktrLLVJWaLrVSCryNvw5srL3Epr5SKgAH1vNXZa/uPV6VcbpwPpuLKykcCuqfz4j1OET6SB4GsPt+b8//vG1tQvm9rbvMBVS676kPxWyuS3/vQdVmFhDW9spDtpSRre13eYGlZr3alqHvC4dCAVMCbkIEue/X3rq2f77toZH0kAV9HXm/P40A5Llgvk8onLDbS8CLIRnK3hFyKoBntXFukVxGmk/IeUIcCLdPAc7A4fD79czpwu/fr0X9eBt3hGEEYiSE3TMgDgDtAReBMOM4fY5xd1NL2D59usdXX30tBFNV/L2ERZjfvVbMfdiHvhRk7L97LMC7CmDa5285V19S2IJpVpJTMtdlPSK2srZacEhrNDF7xBEYbzJyBpbpcsmv7fpqPgavPlv/fJf2TcN1PQ1hfa6OiOAZwyglkMhFHI4zTvMbnE4LQBGgCCZJjpLSK5ZUVaof6FVZsbeDz65lg/U8hsVsv2vkAvUYiOBowG7cYYgR88khhHLxWP+lte0zA4CSGIfXCcgzQjgijgzwACLxxx1rWZzaxwyiAXHIGG5UtRFcbU4ihxAdQnwC5/Yo2SEtCcfjgvvDJLgpsTKkCtI8o+RUj2+lX6RcbMNB+iD6JbLMYwR0w0jlj86P0XfPO1GXmaYjYnQYwh4eHsuScMACkAT3F2TMJNqmmSeUdEBKE0IICDFimeWai3Z2UTKIV6IJCEjZsGMpA+S84NKGG1dl0dKIIERSPtcI+WZ/99hjzll9DKlYJKSaXnVl7c+1sdD7es2ONzt7iw8afrW9vkvYY/PFzGcSf0bmylyVVsTvcijFqYILwxUpvcSE1fXJeyrX5hQDl3fW0l/69178PwdXVVsHaMIsCXEx54xFSUp9aSvpa1GbW5YEIiFQeOc1SQ4wlWbBXxysZFiMvpXaCQCmSX1eUasnSNmt/jlv29ZPY26K5n3/Xlor2zuASuI0IueiicDbZ9WeIVV/83g8rp6xJSP3+/almfjCeGFmHP9/9t6tSZYcORP73IGIzKxzunuaMz0XksOLdpeitNSFu1ozvejHyfSHJNPLPuhF71pJNMkkUibuDpfk8NLdM93nUpUZAbjrwd0BRGTW6dM9PdRyJnGsTlVlxQVAIAD4559//vSEy+WyedY5Z1yG9GKBcT48PGCe51bXMfAZQxsVEZQDXxvMNi6lIGcPcnRSUKmCtRhZJvBSm9OAsMl74JCvOzmUgywwp9bSnhknV4wpFsyTUnYMllCK4Px0hmoBz1OrekqMlA6OPcRz6wSub9kV8Gtd7oSZe7mXe7mXe7kXL7FxD6AiNmbjhnGaJuScUUqxaIVSgZSRDozTwwNOL160aN2cswH+iQAILpcnLCuDVKB1QV0thcK6rM40FtRSm7lRyopaLSWDSEVVgNOEnCaMModh+IkIvvzyS6SU8PDwgJwz1mUBpG7kF0dCULQ7Nq7jZtdUIXQwTOJvQ8QFwthgc/COjoxh07onIYwGkerznP9xAx2b9FpXnKNdiZEmS/1iAJTZrImys7EJVRaUqhbVP0QljM99VBD5Ouz8+H38zPKRPg/G7NM8dOeVwDJBeELW9yzNaXuDGPG1inathU4M2ZOJtBmU+zYF6LA3vv2IK0doOLhkZ0j3ho2g0i0nnDog5U9UQ4np2jgPQ2ZPdLK+7p/Fs9jUEVvj3iIJTBUD6mSD6G8/PlJ6qM8nPUctAbCoEIx9DQPYT8dDAyYMiOngxjhOTR3hGlDYgh6MUro0ccwR8V6O52yN6TDUiqtYJSikGXc5z5v5JKJcRG30iIRahbeKGVCf90gdOEugegHoglILRC4AJagQCBMih3NiwsuXH2BdF5yfFjw9GiEmMeGjH/97EAGHA+N0SsgTUMoZ0yT47C+/j7//dz+IkfOtk2YavYIIyWVGhMa/erSLj803nx3wk//pBzZqYqLyPooaSSU3p8nOVWp5lTk+uwXgDD8RcDNlkwLgdITQAVUqihRMaRoi7Gy8RW7niEQzsFG9zwFoxSEnJLX1gsmIVJfFQJRSHOSnjJST1VpDtjZBOSPlCauFVmGaDjicHnB68QESJ3DyKBxVZKoAL6h6xtunbK0mxds//3HrN3LCxIt/+iVOn6ClPnx8eovL5Yzj4YDTaca6XvD28U1b2+nhS/Bv/RmIMnLy1IjlglrPyFzwwYsTHj/7XXz5098EpxUvf+d/A9IFRAnT9IDj4Ts4nU7ImSG6osoFqhV5yricL7icFZAJOR/xsy8EPCU8Xb7A27cWQWlSw7Z2Pn1+wN/+zz8AKfD4oz/F+fAG6yogypiI8OL0gNPxAYfDjMtlBfAEToRSKt58nvDZ//U9GyM/+mu8/P6H+Pi7n2BdnvD45hWenh5RSwHAlk97yrgsa4s6ZE5t3WTqc+aelABs160xMlCKEZVs+qttrm0RVnDpcCc/EAcgG3MYtWsqKXKezNmoW9CHACQiUA6FtoJLXb0dtNkHqRJEbA5ksEVhQiFqQFWt6wZosrZkxDYlpQxBbfNpEHSJgvTXFQjtO2Et9u7cyqHOzE15cOxfA1kttzo54HY+X+w99ncz52mztoIIKVt6D5U+p4/rbuuz3bPkRlIzB24ApoknaChADYByrGPhBBrbtN9z7O8fQPRYl/33/hXHAOzS+uoOk7avbCTuvr619R2hckg+9qjNjJtnAQxz77gXjTHb62t/6+MTTpmrmjBNJygtEAzg673cyy+h3HHvfxzlz/7Xj0Cs+Ph7gj/849fgnABkHBIBxyPOTwW1rDifz2B+QJ6+g+kgqOsb/OEfn/HD7zFe/+wF/vX/8B/OE39fC/I2kebbKX/8Lw/4z/4l4+8+f4VSX+DtmrAUwloV6zphmj+0lLckAK14+/Y1pilDdZvmI34GbG4fiTItsOEdDf4qXODW589hAPt9/H6/MJJllmUxpUFm5LRaatTjAdNsTnUidvUES+cLVtus6wH/5L98g9+5fImf/S3wZ//mh8837h11+yZP9X3Gzdc5Jmrwne8V/Kf/6g2+eCV4XM747HNzZAIHHI4PbjcCVdSwOfh+htid/nTbPto9p1u/P/fM985+9RTWIhUERlXG8vkZ0yvgxcsZc/4I8/Srs2+wN6fvk86vPsTf/Mk/B4Ox/hef4uUnn2GePsLLFyeoxJ7NAzZEUJGQKeM3/+kjvv+7bwC9YF0fUasCOiGnEw6HB+T5D1BLwuvXBeezBRVE4KKqQkoFSDDlBJrGdK/aUpsFbjJikrf2sSPu9RzZ3Z73+EFtxAuzqRJyPuHlwwGv/vqEn/3kgEkYXASJLJihQLGSnbeWV6DyGoKEPM0AM9I0I0mB1mrdS4R5PmGaJk9dXawf3QZKrgy+XBZPAwgYCcPGpDniGepqH30/7ZijwtJmO1EmT9kUTtH7JEhH+zdYoRig4XbtNkiGMqb/2WNU47OYpmmHPbvN5ArFUZ8gt0MF1etfiil/QsnVRQfMGVtbVEVN5YUJpDEuQrXH0hQHISHapCpY18XSjnl7Avc12yS72og6OeKMx6e3WNcFBMJ8SK6SmtxeBaac0ckO9lymacZ3vvMxTqcTODFECn7+85/h8fG1+RpgyqxEtOmvlBIeHx8370HYotGWhmUO6+CeuBR2XfQJe+CpSPgOpqvgu82o0B6kMU1G+Ig0Sf096thm1BFm8t18/6Zp2hDB4noRMBtjLCfDqdZ1bWNtVJlTFVs7k2FgiUORyO5vKbpWrGW1QKZS8Ph0QV3PYBLkzG5PEphnhG8kMNp1vWBda8PQlCLgyux4I8r08W6kKHu3m30Kwun4AstyBlPCPE/tOZeyYl17IGVgdoCiDHuIe/nFyp0wcy/3ci/3ci/34iXY4e13l8AdyRrxOXPClAmlluaolIjUVTXHXxgfsraNl7ueoHWBrIulOqkVpYbzxiU4CcgRKWMhUr6JouboAfpGKaXUDPfYlIoIOCWUYpvF2Pwa6aReOVeuQQJgA54odfun+/vt2qC9/QQAG6M06hC/h6Niz3zfM9sjQnvctAOwTa57+Tq7OxzVybIkC8wDowAoxEI7aWBP8Nn3wS2W/TXp4ppAc4ucsb/meK0gzJiR1CUav04ZCT/bSILb17n+XDf13hqqvV0RmbW//t45t7kHja793g/NgU2jQavbc9GdeOM9+7F9UJqR2wGR/fgb6x3SmGMu4HEcjL/H9TYggKsucUrD8xqMcBj5oedb9ntw9DNclam10g3obH0VkYPkRIido3GflgnYjTVVqOimH+LcMbLjiuCkDvq4qoyIgFgbmSiGQQc4zOgUbxP1B+bzhM2JIYnttiJEBeyRfxUCMrFhk6nVaqozHAQKo0ZINaUUk+BdwImRNaGqcSjmwwxOi2M/2p2mbVR9O0Xbl80pDFNhEOqATACnAKBCKBd2cBetThzgCwx0HMWOrT+d7EN70sxm5Pfvun3LaPg/pQmVM4Bkqf6Gd0M85dZyWVqdQ+Y4pIBDvlmFHbCw2lSBgZsQqMviM5kkdWIgp4igypbPme15KSWkPGE+HHA6Pfh74uCNCBIVu5YqOHHv72o9N7ZRAKRs68TlsuDF8QHAAZYireJyObcB4LMzwCuQCAUW4ZNTRtYjUJ/Ak0nhRoSZkoGxxAywQiA4L0+gFSBaASr2eVkgsEhyJViKpQIQjEyhTSbfVIigZJVfbHwnnnE4HDFNlpoMYoSWIhUHYhwfHto7njIjZ0BXU145HB6QDxUWBUWYpwPKWiDVFLFSyrYeUhD5LMIw5alFQ9Ew14zzSgeYOlGirZ+qDRg0kp8DmQPwBiS/DiFRwjQlPNXi838nQqjPWRjenU3xOjL1HN4GUuc2H7Xc9v5OlboiaQInG8MiFuUXafKYnSwsQSAhgIxg0+WVfZ8huqnvuFYxEZB4s6/a9+GoEBZ/Tx7VWGr1tntD+yTj64GtF3abrt4V1x5TrN1yEm6fabzTaH/ra5+Nz0Yk8Ul9bMte+W+/Dtl5lvZrrMNYv773iTXByYGJm/JPmxm1LSmb+quO+ed93xTgpO9V+uyobY/QrrLrk+4EGfYyQx9Fqi8RAVIn5dzLvdzLr3cpq89JojgdgJSBp0sBQW1vMSnKUp2ULMh5xnz6ADUxaHqFt5dHfPmmAPjwPe62p4D/Q5S+3m1dh2bnfLs77F7enh/xxZuCpRYUPaFoxiqEpSiWIqCcobVAYWqfLvLZ6vecHXxtN3VH5Tcpt65/C1OI++3t5lvHAKOdZddalsVxDwCULO1mOHS9HaIEaDKl0zRjOtxWNIk99XYdG8dW//nberrjdXwXshk9Uac4ou+01AKKEmEtF5QCKGWQE+2NIO37MzB4c58GDl1V4l04y3MYzr7ssYO4iUKdjC+4LAWiwEcvCSnN77zeP7YSNg35nqysGQQLYBG5ADi5fW+2gCn5eSANWWDFNCnmmZDSCSInrMsK1QziA5iM0L2sBWsRe9ZsyqRQV4a0lx2H2dU+BiJT/LwnxcTPY9qm5wLaNinrGy6kbbxaimWzJ4hMGWLOCQRGrYTLQigAEipS2DtQlMAMuIC5gtkCBqoQwGbzV6mY8oxEhHk2pSIoUBSYJk81R4yUTV1Uns72NCjZO+FZ2gIfg5oCcE6pKUyqwm0IRhU7oZEVdGx3650tVtjwnY79bF+bvmIEBmXqMKV9Fv16C99qZBkRCzKA7dUtLW8GIGbr+r2MbMCdzKJqUjkKsy+9vpBuY6i3s4qpco1phu0rNZuQmVFlmB/cFk4pIyNBVG0M12pkrk1/DG1iNpwLEbzWsVLDUcz3MDkJ7FJWBAEl+jMIlTGORQSHwwFPT083+zae2S3i2C0ct//cV/xOnOrtuZ5Ku306zo97G3DEE8Z63sLYG6R89W56yuRh/ADA4+Pj5v7h+xgVs7taVL+JSoVAQJn8Ga6oaoGEBFPH5mKbDZFq5FUELlGwXFZUMf+QPcMMgfr+JPqFNr6b3ms2dqFdJc0wLyNHRbBRFVOkCbXYhoGkZBjBvXwr5U6YuZd7uZd7uZd78TLmtN47GVrOUVePmaYJeZrBhS0NglqEQ/VIgJwSEhhCLtFYFpzPjyA1yVFoBaRY+hXf9EeKDCP7E7Tli3UQwDfIIlsDArg27EfjTlRBO8Mjoqv2BJZt6ZvIptJgnuB2xJWTBO+WdLwuzUq52kTv6xNtapvjCIkfjJ0gIfTPtB1r8cG31UNu1fcWkHWrn96H2PJcu26f2w1Du9/XU4t5v37vZSS14OY4GOoFct7UtRPO6tmPtOESf7t5ZxCFLOjW0Dajaq8wM6oUdYfdaMCbs7N5GTEiY2Zc2zsURJmUQkGgG257wCQ+3wCgYfSFkgwslVA4O/0t99eFAO8bi4iyeqmY0zyqG1oi2tphfa1AG+u3yGV75/bmuRNaarLNk7xxXpwbERCRlkmjRoNDNWCingoqQCN4fzh40upjL6b3Jkwhq3oEScCm5vRkirFhUZMAwKSu/hCpgiKft2JZrN+nyqBjAmvC6cMnfP/3PwWE8flffQypt6PEfpES7RUQkoOFrOj5rcf+Rn9nsPs8vgdsrdBGpAmCTHsGMQ/vzg3Qmdrn13czIhlAlDDPyQ39DiSa4kSQ9hiRk9l+7xFsOSVIFSxUACIDiKYDUjJAif17Sgk5ESYnyxhhxsZ3Vdg7wQmUTL6aU2qEGdVq6XaIQao4fbTi4z/4OapWSAkglJH4AKaE44dAzskB2z5vilTUIg4KEtLHPwed3kDyI4gyoFYXBSFRBmnyd3vG8cMz9Lf+BlXO/v4dQMgoK6Msiz1hEhBVMFcQ25jllKFiwE2FRzAVO5yPC/STn1g/EwGuJqVEUJqQXxak+QijTjHWc0RiEU4niyyMSMkqFTUDL37PSDgf/+gDVH7E69dfQssFCdoisURCBcUJvjQAZP5cjWSyXZv24OUegCbDdMFNKWmYk7VHi8U0M87Vca2+xjlJWcuwlgwElFifEAoipu6lsb/xvZS26CxfqyjUSjp5o725nBvRJBapAJ8oAYaB97lWVECtEZ1wYlisRQuOKSbHPtvPuQ00I9snhh40tXqO+c9jHQowk13VDFfP6DkHXXyPL4tsHPck+wj7/stedS3WbOA6AtD6t+8H+9V8HhvqPJ5jz9nmf0t52O7YrhB7UBtX45gLVbOh2q0vntlv6XBl2v7N8O9OvBo/Z1IwBCqr98sdmLyXe/l1Ld2FZGXKCR++TDhfViQoKiWE2hqzQNXSkYoqiCdMhwfUesYXr9/iZ1+s+GrCzC+PLLOdLcey3aluf/rlljdvL/j0sydcqmEipRYsK7AUS5kAt1HU9wZmntl+4aus5hFz+Do29ruu955HxgnP9uFYr7A5BRYlz6sHUykjT+YgC0NSoZ4ukgGaQXQA0S1Fk7DG4v/x91hVN7X9hUtfyXsdRvsl6uLWYDvu+7/zhNMHgukoePu04rLYusuUATJSglaFMoZ9rLabEqiTBoBxI7op33QMXD0rb6TZItYiqYR1FVQxBdVfpdLHSWjl2idf/M1HSNOXOP3mAqKCIFyIGkZCbKltLdxmbrYEpxmaV6gSRBPWoqhFUIoYv4EJCWypbuuKSkBS40Ok1EnN67piXVcsy9pSM43O9D0Gut/n7sntezzICDOGW4QSYqRSUYGRZwK3DdSEFAL23ay6jQ8oFdvTeupirUaEExWAgXmeQUyY59mUM9xuqkQAemAnkQKcPF202aQpbYMdiAiZc7PNapD1EzkBxbVuHRuTKs1O2pMnOr4zvlM7bK7tw7X1T4yFW7bRaM/sn1O/bscdLW14twPIzyVvSyiPtCu0ycWpCe36PvcMqh9m123JQ1HG8cB+X6IEVkFdC2rxCC9YUI5hI4CpZY7Yjc3fYS+HjZOyEWVqLTifjfyyLJemlGTzi/ktpmnC4XBotvk+KC4w5T1x5dZYf05VCRgDDvrPtOnY58vePt1jDBvyDvrqYKfsdxxjgIcdl5pae2/XsiwesLWdc1tdgqQUfQA1H4JHpxAIhZf2rEoVqK4gFFDDfC0AELB0S+u6Qqopvtm9HWsGQDT6Ym71ETZjNV6vSDndFMulotSCtbjKrmNnoSI14uX38ouVO2HmXu7lXu7lXu7FS9+g9I1rY7QPqW7i85wSmBilVIhHSxuhhiErYfEo5iqW2kTWpe1+VAWQHl2dkqWcEFHf+JhjUTRyrg7bx2GTFZvAff7ZkT2eU2qfRYTzcxvibqQMrleyasf30VAKw8W+XxMN3kXeUL9ojwS+8Uw2xJHu0LJ7hkPf6wDfbLozDA66IJwf3o0bn8kzzqV3AV/PEXq27brdlvH64z0i2oJbSqbRmPjqOo3Xf3/Qbl9xtOiJfr1dQ4jckX3D+U9Dn2gHMQGYM3N0ng3nsxNITDnJfh6NMmuTgU/jmAyDezzOxih3BxzQ+7ApZfh7xNrG3t6JGXWMeu5TioWTVwkQ9fsgdUAujJWW0oHGnCfWN2TGU4xJInPec3vXYkwbJeN9obw2DqCb9+ZdJfrdCFGjIRzv3Agm6fZZwyP7RgMcQfQLMEWgEc3iZBmLdMqgyNsMAog95VwfewHIGGkD7TiTYhYUUegiqM3IFfD8Bh/96C1IZvz8bz5C/SUQZoBQs1KQUqM6QQlM2mZDAjXll71zRYHWU/3za6cEDemZ4tMOKPv/7R7dyTveb10rZCKkNBlBU3rqwTHFTDjkAWqGt0XCELJLYEOBg5iUbUoe5cmdKGORbrkRMZgtV7fJFquBDl5DcWcAA8iJfE1LgFYD/ZVw+pCQ/mOTM16WFbXY3xIVMCVwmgyI8Ig/A0erS9RWT/WVwB++gr4oIBEwDp76ChAwVNhUXoihMmN+sSAdX+Pt42uIEBgzgAlSE8pqEc02J1VYyjmb43K2OdyASnWFF0sHpLQCH/0lSKWln1IiCBGUjwakV0/3RrGemSS0qEUTvX18i8uy2HqRGKcfM9ZSMH/wG3jzRvH26QlUV5wmj4gjhqgg+IcpWZRckHvJwd5xrh8BtDFS8yaIzGi542Nd7oU282WAX6ZeFGAn2udAzLt99O7XSgOEI5IsKixORnZXi3a1ESVCxQotoaLTzxuJEYkJyn29uSbGytBGByvR1VbInTXjZ1HvWmtLGdXb4X3jb61JXUcfbYmyY3+077pdo8b3OK6/L50Y43OIbvtAWxL3uM+14lpEpI77kr0zAcNVWv+hUwJ7n3YA3dJPERIrRNc2+SnI5lTm5qCgof+sPfaeBNDdyS7bvWWsjPZ/39j2/a1u+mjfX6SCrCsmqmBdPDPcr5bz617u5V6+eTmdZvz4t17gJ3/xGWpmiGZUSWAWTJOliihywVItBQBjgtIBS51wLreVQICtnfttl+3qf+vz8Yi946qX5//yzcvj04rPfvaIUgmCBYuYqqHCCNdVKqpWqBbfA5gd1nbDOyc3sF0bvy2yzL48h3lc7yuu6/WcvU9i6T3KmqBg1AqkojicbCyZjWtpSKAZ1hEFxJftdfb1Gv7f/vT1n+dzPam7v9P+ZyVX6OwBAvG3j3/4hJffu+ByUbx+IyiCls4EEYkvYkoBTGaT7S2kES96ppLPjYWvGiPX+IGTt5ysTZyRMMPI0KnjA79CZRw9oSXz5d99B6cPn1B/+AbL8gWIjgBlgI7D/iqUMjKChAIn1BQxkozZfOqihYTMye9gNldK5jCOII94VrVWnM/nTQrq0Tk/YorjMeM7+Xy6mXE/La4Ia4RI+1tCTtPOca0xMq7eq5yBNBGgDKkM1bDRBNOcMB0mMGckzkbiIIBTNZuHMlIyu72UBUQZnMTfARm+gNgvW0CJuo3oyhglUusOGJSKH7dPsz7u9/2dexYT3dsZgUWPQRO3Vbf271Yj6Gzw6a3ts0U+CFfA+Y1ydQhRwzMaV0alzUymfIyGHyrg6XgZqEHcVFOwcTIFkwfHBpQ53G/EMo1YY886Jcb5csayXMAMrGXFcjmjyoqcsxFjmm1W21gGuuIIgBboG+mLbmGeX1V63+8+R6y3z523vc/+Pcs5Y57npvyyrqutYT63d1swus39FJ4+y/rV0/HVjmuZbyVhnufWH2Pq5qgbeXqp9hBE7XVhC7pZF0FdL7ZfSwllvUC0gKj7UkL1JdI+ETFyKB9ptWVZAyux2wQhrflS1GYIkXifYK1t85o0/4cp5ZpKMMHAUaYEVXa89pexU/z1LHfCzL3cy73cy73ci5fkqSNMMrluNnij43zc8CdmzJnx+vVbrIunCJknFCm4XJ48tzYAKObZpTZrxbLapjWlbLEG5CY2MyhZCiERV4uEKRe4+2IMYN5ESoRqTGMguyPydDohmNbruj7rvInvnSgRBksYJdc2x5XzjK5Bn3eCUc1hNF5jC2YBkQZrMHDjMzCYh3NILXIvwonCCKO415a4MbbhFpFl/PtzjqhbvzcViI2BuTXs4nqbyBBvVzYcZYQAACAASURBVORcNYlNNBnJ2134PBB4q377evfjbn02jhEHG3Zgz/7Y/ZgAAJUKHQhV8SzDIT8CFqOhMxoWY7kVLeBHIpx8IXVpKRp6hAUCShMDXLZRDP15jO/66IRr44EM1Kkt6h/dl8nJwTsbcwy2SAZyg8n7Mwwk8wmqRSm0sYxOenFlq3jHR2WQ0Zk5fkkDO7bvzv4ZWZsHhQm1ejA7gQ5BcJGr5zb2OVSgMAlbVW6OfgRoIGbgilpkhCqB9AFaDXxI2VMFpV7PSIuHsV2kAFdwyiAkT3unkEWhVUyynASHw4TDxKBckFyuPVCRcslGQsE3L3GuBIFoIKyYM9sdu9ohwb3DOK7Tos92n2/gHzUjevikg8q6B6IdvmABTQsU7OkDM3Jm1HqBSVnfHkMGqjFyzpimGdM0tTHOKWGaZxzmAygliM9PodbB/pXSBKaedm2MsrlcLg0wk1pRywqCYEqEOU2glD2NYQJkAtMRRC8g5RETr0iTtLENIohWVHFiEo05q02+O6UZtQJ1LZBqRCtQAliAJFBJgGYoEnLKDsgI1lpwWWzcWpsOIEpIqSAixWsJEoGNhrOG6szqynGhUGfqIcSMnCckztCqKLWgqiInu14D2POElCbk2YAuZsXrt6/x5asvUV1yOc0ZQpa2QL9gA8KIILWCDhaZVmvFuqxYlgUvXr4ETyGFzS0qSqQaqKfXc0Svv4+vzTgBVK+BTzL2SAcTNfYqDBGPDIe2eTYANWbGlOdGjrBc9GUgdBFyTk7AhKm9+PwcexqmHjGoAKpWA9vV8t7HWmvzeoVoQaIMJXLCqpGMiC09kKqirCvWUhspBvB84XVt/ZISAWrPMtaLaN/Yb2M/xvoE9GNHgrbtuejq3ADmYi6Oz8Zc6LfKuJ72NTp+bzUbzoj5atwfbsfBODY2e6WNIty4r9sDtXYPe3YJmSegriBaQcmAfSNVJpRi5Dfbq0/2u1qUXxXFulxQq/hck3wPIZu+a3XyPTe0q970/hh6YGgvU0XWJ8x4wkOumJ7p53u5l3v59Sh7F91hPuCTjz/BX/y7TzFngQhjlQlTVqQseKIVRZ8gRXCYHwABpnQCzx+Bp+Wd9/iq/eov10XS14F92c7s37xwquAkCLoDFHg6r/j88wtEKlapKBBQZkzzjPkwo6igOiGYkZD5YEuP1M362FXxrnGPr3IafhWh5rnzr8m+I0kWDVi5dczN68GVjLlCdMVKAqKCAsHxMCNnV7gjgDSDaG52HLD10cbKPt6pf+Zr4TtbfV3e3UtfffTwZEBJMB2MZHtZgMtnT3g6r0j5AFB25Yj+/ETcToSCOAHNDqPWECJqCqBft7zvMw6nspLtLW1fOYPT3FRb/chvUIv/8EsfOdbQsgoeXz3izH+Lhw8OyPMJ8+FjcE5YF0t9w2kCyMiFWitAE9ZScVkWXNYFaylQAaY0IWcLVGQivHnzJXJmzHlCShZ6wtTVZS6XC5ZlaU7zeE6hOBHv2oiNjvvt50hvVqiRTUAVa6ktTTHRjOM0I+fZlQiH9xsE1o4EiI+Hw8FSTD0uhGWtWNeKZV1BiYwskxlSYQFrTqQgqdBMSNlso1oFpS5GzHJ7Blpxudi6MqbWLcUwndPpBGazHc0ut2AQU1XpDn1gb8OM+K5ubMd9iTTN41zc3pMdXjhiEXHP8e8i1scpkT9zU12Bq7nasa6kIgpBdUyPBwTy+pnqMDESgsCfzN7UTlQIRZtMZKmraF9vdPuUTJW0rCtKXQEYrla1z7yq8EAfxTRPWJYz5nnCixcv3P5dsa6lqdyUsuDx8TUoEU4PR3z44YcQAT779FM8PT01HDXn7D6G5OPrgIeHB7x+/RrLstzE5r9qPewoVXy5ElGQkoD2WT+p25b7cRS24zRNeHh4ADPjfD5jWVaIEhKHdnNXIjduSGp2Ww5VMWIsyxPKuiKwhZwzXr582dJTrevaxnsoTkGBRAmx4WirAxl2SyKo5YwiptR0OB4gUiylMwc5pavfRz1TChKNBTpZe5tnAKEgq+HjYZvXYj8gO8WqlGL1lobbEHWF7vZ09Dq13L38YuVOmLmXe7mXe7mXe/ESTvu9bOc+ulpEcLlYxE5mRi0V58dHiAomZLh/FxjILeYYWVGrYi3VgH6ndYiKWU1kTnVT1qVG7VD3rpMq0g1SA4DmnAmSQPxdtMvnj5vV2ETfIoeM14zvt4gs+y+LcNiSJsZrPHe/kVwSn90ifrTfEQZGpA8ZwArz0LmDvR3tDG//m25TGIxtfLeBjKvj946sTf2fAdnCSHju3FHtwRj3crNeYxmNyncBbs+ds//sqwDCsb7AEGX/HMgwGMbPXXt/Xn8+HaDYj5E9mQngTbfvyUQjcWQ0/AldHjYMjgBPxr5ppCVigLiZjeR1C/WNAHztVbbs3UE0UgJMatjHo8GgNmxdcaL3Wpzvkq90/Y6N89X2PdsapyMItI+4au30+YWG/o+IiD2oAXcaE5FnOzGlDVV4e6q/jwBEwGQ5oY0UIJZjVw9+WwaTRU6JRE7rUBIw+eLm1CQFIpKLTIrXos8UNDNEyMiGsqKUN/j4d38C8AXTBBxPGYQj/u2/+V2U5Rc3g+LpBRnHSDOdAjjGdmn7pMMNsjt2HOtfBVrT7vv+bwSAP/o58h/830j8Ek/nI0QOyClDdTGHf1kbIYGc1jNNk3/NTtQwUDDnjDxl5DxhmmdM04zLWhyUmcHJQEtOCeBkKiDs6i8IgMvUU1Ijx/nQEYsO1lpRSwGrIs2muFKdBHV+umC5EABTkyESKC1NoSpKAKGWyihIhwwmk7E1YR0GEjsB1euLjIQJKc8AKWq5QMVyxoMygBkqyRSlkpNY2VR0VBmRSifAciIny1JFrQVSCND+HmZKlvYnH2wa4OzvmYMpyUD/xNzAS2bGyw9eIuWM+WDEkvOy4HA6OgnN0jCt6xkY5oacs4GvFECtz2VqgJ6qvT+3QM/NvDcUm/MFTBHJuFW6E0F7xpYWqaCTI4BSlyZXHOmSYs4xQg1a3WPOMRBzm3pIRLCsBnjb8QlEGT2dk5H3TOmvOohl81So29QqqEVRLVcYmBVMhNRkjhMkJeTJJOSlVKgIyjoQEtlSqRFhM9dGeW5/MfbxzfRGu31GzMUiFsUWx70rEnYs+31b9OFNUoluo+GinuPx+za1vUCKmMPrqNRbbRSpePV5wuf/9gTVI777H32O00cXBB4fhVPC5M6IWi+D4mB8CUSwqeftfccw1yqGfeSw5/Dlq6+fCtIVKgs++PCAh+OvXqT4vdzLvXz9ErPHn/7pG/x3/+2fo5SMP/oXb/AbP5gxpRdgFhQUTDDMoNQFtDDm6YilVEglEE3vcYdbv3079Q+3i2tz7eiSX3VX+oq/f3V5+d2f48MffI5KEy4VKCswE4NgDi1iQSICZ0KegJQFS1nd3ie3wyLNy9YGeo688m2QZt5Fpojvm/0AWTrJCJ74qusRRZpDbXs1WxcJwsByWXzvDd+zJKg7EU0B7faz6Z/2/8dV8NssI0Gnu/ee1yX46HsF/+y/egVgxt99+hpP52L7OmLkKWOPaVHz2Zp9GPYMjQ1RhfLzhJnn8It3kphu4h2G6ymKYQVwzCknCFaUWvGr7IYbx9TP/vKHePXXP8DhoPi9//rfI8sZ4IxDPiDlyVPPBx4R+y4jhG9ILAkgNvu/pzURTHnCPGeIVDw9PcLpDm1fPs9ze3f36VrU7xNpbkd76RZhI86zz4c0R1RRqgWFJWizO4gTFGUz3gaXuf1T+zl5GqR1WfH0JJCaTdl1Skb2EN/XThbIwkQ+D5iTXcbggnZ1w2+iD8M23uNIgQcZhswoZbUglNrtunF/DW9B7xcniuhog4ykF76ZGjzK3nYZca29nSIiHrgQhAPxgJ1WFcOHVZ24Mszz73yHO/Egno8Pxat2EhNIrd9D5YVbkF23CcgnJRELDNoogPp/xDFPq5MiLH1TngynARQfffQBRARvH9/g6ekRRQpOhwPmecLxeETijM8+/aypmzQVfCeGxfdpmtoYGPv7dn9cF+KuMj2iVtvLjEGpt+2+8f57Jf9tsHJ/Bv1ZdGLK2JZaK5aLqfBEew37UTw9PeF8Prf3A+j+HlsjGlrb2+fpgX0om/osCUQukTR5My77vODjfYdlAKEuE23eHmuK6DFWt31q58RcFFjyGChj7yWRuNLW8+/avXz98qu7Ut/LvdzLvdzLvXzN8pxDY7/5CNUDqRWZGVLN2TelBAahLM7mT2ROYhVjJFdTQyCIpazIs6URadCOO+3jRrFT6zW8WVdyYggRGuM+HEKmDLGNQB5BhvF648/d4bO9776/mstYFRaZfd2PX7kp34FGt8CJqDsQQIS2Tac5NQaHCbQ5GAFX6qnm4IJ2csNYtwAJ9yUY3hEhMhqae8PTa2rHD06m/fX25wNBovEo+KHtW5nRd5dbZJJ3Hfu+xJoosZEfIa/4PMaCaIzYW8+8GwJEoWpin9tmf2toR9dtqzj2zXV0ijm9Qhlmq4xiDlJu9+nPxmU/sX0v9mSb3g9oRJYAMUEG0jR+iL8akZ4kAAx4WhK7myke2Dk7gLq9+w4OKBwYiDqEMoi0/ux1DrUL9bzOaG241bY9cSZUZuK9NuO0buYFDNfpwSWDwRkpmsJ5CnsuVYo7rGGpfJCRKCFxAsEVhVRbBIX1lQFHpE6S0wJCAGkJUEtXJap4fHxCzpYmCBAsSwGwIk8FnAhFKngYu99WsRlJe/95fwgBFR3A6tDZNWg7QDKNgID22TcspKBDRUqAnMXBOUatZsjXGhExpnpyOByMLDMfMOUJKedWozxlpJyh6nmcURwMYEzTbIoo2cknMX6Zh4bZ+Lfx2ceaMoGRjNRQCs6uGjNVQamKdSm4LCuWS0EtipSNsEIUEcQGOkEs/RF8bViX1cEjW5ds+TCHilUnD2nRPPUUZTBngCqABOIMkKnlKDIECRCP6lF2FakM0gSQyYTXWlFl9bQyFcROziAG04RQL2kPneD7hGEQwKIQleM960Dh6XS0XOlMUI+kOx6PRvatgpyOeDFnzKR4/epVIwFvABwfUOzPRPyzPTFjPyfu5/z4CuUVAzG9/hQS+yORwXc6ZHNmB5RsHAFk/dbWgFBfC2KIPS9TkfNjBODa6y1q5BhmmxcMkEpN7UfVolr7eqMoZYWKjVmr06iHBp//xMhWbGMYvt9qa4o/p5i/9/Pqc86zdAPcGklKo4KLDw17dk5kG4m/17Lp7yqxD4n6Xh/RP1PsI02jLWMbb1z9WXA2xoldW1CropSEsvY9QEoOigssOk8ViampVdm55qhQ6sD+CPDfuOmwR9nWae9MsTR4nQybCGCt0HLBBy++g4cjAbitCnEv93Ivv36lFMWbN9X2pLWCSBuJWJUxTQmrFKzLijWiqEVxPJ7w8IIAlK+8x7e7e91e12bkIHJ3JYRbK8p2V/AtFAY0weZdtnTSXBlaBVDrS4Kld61FAAqVNYtEh5gdEIu3rf9bm+eWnfyLOJfe14be3EfDUUpABGYM9dmss6r9uTi+UkWgpGA21cIgnKoyIiWxe/kGHEkHG6NVY/N5/+wXK3sMoJME9vfomr+jcrLBAoK1LFguK8oqIDJ7xPa9aFhaRNg3bCKc9uiO67immfnR6mfqfnMsPPcG7I7aYFqCxtZxT685cC9Ylwt+1d1w1mNq6ZArIXMFaEGVinU9Ik0P4PQA5gzd4S+2h68QiKmTeCCSPTsBcSfYG85hWEgtBV988QVSypjnYyMzSOAl6NiKiOETy7I0xQ1g+/zfRZoJgrWZST3wz0j9psx6OhwhKkiR0gf2LghRU55lWJAkqSlSLKvgchEwEebDAdOULEOxp+aOFMiqYiGDzJamrRSUtcLSlyYkT88m4krm3AkzI0Fln54nFC0MmpJGdAliTd/Tj3v76Id417uDf99nYcvFs6u1K2qOBIirvbiGnVAxpcmfYWBgI2YSNkW1xST6XCquUqFpTI89GMCBu3ataOuG0NXa1BWpMeLlMVbVbbmwY9RtV78Xk6WqJs6Gf4ilxCplxdu3r3G5rChrT7P0+PTWUzORB1MWXC5nTPnQ6hQEmbCBRuX5y+XyznRM77UOUvSDDtNi4H7DQGgdzG2Nusa+7Xv191ABU5PS9mC2DwsjLuGqLB4YATWMY5py84OE8myQcPZqc+o4QjxbAoGGJTO6I7GHwampzVqgnpFyOQWeRLvvlpa72c2OERB76nLOiLTLZssnjALj1jfdd2Nf1nbRW34BcuzUg5/u5Vsrv9or9b3cy73cy73cy9coo/NhBFdG5wWwdTZXWO5s9rTE4ThSVVAyR0uppaeMIAKxRym7k1VHW1xt49fgBb93InMYk4NBTG78x+ZeAakmzVvLBVLXtjELIyec1LZRjLZsgSOR2NQa8BKb4t4fXXaSGRD1CAkaHVD9+GvVi21pG1WiBm6NMEvcu22dqfGq7TMFoBVN4ljRPqcAmrQa2MadkKRkkodx/ThxdBK2+oXzngBgHAf2vUc4A6awEZvj9pCGMTOCZqOTyiPxYyzCokfiOkQYPKp7oyZ29nvHVG/HntQTDWDqhj4FmCS7z9opCpWK2vrNAQg3jsd7NV9Yqys347G3v9cvMUN3aacM0EADOUyushvk1p1DZFkgbuGIVwCUDFyJAepOWTN+rvuvjWGCRx1s+9lv6b+Jp1NTAJbSRFt9+vWs68RTD5lksJK9yzELAPZ7T400jBmNiAh/Ku7kBYWyCTl4M7h4KZ7Mdjx0UGhLzlKoR+VYX1qsgwESVQpqWZE4ek4BqWa0iYE4RADHfCbh0FZQSIcCrhzTyTemHLFAkX0sVbsz2XnSyEDqzm4jPSQ3lCWMQ60OuhpAGelYmCOfr0Cq4nx2Ao2+Bb/4CeYHy02dsknvpqTt5+XphM//6jt439LfzDC828hCH2q6OWOAFDaFtcVG2u/9Si3t0w1T2b9v5wYRwuVMSCdTJIFmqCiKADkfMP38e9AnI8VwSphyxuF3CqaXDkakjFBF4WRfEdmVOGF2yK9HWJERyXzuVU/zQ1AjNpD4+DKShPr6pSCosCX0qkYkW9aCKoqyVpRVUMqQ+soBKQI8BY9Nj9VJMyq1EYIa9gJ7R4jF51Sx3NUBYJCpxYAqqhRXQyIAM1RNsYSITBUG2cE3tkgzDJFlRCChtn4KAKVIyeYqIkTxtnj/dEWqpl5FHnEEhgijenazWFe0OrFMBHNKoGxre10ZVBkTmdTxsmTMB8XxdHRQLvrE5ih7n7qjZg8Eg7CZ34ePbdyQRftGAzppcjvega7oYs1M+9GKjknaTMM+WmLSFZ8nYs/C/oJZROh4LxtbooKMGdkdakZajvFgY1mrwKYOB84GLLDI2hqsqhAQLHuV7dMMmIt5nqEGf7dxbeca2cJISbaOqd+AQBtRH0UbrJv5Qa7A2u2+NH6+RYjcPjf7bBtp63ce9iJxfdUg8sa6cQ2ojnvk7d+fIcs0wDXqamuMKoBU8fB9c4KeX09Y3h6RDysOH70GU/JUa4oDZnAyhyEnu5dCUVValKbt58TVo/x2bethkXrq9aHIF08AnLhpf08QMIpa9jZVxcSC0yljyrdVee7lXu7l17vErPA3f3nEqy8B4reWogUV3/1dRp4ZE8T2ucuTz+MZp48Sfv+PCbWu+PQnwNOr62tfz+rfbomZ+db3sbzvzPcb3/8M80OBUEatlibTVxPbyxAhpwmlCuaHFaADjEKNpvYnUqHsZGeF7X1AlpLZ96Aa6zcKgrhraUpqS9H5HKFUNda8oX3POM6357xfuXYUut0M3/s2kod9icIINdHzvoklIiixW2Fi6UYAJDKnu1YjecJJ5GYGMmzTuk3R8MsdR9T+75bobWWXvs+xnz76wRtMp4LpWPH2rWAtDKUDOBHA5GmNqe2/BWTE9dj7kCm6KgIY0OH+/d+totrrPo6H7ef+15tjqH9vtiABmRMOecJpytB6wbq8AfDinT34/d+u+N5vV6yVUBRQFnzx04Qv/uofj/uuowuEWhg/+3+/DyIBpxPyREiHgu/+kzPSdALREUQZiurBBsVIF8pgSoigOFPjNuxE1iecS8XKlgLlMAkeX/8UnBLo5Ydg+gCgGVUUSglCFriQpxlMCoZAyoKLFFN4CWUYdHxLXZm6BwsFRqTdLpCKRJNhvdXOJV6gRJimxQJJ3O2q6BgWg9zeJ8iqWOmCdTGbmVNCoqPZeisAUuSkUF2NuO9Dfi3VAsNUQUzIKWNdVhSNgCXCNB0dhzAlmmYfkDTFXyKbM8CEPJmNWkooWQZGbDPUqMAjgRuRWbujXRF9VmvY3NQUQILwsRYPHIvZotk/gQ140JZ2bDXUXERrw4choUgMxwKNWCW6ohQBJXZr12beuBWJi+Fq3N7wOQGgrKAkkFpQtYKRXTLY7SWBjUexcWGBKQBkBeoKaAFgWBcOR7Pl1guqKGg6gtIMStaXZRXoYipCy7JiXS2tWKipG0nU1rZpOoDI0gq9evUaqq9RakHKHkTh45TJbU8VLIul27osF7e31IYwBFOeHU+TtiYPLzDg/aqOu4R9RQ5uSVs/CYQEm/fCvqPN/Bn+BZAFPikUpQJFPDCEGPlwsutKVz7qwYAah1kgstj7JipgD6aK+pM7KiROIKCIun3PTryjhrEi7PFWd3hbulKtSKT6wiZQqO8H/FwP0MK+7WzKU+AMcnya2IOCWMHSx/m4+wrSU09/DUsJpmxjTo0EKLpiDAC9l1+8/ONZce/lXu7lXu7lXn7JZSTMRFTvRlXBfw+pSEoMkEDZoiBAFuWap2TR7B4lUX3TJ2rOXFOmcAnCZlyHi92dQlKhMOOOkECeygLujG7qKrGp0goVRVVAZIGK522lZFEHiIjdDEuPYG0elVM6kaana+iQhzqoE8fDN+R2/Ej6GSOqA6C6ippCd+o0skx8EZrjyr73jSj7ptfdPh4Fwe3sdqXGsLa+JAgi5RUUnuJG3LU2MM3DU+bWVBBvQv+j64BEGwMgkf4d0o0y89pYW53wwrnnTm6QgsKJR+Yk3RiHTqLoOUl3G+EmzzgCOLr7HQjZz/ZM1WEl6v171edkoFEoAwgqlCLllxm5KbkBgACJ3BAdwcegYFC0pSuXGKvfo04c5DLejpPX/LmTp0CCRCKbVutmtICo/a1HmkddyP/uzW/90ruUhopHnTaRRWN/+uhpUGAYSGTtCYCBHDAylMM8b0EmaWQwvzCDGtELqqBQ0fG0JzEKqZFmxn7WoW5Wkhti4zH2zgFBmok+iCgsqBrZRMyQ1LoCWpE9op883VJzHBOcNGCggxFbpAXzxPMptbRxE5FBSmdT7dAE8i/2uRTj/EA9igwiSCAkIqxSzFCGdeJ8yDaneiRTdhKBVIbUimWpkLoiv/ypkZdYkTNhPmQcjoTjccLhOOHx57/xtQgzt8aH9zZiVnjOhN2OqbB1bSYLsoyNke2Y35dxDYlSBSgXYJ4VxxcHQDPW8wKZEk7HA9Jf/gj6xYtNLQ6/8yXycQWRpVOyuc7AAmbC8XAAc+7RUR495K+ugQoB1rVaweabaoQxjiRVFPgTAa4kob7WLMujEWBEoZVAysiJwU6oUtS+JgogxV6xWtFShRlJUhxIqEBLleTvOBisCTkl5GSpeEpZUGtxZRaAaEYo4gThQ9RN6JhPxqdN4mtHMoBR7Z1XtWcryYCsmGadThQzZ5vrbIbx6CwnsKqQq6P4CugsMmZLpaUiWGo1gJAT0pQwHSbMNOF4POD161dA0XZvq4BFugmMBAcVRHSUOlCTGhG4jzZl+6Xl8a7S0szFYSPw02S0xxE8KNAAsbcK4kVfryK6SwbQjHwvBQewgygxRmJBbe23qxEysSsadQZQleokFgGFkpaNjLZHaSBwjb1Mj9AMArGCbByDvQ9CPcze3ZCQbqTs1kvSSZhEdrqEyhbMSbR/16nvo/ZOvP0+a0+WvU2kia94ptaO54g3++vfStm12QBsPtKoSRv7IjYXUK44ffcVODG+/IvfxvL6JeYP3uCj4xnHwwNKWW0/xIppypgP2WT6oR456WmqYsppizv1DWZb+31ljvDe1qexfzC5g6oMCKHCnJGJKj54eUROcsck7+Ve7mVTqH0n/P1Pj8BPFYzH9veHjxUffJKMAAAyMkdKkEqYTowf/1HCuix4/Rnw9KrP/f+QU023EmOOvt5z3vrsVvnou1/gg08uKHTEsioui5MjweYwIsY8HbAsFSZ0N5kdqIqJGVUrqqfRIcogCQORgJKbnWYLmIDUIsDDCVVrxdPTEw6Hw24tvG51OHnHcotg860U3/NQwwZiRQpEg1raJuiAq4wYSKSWBAOiqKuRsHLy9B6ktm/UBGD1Vnq7WqvHHvj2S7d7GsJy0xaKz19+8hYPH59Ra8JlYahmcGoWQxuT5LhHQ2SoYyB69czGt2j8uq5lHwO0wQ5GhQQ77l3KRNq+MQgTJxzmGYeccbkU1PX8lf320fcX/NZ/8oTHlbAoQ/KKy3L6xoSZW8/7l12GHa4RZv78+6NFiHSsOH3yBY4vC6Z5AqcZIqsrRFoglamERJicgtWCL6CCujxB9YyVVhxmxouHGcvlU3BKKIeKaWZUIlRlcJ7dpk04PbwAo2IixXp+BEkFTZEGFw3nHZ9xKK3wDruDWvrulCcUUcdNFKAzlvKElAXEDwC6Ckj0i9EkDR2rK7DIiroWJJ6Qk6e6LWFDKihXSL2gqCmnMiVTx3TCC08WBHRZKpb1Aighc8Y0HR3XXofR76lvgsA+RD5GmmGR7qRnyv7ucVN1ClzTMGkM9pzbuxrHOf7qwVWhzFnFSBGA45y8fWc1nkVgP8NxavAUVMxKNlNTG1lESEBUXfGVkefZmheEDkTQmpGWWhBOm2cdiySFkbg8pbCEsiWsbSZGa+d4z2pdoPXiRKYVnIykpQAq2NJOL0FkSAAAIABJREFUTwcQZYAZVQRrXZFowGDR0weVYnM3sc0lgavXqljXMy6XxW3gtOk/Ym7PoohAF23PM/BDqAWKoVoKrnjG+/TMMRc2aHgAH2v14KWUwJw98LYrfVvgxTBHk2Mafl0J44wIU5pwOh2xrhecH9+Y3ZzN5ouAYgQRS2zs90XN7Wa3STklC7qqrsZEBJEwtlPDfg1LihHX2xirEvt6YEijQJou2laZtWE6NLggYk0C2fzS2s4gNrUocrVYgkLZ05UHwdU6qL1vobSqamqGKXEPwnFstuHD9/KtlDth5l7u5V7u5V7uxctI9OiEhl7CiApiCbXIVN84uuc7yDaRL3OUzDdZUHdSce7OcQwOCOkRwEZOsI2ieog5AUiafIMczoEOg7RUBLsNVuT0bBKGAMYI5d72bX3Ur7VVqvC/7I7d9+e+777quDh2jNYZHUDdwAMw/A3NJeZ1Fm10GPXoBJPy1eYwUerElL1jLK7YvhOaO7p993p30lE/zvyYo9IEtQtykEvaZt2Bs+asuQ3CPO+4cncrDe0b29EupxiqAYA6sR5RtwCi+vmxOQ+Hrx3HbexEuguRnmrFzhvqGBVR7w13TklVc1gGQSsckA6IBfA1jk+hPhYUUTc1RzinndG9Nxyu+9bO7w7Qm86/m0U3YzCiFOH5syO3dDQ9AEMARia4lR5tmA8w/C3GtfVbREnG8bfGxXaMNvi7vzqwVCUY7m9GGoGafK8ogd0CTGkgbW3a5ecrPMpHW7qMuHcct1U2EHe6dwUdkLjTOZyZVvVwUosItFYDfsikXEFGMjB1mGzAgPbzAGCaDgCcpFhXLGuC6OpSxhWX5YJSshFrJGNZK/JhMVDFU4dJZayX9zOdouXzUcBpZ1FDUVZGXdPN88j7NWmfbXhDlqHhifaz+uzRAUkmIE8EIlNFYMpYk+LhQMg5Yc2E2q7mo7cQaPWxVm3OyCcAbOmK5vlFI3zEVNznmFAUEmNPCSFFjnWxaDWBpcdroA8itR45eaZC1VLRmEKM0Rcs1ZYBggGiib9HdiwGcLWCk4EItRaT9/Yc8P298HGTkueEtnsaADmuO4yteoc5+XvEYYCE/tW7Ew1UjHdgeB21ofGxZm0BqT5fEzqJZBxK0g6WiD6LcVEV60KQy4SJD5iOjIeHI16/fuXRWmgkl1Ay2y4vw9xDPb3hrbnR5nwHsVqzN8ha+6iTM+HCbTGHBwDlaQaiveRR4R6LDVFERimLuutEv2mK9ykIgeTOInViX7Slk3ijWLRjhZIR8UJme9zzBckv+qWPESOOXkVE+lw3ykCHPPb2fGvnSCQev48gaCd6xTrdz7kF8t/ab707Mr4DhkaovN4Dj/Xc/7x1IsVstv37pvh+pK+d/n5JAidBmgqIK0pR6ExtDztNE16+fAGmhKenR5S69vSLsQeLMdj2tDf2VRT7xk4GH48TtYg/yuZEYFKoFCznjKdHxrqO593LvdzLr3MZd9v7vViUqoKUM+YpoxZTR13WAi6CaSJIUV8bt2Tcf+gSM7LT/WNHsGlPn7W3hZNinkz1QGhCUYbggKrFUxhE71ikubial62f4ZjutjUzo6opBjBc1dX3MJmHNVBCvUbbng5+/Lj+vA8B5vaa9ouXDRY0rNnxWatf7CV35oOogNSSmI57M3MM27WmaTL1Nea2X93UAbsLX/32DduG2+Oh7wgaQgMAmA4VzG6/NFuCoTJBxeoOa2nHnADnT3C7eozN/f2ua6fDz/u/Db8NOJjtha73LuNn13uqsL9dBUfhAQaR8vXa9hvLfFQ8rRf89O9f480ZkDxB0oKnlTC/PIEALG8Z79zKDTW59fs/1Iyi45ebS3FvgeDx6QtUKniBI9Jp9oBB9f4iSA0FTwJney9Ix1Q8DE4ZKQGlFlwuF0zzASYk4YQzIkvnRRlTnvHi5QNkvSDBUuCIFLBmeITEZp4YbYZ9qk9qM7wCbksmTmZDkOL8tqAuFcu5A23j2mAkfiDNiymaKgFq6VmIEijSq7mdaWovQ6Aew2wvGDkisQVxlrKilNXGmwdEmC0FiKSuzAGyYJNIG+N4MVyUOZRk2hylQWrp9ku337bY34ipWtDFiBNu35vAE0dbaRtU2J9HUxuRPt8zsc8jw5ca0aSqgtNot47zwO1CLYgkAm5snDBHaqUtrthxQyfX1Iqyrqh1RdWCaTYFVPJ0siwJoUbd+0nAlFzliHb16evQ9osxptoa+zSeW4zZsd9j3TB7ylKYdxvynV3TnvMG3xfHMrT3xWiDNtIZ99knAoaJTE2JUwbI0pAdTyeIlCFwWVqdZRhngYdG/61LwTRZGrbok8tlaQpzOU/Xa7mn3W1jbRgave6ENhRBpoju+EykuMp5AqBNTSm58mnvJPhiMtzC2zTeZzPe20rdSTJbW9/wMUs3ZoBcTBfPLIL38g3KnTBzL/dyL/dyL/fixZxlPX/46ByKzyOX6GhIpTQ354IRVDphJoyAcKAAZqSEQ0Z065ToG0tuRoOIoJTiKZliEwdMebJNIUd97dicMoTYzxPkPLmDTFqdSikbAs3Y5mYUBBPb95Dhf2gKO7Sts9TuvI/2dlKJ3XuapnZO9N9z6a723+N6EWFAxE0ONK7JFLlSu/NK1eEijc+sPY2UNBhtV6AIxiRMAWShbW6JPJIrnL7hDHMj9BbQFkCe+ua5X2/fv1tn2H6MbAwWKCw1lTeOTLAaA1lBB3ZMcyhiMJaBzr4fysaxSAzOPcJhW0+7+Viv9jcxEMR+1daPQM9Dawa53a+KpQ7p71jy+l3nbm1GObORO94HRbp1/g1H4LvL2LcDtB3XCyLDYNypwmSzIS2v7tiP47Pf9O3wbvVxHgBleJBHNMrGp005squbpRIhitGt27EBBwyMmeBAAXkKJbujzQ19rhOprspRHJgZQad+5bGfrK2e8sP/icrO+N/2qUiFSkUiizDqQEtylSMCIUBzK10ty0AQygkHZijsWlVWlHrG02PBuix4ehLMc8Fv/dGXyFPBixcH5Dnjy09f4s//l995j3HRyz/74zf4+IcXcxxAIFog8hY//bOP8dP/5/vPArujyczahYQ3zwiuerA5t9P6FIrjccbHv/k9EE+YZ09TdQDqpWKaCV9moKBHfRII5//jQxA3Gh+UFJ/8NxWHHzKgM5iSky0qoAGCKBBpltRVqMJwV4aooNTiZBRbP6dpdvLg6mou0iJtEyeUYu9IciBlXc0pnhI5SaJ41JfJDa+rzXnJgYucLZIsJPm3ZAIDYRNn5JTbGhT1GMHR209nJMxswcHxWQDDPD2sZ9fz2FfPN5v5fgC+EqemiNP+Vid8+X9+F7J8gocfv8KL774GM+N0OmFZFl+bDACV4N0MgM6mvWrqHc/NiUSjitewV7hR7/11e1RU7I+0rQeNNOkRcuLAZchJj31ZyorLpe9LOpjI0MMBmPrzjPklzh33IlHfcd+2r3OUcU8HWP2q9Pzi4/5nXFvinLb/CJLZMOeP6+uepBR7j8R5c839uvUcMWYbhdiPHdej8fz93uPWMfHzxrGk9q7cItVs9hQDgcnaOyNxxgc/+gIqXwCk4HTAsqzIecbhcMI0HXCYTyBkrGXFWnwOUbGUbaM6XF9Ersbi9cj0eTbGEQy0TMyYcsaUKi5PC/7Hf01YLwLHYe/lXu7lXgBsnaFbt5qV42HG8WGCSAKSYMoTLuUNPMufOV8sF8n/D7XfltgXxnef0QH0ufNWLb/z8RP+8I/+Fq/PCqQZS51xqQAo2X4OMKej2yqlCFR6tLatv52gb2s3b9aKEYsBrjGHHi2+dSDGz8+2+YYt+G6S6fuXfV1uOzKvlU0RLdrjE0NfjOeMWIv94YZdj6/vUxvH83iuXv28VSa61XsE4Pf/+d/hw++eUcoEUYZUwlqBUkLdgl0lIcCmsIqoYTl7zAF4bu/TrarrWu/qdmOfsydb3bQNxj0TmUKkgFBFAUrgPCHLESkfrs4dyx/8qzOm7yz42Rvg7QLwIYEw4eM/WPF7/+ILzJXxv//3H2J57HvDb/IsW72/5rlftygU4sEwMT9GJdIkWMorTOtLzMcX9lxdOTqwB/KUt8lTqKoCOc/46MOP8frN55imjOMh4+n8CmVVHI4TpumIlCaUQnjx8AKcD5gPD66QCsxpxvntG1OoDWWZoV/G/fctkpuNAxsXTKb8MaovlwX46z/5Hupq4zoKtX8AlMBzwcv//E/wtvwMy2uCygTiGRH8kVK2tDpcDbNQARDqp+TpnryXtWJdVohWpMSYUm4EE2JXU3HCi6nA9ndC1QIobOPOTVHnCr9yO0xEwZwb6YKZUeplsIWpYaApmUoUJ1ORbdjzcP1bNtfe9mi2keMb8D06E4Gkp2hSESNpCkCckFNGrMzvKm1N8zaUWrGuBVIFoU7ElJqZLDLUz4kPpZTmS6i1QEm8r7yP3dgOtZ95njHNGSknrI9P13W6YdNt1jm33W4FY4xYWoxj+9XW13mecTwesCylYR/c4/yuSkvdRVuCU61oY0kVGyVV56Bt2qBiGC8F8SSeoY+LsFFVdai3tS1nI8SEvRr9UWvZYNnjun0rMLhdE9dz+n6uj8+anZ1iz6GbPYod97ztbWpxpowsGvXo/WPfhx2XGqYGKERoaO8uyJeweWgbu/defuFyJ8zcy73cy73cy714iRQxbRcuOoAD3TkWG7qcTcb/8c0r5LwFcmxTGZvVcF73qJUqArksADrAoDKyroF5mjHNE6AWOaFSIWVByM4zA6WuYDWHsckzFjw8PCDnCaUUnM8XVxHRFi0Qm95aLb+qSGxsa3NQmSNzCy7E/ouGyK1GpgGGnNt9YzpuWsdN8C3g6jliSPwtHIIpMXKL+PC0N0SNIDLUuF2TeYiyUvuPht8VcA3F602mQIfUU52NHgbkcFEz9qm7nwEa+is24+1Q/7lDSqFeZIaO/T2Y5HGd3rfRUd7WTesJjTTkRlrr87gGwjLqz8qUQWiDho5OP3XZ1jHSZkzrNRrY4zMkwsY4j8pTS0/hcp7kzioGSOgKIN0bNN3J5scBG4O7E3PQHNv7+t2u7/vDT9tzgsglzajeAm/Rqbcdl7f6EIDJcAu5T9vAxAZcU3Igkdq14wEy+lgJCoRqJ8m0scUEpoQ0WY5mU6WqEClYPFJmXXskSgBY/rha3VtkCQEhXxTPjjkhCDcBNNW6AkitTTYGCRHBEwalzVOW7kzJ+oNg40QVqGIip+KRTpbWiaGeuo6QAGWP3BUQJhBlUAJyUkz5BSztU4VWwfmx4EmfoHTGF1++BTOwvK7vPSaipPwS0+GlPSsmABVr+QIpzzePH10Rfaj0XOfxalJL2USoJC0DOHbfRRZclk9xOr1EKU8QUZR1Qbk8YSqMpb5AwWHj5EHhNp8obP67LJ+hPhWwvgTTd5DTDM6Wm7z6/GrAtV8n3gUl1GKElXW9oJQVsSQu64JaK5bLgnWtYEogJwGImCfaQH9y8MdAsmUtEClQLY1sYICUjXOpC6pUXC4W7SOenglkIGsQZMiBt4jw2c8l8ZkRTLoiDmApihBvoAN0JF0lxeZd6WuKkyiqYDN3WiRbaiBUrGlWXwvzM4Lcdj2N9VpUQKQWTZgMGEwpQTNDawJKQqIJRAnn/4+9d2uSZEnOwz6PS1Z198w5B3vBYnHTggQEGigKJpOJL8KDTCaTyfRf9aKfINOjzCSjQArkkiKEXe4Nu2fmzPSlMjPCXQ/uHhGZVd0z57Z4QMXunO6uqszKjIiMcP/8889PJ6ylaF10KNFmmiZouSevBx4x1gkHYNfm+9kOqIFLanf7QLvEgao2k7Fb0gzoFXvWe5aYgolaZiqMQS8RwFT9PONMgdoM4Kj2gUjf2YngtcdrZVSXprHa70TU+kttISOUCVCKl+5SYpWCg7D75TYfVA3HbRx9xoP0LMlx7e/21y5INiii7Uk2I1lpfJ1AWOva5n5fy/0yfD+0TMxmvA3BirPmfe2rySU1ofMA4vj3CGx6aLXbjZcBTP+7rWiNrG0gPwEhJEw5g4Lum/M84+9+8re4v79XVbGy4nQ6AaKgJMmwd5AGYkO7GH+OPHhj1xH8mdNScylmxJiQU8Dt3QE3x4SbXJBlxTIf8NSrrFzbtV3btQFAC4aqbdD3PV8xpwMwrw94/8C4uXmNkCbk6Qa8rFgeF+QUcDgEqPbflhD9DxECGTyL9kr/+/JeslbGu7li5QMEN2C6UXUInEBS1Epi3ZO7r9TX/0BJ9+7AYF7BtCXGXAqK+d/+T8+tROmc87NBrP3djvsV8Hzw62PaS0SO/X2cXUnDLtwHVkWOeKHP13XtahAWrG2vwfa1C+3L3Nnev7j03g4xsnliduPmWP1tqQmnNYFZy7UwA6VaCSlKiDGcKR64jzE+Gc8Ric6bDD/P33+JKLW3cZ5rjmeouomWfI35gBAzBAkpf4Lj8WUZhzR9gleffIZ0S1glacm2eELMK6a8gB9nnPfm7l5efFeG/+6f72+nCYAK87EcpgCD8Qb5MCHmB4CekPMRIRyxFlUaRSTAyHViCXJcBeuygBk43rxGIPWFcv4E/9mf/DO19SVjXQWH6YAAwiFn3BwnpBiwnB7x/vEe7774HE8P7+C+q2NE3nwtGRMpASN3EEGqACw4hEl9j6IlousawAioK6Es589ekIFQKYKnpUBwixQCStCyu0USIBWFZ0sSZDBWqP+pfgtXwrJ01rYIYy2rKmpCfcSCFYEYqGK+neEoTS1TfRsnALn/6grpfQ2KhqlqGduyVuQs6EqXSoDw9UnPqxh4T44ByNReSimqEHyhjb6u+nlx8zqo3wu4okgFVTsXwfYPQY4JIWaElux1uSlmqET7NKi5isoUNayLK0NIYwQioSWsunKMCOPp6dHUXo0kQwQSxrpUnE5PqFxxON5hyhNiVN/l6emkiWDYJVRiuzfs96QY1Yd//fo13rx50+ZpL9lUt/ioYQ4pRRyPBxyPB4RAePfuHk9PT3bOBHpmvyCK8AQ8x37VtyIgOqEVyFljJMyMdWWUMmJn2s85aXmiWgtYKlgiIiKYK+blhFpWhKCq0f59fg+n06ndZyfuJNze3jR7qyVhiSquNb/9TDnVYyJ01r/+e8dcbI6pZFibm4plFiPQdFXZ84lm5/JkJSotnhCsDDYAxbWEtYy4iJaH9jXKP+FYAbnN4mXQLAFpLx9/bV+5XQkz13Zt13Zt13Zt1tzI8IBEc8hFVN59IBZoQJYAFqxl1azYSM25AAagTGCEFh6CShqc7YGo/rpmtKp8JZwwwZpRL2ALjjNKWcwQ1UA2BFjWFTkdAAmaoV8YKUU0xQho3cvRGA+BUIpnLgBiWecjJtADfMCWACL+/w1YNQYYxyDKnt39XLsENHWDVSyW6IF1oEtkunHbncIeOOmQzQb8sUCKB+bPHZUhk2n4fQ9E6HGjIW41ti9kd/VvdxDGzk+eIe/94L+fQxobQlELBokZzf1auhFt19zmsgAIjehEwbPbnGDRLkxfC2RBS4BcmWQDPI33SdueJgDBnVy4T96C1t7LVQASRZn3getLIOk4r5wwc4b8eJDwmWG4RFDRW38ezPT3vZ87WWZLeNkHJ/vntwpWe7LY/hiiMChQh+EWHeVpn8YIX4r0+ePgZSAxYEhL12hmK4MJiE4ewJYIBXTJ0r4OdJLVCOzqNVvNaoI6fuxKJB384KFMTggdqK7V1yov46MEP39GQlDAyFWmFBhXhSFUBW1cNtgfICf4MMTAt6EsGqCgZjRVLimQulh9bcE6Kwgm6wOmT/8WTsAjOKmIEYmQclJgKCYFSmNCOnwGrjdKeBJ95nKK+P4fVkx5wXya8Yv/8Aq19BWprWSkAGMQRjCNZH+PSOt2+4ibi22wVV8t1ocj7v/tH2KZDiArT8O1QErBKQLlYdJghJFbbEUY5pKe7/7/PYJ+UUCIeMwFIQKf/qkgvQZQfR0e5j8IxtezvasOa7fW8F7LasB+Qa2CGPp3657ZlaWU8FAgwraPVjBrxl1fH9mAvLIBc/reR00Sfdyjx/VxS267pASzGyUneXhJIREDFfW1ptzU6mxfAvL3yiDYzE1qm8D4mU6UEHAHdMXHXnD4/XfIccLxdwpga2OICYxFJc8DmYx31p2NI8Sy9JycOn6f33nrAzpfE8766ey1c4h+DwiyEXz7mkatDwIcvBQQRZsjqRFdlHSMzTiCGNXLVxGBmLFaf+mzHO1+yfZCgwSZQcHlvvuazqJlNVXhKjbQW4xgPZJARrBttIM26kW0lzPfEpL8tc0+Rbp+bj8rLcuRhn3ZicNQbM1s2cvNrRt9pOx4x6F3waTNcfu9sn320hzYgp9tHtn4aoGkvkfqGAdQAKYpIeUA5hX391/g/uE9Dia/X2tRAi4zmIyo3L7D51S3A3wPax0K7RuyfSNEBWunHHCYIqYEHCfgVZ4u3tO1Xdu1XZtb4G5L+drr7ec/ZmAS4AD88M8FAcBxOmJlgNfF7Lxoq+DzQb7fZtt7u8POtHn9n/+LiMPtgvt5xakmrCUi5gmgDGEgxGzKhAJhArPu9zEoRqEkRk8y6TaPb4VjqUPfRy9erwBSa9t8PGAGPO/PnZ/j2ynFtLcHPuaYfhxw7uB25eOO8ZSmJpxixKtPM/7sLzNKvccv/7+Ex/cvlwS6eC3Ye/jb9/Ztf2c//ON3uHsNFM54mivWwpAEnJYEiCZsQNSXEKhaaCefQO0R8p/UMJvnfPfz1z/8LO3t/5cIT8BlnKo3w1JixnS4QUgZhQUxHvHZ9z/Bn/5XM2pdEJMqxuq9A0DE8e6IQBMOU0KmrGkBMQPhBKpANWm7S7OHnnln69WNn5LNmvVtNEUs1W+twhBSwoiUiLf/4YdIOaH8gEC/9xYpfoIQDiALU7p7JwDYyXbQJBkRQkoHAAWVFxBlvP7ku3h6PGFeCnhhgAqW9amtVATB08N7vH//BZ4e3kNqQQyxYUd723tP3vDXQoi20KjPsK4LalmRQtJSyOHys+3XT9JmCKRmxHxAThnVSiiHEJCngBAdZ6hYVlVwSSkjZcV853nuuKsIallBJFaKvkJLVrnKeTE8RRDieH0jSUNAppTja0pbZx0rJFK/xRIY2kBtcGUvoRw0MUOsLG0Y1KJ3hJlLJML9Ou/3CSMViIOJ9pOg6sOaGJNUedgSJ55rTpiJcAzLy+p2HExEUZZAmvzlpYy6wo7uZ+s6WxzB/C1WdaVaVqzLAkAwTRmpEYdWrMuqpatjx8xfWn/GUkuOU2hZ6q4y6+cZkxPcF9Jr1+NPTzMeHu5RK1tZoZcawZNbzl/3n4JSFjB7QkxXghn37RBDU9shwPw9e28gLY0/lZhSMcYXxnnhsQexRKKxz0RkMz8BV5/ms6TPPidesBeaXdeTYHy+PHcMoR9DLVZRdSqHc+xWRJM/iNAU2psv25TFHXPq7z8DJV/bV2xXwsy1Xdu1Xdu1XZs3M0SctOBNAIwKH+q8sQWsqpFbtnL+DmxsDMTQSxeIeYBEPXtcIOCqGbIxqnRCKYsFhFXtIUVCMkbzsswWXAqNjCMsOJ1mlKJGZSkF05QGeURX0VHFmZw9eCiNSKPX6Nne1gceENwEdnoPvcTeb907OALexsDR3kndv+bN1VIUDxvryY6WohuRGO5pMFhFf/eQUv83TIUGJAx9MvwNU+ZQA3UIXsugXrNre4CnZ3X04JK+7X3vKjpjX0jrBz9aBK0UxCVySZ+HPeteA2vJANoemO3EEwOr3GC3+xryJ7egWbu+3hfN/Pf5Lb2PPFgZPMjFOmYdE7sMML5ItEIfxQ9+dueQje0SaHL+Gd6oRvXA/ctXJxYMvhQgHclA47UQdWKRB/Ta+2ffgf45n6vjp1rN3P5aKR7cJ8QWNASIIqYMLYPDtR3XyVWjg+b9rUAWtWkS4NkPPis6ACLDMZY9xrXdXssisjkXGrnL1Tisvj3Z3DBHHA1wH/udQcGcZumz00FZZoCFAAoIcUJMGYSDlvsoBTIxwvHnqKUipQBIUTWTWpBCwOEw4XA8IqYJTBE53wLhiGU5gKxkFBHhcLjD935vwXd+9xEP7xh//3cyEGaGcYeg2logAKII+ixAexKVMtGPouEpkMdbrP/xRziBtscKgcnWSHB7/qvIRlciWOi9/vR1uyb9WTB974S7VwRBtr3DFDuCKUXZPPYsYkDaPrhw3ZSAycnrtvvcCwokQNf4EATzvA4yvGJ7MHdlGekkUid5hZAMoBtUQEBtCnjd8/2z3vfKMcNuIMJ5Vs9uvbUJZeCMPRvcyYpnAA8u7XUGIjVAZruqbNetvje0EkGsxM7phyuOx6xKeBwQU0KeDginGYWLlQlDuwYKAUIJJMNzYfchIm3s+xX5ejXuW1tY/qU2yppv9l4HlNpNS/tbxyBCxMsCOsEzIIYAJhtPB62IADJSoN2tSFdc02yw0va8gF72odQKEgEHQUQvoVlZVZXaU+bBG/iU7/NlU7JpAPk2thBtSZYjUesSaDqSEjdzhvo4jHOykWXavLlsV23GbbBL/Eb3tsuLrS2vPai139/OQV1VylJ1KgWlUyLEpARIkYrpcMCUI5a1gkJFjILKC7rKIFB1E1GSDcxO8u8l6VULh3k1dG4LrACwUkwBKQCEipyA33l1ixC+vNrYtV3btf1jaNKtMOorjbef/3sBkPDZHwSkv1B/cpoSqGbdc6CqfLz3A35r13+5jf7cpdcFwB/+qODT78342a9W/Ow3EyREUIzq/xnxu1T344Ipigqm6WDBJrNryXEBansqsN3XHFfZl030shJsdotnqY/lm/6h2iWf8qtc06X92+2G0X71Prx7nfDqLyYsa8W730Q8vv+K14+XPVzALeztpwTA7/3hAz77geBxPuLdw4KnmQEElBrbs0KWGADHeJgHgq/t3wC69uCXtEs+5h4v2FxuY3+IQLO5YcBsu4iCVP/LAAAgAElEQVScD4gpQ7gACLj79IC7fyFY1xXTFJGCquoJBwgy1hJQiycxdezFHT2qdLFi2zkqg7NXRozEX3Es7Py9b67xYE+aWwEqAe/+9o/s+j5H/vQtpiliShFAVLvTUTfDBwRQJccYoMQqgUhA5QCuFbWS/U6ozFjrCQJgLQWPj48QYSynB5yeHsG1IFniAGBlii7iL+dYkjBbggehloLZFFMTVBkpm+LTpeb7gpZbDkjpAEoJkAmQAJ6AlBMORwKIUcqM01whi6DUFeKlj0VQ1lXVma2EHXPV3/UiNz6C9mHHFv2tBonY794fjhWGoBgzkRMtnNxgPge2focnNez7kVmQUyfnjFhde23wD0bfe3zNff/mmEifW/65ZGQZt+dbyZz2sdHf3h4LdDxV19NB9XjAsFRpPpkyt5cmrx27AFlij6q9CFdTc9aOdkXjAELKGeBOeBn9oz1GPpJkTqdTKwO1f//SmsWsCq7LsmJZFjw83GM+zUg5G/EnDtfQx6c9A/YM+r6sPjjbPNE5sa6r+dU6djFFVeeRPgf9+oUZIcVGlvE+DYMC90iGAXrJpz25pRRNqmpl2oe9cJxn533ix2xJVaOtsT1uOx79vXHuev8Mq/IISQ7nIUvm3Z29zW1XofW+8ydHYwP+jPd18tq+2XYlzFzbtV3btV3btVkjuJTh9vXRyFNJQg9WKNh1OBzQgm7iJYK8vinB8wjcgPNz1qq1LJuhJoIqoplRogECtsx0sgBNSgnTlLEsGhiMMbfsaoggT5M6UaOEqAUTqxnVVVEp5KyEGQ2mZAjsOAJAVqKpBRifY7yPP18mzjjoMDqgoxHcA28XHH6iXo+VuvOlTqJfQM/e7sEQlc4k0iAizODHKMvoRql9j0eMW7BwF8zrjrsgSC9Ns7l/osEp6y6afq47rP1Wx9+5Bblg0OvZnLSgIMSD3g4QdvBwz8B3coqTZlwBx/u0X3F3lNzKl/5r75t23YTnxr47cNwcUACb56AFBzedTENAFZtj9u25gOIe5HgOrNzP6z0oexEs8TnQyBz9XGdwVDuHH7y9njE4eula9RBq3/NhyHL73Xo+/1t/Z/aAXyf09eB4nwsxqhRvlIB1XUzVQFWtYE5/rQbuXwIuZevka4a/QaoUEGOGwxCAl3BxIIeGf/6M6dyo1R1nd94FxceR3Omn9p5Km/Jwyn5usmsvXCFVn6YQIlJO+oSEghrtvoVBVEBgsEStQwyVX15rQHlaIWEFQsCUK8L0BW5rRE53SNMRKQXUVUvkxJhxc3OLm9sCIkZdgbp251qsX4REy8KpzkwnvpwpV4l274D/aDcqUc3hIhkOZfuwLvmqPjTOtAArB6WngWtXAMDp/hH5CaB8wLxULAvjMN3iOB2RQmrzwUE8z/zRfWZVRQh7LrQkS5ee9zWTGUjJz1M1c0m4Ead0/UAHC+sIjGxJFyOgEajXzu7PxWUZdn8+tqAdd5hZH6h+HhjpyJ810jn23M7Yn4/xWvVKA3XFC/+sSx2rGkpsgSBmvSbfy0DAsmjWZc4RkS0bLkVU1r2QQkBlzSgkSJs7oakxaZkzHmvdj/9p+/U+e+/SHj6+PvZzXxgViI3AMAtLKYAEhKjkiRCkq8qwGHF0/H49tkuAEyha5pmpwLjNpBmZjOkwWfks3wPJqmkJwBUcBAjRApl2/fYZGvYKVQU8J8AA23V+8/7QV/t9yY/z84zH6Vp8vlfsCYg+Z3wMuj07ZsxeGqO+X3jr5JZ+jZf3LYareHVQ8Pzz2+P0X+WqwG0KCMrnBa9GNOIMqQlcF4AqYrK9TAKIrORVywiVzXPjz6mW8/OxlnH6wWmFbV2KhBQJJBXrqWAGg48TgFO7r2u7tmu7NqCvCN1+G+yw3XoRguCYGcIVgZWYFyZVYDmdZoREON5qDG2Zn8+O/2228f6mSVQZEmj+2y9//R6PMuNhFggFTDdHs8lFS11wgECV/tQGYIQgmKYJ61LUdqFOhNH9R5NivPSBvz+SUkc1224PDSUUgIt78rZt9+2XSBiXsJDnPnfp9/GaXjpu9D+9LPT4mv87K1mC7lt7xnugCRSOyEdguingKijLhxQFLlwb+pzeeitbj+28RczzivuHgnkOWnoJel8EtTPV/gxgmG1miWrurnXvw7+9B98/TGbRJ/KrkGtGu+hjSDMtYBpoUChUW4MloHJCoKPObyZUKzmkaiUJBC9to3M6uh1m/maVQXHjxd+euZ9nX7m0Un1zzUkzQkoqDENp4bIw5oeKUCumT0wRUqhdkfuPaveqgm2I0VRTgMqEZWUsTwXrKuBKhokVUyBU7LPWigBVuUopIpIqWkgI3XfePUeXiBwQIKkmCbjWppzV/n1gnnkfBwlIfIeQCDFMyElLCE2HjOkQACqY50eE+wqg4vT0iFJWLGXtvphYsqWT5CSBmkntSUc7bEq6L4uGN/oTTYYXqq/tBzg+K1I3r8PUqns/SVt/AJiCuajQ6uhn73waYFtSvfkp7nMAwxyoDWPQtcHGDZ7E4fo91K7N780T8zD85olGDXe0dTPGpM8o23xsw6t9lLP6HbWumOcnnQvMSAGQQJC1olZGWbW0c6QIrgXV/V0Cppy1tOzKZ3Nt7JM9TrmuK0QE8zyfkUjO5iv6nrCuC2rVBKTHx0eANDnA1XKYxfBatO8l8h7ysYMDR1B/25LV0Kd+TKZ+D2BdFniSoRNlqu3dPhKuCu8EoP1ePGIx++dyvNfx39h3o1/d/GlgY09cinWcYceG8zjONPrEftgeG3ZMx97VvUw63tb+6dTTOV4teVAYgM77ykq8EjCI0jBGvRcv4dDX9tXblTBzbdd2bdd2bddmrdSCdV12DnHPhlJnwRUlxmAHqdxwiAB5PemIdVH5UDdkW5USO30g0vIYEEA08DUvGpTO02TlBarVptbvLGsBV7b4nAZonPFfpCLlaL5Pzx5QJnevRwsoQFVqsXJSndWdktfjrKh1HdRztox1NxTdodd/dQjEdyPUG5GTiPzvfQDlsoM5AkMKzLm06CC1j5Es4wDeCDqhGcf6PjR7SbrRCqDHoM2ZZBnKHPg5KDSnye9/VEMZA1rj9Xvr8o+AZ0Y3Yx36mnDvb1cOaIY/NLtmVOehGBGDBo32/Tb2wegAedDP65tLGxMehiIMjrF23EWsEb00jzQvHu336oFN8iyC0N4fg2Wtm4gs0/y87YOOm9IX5jlfIrlcGovxnPvP7b/v4l3TdvzauiAdTjz/vAbrXT7VAc9LTqCfuwr6fAaaL/QiqAsFYzpY4sdIhwlIgYUQks4vm9eluoNGRmJRR1bL4ghi1DlfqpbTUYAlAXCymn7vCC6J9DXSnUwioBad18nWoNbnEBDpawRqhDCBPpPCpkgQE1KiVpoJ5Gou1s/MmtlHBYOXDzjoOIAB49rODNQiqFUB+xATpkPCjQUAvE8UBCj6vFMFY8FpfcS7N+/xxf2M2+NbHI+vEeMB03SD3/vBD5DCrZI7ZMVf/ncz5vlz/ORvCD//9zft+x2Gtm+CkN4vGcg4Tq8R7mz30iAge65sDjFtyRttphpZJkjAXp+HQWeUiM//z88g/IRP/2JGyAHr04LEB1BIiOmAulSsy9z6tZSCeXlCSqnNSV3XCL38gBNOyYioCs7N8wmPj/eoXJXkiaT3UrV3qgVIgICcY1Nzc+AH4vswkBIhJQ0wlFaaB23ewfvQnkt/Nsc1GCxavgykQfjaM8KDsYu0vjrbmmnPxOY5tPWevX72mFG1HdNxHwhBs2sDKYlEpDQSjR4bGghUyqwzQJR5MB0OuOVXOBwZMSakmHF6WrTvhEGipYkQFGAurM93Kby5tnFmdJLxcHc6ETuAJNtnyyIF6Khu3yt8n9I1khUUZCXL5BwQIpCSZljWUkEh4u5WM9RzDsiZ2tivy6LZWWTrASlId3P7CjEElFoty3dql6XKfBW3d0ebt27X6H4Z09Tmw2IS2wCZjHRoz+AIXvrnfRz99RCC2nRDDXX/zKVg2/iZWlco6TBan4kpDUrL1mvjYuf3clVu13qpKS9Z5kC3fifr2t4U6bpK4dguBRhFXCFpC97uPzfadr7SsbCS7jIhBMHT24S///F39fNmi8TbJxx/8NZI0wlKllEyT0RXfFRimZNBfaXr/dFWNQm2/mkpvZgzcp40S1hWSCn4yY8FP/l3ghgqnp6uYOS1Xdu1nTe319wbeG6lkHoCP74D84SQXiPHI8IUMJ8K1sr40X/JSDTji18I/s3/8elv7wY+ogmA//yfLfjsuyvmdcXjuqCK4EQFb3+5oDBwuH2N2zstl8e1oBYBV8bxcGuZ4F09YJ4XeGC0+ZGolmmekVj3imVZWkmGlqE++INt70RPGBn3XuBln+lj3t8H3D7ms1/2e/w4tz2DSTlEcgJG2Oydo/3nysJ9Xw1AnBDiATG9xj/9y7f4vT/7KX79swU//es/f/H6n70+jO7H8/doPaWfjwc8nVa8ebMA8Yg4KVmHZQXXFVKrjduQWBZM2dkCs64kqmoPCT3MiI8e34+6v2E+XbJv9p+9hB+EGJGnjNvbG0wT4e9/+Z9wc3uLu9sbQDJq1WQUrmLrhdnvEpS2SwLIClcv1vI6AIUEkqmV89l87zP38zE9omtVX7G+LQvHPPjmiwYQSAj3P/0OHn/+O5huAv78v68IUwUMU2BhXUMsyK8JGEqYXks1/27C4Zjx9LACNOFwqzb/UhYsywJm9f9TAAIl88u056sQpDYNnDPsLee8wTJdyRMpIqUMDoKMjCpkfhfj8WE+UwnzfvbqYgEEWjP4X/8pwj//GW5/EHCcPkFMGQBhOkaECNRyh09e3eLp6QG//tUv8fmbX+N0ekIgQs4JpTr+pX4hkBBJS94ozrQYfolBDaWrlIz+SgiKTUsQhDD66e63uN8HMK92DiU3xnRseHcICTlnEBFKWQEQUsptPa7ted+SFXx9H7G1QN1HYAaSKccEAnKMiHSjpDLWpM95XnXeMEzRJUJVqbpS+og6uw/lqvEpxe7NChkWpChIjAEpZRwON7i5uUEIwLKc8Pj4gNPpCZWLluRKltBRC9aisQX1OxJKqViWGTFmxJgBCOanJxyOhzOyx3M4prcQAg6Hw2Y/OCfIrBsso5QFp9MKEZ3bh8MRrqCv/a++WxyxVccwBPBES0/ArHVF5YIyF9RakHNCtLhBCNq/p5Op70AT0qbp0Pq4shLBMD+hViUCRRtb38v8fva4r/dHCMFKL9b2jCrxRhquSBRw8H3H5vSUM169/hTzPGNd1w0u6995qd/1PbTnw+MoMZLhnf14v+48pVYKrVazi/RpUkwqavxG17lV/XoAT6cnXeNSNPuIIEWJT75SU8NyXav16qN+U+1KmLm2a7u2a7u2a9u0bqi6oaRGoRqLwGA0OamiVJNlVNJLKcUkCc2ActKJY/NgK0HDqKVqdoMpnohliWuG98CgF3WO1aDnVjtVGe4ZasBqXeOWfRHUQ1LCgwbjLrG2x/rXozMzfq6Xk7pMCNDPpIE0sQWwyIJwz7G2W4fi3DAemwc5KEYALhUqXUp1k40tF4PKwwW0YKaPlR8rEM1UZt6YnZ59PPafO6L6u6rZBALEDWcMoUSLIQlgqhwOcmmE1KUq9yCMg2J+rT7fGkHFmFjdYeL2Xif57Nn2GKOfm7u81D4MNPqx7F3bgnPnxz8HJX85sOvcgflqGWQvtedAz/M56n3/0rl8fu3JZ5fP3V/gRiQY33sRkB1C7mdgovSnzYkKro4AUQBL4NkS+hyNz7MC3sC66s8YMsLwfPfLktYvdlH2vOhzHBTBASBGAovteCfHqOM5QoMOdLVL0/NHLePj872tm0RGhKN+FgmbuS8itg6HPi0FCDGCwkjQ6s8ZS0Gx9V5E1/GYA2IgZDCONwHzacX7929wejphyjeYphu8Oh4AqXa/wPF4QJpe4Q/+/BGf/fAtlqeCv/tX30VdwoY0AYN7MKjCXBpxGzlTJeukGTGiDENgy007efseAgJqU5bxfSdATBp9COIXAhedyxRVkSdPWQGUomSZUmbERHCylc5BGz8xYMagQwcfAM1KIkQAjGIgy/HmgHk+bYCztr7YdSpRqgPu5CV6hpv0TCaIl//a9uS4D461whuQByCQgE2NwtdsX1u9tj1bMIdN0c2ehEaoaBMdvawR2nvjuuCA1UCisAPCONd9FiiqDid2nn5+g/nNp0CuiH/8C4Bg+4eVzwpRx4Rh9ofbOX2F6Oem3e9xc53ktwR/2vwZ1FP5DFUgLbS53J5p6TXjndCRUoIqzOjeyrVglQJhzyavOIWIWrmBgo0A4mtN2JZHEtH54GDtXo0NqM0eGJShVXkqpZYBP+7TmkVY2piPRE6/rv2erll5UcuRDyCgr7WXyDOAq8uojdMz8cc+7DaKvl4bgNdCIwOw6iDhfpzVdiR7VrZEmQ+1/Z7j9zXaIOMeqHNEEEjw9PQIPOm8qeUe+ftvIKLAJzMDYUEIk5LjKKIUI88N6oCNQOu2quj5dSlQA4UIWoKsb4vw51FLQhQIVZSyYp2B+RQxPg/Xdm3Xdm37tiEKXPwE4YvfJPyr/+01IAF/8hcLPv0eI6YbvP7kFR5+MyMfJxwD8DiVf5AV509+lPE//Y8H/F9//WM8nVaEkEEhYZ5X/Oo3TzjVhIf5FtPxiLvbCQLgcT6hzqrk4PukrAV1XVAWLZdyc3OHeZ7BLO0zp9MJgAcuxewtLa/g2dWqdkmbvXcMKI54jVstI2EG2JZFPG/bZI992wciX8YyPtxe8iu9jfdHBLXBn8FFxmMdz6m1IoYKCQxBAtGE6eYGFTfIhy99ydvr/Mj3HQFYlwUsFcwReUrIaULlgrWaOi6sPKPfLATuATnFwhVHPCHMx+vjx2J/VZfbaJv08314vEZ7JobQ1EfKeoLIihBY7WrRZJBm/hKbuer2/RZ3ghCC2TEkAZEmAOsH0ZJLPuLl1y83+ZZWHnFfFgPqVwOkBpQoYKyIlMFsxBoWVF4hqCDS0sok3QfUUjhiJZh83igGqolkaisH6URxVwM3YBKyI607BnqJiOBJhOrD2GzSOuIGoRAophf72RVbAwihZMUEUsV0BA6HpIomqI30MR2PgDDuXr3WQLkA83JqvoC6hKpBG8jVRrp/cGnNcDxxgzfqY4buI/gooZUb0nMqfkEBIJaGTwHdFxnVvoKVau7qYWqbuyLG6HPvy9e2eSNA8+vcpSdCjNqProoirHgSKuDkDr0X9z/PRgMU7DwtCdXv0XFXYE+CKEXJIZ4E6CVyKOjF1lIxn2ZNLOMCCkqMOB4ngy3IkhsSJlOH97G59BPYqs20tWZ0UofWVNmHzwN93/Q4gvdJx+4DUsxtDymlNJ9aRJVaQX4tvmoZyQ9oe7UIY1lmrKsqxkQvU0Y9gXNMbPV8Wr/mWiuWZbFk3tSey1FNx7H7acp4fBzxf79HJdKMBDjvZyULHZBSwul0agTcMRbQZsh+Htozst9uiFx5ePu6K+cEf0sCQsjIVn4qhp74EsSV8V1JOyix0tS1OqYQTK25Dv2/Tbq8tq/froSZa7u2a7u2a7s2ayNpAjgH/MfX9I/RwOwBjlYygfZGKO2O61KZLGoIhegGoDl0ZlALi7lWTpjIEIEZvMmcDSXuKJtfAFICjpe+UAfIDed+DR4Azzk3pr2WuDCZXAu+xNjVVfS+YJ5VD8D08+qHerkdLV/k7RJg9dJrG1ACHZQAuvLL6Ajpn4S9ItDooDVSiRm9Dths/g0gDdrfGtTdXm+Xd9QL6Lk6wkOwU9Qxa99vJSLGvvOm2d/AGDz1eRRjryXcrh3bPmnX2wLSDIxBM6K9TW93su3/zd8XPr991wPAI4hkA9K+2mpFD05Fm0rDaT4a1Nk4NR950Fc49+6dF4+7RJzRsbLAOskGENivEfs1Rwzg8zFu4/rM/dLGX9t/SDv4/N5caUWJByKq/OGfdedU1adqWzdC8LJuoYEhPg+cQOb1n/tVuaOfLSjrQHTPWhlJCu5gqwoHd0fd5j+1fukOs/eY9lkceoIcfW7jAggQohKFCEAL2g9BYzsfi5JrWIAqWu6IKBqJz/YAOuDmkFHXE5Z5AZcKLgu4znjzJmJe7pGnCcfjETl9AkoTXn1WcftpxeN7xk/+9fkM6713GcakzT8F7xp5ZnMO2Y4EoT9847zZz98ObbZWSsXT40kDICWBDwaSVVP1wXYfcBWzZZkHUua2PI+DfiJanmVdV8syclUqNuLo9q5bJipU8Q0GjG4IDNBAjD9BlzK4nEDhWdBnz2Vbu23dbSCMqZBIJ9H0PaaXMMO4lm9GZguCbQlztkcNNomuH2EzIp0kwOBoa/wpo3x+BHIB/5ARj17fOxjArJmrwkrkDYSduldXbmt9AGxe8+8e78VLUba1AD5efh7/s4/9eI/B9nVVA4ptnajVJ2lXUFnX0gBXBQSpAUosRsLxvrf9p7K0dcIviMiIZpbRTcOYiL0ugO1fSqgTW4REeomzzXjs5tAYdNsDW+P4bskkI+iJBtD662MAcd+8X/o19Gfy0mcvBQnEFoxzwtSH2/7eL+1xfl/6UtDSa05AI0K+c7uXm7R+oMkCZwbioj9T7Zr317hZwgb7SPqe6WTpWitqIS0LZeprTjy/tmu7tmv7mHbZfxKsM+HNL1TZ7I/+6QlAAQVBvpkQckYIGQgft8Z+K41OQHqD15/NiHM1xTlCTIzvpIQQJhQEU/kTIBAe5xVzUeJqoAgujLKsKKdVg2ZCOByOphChfjSg2IUqH7htJwCMmG8Z4yK97JCTT/elKrb4TS+JoH9/vQDSuG9/E+d76Xv2xBz1y4ISBexzl/bR8RzNT4taxiGIlp6heEDMd4oxfd1rxbl3KcN/x6bllczvtTFnUXU9vSslS2FTutzOJbKxItXG3X7znsR0+Wq/vba3zXPS8qeRAPCK401CjAJIhbCqyzS/WAQIhtkBSr6wXnG7iyToM2B2DaH7V8CHsZnn3r+Aum3O+231mp9XEziolTZVH21GEsU4a1NCWbUciYjZ73b/ar6ZisdqCQuWkFYFqpypP7svEi0BxBVZqCkgj/6NE0ouPmtBsQIW0fI6hpUpqS0g5oyXRoUBaGEVQQThcAg4HBkUF5yWFaUIDsebVtImIEHyAcfDDW5vX2EtK06myKHX3csaq3+QEETAphLj/ow/Un6v7ue2cRE0pUq9Z8DxGiXBqG8bowCkhcPUz97jfn0d08TR1BKiWl82f/r5IP+5fySGm6p6a61AES2nxZWVQGD+vtao9j3meVCx46oRKSkGXgq3uQboPHABdfdTFe8PcP9UyV0VCBFKkFixLLO+RpqoknJq+xQZbpxiRIwJp/l05i/ur/ND69y+H8e567jG1h8EOl6nTnkIAcfjEdM0YZ5nPD4+GgkzGkmtfVvrV8fJUgq2P3dle1V/zY0UtBYl4VR2NXMyPEavI1s5dJItocuxmb1iXLT+26yHNr9zVpxNRCyhZY/zqwLPsiwopWxsiA/28/AZP9eIf4yrLhH18vVQdSQt+RuVSOQ4GIkqPBGZCr4mMQkYtZRGkNP4QNx+PxSXupRkc21fvV0JM9d2bdd2bdd2bdYCeRkYAiJ2Ruc2mADAQ7HGfHaABqb4gk3AbZtxzBa7ISsXIM3Y8XqozlLPISl5RdTNU9O/yyICWooEZqjHOKnUn5UsUseHTZKwG/4a2GUDrjxDWUs9dZlFdxi83EAPfo2tZfuwNEf/pfZcwMTbSEDaNzUoMfS3B0s9LDwocLQySTpaVXp5DL2vHjBiqcCoVDM6aZavUpkhqObk9PqlgBORupoABqIBD4QZ8cBMO7/3RWhzzPtjTwrSe+t5Od1hCBAJDXfRF73mr70gDrh5kJPGdzfXIu2aWhj3o4Jjfn8+tzcOWUAPFNtXyTCVNNjV/95hNmdtDBSOffZN+wjPzUO/QJ9b/myMH/Vga2+793cB1P33tqNEI3k9tOsdJXhuVMZQ/H7stgCIRQk90CvjMaoAwTaoFLr6hq9huuYkeGmPca70ur5+j0N2h/hXuaqMKSmwAEEzpMSINiqlvD13B071SSP072cHU1r/6r1Qm+/+3I6dYs8RSJ/PVnKpNhUPQKVjhTrhK4QAmOxwIFW4EVZwKwTgZiJELFrfHCpf/O7divuHhDwd8OrVa1ComI4Z8RAR4h3SlPGd369Y59nA1YJaGe9//RmEw7OPxUhocejxwp0O82h4h0SVFrwvhZq7v53B259AhEjCuhZE6zvmArBAUABSMFxEM75yTlAVIKCvn13hQgEABlEBE2E+nXCan1DqApER2BNohk4Y1g6bA8OzMhIM9HuKZi2aElGtw3WQPTW7bc73HAVqbF40RRlpPx00OgeshnOdjcW2fxXUGkr0Gcg5Bv59X9DP9TWkZVGb9o1e96CkRACFgDwlI9wSlmVF4WqAshhpQM6+b5+VvV1TdmvVQEJwupbsPtcP3/eI73Wauuh7SSC3frwEj35WbSreHNvLQirBRYXizokpG6UToJXGEqCdt/pY0rb0n86DwU7xIEnuCjHjHgWitleN6z4P6ON+H/A56yTFsd8VMNN7FHGC8/m+a3i0zcv++Uv70n6v63aYrb2gC8d+oMl2Ll1qW3KYPXwSG/ivgQBCikn3hVABYQhHrCsjJg20alk3wDeXBsgP16JiMvaajaGAgaD2a2BBJQGZyhZXVU9LIeDT32H8wR+viLTiP/30BrV+iX64tmu7tmt7pr17o7ZnyBX5sODtFwGPiRAR8P43vx24PiXgR/8k4mk+4em0YA1P+L9//BYL32FeCacFWCtAlHB7NyEQULlgLgtqEayV8fR4Aihgmo4gCagLo84CFEIQLa0yzyfoPu5KadVsNDIfujY/WsRKOFC3qzxotifNjOWYPUjnfsmeWPNV236P/jBJ4+s1vxci6h88990AACAASURBVMorOyzK/42lVZwwowkNqiIYYwQCEMKEGO+QvqFp1b3R89fGFmIARSvDWwuYKhgFMCUHIVdvC82z9aSawXIEhMw37F8yYkYfNx4vAwXPn28//vbZ5p/qPJymjCln5EnxvHV+QgoEqQuYAmIKWprI8ECigsBV7ZCQGkbSfDghxJAgFRCJEFQAp3Y9H7Cwnn1///qmn4d7/bZDr2wom/pyjHV9QJqUMFMKtxI2apM7aUNt4hijkuINf4opQar2a2FGLaupm5rSSvNqHQOLPnob322fEOCt+wGGP4gAgUCRAFZsQLVxLx/vTSDQJ8C0St+/hvySMSNhmQvWwuBXqtwqIpDK4PUAeXyN6ZRwXAJyvkcpK1rZ1KaWA6hSKyHAlBJlm2jjS1n3a6X1vwf+R0KF++zMltyHThDQXBXHhbblcrSRrefSCBtOdGDuKuf79X0M/G+IhIZlI+j1zqeutuS4tZJq2gIBgwieHY1A1FRiipVQ8hLkjj1pHkVAtOtz5ZJSV5RabS3zMkyqrlJLBYihavAJOSZwseQUUyHiWo3sU3b+2xYjHEkiY5/4HtDwPGz3jvPzjHitjpkmYXZS04gt+Hf2hDi/Bv/+jrW0ZCd7RnVMlYjkibiOm7B0zMVnSwiEaZoQSfEkJ/ms69rm67g2+71p+aXars/fPx4PuLu7AwDMpxnzvABwUomSZaqptPh5x37z1zaYDs4n0942IFu/+6qqtg2JKvggdP002PrlCjJeeq6UFSyKsXp/un3EbOPRngmN31y6lmv7eu1KmLm2a7u2a7u2a7PmGdYtyuCGYpPsB5zYANjbQoghWkCUBlUQdaS8LMPG8R6CvjFlEAWr7UlIeUI15zCljDxNzTF0w60YOxvw4JA7LsA0ZZS62PsCYaBW2TD7AQtQDkbgNE3NSYghaia1VMAz4wdgotti2wAaS4VwHYznkfRhAeZd+Qg/9mws7Eu0Hrka1c2BFWhNY7t3DaBZIFm4gUo+Riw6ri7vfGZMmhNduWrAHt3YdmfSA4G1+j0MWSc+pKQ1SUEAN9WMFsJxn1GNZptLY3DU1Xtc9rNPFw386J8BveyCjg9ZanTP8JB2fWROamXZyFiKCHp95W3wcz8cbRwvfHocLy+l0UAc6iBSJR0rd45eIos8/y3jNWnwdAOM2jP6TfsKL81P/65NIF+PQiMttXtFezbQArvnQWgiLVXkQVx2IhrBHP+9LsWFazbgsZWg2AS70daDpkxgTq8ve2Kx9vFvqwc09gJ6psPwTgN1fX7rs8DCgGeV2HzhChB5eSUnpug/f648yZZA7cKi1fptvUHa366aYbIv1pe4QDTZKmY0gEf8NYGxP+wBN0USYiXGGIobU0SEZoKUygiIqnwgBAjj5phwc1jBsoJ5wVoWnOYvsDwsECG8e3eLwgtuX32CfLxFPkyYcsSf/jdPgDyglnuU9R6nxxV/87//JfiUnxnxNiJtBvT5cT5L/N0OixJG0ox/ptMQt9/gZ5wOr/DZJ3c4TAVg4JAPQK1Y17llFwWoAlHOCdOUcX9/QkoZXuudmbGsMxR3TAihotYImggPjw84zY8WVOEtMSuQZTzZ3Grzx4H2bZacAB04FJXBrey94P0koDqAHcEkgJF6r9nY+nPjgJGXXmxZRNSvB0484GGE7IEbIe9GEBiAIN9b/N4daHSbxBUxHCiKISp4Kw7IG2xDhOPxiONNwpQPAAiP4YTHhxO4WvavEAKNAFjfdzckPu0I+0travcZJwamDjNJ0MkK1M/S1sb2366cAzh4VbWCGlwiW+eTsN/YuK8Gk+VmsFTdE0LS2vZGOnFpZwx7vAeY/D5FtI56tTU6xdTWHCf2OWDcxkmleVQN0Pbsse95AIMBU6lpJJ1O5PVrap9jbvtBsyq4otR1My7RglHCovLiJhevalPB5oPSSrYkqB6I9GF10FAM3NP94jJ4+1xgoeWEy3bOe99tSEW1ExwVJD3Y+m+kcBaIRJTVnz+AWeWocz4ihIoic+tDvW6VgK8+EQmdEGYDo4Ql6rhmZAiU8BeilsqkQDhMR/zxP5nxp3/2DhN9gf/1f/kDPD5eYbRru7ZrO28vey+9+br4H/+fyX6rAL6w95z4+dtRtTreAP/D/wz88jfv8LNfvsP9Y8WvHyZwvMO8BlROCOmAlDIWvIfwPWpdwAxUBLx9+x45T3h99wp3xzsQA1wqAmvpgRgSUFecnp5wvLkBEUw9cMU0TQjRAlNg3dtI97Ack5HRdU8ebTr1LdQX1O3D9u5SbH85L0nxIULFxwSbRjznpc+/9F3PHbcn2zZSEGmeOTBgK0NZCi0z0+1KVWfUfS4QISVVvNCxuEMIX67E4kvt0p3s0YWcEyQSKi/gykgUQdHVOiNgiisOwcHskJbEZorLbgWJYQqjHQm8NB6j5/LcVaMFQ0fSzPnx/VgPqLvPm3NW5dCccJgSSpnxm88/1yBwTAhHQUBQm8aSqSgUUGAgBEgCEGO7U/etiRJELCkDacCEzq7+4vpz8bXB35MLpX5HD/Hban52NqyCwViWe6TDEcKEZSmYl8XUY4BSK9ZV8c3gJTqJEGLEIUQscwFI7XauFaf5CcwVOQVEwwiaPwZNRgxkgXkLVHvZ83H8HWdw7M4vXkgUAw4RdVHFpFIq5vn5Unqjx1mIEQR4+JvvYIHiCUEIlRhvwEa+Ubs1YALhFgGEm1ev8Pr33+LtF5/DEygc+VGcUpov5aqsgD9bqvAkdhG+VoowKuuLDasC2rEhBMQUUQrg5W28dK+S9syf2ag/Ecq6asnc0MkMOWfknFEKmhqWE2W8lJCTJM4JI7AyNrrWPa2PWhI7JvP5gGVdAYoIIYMsAZaG52P0ZoPtNZECuBacHh9wmp9AQZByAMHWpgrEkJDzhMPhiMPhiPv7t3h8vEcpC4iAnAinxwcUm7NEgpAiUkyY8oQYItZlBYGQU0atjMf5AcxiKsUYfDNs7htQRST3Wc9VQqn5OQBamWI9h+Eh5AptAz5hzVVgSql4fHzEPKsScEoJt7e3SOnQShd1cokArM+vk2yWZW1zw+fFPM9YlqXNSVUd8tiH4XCk/vnxMLXxSEkT0r744gs8PDwAAO7u7lqZKMdcTqdTS15yjCjGiOPxBnd3d22fXNZV1wGG4QJFEUfr81JKKwOVc27YREM4RP3rhkHLUL7Nny9T/tVhs+TCRsTpmKkmEaranj5PBaVUMK9gU+gR89vbPmPXUauqL6s/Ww0Hcsz045Jcr+3j2tXTv7Zru7Zru7Zray0AokZTHKWQgxqhbhyqv2UBERhg44EHqAqBs+URnPUt8MxtEUAsEOBODvn3iUrvwQz0YplbsJqx2pSZHWMwQ63Lhq7rinUpFjxSJyjFDM/OBmiQ7ONm/IUA5BQUrAgaAAMF5DyBK1v8WQEaYdd0QItEijlYmwIRLfCGzT228EkjJHVmvH+Hvt0DG/CAO9xR06BkP9bVY3pJDQ8Eeea1u/5E/boBDygqeBFoG0h3o7iRBlRA1ox7CzoFJ60IvHqLk6zYbtPlZkFAEDe/zBmVLgsLGkgfAwvBSRZ+dV6CwB2DDhwBGji2WxTZOLTD4JjpzVsgxeQ1GxTjYE3z1xw0ar05BKl8TgHutHSyTf85XG47JUGzxvzUYbheP5//3m+jB5dD6KH9oduw+Y2ozcV2Nw1EuORcSPuxzc3xoGWfawIHD8jUpExeerjWfiHaTy6lG6x2LTNbHVtq4yNOiBqVm7iPyxCJ3EBb5M8MCkaSnwZuuT+n9sNLsLS7tM/pYCRAgFpmAAIKEdUIETEli8VWVCl93EiBLwU9gwEcAcwB8DrTAKpUBNg9D+JH0lS3xJbXrYxqCNHARp/bqkIQxoAsfH5bbeTmcPoagNbP1Mo87UaZaJim1IB7XTdd6pdR1lVJBylr//j66yQjShrQDglABCFhWRbMy4K3X7zBvFTkw4yUJxyPCb/7/Vc45AmVjiA5YAkzHAz7UJPhky9/voNHfdx9vd0+D3uY2QE8gJBCxs2U9TyW1UUUUcqin7KMMs0uVsKnKqkBLvHcgDZTpGEWzMsj1vUJZV1UbS3HYc91sFPJZGSLlJCppdnaD+l3qZmAWadZiBBodmE11RgiBoKA+QQKQwk9iqhMgASATeYZCm7oM6IEr8qsZC2zCbxaITly0nH1tvf1lVbnVrB53P7nwAppcMj7Teuma1axkmIZXKWBjYEUENX9yQtQCQKiKpODkPMBtwhY7hTYA3NbU2pdABFQ9Oe1SyfDt2UJGPcfB9yHrcHmy/ksFLNfWgk1QPvMfuq+AguY6EqmMvw2r61kDkuF1pyPKo8O9D3UrsNnsmdoR1L1JPh6AqAwQ4ww4xtwkUXtCYqQEE0SX9AGdlMGycs4BYiruTg5irSwXWVdx9mUUFxdJkVqhBj/erLZaR/UsbBO9fuJIfZ7MAOFS20AZ4ipr8XS10Tfs4i2imzSnnsHx2MjzKjaS88aHbMON5l3Y4CB+kSg8b9tD24TpP1sIH0j2Xg5vj5W7YOooMhgnvXZx069zAFKv7gKI55qP6jQtRtKur4TV907AyCmXlU5oiAhUMJTecK7+4eBbHxt13Zt1/Zx7WNXjX+I1WVdK/763/wMVQqeToRaMwQZhIjgW7ua4yhlhdQFOQUgRdw/zkBlHG4m5DA1jIHBkGABUWEwUd+XbG8IMYFiMs9ay5tUgibfBLLkGB6Sjzyb3NVTyGzI2mzKTrrVNmbGv9Q6XnH5ve3f7v8Cz43YV830HgPDfu6uFrv7LHTPzDlrgkVVWzuQgFighV/UVgJHywHISPEANFLWt9O2XVbAPJuygpckUZxLrOQhDfaNvi/NJh5thmaq7Pz5j7qmwTZts9DNOowWORrZt/kcxGazSvMniaIeLIRAqREBDoeIKUeQRARK4EqY8gFECWuZsSyzzdeqNoljgQmIaVI7PgYL5ka3srsvf/bfZ+737P4vf5pMuWc88uP8yK/fXBtQcQNV+COBJg/OC+aTkqE5mKqwkJEqDDeTju8wr0q8CMEIRmjEeffnHa8b746ltiSPhjewjzEZxuJYVk+EUOyClehCStznUlBRgQvP/9j77kdXCIphFZ6k6Osh78bAp30ICXm6AUBYy9pK4cCwT3VxRAlWlgzqeJnindwwnkA6t2F9Q5YU1JPzRn81GF7ZEzIANLUXB3IUC9MkQp/Hvq7Vqr6z47T++dZHRO3nXknEOyMaBqs+oO8p5ndHxQooGj4bQlNRVYKaYm6W4wAiQQpAJMa6zCjLE8ArQtTStyFFcNXnMMUDpukGOR1VSRhK/JAIlHXGfHqHp9M9aimQCgQwpnxAygcEyhCOACVMWf2qWtXPjKZU331qx7LQ8OvWBy2p0sZhOKY7UsHWL1szRceHoOTE0LBmTUqpVYleAIy0ob+rv+g+eLWkI503zDzELpSwwWJKpHAsQ6dEiLHt18yCWgpSCChGikopAaTzpCwLQs5Ixwk3N1pOKaWEw+Gww5UVj3F1qb7na0zDiW+aYKQqOmxJU66+r2UKu2otxaiYA3XN0qHL2zPfhkJY/fXmvwKwua2kl7rZz/U6SMsx5YAQBLWu8CQfTa5zmpwew6JrQ6kFtVTDT+yZYL3KgNCSE5VMdi0f/E21K2Hm2q7t2q7t2q7NmjBB2ANVrqxiFhB1FRfAXjdzkIUaQK9xWXPKLCO8OV4jCad5/FZL1wziKoQqARSz1bAU4zAoKUcNfLIsXMKIATlwhObQWTY6eZAMcGcmUNTMW7EckqZiAzPc7JpCRFlWAGrc9fsfgYadU9gMSQvShO78dHexRw97lnmPnIzB8dHYbIbqYDRvXFAafzqyYGQdGYJQg+PhZBkF79wBF/uOgOgBwmHw1DhWMkoIAgvVGWFGA2dEEY3GsLmeHnRysE0s6NrmxXh9rVwOuWjJMKcAJVB1h8lLNYydckYIGS5FZFvaZ0O92EcdnSxA+3Hy2q0GATj+YWMWKGyGSRUhWneeOcMDo8Hjl0OwzrtncJz8b+D8Xs/ubfgaO5/JH+z6zW9ZLr7uYNkYJOzEIT+XzQVQf7aarKYgpYwYLSNH6oCvbMEDd92k/Wf41OgjD5cpTiZoz1pXMuB+9xduy7KUbHrp2MUeu2VpAdjWkyRgVIB97XTJVSCYCgMLoRrRS/l4+rw11Sm/HNInop1/eMQ7AO0vGkGBDUwcoVVfW3x+b8aX+wSwdZiIh3P3cWS/RQI8W8tvW+ClpLzkWgWrHIbeAdnaDbJSTkCcAo5xQswr1nXF09MTlqUixSfEnHE4TLiZAuTVETEeEVPCZ98B/ou/YizLo4IbXLCuJ9T6OQDGFz//Ad7+/Hf72J+P6qbtIbiuX7F5LNvPcdX2kRFAeYoViGSBC1GBaVg2lmh9KoC6qkVKGSklkx9e4eUKG/lMXJq4gnmBlmhSMLBKH2W/FkUPFfBzYkWbJ2Rgt819VzBSUg4BlE1OmhEig2JFqbPtFzpRg0RAIkgSwAHCqu4mBAR20l7UojAsxm/gTpgBGjDT1IlsT2nbVQCiBXmCZSeRj42RXpwYQgTNpCM0MGZdFcTSbDJqc3LKGfj+I+TmEXmKoARw1UkdKYDyhJvjESlG1FItKMVgCQgSEGIEcQWX4WLhdI6uVubP7mgLjOo0F+cgcd9/xdVYjJgxzjXyGef2ltsW3J4zttSqzcpo+wj5E0gKnIZ2sfq5QECpTkpxcFEgXOBEEYhLTLOVqLPPcd8fHDATt/mgv5OtnSBdAwRkYLVeg2bIGpjrBh31nUowrHu+fg6fdTurZR6y3ce4CLDvyfYsNHvBycCjHbXdewlOQN7uSZeCgWPmPYbfN2bZaAjI5odtmd3ec7uavARDs0XcXhNVNhztM8JmHPu16rjpGPm8snsVAAhAZSASIFogQAAwZRRkEBiQA1aOkGeCTtd2bdf2j7t9nZXhQ3bb121/9d9+gn/5L2/xxdt7/P1v3uLt2/f4/P2M+5MSTx/nCmZShT+KiGFCZUakoFYTFRALWMqGdBmYcJNvcAgHRESAvYSxgIOgOnmRAhJ5qQ0v/aEEGC3/OhDXQ1AiK7MG/lhayQyxQJQrEWwzyzWDOzQlia/fq+dkGf9tby1//dYxDxq+xwPRXrbm/BsjBVQjcxBU3ThEMpyCmx2t/nPEJ98l/MVf3WM5fY6f/fh7ePzi9hu7h4uNbP4EAQWBVAGLaeaIwMk7G9IMuQ2yHQA17TzJ6Etehp2Adq+NRJrxfbdZhAJEtMys2mHq3xMyPHEumopEShE//euCh7cLDncrXv0wgCuBSJUqa12wLI+IiQZcMUAQEEoAMiEkgSQjQAhAZIkuxKCp4kf/9SMqP+HNT474/O9uXuwGctvvQ31jeNNoe/62mln0VqpKbToWJc1UU5PgaviT/4/RcFZPYssWHG/ri/shrkJNPsNcgZT1e4cyT45twbCpjjV2XBUgIwAECAq8BBLXirIuiHjEZ3+k3/T05haPb+7s3DT801lUSUADvqyUIS/t5N6PHht/9CukTwtCqEg8IcSEtZxQagGljBiymbqqriishJnmJrf76+uvk8ebopAZ3wIdA/e+ANr4Cw0/I/ffxhJASvgopWIKyY4RI/P7vDc7fucnbkn3vfW/O14qzJaIpMQjAYAYgNh9Z8cHfTxjDJqcBvW7db/QUkp1XcB1VdyqYR2Gw4eoxA/zs4uRFwIJgILCJ8zLe5TyBKlKTolGoIsxa/KFuIpyRK0wDF/LkLMtPOq/DftASwh0f20owwS0f6PvhnbLY2KEE8ZCO6oTTXo5RE1K6ziDgLGusxFrFnvWIkCmMOr+riXj0GZdJoRoikCuDG3ltQk9cURMGYi5Yl1mQBg5Zy1rVXWuHA4HAMAyL7pPBukK8EZYROsLXZ+ZVd1GhPH09GhKRmR4n6jd4fMGWjq8J/ei9fF2Ivq7PQnFwFlTefEjbEWzsoOOdTIzSlFiH1LSdY6rlSvTWeyJoOwYQ3OI0eazzmUn+zgmQEghbpO+r+1rtSth5tqu7dqu7dquzRrzCq4rmjEOd5QiXG1Eids9w8AB/XNQpgfyHaB3J6wbwV5GSJ0SNXhMAj+N9bn1JGo0ewAArdxJi6XYOYIpxLh6Rbui5si4aa3X0CRvvZkxnnNu96jBzNjkT/149NO92PbBM+uC4R7dKLTrukB6aE6xUsdbP6OPxND3nT3voMoIvPh3tOClGd7b/gJc7rkTKqBgCXcCVQsCDSVNRIxc0E60hWf89mjb7X5lw+d3QJHPExnm3gZY6wE8d279+0bCiZ2lzUd3DMYs8jELsMvS9nk8fGP7/D7DfAM2jOCl4Pxz0GzCpkTzQnP/oc8TGt77cjDPBvvcfW3vS9kdcw7U+dg4Maaf3VUnhicvhAaQqGKSOkw+/y6tJ078kP5Ku24a3xiPGkgyG7KQLzznR7TrVLBEDEgkhJBMOldAUOJDzgkpRTjY53NSnW69Lg0Mi8q2tprU1OabOvUGgoUdwL0DS8fsG/VR9XeXB+6f2R7nSl7eYdvu3YJH+0ynFhAf1h9ft6qpp6iUsM9/xmY+Ds8yhWRSyQkhZqSs8q8sjLU8YFkF84kQ6ITj8YBpyjjeHPHq1S2mVwtiraAApDiBKGNdF7BUrPcZb39+YTh3bT/FZXi19yxpwqQ0SGXzeR6OY3aAQIkYBAWVvV9O8wkxKTHKgQKtzVya9G0x+XzvU/1MAZEgWekhODhu/djW1PZSB48cFOtT3O5qIAp4nfU8JSM12B4XAcgdiFSmWaqOcQxJr4MVVNOKh2zKRUFBRZvfpY4i2prFJ1WDGH1d0L5yGyE4AGP1xHsGYyd5OhnP55vuMdzkj53UIHYxPl/jTUXORcEqJJRVsMaCGDWza13X4dmx7MAQECQiiqCGgGLX0DMtjdwTQn927Fkdn98Xs7qbapY9r8M4AH6/29IHAjFFIHumh/fGcoPjPlmlZ3q60ttmLWSBGPGo72EaFKFAGtyRilIWU9qzMm+bvcFUs8TXJBtj3+eBZr85SBd8KjcDcNhXpT91Tvrz+/T3PRN2vJ8UU/u9z4l+Hj/ndn/Z2g+7QYI/56MNcamN5JTRtvLLH27j8veY/bfdlvr39u8WdGaoGKBPGMvsnV9cn2m+dgm0xB45WUgYYs+40LCfpAShBCW9JcSYz/b+a7u2a/vH2b6JpeDLeSxfvT2un+Pzp1/iqa6oeUZ+XXEbK2hRE4txwMpVA60UwFKxLA+QoDY+FzF1W1bdElHLP6aMmzS1rGoRLQnkemq+m5HZM7XWZusJAC6d8Or7vNtvAkFoe/M2a3rEWDxw1hQ+LZPdbYOXyLtj2+9xz5FDv8q5PvaYnpQyKGs2m9J+M3sjmM9EgTSbPgTUCpzWBWTZPlx7OQ636/OB8N3fF8xzwa9/Inj84ivd4ke3QIR8mHA8CtaqZWOaEjIATzrSYPFgkwgPPhQGN46a2fCxbfRu935N++7BK+oH9oCqkyz0Tx+LXkYzBMLT0yO++DXw/leEV98TfPZHEcss4CpY5hlrOUFQAdKgvas7iKiaAwkQSBCD2uIejCX/Tqn4/h9mLOUJT5+rDfMx69Bzn9mZXK1K5W+rjSOhcIOrXtTNM9QSrxwXUJCiq7CQ275armRdl1bmp32PKEXGS7e6v6DPUsd61RzdkmU6nmUlSkkVTVRpI2DKkyYjrsC6zjjcACkAy0PeIHuOH7EoTYyh6luqNCNIYnhYR4z6sa8fQd85AZWA94yUCPNcsZYCRFUnYktqCqLrYq3cyuWMvd7xUNjPy6NOTqAZ/Cp9XRWQ/W8vGywQSyIanidbf1JShZNS1uG4YONme0ftylduh49ruIgmBnDzLbQstiZOhAE36JSXlnRqWDaZug1FxbqZC5Z5Rqmq1gMEKCeEIFVQ1orjdIAK3RaU9QGlrFiWe6zrA5b5HvPpHsvTA8qqBKqUMo7HW6Q0aV+EiBBVZdjLObvfGmOA1CEJor1PbR76fqYKI12N+vlFkC7+LkATE9ZXQ/OpdLmRwRd339RxGYs9RMMCbJ/qJ9uTnxi1mJKREZtcvb5WVU6JKWKaDqqSJoJTZazrisfHB8zzbASTihiVunCaTwghIidVaBn3eLcBnGZ2Op3sHBWlrM2fdPvDwwnPKRz5z3EdauWtXOn9bGX1sdJnJMahzHZLIDaSkqksr+u6KQs9NvX1ARDZWtZxkWmaQBCsy2pl6wKWWm0OXts30a6EmWu7tmu7tmu7Nmu1rqi8ABQBRLPrIgLDXvP6oREu9aEZx3tZ28GIBFpg31UlAK+X6TLB3Qgm4sEQBpz00gNHHqDstatdVcY/Px5LUMdCyTU9oFRraZ+BExTMRhO7vpiyGcjbY/0e23H4MDA0kim2ahzjvW8D0j1zrJ8DsGAeACd3uMO7N3h7tpkTBjRrzj81BtH1mqo5VeZImjNCwYx9OEBDCgOyAVCj20lebsaCmxt1ERnuw4G+4fvF54w7H2MwbNtn3vq88EDw4JxK/57u6A6fJ2zOqWOMs3Nvg5bnoMue+HJx3OGZDbQ57761488CZ1+/jd+3uU4a0aGP/WJ9ttp5HYk5O1a2oIEdm2Jq2YCqXGDjOsyT3q/nQO/HgvSuOjU+X5fIaJsrFhOdNhTJy9CFGIFCbZ52uVOrrW5ZM+Pz6P8cCHFgSoOwA5nAnnsHtsb739y3XbuvR35eJ2L46+M9crt3P0c4O3dzgHffM17L/tkbSTp+7SKjfPHZ1TfJVJc9/v/Ze7cmSZbkPOxzj8jM6u657JW7iyUWwAKCiYQIGWU0UTCT9ELTi/6q3vUD+CIJkgkEtZAIQCAAAcQudvdcZqa7qzIzIlwP7h4RmVXdM3PO2QUJVBzr0z1VeYl7uH/u/nkwYCeXFSnNWNOCNWV88tkJBMIwjLi7e4mvvf46YhwAEMZxwu3NhOlwAOMGIoLX34hIDecVZgAAIABJREFUv2q5yiVDI3hS+3fJeHzzEmkZO5DE2rZpKLVPbd9womifxT3cvHG6k4LAFj2T9d3LMiNKQJB2pqWUDMxcKyDaj3sdXwAxdsBiZU/z/auDHy2PisNjQL+SHaK09EQGYsQYMRw8Ai2AKCLwgCEcEDiAQch5xXx6h/HAiBEANNoxLZOSFAmQshg7i87nIRc9ByAoJSHlFYU18rCmcnGDCPkZIsiS2hwTjThzBxSBgGyOa/oqdZbIOWOe57oW1WClTm5KP6zz02UKB2R8DABgnme9xqMlhcAlACwG4PdOkLauWemkNdUBzua8r83nHGaI5Wyd9aDo3gFOu63tsdTJJP21e7AxpaQzoJNB+ufu5RJ3LBFbA3p+FnMa8SgxwAnTPYLM90sYvE27mcjmOEkwzIyBlkdqu7fs27w/8/szu/9sDxr6szbPe0Jme+pc0Msc/L5cejlmKzNI3W/0M5fZ9u/snEHF+3xTi66+/TnrKb24++xSI9ovsl1CWuPaZaVoutRNHwdUZjFiTSHywSfwtVzLtVzL0+WrVHNCBH7lB8FSviQ9l83QRgT89N1n+F//rzcABhAPCDSBMGkKC2YkEayyWDpVQcorlrQijBECwZoTcs6Y6MZS+wgiM0KMiNEc6pFAoqkyBLbFiurPjAJiAUpGkWQR0X5WNQYV1z/Yz3cAIezlgPO/mxGsBR70esH7cIpe133us7+LIiLGFOdOQbz5TkSNrhTY9IvGblyKIKUCiooxgV1nGTFONzVF0ldeZzRdg4gwTRNubwhvH4xRqOSaSmJ/3j+ppRi0Qa5bf/DQSCeNPHHFE2Nd8ZMuNXKVF+03kwUGMHB8eEDOB6ipzQ3OmvJnXRNSXjAdAqL1e0or0qqsKhwyQlgRC6NAjaMwlkXXB4oUTLc3yHJ0ZOq95blrNqjH39FUr9IdKQNRkYSSQ4dN0Ua/743eqhcpc8SaNL1JSiuSMdN4SjYfs4ZH9Hq9MgS5/NxjGD1e59itYqdtVjEFxIERoyBxwbp4vwqGw4y7b7xDIMLp0xctZXbX8QTlqSEURCJE0XFlWFou1yokI8ts7CQnxAhwIKS1IK0JMioe5fiky97O4umytbehsWHAK7I5k7Svtb4NR9H+aRiq9kEInp6sJtE1/Frv4aqDb3Wdp3Qx4HyvbynQt3ibs39y8AAdYyo1nbHhBhbcZc4HHBgcGadTwmk+qi49DNp36mOj51NKiBMQOAPlhCWtOJ4ekdIRy/yIeX7A6fSAdV4hoinAQpgwHe4ABKSsqXKGcUBOgnVV5w1ukRN1IfrcvrwX9Zj5hzmBnhfDoVxL9WBP8rmt+EEIoTJi+7uV5U11ImZluaXqJHOhvoCleiKE0AXyhICHhwcAymQzjiOmacKyLIZVJMMmltpW1x/XdcUwnOP9IcQarAdjMZ/nueJMyprjbdpiepcCdfrP+t++vp7SoWvgkKAyvwKebs4Zg1XeKUXbo6zKsjnX9VUezKvyEDoHSgBVRtIAtBXjOFR87Vq+mnJ1mLmWa7mWa7mWa6lFjX7Vax5QRVWk5n+tqXaIG3MCEZpZ0YSmwtX43Zw/XMhpxoXeyNEzrVQhjhgwmkJVfPyV1eLSjFjEnbInbrtBU3SovscVRiIzM/bOJl1/aGSCGadNKfW0ED0Qol31fk3bFYG90ac3rl8yavX9qAZEH6+90rs1/PQKmEZ4ewup60fYuHgqHRul2n9qNRNTPklYjX0ecYJmjPd0XO78sHcU2huHLwvctDF2+XPO2+nzwVkJds+kbUzL9kX27A4UaMrw1vHmzADWgUrvAyDr2HmFz9p6bsj8RZbz9uALI9Z9f3sOXUBqlE2ljLZ3NKATIApV2dyuAaAudLRnnoEaH9xenI3Vc+Cv7xulG4tSLAEL6X4kgbEuCkodDqPuhUUN2Oo8oyD1JYDL9x8HuKQstU5u1HfHk9bPT7MW7Q21+7b07X3KIL3/7Ow5HUDqP422lhWcwbaOPm77yeXrtNVF58kQA0IcEDMhJ40WSykhzwWlEEomjOMBIURMkyAlwjQXxHjAMER85wcBv/LDgpRmdfzM75DyETkfkfIJOZ3wl3/423j38xHoatXv9c2cj3pNDy/3hNHFzkcxwNBBOU1JpDT69TxDM94DbR30zhxe/CwkADmtcOcFIt/3dC/2fdKZ1LpRRIt4ozoWvg4a0MOIMei6IgBOzytADAdEjiYHzEjxhGGMiIOAKKOUiHEKkFXPx5AKUsh1TiMWENRRyZloxESCbKBe27fbYDAKWAqCFAgCAgShgiO+l3Btj64zNYQcDgdjhFMq/sCMwFxTNfUgjK9JHYs23zkwIkeb4xohV4r381aGAJqzrH+2SVm5e8+lcu5ovAWmtuupZ3/Zgld7ecLvqfdiuz/0887rGGPc7A/sXlpVxrB0ErEzvNX0Ef38NpDTKa9dnvBB855jd8AVJCkoXUTlHjzeMPB1/XTJqaa/ft9X9Uy6AEr373269LvB7hvZRsS7rNAu38px7dXGaER9pN4lWUC63x93Fjpw2cxCxvakX9r7L73L2oUmcwqwS0d4LddyLdfyxcpXvYtMB8Lv/Q8Rb+/f4LNP7zEvGcQRa17BQdMZpvwKRRgpESQHDBwxhKjpM3LCmtsOmXIBBY2QLsigoqlDtN4qp2egOmpAMoqfgRYZz0KQDAgyAhXEgSEhgJCxOD1hldP8t6Vi8uChndx9Se/vv/d/78+/L1q+7P1fpmzb2Z+d7SwUUUYfx3oAsgh+S/FgRjkIm57lBsiIIMNG7r/Uyi87T10/iFFl5/Ju6d70yz1LBR6+88XuBoBePHHZh5hU7g4EkKZzIQBSCk7zESJRx0MyiGDpmC14Q5Lq0DbXixRkySiSUahYmlaq6XGEGKlITcX9Vc1MoV6y6fRl/HJGyWY4Cla4/NjwzV7/wAZLWJalOiAs69JsysCZnNz/3uoU1OksJonWe1X3as4z9mNk5Mo4o84agQhDJEyjytuChOFbD3j9vc8wRMJf//5/hjIz3HG9eIp2eKopQRZCIsEAQhSAocETbA4zKc9IuSCXGSGSOmEUNbiXlBFUtTCHD+4cCC0FUNWFL+B4BAu6MYmcWu36PqsYIsxZBYLIg6Wp1R9PI1z7rGNGdf1X9/ynZ9dTeE9L6dTYxUDGfmJOH50KVvH4rAohAgVMhwnmfoOUE7KnTu7YW3QeCAIlMAlIVmWWmY84Pt4jrSfM8yNOp6MFogZwHBHCiBgPxkgZQAwMw4gQAta0qBOKOTbqAmtz7ek2Xzj7vsC5pG3iug86nqDzQhl3DocRwzBgnmccj5oK3B2k/CxyrFrJXp923unnibdJWWPSBg9KKVVGGA/ybXaCtvY1UK/N377s172Utm+E4HV0lt62Di7tE32/7xqkjl+FKtZVA3ndObf2c/dcYy9tOzYBKBdw4N5etH0G2fu9bsu6IKeEdVUstQYd/R3JK38fy9Vh5lqu5Vqu5VquxQoRoOQx0hndxMAb96YHtpACbQSYauw4A/37iIUt/SRwzphQn2Npl1ymLlk6gyHqOxsdLG+Mkw5c1Vp0BguvXRFolIzxsNZaZ6U1dQN27p/7kSp6LxRfMtTsnWX2BtY9YEVwo3Rfj86oitbPqnA3Sk4yQ6tH3TVbojlBoWMxEDHQrr5Vo7NEDa+QFvlDZEBjb7TbjZV/vlfcVcC93NZeYO8dnSqwKI2xokWNmIK/Ecy7eoipwBfqd6kO/jl1fz91z0Ulj7ZRUM85MTynPH9I+dD763Wd0fiDi2pC9pz9M/s+uHANvF/a3PeoJb/YFVi95ov3R2/E3iutTzXM3xsCG4tGNt24dwQCUhKk1fI3i0di6DOcFat2sQDKSGFOgNKU9L5eHg16sWYXQAT/7U4Xl8AF37/286t/Rm+U768RR39gQJ7vY1n7MMQAJt4C+dWZoB+31kaN0NHIQ4+GEaiiPcQBMQxgTggho2RlVnn79h1COGEaJyxTQloT0iFjGCKGAShCmMAARsTIiEPAUCakfINSZuS8IITxfH5gC4YKWa5u1OQxOI/KJHMmtL2LmvNhykmp+KWglLQ5l/qx6veznlHMWVKkFMxJafsdnAgc1GmnAzHbeetrp29TG2efi8yhvkMp+y36GBFMmpt8iAFMwSKsIkoZMQ4RSvCjxgeOAxZKwJoAaKqWzBkrVogBlygCyUVplqmLWOrOwlITxPsouJORbTGSwfJ0dGVKjSnOnYPsA2gKxcWQy7YXaXv1rA8hYBongJxhJhgApBHlLLljp+PtupNtVPDe0eN9hS9c95SDSP/MNp5bg9mevr2+hwnOhrOPNPX+6N+vddC5xwbMiq2JlnYN0IjUlrpT/GwG9D7SOShFTQD+vdhYij3H05f19dlHu+37w9dLbyR0+bHf3/szWTtvu5b3e+HF4reCzq71s4xgezx1z+0Z7jqH8v5c6NMVbvfeLatd9zbUl9XP9PezTiwdiFrBXhei6mfbPftynxB2fmHXci3X8g+47KWjv8uSc8GPf/YOc0p4XAOKRDAiSogoBKSSUYgxTDeQlbDOCatoQJCUgnXNTe4TAijWCHgCEIPKCYSIECdNgYGCMARwZAQK1fFRLEUnxFJqZgFRQgyAMKFIqNkb0pqVqc+Z2opFU9fSzjoiqqycQNMb/PyvP2Wrkz6v97RySYZ4TqZ56pkXDW0fWJ4yBCpOs3U67XGjNaszxhA1Ve6yzKYDZQhWSCHEOGyxLLH0Mvjq5zHVHx0zChFhiEhpAXgEcdQqPHN2X+rD+gn1ssT7SjPySv33rr5PjLOYG4f/7a0TUSNoCI4lkepfkWuAlqYyWRE4Vn2cQ7T0Is6OWpCzIAZCETEmGnc4MGwQBRB1tGAOmE8zshTAnCku9M5ZC/ej/DGOv3uN9hdVRHQ/GEdn4aQzHb5fHznnyqhApAEnErrUOxa45MPap2lrz1F5VfUaVEzX9YX2OpdpOweeoA4rKc0gUp1q4IhwMxhzUkIuMwSMkhMKAZmUBZQNLXD2mE0/wPkr0aW1YwxTBN+OyGuBIGMYAUGGphTSfogToAxO+qQQ29zzdmigj82BjllWbAzaueb90usfW+wGRBZg4GvIMGvXec3ZiO3HdSBnP97rcrWWHeZU0z3Z3q74bTsDgMb0S3ZtqfUENNC1w8pD0KAZFMzzog6HpH1dxINVDNsQdcJBSViXE+b5iMfjOzw+3sNTOS3rAgjAcbRApgPG8QZMERyixtCyp2IydlLxcSXD0HTfQDnXS/s+2cwSaSP18aWNuzvuMAcMw4Cbm1uM41jP1pyTsRwrW4yytcQNztn/7YWJESjCnUCcZVmDb2MdN03TKHh8PEKDfCJ03W6ZUolI0xB1/dDrimTYhwfAqrMT2ZxwTLQF6Dm24f3dpwPbz80NxuF6P7NtjHauiGm13DGVQvEOYmU90sCybMR+vJnf2zOI7D5/xfk4r2tCTitKUazTg3/CEzjqtXx8uTrMXMu1XMu1XMu1WAmREIIarXLRfMPIGRQHzddpRl6VwlTFYda/3bu/N0pt0xEQ3Om3CZXnqVJ6gb4JaVBjlYgJgo3ZBEEVGRfkNF2DMUHAlAUmVbpKNtBJjTbDMJjwljVShbtofANnWpqUpgB5KhU2BaTVc2vQ2QuYlxxHmHlDm+pCa59CwvOde0Q4YE4+5JEm/s6mxDEHOM0vERCYFLSDx/0AgLSMCCSgwGDuxoyk3i81/U4HHBDBc5hWJbMyHlD1NEfXB3sD2B4AaHlPm4FdxyfbZ1ujvlNler/0iv0GbuyMqZs6ocZab8atr9/WkQBVCdiP5V7p3Qr/Uudjf8/+/npf9/0lo97+uw8t+zmoxj7rm2qIuwCYuSZU69c7yjV0oTcq13rDo3SCGVgFzQ+DN2OtdLM+UG7nPgcF93187ujRQONL3z/fSa0LArNhKQVEuv/woGlJSk4omZCTUgJLAbKoYZQp1LRlgub4E6Mqzkqv3va5vl17h79+bl2iVve2uaJ4af5eum9vNL9kiHdduJSMnJzuXQEcsjEDu1Isde72+19tA5phWUpjJWIawTxaNJi1hRUuKyIoWXNHp5ywphPWdMLD8TOEEDHElwhxwN3tAXd3NxiniDhEFFnVOWR8gWF8jUEEv/G7wOP9W7z5ueAnf/q69QP81DKWmYZ9GcBAHfBdVwEghGDRayLAumasy6Jp/IwQRcHjiFwKlmWpfeLGiz3lbUqaAlAMRNbIHZ1PHiWnCw1wuNHr2YM1/Tzy92QzJogxgxAYh5tXGMYJ0zhgGBghACSPAApubw+IccCbtxEhDiAKECEUKihLwl/9AbCcGK+/B7z6bkaRgpQXxBB0LeSMVBIECmTkYo4RzJrTmwhh0DblXMDmfFF0wiGBUCgbiFU26aRS0lRMy7Jgmg5QlicD7UNEIIApYhymCjhlc84K7A6jdiQaaw3ACmYaa1IQjQT3s7gCoL6XXHAueBrYO997yMZx7xCSd2wrlxxG+n/rftJYinr2IhEDpmm7JrcsO82pTsQcg0UQ4lj7tRQBk57DofZFT0lOlYmLXGYzeaRALEVWUMMWUGn8CWrc6oGwfXuJdVy2537pwPytXNEDgf0z9Tww6P3CmXrpbOj3Z6nCULUo2HOLpeiyRjuQWAF6c7Ksr/J39xG77Z1EGgWrrD4u83j9/KyVem174vvLVpYxqLo4q6TW1evv1yzLgnEc9eyWgEwDvjhAfS3Xci3/UAqd/etjTNStTFPBv/iv71GwQiioAa7oWX86nVBKRpKAR0Tcn4AiAyhMYEuRqekeM7IAWQTLwwwNSGbEIBBRI5gwQSRqVDZU/meCGQyBKZLJhwXjNCEOEUKCVBKIoI44IiipoCRBoIjIAyIBD59n/H//7kWnr5thMhR8/R//DEyryijF5XXemP57GVGkVEcCT2fQ4ydqBD5P0+j/fq58rE65MRzvynPvesqh5pIsJao0KL7DGdjpfTEEZUow5oacc2Wty7lgWRLCwChlARGQc0AuAqKIOLxQx4J9PdDO1f7v58qlZzgSkTLheEy4v094PM64vVOHK4YH1FzuqyfHgwTPpWR6dpylPXtjBH3yXZY6fVMv04GCs1YSiqy4fzhhnIJiTtZ+ZsI0DVhXxXFiUBlCRNOV5NxpYVKQC0AZ4MyIWQ3ubPolE2E5FfzF/xGxzndYHvY95/L5tmv+0W9FfPM3gHk+giSDoAyvIgsEK3I54m//+Ht4/Py2Ob39UlxktoUICMOAEAZkDiBKVWbtx6uUgtPphGVZKlMFGa7pxnGg4YL643KxVH0JsECKMGBNKwJ78A1jGAbbWwJqQBoIZKmyiDXIIwwBwzAqTsmMwzTi5mZCKQlSVqwLdExLgIBUJzB5k0WRAZZ9eJvitpkKGBoUIxCU//f74L/8LoIAL0xHxj/6I5TbhJIFy2nBFBIosrnZCCiQK3vWNjKHfQvO8o7qB4EUpzB003AQSx++w2hCDfiUqo8RBdPjNZ2eiN6fctYxooBlWbGuycagpZJ1zMY/77/rgwYBPYt0XVhqwGHQ9yMAhnsya8of5mC6oiClGZ988gYxMpQtdAGQlOFXEnKOyuxTGJI1FfN9esCy3uN4fId5fkQuq2E6ijlHHjGMt4jxBoEncBggFLFmC3ZEQoisexe5kw85yKyjvtvTnsLOfQ1UZfQjShtqXyeGw7gDFzEeHh7x5s1bzPMJKWXEOICo4SjORBNjxLKsdm4TmCPWdd1gaqXuRi3gLudcnTf1uYKcZwtqGu3+ps+qjq1yyjAMxmzTB8YShiGCOSj2Yk4k6nxjOj/UIUqDiXJ1DgohNoZgm3P+Dk9ZvcGqSNcTBQZDwMH1yRqmZX3sYyPIIl1/t/FTZ8ls87zZYPw1e/24nVGGcShllAWCqTzkOMO1fDXl6jBzLddyLddyLddiRYUSMaDfDAVUTG0BzItEZSCj1C8ikKxUuMBT0S4q7eyZE6owWVrKhL2Hcfu35beEekpvpSEVJsU0n2Y4NEMHVAmvSqPfwgyYEQ2kcQ76AL3P69UbIrcpn7yvWj2eM0pf+nffF5ccJHoFqj0EnYNCzzbRABB3EKn3OXdq7zBj41k9/KkHCaT7j8ypoq+7XWc2os40BOso1AS4F9p+ybDoRsn9dXtgza/ZzpFt+/d13T7XjJ5karBs39WXczDwvA3vM7r5NeWsHc/dR2fXPQdkfhkwVEdf6pzafuN1aHXy/u7rJ+ZA4Ebly09pz5CN8tQU2P241anaGSjf1x9tnavWdcnR6Lnic8nBOQU69F3KwqHpXnJytgZY21sKKiKCqpI+5rJRAh3Y7veTvv6XjO17Zxhga9Dd39N/t3eI2Zetc2P3XjQHC3c4BIxxys6LSgfc9XFfp7rv2/wSQY18gpCCocS2/9o5wMpKElAgISNnQijm3FiSUgIvDzjiBA4B83LAab7FNI0YpxEgwniYcBduMQwHEBFefavg9rVASsJPLrTT/yo+htjOXQfx2k4KIAvWtAICzPNJgRKI5gVnRinqcLAsC06nU3XA9N++v5+NTb+32dqCp9Rz4K+eWa3f9+enG919TsfY5hwx4cXda4QwYBgI0wjEmLCuD5hGwu0tILIixtnmbQQwQkrC8fEd3n3CWE+EF98AmLMaI7hUAD3EgAEDmEeEgTEvC/KyVAfUImKGCgJRrn/ruWZOsRwQwmBtYHMEDZjnBfO8IKViUV/eBwrUEyxdVDhnMvKRBKhz3NM+97+r40x5Pq3S+8reIc7Lh+7ll4wYl85RB1h7h5gqC1w4s/ZpIDd1JgICA4gGhpoRSrIC80HXrc4JA9AZoABIyXV/0/Uj4CL1nC1SNrnPfYwv7dF1PXQ01v55v2b8nv0+WHb3obu/v+6SzHmpf4G2J1D9q1uz9bY6oew7S3Eq/XftHOhG1t7Vya6yfxYAai7PH1y8C3bgI0wermNGrX/9Z13XxkoFhoSxb+y1XMu1/AMvZ6rD2ee9KbTp5R9SCCq3/MZv3uLh9AanJUEISEnPnHHV4J4VGQGMggDADUdAzjOy69HIKn+mgpIB5sGMUCs0twgDxdJ/UEDkqNHuouei4g+CgRNuJsZ4iChEOK0qzxCrMy+IcTiMiBwRoFH8KIzHN+emhzBkfIO4Y4SxvrM0iNUpkxqTSq87eEBNZRcgY0eU1vs9LvCLKM85vnyRZ/VnfT2b7WePv5RCoBhR3HgOZSgplhbX9Tc2pjt13AZKYQSOdpa39CabNnyE04TrB/vPvJRCuH844e3bFbkAIUaoAPqFuukLlyq5PCODXi6OEWwZAFyPd+aEdT3hMAwqU4i5V5jj+TwvVfb0sUrGMOg4gsNbvZMITC4JlRkz4d3PGOsxnu07T826w0vG618JWJYCKqujWlATcsa8ZHz6F2IGe0fF/Gm/TNcZAocBHnVB3Rruf9QonjZGbmUO3crD7Z5eR2S4kyDQycBFLMVSu67qXbRNHSykKZjI2GyGMCIXHaM4RBAT0rpAJCFLBhAQ440F6YmjrRWPbChr3xN6TYbYzs4ob29QoA42rouP3zlgmgYspxXrrM4C1jCAGfzkrGhroT/DPERmP+qKA5Xd3LC9rgI8TW8vJvO7c5II1JFv8JTH53rPpX3Tx7DHgusemaWOVQihMqUSGCRaB2fUEil6PkGQ0mKsQHo+KTNsBiyYBLAg2ERIy4o1nZDKPeb5LU7zPXJeAVIdOwTV8yNPiPEG43gHZtUTsjOLQtPmlZQNS2prvs6rD9ArnnXs+9BCwD4FVD1j7LN5nqszru5fcaNfO46zv68fG8Dnl/91SWfX73yNxhgtsA62Rvt2N0edlBKkbOePprmLIFInrDZfpGErwhrobI4zMarTjzvdAahMLf1nfYAKGaAk0p67OZ+7dtb+sLXRLymR7XVVxd2thXKmh3f6NDmLrjpm+tq/aqhfXbk6zFzLtVzLtVzLtdQiG4FFAw3csOKguljKJrM/ZEGRjAbou2CzN4o3y7jUd+lfl0CgPgLflUMSY0GphmjDG1wgrKD/Nj3FxhDphhxxQ6+Jkm6wJQesBKWkClhdAnAuGl6eAFguXe+fOZjQUyL2Bov67PpeNGG/YRhwwZ9gil0nuDYBvhMjL0iUDahoEeq1PURV2G1tpI2hqG/5meGr64t96fuwKXcN5OOqXLY51hT6rbOCv4/AdZ5uBXPNkd2P1VOOBF8FwHjJ+WEPaOwVBJuCH10uOVt8+dJAowa6fuQ7dsbCCjcIANo3VLrf9j5p/fM+w+Z2vaOr83nfX66oO7O4o5i/A2rAN1pRYQFR1j3CgK1tHmPZ/LR6Och42Ri//6yv/74dffufcgzaG9H3DDZ1f70A2Ihkc1LRPT5G36d6w2trG2/u3bSirkPAZw/DnSNAAUCA0qMrRAbJtrEZQBEHAIxSCGsqkNOKtJ6QE+F4XJDWE2KMGMcJcRxxW15giCNiEDV+xBHDEHD36oRvfX9BzgvuPztgnWMdLWuNppPx86MHxtASvd18u2B4sWI+6VlyOp0AyRiHqMYVBoCCdS01L/Vg0V/9WQecO8v04Cb8t230utWT9V9bi9TNdSIF6O2EhQghRNYIpMA1uuj25gCCRjEyrUBZ8dmPM6Yx4j4mpLTg4Zjx8tvAME4AAqSsWOYHiNwBYMwPhHc/ZSwLY/oaAZTBjPquOA4aVcYBYqDeNBGWVaPTiBkxOhhINRqKOSDEEeN4gFMG15RVvsdTow2HAfMxBpRV86wPBkw6E0rvJHK+JwA9K0g7T7bzGHU/2qE/dd6fywX774mogkD1yQ5APQOc7t8BNPmpf+/GkQ60YWjp69A/o69HoADnhCLySG2LQJPWB2xOsURc/WOJBAyGI+KFVZ6QIqDCUPjbt36L1ty9v3eg3rMVPgUe9z+XvvOB7B23n+rjS44s/d+6PvXf/rvVT//d5tIl+ccZaM6NmO8Fg0X3qI+Pg15pAAAgAElEQVQ95+nCX5uHdiBkjWQtWyMNiBDGCd/61RXLKePhTcTjm/NUd9dyLddyLZfK5VPz+cJEePHya3iYjzjNM7IAqSjbLDBCJCNB8YGagqQAUjJyUmY0kYRi6RQCB1DUmhCL2qYdR2ACiRqIBw4oOcPduakImIBxIExREENGoYCCiJQFqQhyUqP7YbpF9BSP64JhyvjWrwDEmjbFI6GHSWWzZTbZ03pIU900p/sQQmWScRlyyzjQOUyXj+3hr778YnTRc3TF27zmBDEGzB4j8FQPMPmu5IxS2HSNASKM199ccXyb8fB282T7/8cxjexbzFzw6lsP4LDg+Djj8ZgQ4oAYB0ju0lF+xJB9mdGV98itH/tyddbSdK4hQtdBmiFF5QIdA2UWEWeEgMucyh6qhmE3y7XAm4btsKb4cJm9lCcdLPq/OQjuvrWAYsT4AhCJGGIAyqq6OxKIDwAWdaxgdb53p5n39dkvqhAiPEV8/Yy2AXR9GjaXkxtDr+EM0uTV/ulb5zl9j+tQapRX/ct1b2dEKdmx2gChxlwBIoQ4IrquHgTruuCTvymQDPBUcHNXMB4CXn+nYDklLPcR+X5EH4SyrWX7v3KTaAANg5DtK2elCZExjhHjNGCek84/KQjR00J5H/pYNnephih2WKowKoNFlfX1iqZX2CcuG0vfiO1caUGoxjJjrOKXMN5eD9zjNXtcq7XJ7q94rNhvnQOlFOS0oBQxRxcgBME0BhAJpCjeQjDHS4NTpWRjc9U0TCk/YE0nnXekI8esKZhCHBF4AtEIZmNIkoK0rOpYxYwiRR1mxOYtG0uusVVRxX63c+Ep/HjvcPOhhTqsvB8r6vamnJRVh5jqWnAnH8fAPB1ij+P0qQ+VjV7qKzoTScUWm0OLMj35fgnkGqin539jnDkcDpWdqORtOmOgpWj3eZTSapi4t1HPRXWw0cAtd1y8ZIvo9XF9Jj+5Gyr2JHU/qXg+3Pbia8fP5aI4AqhbgBa4Q7bv9pjKBdxEU50Ze7mgnfnX8pWUq8PMtVzLtVzLtVyLFRHPvdpFoRNbXhRAjQMCpW9cIQKL5En1+2a4BlCN4r3xycAgbAXgvfFr78BQTEFmq6MLmqW0ez0SohnElfzTWVQILV9nSk3I5RAROKDlnQWAonSinSG+GSZdqWl950bKrtVnQn7vFORt6j/bf95/v3U+QTVYNfaXJuxLf52PBdnYuRJ1Ju7K9rMq2Vr7Sf/X7tT+IAOnyAV7h/xEdn13Xt4n0PaKozsXOFNQ6/PegWNr5GqAXVdrsWg9V846pfe5+l0C/z7EsNnV5uxeN+xdfv62zn1/PFe+lJJA5/Pi8vOoKulf4CXd3z5BGzjl67Y93WGTsJkPTynQ+/65BEL0a+mpKlaW2Gos1H9zpc5mS7vUFNDmNOPKcrb7WiyVVMcfd+Z6fm08Z9C95CCzN7jvAZennnmpLwTFItiUAl4dFsLuHtmMWWOv6vf87Vhu22d9IeYws2H58j2cAGJ49hdmaMgvBJmVIjmXgnU5YV2AZZ4xTjeAEBgBJTOGYcTtbUQMI772zYyXv/cOp9On+JP//Tv4/G+36qC3REhpoNvotVawEL7xOzPitzPmE7AuTosvYFImtJRWjQLMqQNVtnOyOSydj0NPtbuJNjSgqh1WvUOV1Dml6ZUa7DgdBkwHTX9TMgwYKQgMEK0Ajpgfj/iT/+2A+ei1YIw3hN/9VwnjlEEkCAEYYoJHYX72N4w3fzNhGEf86r/8HBmLrotAIA6IwwgOhDgKJgQMQ0DgiHA6aT1jBAQ4HufquBWCRllN0w0OhxtLCdXaGWPE4XBQJwymChoNw4AYGGtKtV8UfGqOqf6Ofh9xxyR3GGjrdceGYkdGRwLybHnKWUYZV+zs3O1nT507ft3+XPU17rTGjcK5PW+/7/UyV79HuAymvydLg6VGjWVZ4ExanmKoFJ1jIn7Cse6E3r8GYAkFhKDRjgJCFnGyQogxV/V90OrAmzrv+6Rvn4OEe4eZvq+w64u+v3VeNAdxwI0IbfU3Oat3LneZcevE086b7e7hsiTBE122NSzSAMV+Xjx1VH1po+SuL9q8r9WtdQEIQhHhdsJ//t8+IqV7/MW/eYG//LdXh5lruZZrOS+0+7/svnvfEdqQB2CVgtOacVoFQgFFJkg1bDIKZaPnZ7iDpqQM5GIuD8ZfQUBkc+AVDQxiS5lBYIQyqsOMMAITUi6IpA7QgYFhYLz6+ojhoNjIkgUiDMnqLCBZ0zIMw4hApIZKZNy+Svjt/yojROB4POLtuwesa8Lh5gZpJciirqRk50GhAq6p99oZVdm+dvLLlkWyABS+3NnwH2HZzxd3oq5nvqUXZKZmRPYzTgApahhMmVHKiMARUgJ+7Z8oS9Gf/+icafPy7N3WaY9A9L0ex4xf/y/+GsKEd58RiCKm8WCy0DNt/bJn+9MPRv/mD34PaYUrllHxJTXmxhgwRAKHgIfjG+R8A8JQ5fmSi+qHVX4SiCgbSC4e4CSdjMbtB2ypgpTRc1nnZkTdVnLb94Pg+//8HYYXdwjDAUVY0+gGBlFBkWzpewcMQwBz0wVJCEL9O345KZoEQMkEIACdDlhldZPXnV2mxwgrLqkgoNbc5WzHZA077NlJRQg5G94LMtbRASJAjANubu5AaOnfmBlgRozq7EcW0BLDYAbyFevDgh//P3dYT8Cr7ycMv3ECx4Df+C8z5vUBP/3jAz67nxDgbDEdfnmhTxKVqjPAXGxMI0YMhHEKOBxGLKeEx3kBxNguQzC9herueo4X7t92uWzwxA5Tqo+s/Qko5uqYroBI96ZizgnMmo6sd7DQe7d7/t6hpj6/6reMlHNdm46Lx0AbZo6UVktvvYKDprEbArAss55R5rigwRUFKIK0aurj4+kR8+mIUmZtM0dwCCAmDOMthvGAGCYwReSigTECaGrmksEhbhxFlcwtgDhWPJ+J0QLjnsb1/O/mxPHxWGRzmKEzfEwEHbNKmyf9da5vV8eQiiMrHuU4g6cGEg88BoPIHVLa+kspoYhg6HT3Xuer9gyzzfjaFAEy2h4AUMVExlH1smEY8Pj4YExUou8VQQyxsuYsy4J1XTc6d87Nqbfvd8dKzjqdYO93+43P1y7ATvzQ6/VvD5Iz3bfHs+BhO+eBuz5HKvNflYds3P6eyT5/l+XqMHMt13It13It12KlZELJKth4KhK3FopkEwYziN1TvaBIQTQjjRsDmoAfOsVXBSf1uDbjoYh5b3M1eDjwsU9XMQxDFV33ziT9DxFVT2nAjGlGoamWzmoBMKpKi9SSFmFBZsiOMQLwaO1mLKnvtdQTgDn0SKogDXCeLkVEMAwawdIbUN3Qk1Kq13r7gSaoer+yKxqgyrDznIHdhWCBKjE1u2dnlNa+0tQLhixVR4ECAVlgkPo2uAG3E6CDWFRbsfkCA68u1+eSIVHqfTu2F5IGjhDZvPJ7NNWG6u+8eXa1dUFqAHszSklVLC7V71JxD/19G97nxKIXPd/283c+z3jzRYG0S89k6p534bkObLX3qkIily//iNKBkOJgia1bM0C68U78Guna4PqsP60DlXqnlf1YPZUmpa8VEanCmzNQ3JnPjIaiexmHASy8AXj24Ie/85LxV+tyPiZ7I/2edWtvXPZ7/P2+j/aA+rIsdV/pHfN8H+0jUjTPdsK6zkhpRQjbvbUH5p0OuvVx3/ZiBo0GkOr+apT3tva4Rqtk+9F7QQ5QMJiiGUMEQARjwDgcMAy6RxeRmgs554y8Ct5+fo+3bx4Rws9wuLnFd7/3Pbx6+dLog7+Jw+GAwAP6YjsuzNVSFfWaTqVFpBFI86UvK45HY+Cx/eh0fEReF9sP1Xii+cPP+7Afu818cUCHdK+tQGhlQtMzjENs501QUM7HcByi0fuqo8g4ao5nxRJGxMBI69+AByCEjEArhDNAX8M+3o8xI/IMDgOGsCC8yt0atT2JCS9fjUAMmBdgWQVlTcik+euBqFGA44hlWRCHA8ZxwjRNmj4pnjDPa3OaiQNiHCGiEeHDMNRz8+WLV3XOnrOxCW4PN3U89hHYyzIb0KXHSggDxnEAk8o5SnWekfMWkO5ljI3h4ImyX6f785wcYNqd33vwtP9+n8bt0jvWdd08KxBDyNlgUL+7vH79OQAkghERIyFGZSRKKRnlM+s+KAAZsC8oKKI03WJRpwIBWDt6yQW5EIoxBILUaXUYBkuj1fafnmVvL0cRUTWSbebohur/nDWHHFDE9szt5wZRi07bOr5sx3X/Xv/c696u652kfYzdCNRAwPYONnmmH4uyrcNGHmrveWo+Picr0O4aMXmJSPtvXVfM84I4jCAeAYpIuFPgd4hAHJ569LVcy7X8gy/n5skPZWvod62UVvzoT/4Mty9fYXr5CikfUDChJKDkFQUzigApq3NnKYplQAgUGXrqGKMhNCI5cDBdsoAoI4aIyBEDRWOUEZAUyJgQY8YQBdMU8OrlLX7nn/0Qdy9vMa+C//CTt/jRH//E9OuoKeuEMR8zxlEdJlOZ8fj4BmtKeHd/j2Rn9DBN4CRIpZgSS+o8wBbFTYJAARAgLSsOhwMAbM4YIjWOxWjGr3XdnTcfoad+xeW5d37h+lzQf2DjqQEM5/KRGho9pWvGPANEETkGTOMBQ7gB0QME9xfN6M1812aun7eXrt/UTgjLyiggDOMdXscbLGvG6bSCB3UTyFkTiX1sP6DqJh90Q61ZVaG7m5+TE9wQL2rRND3c9Q414KqeoX39+Ok7pPwawA2YA4Z4wOmYMI0HiGQcj0cAGUUSjqcjCIwhGtOo4Vv6M4A4AuZoIFDddFnnvfq/cYXwwiAcphvE4QbgCZDobnMQIRBPpuvPKGWAyApPQd9pNvDR/rCd68uVUoB39wnjFMHcGDV7nd5l2L64/NljEHvnC0/30uMAgM6/ZVmrrnN7e4u7uxdgZtzc3KiDVwEeHx/x9u1b5JwxDFHrOOg+G8OIaboFMyHnI4Qe6vPHccTdixE3h9dYlhMO04hxVEN3FEYAwTktVct3npwtf8hCqmcXBETzBJokoJQEJsFhiki3E47376ABOAHA2GR+7YzWZ+jXcysKZTSju9/CdmYoNrQid7phYEY2sKpIS5HnuDLgs8jS9qFUXUafzZsxdv12WZYLGFJBCJaCKRCObx9BDHAMlhJLmVlLJiTDsSQXjNMEZkurfHqHn376M6zLCVJ65rJogUZAWjOW1fTgIhimA+Lw0t4TEeMAjqOuU8MmyPWgdQUx4e7uFkuaMS8nEAnioPu0s7a48xOHCOpSCPXzvp/L/XwmImO6+UggkqA4iuj57NiUB4WN44CXL19hWWacTkdNtW06rmMCOkaD1rPD4TUVZG44BgdNIWbOnbpXxupU8/LlS5xOJ3z22WdIKWGaJqzron0Vm13FpaiUEj7//HMEDhjHCUMcqs2DSeWHQBGHaUKIipV7eqVSEk6nY61rThlLTjhZhNQ4jhvbgzvn9NiH4+7ulFLJ7k13RDBGX2mpw338SKhffk+eOVsnJjEyamoHV72NlLWoqMNYZbxqFbqWr6BcHWau5Vqu5Vqu5VqsKJBvFI3VqQBwFwungadC9d+9Wrl3ZHEjhXqsq4HFDQWq7J9HNXte3t7oW392BqLeANwbS6rSYbXrUx+4UOdGT5fXSi7qQEOoTi8qOHruzm1Udm/QPDdc7aPS3XjfmHP2VIf7dl1SDqqxznMfOFvPTine31f/FicZBc5Vxb4NpRppFB8R9ztRj2+qXBodeOWKbev7cqENl+rp7feq7I2ABOwcW/Yg0fY9blw2e2RnBOoFfmyMh0/1m9ftrD47h4T3FQWazvtg/9vnl6+/fX0+uB+fKBcVFOsoBQm2MFQz1G37f//Jx5X9nZcUYVuhPfNMsxNu5ku/RwC9o1pzPNi87T19JAKlUfe9jJpzh1efjSFGLFqjgnB9KzfvJdufmrJN1D5/qjw13k85zDy1nwDY7I37a3pgonYCYKBMz34lZ0bs3gHgvC39O7wn2lqo1K6k9Nw460W7QxjMbiQ3YDBnkAwGVhEGBkpQh8x5nbEYw8tqAMfDwzsMkTGNB8QwYAgv8MPfWfC9X7vHm08K/vpPX9nbPMa3tsB+6zdBNCd6yRl5WbGuGe5o6E6lCvgYGxqaU0c/Xg689I5LF51n+nlSQbzmiOp9HpjAwUFQMXBGHWaICZCsDqqWc55JQHLEX/zoBg+fTgAGSAHWebcfAhZJmCE0A3LCMCY0ynLbM0Swrkd11BkGFGIIB+Ri4HRQUFRzngtiZEzTZHTfGbe3EdNUkLNGhzMTxnEyY1DYRBP3DkfnfZoVgiNnGml9qxFTUtlYNiBkN+pbUGd7jjtwtXV8uVwunRE+h0FbZ5n9mb9fk/s13sseXp5y2NNTvVRg8dyg1PqUyOU07w/d6xQsVjp2pqAR0sWARwQ7U9kP7GoY1b2xaKqLAFAhO2ZsT5QM5LxJ59aPS+8ktJe3etB/v5fFGLfrSgRCWwrvS04zff9sxms3Rn19tve0ddE7onjz6nxi32n6/bGgN/h1o9ie0R3RG5nzginnubPlfaXvD5d5BIxUGKmorJzyFZS8lmu5lvNyvvMQqNujPmbnICJMNyMoWrQ+GCis9lAizeAposZ2d+Rk0r9Z36ZiUzFnmYghTiAKYCoYWDQ9ARhlXYG0glgwDYTDDfB//9ENPvs0ggmIMeD3/5efI8SAIoLpbsW3f5CR14K0RqSVjLnipIwWnPDw8A5v3nyGXAjLmvTcJIBSwbomjIcJ87oCiUAsAAmKMecEhKrH9IFEHgXf4yDFvYDhe//H6T7tvq+mfOVOOqK4AovL2lLbHEKN7lJ5Y3M2mxxIJo3kjPmUUGICE8BgfPcHjFffSDidHvFnf/ACaQkmAW1O6fr/9tmmepvP23GtjgopD8gJyBnGbEwNWyKcGX7P9LLNd/rGSz38FDbh8fo93tNf++TYS6cH7eVZNNnn4VPCT/7dDeb5B3jxnSOmX/85bm4OiPEGKS0YhohcCk7zESIriDRFTOChrk8RM2TXRGjq/LWuK+Iw4HCYkF+f8N1/8QnevPk5Tj9+hfLzb6OyU+zqFpjBxCb9dhgkCKAAkaBtI+DX/vmAb/3mG3z+4yN+9qcvztrZdccvrDAx7m5fYYgTMrg6VABbTGgvF7f13rNfP4UXOfOmy3mqd6WUMI5j/RmGEbc3t5YOrmAYhhr0p7q76SQhWPojZYtYlgVv376DyCsArM+bCOsqWBMhDC2QxiTkC2tmiwb4vxOpI6POEEHu3GtUR2R4KmkOESzqZPOc4+DZJxtd5HyM9p9VhIBQnXOkw6bqOIE0zZ5ITbfjdXKW1CIeGNn0n5513G4A4EGmljonFwzjCCKuQTKBA0CE1VhQSArKmjDPj3i4f4PH+7eApSvUtExkZ+IAOJs7FFfgIeJwo2wyzBEg1QOJI4RCwyVYoGmZswUyNicL13tQNGW06n82ksVxDW1bv/ddwmibbkKXB+mZ4sy77dlbHS/nUh1Q19VSH1mwLwBzVIot0Axuy2i4RGN7ZZR82YnNMQ0/v90uUOWXDrPWzMX6npzVwVfZWbAJkhnHAeM44XA4IA4Bp9PRnk9IiUA0w52Eej2aWfGYXsZwrK/HB0opyKX4FNyMTcX8iTZrruJ9TiDdjcVzMoLjX84048/tcZqSLVh38/lXJ8Ncy9Vh5lqu5Vqu5VqupZYWCesCK+AKDQcyAb9AVLNvMirpdc3I3xtQXbh1I4+mqxCPksZWkblkXNoYSapgtFUageaQ4gBSERXs9NouOhxu8G55ekGCYFEC2jZlXCFpBpPesOT1KaaMFSmg2nY5q7//7YJo/6zeY30fZbAfHx8X6YTDp8o52NLV68JnrY5+hQuogKffgOOP6K7xv6n7VLZ1eA742VZgr/tQ9Q/y+u4Ni60dHaBT398exja2ylRyyYi5NaA9V8mPux71mkt98D6Hjr0x79I9H1Mu16H+he38dWPf7t3deOyetPu9//vszZvnbPu1i6oXjyTp+3G7z/h9dUzQAMgPnYMbEFKk5sYlMraaYHtRZQmgTRP6lGGeHk5fqRc5jSvMgQsXQNKzHur2A39eZWfp8nPvnVguzRd3Krg0f/fXu8Lf9Y4x4uyNw77392PSj4HXyfbRLkWJOk8C6jCT0VhlrC7OPCRQQIUIGjdooE5hSDFqZgKYCtjYt4gDUl4tJdKKh3dvwATc3QrubkcMPOL1N4C7VwtKWVvb7Q2aH33rCEUAAggDWB1m0oqSe1BeDf8UB0CAXFlmeAM89BHCDQjzPtG2iO29FTRw5wDDd/bzXqOB2BgyNHVAjKyU2QQcjwvSksFMds4VxPA53n064vMfH/AU+A4CDhNjGgtSOYFwRDhsI4V8fgCafoBCwBgGhCFiXjJKISBD6dB5wOGgLCXDEG2dsNLjC2p0FgBMhwMGc5bRfnJnJHNYs3OQSZk5IJYmiEQdiGy+KltGwjyf1NDkYxlC7USR3tjUywvtx8h/N8dH32fbo/Mp8KYZLZ4re2cZb2s7n5t8VeUHYpAbjqxChHb91kkGFbhV2aOteWbtSKFs67WoU3HOQAgazShkRj0HsG0PIZWpfI9mFAg0et7HSOq8bR3Xn3vnjjCN4YvoPM2c91f/swdcL0k/fT/vz/K9MWkrYwBt/LxP+8+29WHuZeCOrQj9fvq0POH9pNf037V99sNLd3U9yzvZCVs5tQdFRYBUCPNcQMhI6aPj4q/lWq7l72F5SiPtT9CmX3xcehMOAd///ncxpxVv3hFO84pSGIIAPZ2ALPpDrKxqJKFudXqME4gSAgPjMGAaR0CAAMYhkkZkc0CeCZIJMQhuDwFff3XAv/0/CT//aV+jmrMS3/puxte/O2OeGac5YU4W5b0U5ETqMPP4gNNpBgdNI5VLNgcPRsoFB9Z0pJoqRqOmU8qgYEZpac6hveFqWRaM43iGM/x9Lq5jqbNMRs4EDBHEDHLHdNrqTX5yqyrGdu+q6VpDQgDh8IJw+yri+Mj489DpQgCCOb4LNYbevQSyndXbc5mYEYcB3J2XJBrhr4Zkvbje/Z4xJLv2KRhIZI+jbGvaMKT9fe/TkXtsRUzma7pIXhj3fxsAvAD/6j2mr62YxgFDHJHSG3NizsgpAVTAxhzgzJdS+pEyg71Of+RcMIyEGJXN5uV3BGmakd+sWLqUPl0rQQQEjobz8QYTAJShuQBQ4/+Iu28WTC9H5LTiZ3/6TDf8Agsx4eXLr2EYJmXrGDS1iuvuvcHd94H27+efrbqQqHyPxqYINBbEcZyM9ZExDgNCDIAIlGVYzCEl6HiJoBgDqOpoBWldcDw+4vj4AJGX9h41wt8fjxjiAHdB8/+a1r89Fy41R/f77l5yGdUwXWJlksoZHAaEksGh6UPPdVKvK+1/e6Cnr50N1lSK4lMeWCWApmRynIarLO1pcBosRNVJwp1lLuEyLpMTUcWlG3NWQS6aPjvlFbQoUhHiaHtkAtk163LC4+M7HB/uUVKCsoLnyuxNRAAXBNK0S+AAjhEcBxxu7jCOBwABynDOEGOSFx9RBWvgqvOSVmM/YQuKoNpuHS9NmVU75EK+401ffwDW+r7i+B4B5pjSntuzhLpOTETI2RjoN44sgO/a+zPYUycKCOy6He1tAIxlXbGuq2EHVJ1UKtxT253haY4cy/a0bM5aLBAM44BpGjFNI+IQ8Pbtm8q07e3zfUPqfNa+Z+KNo9Cl/n/ufKj6sqCuFbIoZMe1+rt7Xbt/9ua3r+86cP5HPYj0DEXTy5kJl9jjr+WLlavDzLVcy7Vcy7VcS19caDWASYX+Bni5kZTAVQAkaN7MjTML4JYAEAm4OlxIx1ej9zRjgApYzWnEVWDaKCrVgEgKQrR0IqUax0opIEu5Q0WVKDVQeEql9nwxQ7AaEk0wZDWmpTWZQQlnRuScPGc6QMbKot3mYInUNAhuiPBIsRYlzgoewAV3FSq3BiGva59KhjqFC3tpEs1S5uCD/pvlacMREJTFBwwhJ0ZFvd/rtjHA2djUZ5mRV6eO943UMax1657ROxQQAaVKvjb/WmtNGO8NaLUWMKsbyI2n3dv7t7qivWl9103SgULb5+vznlcYLn8uT8DJe2eqXuHY9tJTRrH9fKBnrWeX67dPr9Qids5rr+BKG2+vaK/w9C95CvI4r0NtdK0I7eY7Vb1a+lHdvJK2z+vf0F1TnyuboW8Au+1Nvv8BprAWQfExE2eZsfQmxi7iqb4IZBE4OjbFp3TXz6BQQbz6no4lgojqVqx7lkcxlVbrWr8OdtoBLm1aaA50KdL2KkULdJ/z5xAQWKNoIOoQqOva9m9/LfEGne2N+VKv8f73lgpqwqPa6QXoDMF1LtvgKjDn61vnIDFX5whqA6f7OEVQZMQSkY3C+3RaUOQt1qUgLQC9eqmgQnyJu5crvv2PgdPpDea3d8A8WXyjz3qymW800mDg5weAFvCwgMDqOiDqpEGkkS+gbP3WUg5C7OyAd71HX/l42BuNoUY/UzCE2OcN7G+G00THOGKalL1FZMXxDaGsXAGhx0cgr8XmkvZ5HAKWI9dev2TGKhn49McR4+dAKhkEIMoBOdNm7ZRCuP/pBBoIoAAKUenav1ZAwwgWjUiLISgYRBbZRJoeEQYIoyT7jhCiQLAil4LlKHj3M61dDAoADZPgxTcLCgJAETVtGywKCivmt4TjG0IuBeF1AQUCEDT6MEYgJ+SiZzl1DrbKthdAFMEU67xTxhWPWG8nSYuA6uY8WgqgVhwu7iOX+53Sn7H7vlsP/bP0/1Lf33Aik1tqLWzu2BknxcHqgiIJJevcLmCwMDhlFCbkoLVQ57CCJAmFuRoz1BFEz9wCAYirc4ug1JzmGlmYgZLhvDMC39esbnXvcjlIo/3ga973RVYmoSItjabvXcW9cnRXZIMAACAASURBVPz/tq5IjMNK+h53Rxe0e54BZHsHXXfGLZ0M24+Tf+b/bo6UXXvJ39ft511d+mfWlHzwGeS7ks+Afl60tmzkFT8r6vMLqLpAK6OB3Vg7jyjYWBMgjCgBKUcUGXC4Y7z+lYycMh4+GSD5adnoWq7lWv5+l62Wc9kV3KWMZjR9/7NKIbz92Ss8nI6gsOB2XPFuXrCkATyMKIgAFQxhBQEYYsTxTcDD527MUhY0AqvDzDhgHhhSBEGAY2RMIyEGQk7qaBMDcBwD0jFiWRacu0hYPUWZtpZ1xZIJKStrRlpPyInALJjnBbkEM9wXQAqcQaNkwboklJQhTt0lBZJFA5WSsgfEGOFOEsXOOfII9bhloSmGk/jZx7SVQ5q+0+lX/xFt3f0ZvNGLSSBFHbBLMXEiEJzhsUhBKgmVzQAATJbz8HbXJaQo08+8PoB4AA/AGA4I8Xzmuuyf4bJWV9fumjZnt5gIx4AwRvCqKcDcWFuyp2bpn7RRqZ4s55ymfWUurL2qj8kzz35OfydIUZa5Jl+J6W25ycT+uhwgWQBRB+uUFyyLIJcEx8aITceiiCIu4wU46tOc1u3ZAqAIGAERAwaeVNfb1VRrazsMKxNDjdMoyjQEERQ0HYZIU6uEcIsXrxnf/LWMeT3i8dPYsW665P4szPKFyt1rwt1rxnBgHG4OgARIyIgxIGeVqZVMSdNSqeO/VMNwC0C0mnq6eMnaF0zmAABojvVS5ffq3F4d1QVg1aPm5Yi0rvb8AkGCICF42qyqI2mKrXefz/jkJyuODwNefTsjcMSLbwygIFhSwuNnQGDg+E6flu0s2GNyPqZy4TPqRlwAhLffBOcR4ATwz8AckFOC5BVSZjBGk9cJBHOeEq73N0na5F6B6pImD7OvT9MtGGhpZ63f9R6uorP+iE1Z33f1HFIdIAKSIVBml4KiwaTuyOFjaoEcxdPnsrLtsjkHgc3JgoCcE46PDzjSIw6HBcN4QEoFaVnBpSClFfN8wjw/6pkSptrDqs7o+gthsHRDAeQ/IWKY7hDjCGeML6LpsIs5yZSSkUsGcgKC6ofrmiHQZ1Z9RzxgjIxt1DCcTnfryx7PqudDBc0uraju+4vf+ei4HNIeUqRgXhfdo3183SZh+pwy5NgNFtCXPRiOA4I5zBQRYzFTbEdI0a81ZwQOWJYVay7G/qt9wkH1eEMRISjmdGZYEnPTdzsW1VIScp41HbasoJlwOj1oGwlIa9L0f4E29zFFEAg5C2hVvXpdk6UOAzRQWqoeqtuDzVJXFdukV3zRx1WoW7f7s7Ufx2ZrqlimYyAeUEZWl1LaXifm9FXnB6BBO1/1Dv0Pt1wdZq7lWq7lWq7lWqwojXCuAiEHgtPDl9RSShCRRhib44cUo4zsU34UUVXIlThnCSGNwvdMtc1g0YlT1VmGm7cyWAVcMjYXqPI3TCOmaWppFUTw8PCA9XRSRSpENbgIgcQ84SWrwCkKbNU2wQU1QuABcTxgXh+QckIgMupExmBpIVaZkUVTOyQAucp4VhfPXWtCpCvlDKpsAe5lHgLXdBo5r0onyq7cufGJm/d5YDNid9LqBjXolU+HJ13A75X/7qrSwLRaSFVaVaZLbZvW3ZvGqCHjQI1IZyGgpoFoke0bBZjIFMCmEAFlw0JR+48IYnla+3yqajQrJphLbWepEUXaA6kyCHitdZ5uHL86hpC+jt5fnvd2D/M64LCpcO0nBwSawrdpf6cA1igAKe0ddA4m9M+2S9CMtU8rie9XIdyI11iPfE3q882IDwAklsJMlWW9pHOmqet6+/znwDrvqwqGVAe5Dj6pDhKebgWoTjwESNmzE2znbaXCFdT2+cxXjFnbVSTX/NMKNBXbt5TeGdJSnJRSkPKqYKAIAoICiSRgcedCIA6MEppTX6nAoDnSEZAs/7ViNAquq7uEMl5JoUoNW+DzR9ulNLyx9mWNmvHxtD5J5qTnDoCaTzm1/gYp7a5ov/q2ISIIHcsMAUqL3/W3SMvfLNxHWTWHQN0PSj0jGiRtjoTc+kxf7SmP3ACiRvQStX0Ovuo7dY0Gioik9NFxnXA8HvH4cMLj/Qmfh88RfvBDCL3ENN3ga9+Z8OKb9/gPP/n3+MmPfojZHGaCNEeZYLXTXYBBf/oNxALQDz9BKQxIhAghlaIOGDaris0JgJQ+drfW/W9lNYPtXTqnmaLNbYGIRmX2zhpEGtkXeMRhvMPtYQTxCct6jx//yQGf/6TNe+BFBQYrzoNvYF/2IOU6E/7wXw9tjHGzudbN7Glh/PUffHvzrOGm4Df/VcFhYsQ4IUQFt3NerS3FUidlPDwccTqd1IFUGMMwIYQVWVaIrHjzt4y/+P1bY/9Rw9jr7yb81n9zgpSIEG8hGDUFFK0QmpHLI3765wM++eNbjLeMf/o/vsRpTVhXN6L4GaIgERVlCPI9RYHgYmdfH2UFdUwiM74Y2GiLoJ0h0oBsR5bquFcAt+vMvkgH5nYXXTwJHNDdjR1I14Y/UKSAAiCSIOQMImrw0DNSgFxAGeBUSew3csNxVmCUoLnRNU0WI2VgzQzCoBTeRObAolHUyoZle7adM6Vk0DChhCoggilUua+IIIuoHEQqA6nDlzpZpaTymzIMNWai2oWKc272r/33vtpKF2HZzmXv0b2jbDvrG7uMyXfczqoWwVfq+4j0rKxTZA/+Wn/v9we/tjrLdPTfrS3t7woednOhB4Zd7vZ91p2YAJhMpmeJnidKmR4o4I5GDOElstzg8KsJX//+CceHI/7sX0ekq8PMtfwnXH5Rs/cK3W/LXsZ4qrhkeHoU/M//0yMA4F/+3oB/+s9m/Pn9Z3j7EHH76tsIfNBUJjcZRMDtTcS//yvGX/5hxh7ub7KPdJ8IgPlCDZL9PNcYhvCIzAt4JMQ4Q5Z75PkN0kIoEpBSBOGAbI/yqPqSC1gYp4cj1tOCZV0gUqpztaSMZUlIueCGGQHAssxY1xXEhLubO2UWHEc9+6QgjgPWdUXOjpMEhBjgDBWAnSdu6ISdkcyoNstfQnnKMXV7pvX6sjS9dE0gDAgsqg+ZjJ1LwrIuNV2VppCZMIQAIJijjeJPxAVgTd0qHEDDDXg8QMILED3Ws1AgyOTBRvtQkq49aDOJNp8AYQwYDgNiCsBDRkkrpmFAREA2nUk2Z34LENuyfFofAQByL/btOncjWV68u3WzoOcNbvr7Fh9SnZK7HjDjMGWAVhCNIG51DXRAoAJIRFoX5HLCw/GxMjSA1YmJWLEalIgQBlBQ/bXiYqy9OoQIZEGShMgjTgsgq6Vm29Z8U+dUgmJRonqkGC4l4o5rirE1N4UBL75J+O3/bsbnbz/BX/7+Lda/Hbp9o73rq1wq3/m1gB/+7gjwgJKBvCaAMtSwXypcl0vGPJ+wrmvV3yv7jGEAPfO26uKaSi5GNSRrUIwyklAYQKT6/zhOmOcThiFgOkQsa8Kyrnh8uMfNzQ2maULKR5zmE15OX8c43QCkfUO8QsoJb36c8eM/mjAcvo1/8t8/4tU3JgzjAWtiPD6u+PMfzVhP2tuRGNl6kX0UTOduCdGaW4Pq3u3H9dnwV7+loQyvP8Px1x8xjbeQnCF5BdYjwjAqiikMcARoQBYBpMn6bEwYAkvzIsYALOq4yCgAu05PyCbDF3KoqwtwIA3uSmbYzzlBg1oYuQQMw4DIETkdkdb7imsSdwzixtopWdlyIJZyKphubOzonopuPKjzy8P9W6Scsb5YEMKoUn3K4JQgy4yclM1kGg/4/9l7tyZbkiyv77fcPWLvzHPq0tXd09MzzIUZMS0TDDIZesIMvUgfQs/6cnrUg8z0LhMgZAYyDCEGEINgmAa6p7ou55zM3DvCL3pYvtw9InfmuVR1dTPaq+xUZu4dFw93D/d1+a//8tMB7F10DsRTxOO8gjut/K76/Yq+m17ZvJzA5GBZF0g1WSwtFFtfjY1Vavki50lZgT9ic7AUINb9x2tSwPAWl/rMz/lkNWHt8lr39BpoaZOdVbZdVxxFCvcP9zjnOC1nzuvKNM3KXqwL9eAz7La+xUjmWUtVUZPcAtSSSpVtSBynJTJNggTBhYCfZ/J6xvvqDywOycbKKkzB17nXy3N57wnB/OEQ05nlzV0rOx1j5Hi0kmqJuK6A1H2wJhaLY54PiAgxZs7ntZaO7yAZbUIH2Bij1OhnzJYwbX5B8zs0G5o2J+yL5lduf+u8SDkN50JJEQr4oPGbFGP1KThKWeuco/rGXAXDvkVvu8o7yxUwc5WrXOUqV7nKO4gZZJ2eUIPJ0zQ1g8MM+z0IwM5vPwvK1FD2AIwesNDs5xE1rEGE4L2mflUZA79Ggbiua/vcACbTNLXvLZhrCmMDcpSuwOWsdXhTqiU2ds9jymiufQJUw6VTLo71P/f9MEoIgWmacE5IORJjqYYtWJaDG9kGkCHY/3icLvW/VLDD+4kZh6rI5jy6CEZnyuXrGhuR3d/6YeO04/JzjACoMfA/BrMu3LA5c+z5e+DIIu/VWaTRsyf7cC8t0P8NPSTPsdN8yPHve70Pk+74+2XLOLaPx/6J1lWDzNg77FzoRuV+ztixBp5xla0Eqgku5qhUh54mE43l0nx11BrwY7vWLcvSHFcmVqtYRsDX2K7BCYCBW7KysVjJHqsHnXKqwVcLnBpj1XatKbs5vl/rbK261P+9f/qasgGq5cfgMmv/WFrO+nc/V+061g993J5e2y79PgJrLn0nIkzT1Jzo67rwcF64u3/FNDt8uCEExxSkUVWP4nENLOOKAmea886pwyNGeg1uBIqDMrJG1OC1s7XHgt7mqB2ya+pZeux2bIw9o/WtqJPAuYLzCefOZB6I6Y5cAo9N3Uvvcnnmr+Ze3/29P6dg28PezT7PENMbzstrRNSxtiwLhVTLICpl+roU4poo2UqNJVI6g1sQWbVWOrftXlKEmM68uf8ZOQWcvwEOmqcnGecT63rPunwE3CIIPgSm4iqozlfgxqpU0fVfdwB1/aAzwsnuuftvPaO5XmMAGENfp361Ms4wh3O2cgXGIIiOaBwAJ5Whzwku5RYYKc6xplreIAulBEQ027jU8p4j2Kaxv9k6lCvVdV3v9H/xAhhkBKhom0p9BnueVl5zczzDWmfnl6ar2fc6xsKW2c+19dZ0iVGv0GvJsPZu94jx2mPbrZ3767Y18sIUuQS0vSSX1s8tZb+03+uV6vFVp6x7nRPB+1D15ppp2lA+Qgha0q64QuKAl2lgNrrKVf7Tk1/m9P0wy+svp4wW5Pj3u5776ccv+IPffklJCnjwcyaWhVzOfHyTeXFzyycfveSLF5GxdNIvTUQIk2eeJzzCskbWc7VzW6VN9T3Y+tmep+nRuiYH7yn0kktv3rwmF2GaDoD6O9Z1xXvP8Xjc6LUxRs7ncwsw7n0BqQXILu8j5pu5NFv3+88vW0bbYPwM6QHlsRSF6WpA+7vbXwqkEawche3VpsmWVgZU980eqgftjUwhixWCof3ci43uqBci4MMR5w+E4CsD5ImUTK80X83Te/p32ffPSmVmAWuXlbo2W6S3U5mPNPB6Xs6kqKB0j1cyyBpkNd2n25b1VlVvLPVerh2n/sdlWTifz8R4q+2pvT/aH2rOqR3fLJOWjHWpz/WYXG3fj15+QgjbEe0Qjv1Yf1Px5DKRo9TywwFI7VmXZdn4WkfAzBhEn+dewklt31u814C6+jQK5/Op9rFU/6YjTIHj8ci6KgvJ118nbm5uePnyBcv5XN87wfuJlB4ac4afHDhN6IhxrSwbytK1LCvLeSEmRy5TLR+3tF7LFGItwyy1BLKTova2JWZVKTaKpSeweKQBbACmeeKzzz7lq18EzqfEui6AEA4vofkU69V2Aze4KwfpI1zqvUu1IRAZStOabVNteWwm9t3Oua5TT9MERSjusa8kP7Ib9RqjP8kSFqCw1nVLffFQRJid46OXnyBuohTIMZLOJwiBkhPOe3yYED+pr11Ex0yc/l7tmOAnnPhawi7jvZVQBk0C8JqQ4Xvn6dxMpJQJMtUy0crWitTSU7mzbLFZj7eljvqoP5aNXfmB2tsYf7C+7uutEGMiJW2DrUs9IaLLWG57/FvfVYefZ5Yl6rUK9bpJS595X9e0AGRSWiil8rcM66mVirK4Qn+Gft+UIjmn6mcMxBiZponz+az6iFSQ7tBeTfLQMV3XtfnLFDRTakIMFPLOPmbzvlzas58Cxeq+2O3i9o4Nfv7xmTT2BDm7tu/rnJeW6FtbAc8AqK7yYXIFzFzlKle5ylWuYtKUdlM69GNVplxDIzvnmsLn/YTwOHA6Kk6jknUp0DqCO+xntjDiGPgA5hCYZs12NyeHAWBGwEyjrx+CXS0LY1CKzbkyGu0AqRRiVR69c2q2l65QWwC7AzhQYyNvA22t5uylgD3bIEbKRoMYcW6ihYTcGOioJZ4oj671eDifCO49ocQ+Um4tADoE/FosvRo0TwZu2vUeH/OoXUM/jeMyfteDWqNjpSvXMtyvG7g7xV0GJ1ilimQ3Dvt5uB27b6CED/feX//i4U84NfcBr/2YfVg7RwaDvTztyPtlyIc4BodYN/Xl0LEcgFO2RujfjwOHOuf6q6GOQKVPV0OxALkZmOp82jlgxFOYSCk10J7dV4/rc1jbV51vLXicwRn1cqmlTDJe7NzaDukUvxbo7SU9jCmhvzP6PFpGxta/PQBm7IsONEvQWLkurxmXxquXROvMOfsg8qXzyzDXnrrf/r25tJbsnU8jaEbnc0ZIvLn7Smuby4pzR6YpMs8BHCQpSAV05qIUzNRydolMwrFKZnIZ54syXEMtEdVpeykG/tgb8YKWD1JnpWuBdvs4kTFmmtwcS0r5nCmV+UedyIIPgnMrr74Q/uyfOlL+lIevJy7L/p3erc+7YIAdvXcb21o7uo6z9GMBlgX+1d87kJqOUM/JtwjVMVpZqVKBVLRg48vvC7/712GNd6T4mlweiOsN8AmdY6Nw+vrIv/tHP9a+Fc3cou5TDijlBfE+tLW3JHAy4Z2Wmcmt9nV9SvUENprpUozRqIMidJ7RfO+294ts56wMJQBaLw/z9mln0ofJ82un7JzBrvUhohnvpYGz6jhJGf/C2NU6jX79LmsZCc06m2r5S9/7qvbBPCu42pyvti7rq1DIpY9DXzNqQCl3fXRc0zQY8tjJtl37rM/pDu2do9SOMX1w24bH4OOuQ15eg+xae51CpLdt7xy0NWN7fL/26CQd72PO+/Hc8Zku6Rrt2qU7p3uAUPc4BbN5HVf1mLZ4qlTwlJI0CTcvCz/5b86UtBI48+bzwr/6xy+4ylX+U5BfN/f6u7bn291BPky2esGoXWz1jA2ofDhbnniK8uhYlX/4j0786Z8K96cDD+epZuVnCoEQHN4JU3jg1dfPX/fbkldfwD/5e46YAj/4w4QcNHCsqtvASdKYMXuPWTKK2hOVAUJoQfJpmrU8RlBdLkb1DxizG+j6a7ZGzxrf6tzmJ9nLRufPT/fMh+orH3rOpfNKpTIcQRWmQ5hdY74mTUDqvgI9p7LlFmn7sOqiOiLrGjmfV6Yg/NHfnjnf/5TP/+3Elz/9dLDdbez059ueznZU74/4cCBMnhAyRWBNkdkF1X/K8+/8pf54m638fn3fdYR23nB62Y3/+LuyUDidy8d7PvrJ1xyPNxw+UbZAgHVZtIxYzjjfS6ODlWUdQANCHbvKlGK2XCm4oiDltAo/+78+4nQ3kU8TRUplNDarevC3FK//GnAmgSgrcX2CrthQf2aB4pjnW374k59z+1uvuP9q4ov/54ftqPed2WFO/MHf/Dl+KkzTLSG8IBdPyQ7nZuYXnmXJ5KLg75wSy3LmfD43ABjQ3nUbh9Fn5pxjnmcMQOfEcXNz3Pg5VVUspJhwlS2EouuP6uj1nYqZ0+ms7BN4YsyUfCanws3xhuC0tG4IChxZzidOpzfEdUK4oQAxKeOTRL1nCDO/9ccFj4MSSWkhLonP/8VL0momh9nZxUZneDdkeBe7rTkp5ys+TJQXN4hkxHXGipxS7b9utxhYzcTKvKjNJnboMNpmE9ayr8VsfbMDu2/JuGjND6IsvtPG3zIC5kebwEBkbfWo9xiP875UAo9MXJeajKXM5wfxzMcjH3/0qdrDOHJMLOGeEldK0XfQebWBU1b7odT2Nmt1cKy5CuzRJlUfSwXRi3NILvpOiQJEcgnd59rsQWlJRdQ+ClMF39QyO6OnYfS17wEiowhPJFC+i+xO63uPvoOl0N67Pl8e3+tS/CPnjBdb6yD4gJBZVy3TfTwcCb6WbcqaJDtNR04n9fsJfT0e7eWn9gIDxWm7tZSx2tvbeMveR2bP45wnhFITeAMxri3xDxRw23yYO/t5bMf+Po/76PmVs69nmiAm0EpI2bNIm5O++heUBb/7Z96+N1/l3eUKmLnKVa5ylatcpYoaIo4WeMaCwTQFXhV+X508ptDG3XGXgxejg99ydbrjArYWeqVMLI+vuadotGvHGJsiaEquGYl7NhlD69vnVpakZWflAsZaI0LJmZyi/mxZ574HDpoh0B9hVPL3yuMopShjRM6ZdV1rBpkpv2NQno1C+C5i9+1OkPcwLApo2R1pTh2TcY48eS6Pj3kKODQa/peOedJhJ3Xe7ueDNeLRKWV77i7w/lbDa+8d/oby3Lx4dOtdn1wEy/wlsRL2AcWnumg7brKdl6UD4rQsk4FEQnNUWH+V6oizD0szvjSDIeVYy6TVUhXeKaN0c/KZU7xfb/xpMjJWSK0/XWrmSLXOCcFh2RzjGpBS7u2W0qa8ZfpY8Ha/3gK15nHZGJx7BpztOqFr4AjWG8fmKbE+Gxlv9u/z5fPk0es6vhuXHBLPraf74zQYEWofZQorp/M94cERpoIPkVzAKoolMohDSg101Ji0FKvirpBOJ6mCZipbEF59sajD1QoWtX7B3Oy612pf+erscs2ZmUWglhszp5s64gql1l8X1EkWgidMQpGF013mq58dgcOz/W09tO/B5ix7YiHZfjMGDQpWeG5zzQxf/1zIxuaCuZyklbwykt5EIYn27+FYmKbEeX0gxlfE+IZlWYHf3rQmL4GHX4QNdKe0e9h96u8FyIJURht13g20vSIgrukdpUA2JiA3lCZDL1Zyblv+Jf9Rkd2Erp33wc69D5SCZmGWFr8c3cC5z1OjIK+HSHAt4FegZmjqGlmGrUbBFeCc0m53oEt9F+szK6W1VGrqTMmF6KKugaLrmDmFt7XidV3VWFhdp+39FFv/rC1vW6sq9fruu3GduaSfXJJ3DSJeatNe19mDFd92jfFa+vNx+G6/dm7308FZWiwIUUvNtbdTA15S90Ak12TPrpOWpME0cZ5PfhRwwERErnTYV7nKL12e20l+mabA/r6jXmDf2W78FCTG9uzLOsjTWsjnnyc+/xx0HdqXkjH22e9u/VnP8OXPtD0f/fiM40xc1krGocFB29fGJ9quy4VpCro3VZ+IlppWPTHl7t/oZRClBdDGzHMD6Y8JQKPeb/fc718jQ8de3sdO/Tbkor7vRIEMu6DzmJxkQILD4dB8P1bWJ8ZeDlKyNN1BRMg44po4nRY4Oj7+YWA9Zd78orLh1nZIqbpKnbm1UOwzT1LtUzfj3AHvHWGKOO+Jy5lcLAj9dN9+N32vY//kvUoZmljaPx0m/RnXSCyRFz/I3NwUvNS5VHoJ4GaXVr+Nsm5oQt5oV/RSwZ11z8ZYRPWO05cTy0MNZtNLw3ZbhKrFVLBM8VjA//G/8ZnVJnOi7E0ffz9w/Fj9gF8Mx7zvCuscfO9HnvkIYZqZwoFcAik5nJuI2REjakOKZ1kfOJ8XYkz1/M6u0EoeWwC79pf+1LK3fgic2+uk9jxNJzfQNGgCkLLp9nUjrpG7N3cYi21KCmo4Hm+Z5hnvlKVSXOZ8vuP+/o51vQVuAAV/xJTorJErx48jU3A4MjFGHu7OIC/YvwMGorc1af9vHAkBZhxBPDEo+N8FwScrM2fMUsoe1H1/zWGznQWP5vo43HVHE7V2LbmClNESvtVOGmwYA4xsWGekr1lbpnO6fwizhawBnWXJe02eiSmqbSUBqZ/f3rxknm9IGUQ8xRdyguIW9SBUpuOcSqVh0nSJ3B0O2HqQS26guII+q5aX8njntORuXVPN9xNCIFeGXR3C6hkQ0TJFRZ9vmiaQzBprkitex+KCf//SuiR23fdWdszQfWwz7e0x8x+17xi6yNrwhB1o36V1aTaVd7qHHeZZ31dxiMu4KVQdQMFnObFJwLXrjdfeJvt6rNzvsqwsy9oSiPvxe7CM2u8jQ38I5hdc25oLZQu6dTQw5Picz+kXKuM+speyWc/0OupjsbJzet3OthRCgGjrRGnXYDOPr/JN5QqYucpVrnKVq1xlkEtKaS9b0invt6wtXZkbFaU9urgxzQy++lERLLtgUo/dVqXVjLhKx3ep5BF0RHgPTOv3o2GyR17vHS+IEKYD8zyTUybFFaE7pqwPnPRznfiNgj1SpT7X1wrQsUC6VOVwW64KzFngqhFTHluOQ1/vf5qivx2Ax+fsPlX91ncXqB1mXf6UTqp2ojQjdbzHowyBQYG330fGmfGcTZ+ZW8TspTJk7NljymiidrABhQYEGvvoEmin//xwHfzpPMq3nLdrw6XPNu+afIjx+Osjl4J77yrSB3q4oP5vfz0DxdmaswlUloICbPqfY7tK0WyYLLk7M0pp1UHUkJswh0N/tg6AyLkgrmj19Asvk0gF5AzzUcF8gFQmjguTUUQefaeAnj55x/n9rDNW7D0fXUkXO/jy6TvD/Lnj2B136bxvApoZ1+VCYCqBdYmcTie03Fzk9kXgvCiLT8FAM/URRdCa5prlaBxo7nWg/IcbijjCZ2dlNU7GIFRdtjI1B9uj5ooMjBx1bkrB4QnuUNuvYKm41nEo5oybOR5umA8T0yTEcxNFkgAAIABJREFU+Jrl/AD85pN9vQ9q7aU9Lk+P7PY7/cvWV3OQjde3wNjjmVOBF2VskR55PsEv/hweToE1HUkx8/DqOFy7/9bVCdkE4Houojnuq04gDu8mbCtofV//mZPW1gbL2No23gB1uQ6JIAaQ0RNrK7cUxtI2pu9KdL60PjZnMVKzDwUDy7R+s/3Fl03yrWbyVSdeDfJJnb/ibB5X53Zdb0ZmpZxtftQghgOXRfULGWaRLXLYumzl5/rMbPNYqPcYygO0ew0ONAsGijQdqu3Im33UtXfVmUO9rTPbWf1scGnnxDX9xKZHV97sOccDL+/7+9J5m1GuQY7n2BsfA3Q6gw9trepZ3eIsyy9rUrYo+Mx7fbMaCxOQi65zuEBBmI4rv/E72pdffV44fweVUa5ylat0eW4P/6bXfdfPTS/YwzBMJ7h0lT3D3a+r/NZvwXxInNbMkh3LmijuxLKcWdeV2W/ZOmwf2uoSZfN5Lgy+ALUtUsrEqH4HA8vknDmdTtgoW7lsS/jR4Fcv/Wf2wyh7ncaACU/J+wI33gVM+q7nN9CEaP/sGWgvZd5bfygzQqGQKEQtcysGCuh7b8qFFEsFUnu8PzZwLdBLvxQFx+c6i1vVrZ0Y7NQBuXhyFpwXjjeBmxczr+MDqUQFdL+lW79L0Mzlzyr3RrMte/AypYz3mXXVz29vX2p5mFwga0mNmLR0ljIv1ZI11U6epomUIMWsOid9fJzTIHMmYwp7KY2zqfV7RssD5SLVDB8sneL0XyvfqfabZjYMzqONdaQ+xPN5YZ4/JvgD8ZPEb/z+TIyR159nalWjt66zLz9ZePlJwc83HA7fV1YNN5M5gPiq//r2fIiCf87LmfOyUAY2mXVdSTFhuqwTS3zppZ6NtaIUBSot61ltnqBJNTlnlmVpY21riveiJZVSIgQtFZNS5nRaOByOFShQtKztNHM4zITJgaysy8qX/77wcK++y49/dMJPECZHTjVhyWXWZVH9OidiWjidH3h4eCB8NFG+foms0wXb0TTUDpwxqSkqeISpCPP9hP/pJ/z4/g/5j/wpr/2X5GR68XDdUlDGL2kB9ma31Cv3OWS7WA/ob/T5bCASY9l0g15dmZPMbqevSzkrU02qzCrOuXYPEYc411lvzE9QWcicU3so5cS6nCu4UufBfDhyc3yJMJFiVOaSMJEOQvITCM2Xvq4rYv6RkvWdHWzWEXugtnq1bYv5qHwrX2ZMMlrG3BifBIpvNo84z1znpwEZ1/VMTov6U1y1Q3PRlbX6Xrrd2LWJ0W/01Mr45B4kNnv2n0sbr5Ty8FzmqLAZuNubdmKxiWZ7YUzQNg+qb7x+V1Ii5ZXghSl4TneRdVUA0ZjUa/bcyDg1tkFjI7mB7AxUa8eKQAh+42MfAUFWltjKIFkf5rxlr7vYpTtb8yJoZnNqufDT/J2QcmWOy1njLHZ+kT4MMrpczBebaxdfZsG5yvvLFTBzlatc5SpXuYrJU8HHmuFrCqAiwTt7wx6Ysgc/dOS8KY/SqHVHsE3PKmZjgTYnvxOtwx0flxXZH2vttEyszXXEAjh5oywuy9KMmBAmpuMNh8NBawejWf/mnPGNbr86a3KhuP4s3numaWqlWezzSzXETUH0TpjnwDxPxLjW+J0Fc7YOt66YjsdsWXxGRXVLP3rZiLhoXGwCfGU49uIlNifqPbcBw1FJH59/LF+gIKxOH30JvNKe39V50Rxmw3MPfaOtH9DnPXbYjt8AoXblFOyCnUPh/Z2Bl8Zpf49HTsIL51+6buujZmB+E9kH3Pb3G458rhsuOmCf77v989vcyPly5r0BXYzWXCO8uX6XySW1QGovp1TBci1AO95XjfCcC7asiID3odGCWrDRmGvMeWVroqtUxebk3jBXjf9q2SWpIDm8J9SsIeer8zulVktYRLPIECgp0t+tDsQopZBTqu3v89gM3tF5Pr5ntga2MRAFlOUcsfd/nAuP343++Th2+3F9Gvglmnn0zJwY14dLAeVL54z7Ui+j55jmGUpgWSPn5Z7TOZLzC84rpFz7AQXNiEAuWqapARWLOm7Sv3+J/PuXyDHy8d/5c/yUiD5AqpmjxeHlVvcLp1mGzhctBYUxH6nzjuqMTkVhH9N8QwgK1jidVl4vZyheM8nwTP7AixcfcbyZ8H7lq68eOJ2+4jnAjD0XbRW73OfQ39RLjsrLR9IAK9uQ0OO/NdBgZdMKrjjNKKzHvPkC/uR/98D367/tnZTERz2W7tmWya4CeqxgAA/OkXGkHMjOkckV3FFBPzv9ou+toOPmtP8q9XePN/Q9pv1t/zavzIftI08+61Prfvc00Te+CgyhUJWxeg09VgQyuQJhBoAdNa+/gv9EBOcNVVPfr6rbWWkfEc0avH84qyPehUrBX53CGP10v7eCGbW/hBrwGtZOpUZPdW0zMLZv77tz5dF629fpygq42491LSztu7ZP1G7a9O/wWQhhe68h+LldJ7tua8fZ+I+lI8YydqPsAd7j9945wqQZ0SObol17XPebvoCD6uA2vcF7NwCgdF8tOZJq3yEOh2aEC1Kd7aJMMyj4KUngxfcif/x3Eo7CP/5fI3/x060eeJWrXOWXL89bfB92rfe9bmn/39piz9/p29sXf1nyt/5W4ns/fODnryNfnCa+fHXP/enM6c2Dlk0i1JKDBVymUMuiAGOQyOzWnBXEmXPP5Fa7FsT5VoKplMLDwwOlFG5ubhvrhpUhEhHm+VADft3HYXvcaO/anjXq/5YgNcre7n5Xee745wAgl2xf0Q2plZpoukDOjX3HdLVlWTgcDtpnUohxJeel7ssaiHRMWNmNUjT07t2MkwmKR/wBcYM9Stc1+5a+D6vbscqe6BFCEeKakLjg3MTtS0/hlof7r8hx0TK87xDce87eetfjn5bxjS791/ouFjHfitnW3deitqWvLJ4zt7c3GjBGiMvCkiIppsZ4Yglp0zQxzzpGDw9L9XlV1uY2llVLLaXqI93vNjQSZfvpoBmzbUBIMeOz6ZfV1mpWxDYprfVFqfZ68ghHgrvls9/I/OZvT7y5e8O/+Lsry39I77RK/fh37/nP/mYkyvco5WPAkYpQUi1Z5RxFBCRRJJJyJOXE+XxS32NR29DYZUQc8zSTc2aaZqYpND3YOe1XC5TrY2kfmn8rJS09Zt/f3ByZpokQHA8P983XosynEzlHchZl2C6ZuTJjHOYJP8F5feDNV6/52T97yXp6yff/4BU/+MmXBH9AZGJZc7XxIKWFw+yRknh9f89XX37Jw+mO449fU5bfJ629jLAB1Oy989BBGFVCEY545uKYi+PwxS0f/YPf4zfLX+Xvfv9/4o28VgbfaOteVlAiDuf3/il7br2FrdPF/l99K6nouEtGwU6VoVGZ1w28ZPNq8MthyVRByxZVhlLnPT4E5mlGpCd2OudJKZKjMoS4aWKe5loKfAUicT1xun/DZz/4EakIIRy4vf2I4+Elp4fIshS880zTDfgDMS11P6iAndM9WBJozjhJtTSSPnuumJVSFNhjr1Aufc2NtW+1pM+Ec8KyWimdCXCsa8Q5mKeZw+HA4XBgmgLn5cyyLKSk5bqclTByBXImO+33cY2V6qOTutZv99P3k31pXjfsc3HpjG76nObHH8+XjW/PxPYkKEwucDgeCGEipcy6RGLMLMtZrx3hdHrgdLojTIHjYeb1q1fEWJim4ya+YevnGHPpvrzIeTmT0so0zRyPx9rGnvATQiD4aVO+UX2bvu6RuSUkh6Dl3VJKaqOXbpe2Ng3dPsZe9vL4s77P2F5i/6Sy7KWYKsAy93WgJhOnFElZ1/hYGbScQ+eP99WfcAXMfFtyBcxc5SpXucpVrlKl5KIUjeyDmbQYENLztg3xXtxWWdwDZeCxg388tt2/Kk5PAlxSaYETkxHkYAEO6JR9dl1TMs0xZJSm43HTNFFKYY2RVLMwnFPaSBc8Sy3JFGPEz3Nrg11jLPE0KrmG7rYsMGu3tUEVcst+ker4YgO0sWB/C4JIdzrugR7NKXGpn5+xKy46XwQ6namjlzPYBbvLY2DUvnTWNgj1dOmDS5nUo3NsnB8KELDgkGz6KhdqYM2s1fHB1DjO1SIcA0qX2rBtq/7vEtBl71hsAX6/zeB/6nk3Xb8bj73RcQlI9GFi5kgPCI+32r6H+k+E5ny080YDpR+77Zt+7W32gX12iTEq5w5KgW7Aj07n81nflSlQx1UNvs7W1IFp5/O5OvcmvLNMsnN1dmgmT3EeMGpzj7iyG9NcA6aaKTNGE2x+q2PEb55nH8Rd1hWj2HVj8Ld0KEM3jmkZ//ZM1neaCUOjTd3bp4XUnOX2Do7zTrPKQjtf0HUpxk7vPr63+7k3PuMe/DY+9/7dbXNFpDn29nIpKH1JtnvNlra93QegCCkJx5uXiIusayRGuH9IfPrpD/gyHDBChAJEMk6ERFJemZrhYuWEABwZZMHPAZ8zrAo2EAKH+bY6wxIpLyAJHxJIppQIohk01HeKBDEJ4AdAaSH4wBILPkxM05Hj8cg8H3AeUl6hJNw7+gjs7TE+mH0wrAz/H9763THQ30Fpf18KIFy+f2nXSpLeek7/vrfcaLsd23P3q2F3vibE1f2sfk5RlryUMmQD8iiAh5ZZRgVx5BpH8IjXrDznIZdEypU6/QkAj+3x/V3Qll56R55cz5/77gnph4+ePnsv7H30m3MKIHXtzBXo4+s6pU7lACUT1wg5qfMyJ6QkpsnhXEAQ5mlmmmft37sTN/OBeT5AhWEty1KxGn1Gik59oOtJI+NcKQWPR1zYAGuNqn6fSb95rroBjX2811dGfdHWzE22+u56to7udR1r2whctO+ebBv9uUfZOCmHz/Z6hK7Zsa3xtnZeYmM0VqDRuR/EsrrR4MC6UGqABJyWJ4yZUsdcxOHV69/WXO8gyKQO75Qo3LMHTl/lKlf57mRccT4stLS/1vj/tzPCbHWFt8k3beF3I7/44jX+JpFyYI0rMa2cTvfK3lCDzk48qQZaEUfwveSEsXV0wEzSog3SS0ofDjMpa+DSADOgvgpjUXNOmq0xJgbc3z+0PcE+18BY3ABnNvYJl3WRvS0/yoeCYt4G6HgcgJO6nymQYrSzxr3ROdfAMsooWcv4lJ68kJKydTiX8DWAKHhSyJzPS73O4z1rrwd31oPLz+IqYCYXAyvcQync3gakrKpLMW9ArWP/vC9AaZSnzn0X/VH1pMqCUJXlEYRcjxrmquB9qPMSQpiRUogsDbil46FlO0MIDeC1rmtjQXBOwbrTNLXkEKQmdOTuz9NnKAMMT6H6ysbRmWZyTnz51dfc5pccjy8Jk0fZTrqP43FvlAqYEI7HFwTvEFFfx7pmYGJf8q3bQ5c6fAIJWpa2uMbsKFLb28DnhWkSSiqcHx7QMkZ0natov5pe6r3jo48+Bkq101MFa3igkJL+szESEULt44eHE5DammDvyueff86LFy+bzv7qlZbC/fSTT5kPCn4oZF68ONbknoX1/MCrr76EfIvgiSmzxsw0BcAxTwFB57eTXBmXIsv5zOnhRFwTq1Pmp0ddh9TCe4IrxtikkyKjFdpCFo7Fc8QxFWWaUSbECccMLK3UkDj1MwDKEpyrbi2qC+tAVOt38DfknNXWq4xHKSdSKUjW0rA+BAUXJYgxqz/HOUplWBLxzLP6edd13fpARUvu4bQsWSqJdY0g2ifOBzXiasaNCxPBCaWscJ8oSwXBoGCcqbIDLeuDrouiiabOeabKmqXrUWSebyhFgVhxXYmlds/AyFNEtDRxgeC1jHhGyDER6/OHSctB5WrfhslsBmFds6aViQcfkPoPH/QZ21hKBUXUEc4OKZkU4+DzU1BLCL4y8NT7+c7EMu5r72JrPXXc3ne3Z4wf7ce9Pbllto+cHhIlPzDPM0arm1OiOMerr75mjWecy0jx1Wbq7RwZYoD2zo730Dlaagm7qSVdKEtUt29dtUv3MYp1XTmdTpRSmGdl/YIOzPFhJmfPw8O99j1jmcnH/rzRpzH2lb4/W79gSgosMv8shRp38fgKalOmpYSIUwY4Y5XFKbO/7cTFEq+3/uirfDO5AmaucpWrXOUqV3lCHiuRTzMAXAruW8BgDLA+DnqP93vemO8x+K6QbWt4binpzdAZnRF7RPgY7BjrZFr7z+ezZu3GyFIzPrzTWsJWoVWN/1DrDcehvVvmFAPI7IEiHShUA+cOcq5tFd8cEtDBMKWMzoKnx2HsfwO5XJInnTNSEDFQxOjMsT4LrfzMOFACzYPwVOD6UtDqbU6efeBdvxyvZSwYmVKeV5hrt38jp1S7Dk/PXZHL742e+80cYnuj7dsS6XHiD5J9Zv4IWNkGah8Dj8Z50kFvl5/NjHLve6akvtLqSDZjzMp2WNtaxmVOzUAb27B3f5XReYgxDW0ZseydsGfaOz9Hse/maarlNCygX6CtLLR29OuO53cjdPxdn60D+SzoPF7nUt+PTvSC9o2tn7ZOjuut3a9RzQ7POq79l36O/aCOw+fDJOM6fcnRf1kusxIJDu9mhFADGBOUTFrh/i7yg9//mu//7isgVccZfP6n3+f09ZEshRMRZXrpDjy/Cl/9nz/GOWH+8QPzj+6Ia0FyqI7mhLjCze3MfHDEdEfKCylHTveRn/3JZ6TVaoQDPvPZH37F4UazfFxlOJqmQAhzrVNvWXIrOZ+ZZuH29vCWPnla9oAY+0Sa42zs2f5/+608+vTd5EOXmVLdJEhpWaVdenZiZTkHKTifcKzksihNfin44DlwYF2EWOt9gzlcSgu2KF3x2OLKNyZUx03u9xXB1eCYvX8p9uw9Eaqz9ul349vur+dl5/Iv1r+2DxgrVl3LalAuhKkGUxxSPI6sTi4U/Bdj1FIHKTdgcBoArqnSP28dmL0Re8dm+6Z0QOHImqJ/+2Gfefycgnt0rVGvGq9pQL1L13Gu71F7/cUcmJt35Iln2VxV5JEeeglEtf875UzKmv07Bki60zS149WxrAxnEsb+pr7sub1LMa2ktAJ1HcuZGMHXTD7nPM57Jq9BGp0jhbUIWgoBfv+Pj/yVn9zx+vMzf/pPZq5ylav86uTZ4O47yN7utH3Qvvvm1xuv3I/5dZNSPOuaOK0ry5pYlhPrctYAF1SbQO3uankQ41AycuPvqJp/6cFaMLaB0myN0+nUWAo0IG3XUl3eGMZK1XnGwJrtU7a/bMthbxNPoNtEI/jyVynWMtNH2udDUNHsH9v7cs6kHIf2b20C3QvXGmycBjvV48OEuM5Emi2Y19qzs+naTzE3FbkU1kX48/9Dge2UwIsfRH701++YD1bS8DFz3DcFy3w7srXTlb6lfjw8u9qIoCCQHrQvObeSS+saWOLSbTfMVnVtbAxwO/oKBlWbXDRxQZAWVDYdcG+5aAsLaRVe/5Nb7oPje3+Y+PQPeqkcfUEdj1cfsy/1LwWdgPrfBOcO/O7fyPz4jyKvfxH5s38a2p33I/aT/+rMb/3VQpGDrgN9ktQWChaY1mTAREkrKS2IK0zBU8QC1GXzDouIloyvCUU5a/8pY0eqQCQF3YwMU2bTh3BkmkLTD51zLVjunZaImucDU5jVzqQQgudwmBEpnJd7Pv+3mb/410eW9AM+/YPPEV8INwnwpMqYRYaSI1RAByVyPt3z8HBHXBeC1xJPWS6NRZWXXyO/9W8hT4i/IUwHwt1H8K9/g1RPkWxJLBWoFia8TJRFAYIxJYIY+4v5gmm/t/Ez26dkBZbkyrCRC94L3tUja2m2AgrcEF1DvLMESC2drXbClqXUVR9yKcpe64a1VQEKCnIvonPeD4BInQfC+Rw5LydyTSI1ADzilBmmgklijMiyqL4eBCdBQUfiEA8xKgsNQdsWI2rnkVvJVZOUC25896Ouu7mA5EKYlCFoWZZWamos12QsPAXH6bRwd3fPGrUE2DzPkHIFa9ieA2tLRO0MV7HuseojdxubZ9zbnpJLPmgTHaLt2/zc8U/9XYr6cvKaiKeFdY0cDgcotqaExkJjyXLn84kYFRxja6fNiaeAOd13WZgPcwMg9oSJqfsBY9Unhv1FdQZNsjgej9zcHPHecTo91ERCITjbU4dkOKyftvLs3lVyK+cMBho2hphSHc+2L/fEwOaP3vmK084faeP367F//uWRK2DmKle5ylWucpUqRqEPQ2D4kT7UP9sH1Z8DNWwUGI0wDbrWuzliLEtgZIywa6/runE0PIV2NmV6dADtwTO+ZtiasZFiJKfYqAqdM7T3cA+U9jfGtAng7IMe4/32wRkzmnJOxJg0sORqreVWD5beVrcNtO0NhceKPE0hHcfl0rHt+arnZ6O09is+ckL1Mb48hva8e3mSEWd33uPxvXyP1p4n2lBAqW7ZGkPvI08bSk+Pwduu8a5yCZgxBhE/RGweUw1GzfrfvKiXWvL09fSirW3d4OtMC3ZfGebZ+L524MU226OvT/qZlkuy3z2ulkmx+42gDmVAsDb0R+jAptGpar/k9n5pOYp+nJZ3QtkqcEodXftNQwlDmRobo/rMmWEO13dT7EUbDETtv3pPSnv+3n/dIWMAmk35DRnZlx4HeS8Fc3PWTDys3JVIWxuBWnpFjVyB3fhsGSvg8VzfvneDw+qC7Nv3LmCZi8Z8bbg6EH11HKL7ConlnAnTGfyKc4Xb45GUC5/9zgP8OON9Zo33uJx49dPv83B3xBfHlB3pF0ccQoqO8MaTJfPi9x8I06nOwQzF8+pffsTpPLMUiGXivERe/XwmpaFuui8Ud8s0a9D++BJe/ujMIc+NFWI+ggtnlvVLfv7/Fu6/+pjTmw9jcrDZJAMqxn6zEc9FnYK/Tm6IFkSRgnmjn5oZQsH5e3UcCsCMK54iAZG5vXOlOvmyokOqU1N0v7D1qX5uoTARpQuWHi5hCoEpBFw95/7unvP5XNe0PKxBj3v0qfldnvnu6U4qXDzlmeu0/dHWIdCseaFmy6sjt7XcWX5vqUG/uh4JiDnEfCDnVPcYXRW9F0rx6lTFHNW2KOusVFYbdV6Xob9FHMFPlXHLymKNgMDHz2R727jX9D3Et3uP+lsvXWH7bl+D9Bi75lZ63XjbA7UB1q12HXPOXtIPn1qj7bNxDd2XXtqXEhuzFG0/i3EdPhOoZa4Mjh2C53y+ZwqBME01wOIsXoA5wjW46OvvlVkNAQIvv+cQidy+zLhQEM789E8n7r5+vEf8KuS5fecqV/ku5V20ml/P+9jeWz7w/OfvLM9++6uRh3Pm7pS5W1a+/PprHs4La1xRDSJQUtfRi6hdTyotwGdsrSrFNndga+uqfq0lIcYS02sF9x4Ohw1jbQuA1wDiJcZH2wvGPcVYUIStfv0ugadfVnBqYzda68w8qve0UjXQ9+UxeSrnRMqaNNETOdywd5fGCOG84IOrtk3g49944Lf/i1esS+Tzf/MpOfqucw6QmR/+5onPfrRwToE1aVa/E6fsJKnwxb86kqPOhyxnPnr4KS9eQEmJuCZK+bCQ1If0++Nz+g442t+Meo4DvBBjZ0YyHSqljPfdrwZaJiNHZe8EmA8zr+9eA/vy4LTPStP3Rnu9tHt1P5QQZscP/9pKSYm7v/C8+Xmgr0HoeWji2fKVxwHptxLi7d4BxMpRjvyUGQOzaF9kchrv7Qgu8PH3J0ATLUx+8/de8fKThLiZlCfA88PfdUwvb4hlrqpnqeeYzWuB4wJkSl5J8UyOWgbefKXGbqHlnrtd38uzGJgClmVt4zBNM/M8VeB3TXqxNov5Hruv83g8cjgcCT4ARRmuYmKeA8fjzOEw4cTxs3+WWJbCablHjiduJ+H46YILgriAkxmHseFEBePlleXhrrJwPbCcz3jn8eIpCcLHXzO/vIf1wPL5Z5v54afC8Qcrk59xAQorhVOtyltIw7toMydME3M4sCyR88NCXFcFtHhl+Sls17gMNaFB/Z41XUDfg9LtCTULpem+xfnqU5hwMmGAHFu3Rr17D1JElJlJ16tSy80pO04pKyH4+n4oI7Ktbeflgbu715yXM+GoZZrEB3Ip3N/dgZxY1pUCpKIJIj5MyAqr+a9EGdAw5pyh7QmnLJKpDO86tV9o5298dgX8FCq7SQW5pGrsIA1IlLOyxS9LpBSY5gOlaOmvUBMwp3nGO09MEe7vWddVQUt0/5X3NWmp/rP9z3z7bwPNjGvKVqpt32Ihfb16zvZ+DLzRBAOk4J2QROeXmbfeax8fDrOyMq0KnKEUjocDBtDb32N870dWOdvHRPozjCC5eoFh/e5tNkaaztAfGqgLwAfXWMGMpe5D93wRs2nNb2L93N+xdV0wH4mWM3eUtb87Dq/unuqvAQa/qpWIvjLMfFtyBcxc5SpXucpVrlJlRBCPn10Kpta/EDEASXfsm4wO+43Dv2lKeo0xWPCcKGWnGbS9PWN5kX1wGB6zE1gQZESk92B4NdjFkTffdUeTtLJEQEVJx9iP2QNYxraN7bDfW4C6BehyNW7V2VNajdwagK8I8dGxtb/eOG77wHTrz53Ce3EMxL7blmLppzr6sNb+JSMF/BNjetGweCJoOD7DyHRxSTYhchFotawvH1wGk/lDgSvf9NxvIhdBM7zdGX5J7BHM6CitVvSHGkXV+tnMjTFIeHn+bRzFMBiGl4zWcX44DIdl61gpqTnftuWi3KN3YwPmQx+7gcEswNsCszQsSwNHSX8Xxahcm9/R+qJ7XTbv/DvKCJrZG/rbNdo9WscZfr8EOBnn0O6uzVEisl3TMYdedSoh9qyugSyeeretHf3n87N2XNfeRR6Dq8Ynqj/VC6zPVArKSJU1yyclvNfspbhmbj878/Kjwjwnlvg1p+U1r7+6Jd4dyKJZMxMOB8QvJ+TLCTlEbn7v5+DPII5EZD0Jv/jnt5zOEwueVTJJilIZD04/kvDmP36k7Qc+/tGZT3/nxByOjT46hEThjlNhmkogAAAgAElEQVT8OT//s+/x9X94+U5986iv0HFzA0uL7L63nwZlGPtyDJF9VwGt0lY6c6M9PuLxnCog97jgIVenSpkpeISpOVmkOp5HimcpQi4FZ2WZClCy0kbX90DEt74UEaYwcXM8NieTq2uQgmYsW7QzP72L9Fz+dxfFJ44j1wML29vK9reqY7RDcnUkVz0sizSdpwxBOQPYaQknWmAw58QaV5yvekwpSJhwDcBUQVkVVFNKrUvuHDGmupb08pNUfchX56zsSgbsdde+Fw0fDb+PzC79e1tz+17Yt4q9PtXPgceBStsC9sfrnmjramcDG+XSc43P57yv9d0v66D22ehstWCG7kt13qLZtJaJ6LyjFGUHOhwOHA8HvHPkZO8GiPP4aSKEiTDN3Ny+5Hj7QlmwRJnY4Iabjxx/9W884Ih89fPA3dePHvM7l/3adpWr/KrkXTSb72qefgPNHwth/GV/n+4eEv4u8mY58fWrrygiuq8XZTjLFQ1vmp0FFTMZN9jNpkXtwY+ge6YTR0FLedzc3Oo+Wst6WDDWdBXvPfM817JCGjS3gNoYOBtLN1/08Qx72dt07m8bLPOUv6kFaWtJ1PH4ETBk0hNz9Hm03O0IvjGzyMpVqa3ovSWLeD7+YeHmkwfuXz/wxZ9/TIqVSW1oryB89oMzv/dHr3mz3LBwZI1SwfiJ9fTAF/9mJlfmgJhOnM4/48XtD4nnwkMqFdBTtLTl8OzP9e27jM27SdcLNyDcGiRXvQFTClFrpeuPVnIppUw0BoMcSTWBDGCelPkgBF8DpKN9r9aPldJwruvKG3+iaDkcEPwEP/xDLYP78zJXwMzwNFXXGloKLuG8kNNBA+8Ipem3Wf+J+RgzFlxWxU15S6DOq+KgeDzd9/kbf+WeH/1OxHmIeaKIJ8uBtXhajVHsetahOjedlZrPmZIykjOuSCP0UR+rzlErnwRSAc8GvlN7os9zPXaeD4TgG4OsRxlFYlxJOQ16YVEdLoQK6st471jXhWkOvHh5wzQ7Tm/O/MW/dCwPjpu/cubl73yJ94FMwLsJ5ye8n3FuZjmfOZ9XcoqUlFhP97x6/SVIQiQQ/ETJQloy/vYr5kOBh49YP/+ssrdWthgXuDl8wmF6iQRlK1qq3RzJrGRWESakscz44JgPM/O0cLo7VcaTrgen3G1EXZsHH48lClHacuOaTq2DIs7VckleweJ+grK1ISy5cr+mKdCsrseiczAmLT80z3Mro6plhxQo5b2Ou/eeL7/4OXd3b0g5cri5xQfV/2OMnE5nZalVRAyShZIDh3KoPmZbmwJ4LZ3mnAM/su8kJGeSJEpK9XnZrAfdDTcCztT/M88TpVATSM0/55t/KOXqM5lmDn4mpcjd3RsQBTMdDkcOhwP39/c8uDO4jK3aWpKpl3TzTgjOcX9/v0mEfd5fvPU9bX3m+q+U8fsxueWyr/rS77kUHFpizhKdcsoUEeZJGWaC95QsRApTBcRO08QaC+fz4/JJJvvECt0HO4Not1cNBOM3fTKyRBt7fUpWrjE3liorQ6Zrydzt5Jwu9MRTUvuUOoeGTzt4N7d/MWoCtPdOS3SJ+aXr/u3AMTBflxrzQeew3ucKmPm25AqYucpVrnKVq1zFZAz6Dj8vGe5b5053wu+/f+oamcsBgLc0j+rZb8eOZUTGe43B1UvAnUvglaZsS6fbb22rhmUphRQjLoRmaseYyCXh/OPaouN99m3aBjV6uNR7aQZTthIIDblSDbVCDUw9Td/7aAzaBWj3HeXRNaqfQfvF0OuDE6pd6LHyrl+/nzNnnA9jX+2DRdtn685Ic9KKjP3+zP3sKXZz/X3k0vHFoO/D989Uw3rynu/iiLwEmnlfae+VXnHz2TdyhtZ5a23rmWM9+6G3YXBcDJ+NtOCX2ryfF/a7Zbj0UkxmONv9S8teUKdfooFD2jXqDGnvy7gmbB91nDujI/upNdGk04cPI1BKK4ODdMaK0egcr93vIe1a7I4ZpRvXWyakkap9dKTb71of+el5qWC5UgPtj43VtzmAGRzZl7/eOjbeNjcv7WX9+S3Anm3Go3WTZ4jKAAKZ+7sT65IIfiYujuAcU3jJ3f0byODrLhBFQYLNl19ASuSrL1/zYp1xzpPSQnqAWBKFMDigd2CZ/XMAJWbO9yvhRhmSpAjxvHL/8JqH5YEUP362L566rjGiWNkiAzqNMy5TgROyDRUMLpnvNDjWXeDjb9t2w+O5VAos95r1lVMkpwVKYb494IKWRpNaYiYXmkNTfwquFDKV7a0USgZx1TEqjpruuNlTSqE5Jw+HI+sa63tn7662f5yjT85t2eo+7yrKjDNer7T/73vtwtl1PanAkWIhBp0z1LXda6RD50sugGZw5gIla9BkWRcFoVXq+Jwza4zM4Qbvpua0tnXdHIBg4IxUAys6timlzSg/pWtt+3O/j9i9Ojhzv5de2l83YJXG7LK9/qVxGs8bvx/X8kvgwFFfHM/tP3nUdlu79+t9jJ0tUYqVFLNz1Fmac6wBBkdMkRQXKImStDxpA4IXGmDG+UCYtESA8575cMD7UB3qwRoJsvDrmP03jtZ3uZ5d5ddPnloRn9ujvyt537Z92/d5tzPL5q+9fbH97W1X+PV5Hw+z8NFL4c3dmZQib+5OvDq/YY0r03yg16zZMnWUapg6L0iRtl6rlHaO6Q5m+4ig+2jSY1OKnE4nUkpM08TNzY3eQjowpu8fbvP5CMTc29r2OwW1nUre2AcjI+VT8r624nN6zN6uNb+MAEVko2Pt97vRZhxBqzFpWRgDXeg5NF+P6jh5+Onx7ggh4V1u5+xZGIto6Z/Tg3BeBTkcmKepAkbPLPlrOjeesp7ksycljxfwTkt0dP3n3XW85/r8/fwK292vn7vXUcY5qz9NR3YuUbpq2+cjnjDJxjemeqKx3CVK7gawsR2YumAXVKbBmkSGlp9c4rkxvO712qqmjy2lQ2gM9IIZ9t1ws+NMN/LGWFD65yUhFHwoHF5oCctpOuBkBm7w/gVJAqU4Uk146zwjlWW2DYOgliTaVxIIMhGlAniqquR978PH77SVfc+M5VhGoJyWXkl4r4CGlIxRwvyWNCBekc6ou64LwTscnuVN5O7rB9wME8I0V2BCApzDuUn/iep9p9OZ+/t7yAkvhZRXRAph0tLZcU0o25MyrCxLRpaML4IWHVYAjM8Tfn1BjhPiHaV4SJ6l2t1WHlmqFUsB8Worh8nYDscZvvPN2P+G+dZANNRAvhRNialra2knbf+Zvt3LY2/tOVvPUkq1dFGsvge1QX0ITPNMLpVh2TktezrPreTq+XRmXc6ESQFOykSjAK+UE9SEMbI+eZZCyU7BMRKYg15PxLPG1NhEnRPCNCEuEEphdSusa9sLvDefnHZWrr5e22tSfRedC0gFHyp7l5b50mQ1naNWVlBcYV3PTOtMrnO1UMvZxdjY420up1JwpVTGy4ngHF7g4eGhjdslO24z/qWN+iN/817etk89d5xNERE4HGbWpdpdzY8+MHYVtZ3nWYEpuUS0XGB/l8f4QfdNWEJw5kU4bmzZzkqlq4+tD720V4+NqAmv8/V8PvPw8MC6rm3OGajUfJYfIuMeYn77nlCjQJn+/mzt9x5j0hU8b2x6aQu/Pb8l81zlm8sVMHOVq1zlKle5SpVLToi3gWX05+Xj9+dtlLML37+9gdtgsF1rD7zZK7Gm4O0DxKNjxQyY8boxaV1PNcgcflKFNVbUdclKBey9U9YZM7yHdtk9UkotA2psb0d8l6bwje1S+nszUNQo8l5r46b8ODt9DChf6j9Qt9y+z8b+GHq3unlyG+NuWNhYUhX+0fhwiDw/tk/NqX2/meyzpPt1tJ2P1Pfue3qqBS0496HyGKRxud/1uPdnBnhO9oExA3F8mB0zOqdo1/q2xAw97y1r8jETgIm9I6NhaO2x4doGCfs97Jh+Ly2PlHNq91Gje3y4nkWn7Uo4Maddz5wp6JzeAmbKto0bp8m+PJw5DoZ5bo6zwcFecs0oqeAXZ86ZMrLLmENXhmfQNqWUqiOns2oBSjVeaZ33wJNRRsM8VZaVUh38ZixrQNXGzkqU0Pp/dPxeyowx2TrFscF98vj9u/9U5s343I8von2jvCS5Nbw9AxCmQJiFkhPrsqoBngrnU6bkwuFGiEtpZGeiV2KV3EAlRYAonP7vn/ClOFzNepuyQ2IgSYfIPAeWMTl9ccuf/283uraSyPJQuSA+IvOCHD8sAP3Y3ddBM9q25iZu7dyGeUZX9a9C9C3KFGUpGVhyxtW9AOvJ8yf/y48pzlziiXDM/PF/OzPdOIJXymipAOARMBMrSGDUMUQMHFLLtEmf+yKC8z0TFDRr7OZ4g4iwLIF1XYhRndyjzvSc8+7D9qs6avtTW2Th8rVl49yivtO6RimASqDUzL8iSu/tAk4su9XXrMRxPa9roFg2W1a6ZxfQkgmJlGLVUcYyeANYV9SZGte4Wcv269n42bgOP2ZRNDYbW2e7nmjU9rZ39bGydVwp8FuXDo7aeZ52jGmyuy/Y/mMZgbqGb9dukz0Qe3Mt50DcxlFqOqe1YV3VGWmAGUqpLFq2vxbV4wSQrIxtUnCuVPa2xBpPxNO577Uouw1SKggtch8C4j3HdKv0/tNcAVFCIZCKv6Sxvbdspu63LG9r3dUV+/9P+eaz9n3u9H6z7Km2vbuVc2mD2P723HX2Ld4fq9/3Hfm768tvT/7zvzbxP/z3B/7H//mf88Vd4etXZ96sd/jJa2BWBEkelwSy7nMMFWi891racLNPQSvjARs9A0pl8ND1f1kWYtQA6+Fw4Hg8tiC3rfPn87ntN1aGSFnarKS0e1rHeGJQvm2wzLvIxYBnVdKfsr33wFPbA1NKeBe6fUJplzP7MKWVdfXVzlHgqHcOkRnvDozAcvOkaNBYoAQoR+BISp68ZkJIzAeYZmUNMFjHw5ff49/9/b+N4PjhH/054ebEsnYda/9s3508vVJYX+6PLln1A2WSMH25B3j13Ix3Pdi/9ceZ383TymK5zuIMQ+C7LjC5qJ3uPazLwhoLhWNrEzQrnFLt8lJEwe7NNu+MMcbENDwVxjLTrAlBjy8VKF6BcZ/+MPFf/3f3HH3BBwdMwIHMTMqOJcMSEyLwcp62uHVcBc+NfV4IbiLIgcJCqXrYPmBuiYKjv8T0Pu99K92mYIqpnbcsCtIwEIIBOmKMTFOoxywIqfkwpingg+MX/7LwF3/iYb7lk//yz5iP4N2E5FtigsKs+l1S5txE4v7hxOl0xlM06loK0xwoRZkscvKEMCtYRISUz+RY2bMrWCbgKF/e8vof3FTLXftJssORcQKnojaJPmbR+RRgnr0+l3OUXJQZ0WVwpc0nEYPQKXNFwXyaNbGGIRnU1eOkJ31JmyJ6lbHstfedSczWGRufnB8DZkKw8kydBURtibmWyzrw8PBAXBSwOc2ajONDqHuEME0B5z3n85k+4WoSUFJQQlrOrPOZ+XCkiK/2W7VZxRNCZVStNmyMsYFcvO+gF2U0m2qbu53snNrTxVP9Rx7BgBZaXupwnJjnifuHN9zfv9F1el2Zp4llWTifFWy1LGsDBFn/GuPlPM9IycRlafb6u+xFxshk5doVZPFYezHfrf1tx+5lvOeeUd4+m+cDDw8n1hjRSlu6hlifje9hrEAhW3M3djDy6J3Xf4nyZm17vI5VqHNR3/MUe4Kxge5U91BfZ86Z+/t7YlxZ16Wv1263L3zgfj/2UxnWdnvXLBYyTb4lHa7rCgIxR4z5vNS9WFlV6/nVhypFE5DzB7bxKo/lCpi5ylWucpWrXKXJGA6TFgQuCKV6CoTGy6gurwK5WHBEKGRSWljXRUNZg56Vzbio13Gb2qB6z65QlWaAbGpU0hVFUya3AIquJLXansUCAlbOyGq3tsaoweDGzKWCE6VOtmCqKp7CRy8/xXvHw8MDp4cHzUjPWY2PnFsNYV+pZzV45IagTKWyF0AcLz9+oYH8nFjOZ+4f7rXt5tQSy5wwpbLSRVJBEtRrMtLWliHIpQFfcVU5bXQCvY5uoQ1FO6e0fvS7MRq/rXcSGnVjrs+nmWC95jpVKU650+8WasZ/qeNdhySVCtJxUoOg2g95CEiK1EBuVipjqbV5S8maITcEH0sB8nZuiRvyfmRw4Q5ztgUGpf3Vn7qBFgzM0OdIzhdoruv83DMejSXD+nHU5xrHvo+BOVdbZngdHzOm3k+s8aMj0TIKDVDS+2l0Nipj8QiyUAePBRbVwFNyXSmxde7orNkDZC5Jfya9acGmaQeXmfOikJTeNiWcKxvng1FyWx+nNLapjomtb9V/qPeyMlVUOnUFrGlP+EaxXooFV0Vrd5uR66x8SZ8HZiSao9BWOVedOylGKBnvukFpQJvY+s1V5hfNUPPB6zOiQVQtGFNrI4sSSEsFiRj9KiJaM3sYS+2vTM5ro+KFzJqW/p6WOu/q+tppprWsjb5jbji27CIq/X1ra9WFd2b8fQ8suBQgN7noOBn9oZKqHzQ3l8i6ngnBaGBhnhyH+QYfAkWENcFyl1njLbmEBifIFM3ioq28KtHyCvU9jkXwokwZWTrv0SUZ3+JchLR2KEuhkAQyjrw58vJ1nnId2FIu439FSJLbs2ShOfv7eQPT0bN3/y6kBofqPqR6Sd33YMPgn1apTlcdr+wz0f87zbYrN7h0gydwc/tCnVBJMzOXZSVWB1YNa5GScF4TPjicr2MSc9vnp0NgutEgQZIMwTHdHvHHidv8kpIyp9MD63JWFo8cWZfz1uFWA0TYvm7U7e8jzenXPugfD2uc/a+MxxVpn1hGpZYNqDPAed2XceSUIEasJGNcu0NPL5AHAI2tHbC6E2s5E6O+j9M8tT28BcF0Ax/a6QhuatfSkU51OzBdNTddJYQZzZy3fdQNa6o6QjsoRjbOV9WtFCyobbP9T3WdVEtIOXE1i1L714caGFJv7KP3JFfdB0oNErla+mtcFfr+nq00JwqOUYfvqBcmcrayFPq5SHfyphSr4ztSCoSgjmvf9BFQSv8KgC76LjmZAFhj3Vf8bKs8iNS9xSFe58K6nLm/e0VJUTOxpdRM0BlKZE3CM5U13yqPZ/KHrUHvqyW97dxf/Tp4lW9X3mWG/DJGXXY/v8m99rn1T11Hhv/v2/FYh7j09/hzD4fZ70Bl99f+yuWJb3/V8uWre/7hv/gLztMEN4V5guO5cL+cSGchZ4fkaid41QyzMRSUVvhl0x8G4CipME+B4DxxXVhSUvtXPIgGhpzz3N6+rDq/8Pr1Hd4rM6KyGEYeHk7NNp3nA/M0t7/julYbsQbIku6zIqLgENP9pQP1cwOYjPr4NmbW7dJByvO6iuprlqyhtkHbz6ud2cCp4hAyGOOu1LI91c5wosyA1Jb6acJ7R4qRXCoDsPMK6mxZ97WUoxjLaK6gUmqwMRNC1jJC08taGqtZs5VRUnAUUvE8JM8aYfI1UJ5XTnevics9Uj7D0i9KdqSsttntLbgXmVQyy1qD62ZXSS3Z63r/12IzKCNJBf2/r1xKZmq+jJ78ZLyNIjVJImWkOIK4Qf8vlKx9HEksLhO86mvzPOF8xgfP4Tjx8uUL7u/fEOOq88sFtYmT2qqewOQDUwjqdzNAS0mUVFjzoj46HXYK4KYZCZ64eyax3jIfBrDmVwpeIbDkjHdHxGUg2shUN49qN8aSKA1cU/VhKQhBv/OBw+1N9UWh55RAZgIck4ALA4tfm+u1j3eslMV5BTD4wGGauK3+whi1jTGmGkjvfovDYQaklk+B29sjy7LWoLkjpbXqoYnDYUZkZo0Lh4OWwnn9+jX3pzumubJs4gn+hnm65fblkWn+BAmFdYnkJeBc4Hj7A44vA55AWjP54VTBSbrWLec7Xv3iFSlFvFdbPRYFuedccMFTvPpjIpF5OgKFICCrq0XraO+aLw5ZbU6abVptLgqrZBwJV3Tt8mTclJgOmfkgTEFIaSXGM8Z0HJyWYsbpOJeslqHq0GZzSAXEqdXncm2RCxVIoOtyTsqec7g5IAVyVB+UOM+yrMwh1DEv/H/svUuTJElyJvapmbl7RGZWVVfPewfgQLALAbmEUGR54QqXB4pQhLzwD/PA+x6Iw4pAKEOBYLADbPdgGjNdz4wIdzcz5UFVzcw9PDKzqqune7ChM9WZGeEPc3N7qH76qSqnGWDC0ANSEriHd5IJhzljOh2WxIKc0XsC8Q5xOuKr33yBxD2ef/ZzPH/+Arv9DYLvhDDjFQf2Hl03YppnzPOMOSZwHHVNFvvHM2FOgm/2/YCeCMF5gDP6rsM8Rzjn0Q03yH0WAg4DnDIyExwFfPbiJU7HoxDn4JDmiGHYI80MThJM6p0QeEII8CEADMwxwocOKQPv3p/w9u0BIRCCd8hxRpodgvcYgkcKDtNs41nKG3sQpuMJx/f3kpUkcyGEAhVfazOjWXYmw7yNtDfOEzgDwzCoX0EJq3odw+GJxO7iFGWNcZKxJ3MWEqzOYXI1KJDIoe8C7u4GjOMka4Zz8F1AN3QY5xFsAXzeIaWMw/EEP83I7OFDp/eiQpYBCgJbIDTvGA6S9d6y3oppmeF8UL8Hg8jj9nZY2LBio8eyXjhdX03HCDZ2mbDf3eI0jpoVTG1NBpiboBaC3M/2Gt3PrN9tpayaHoNI7GDTZQDL8MuyCujeLsE2lTTkXCiBIGWPdIBTDO8qn0auhJmrXOUqV7nKVRayBEYA1ZUUqmcDx50atEwg9pKOPThxlmh6zZQmcIGHuCh5wFL5O2uBEQcUOKl8i2pEtGVD1gSBlnggCl0FAwv5pq1vaZiMtUd1LyllkEsDRLEkTNMI77UmsCrA1oLcRI9Z1FhxepSIadbIj1DIHOMkjO5pmpASqzG2TMEo10cFoszoZvvHTekfQ7QaR7N6qC71e9sd9ov46i6fUaO6NOICNR2kd6GkT7YLEBwSR7jmnZb7UVXguR2HVN+9gXdGtrLzaySQOZAaBVrTgIIb6lUBMFZjp71W+bs+gDj98+qM+nNdN3UdHbU1Vpf9WC/HhrA2z28X2ipVRNYfjTH0cLaCRqyJvH6nrCSQrTbXuvH2nBL5tE7fzQJAFIgNxeBZNOERskN1DrZtMaOxOggtQ4A4/5Z9XMosafsz1/fd9lW5R5lQTX8ToYQa2rUbkJ8haaOz5acmyyyjWTqYqwGrUY85K+2BlQjIloK0RrkVBy5JxI60x+s/MVSFuLSsUbzuW2lj0uew53I6/2oda+c0hUoD89frVNBBBqhd2aGNlrV3zav3VvoZddw2F7k4Ztfjoh3rl+Q8UlWIcsRQwNTGgDnQLQW3g/OSGcRrDXECY5xnONrj9idH3Hwe4YiRkUAeSHnG+9/f4P7V3boVABiZCEn/evkTxsufOoB2AAXENCHxCEaEo4T74ysAE05ff4bT7z+r3dzsZwYMr2gOi2dt+3VTVoewEn8KqaRZjR+50ncgLYAkvzFQSDKGo7f5vYREI881R8av/4YQ+gzCDM4E5zv8/C936LqA7BneeTgKmMgjxVlTwkt+H5ecZOnwegcWUoZ3AT4M8GGAEcXIO3jH8IIeFQKncw4uTogzkHMEx6RbdyWWlAX6o95C1UHO9LvyMdfr25pW5qjNDR13miHGFI+iWuQMcCo6hl3SUUMotXOa50lxKuC3AF5e1j8tX9X3vc5zczkR0EQI23ov5bL0DatewFkjB5kgTscK2rV7HIBCNhEdTq4Zgte040qwdSSOMz3HsUPXd2dps00vKcRI/b3t+qrnoIwRAMXxZy/I5rdFaEpUpKz7clp9Fon+lHt67wroaft0CL4Qg7wPmk3K9j+LjnSlLa1ObHuPEULt/bH2Das+lTkjxRnTdELXSQQqfC5vGOzxMFXwj1O2dqDv33r5dHmC1gjgj/sZt+Spz708+lIvPHW9fspdH7vXU693/h2d/b4+ZkMf/4A70MbnlzSWh+/63cj/8h/2uHuW8P404tdfHfD2lDDlhMRCmudCAqyO9ky1vA8VmySXAIy6HeheCttPhUgpDlzV0ZUoa1kIzNlnGcRMN6/Z0yQgqQty/DiOoLLWK+2SHOBRCD5oMq8ZdFCyLDTZNiu20ujjvD3OH9LLc6F6N7a1nlNs2aL9NBooaxhXY1NLAJYvNpDZWyknxBTBnOGpIfqW69X9L2f5l5I48IrmSwTXdfiTv2KkcdIMe9BMDD1iTOjuGFNySBlwKSEQRBdiIQ97JiQYvaVodHj7xUv47hmiiwgv32KeTc9ps5tKb8HGAhOEMGN9+6n20kaLVj1KbHktx4KgVAXJ1WK6HymulWJGmgmpCzo2CI6A8Z7w5u8dDodnSDdHdDcJlbAstpiDF53ZCWGskLlZriO2suh3XjPfSSmhDuwIaTH25N0KrceC1oCURyQ+wbsI5k7jOxiSfaMV1/StzKUaDKK6I3n5XEvrLq9Qs806AtbJGepIt8OrfSWWdsVZLQOE6XUpHSULY5bsR8MwFNwiBI8YJdshESTTiHN49+4NfPDoug6GW4TgEOOE0+mEmGaQI8xxknI8kNKqLnh0w4D9vse7v4uYxwN2f37A7naH/e0L9H0PB0KiiJwdpnhCnCPmOOJ0OmAaD5ql0EEyXTFiZrGv4ZGRJINO8CDPcL9/CRo7YO4l8w6wegtmxbnFLM5gRORSlslxgidCdhEuSCYiIiDHKPab7+BDB7IAF84w7TRzrrZNWY806EcJcwXjKNgLGoKArnmOzAwBAA3U0rWKMmIc4b2M5RgjQAFZAzIYQlaQbDNeMn0gI8cZp2nE29dfw3U77G9eYrd/jq4XgoEkmbSSSA7e9+jirBmFJsRpgpS1Vew9s9iapX0kc9ATOEUlhghJU4Kw1A4hIRt1nQRZWdYPR0DwHfpuB1aUg5kxTiPAM3yQTDggkuAIK1kliW+AmLHvPbrOwZFkVcICNBIAACAASURBVBOyfQDnDB86DMNQ7K8UU82WiTY4cr1PrewyruWyyBF8TsjEGpyJstS61oeg+yvsn31OBMoAHBfbUo43fE3M/HlOOB5PSFlIVORIS2cBKVuWKNnnMzNyzKVEtN3r0l5KOuEJwKImnpqUMjZruULDBS2zjV3fyhCusxzVe8u/OEcd11wGOBX7VQJdjSgjG7S1RfczrmX3su7Ndl7NYi0EVsHoLbtQWGTZKnMT9Z3YokFUV/CrfHO5EmaucpWrXOUqV3miqDtDfpKD81Jl1mVlj3uClegAMsZRDLtvAnu1Tv/q2FiWMGiP3Y5oqk6iLad86/CXz5szVekzP0vOjHG8Rwi+OY6KU8IcJ5Z2s5APiCR9YNN2U0rvDwfM86yKP0q0mN2/za5BjTLIpY0t0LEkC31oNHoFwJYKbvGPPHCOKdjyflBALV4Rvc0p1ZZtWjr31+kxm0izck9tZPO3kY+kn3S0NuCeGYXWhw9DvpekGtJrWWfBaD+7NAXWY69+sXHnDUNwcY+NY9b32RwPzbutmU+adw8ubWznXY3AX86jddkfMY7aTvgEpoyNydWclXbWg4wAtDT6mufMMs4lTXRNn7t8YUb6cs1zWVREPbZ9/0aWIUfFOFzcV/9XKhk3QHmMUcFdrc1d5oYY0+K4lciTmlZVrm/prttnbudOS26TNgPFoiXN0kTmiCZ4H5BzrIBKqcktqIKB9ZaRoDgMNtbn0psbhv/WWrU5L5rvPuT6i+/VwC6gLAAhRq6OIhRgxSlhBmC42CF4wt1PIpwb4VwEU8QwBKQ0IbPHeyXMtLcAFJTT35//mPFnf+UA7JEREBMwZyGZkov46ne/ReYDOBFOv/+snEdNVKLTHTmjkmaa3aL81gKMdszWCqguGsGNGrJM62JYQ9PfldDqp0lJ2Q0CiBcBtQzFvvW54kz48pc3zXPMGPYRP/s3VmLBwSsw6hxhnkizwUgqfgM1LcMTXIZjhvcdvNvBuT2MJOc4NbGRGXACAgYlxuWc4L1DjMternud7WufotceOKJdM8ga0LRJ1wwD2diAM+aa4MU146/sC+2eXImOzAyn0X8AF71o6RBE0wZRKkyPsOt6i4Ru9DIoWSdGTUlOQnBuy3Pa2rskTHLdu3SmMJbrje1/61JJ7ffrfr20D9c9s12Taz9blLO0qZIaW8KxpYC3zItGymZmTNNUPmufL8WsWW6sL0yXOo/OM4CY7d03n1cqcu3TlCLmeUKOERwimAKkxJNHS6D9UFlqgh8nfygwdb1e/rHIFWyuUsb0o0etj6AHvts67kNa9Omut9YDbMVrV/3qLvtwocVvfOGv77f81X8PfP7jGf/f35/w6y8y7scZMUsW3Tkm5AR1zNbMGIUwr8pa26uNRo6l/SBke1ufs+39LLq/Rciv9x5Zb9PCKeZ9EKemrv+ts8yu770vpVqthEExWVe24EUxrGB13GM29se6tIop2WwEzBJM46gS9qUfLWhBz3UknIEFDrDVXitnRUgJcD3hZ39JmpVTMn8GH9B3HcZjwvGQMY7yviTTQYbz+r68g4OUZRVyhNzDgfD2i5dwIPQv32P3o9fgWcoTidolZBJxPtto4TOd9tuQ1t63MeV9AMeoflB532VNUNtVsqrWMpDOE6YD4Te/ZAB77H7h0d9KVtXMpg8KAdjr+HSOAM2k3GIMNROelMZ13sG5ACHwtMXeSk+BKavC7+R3ZLHd3RrQalc8oJZrsu/WY7XqhE+X9hrnZ6plXm01ZqScEYoTWUttanBNCAG73Q5v3ryBkems31tdM+cMx1Z6JivJQAL0xmkCOQkKiSnCkWSQCaFTcl4H7wPilx7w73HzFwc8fz5g2O0gxZIACg5dH3EaBcc8nY4Yp5NipLaGZEhFIp2f7MGqqEtJH4J78xnw5lnzJhq8pnk76zel1hSiOt0dhKAWeQaQSlAMp4QUE3JX11dZb2VtrT3fvOFGr7dgIke15JLTjJLOowQYGNYLkmlS7BcihCDZ2CWjh76PeQZYZrmVPepCX/R3R4B3DvM04s3r1xhPJ7y4eYF+2GuWpmYdI8maw4xCfPBaVmkEkEoWFtPl5f3Ms5Ty6kKH4D1ykiw7BCj+k3Re69rl5VlOpxOg+BkIMga9EBiZGTHOiPOEzIDPAT4LUSZpaShrsmRVnkHkJGMSM+Y5akZXuW7XdeiCBJhZAICU7TE8itHuWe3aZe9gnuWetm92mrHGsPd2T12S5s5ncPnsQTyLkGLE+/cjTqeTZJ7tAog8pkmyutRs3LrGlj33I/bHBotd48Jtud7Wxm77pz3+HAuWsr7Wh0QywGVMULNWV12muSJaPLYtAWXzQK5ZsU4hnsl6kfV+lhmufZ6tZ8Xq7lf5ZnIlzFzlKle5ylWu8qisgC4iTZ0nip/LHl3wEk2ADIkoCJhmWgS/LJWaCsxcvGvjdF87nLevuWGEMgNcnZ+maNm5a7JJve6506B+XcuzVJClGqpCHvI1Cw2LQTEMA06nU6lNejwepdxDjCBHCKFD30s933EcS53hoEaC6KfqLG0M4ppamIry2zqBqlL5sAq+6ItW3VQlGLRtHKylvT/AWkpg+T7NgWbvZfkuzh2G9vxrUAtojYO2ba45vv4txy+zYHyYbMO8WwSVrWPWY/Qhkk1LtHjoumuS1Np5tzZ6Ni5QEqlcat95G9s6wDWC43EyD30aj9cD0hJ4zp2WKDe38dmOJ5tj58QjQn2UGi20PLaO43X2q63+r9euYHM7h6FjvpOCx0jJSWwfEVAyzLgyTs7b3D7LpTkj9y9rhDq6rZlUSDRthhm2HinzyNbA9sWu+/HSnGh/X5Nk2jWs/eySbPXB+U0rGFfaWIietS3et0CCkvyY4NDBeXH6Zp6RLKVuP2Dod+jCvrbncisEgHMSYXU6HQGaC0EFTEjRI2VITXhpbXFLS5AlFQLI1qrUQj4CFa/AQFhq+QpKGvBsZJlKCWO0b/7j3d2fTqj0hogBp1i3jpbHLH877zlmYDyMyCmg7zuEvgORL+PBxxkxAiBJdwwEEALADuzlWpKC+gbBDQpKApkjKDOYMggJyBMQBBxkZI00M+Jebva0tn2ES0P78rx4fLFdz7H1erI1/87mN6gkX5M5sXR4VBKKzStzWglQWPUGaIbCXP7ZPexpCNCU2NpPWvZSHH+2xjl1tEhmwHbsbvVd13Vlz2hryjc16Yq+1QJ2rZxHwNHZZ21d+vUezQpA1jWbC0B/vp9IJiIGF9DZnJ+mN1p2nrZ8qT1XjFEnzPl6u27X4rONtrfn2/1M7z2NJwS/h3edRMHCod8xdjcJKQHz2GbU+XD52HVouXpcvuo3Xecev8P3Q75FleyPUM5Hx7p/NqyAR6/36eRp19s6qt356r9mzTJjgETfAdneL/996rhd33vbcrrcvu/T/PjtV1/j/fQGX/3uiMOo+hRbWdNc7IqyDzb2LwAzXh+8h9vYC+o5NTLeiKQA1GFYzzEHmDm7nXOaYWDGbrcrmIQRURd2Wsmcem432jHrz4pc+Hxpg5+d8qhs2/a1P0ogO5SgSgDgyznSP52Ql7jZtwoWYNjCUq9iZiB7IcCw7MFu6OF8gKce0MyfcVIS9UxS7pOr/hAAUFCMBii6NivbxXEt7+QI8CGBMQEIkCxsal/ZOCoPq+Un8c2C0R6TagPSQo+pDlFAbCgtwQ157hitvIcHUYD3QLcXMoLvqOhlcgOxOEjLEouODck+krlkYhXcQN5p1u5w3sNRh26IGG51fVHieYqEHL3YPARovWEh5RDgvGsIYjq++IJOwO3f32Z/L3XkFmNIWTJqzPMMzlntTyEdvXv3DvMccXd3h5vbGwAyF6ZZSl/tb27QdRLskVLCNM148/YN+i5UOzg7eNfDhwHB9ej7Hfp+J+WxnEMApFxWLxilI18J8IoDyToTMc9CILTMi6ILmg6vGVmYwCzvugtBshbSeicSsaxGJaPkVt8BkNwpjBEZRBF56uBOe7g5AvQGSKmUZAMMp4RkVM2MzJYnSMihVuLddkjnJIuV2S9GRnHOq8UpWaRABOcdmKSstuEz3gHBdejzDXKOOPE7GOlDiBMtkafNICY6/fF4xNu3b0EMDP2ALnRF126JkPbTSCAACnkyhGpjgWUPy8myQ88YpxO6PoDIoQtBbJycJZ+V03Gnb2WeR6Q4ox8GyUoDLiXAkBMs20nfS/kywbcHkHNS7skT5jgixYjgCc4HOEfoQih7VIwRKYptBpA+ExV8Rp7VggfagM2lzXlJvPe4ubnB8XjEOI4LW4dwTiLZtsnreniOd3F5FzlLmbqukzLNMUYlyFigrVsQWbCBpz4ma2j1HKNc2vXrgDsAWra3JSTVsVjXd7Wvc16c+xA2py2C4AIJFR8472eZC1U3JTTvZdUn7dhf3P8pCsZVniRXwsxVrnKVq1zlKk8Qalj15CS9Z9/18L5DgBelj4WFnlJETNNCgTXli/lxpaplO2+B8a0ivM5msXZWnD8HLRSs9THF4IAoay25xn5a1Ja11QCq0+FYnASm+FrGByPQlPTIeh3nHLpdTavKzEVxb8GwRR/oz9Zh0xIDLinZj0V0rd9L/XsJpK2v3RJe6nNAleJ6d/s+qCHW9m3JSqMO+/Z9LkGEpWFS3+W20r4G/JbX/XAQW9px2cHT3q91rJEX47utqdtGA52Dk7UGa+2fczLAesy3/Xqp/WefWX1cWj7DOYDTElAqWWud4WQret/OIYKkzv7EYuSr9r6XjMy2z3LTvnNSy3qdMtBa/lqCFNvrTzuGeeNeWYFDIiq1kp3ry9pDi3egkTskDmL5vD5vGWvNHFmsC9ZG50DEaIeJgHOaSLoJX8wJcC7ABck0k+IkUR5a3iQnA0B1PKgD3OooLwCIzXG+WqMag760YSNTg8lDZacuCSnIJ3MlFaDKecLt7a0edQ6IOE3DLUCNRDVxAqY5Ic4Z43HCbr/DPD2tdvI4Tnj3dgKQ8Jvf/jPmeETiCUQZXddhf/MSIwPgrqy8tFrFHSq5iTfW92Y0aoRl/bz9136eFpll6n5Y5bsFIlpYddshyIufl65hR9vfdvQ0Mv7T/z2BMOPP/mrGf/Nvd2DewTmPYRfQY0BMA0LsISUpO1AOFWBT31jXCRBs7chGCAEDHMHJ5os4Q3KOOBxsrtfyO+JcsD19e5w/DAxuOZyW5z4k5vhr164WrCrrTWYpz8O1ZGA7P533xbHWrlfIhOPxuCD9thH04zgu7iXlGDMoR8QoOicoIwSbl6msyXV/kj408hKAQmy2ZxJQVggtRmpOKSGzkGbWUYq2pq3JKGudZf1uWv2s7ENFF6pAfuk3jcCu2WEaZ1YwMo0HSNYzi0wFgINmL5znGfv9frE/M0u5MdvLuXlvbTsXv1OdKevxYKB/C7bmnDFNE07HCc+fvcDd3Q4+EP78fzjiT//b9/j6nxz+9q9/sD3wVrI917+JPKQRNxl0mjt9ypXvD+OGe5p8uCb8L1ku7y3nR333724tT213u4daCYzFcUrINSd/PZpXc0Nkqx8+NovI901+/eXvcHc64PU94c0hoxt6pFPEfDohRsbQ72UNZqoYB2tZHWoJ9g/0R6O3i2N7Qr8bQOSFNLpydlVMZan3288UI07zCSkl7Pf7EojT7nX11mJfMGppwloGOi9+tnahOBbVSXxBL7mkXwjR+2Ebrd6ntacqS0Z0Kdn3um5A13dK1GjKjIQASgnzNJd+4szItHT2Na8AOTMciaM3J8lSMoWA0HWAOuaJGa9fv8X9u6M6nR0yJ3GW672dF1DDgeBBolfrGChkGQDeZ/S7Cf44Yp48JIOelschAE493ABAWYg1yqH5YNk6qSEZW/8brrXOWmprgHxmeINcM8aIw+EI5wjjOEq2jF2PP/ufE+Y4I/NOMjSmDM4JOROAjOCFTOuDA3lGzJOMeQYAD0cOOTt1Ivuiz3nn8NM/n/DDP03wzmOO7/Dm7W/xz7+6wdsvflCCAECA7z36nUeeR+yGZzgeR7FvvRnRbqtLCsGpdN9HdPlj0mJCprvFecZxGhGnCbM6sUVHCyDnETPwD//4BT7//HMQEU6nEw7HEUSM0En2IyJgGk/SjUQ4TRNO04Sb2zsAkjEi+E7Xr4Cu3yH4DrvdHvvdTnRqTgjs4HLGPB7x7u0bvHi2w9DvAWZM4xHTNGOaIjgDwfdgJsxT1N4KiitAsUuClYxzLsN5hxcvbnHoAlSzbgqSaf+AkRYFzdbvgpWwIpl/RwZ2f/c/4ZYYzv8DaPi/9AQq6+g8TwAEzw7BA6QEEZZ8rU5JVFCbgbOUeKu47jLTY2IGvK3hGTklJM3KMnS9ELXe7tF/8RdgMH734j9iuj2h7wa1YxhEHvOcME3vkVLCMAw4Ho9SlokIfdfjRz/9Gbp+wBwjnK5nfd8v1ut19hAiwLseRI3tlTLmGDEbvkuMlGbc379HjLFkGer6Djf7Hn2nZBlixJhwPBzAmTGdIpwXglwIkqlojoL/d52MpWmakNKIaUpwPiDljDTKHHeecffsFn3n8Gzfg3PC119/jXfv3mEYBiHZNHubU/+DZGZJZf1pSWZG8AhKvhFyigSt2nVAkrnmxYsXyDljnmd9B4rbsq0/rb3mEDSbjq2Ja+z9HLt32Hcefd+XuW02I4DiT2jxcOc8UMbXU4goIoYhlmfEcg/OOeN0OoGZsd/vS0m3aZpwf38P7z12ux1CCOU4ooolOufQ9z28I+n7VDPztNjdJTxCMqDKXua9Rz/cwnuHaRrV5p51LmTVpzLIAd3QA7r+Lftp6St6aj9d5cPkSpi5ylWucpWrXOUJIkC+psRTQgi1CmrihiwTS1TwlgLDaoQ8xcF55mDeIAS0EQNrJ4RzrhhV7bW2yBfr++bMpa0giRqwesIpWQQMkGKGc8K8LmBkQyCwe5kzgZmLs8YUaosiZjDY6flsz1tJMjVgzUH8T0sSxXm2lm0n9FP6vP5+7jzeOqd1uhgA135nYEubShElssdVYHFhoNAq4poW9xSnmHwuTW3BtPpfSaVqRnt1Mn+48MVzH+5nRpuxaEkuOp8LLclg69prItfiThcICWtCR/m+OGHPU5puXbM5uxiRS6Py/NnNyScG98alvqG0hl1pXeN8bY+T2uxW9qvNzqNtpOqQXD639cvSWJN7uzIOgRr52bZl3a/1XcgN63hlkHNnAHQZL0RITeQdUb1WO66W95CMNawvQp7BwTkufWdAqPyrBCku9cQdrGzVgiQESzHvGofAeUTIJbLMpfVqa/y1x1bn+YacOSaavqY6Ttv36Pya1FO/K+CIRtkYUJNSxjwl3N8fBPiA1/Ivj8vpNOLV6xMIJ5xOR6Q8gyH1uFMiON8jcwdiLxFeLKA7gRaYd24edcuBJU/CWgOeCxmUUCNe7TPHBK9/5KaAUHu99X2+DXno+pecdPZsT1naZYTXvaYl1zADcZJPU0xgTrof13rZzgOdgo+eOhA7fScWwcwgF+VwA8N9vb5segESKezBHDD7oPqBlXEz0gnVtRPVqdO2V8bnuke2emzj22YPuqw31P1hCV7WNdB0Qyh1i7nqawwBaOsz1IxvrPt/Scnva1pxcYihrIfONWXjmEDOSy14JJAXwJA5lBKXngFvGVqcg3cVhLR2m15mRJg2QpGIELQkm5VyOl9ba1+0et1WBho7dr0Pm1PK1iVL092+0WVN+bpnm35qe5D3oqcLUSaCyKPrCM6Fsu/lrKWRsARkL7W37a+t4dQCmTYmTNdNMel6zJjnASFIND1pnz5FmtX7bB1ibI/wh2aCEQ8vzYzza37Iire+M134fHmv7wrqpc3fH3re5bj8lyIfu6d9l+9uLU99Bmr/Ff3ugaJLiwlhGl/dP+2azS66OUq+L/30oTIlwswB7D3gZ0zThGkcVddr1lDeyPRotpX88eB9UsrIKS5tQtPpNzLJyjmVsAnUTGMEKmUtTEyvXa/zda+qevc6A02rGy91+2pTbMllmOfpM25rzxR1p+5bkg3OcCohC1gpkdxcZ33d2u52R1CDVbXEnBjjNIPZS+lxADllHA4nTHOUkktOs1BqeRYGAeRKRgFDolqNysQR0HWMbmDEWfpSghKcbvEOQEJV/M/xkE8hSyxiO3DJ+qyQC1a2bc61/Jc4WAP6IeDt7141Op8QHMgRCF5tL3kuzqn+U2yMzfbOAHnRFyWYQ/q36x2C7zBNjDkf0A/nLr6cZ8T5Hnl+h5l6EAbRB+GKfiKWko55wwAWGyRv2JafRtb28DzPGE8jYqxEL9MTrQ+tnIz1vZXEkdKuUhpMMoB4HA4HMAPDsAMzazkdAuAAchiGG/TdDl3XYxh6dF2A8xkpRwT04DhjnI7o+72O9SQ7BjNinMq1iDwcZSROdQ9g0xHNOpAM5f0A9H1A5mU+06XO1M4bXnzaWCtl90oAQBk+O2QmzPBSdpQlI5VrdGzAPoPi2RqkkJp8rEagkNuAnBdjzpGWYar4EWxuqJ7c9x2ADOfkHo4cOIohOI0RfMMIXQ/QDMeil4/jiHE8Acw4HrWMTz9gv9tjv98LMZ0JnDMyapBaO1eJaFF+tew/bDq6Es+c/J5SxjTNGMcTvLdSrlnGEnucTgccDifc3d3Be4d5HnEaj+i7XuemZQO1DD6s2FJCnEdM4wkxRfiug/cdYpxxGmeACF3osdsN2A89xtMR83xSwk4oGdFkz6trk9hrcTE3hChJxaazZ7+IV6eMcRzx9u3bElhg+J/h74aNCd7utfTUck2U7DHntt6ZfUhATrpGmq6gFeMMHy24mq697eb5FAxfbNtzW65tb9s2yxjz9u1bABJEYsEiOecFsdb0Dgn8deBMiJxRiXwXMr00YtclImTOyHNGjKR9n8sxKSV4T/AubBJx7T4PBdM9xb90lafJlTBzlatc5SpXucqTpQI1jlrzXxRmAyc4SwGIteL2FOLGGTi/On99bHuMEWTWx/smI0j73fr88/svlS9LmUhG8igOHKp1bdVQEYODF9E5KSWM47gg0EzTBN8NRS8WBrsZxNLnlvFBQIbt/lsDW+0zfVO55JAo368Uc6tD3RKOKuEFC+NOzof2rV0lw8CgagCYkx/lnPI317wLiycuxABSIM2VB2Lmj8I9LhkDW4DeU2XLUdner73vGrjaOmc9rh8aB/W77ePXv6//bsky9XMDW6sRaGDYt+5pL+1aggft57U2uo6y4vht5x2fXVNST8uY8r6S86pRvg0uX1pj6jszMKMSVwia/UaBnkLcWNVer47T2s5WCoiuRJecJfLJfMZnhBBmuEI7kGey7D1EktrXQApzXoOoRCOX58ksONwnXovWsi6bV1qweT9qfjZrt/30VJzmVn6nZomK4JTAWTJlcGbUokVGmPKIc4Ib7vHZzzNubm/AHJHiETGOkr4/RwULAnKIePM6wbkBSTPd5JzAyAjZI80EFwbcfD7Cza8xffmDEpVKChdmMBJLCSV5surCamCyBlrfjum1kk+uXIPLz62e/DYdX7T6Wf+65HyrIOpT2kUbv/PG9eULBkHrbGdNYc0AyMH5DuAMT5JVBQpMkrOeF6JImdOOyl5FDBB55OzVCePhXQt8ukKUgb4Lvcr581BD7P0DLLBb4Kw4C3NZKyrYTGVtLOte8x9iRtK1pCWNgKyGvUQGWlC57flCXsslQxgDcBlgr/qHz6CcBQQv6dMlM5bpcfYsBsq20joNZfFzBRxt13QiKmWP1vuNEWfaf1t7kl2ndVAKmbN0ISQDUY0YLRnf2MjHlahshBojW3edODFk78uN01Uz/uTLe/9mtscLes6aTNSW/mCIU+XNa3EePHu2xzB4uMD4yZ+/hXeADxmMiOM7j99/8bKOFesH0OKzhzJI2XGXdgHauN65fOwqd+mKlz6vhMVvc119rDWP94e17w/d0u+/tHvud92GDzqHl3OhlcWz0PLXrWx27WF1x2rdnBeu/T2VX/zJgP/1P9zhr//fX6Hfz5izR4bHnEYcjkfM0wSgKe2xIObbMkl1P3zCQ6eUkDQavu973XuA4AKocYy22UvXEde2D8RY19+bmxuNoBdNbx0wVAieqEEvbaa31sHWZk2T36VsR7tn1fasbZ0ql0yCh+zo5XdV37H+t3fQlrYwB6CdL87QLT1q/YHoxACQOeN0ishJy115wjzNGEfN9GJZJ0WxA7lKKXM+NHp7RcaqTg6QA3wHdJ3HiQwP8chZSxDZsdz+0jT0E8oaU7M+a7PLtlq69HUdi4Z7AWJ3ei+lTU+nE/q+g3O+6KuOhNwhup9mN8pKdGIrdabvIIueQ7CypQlS1keyfTjq0He3eHb3OV7tajkaswtefXmDOHt4F/Czv3iD/e0zEHYlcw0KcUZ/P+8ZfFs69tqGl2AMIby0dqoda/Pz5uamECMMczS8xXtCSliV5vFIKRY7N4QOwzBgGCRjTNftJKtIFxA6Bigjc4SjHjnNmOcDUr4BOSlhxL8h8Jc9fLxFev41EBjeB9H/Mte1gY0AD0iW1g53tzd49rxH5wjvf+UR96+x/8v3GPqAw/097u8PONwLEWeXX2J/+NPFmwCqJiJ2at1xMhj5J/+I1L3D4fQ75AMDiqUAEPI8acZz0rGFmuXRbAojThCRYiYChDCsJF8txwciseEUK3LeYb8fkJIEUjpHoLsJh5/+ZxwO9xjpDTrUDJHeO8WJTW8PJTNK13XwIYhVuRqCRkIwgomNpZb4QGAI1yMV+0cy5QaEkHE6jfBestykJEE7M0/ILIQp5iTBQfOIeWbEOGO3H4S8E1OZp3OcZE4beSJHTGPCqFmOfAiQck6z2M4+wHshuwzDgHk8lICjoOXAorCs9FmEVNT3fbGTiTSTmBJaWjtknufF3Ikx6rsU/4WVKzwejxXPsvde7Oq6RkkmIg8rs9WueVuElDpgFUszwhI5TWhFlUST/v9Y7AAAIABJREFU7VzF+T5inbGxuLZR6/cVr7SgEstA2gYXtnbgsoRZk4mUgJzcYm+1LKOX29f6BxKOp0PJCNe+IytFJra8X9x3C1tdP1vTGVf5BHIlzFzlKle5ylWuorINQFNRwgyIL2BLMSw0ioftZxTH30phqw6D5p6NI6E1CO279qcZ7i0pprRywwkBoDhu2+Pan+3nW4xs6wNzI5I6kGt/1LrOEr1cz10rqvZ8IYTqUMjq2Fk4TM5TL2/1x1YqyPVzLh9y46OVod5+VpRPXn7fyvqcdVQasI482wZ6iKoTuET4rN6VkRXaMVPbsXT4nBkL5s9sv1Mj9yE5G1P8gNtjo11rMsZD5y1L/Gy3ZWtste1ct3nLsDgjbmDZd60TdJ2O+6H2nX9HZ91r68a6re3P1vis1zNohBfvwq5FG9e8aLyifVfnwNil5xMwI2kE4+VSQPYut66zfF6qoIw+ivQ9l9rtzNUpTKRlm3hJAGwNyXWZtvqdtVfnI/PZuxGgQZ0dVNc4/Vbv144rbfWWH3W1xre/b/XXlqzXtPV3FudcnDS8/H69vlgbDcjPmRZ/g1AcDAaQmDPdMorVutZJAVvpM6kPLoZ9d3PCzYuEzz5zSHnCPL3FNL8XsEnBs8w9cuwwjkGC1YLU784s75coAOwB7tA/P8JHAr78MXwDvDOApKQdnRmN67XCu3W1e8hjwwo0Epar1YNx559ctldJmx+0eD6R6pB7ShvrqGjdw834PDtDgFQiRiLJtmRNkBJd5oCRskCiH+kc1NJATFauwDW3q9Fa4AD2WQgMqDpOHbMtgXSrlbTx2cdJO+e2dKw16aPdizJDAHJZ1KStRJp1Rs+XC5e3mDeub/eVeZfVwbJ04kgv6H5J8h/JxMeaoc8hhK6Ac6XsoBKeW6dge//t/tC5tqGTWYpqW2vbLIJtac5WWrLO2V68oZ9avwStJy8fyj+COTF9AZjt2oXgfaYvUAEjc0xnetNaJ1z8XVuwkC0do3XExjhjnkZMkzgYc8oYhg7eAy9+CnQd4fYO8F3Cq3/q8fsvlvfZJIp94Mq0XNPWn50fu0WiWx/PFz7fkkstrXrvH07W7X0KWca+5+a3P2Sb/xjk063EH37fTyntM6xLkqzvt37moo9tXOuPSX78o4D/43+7wev4Hr99k3FKHeYEpMylhIZkRZP9LTMv1hhAdWLZ9ErHFBKC6WksBG1zkrelnM0+cF4cRzHGhW2xVX6XWYid8yTkzr7vxRlZSglWu9SuY7+nvMxWs77u2k5LKcl+rs7x8vTFpnHq/Du3j7ds5fb39b603CvFdi9jjFl0jbKni+P3dDohRnluC2qqtoH9fmmEZhn7FgyWZqTImCYPR1IyJ6UZ3nVqLzGqDm7lIaWUq4cDN/ZKbihnNhKIJAuFfljsKWq0VsHcVrbWtyCtnd7u48VW0ow6ouuog5S3xmN5OoTQlbZLluaMzAmSP1MfkTX7ArCYIwuNv+A40g4iKXiVE0AuYDfcogsnQAv8SNMYb766wduvbtDvMl78q98gdDOAG+TcI/gOPvSQ9+bR4lAL+USL2UO2rTybjqKGAFHuTyiBe72WVHFK6J6jZGpg1DkdY1zgDDFlzHOC1xI6fT9gt9tj6Hbou73OoQwgIucRp/ENOPUgJIBGABMADfz45wD8MqDrbsF/yaBQMUDvxD6e01zGRfAe3g/oh1vcPbvF8+c7BHZ49UVA+pN/QveLGbubHsffv0J89QaHcARnD4p/gv3hTxeWmsy4tnxT/W8GYf7sC4w3X+Lw6oD8Zl7MTjDKukTkNMuHWZFLO5N0cK6xUMtQI5lPAMNzJNDBMloLMcA7Gf/wI149+ye8Sa+QOaOnZ0hZCfIkeFTXDfChQ98HIeTYYkDAHLMEa2lGpnZdXBPqjQxhuE4XCN6zZkpfkitlTnol6ck8lzJbo2QPcowu9DidDjAS136/lzlcAjqz2na5zFEhLErggxH0LRN9CAGdlimScoDZNidY9uOCn+raIuvNEme252vtH5tj0zQtSBbt/KrvMZ3Ztc45JewxSmZ96y9X+74lzNg9zzH7miGd0AaZVIx1bT99E1ljvls+BKASrUzfWI8hO8/mrtm20zRBiIu171oirf1tBL72fRjuQQSkHDWTTA2WEbJYi3eQHpsXa+9Wfz3q/7jKR8uVMHOVq1zlKle5ioo5Q5fOGvmPKYnViFCYlxkxCXCQ4ow5TohxKtFKNUranC3GbK/KaquwtbIG7teAzXmd1m0lKXOGg1sos1tOofX9ynNqlpNS/5rRfCZRL8bQBrhEdBTDUR2vIQTc3NwsHCr73Q5zaq/NJQXlQ6SIS46WS8cL+FYJJ+3nW8p0e77YkUujoFVY2/6X9kd9butny1ChJQ5C0HZADFdzSrEZjdhokzm5lc0PzerjxIhdK9Bb/bEmGJX7rI5dlj6g5WeoYKO1bwEers4r4w101r41GBhCqBGDvOyDZcmGJTGilXaetGN9697lGGX722d2r5Ys00Zt2LW8GpHSL6Rg3jLbSvsu7HPC+Zhdv6913xAZUCbArLw3bgzQ81Sktjasr1uiSBrjVd5dMw6xHIcGlphzcmt+ro1wGyftO1iOQfsPl/XUJFkKYXLF8d72q11zXY7Onrs1mms7HSwTAcMM/Vr/ubS/9AMgmQmgxn06A9RlzpYnghm5royr8+iUdX+111uvcQ+tgSAFmvj8fCMybl1b3ovXZ69rHOs+1PdCfjGHt7ZGgTZJXZy1lrmQmQw0dvAK/pBjnMYjck6YZ0ZKAZkBok4jvnq44AFIZhHyEnXXdUHaxAGAx6zghEuM3W6GA8NNOyB5JcwQEtVcNwbEmxugAIQAUEov2BOhlGMyyZrK4/vh5NpybJuTZNnuD2mvRfvW87adJgQgzcDpPiPziH4fUMoBlX2DQEywiGWvqa4ZWYF/1pIXTggeLEAZWE4JXlIOi64kADY1gLi8IwJKCSON7NS18KH9/ylyyYm11o/a/WR9z3YdIt+ut80eq8dzlvWC7LucEUj0AdOLWr3C5qCRTutjEob9UPYmK4+Wc0KaE5x3kuocgNVaZ2Z05OBcwDiOizV0CzgtZJfS/8tyktY205ntu5p9a3mddt9tgdb23Pb+pc9MP+jEYRpTAmUr20WIcUYIvmS6sXdixGzO9f06cqCw3I/sudfjaEsvpNXfrdhaaXtf+5ntE30/AEQYp4RxjHCeMAwBfUfodzsM+z12ux7DPsE5xnwKyInKvT9U1jObVmvK1jW5+f6xu35Im2pbtogm22vQpfs8db271D5a/Uab353L92Nf+H7LU8bE96Uf+cHfzmVrlG4dTw9898cih+OIv//i97ifHCIPQpZJGV3oBK/IHo5qOWVx7K1xiDafSLUNnHPFjrA9YJpnSKm8moFWdEQN0qGlHWZi927X3xgjcpI9oOu6Ek1ux7dtafczcXaeZ69pj2sjweWarPpU3bflPmgmg2ab4MYm1uwTtofWEtUo7VtHvBc7WPs6Q3T3nDM6csVpmnPGOE44Ho9gFucdqJbKNVtq6XC2LAxqR3EELJMkZzBmTHPEfJgR5xmcE7wLIEr2IoDMmCPDeUhWPAYIAYGtveJoVHNSTgPAmTFPEdMckbkDshC0cwZQAtS0M6k98+P0vkvS2pnenWNDhnHZTwBqD4ml0eo8rHZEzozxNOHly5d4//4dDAMCZpxOE3JmIRPQoI/DkhWQuejVmRnO1XctbVG9mwULSHkGOEIC+DaIZDoPc8549/oe4+kE8A1C2OHZZzvchGeA60DoAARkyzaj79FshY9UtS/ia+13S0xN5v5WIJXgroJZSEYODfQIAUQeQEJMgsGGXuZ/ThlzSsgZCF0v+quXEjkhDOj7HYaul7LDaUSajkjHCW9evcbN6TMMQ4ccd9hNPfA2IYQe5AjzXYbrMkLvQUFs75ylbYBDzpLcJQSH3W6Hm5vn2O/v0A2CR3gnWlnOCYfDEXGecTrN8K7HfgjIycNTBwwjGAmYe3DWeVx0qarH2Go7HgkjCGli5BjLgmTERCux6wJpnzVEAwsw0nnHECykBjJp+VegWNwEaCkhzRaTM47HI06nA25vd3CuxzRGvH71CtM4Yn97A+97pAzMKSPPsZRD8hQwJ1tfXNH1pYSZkO+ykhTXBJk6v6oIaV3X3+SQvej9gsXaGGJ0XV8ypMv6ecA8jfDBIaeInGbJ2E7A8XBfbFQjTnZdh2maJQCEHGKKQrDQwIUUZ+S5yfCsti7njPfv3yNOEwi0yBTjmyxlpJk2x3GErd+SEafuI7ZXdV1XbEibO13XlWMyM8gtM8LL/F5mdKolqtQ+A7SE1YRpmpT04cu+3e7DZUwWu87wNOjPFfbGVVdo94inyiVceEvajDxmK7YZitbrk40v0S8mEFjLJFPx47T2dJvlrdq95hOSBVXIvD0ALv2Z8zIALUUpqUhuiXlu4RRte6/y6eRKmLnKVa5ylatcZSXVMa3OjaJEVWMxi4dDFKI4YZ5HpDSr411qLTt1tBIbOOGkZidQQYjGWWOK0BZ5Rtp17vi3Y9eKVHE6qAXFOCfcbDm922uLEYWi4MrvrvTB2pnknZO6m5pCswXD7Pe7uzscj8eaGpIIFGsWFkk5aSVfTJE2opEo28LYn/GhQuRACjrYddfPsSWOxOhlrmzydd+dO7czcraoAVZHIQAjHsHGxNolalbCFhkEAkjWJypGL21EQT4mQmRfPsuaZNI+q5Am8mKsXRpTW6DmY07N1rCooNMSJFk7NB+7R0ucaMdiSyRZz5v2eGBZtmfdDnBzTzbYQBOyX3gllpZ07RSU388j/j+18VPAYU3vyhy1T8ICzAWWDkwDYyXCjpsU5ygRKDa31nOjNSRbx6lENhkJDGqAapSSpqYmBZO9V4LYhiVt97AUvmvDl+DAXJ3uelZpr4H4FeRmSXHOS4DeeyAzKXBkwKSkyDYC0seAuGuA86kEAN9kb3po3tmYb53kbX1mOZjVYBenwVKEnpI5I/OspXkEdIpaaikmoPeErg/wPqALHVL2mkK5A2UbBwY4V0KBc2KS5iSO/5gT7u9HABnBewzPTrj993+DmN6C/ubfgb7+sZAsAESQEGdgOREU+GlazmTEDYPZDYgWkkyzG8CSqHyXkAOVHYI2RhM3I/gb3EP7g+liQSb8l78FvvxVRL9/i3/3vxOGfVCHkgfnAIcA5gBo3p8UZb8TgnEva4UCxkAPgtbkpoycJjgnc6qnHre3N3j58iVOp5OuB7ZO5LJPMmdYZvD1vs2r/bx50Mt9oOdeIotcIrjZ3+u9Yn1d2/Pluva3rbFATf9nYKX9Xq8joF77mayD4zgW4M05h77rq+5qUDbJ2hzTBMnWldCHAXu3L2SREv26ilCsmWwsew4vgNH22VviySXyYnvd1vnY6rvMUue+7UM5J+F0OgGo5ZRMxyTqkFLCu3fvIJl2cgGMu9CXPYF1zbJ92nlC9lZKQ7XynM/u/VRp9721nmLrHDl1MrtOHcZiC4wz459/d8LrtyO64PGv//0BtzcJf/f//ACvf7t7YEe5NHOXR9hP++dgdsnWCd9s5SOmRVaO9m/TjoB2FXvkehc+e+zsS+ct/7s+9lJP/8sFoD+ty/np9/w+9ai5ac7IMI/MhfW3rcPym7bnu5bX70/4T3/7e7w+OHz9dkTMgO88+t4jxUnWNlexDQkaaFcbBkr+g1rO1fRO7zy8k9Iyk5Z36rquZBnx3oPNUQrZo1uHX90b89lenXOWzCa67h+PR9ze3pZz20Cl6kDMQlwAL/ayS3t7cWrlDLDoPe3eJ7ZFwjhOSCmj7zt0XV+CDkBAShEx1kxtbdtMlqRZKC5idpOQZ6SMTAdziAPy7LvdHuN4BDPj9u4WAAqZqAaCnGfslP3LSD5KR2fTEzy6zsNBS36wOJtFTxD8JiaA4eASkHMHJyFbdQ/iqpcDwDwnvH59wv27BOIbOFLbjxxAEUC9h+EeCs/9QcT0lGInCrhXybYEEJySWrRvU0aKks0EIOx2e4TgS0lfKUEjeFbOCY4A58QxmnKGlV8xon8mKY0aQs2iIUNC9RokeE84nmbMcbssCIMRp4B//Ot/LXoUHJ7/8D26//HXIPcC3t/A+TsQ3YKoA2cHhgQxWCYS8KddnVo8pc1CbfOhPW5N2I4xSrmeUvpdwiYyC/4aY8ThcNT1Qgj7llFGSBgO+/0Nbva32HU95nkEEJHyO4xfzpj+44+w45cIscNneI6XX/1CCYIOMwHuvzti+D9HdAz88PAZjqcTxtOEea7zeL8fyvzc7Xrc3t1ht7vBFI+4P77Fm8MMzj8DZ+D1q3dIMcGRR/CDlGvxAd1tRP7R34D8e/Df/VvgzQ/0fdLF/abznwH9iLzzGG4PON0fYDuL2BCancj5YvtaP8sS1miM3JIIqhZpd7a1XZOOCg6eI7rO4/Pb5wg+YDwd8eb1azBnPHvxXDLJeLEd+34HYIlR1EzCDVaaZY/JOufa4w33sXa2wUohdNgNATlHHI9HHI8nAIRhGHTMScaY3bAXGyRneMe43d/C3exl/QPKmBvHsRAwo67ZYEboOtzs92KHpAROGZ4cfBCCVmbBfvfDHjFFHO8PiF1C6ALmeYJnWRdknTCb0y2ehahmabNjAca7d+8KBgagPNtDeC6tskWXec5ARoL3AbudlCmTbGURiFyIQFsBu3YfK9/rnYNfZEmt9zLcx/ab8g3RYkx+CBa6tLuWmFhLimnXHfu867rSdtMP2mC3ruvQ972s0zr7rM/Np2HXP51Oi79trzXMkYGFPU2kxEuGZof1RaeiB577Ikbxidfp/5rlSpi5ylWucpWrXEVFlBYzQlVBWzk+UspgJGXcO3BOyFEiblKeIU6KWu5D7A5T+Ou9HBHgKtml3v9xCOASs9jO3UpD/xDRoD13qVzWyI6tWtznbZWUgqY8GnO9FQOGTMnMOSPlZfabtbPbmmxKp2U3sDY9VQpMruVWLgFhW+eREwfDQ+Sa9jshKCUAWXGmavSlJHWoi+uWnDoRDWTcfkfnDjvAnGLV2fY0YQ0bai/Zjh+734IcUnrj3HHYOuQ3+2aj/VtSxgEe7uuH5sma2LL1nhcGmCIOW0bZpfG+JkY81aDbas+ybct3sr7vpxLnJNrPafmjdv5ttc8SNJOO0fadO2clj+rYaK/X3rM1UIkIiSFAyMLZbdklakTLYi1bt60BAiwSZovUJkKwbDw1hXqdO1zITF7TZicpE0SAJDqWNLXkFKySgV2M/QJefeA72yK62M/LY6ZmL2sBrvr78j3U9yTNs2glS+lbSVEVUDBAOKVcCFbmH+CSLURrl2c5zlGWcaVLmcAKkpVE3mXrRIaSGLkAxPKsGTlHWHpnZgKFJiqroZQ4ThJzRnVsaE8AIHi0c8qKSulapy9NSDJsrp1mjD0ddPgmTsD23ApHLh27S2D04wtFcfnP8v7tfexnSvLPhQTwe5Dr4dCDOSCnDoQAcGjGe4L3SniDEWV03CkTKQtLDkYqlOeSlN13d88ASNYQZkZOrPqYV6AwaSrwc52l3avOSTMP9MfGPmPzZWsPXANU5W9qyE2r+dz2KenAJ6h+mfP5+2ierdZ2b9bAEvlN9X1m1vmo0c5OCGUpK8E7M+Y8I83vAVQ9qyUNre/TPOhi7W77oXVk2PlrQs1DfdySvgGAvFOw1dbnul7Y+sacMc+TEPgSA/BwLpTU/JUAuQRGWweobGWmb8ln59GOK2nW1i3ZIs2suhGFhqQZvoxomTLAM2tUPYN8DyFiPixPXXdaEt6DT3GJSPMB4mxc6n2IqfRyC4zX3n/aalZb/vAKvfUEdi6dHbNFSlzKmlL4sWvv91s+/r1fOvOhXlrvN5/yvh9yAQaX8fkhYhpfuy/rrvaAFfe0q34fJCbG22PE63cT3rw7gQEMuw7Oq75LdUVZNnt79pmOOccoEfddh+A9jscJ4zhiNwxSdo9rZpdKbK6lamy/aR197d5U1l3azpbaXsOcrMyMNCdkEoLI2lFvf7fOQcsSUMipONdFWucbc9A9TGyPrE78vu9KO+qx5yUySk/qAGtMV0jZDFK9ixHjrA48OWG9/1Zy8bmpstyztd9NX4OUWCISrhRnyZDCTnLHpByRGUjZA+SREyEl02dd0bClDfUZkB3S7JFjk0VHdRimDCbLVIRic1DR6z9sznwTc7q+EyipJS/1CcUtONeMBFZSU85JiFFK9YQQMAw9zHGdcgISgbiOd9YAqXP7sP0sS195wGmmTilj2oxhtGsUI0dxxhITckyI6RXGMcL7Ef1A6LoeaDMYk/som+hDpSXDSFYk098AUn2pHZsyfp1mXJLx5L2Do4CcJdPUNE/gzPBeAjksC433HqGTkkzeO8Q4YZ4PCIExx/c4niak+UfoNJMTsUPILZ4pOjiGGcgOO+4X78UydfR9r1nFpeTb/f07ZET0g8fd3R4TAu6JMM8RcRZsUOysgKQzhxlISAAvV9eWLqOaZKGx+NAheyHBd32H8UASBJSEfLbQj9HMR1aLTIOTFGJQtYtUPbR1xErxVfIFQQgt8uwB03TCYX6Pw+Ee02nEbr8HoMQ99vAhwCtxp2Kn7dNRWafa+d7OiXUmLqAGnuacMc8ZzAkpToU8JeOhAxhwPih5Q3EBJ/aEEACVEAPDKCR7zDDs0HcdDscDxnESXDplHO6PJUOSrGMOnDIypD+dAhVxlrKGXSdBmZwzMjI65wuhPqUMMJUgErmmWwWnyfNO06QkzpoNZp15vthANofP9kXrO6fkVVdwsHpNUhJSKHvoFn7V4oNml51j2Lw4Zy1rW/4xLLQG2Zy3p73n2q437KvruuK/aHHE9hpEhGHo4R2BcypZjWpGWFnvLWtN1RUsI5L1jeyNkmHM9AqU/UGy8ehsfhAzPrc3vw3M+L9muRJmrnKVq1zlKldZiDodUI0ygqV/r5EdojhPAnpw0swyGVatQK7USpt9QMAcO+5hEspSLhE1FkBR87mcc37eJbJIvca5Y6QlVGw6FUgyBBhYYwp7GyHVsq0tTXJGOHPebD1TW37AjLoPlyW40fbHloOkvKONvjq78qL/LVo5rxwQpMxxBy5RGwq3NcbPY7Lsq/PneVRYmvXUM76JMt4a5Gtpx5T9dAp+rB2jH3rP9h6X5oYc8PC5l9pQHE8PGGdPbeslwk39fOmw+RTiiLTcifXRA+MalcBS18ZqgBsRQyp4PN4vBXhErXktoCwKyGvH+QLsXH4Wa49zrkR2LcDmNsK9BfrhQBq5ZwYts7TJhw6SWlnnJamjwEBebS9czRj1TQzVBeGuWf8ePAfr4bsE61qA18rpkO49Oce67mk/Vwd2Ez0JIEatz82kJUIa1F4z7KSckKJE9glA6KTkkfjqdR2UclhQ0pFshZJem83hD9LMIwQo0YIzA7kHOMCzQ7BsMQT08JjBcMwFWG92Whjwdt6TXPtOO7IeV//7IbPuQ97+Y85Eu1bJBNGUj/rYlaAAo1SmBFy5PpWU+ev7xInwn/+mQ+gcfvDzCT/42QjiHYAgYLrNHSQJk3UETlay0YMogGgHcELNiuaKcwEQkPJmfwPOGdMsUdlxjkq6sXEhToSL/XZp7jzyYrZ0sCVpZZkNENheqxff1wMVjObyuwMKGXurLev7rIHPzBnm7OUyvvUnG3gtr4KR4SmAvDqGMwoJZ1H+ooliB5qsV7aONqBgq/+tCTFbuuYl/cHW5zainpmr/ujr+qVNKWMtMyugLJ878iBXsy626397b2trq0+u235RH8TjStPWfk4NYRAKwnPjdHbewZNm2WLCPDucTh4vfxbx/HNSbn1EjO/xu398jtP7Yd0qu/vZb7T4r+65TIuz0Mz5x9awbXrJkkLSrr3tMfbftTbjQ8a/+jevAAJilixDDAK5DgRCihFxlqyS3u/UFhNnyzB0EJfWjK9/6/HqtxXepLP/Lj8//+zS2spnv397bsPvVj5eg9m+1vexn9qR+A00tgd/W//1eD98v2hYGcDMDkxSoiXGCfn+AHJRbVVbV7dmEc4+K3p9rmt0jLFkjikEVc1WZnsOiIqjsnXcrdfoNSYhmWElcMVKdpgTzI4z4o2VKWF2cP5cv1g7Z1s9w2yT6mxe7ovtHrQklzK8r4TRNrNMG3xy0aaw/UTtDtPtHLC4r3eim8/zfJa9eJldAGhtOyMqMItu4dHsGcy6/7Lq7RD9VO8r71XKvuw6h+EvXmP6++eI70J7Fex+/jVyf8CJ3mE6AeAO3nWiG2YG5wQ4K7Yq81WwEiefcSXSPEU+hSOR2Uq8CCFGrns+183pT6ASTFA/l74fhkGyGmlGCstUmgGALWup2deGPyoeaWx/vaMlp/VhwA9+7hH6CTEd4FxEzke8+6rH+69ua19ASPnp3Q1e//IX8K7Hs1+8QfjhEcAdUlIbywW1/013+rSreiFtNPPJSDMAKXFI9X4rywYUuzXnLEQj0mAYtQEZrISHDCPVOC86g/yUjE+h69T+jwAi3vyKcHy1x/x2EL2CHDo+X5sZAOcEThMc9QjBIXUeXQqKIQQALJlyXnWYfmdlkIG5C+h6KV8c44Tji1/jwK9AibHrB3jXoYRM6NjKKYjNxf7inpX69xhffonnz34IPE9I7Aq5gbwHN8Tlovsr+azFDmQVca2F3CiUW9qmiJAEIOsoyTg9HO8xjSekGMsYbYkehg+SvbUGkyj3qMaU4J1+qae3Onxr0xRdP2Uc5wmOoBlClIQUM/phQN/18C5I7ALXANGUkgTDphmt5krk0Gnmz92wg3ce0zQrIS4ioLMRAkD2IkBwDCuFhKxl3Un2n2ma0XtAMrbaWiXPVzOgGn5je4kElNjYb+2cEIKUg1rtPzKkhPi0iclpNvfgLfuL9LvhQuQATzXIoQ0sacUwfdcsjlvYajvvy1vexOIfNbwePG7zwL1/AAAgAElEQVT9eWtzml1rWcSsDW0GnXasFSIMVzvSzhcMMpdseEufhWRvJrKsO7V0fc1mE/UcVrzj4cdedsElTfQq30SuhJmrXOUqV7nKVRohdSBX0ACqsIrR7lwGZTV8s9SgJjXmjTUsimlSjaU6UovRCfucSwaWtbP0klxyqD943EbWCj1KnCtERQlsr7tuCwElcoBIohWkr+z4ep4RYoy17Xx1tJjpuXaabzmtWgAuZ4sy+zjH9DIWcH2fbSXdjAV5RidvsICES7Bu0X6Yk6c6fe0bp3lLW4KCBs8sDMll25dtPn/+NXD5sBCJOb5+F/YsbV+sSxKR/m6RZ4t2bvYhF6fb1ndbY22L3f/Yu1pf9xLx5ey6BhfQ8twWFL0k63H6OMnhafP3DyVSh/q8X8+fY+0OQzlu/ff6+ddANp2dL+AnSKpTV+KKlmlSY1XKMxHIB2CVRnx9vzPySdN0W4fPHbuWEUMM6ZwtEkfnP2q0JZf7kiasMnDkfI1p5Wljafu5Ns9pfmvX4FI6awWqr29vwKRFDVkbBBCei+MiJ9Y1jJDSMuK1AAkpIxPBuQ5dJ0CwRKBKhJbtfBKhhXqfNIOzjgNWQg0inJNrxgQEHxDCgJSPCBQQ4OAAeAYSMSJnLa1kyZOX/UO6SwPVWdb+5AUZ5dsFHWznaH9ePLYlsSnL5Zu2qfQRiePcQf5lZmQS50gGNz0EpEj4L7/c699f4+azt+C8g6MAOCDlGTHNAGd0HOC9wzRFzFMCuQBPPbrwDMENIOoACgAPKKwpyFrUdR1ubm7RxwEpZ8zTDOCAGJUkkVmiSa1hzcQm0y3a9TuzHnO512y+AMt9vN2X2hJNW/sQUV3VuKxwbP+vgCFgFRpLs6oewNaghY7Bzbf1cQmZLcLdpqa6olwloxmhRqL8SNLJsyt9abIk5NgzS7kL2xxt369NsHIbK32Oqt7c9vGavNLWfF+W1LB06izOAVfbRNppOWeYg86RRIOS8yUCk6hd06Sdax3AslmtHZsP6t94eL6W49bjBBDuNDQTlra/6DUMOC11ljMhJYfDPTC8mDD0Gf1A8D4h8wHvX93i9N566kyjqO9j8VlzREOWWY7Zy2vL+lpb9z3P0UFnR8g7JS0DV+/ofMZnP/09EBgxSR9keBANABziPCHOs0b2BonA9cAweNzddPA+wiGCM/Dqt+uWLltCTWu2Wnr+bCK8+ncVkcfmw6X+fOx633Yf191N9tWLJcounnt5nDzls/UR37cxFVPG28OEac5IWfU7RDg3F7vJ9r2yclNrEi7XIhalWZ1xUsponmdYtg05pmYXyJmV1MvF8WZlD9YOwE1ZKbutA9X2+5RSIe3YHtPafnZ8SxJFaaes5e0u3ZJpWkeatNkXTMgyXphe0WbMWZc9XOsbrM9W1jHdH3PKQhh1VpK2xzSekFmIx0c+lGwaYNujXPO+7Jm4vAfOlhEQ4KJ3VRstJUj2BCdzKHFC6DukNGu2YYB5RPfD1+Ave9C7Zw1SwaCXr4BnXyMfE/IkTuuiVxCrvstA0epJlB2mRs96uogtuLKz0Kxh1teqB7fnWSkl+5dSVKIx2RICRh0XIBRCVFvSJWuWmZwzQujRdT1OpyOO43sM2CF0HYh8KZlje5XT8qXeC4FWssgYviJ6rxHUP/tJwIufeMQc4R1jmid8kR3uvzKkiIQ0y4R8uMX9r4RI03/+CsOLN8gckFIP7/boew/nPQAJ9NKJ/DRF6Imynm9ml5JmtjH90OxRO7bvLauL0yAN4HB8i5wjAFmzgu9krvmA4Dv03Q673R5dJxmwvSOAEkCT6Ff/cIPjb+5AIAR9b5LDdCkMxjjdI77/HULYYzfcwQfRSVyTbaXrOhzeD5h+3ZdzIwgn/T2HjPHP/gmcZngEEKQUVta1Qt4xkJMD5R3coiz7UvJwwPTjXyN/nuAy4I4ypL336Poe0TLFplSwH2JW8oS9B7uv/Kt7HZX/2arONgx0geec4YOHCwGcZ9zf3+N0OhbbDgzkqOWTXNAs60b0z/V+arsUXYAWu4yuQcusluU7nAd1JtbADO8QQo/gA2JMmOJcMs04bQu01B2zlmyGdE7OQrwhkmbHmBGRsRsGyYSFCCIP76isq3WfEJJXCVSAlVPqNECQEZyVdJMsI0agNBJPzhJY5JiVgIMyNqB2RS3V5DWzka/4TFMmCYqDVdu3Ej+NtFfbb3MvI+WMzgfULMFUyKhis9l7aEs/WUbnMlAWY7YcpzZqJUApYv8oplouVMbG+vo2Duq6QmUdt8+Aqg9YWat1oIrJPM+IqEQm2cupWZsyiALmWTA0BkBaUQBU6WkyTivWZvdMKYMo6vvwGuT3lC6opcjW/XCVj5crYeYqV7nKVa5yFRUiCPPbouAhCkjKCWmeMEdJoeiI0A89hn4o0Tui9HmtbyuKtoEOFag345dhkTFd15esCBLhtK3kGDeBqCVsmJHTltmoyqEpvEQJaKLUocYAuQb0av6JqNGQVfmD1C9mTuAS+QI0MDjw/7P3rj2WJMmV2DF3j4ibmfXqbjZn2JwhxOFQ5JIQFhKFxX4QIEC/W9AXiQtBWGABrUDuQlyJnCGnp4f9qqrMvDci3N30wczcPR43M6urumd2dX2mOjPvjYc/zc2OHTcD4LxHgCmeM6ZZw0RyQExy6mgeJ8xxBijDdx4eyqzOEuZWlHHXABnLNjkFlCz6QzOC1luLzxYgngFOQNNe0vZuel1/WC1ciSC0IGSQPdqMiPb5SpbZGKL2/FYNPjP2q7ZsCTsKgbwT+UL7Zeed6zzRi1NphqJZzY1Mg8ZoVQcQ2/X23SP1M0CkAJsNgP0YYWZNkGmBz/ZeMyb2Qm0Wf84KuLHnLfpXQSo7jWNr4XHDjlbz46lj9hBEb+9GM8eA7Zxu5EYBKay9j4wNqoEnbaj1ad+xHoczVV1cb4C41SuliMRJyYhAgMccI1KaQY4QAPiwPCnZggLm4F5ETCCbt8s1Cu2DGsUCsJDsOS+JNuCMzDXMtRFSwKTgVq7rYHVy87E+2Zvfj88lBeyJ1Vivnzlnp6S4rsMGZMmahktSMClZABUMnucJcZ4kn3oJ/+shhBbpEHH8kvxjAOzgyKMLneyN3iFOI1KaEOMMIg9AQg+TC8iREeOE0+mEvr8Sgg0yUpzBGGXvnYEYHQZ/wDV/DEqMwAOCnr6TwOMeGQKKZTBmBae0OwpA3sq7cgaR5J42DdP7wAz7q4h2/2oBwXVRSLq0gxffcfn+uxRxP1Tgzn4W0ow59SH9tExRBdy+ucXn//grcO7lhFyXEfOIGEc4BxyGAc55nE4jTqcJ5Dy863F1eIGhv0EIBzh/ANI1vLuBcxKyvDsQkB2G4QrDgdRJEUGuw3iaME8RMU3IaMgVuq+QtYwBUjJIhoT0r86Wnb5YOdBaAsWaKLpHJtzsIeo0MfFoBB4QaV9bfakAzbn0bvMsvcbuy+K5KqcCRa+wk5hyr2aa1PpljQqlqSs92asRgoT8Ph2PAsBaVCkFiOVpSrhjFpmn77ExMfnhVCFqyTJox2fVR+0+3BJl1vu1nKAWJ4iAgAZ+1z2OiOAdEMIA7wZIFCPTWcrUAACkFJv9gFXXXsrcdVqpdy0LdZBanaGeLLW9jpyT8XBiN8h4pRLFhzMjzRmn+wTvE4aDx81Nh5ubTzBc9+hvMnIE4rjnPFlSV6j5Sbz6G60WutafG/1r84a98rgO4T3DH5LIal0rmRkIE37z1QQXHMgFONeDKSAl1Tf4AOeuQaGDCy/gnTk4POZEINcjhAH9Ycb1s4jMjOnel6a0LWlrWfqiJa8T78D6tRX/JcLQtPr5rvd9yDp8iGdvZ/BD15ngFJvjoXsaC+M76Avnr+QnXfXDlK6PgMuY8xGf/+YbfPM6YRxHhEC4OgR0XUC6PwJQfQ5V1j2ksnIWh1s/9CDdR1KKAAjzPKMLqtVRTZOUc1YZ6RCCw/E0ouuEkFtT3SyJmGaTiNOqEmPayGO2F5xOJ4zjWByMsgfkhbMTWDrO2ugDdr0RFlqpajK96zp05hgFIfgA5gwXQnHQtdF3Wwdeuz9aySypdE3vETwiI6YIpgzvCd53GPqA00miO0zjhFhSZ/QaZQ4IYb3yq4OULQW1gFmF5Gj4kaVmTZk1HWRGZIlik2JUwnPC29dHeM94GX8PXd8rqURiGb69mzTBeY+uCyB2SIkBSjLGnpAaYnBb03dPotbMxdVPApBJdwfnYIxjVudmzgk5jpgmSxVp4xRQU0zlgh+ITWbkFlYHrEMXrhBjwjyfkDMwDIS+95jTPd68/RbXp5e4urpBFw4IBw/fydjmnOADEDpC8AnOcdm8bd1JQN6iBCKEAcMhgDACyAhOKC8ACmlW9P5qB6RTxu3X90IOyB1C9wwf/d6A/iqo/ebRnO7azJ3yu7HC15/tjkL9u6r1QjDTYMMyHxWzadOyv3jxrIwFkaRy/fUXr8GcEHxA5wdcHV7A+wDW1MFDf42XL1/JgYyckfKIeRqR7k843r1BnnsAAQxGUu087tiITMDx9g5vP/8NnBvw6Sd/iL6/Rpd7IGXkmBC6HoECRhgOAXCYJLqg2QhhRggdnh9eISWJ2kSGdToZmZQyYiZ46hBoBsIRgEUJtrDmBOoTQuhxd/sWfd8rRiXv6YcBPInMncYTDtfSdyJblKCnlSz6oDH7tbpEVHUlNvtK7vCOMI8jgj8geML9OOGrr/4Z3hNungsBaZ5mhN7peAAMp3mRMzJLeyRKEHR+VdyizDZqSfYyF4ehh6S7F3nqvcfNzU35m71HRwfpxyTvIOcQepnTOTG8RuJJJKmVACpEiMwBeU5ILhXDYo4RwXucTjOOpyPGecJhOKDrD/JOjbwlmGaGCxrhyDk4D3hy8MHBk0Qj6p8/R0oTOCdM8yz2gHPI2YgVSUl6mhLJd8UWrVg4IQRpRwgdPv74E8Q443g84v7+XqOWWB87jcgpkZBI50JmICVGzrE8f54jxnGC805Iao7AlODh4ILXrU/tJ5Y9IbPaG04i6UixSDnVjmZoRGfn5fDDFJBiRnQTkpvrunkCAaSSuVpNTeW7RprqhyCHnWH+BiqRZaZJ0kNa1Ds70LxOk3g6jcXvMwwDrq8DpmksPhxmIdUcj0dkZnT9gL7vYJHkc4rFNp/nGeM0ir4CoAsy1nFmhEAIwT+4062JtQsc/lI+SLkQZi7lUi7lUi7lUrSI40wUcjvJ5J1DFzy6zqPPCqiRKw5KZg0JD7HsapS/UPLWlrDvRVGEKoAZMU4wiyTn1khSg908BGxOQKeknJaJbUqSOBaqI47K+9qT14CEgBfQwq5Tdj0MKErIcQYjwyuAkKM4GojN+eD1O2hdqESAcaHD0HcAMo7TEWMcRSkOHjFPmKKQZpiB3g9w6NSAz0gxIeoJLJA9U0qpbwNOLR0ylcVvn5UIFdz2jT6vXOokBQhaxVzHY0NQsXE0YlVz2oxyUZid8yX9gYViBRz6roZ3rI6/XJxf1sa2EEFPHJmjjVb3Lz0D7SmcjXMPVMZszaBnrlGPWufW8hlUx4LUALDn1kGqFS+fb9V+M0DWhBRSIoKVNnXC3r0pJc0X7koO37Ys1wmWbQYEdFBXtOTrrmMqgWlZx5PLmq9OsQwBHMTAb0++nCtmpK1JPkvC2zLKzqJvgAJcFhiHyn+0fq44NtsTOIZ31fWDAizLPN1GUrBnSnWbthHAuRrAMgvaedASamhTd3gqz7QVxlYfEiCPvEPnevhcT2oWEK2Zl0YAaUOm2ncyZnm7XlT22VjICZ9GfkBDykLSoFDKsg61gRK9ARVgt3op2FDHs8oqQrMmrGu5nqYRGbYcg7XT2eZGxqS53qU28xylzr4N8SpzcvAHOC95sceYJJVFCCB9VnH0Z9tzFMBiLjLYeSMSRB23CHJJ0zARQBHH0y3meAQIuL9/i5gnWUdOgJWcMhz1mFPCPI2QQGUZnCMcOYSeQNRhniIQPLquQ3/7DOl/+TEG/Ag++hbSg/oO4EHwkBOxBCyixhAkmkqkCnxm/b2Z3h+gPPEk0Jl3trURXQRFDrKetuWd+75LYX0mmNSRbv22rIlSfEudv/nlT/D6V58J6K5OBsfmPjNaiM7RUl9GdqR9juZpCYQTPv6M8Bf/g0fmQU4e2jtdh5ubFwhdxDSOOJ3uEY+TRhjR97fR6dTRA8qqI7DOZxQZtd4b98iWAIojq+u6AtS3p9T3ZDdBwG6C6R0QOaanTXPOGhnG5iaZGK797Wiz3j1qCGwbmkN/UMeVyoIU633OoXMSeQUkYLYRYDihyCFWp1/nfT0Bp+kiDfD0zoMpARDZJ6JUUqhlQgFgRSZFPd2r+hG7hRy0k3utXtbKOSNad12nZBkU2ZGSOaqCnuCFtl907+BJIs3AaR+y/rP7Z0yz7gMW0UxTOLWOyW2aitW6OcO/WugvVQOXexqdcbE3wWlwMq0rNBIXJ3HgOZlAY/TAmNBfXeNnfwVM4x2+/GXEP/y7j7b1WE6nRZ3eTTo99Lz2SU+Xoc8+OeGP/uqfcXfnMc8ZMYtTeZpmkB8ABBACkFUfyULWh/WZAzInaQkp4ZEd5ix77o9+nvDpn0w43R/x7//nl5iPRujeb/k6qoiIPlOiq6xt//2XWc70zw9ej/cre/vpY22oDhbC1qm7fbbtwY+//d3ny297fhGAP/yTL9A9e4O7kTHNwM1Vjy4AKUfElBEzwOibytqeaoR027ugEVYkigoBuDr0xV7jnOBISNYxRqTISDACjEQW874rznIGlSQhtm8BQiBhI32SRb5VTIP0exYHdoncIpYFhkOP4TCIzZa5kFamaUJKgPOE4PU5euqdyPZ+jcZSDCPbO2qEtuurayGCkBcnYErgDNnDEGB+9K7rFoc5mHnXPnTOIXNCsjbqYQ2Ok5JsPGZigCX9CWfG0A96cl8cdDHO6MKAvu8xz1GjsrU2oh1aEruXxSiAbuswLERSkOdCtmAmUASmcSz1diD03QEExt2PfwHwL6qdAZJ0S9kD5EBJ3kcN+T8XXcWXd4udlMp8W9uAbX/tlQzC+nxIVuKX9+JodmRWPxWiq/OMzDMITklbQQkOFeYgZDgWOzqnGSlNSEkOgZxOCT4YUSCA4THFhGeBcHhG6L4c8Pbf/wR3qpt9/C8mfPTnJzBL6piuz3BhghA5HIglRS0QQCwHz5hIdbUZmSN4nuEoYp5OQOwQuJIPqiUq/0vI+OZv/kLIWCAkACNlXP2PwOF6ArgDUUDiiKVU3ZGwvKM1GB6AGinQflYcosGXGl2XILpTH0ixGSGdDUNf1g0zI7LYojc3zxF8B04ezl+DKIAg6Zj6MIDZYxxHECVknnD8fMa3f30D5mtIoAfbFeR/MySaSEBNaRTB6D//I7z84jMwCEdHOEJsnAjGzAkRQnLnpA3xEfd//LeAGzVqKyRFVEeqx2oMcsMB2PpB12AacXr5t+AXCd4z+t7jcNVrWlyN7D0yhp5wd3dCjhNSBILvER3DUUbMCWmOyCnCeSUf+oDMKCnGGCYTJOpHjTQJ0YtylmgrnUTu6YLH4XAQcn1OOJ5GjOM9hhDQDz3efvsWzjkcDteagkxGlWHEDOmeVPgoevA0c7G/JA1rjQxZiZJALJFiBAOPccbt7RukZKltvESRCQEZHjFrGpwg0Zx81wHOIWmq18wJzkl9okZW4QxJT0aiJwQ97Hp/d48pZnjfAySyzPkekWekPIthTBKN3QeHrgMkgm4AeJL5TcA8jQCzpICKCV0IuLq6wpu3d3JQzHc2AGKPpooPek2fZLg8kW/aDQAnMBOG4aBYuB6mY0kNVDFq8XnYHib97HA4dLi6usacE3ynUfGJVP5lZCY9XKOapEU4ZqgMFR3e+frcbPgqCV4VuoCer/DyP/4xaA745uNf4uuPf6m6PhVZwGDFHGn1D0g5mZip2A+rXHEStSumjPv7e0zTJP3lRRZItDvZd8X+rPiZ/bQoMKHr0NEg0dtSwuHmGsfTUZ9J6EKHxIz+MECiWXukLPuCHJiwNHcRrgsIyOi7AE+E27e3SDlZT2rblzpniw9bMRJw2yeX8mHKhTBzKZdyKZdyKZeixRyLpizKZ5Jzsi3VN1MJKJo5egEimVFQc9FSUbbFd1GdmaL8yLOcnT5FVXrWoeLXTh77TH5R24ZM5apOYoPvW8d884Tmb3EsFMMWGua/RNOQa5gNqBDFmrL1mb3WwsQCORN4TmAwur5D1wcxBFObC1370kkkGQaALM/LVt/2XxkTU8Sr86rUsg1R+E46pPUdYZFDoelTp0SLjKxAmqU6YDGAYf3j9PXUOGfQ9J+Cjmfh2JV7Ymfsxam538A9okirYFvZI2jYfWvn1qI+P3Bp62KGcyeW6MaIaJ2ku89C7U5ZN+YwWU4XZi4ztJ70tzXaAsVPm2R7adDatu2lANkru9+bjAKfue6cW+0dS3sye29u7HV5s6R2H1lqJwOwAUS1u9uoEG3Z7y8u48ng3fmwJm4ZYGcObiJqnOcNcaqRB6Tvebc1ofebz6Yxdu29LbltTQSy00XiGFYwJctJSMkpXsmdzK4AlsUprTIoZ4CCgLuchHBg7wpkIaLbUQLI2e7GmNMMR4SUZ4yTnGSaowC33pHIdHLIEECLAO1P15D0xEnhQBhTBpFHCB6D7+BnX05EknZyKntas470ezvE1zo6baQSaVrFAox++LKuVy0NWWLnzc0uX0kzm+/er7S7WNs39pOYND3TkmRKICB7cPbLdVrSvNQdyPrXSDNpJ5qPXRnnhMSTOrn0xGTW+dwJUO+dhLY/jm/1JGJdw+vQ01Vfqo6fTR+c2Q/ava4Nk9z+bNfl2knDGt3GKdAFQCOM7IVKrmS0dR3WMmAt/4S808pH+2c50S3dlZKxVS8hrnVrycFZQTp5J4FZSS3kQJQlLDRJlL0Q5JrWyQbKSDYPVC6uRfFZ8qcW50gj4Kz6lJXw084yNgKinJGWk5jSvQ4WpUbI30QOyATmiGmeMM+zAM6RF8Ox7vfvvSgQ6lh1aDDUo1pamgFwTqCJMI6ih/fDgKubodZ78dCtFiiqa6Vqtmv0obLUGM7pC+vPeec3nYkMzDHj7pRAJDIkA+LoY0nHwZl0xapjlaQ/xLmSm4iecqo+aoQDYsAHnfvR130AOJtuZ7efduouf/82NN3vt+z1ygfQCnef+dvqvYfeu1wH9b/n9u7WOlvvYU9957vU74csZY/3kvtFyBAOyIB3QjKx3ZQc1yyki1KJgQAjBF+ixFh6mhgjojpmQwgAV6I7AHWWKhGEKyHU0pwEdWTJtVRImLbvC35iMrwSITdkClO7uY10pnsc1dQNAGkkHOw1WAj0LIeJYkyl/t6Fot8agcCRB3zFUCSVTK3T2gm4SC0Cjfhn+z1Do75wab+UDOaoUTg10kkQOvM8i47lnJD/5b1yl3M1MCYD4Jg07Xh7CKStm+2XFsl0SfCXVC+2PzPY86It+lYUImfBWNZTar27VX1ngYucwSfWjzpjHS5+T4oDOqpEZc6zRo3RNOMuADDi1lKLNtwsZ+lD74V4M88zYtTUoiR7+TzPmGeJWMDRKGHAPN1hml/D+x7sGKfxDVx0JT1ScM/RdTcgJnB2AHtYlFPr5XoQQ5zoXu0i+ZYae0rnV3RI+lnW/orziBgB5wYEqtLx4d1z/RmXP2VHXpKdWqv/waLjJ2Msjn6LUuW9xzAMePXyFa6urkBwmCdGTnIY0IeAvu/R9Q7gCY5mwEUcb7/Gm9cn8PRTSO3s8E7pRTAYkRhz+QuIkKgvKQchlWnw2VxmqAfVY5ja6owx3oOCEK9AIluopCRu7Nh2HmuE3MwRiScwJ4nwFBPyKWEYBhwO13AuwE+T6LaJATj40KMfEqY5wfkEHxggwul0Qhd6hK5Tm6tGueIsBJyqoInt06mdfhpPcm1r7zEDSWQPgeGdR1Q91tIDdZ0ehmCRfaLS5zo9SMgTTg+tkWMIcTkpWaam5gLUPoT2HaBkESjZ3hVivdgtcqRGUtxIe53zIK82J+rBvCLvCELgYyepbmXylRmbGYBz8MGINDJ7nCd01IEckNIkbWBJxQZ4PdQnkSdTEvk5zxHBSRSeGFM5tJuZS7Cm4nuATJV2NbaHPyz90tdff42cM47HI+Z5lqhDupBk7wkqG+phMpPlC/uHCHAED6cHK1ijx+RmfjoY/mUyHwSNZmU+lPouwT/LsrZGgLKHSx6cpH+cX2G4K5ysrpO69xR8o9kP2jSMhhc7J4ShSr6iQpSxYhkA1oeTxWappMqkdpvdnwuTUuYag+oAkqH1tn6U1AvFFIq9K/qJyYp2nNtUjheCzPdbLoSZS7mUS7mUS7mUnbIgMRRFUs2oFXHFrl8be3aZOH4b0g2vALriuGDUSA+AEGsqMLR3IvpRJYks4kqt8+49bGagQYU1akTbBy2buzSmbZj1Twk5KsainA5mCRfZeThVugXsErVRDk1RiUTgnBmeNR+svaclE63btCYTtQSIh8qeg6SYg01EioVDoLmFi5NIT7kv3m9PqgSVdyFD7JE+zinJe06pvb7ay8/6UH32rt1rw4dS3N/FYUVUQdc2Is5T36MzF1CwpPS7XKCnIZp5x9A5mRdj867vbevffr7Xht35eWYOrMHN5XseHuN1qorfTqnGe+ZlVCisZNH6pEW9bEmMWa7V/bFayzo5XbUnb7eO1lJnWoJI7RouLeN9ebL/3Don1sRJ0ihCzElC2irg5Zp9pJJtnEaiyPDel3RMZM4DndQljHFOTbQmA+W38t5kfpIjubAYIoAvucJZER5yDqE48m0MK1hlfS7p/+ppY/cqIf/lP2OKdzj8048Qbm9Q8TwhLPJmLzJgaf3NMnIAsByBdyn0wO/nHMwFzHngufZdhp2F3n73vkXILBb1pULE1Sm4/6Y9uFwiPWzbZTMhF6B5+Uzrp+Mbwt//Oxkgb6UAACAASURBVAdCxB/8nHH90k6CexAFJVE4pDwJONmEZwegoaurLK7ygJuaVBm6F61sTx7YvK5zcTlXdzoVRoLASk9by5Cyfzb1WtfJ6rCVIayOrFYWWkQWI8jVWS7p5SrhM7OceKygHMupdTZnhgPBKzC5GjVSAHq1tzAAlxUcJKvftovW/btucyX5WZ/JrDI50VaGCoDrSj9W2a7rpkzKXORfTklSPzROmt8m6CggKaPxZgFUI6khAWDGOGYQZbirDs9eAp/9+Ygv/q5HjnVVLtbnKsVMo9UsyrPfu8fNp/fl75puROZe0P3C+6CkSNkjXv/yBabboVYZwKs/+hbXr6I4JphA8HDU4e7uhOP8DX7zm9eI+YCul/titDtdoze3c9vDAGU5RZ2QrCWONH2E7nUqL5hC7Ytihz2t2HRpdvT33id+l8vj/bJ3xV5PPLarfdf3f39lrTHQ2W+Xn/Dm0++2Q/8uzaeuY/zpn92DXmTcJ3EqinNe9E75TSwkSx9g+8x2/1rq6M4Ruk70zXme0MrzbFF6zU6mmkp1fTCikliw+Lwt5jDLeU0o3V67fr44mo14o/tsY1+0t8v+pDhFriR6ImjUBldwjlQOQ9VoLgyJYEequ7R1rA7Fxr6x/dCZVDJS+A4hqGkbsxBkfQgYT1OJpGtOZxmLFu8CgKxRJNLCHq2ORUvNi9X3yzEAs3aayYYzGAu1rvc6NufLUidqbb1z2Fh9O9v/Sw3kA0LKGVkjDcg8VL0xR5BG6PElAmCra2wlA7PMJTm44MGJEecoEUxYbCnPDqfTjFEJvC3tfPzNAd8m1IiqOUtEJufgAuH5nx4lNSHZvmnMK9KFKURiAPCuRyAPz5YadLnHGbE9KgHL9mEHwjyfMM8ZXbjS6DUfRmq1/baLY8kXq/dRI2o1wq4Rp5WoNgwHPYCh844DMhP6ziF0DO8jQBMyTpj/rsP8m2vg277pF97sZJEYE1vqLesvIIGRaWvXWP2dat3pxRtM19/iNN9iikcEcghOiDxmXzjyC72aed0vRoT3JZK4+OQzhkHa3fcDAMLpOMIigHvy4M5hnCKiRknJDEzjBGInhJGS+s5kMJX+teLLu4VE5zrXyAMhLhKSEAX0eigBwCJ2FBmrEULUXFL5pveoTCtpW03e6cHJMgWKrUO6LirB0UavYJxkMsvVSN26L1mUmkpCSEXu2b7knENGldHSL7L2C8nIcCYY4cEhwCNnm1cZ85wKYUMiU8teKrYIL6LHz/OsfeTAzQECray00PpQv1oTZmKUFEH2s+53rhBRrE02VgsZbnujvVpPJOQH8LPlCqg2fv3OotEBbdqnlBJmTHj96T8hT4z74dtmnNwT3rfdC9Z7hLwzFzuzHhrFIiViu4+UCPV5hfU29rfhYt45BB90rlXqnFnfpjNVuSfoTrvHi61uhBlLS+nKmLdj3OovbX+0Y3Yp718uhJlLuZRLuZRLuRQtrYrRGgK1iFG9axytwJh1GpsFALR2GhUlx05WVUXznNLX3nuOwNMCS8t3bZ03BroU5wQYfuG0qPcXx+YqwkNmIDEXMM0AFesPOd3U632shkJGoA6OPIzV772rIUyb5zirixkyj3ljmsLFKfzA93tlgwGvoNIyntaftb7FsOV638KcoNYg5WIMtt+vFeFF1d7BwfPQcxZtWYGQe/Ot/XzPEfgu5Rxp5LuUc3W179agYvkOdRyrsQgI2FKNFLm2BcaqQ3C9Bp/SlnVft4ZaATqd26zBdytrZ+DjhpTa4+/+pvccv7ZUsEJPhFCVJTIeS/JIm95jbyxMtq2/a8dgMY/1+tZgB6Qu1RiHvrt17AJymqhtyxJoX7UUJS47GZC7nBctKaDtY/ndlcEiDW9PTk9oNalf5JSrgqfeIeiJL3Azh8FIUU7JWgh9k/dZQ+KjtH0rBx21KVYkmgwTMAw36kDwKsNbcKqeLrPnFL89BXjfwfse9IyBn77GPP0G/bcvwbc3BbiMxIjISNRKYp0nTQom+2whY7F4/TuVLTR0/pr2PQQ5d2jfnXt/rXMLpL9fnbfvqMAvQ4gtCaz9VutrIHLbnvY3hqS4Ai8ljAHxNRXTGv6Ws2fTW49f/Q0AZLz60QnXLwG4AIdOItpQB+fkpOLNzTNM06g6lqwtcW6ojG7CdjNzIQ6YjrOUCVuQzT5b73UGrq1Tvtn11h27e8wDwJYDwKtnPYnMSksgso3KYmBu+267RlLMSdoFCQSQkXMsJ3XtFCZZWyyUAAEWgXEJrKtKVgZWZ6vJ62bAz+0RLZhqJ9errF4pRtqmerKu/VajETLrqV2dgcwlPLvJarmvntz7XSgtoM0SAx4gr2uQMI0EcIYDMAyEH/2M8eXfQ9NlLGWEnVZertn9/X94ecKLn35benqeY4mq4LzH0PfwISB4X4DlmGacvnmG6bY+nwF8/NMRn/x0hnM9ciLM84hpZKSv73D65i2Odwl+qEQ0a29pv/xSxsmR6PqMjJwh9dKp4ZwDOq/zzxUBQ5xLS7eu2HcakQ8ma3/XylP2r4d3Nt657kPuTj98qRZw/fv8leeK7ZiPv+t3qfjA+K/+5Ihf3Wak2yCRZpiALOk/QJJuRjMcqr5a9xgr7e8tMdWcdinVdKWmC9aDQa7Igoo1mG5Lxal77lBEdSQpSVcvOYeFtPuycx6WttUiNTKbhrTcu2xvFIcXAyTpLzIzvAuSZkWj3mXVsckZgUbtEtBCj16ThGyPK2kgSYjkbidMyqIvSKL5CGlAIs1J9JsIr/Lb0n6nVKMIy3MUC9KIeMVp3RCE93ACeQIXfezcfNjFLNZKufXPI/tyW6e1rf9gYbSBPPSD+swWyzFHKCHDE0qa8BJFWXEs3XSaZ0pKy6j93vVBovfoXud9UBKVwzQlpOzhXVeoygQgfn2D+HW1cxxIHPEguENE/9kv4FxC3z2H9zeiM2gUKIIDs4w/ESN4RnCM0KZMLTJKbQCS1EMEwBPJPAMwjvcYpwlE13B+3IzVdykFxuP9MSwDwPqzsZ7q+2UgTVdlTRHb9QeRXQCC03XFGT7MYD5hivdI8y1ivEP8Tz8FPn+FAYxEYvvkom3VkpAxkuCbqG8vaXK3fdLMeRDy9S3GT/8Jp+OdkFM0XdyCSLCYw/VPab463DUaa86EzKY/yedd1+NwOCDGjPEkaY5CcBh6B+8OOM0J5CXiVYwJ3377GnOMoBhAzheyBmBrr44LUU0hbhiI6YFd1yGEgGkaEbzJbIvIGwoxQdrFADlklvVkWIsREGTmL1PTIS3niCMHuVlTRjuJ5mUkvnqop+I3YsfItSBLxaoRdZpIHjknTRdo5Cir03m7rkQUaQgMiRN8iVhiB4QcomoX8vikUapkjLsQCs5l9zCgBB/UGWk6csGblrOuTVVYlg4RnMr+lHPZY8uYrNq36O8mahsrKEer6879XvZWtPZsxdYk+ieVek8YMX7ya0zTBGYUvWDvHXuf732/iNJW9voaMVb0iVTmiNSw4r5ZsWGUeWRR3tpDOSwHPbxHUFKZ1qz0V9nm9I9aU42GpHIM5TrSvYZFL0Ht07Zdj+IEl/Le5UKYuZRLuZRLuZRLsdLoGeswdyzakxoyS+N87VR9yPkir2nP+rbKnlOgvHCRAeyTZPbKruKriroBTebIWD+zgjRqpIi2ummnATitsmb3SjhBeasPxtyW96SUMI6TnjCrrjPnPIargxoc9R2cEnKycI9q4ls/ikdkAcbt9dEa4Gm+PNt/u8qnAiNnCy+NZmZLLRCQUsY8R3VAt6e4zGiqwFtV02v9HzJIWqfaHmDUjs/edUun1Lbf1tdv+mXVZw8p6g+BWLvrhFFTWJy5Zz3GLYj6nYg4G2Cmhc251stOA8IcW9s+3My5J7Zj3fc2znsRVNp3PdSkDdALiSLzUPltG10lqgyL7PAlxQgA5prb2wx67as2dOryVMp2TNq/N4C6rvuc7TSQyKcY42Jv2ADAJNI9oyVMruc2rfC1Zu1CZK/3FVi3U2WWtmjhVM2+nJIq1xfipRrWpKH0WcCtfujggpwXltNiEnVhjjOmkxARvHPluRZxhpzkmbaoYdZvbSjbcRyRkpGZCCkCL159hKvrazgn4yPg/aShyGekHAu4VPaSDDjfo++v0XUHBN9h6Akx9wK4aV8lMBIyZpIc863Dy07+GeBcAc6218l6/Z1KxTXOOWN1B2+c1gvpQjbaDzvXGsmj4DDaT96rtGA5ISNTQ5hZtKS2c7U7Lv62Pm/9BtLnJQD7znPFAdSeep3u7zBPI/pDB0/XyBwEG2dZA69efYTb21uM41jAynmeC6Cbc9Z5ZpFhGC1hZs8BZM67dikv1pSGcLYoT/Z5aYsCueSWTsInRQpzy35cy5VdJxPqCc72ua08M2IytN0Gwjmv6ZdIopWknJCVKOdKmG7WSNIiq0h5eTFLSHFyy7hHRkQx/pvpNG0Em7Yt6316ufbTIiS2tbEFIV3pG0j7kKtTAQxOtj8wmOXEa0pRTo+WKHT16XvOwB+6LPYnUv3QEbwnOBdA8IizhCnnFMFJ1sdwlcUZBz3HqI5tAEizR5o8iBhhmAWAzVyI3LI3eUyR8Pp1V+ZrzgFEAc6LwyMn2XtyzvDe4dmzGwTv4LuA7srCgsvYXx0+Rh8AMGFMEW++/RZf/PpLzGNG39/g+bMeYx4xa1oWW8NsupXaEAviEBvJXhzu4tg1Z9gAQFI55aSELzgMNwneZaQJSNNWVrWlu8rwvp4sZwDTiZBSWUEfSOr+8OXxmUw7vz3lztqnKw14dV1173zffXiuxu/y3tYl+pT7zu3/D731d2ku9T2j7xndwHgzBdyNAQkOLgSkFMW5yICjjMzAnDJq7LilzFzLzRgjQgiiW04jYowYBkln015r+m7VCuqeQFTJoO1p7zXOAtT9Vvyyrji5WnymfbY9qziKnUOgKgXkPo/AodSlqPGqFwhhwqHrB9XVJc0FZ8asJCFHYRGJgDnBORJSiuIplq6q3RsLqRzQPU+1xYJJWD0bm037ZRgGjepDuLu/wxe//jWur4VYEbSOOc/NnpxF3mnql5Yss4cttbYJEQEJiMLc3NhZdu85XWZvFT1mP7dReYpT9wmFeWddc12v1ibAVXKA8wiuF6JLMv3RDkvoWuBWYsg+O8+SxqkfPJzv5DncYY6EPM5g9kAGOv8c7sqBryNczsDUg1NzkAKERbQ4Zkxv75HGCTfPM25eaDRU7tXJ6kAI8pMA7zocDiOuno1IaQaOB1h63kQodlQkIwpo+hUA43SHcSJ0/Q1SPsDjgHadPrWw2fTN+tmbV22h8prGdq5dIDgGK2FWsc3D9QvRCHOSyEBuQvCMdIwY725xf/81TqcvAZ5wGD9FhxeiMTCDSdLQ5WbPsplhhzIW9Sv1ZLiDzn2IPpw0aorYRRHIjL6TOYAE5CRaRdF/LEpegSAqngiVaWAhMHtHoCyR/ozcR0QIXYfD4Qp3t0fkLPhq1w+4OnQY54yuH9H3A2KMuDudME0TMM1wPsD7JqKICjri5tkhFJtdog16dF0n6a+IME0jSKOBy7phHA6HEjHS0pEFH5CTEAzgCMhpMRcsIrrJcZP91aZYynGLumT6Y9ZoXt6bjaLHMpzh4KiEmSC6seDeua7ldt42+9y6iD5co54VEnjOgB7qCqGH9/Jew9hBWftRIwRnIPQBnLLYYU7Si4EIMXGZ9tLG9Rw0IkuBrZCYQSV1KWlKRI/QdaAkqXetv0yOt4fOWlndEmay7pF1rNqoO1vM1XwOLWHGcCkiQs5KdoOlBK72uNODX2bPP4aJ1zmyXxd7rkVNtnYDjFHxA8O8arQivc9JRKg6hhUskHXL6PsBXvG71ESkI1J/j65jQHURRrFtvOs1xRmXuQyVlxJFMyGvorqu97v14cqn4M+X8rRyIcxcyqVcyqVcyqVoaY1/UdSdAB8sp1NBaxeRlDV5wT5bO87lMwAwggQ1YXGrMp2VAe6cL44B+/7cs9fO4KVDNzTvhToRWmXKDJTKkAczcnab9xm4tAukOK8AVXsP9NmkTqceRBK+c55npDTj5nANMz3t/SlJzlrnKphe3iUvXDiV90gLbRHF3vr/fNl3lnDzc+89chJPjMyam3kuoX3tuodf/hD5wb5bO+v36t/+rHVc9kn72dbJtgUz1s87990PWZZg59IwWpeHvtMLICcFScEJBSLX7yzGMzZz6RxofK6cA/jW4G5b//+/FFKnqIBVCQZcO6d5oxM2a6E1tIEaEUK+U0B81Y/r9b4wOA10a9JuhWDjYvO/Om2LAwHb+basJ1ZiZAmM1R5ogHuFHYgEZC+RHiCgguVhlnlJ6PsBmRPmeULOhOHQowtdOU1FBN3TDOiJmKdZwwBLldoTUyI/s6QbN/DOaqmAlRApvaTdCwHX19cg8jgcrsV5epolOoA6g5OCQ7Y3VZCM1R/jEfyAvh8QgkNMk5BtOEH+J5Fl5N8ygkkqwG917TCxAoCP0VQeLgbBtT/PX1d1Bt6RJ7UXgSVlsunf8seHl7PSPwq24XFHnkL3heBip1BzE90nU170Cpf/SbH7CQTP4t62uc4A/vHffox4+hI//m/eYOgIRM8A1wFZ5lrnOlxfX5cUfET1tKOBa4BMbZnDuv6Lf0nXUmkRFzC/+KEgp/zaNSDPXJI0W1njVV9bk2TaiHx7QKNTQrOVtS5ZQ3gvSTSmWxS9hlHCRBMcLLJKTtYnDE4OiRg52zq0SCI6skqQcQ5wjsszzBkkILxFkKoRAlrdZqn7LWXhJqz1jr61dn4ZSJwbALh+t9Rjy1pjIEaJnBNTXAKdcEquApRLU8anTYPxQ5eFjgVqQuRDx8FSjTmgk9ayY/zpvwYIjMwRzEe48Brey1nWX/+Hj/Hr//gxfBfx+//yPyH0Dsf7hLvbEeMpgajH82cv4TqH05g1PQqV9GreA4llz3VOnFM5E25vJzAznv3RCb/3pwNunl1jGDoNiNMLQf404ZtvvsXf//0vcLyfcX39HAGEb1+/RXflRR6W9SLRjWwuEZbzxkK4I5NIfglBhuSFzJmzA7OHRJkh9EOPv/yfJjC/xa/+L49f/c31g33/s796g48+m1QPdOCc8Dd//QJffd5/4FE+X9pV8F1n31O1xL3r6MFvH372I5ZN8zvv/Pb0535/q3JfG3jofdRcQ1jKQPv+PweXxc9/PuLP/2LCiTt8c8pw/TUci37mKACUtDGKB0CiAawxg7Ue3TpwbE8ehgHDIGsq66EXzoxpmgo2ACxlYXUS8mJfsHfI+l/uuaTr2PaS5X4ixPfWISiRV4K8K60c+dTaZFsMIGfbF0WzsUhXWUPxeMUw2iIOOSEXt3tPG1GGaIUPQVNPIuFcEedojdJTou0ofnU6HdH3Sodw1aFn/WL4UzbvPeq+ve5De9+CCBR509a2bu295fOyUt7Nxl04ZRt94jESxlOL6Wjee3RBHKbMrM5v0Scl3ew6ApG1P5e5P44ThitC5zvkbHUVZ+twuELoB+BqxNXHv0KMX+L0f/4c6cuPij66bkkeO7z9P/4FQED8+TegP/sS19eSbgbwqAfyPCR3bcKrnwNXP/ka33z5d7j73/978DgUu8kSLRX7SZ/i2MMptOccAxQBVALrU4vpieZAL4jaA3rWY6Mnh1jad4h9QJBIT1nnc0BG1xFe/69XGP/hBo5/hCuwjFIM1W6B7QINzrj6bW3HlP/2Ed2/+kfkkDBPGfe3I16/vsUwDPDBIWMGJxQif0DApoWKPa1tDFiNbG17eS9p+iwXAuCCtIg8ur4H9BARyCFlRkyahscFhK5H6Ac8e/YCb968Eaw1JiAI7uuDRGvJmtprYeNolBKrm5FhmBl912Mcj3ogxohiV+VeQNPAcSwHHIgsCla3mQuGoUp/uOanU/J7a1dJZJmUGgII+TqeBHjHRcyInJRolkJYSYr1VKzXiC9tpK09wobJCZvf8n6L3iuRoUyvFVJGByJgnpPaoRID12kqW2tb13Ug53A8HnG4uoLTiOXOAYmXkXkNf6YyK4VI1Pf9Yh7J77bnLG20PX/FsrCQO5vr1vbxPn6+nOLrZzLL4Ujb69a43rlIKvvP34943vov2siW8lnCNM0YBkszaHghNWPe4uKmF4gMdE6jGuUMWIqv+uZla3MGmpTkFuHNez2QkDIkwiuaOa/pmWi7r+5h+nv+kEt5v3IhzFzKpVzKpVzKpWipSlT920K8V6fV0mnR/mzLQ6QGffpu1IjKpgaKF6upX/v8ts722VIxXpl2ZIYrNsq/EQRa59H6HfY8i3RQQgVDT4lSNbBasIxZlOBhOCyMnL4fCihE5vGBRJcw0IbsFDUByHLCDQCIuaRk2lMQ19FXnHNqdJ4Zjp2yHLstULZ+t7ynU0dUQowTzNHvvbL3sz2XxCGlj5SUJ/oct5w7jxkKe2O+B2DuPWdPsV4bHOcIKN+HYl6Mzkeua09DtJ/t1evcCbkzNdj8ZSCk1K8aTbZm1u976F32XQvitmP2UB3PPe9B0On9MMMfpDRLf2PAE7DIOQ0IYE+NnJH7ar9a2TqZl9GAKgi+LaVfFXizZxmwbU5syxu/GANzXrdzYtHAx11PVAz3Gq3KgKq6tzjkJCC9ESztGVJ3Qhd6JbEEGDjhiJATJASyviOlrI5lJSIqgGR/e+8BaqNJ6VpFHYd5jrDUOCbjuq7TepF+7gBi3N/fYp7FSep9gCOn4a6NyiLtAjmQ82AAp/GEaZ5BegosUsaEhBMlzEhI1JAegHJKsI4BhDTT9HKbrumxQs1P0po6NsB/e+2aTGNAsbVuPRNocU37PnOan3PrvV9RLWfx995V3LSHgBIe3n631Evreu7vnChkmQACcW03ZsI3//dHuP/1c/SHgD/+1wzf6clPnSNd1y+cZRb9pQUvraaZnDrn9ROqI7jsad6taCufbX+y/cei2hTH3Bro3rmn/UckBLjWB2bOqbUT6Nx+vuc4WlzrlJRjcpNUZsihS13LCRLhTyPyoJJlUs7FiZgSK+BrqYwaZwLb39VZ19azjQqwHiOrbtW5l/3XqsrUeJDkMiMlu+Y5EjmHmdF1nUbJGgtxSK6rTp8l+LudA99HacdoPWYMBjmJFgNSR43uRZwJ85zhKMN5IM4j5nlE5gjvIw5XE/rBwTuHF394h/7lBEZGdxNwfzdiThm+C7jyPZwLoI4kOiTkVL3su0LIZDjkTJimVOrsvQd5Wfeh96BAGOcRp/keXSd2wNvbt/jqy6/w5s0bxJRxdX2FEDxSTuj6DqBcwq0baF1SsciLyneKqOvUonIS1WwHc37L+g1w5IGgjiMc8Ad/NuGjn9wCTMgpqwwBSPcXRw7PPxkQDr0KKwZ4FB48amq6Dzr27/n9eoo+Vc3b26m+DxXxAZcJAJO6jTPwiU97+j1PKds9712eux0DXvz1n0tJYIw54zjPuL1PyBAnL/OMOM/wvNwXGbYv1cMha9vE5Lb3vjg9LTWHrF9LDxrQBV+iTdm97c92v9ju7yj7frsPA8u9c89Gau9hZsQo9RKCS3UmnrPLvPfNyXc7lV7JMQQnkSv0xLoQdxtdABmOPBzq6X67d03cJMVWyDl14m5tO3M4epZnnU4nxDjr3p7R9wPG06iO5YScl/aP9EdWQj6XKL6tc/SpmMQ5x+VeWWqWTy/2XNOV9sjN3+WZVT/kEtmz6zwc0Ow1lmZ8bu7ekcosBKwYZ3RZsCFGQps2pgs9ug6yt3UZ1/4juD/7BU7dCfHzPwAvZGZ5MhDFLrr/hxcYv7xBfxPw2b+a4QYhg+RC3JIIB0wEBILrbY83vVBiSubSXaK9JyIhzXhIlDsP0Ud2heRKf1nZuYZnmvT++v+N+PL/mRA6xo//W8LhRp3CWJJqHhpB0VdrGiHDNUF2cM8DSkyLeUKaPHgSoor9z1prNpDFzip93Oq39ks/4eov/xboCZw7xOgxxYQpTpjuI+aJkRLgDw7wGWNS/SxHdJ2HJ4JwrNTiM50dssZN5Wl14rY7DXey1HgW6cUZkUX7IoQOzhNSZsxzQmKR3SCHrgt49uwZpmnC/f09UkMk8L5b4BRru8MwEFtvdjAwhIB5coAPkJTZENIHoUTPIooLPZtzRiz4LxbvMdxhbT/YuBtxrf6r69fuNZyOnMpOZMjBo7Zdmq5VUzEJTpuKzBPy1ZaQWebFan8hUhoMZyVEOMVa6vUxzjjenxC72vbJTUhzxDTNJQqKt3aVKMIqh21vsvnA1YbSxpU+UwOvYOnSd/WA1d4hgT2bk/XZe4cq17/v9dHeGDuN2iLnm2T+2h5uhNp2jJ+KN69tzEo8WfoFbO/uuq6sIUMFsrVJ+6/VPyxNlh11snReXlOiF+xS/yMRZrbojTze2mbzxaPIU6rPcCsNs+3bvbZuFIRL+c7lQpi5lEu5lEu5lEtpSmuoLEpRjtpr+cHf90L31+fvERjMaARqJuPm20bRWyvorYLbKodmlHGr8FOrYKlzpH2epgg450xuT0fbTzNYQFVxX4NVEqYYYDWISR1M0zQ3UXUkOgEfxNBbGCNEQMOs3wPp9n5/qOxdVxxZmq7EOwKKM5ZWgEHbXrUzmdSAcaZrwwx6wIAtau6vDHbz450De/bq2xoHe4DW3lw59/da+X6oj9bvX9fpsWseNkC37XvKe9ff7RmB7ToBGrBchnn5DlQjZDmft3Nvbz1vy7Z/27rttbE1hB4a/4dK2175e69+D4fzfApI2pZza3C3nwjFKJWT7CgIYXUe52Ze1JM9LTGmPQm0fP+279rxTDugDWBgrkGITXWdrXsbNwWAsD8/oDIAO8Z/3Segf1fZ4Zw8yzWnRuv3lvfYZLzNbaf7jD2jDbUr8pczI6YEzglJo32xhZBuwhLXPiYNC6zPsDaDF/PTIoI5UrCqgO6S3krIAHLq1hzZOcupTc41JYcjh8PhRk7PgUCe0PUBmSbkvwAAIABJREFUCR7ZMbKSZSYkZE0nJJ0oJ+92dmtJj7SI0vK0PaItCnEWuHVNirFr6rXrT7WvmGDTfPFsriBuqWW5rj3/+GHLQ8/k1W/1FJu4vahpG2/u2X8eQ9M3AYhcUtKXMt51mG579NeMnE4Yrjqk5MARyOwVFA0w0oOsfVag1uvcj7KucxIAnrnIECOGSMh6q60B73XutzLCnCPn9hYDhveIMQAK0Lzdp5dA2to51X5m9xSCQKN/yHU6DmxtAezUeFmv0DWeM8SZlkq7BbTTtBBKxrMc7pkZMTJC0FDa5US9zgrSGUHLeq51ku0eUx0fRCjkmL39VmSs9QfD3BvkAFdSxWl9c4REB/ObvaMUqouwrc9eIaIixtef77VtTwd6TA9a1jCBSU6hMss6SZM4NY9ECN4jeI+UZmkn5CT4NEHSC1GSZ7ij3PM2YxozctK9wQuRMaZZSGW8XuuExCynj1F1hgyGzwFdcAAB0zzh9PaE12++QQhSp3EacX9/RIwJPgT4IKd9U44yb/LawQZdu0bEavoSUjFWGZ4RwWlJgpbITklPGHcAnDr6rtBde4RrDfe+SHug+5W2fZ7NbpKLGO6Dy9oPBWGf1zTP65x7T9nR3J9cx6dcZ/vZ5nMyzcrKmTW32cW/WzFpuS5P2a+eUnYspPd84g9X7u4jvvjyiGMi3M2MFCIYHjlpmoockeKElIW3FrPtWCbX67PWMs9SpEq6QtuTZC8ic0QVZzsv5HTdJ+sBhXZPNn1/kRYIdW+gxjm2xiysmO4vz9GoLyYXLIVo4zw17WUp1x18kFRMIlaUMOMAH6wOIvOYq3PeMBbm6qyOMZZ6tumnik2jNVhvI9Yfzkna1BA8Tqcjjsc7SGTfAEeEvu/l8I7cVJzKOdf9X+pYI8y079jqIMvvl3Ys8JR1YOSIvWsfsjnXe2wbjWfXVt61ebfvK4QnEpKXEL0IHgHsa5SCGGfEVHXCguuB6l6qc3GeZ/jxBIDh3AEh9Oj6AcH3GtkoA9whuGdwNODFjw9wX1/h9vMtgb5tBQHI9z3iPWO+S4jxDbohADSAcABI0jPJKnMg6tF1z8GrPmdAox3JUx1I/gZEz+gcnK+EViM52fiUFCRNLSUqAinBq5LDmYHxNuP2i4SuB968vkemA4ZB+sWWC3gzBfVDGysAqOnU1CcNsB70IAZTxhzvcRzfIMUAoG+e1BBliJH0d/t8O1vkPeSAw48mdM965ORwOmZMb0fMEyNOQIqif3c+ACxRpDxJ/xHEzl2SY+ouVP9epiS1PhFHuOk9Sqx3MpYxJcxRsMW7+yOurx1AAQniiE+ZIGQij9AN+OjjT2CpOQWaMOIfNQKmjrGlixMSDC1sIuccwjCozKyDZhFrW3JiTlB5XfWrdpwrnlHljOlrcm2L3y2/t1Q3gg/VUSS1Ex050VFD0JS2Gi3T6SEirtG17NBmux+VucO8kS8LnK7sEYyUVdMp7wCYHbpuABHU3lIy0BwllRRJmmGT/UmJem0qdVrgZASQU4xG9zxQsYgkPaH8853XtqNEJG1Lezis9L9Mz41PY48Es/mbW/touXcJMVU+3LOr18Xm3f6+sD3ssIeNt58bZtX1ag+tcF62e0jWhCt9wUKu0qVi+2dMqUzmbPWhcnsh2uhD4V3Q30SGMhMOhwNSisu+P9O/68/O982lvE+5EGYu5VIu5VIu5VJWpVXKWkVP7KXzCmKr6LWnhFtne71PgJbt564omRtz7YyytFYwW0eFgErVMCN1TDkStn3VuM1qsjDBbvO+tUK7Vqq1FxSASY0hY4YsBNHX0+TItTst1KT3krYp9ISUM8ZxwjTHxftLGze9sTVqNn3WIA9rx81WGZeTBcbyr1Y0SxuKEVfnSEo1TYJEVsjVcCuGXEZxeJf+WxJm9trzFMKCXU6rNj523977zpW1U2hvXtT6bA2rhwgg5e/Sju0cPNcnj9WdiBbhrhd1N4CG2u5fAidbI3lrgFk9ynjulBbw3fvsXcgq++1vSFxnobbNk8rzznXjQ8bY3piv/z7nMFxXQ9a2Lbj6zhKRq5lvLWnGrlk7qdv2nQM99gEAO/WlIHk5eyaySu5riYgVHHRuGXliOVesRgYK7YegXZf6USXZOXV6mlOcGXAuQ4gA636yEMQZmbIAvvOMZCHtQQAruKlvWjoajJBgY2qgQp273geJ/kGugHExRjltpe9xnhC6AHKE0+mIaZok+kDK5fSYCx2urq8BCiDvEALhcNUjIWB0wIyMWdMxlROBrHsCE9zKIWcJmrghzZwD6R8uVER0paOiPKkZ5c097ecOjFzIPQrpcZ33FdCWk06Jvp9IB08tRf1p/kkhjTQj4FIF3R8mz1hEm6zr2zHgNU2SwqCQ07iMnE8g6jUiBYO5RlKyqEuAREuRNW0pHPRphTCTiy5E1KZolO9Ki8iu5cXnsYCWvFlb5dQl2Tqo6X3sWrvG7rN3ne1zVTqNRN2SbWp6iG2xNm16PDcSjK33KyBcq2Kp6LS/SaWf9knOTsFCIx2VNyvA58RRsJL354C9ZV+QkgQXLVruKxvdhiVFiALfSR2bdmK+7q1bcuJTscWyv0EUhPWe1s6LLSHocd2t3f+rvTCXijIDOSVM41xOmBrpkCB6s3OEFB2mEchs0R9NTmfR7dXukJ7W89ScwHACDu8SHBTQVuSXEsBIYABzjJinCW/fvMZXX3+pEcUs2pJDN/SojhGdawlKXqxjfq5/mAFiIwqy6GicZJ9aOc99DAg+FhImOULfEcgNsLUi79H9lQnsHTII0zSBGepMYSA73LxKMsedyOmcTnjz5QHT6bvBp98HjE0P/LX8fGdNbe78/skyVcRIn9Z9xfa9czWsn1US8/nS6u3nrnhof/ouZa1p/y4X5xivPr4DIyPhDl99c48JHtEF5KipyTiLnpJmxDghJtFZstFkHQow0srzrd5pWAE1+7LKPADQiFEt0WK5VwBFg+NtWr827VIl1eSql63sgbWsOWeLlfeljEq05kL89qp7O+9BzsO5IPalvZkIPoRq/ztphj3f79hubYrJti9LvVJSHcNJ9sTmeyEOVUxhniPmOaLvJSIcc0TfS8RJiUyJ5VjYP9tPeUmOaSP4tY7Tsue9A+aw6P/SY9vV86ADkOsqrpGZt+nR67P0XUQ7i7XRF5u/jQANABZFqBBm0oyco5I8LVRfY0MblMESvfM0ys9hAIZDj74PCK4HYERqgkOPlAMOhxe4+sQh/mFCjhHzl4Mtk52eUqshAa9/GREOwOHjjMMr0eEYQdczwfke3XCD/rO3OH3+HOnkm5bXRKWeCQFOokB6iZDsyKEVltaXRFTmNdppVewAjepJclDDEWF4Dtz8OCPlCcfTHbpRokaWFum1zOvoQ1UHlDGuhzvsHZlnSDq2jPk+4/6XwDQR+I5WBH/RgCNYj10ASS2T1nps90aGproJNxj6a3A6CMmBgMgzgmfVTVgiYiLBOwdHAQySdDvM8Dv4EHMreyT1JlG1UWC6W7G3jSxDCK9v4N4+Q34RgE9mOWwIAjRtVcpJbOnAJZrg9fUzjM8nnI4j5nlaYmK0ImcQIcao5DuJxjFNU4ke5pwrpKjWZrLnWhQaw0xFXktkw3pgob6rYj77+FXV34UQRqKUl34CmyxtCAoMjapppKCqOzon+1mOsneIbOUiY9bY3xqvW8s8O4RQZY2RdiRlKAG4urpGSpKmuuCSDPR9X3CTlMVum2MU+Fyj9UrbmyTOFi4U1W6EzleLBkpOdHwjK8lGmzey3PafNsqpRaqxft5r8zlbj1bKmty2JFa2++0Sx9zRAR+1mc+XvTqSI3iySNH1X3NXtVMUY7DUXxK1dblPFRs/i0xxxe7Sd1LdHAQntLcwvAO6LpR5mzlpdCIZu3M4ett3pS7vuA9fyvlyIcxcyqVcyqVcyqWsyj7gjaL4nrunVZ7PEQXqn+K8NDZ+fdW7Kzm7SmD5bP3TDJKMmpczgzmq80RAbQ8s2tMaU3uppMRRIg2pMKhr2iV/O/ILhwOI0HfDqt8YIfQIBKTMmGY98bzjgNlzSpxXmhVeWX3d3rd0gKiJTIC5+FpCh1ZpcW19qF6m13Axmmq0CHN6l9rt1PucwbBHPjhH5jh/zfnyeF9i1Vdb4+ncZ3vf/dBlAcSRoTs7dTJZ0HxkgELbxds27QN9ZfrsGJzl2ev6NXV+qD36hAZksXq0cgGPihgq/XHuu3cr5+7ZnixUMgKJ8bjX3ErM8EtQW2VS61Reyy67tpXNBha0eblR6sSFHGJykVGjdQk4J8+zdCyC4bVATBsiHos6cK5Gs9WxBSmsT2q9VnWn2ndLB0J1+LvmRIt8Jr/HPAuRJWUFxxVsTFzmzwozaGQ0FnWS3wXAsRDmjnxxKsxxKqlzDIrsugMsRL2c1kwFHPM+IHQdfNeBKCB0AT6Ycz+K8x4ZCRmR5KdCQyiUEwbauMWWKkdO/egiIBvlpxV7dvlXCC7tSNXfDYRedWP5rwMreEblWnsm09J5mLkSF35bpa4Mc2BTqQ8RSsjgJbWsvXNZcvNEIkkNEbiSZsS/lJHTBM4TmD0Y3Rm5utQDWj3IkQM7G3ebq/FMK4ui93BfrGSPrefss6Y/84u1+j57XtUhlo48Wq3/tjhHCyAUYDBlEAwcFFIdNBw/1BG4THMnUf7kHRYVwEZYR5ltpKwuCqhiCSq3fbaWx2ugsW1rC/7ad1Se0fQRIKdBM/TUq9xHZcNb6yK1bx8r7Vwy/fGcXvagg2/V3j1dqIwvGBwT2ImXLGdGTnHhUO28RBIAag9lZqQMzFEdxjZezAhdTcunbys/xSnQUgCXHcNZ5g4RgYmQ44w5z5inEafjEcfjEU5TAxS9sMyL2h+F/KXy+klrokyBlowETc0Xi2PEuYjovTiltJ9Sr6kM9X5S8NoG0iXps9NxBDPQdR5dxwBP+P2fMT4LAd3gEULE8fQF/sNf/xhff/7u8Ol6RjxVi9qXRPt7zkPPWN+/3quK7vXI/efedy6SzIP3caVFE7Dhaq3vabXEJR22nclPK+96/VPLuee9u9b8/ZbQJfzsv/4CMU+4vSecpoDsAICQOIKJ4YnF5ZtmJVBWGeG8A7GkBlrbzcByrzIdlIvcXOq29nshGuyWel+rV5v8TCmVCCMlRQ8zkJZkHNNJW1J6axu5BcbBxfFpEWzk71Z+a+QIFyR1aKO3W1qnDY5USt3jjEzbpiExndn+TilhTrJfE20eVuoU44yUpO71eVLtkh5KAswV2VnrovobZ0l53dS/7cP1mJue5Xbq9L7l3B7BzR7yFByo1QLWcA14O29tvoptpzOQLeJPUid3ZbGwRhZuJSqp7pRTxowERkYIPXKekdIMRwHed6AsulaERJQbR6D7ccarT0ec3t7h7f/2KZDcmZUjrYujx6//7UdgMD79l/f4/Zd3ADqAepmfDDACwqHDq//uc/zzv/EYP39Woh2JJiekd29kGclLiDbdpti/prPpGihzPZd+ExIqlwhQzEKWcd7hxU8c6GXC27e3AGrKYefOk6xrYw3TqLpoGUzVix0cHBLSV4y3/+ZjOHwC39iH9lSGRLpU9LPYJCvJ1Iyn9VEARwchawR4FyCYqkXIrUSeUnG2J2udub6pzlmcLaZ/1R2z3vvsV5/h5s0nSL9/j9PLX+HFixcYhiv4IGnj4jwJeS9FMAPzHDVaBsGHrrHPCcFnkMkM1PGw6N82Vsxc5ItzTuRvwTGocMhaWSYn0nx5rhCbbOi29oGMtf1e5ZT1gc2XotGovOLSp0YAqpELLS2rrWvTDy2tjgAGXklANWLInhyqKfmW85TVblri8BXvjTGhHzqY7WRrI/QdHAnZMedciFU5ZUQkeK+kmQ1GVPdPGzes19GqjoUAv2OP2VhLXWN9F5X/LGyXdfv3ZPDWNmrHcu/e5WePY48EQhu9fVn29gibI4xlG4Q02r6XSp9XPca6VGSOdwGdRucX4mwzF6uFtqmzFcMBwUDwQaRRzmqz2MGZZb+2P/fsyEv5MOVCmLmUS7mUS7mUS9FijlE7gShKkQU1BLZeRPu4nr45R5RZGuGAAdetY4A1D+ljiuEeEWFPeWWu7ylGjDoaUs4KDlVzszpDDUB/mEm+VtAae7DWBXbap5JEWvCLM+Pu/k7SgajhDADXoUMXeoQCVNUQwWIQf3hgxkC01pFOxCWfbXU2aF9zO8bWNyh9XGGIekqEUIE+O0EiIMxDhsXjBsPWmbbPRrdnPVT2AItz5I6H6rl37/s4Dt+3rOu7AHl5d2k3ZbUGGsdg+zxgf/z26nJunNc/36XPzC5uDfXHDc0fpqz7fuMgIUBOoyc8VMxh2Mrbc+/hRmbsGeAtCNzea6F9c0rlcwP+7Lnree2cApqZN++Rd9k+UYHods8RuULNz0p2EkCqgpHOeTjvEWMSoCUEAcL1nmmaAXVsmEydpgkxJeQ5YYyjROSwGVz2JAMNFRwsjgUB4BMneLaoNpUAKvVyBTyzNBdEQIoT5nmq/aonKmOUk1XOOUzTBEBCxg/DgBB66e+uwzB08GHG6XiHu7tbXEcGw2Ms84QKN2Y90xko5BMLvd3CrE8ttPhHjzoIN/eykGDs7zaCTEu7KU/VSDipoZX8rpSS3IcyEgge9WQqg4X0Q+bQAKzFD7XDxidS1mSUzd1OTmkxKQi9F7mAKtHIO4C9XEfkkPSkVwW7LALYOkpLBWLfpZjMSCmWKEpd18kTG51sHd3Mvn94KjWOrEYfa516bR1KX+zsIxJBykgRetwdDgRJxbY8mW31y6JvOQdPhBAcvOsQvJ1adyCqcJI4TDSFxWrA2/1uvadVWb6Ux9YH63YtwWLIOyFgd0oWJt7DZE0lKUtfWghtenRxrfpR/nhvHWaPLNN+x5wRedYIJyj7RQjioABDnXbyXUnZp/MblDX1qbYVKnNUv68tg26M5tzbb5et4JwZcZ5wvL9DzrPIdao6c9LUJl7DvzOjEEPJVflp89ocQLavLfcU1bcX+kvrNAKEtCWfm7Mus0NKchp6noGUakQKcTrlQtyZS4S16kAhAuZZCbIM+BCA0MG5G3FwFlm3lWpW071epJ3ftmX/eet76Mzv6yc8UWtcOBFLpDYspSGfWSzvQpbZbw+X5yzqTvVz/WWxZ7Z9bzPiXE2WfcKbz77vYnX7XdnLMwO3R2CMCSkF+BDgfIdIHjFpqj4kJI6I8yhkPSZkeDmlDrfo7D17s3UmitxZphnUO/HYfmuYgUVH3DgnuZJWzZlbDrisrltfb/UTvVWJNNn2o1xkkOnQIquEMFBkleq+fT+A+gOSRqDhLFpmiX6pe3cWoVieB3DZe404Y+k4rE1EEjkt5QTnK1nUHO/2d84ZHCXtadd1OBwG9H0HZm6iPLQOuLWjrYnQKaDQLg5kRIhlhGEl/myi9X0/s74lBLe4zbvazLUYxmNtXUYBYRZH9zzNOj5pde8aNyHA5go06nICGBGw6G5oSMickZKkp405gyFkDHKHoh+jvMX+a3JQfrMapHTElO4x9FfgbLiig6MOATeafjeUWhOAjl1JaylkGfmXIiPNGdwDbeRpw62cY3X2AnLUjjHPEW/efItpmnA4XOHm5hmC7+C8Rwhe2/wMV1dyWK7ruhqxqWBvZrNbq+q8knlqlkhGiVJCEv3VcUKKJ8QZAF6hUmWqTBDbsO7jVUuqOrDTf+2+5diBWaI0pSzRJqB6DhtOqTocmb1iSz4vI+YsMISn2B2Km0jdRZ91TTq6lBJO04ib589KumZLcylRYUbEOOM0ik0+TREhdEhhxjSNOh8rPtnqv4Ix1Che8zw34ybEClsxEmEHwCL6l9TfaZRxO0jksB9RV26v861ipbmZF/adkWmyTpzWjnGaEtCJTZ1mxCSpxoa+gyrXFYthwKLPyBgBa/lnY5dSKoRG65uUEnKJUkOwFNl2uCDnJH3lSe0rlVda20rKy/C+zlZbb6RhXOseZhFzCvNIu0V1cDi1/RSaIoCczMN1hPh2T1zv5/LnPqFtT94uSR1LzXht02Knf9fv+FBlg09DbFXD2nTbK9zHMpWYi5wwm5iAEiEvhIA+iHVwOp3gnZf1TyqjSWcsrTGM5RzOOcEHb8Kv2Gwy9lv7vu37tY19KR+mXAgzl3Ipl3Ipl/K9lxgjfvGLX+Czzz7D9fX1b7s6Z0s1vPdAbOD/Y+/dmiTJlfSwzwFEZFV1z+XM7O7ZC8m9SjQuZZJMJr7oRX9dDzKZyUhJZiKNRq3EXZHSLs+eObtz667KzADgenB3wIGMrKru6Z4ZioW26sqKjAuAAPzy+Q0KTszNDCGXDitjze1BgDRlrx1/2lnmmnF4z0lH/kZXmHYMQ7VYxV4ByJoQSCSZYHgfCJsFtPZ7qm8KsEYcCZhiUWomiRposy4HmGMSEWHLGW/fvsWybgARbm9vJQ0uS43vBsDvzM+1+TMh2EPce2Obf0rJCFQmQVWzNrToaq8smOnQFKHQxiUqcWgKn19nFqGDnTUwK9LXjCx73107/lyHjr1zLxwf3HmzArUnvO8Bnj9Gm8dD8lInhW6n0ThOfy/szMWecj3cbpqTxxScvWdeGFw96DIpuzQB289t19bH+yhh19+9AorNINod6mYHOVJt0wDqbdua8dLf04yjHrAHgJxrU8yJJFW6VzZJr22OayQQZa0ZAEv2iJqR8+ai4EjPkSjcfiyAYo+4MxrRwAkFeuy9CVBvKXCD27MYxjWDwswCroYQIEFHHXhY19QcfIgY5/OG0+kBpWSY5s7VwP/uvkEhgKsBPjLOnDO27YRcNsnUEft+ESwutugXZpZsMZpmOEagIiNELRcVCesh4XS8x/F4QilFjRHi2HM43ODu7hUOd7cI6SC8698n1H93wE39YxzKHyB+9wnumXCigvMV5ypdJg0G9c4ytuKe6zRD7keiC+0Neuj6UjRob1rBkdmw6B1l5n77Vol3zD8/bWNIbhICo9IMKkuzsZD767ER9HejkcMAzifC//U/fo4lJnz5J4wv/rii7hhoxRDVnd5ilLTGoUokfAG3KEfb41edL54xz54Wt7JQoaest6i8a07U79LMOOV5aoziQNfBNrr4ueBFJDSp1F6uYli85uCgdEumk1rJNQEMAUJFIfHUYGdYtBvJ54oYQ0th7cs57MkTvZ/cnBlGWQJtvIECpKSWdbwCJAYoXzJCLpd+GV/QaehzVOvVbbXLlxtfHXnau7zbPXBz/l5A2aXLiATEuIBrQc6MQAHROQSJTFxRuaDwEYjC+5klbX+giB4ZTuqcYDRb1oPPWHbZqQZ1tymPISHe9Iwuy2GBlPuQ0i0BVlZE15QuV4aUhLEpbLLxxX70czLuS2rXCiUSfi3jlQw7kDFXMaDLHPh3JnqPZKbIaignPJwqcNzAvIEQUfMCcADXhLR+joQVUQ2g3djW23NWwbVz9rWa57TZwaW9qeHOe1Ku521ofK3TbPJXv4OTqN37saPUftO06nQmfECC/U1+LJcjfbq9+xUfqv0cuPcnv/gKr7/4O1Qc8M3xjJBeIYYAqlKciUlLCGipNuINMVQsaQFTRK4BmwZx1zLS9Fl3HugimXwPdEcE3UDPoJ3NmOVopsdW5kws520TJ6BgPI2v0ltvNJQyJ9AMLTY+dRYvFdt2Rq2lZVoQmTYBILx5cy/9KmLwWpcFKS1teLVkZJbseyarRH226SrmSG78KsaoJeYETzgsqzpR9nGBtRRhEUNsjFK+dF1XxBiQ84bT6QQAWv4UWJcbxLiqntSNxe391SYI7Moxs5xhWVeqy745Yyt27c7bxWN07zn4gNeLRnlifIw/NHzr+teN9J4nyRUxRIQYEIqUOpdyJ6x8tcIckq0MijCJ2ua3lIKH4z1qDVjXjJtDBXAn2dk0owWHDUwF0DIhOAS8/mcPIL7Hw7+/wfHfv5bslDvagtHt7//vT3H/m1dINwG/899+i+X2gIAVAQFLeI14WBHC4nQgoaZRMzwGqMMME7gApQK1iuPB8XzCkpa2/vseqXh4eMA3f3vC3/3bhC0TXv1BxvJ7WfaACgLbecP9w1ts2wl3dzfiYBsjTqczcj7h9vZOdUIaRmX6tsl7wsM3cN2QS0b+KuL8Lz9BIUZBQOWIeuxXEo8rjYd/oz5Iw1MnhxkiLOkWh5s7vH17xv39PU6nkzicsDlkiwxtMmitVRz3XWlkcxqQ9cUgDSq81iozuGTEJGsQ6ihEIeC7f/TXyPFb8Frx9v4BX37xur2fbcs454qcK87nDdv5jFoKCBUxBLy6u0MMQnvM4f/u7oAQEkrVvk+BQwBUXxcdXXDZipBCc1i0cdm1MQawZlCtSjNCXLAusdNojBu0y7YYjo/YjWFDlnkYiq92RyJxLBQaGrRsXXLl1sRRRuhWqQWnc1ZsSgOdHD3Zk989jSzFynDJmhdHNQ0UKrKGlmVFLR0jlq3hAy0AIKvs6oJUtKywnWO6rjisSY7XUSZ1fG3ABs0xRLUAxUIJnR9aadNeAlEDwi5oK7nnjHR8H48eeYro7pf2E8P3hmNPyArPcTrbxddVP2H9PpDoDGPf9Wxqs6frpssI21ZRS8HxeJR3E8RZiYmQgqx/sEY5OIc0+10LcDqecHt3g1bCFuZsW3dsLF228f18T6jhpV1pLw4zL+2lvbSX9tI+egsh4LPPPsO6ru9tNPgxmhcmpZuqNhkyCkCEJPndwDfGIJD6NgiMPMe2OWcZ+0dOgGIv+D7WcTRFDYAadA206NHIVlvWDKRNtNY+wMZhcRUiGeopHXDyCsMoEPcON8EYowOSKYyi5AioEGIEFNgXZaoi5w0gIC0LliUBWCQ7QikoNovUn9X+NRzBjG7WJ4bmpJ1af4cWoeq/mwG+EDSe3pYEh3a9vAOLjRfnGEs+D3Rhflxj8pxmENBBdeMOtXFcc4bx7X0dHfbAxKvA03SlkfYwAAAgAElEQVS/PTDyKeeua80ruNd6/K4kZM8A2vratWtVnHaeOxlrTFG9BPn0HHJ7w51iiqkZAH0/ZmORVx5/mEMR7ax5681O3x+hOB+Sdg/3MiBLQY+WHtt6yT1lKpEY+mot4ppG5HrOEkJDasjVustMpBkFFNwHNQNapw8jPbOsLRytvJGCXVwBNQQKICKfrbSeAQ8GktZKCMGiYhkC9kVVukPvj9Jhi5jvkU59fRhYFWN3rJFjgBmLbQwWrVdrRikVp9MR5/MRtTJiioghgbU+svElIhlTgSjoBhCXUiQ61Yzg09YxWi99kT0kBoGqv42/EAgJ4ITT6S3O5zMoAImiGiBWrOstDodb3N7dINeT1F7/Hoi/+gSRV9xAHDkLZawUJALS780dusHDz9PrfFinQHMGIYihec85xM71nwlAMGcZ/d+eGqZzLyQDdZIpMLDs59dsTk2WMGB5Bp3fpe/9Wr1zJbz59YrAhE9/WZACY8vtpPEax1dDiKjMiJXBpaBkuagqeF09wAS0bAadz+p+Bg3PaCTe0fDeOk+fHaUZYhwzYNYAxndpo6EqtD502rDvAFwdUN/6DgiIa3Iu9XI5dk3bt6GXgJCMMlF+QKjB9nWPbrQoT+mXzHqLgoSNHRh3TI8aFTnYnC1GOcnB3/puajuuIpjOTU/f3kuP9tU1OsHw7rvsHIh3jqEf94ds3Qzrw42Zhyv3eTvv3cPmQR3P7R/ZGtNZZHGaSYtkDhJ/IIlEloj40N5V755RIPZH7amtn8YrvVHV5GPpq/FZGUIlkwn7++7qzeg8NRsm9+YDzOqjTk1eMDlf+q9ZYWpBRRDDsvJc4oDaXoDMRa25gctBa26wZnEAESItYKyovIDrgiUURAqt9Nxjub9+DC3XeNL8PB7WrB173v38X04THe75MXgRDb+bOWL4vi2NSabeG+9P0X4evZA2rofe0uGMm0/ukZmx1QWVovogmcMENFCdW2lR0XsTmCKI7bza5Ub3jOroQjNGwmT79tcjE3VJX7ts5HQkNe4NBrX+kCbL2jO98XqYJ6d3NadQM+bVImOFlDnKOSOrHEEUxOjJ0AkT41hMAbXq50iQkj09c5UY4wigoCXljF72fnnHn5xzd5a1WQjdhD/yNLR3KHRY+Me2FWxbRozi0BsotOj4qs6zbWqsL9N8+HljNSSj2jvuNH/UVy9l7Wbgntt7EEw/Z96QP2MW+5iCoipuOZCeG1uJXKH1UB5BCEgpotaEUiJqzS6bjjmj8kTL2p0B5Y/beQP4CCBgSSuYF3GUKhu27YhTfsByc8DhcIcUViAw0hcZMVWcv67N4X+cslGe3d4sOL1ZEG4zvty+1+CzWzCtCCEhhcOAoxjdbXoLLGsk6dgqSjmj4oj7+zPubl/BynuZo6rcISCfgG//NoNB+Pwf3uD29hYpLeLoHkQuCVFKPpnzAgDkreB02pDiQfVTwGtfUuaUANpAqCDasOWvsW0POG8n5G/vUP/mc2SqmsMntLGJjA/F2fo8WRmm7jbU+Sq5J/c5cnoCGFl1Y3Eu2JqswgAqF5W1RB8WORwqi+mqMWcQ1vVJPcMLN7na+GGXdSMRBHtgpLigvD5hu5H7nb45SiALrEwpKzmXDEalMMDiaLGuK25vDwARTucTlDQhJnk3nHVutL9dvymwDD+VK7accc4blnTos0U2Phc45zJstwAhUMeIfa00pZk9iElP4b6n27vgWdbEsL6ZuSWLjyEhxYjoSmVbNjCTpb1MPTdP4/bwcNkXXjKTSWWQvAsSfCZnLa8HLVVm+hv1VcjKPJuMa1grS/4pK4PnWJ+fviGDpvCegGjry4KwAvXzNDMkiFCKOHnJtT0wdNe5xeillUN0ARLtpQ07j9t4Gs2c9eFBoOrZKAc9wk6xMbs1MraRB/Vz9Z5eOYO9C+UntToZxvisrplqBEX4deGKsmVsOWsmJXkJorZ0/WiP4YUQwETItej1eh51+4Pv/+zAOv69M58v7b3bi8PMS3tpL+2lvbSP3kII+OUvfwlgTrX+82qjw4spLCaEuwgqsAIhKqBwaMIUiKT2M3VYoCm3Jmm1FgDNQNCMHtQLEoggeCm1D0dIRT528pGGUjCKjEFBZFNwRBExMNngRlVMOQAsRmYE1nlQYyykNjAFG4cJvWjHfN9YhcXWJ5Y7tH67Y33+AGJNa1kzuAZQ1ChRZpzsxtSVVpmTsf5wUzBND+Nu9CFVhkRG1rMV8THQpAH8MQlwqKMnTe/p36WH7Pvb1rlrdXe7QD4aymzGrL6vzXmPKtee7BtXHmnz+de89PciJt733teaf/asYO5dKwChQzeGL7F//LKXbXXYhbLGePi+QyPD6u2fbL0A8Hk6mZzaczGES0jLnyzLZwIS6fIdz8f3DKLtrs9WkN5dkXqfdfH0NWzkqMVa9NVOnYaqkh5YFHc5T/lIc0yRPRqYJO0xW5QsiY+K0Sp9cs1oDndEQSNBGBZVFChgTVJjWoCmjFpD6xfXOoA/9o91DjqQWjQiqGfNEDBLjbpEvW8s/TXSKuTQp8410MP2kurS1J0AmsGxGqjF6vBybpnQQiVQ5JbFh2wdkxg8bG2qrQSFpTBQjEEzdwiYYECW8ZXmTKOsg90e5hrAnAC+QSkJ2yZzlAKBKSPEA2JasCw3SOsBAcD2H4ByZoRvNZOJDi2B5IcDIoKU69HvzS3AwzNutbVV8FxK2tdmd5bpbk5234kW6neBmxtBO79TovEZslo7LzN+Ztll3qXPP3abqak1wjjO5zaVuCAxeRLlGkBYAiPFgrzJjBDFQUai4KgIE6LKQVsIQBCZhok0wts5HAyzayvE+LHR/f6e25vvX7S90h1sVAYkZ5hRQU36Dv2+3eJqm9Nmy5A7cOgdaGYDoHeYYRYgkIk0WwPM6w9E3cBZWTKYtMwyau2TZ2ja/JhgDqbi7Bx0HmRfN5qmmT/MN8dSkLsJBDcZ2GZB6GyTCSGyXAjc3rVc7oBPZoBJIzlNXkKjb14UZWL1nX6EGlCX47xB3mT9tlPtxVajdWbQVODY5ErlEWwyL4/3ILh3Z5SK1TWjrS05HHVsXKqI62at1PkMlEAahUotDYrJt4SWzRFAN+89TmEY4z7xPM5kZVtrpC+7Oai2LIvDBDdeP1AJt8/k2h25t06X0Xit/CsAVRTNJEN1nF/J4lCQYhJDMgLM+R2UQDEghluEeItAK8Q186EZEufZel/a7Lr+bLGW2s+l6Xmkvl4/uXZnuvhrz6D9Pv187ElP8QVbG7PTjB2beakLj7h6P54+fcj2PnzuY7W5LzEwPv+te+SakW4zMlZwiEhpwZYlc6uRCITusC3GIAJzRGUpVVSKZKalYHvFaHif32asuSb/D/vZ3sdecEZnjq1/nncEDUlptE/ordFSkWuV99UMChGeWZsp3oylMF94ZnDN4JrlXGJsmzjSMcTgKmVOkhjBNMr8sEakJYFrhMm9YkTLIn+IlQ0i03c6KtNoGSPHkq8+c07LTOtKpnUjaZUgANUTamXJaMHUDOTEASkGLHFBpO68G8i4nOlN0PfRg6za6yAzKFcwjXQV4Dbv/TrLtNnHubMgFI/54btoTyfuwTFo/Jnd320e1ZgcKWjGBuoyjg4/amnKGAhFDaBQTIHs+ZB5cg+Bcm1wlQwRW81APSLq8RgjChfkcsb54TtsW0TNJ6zrK4ATUjQnlxVOQmif+0z2RgBQCG//OuF8IAQt1WgBHPm+SWD719o9v/kE58SgRcqEPNwz0h9kpFQgARABXGVvLQvj9WfA579/RKkVn/7iBre3N4gpoWaRPQMR1sOCmBghyfzWSqgs9OV8zliWpev6FAFEtHKiVBBCBdcjjv8P43wkbFsAfx0Qr9L2UTdh9Iyje62LF9SubL8L8PDXB2w3CUeIHBQigaJkkbJ3XmrWtSe0U/az3D+E/mQvp5ruIo7pih+aHkIAqCh2a0ItIalhviptrkWyo9SaUbaimRkhDm6IWE6vEI4rlpSwLAnxmICaJXhl1Uy3UdY0o6Bp1q2mpuENFbmI07E5DTGRZCPi7phn2LGOHNCMtBSibkHNn8p9VQ86VttL+kYu9KB5F9i5TkJguWfQf2S4kJWl03mH8Y7QaXhl7YbpcztYZnsqUS/VY/qG9qUCQjOtS8oPwIISBwViGGg6qqJRsAAAsgVTK0JIigUpX7Hp00NkMr/9wBxsgq5Q0YVJ54bN9kCEahkoDdDpHGuXVpuDiZXfkhLbVtqcLeWSvbX24x1B/Svsc9vfIaMj7Z1yzY5NKg2SexzG57JbS3YvgtDxNlwGwLUF0gQAFAz/kyytjdZr3wozuBTkKnhZIKiDVEWI4rRPw7P7uiUyR9kF4Zhw3jLWRfQQcnMwjJTGjHv9uK5VvLQP1V4cZl7aS3tpL+2lffTGzLi/v281UH+ubcx6IMKiipkNmDCDpAhzVYVQF4lg4Dh1JxsRkMlFNXeos5i+rcJ81DSSLcrJ9c/Lw73TCrg7/GqIbGZG4B4pZcZRgkYfqPAbTSk1cyBL7AWYUWppKYPjYnPh4UnNYsPmid1T3zeFB2jGkj6XFi0Ttb6sHmPW6E+CpTwMxGATWG0uuJsYK1gjSlsyUBioTQrYhGaUUUVC6y2bwaEbojsoF4hQVWFrJrzd1JQOqm7jxfCd9dUDTP0a6sqDWzvPdWJ5zJmmR6Bf1gq+BCn3r2+GITx+/lP9sPH4FM/zOcP9diCN5kzzRLsEzyBRM8OmYi3xALTxATDrfIuk5FF5hDpCTSEcsLXVPrsxUbv+ylif8a7pmWtjb12Oz764wv1+/rrbf+Zln6+dSy4bgdFRo4am+Fl2rMrqsEcAIavjW39HHVwTBw6N7eqR8KRqf9fXARIj8pIiqFSpHV8LUAnmFyiAAxApYFkkGnCrBl5AHSk0ja0CSVLiTsACK3EkcxHaEvLOL9wsDvLbyiGBxF5t9bABRi2lXa8Xtwg2a7Uo/WMB0UCCd3ER5x+CRNmbk2ajDe69VyF6YAggaCnuS6lIScqi1Nr3mBge5UpqwHpRY0oAkBDCrfJWKZlDgQGSSKsUxWEmxgX5dMLpX3wGvg9ICmhkqngA4UYNm2pWh8Qs9v1WXdkGXc0dlNH1NaAze2u2/dZnNGcZjfkbykVQA1ag33VKQe5+I4gxUzrjqYLleXP+z9dZxhpf+dTn4PkjIPS5FkornyNVpFBANcNwJyJxNCqVNWLQ7mF3UqCLOuwka9qcZVxvGd2BRkFMAwppZwiECZQzR2N0GQgGxAFNnuuGLQe4PjE9nu4b7xxLSThg0zlPiAxlP+pYaHISU3esUJ7a7+fKKRlLCxFpWVG8wVTRZJGJjB5DiA31jH19B5JztPM8h3SeZAyWIYuMyFYpu9N3w8ijmFnpvJe79Tt3XE8Gc1HaVdxGHPeqAfUm85swSQhN9mtku70ngNgy97DtaAhP6td5Ws1NXhiB1NAQcOmzkuNGqxug7Gi/0POEWnzHnPxhWSZtpm3+gN01uEd5bO94J58+/kvZFuq4L29Z+2JzNMvIOk5bi/1e+ixnLN6VUUxuQ9XEoBWldgO6KEgWtRzEiE5Sxkm+Cig1Smr8sIKwgLAADJQti1yAiApCYKCQ9f4Z8qifp+m7pyjkpQSl72+nTBIByo/6XcfcCv4Oz33e2Mt37+/j3/lj4zw5mdyO8chve38ed5r5Mdq7cbofp6Wl4I//yd/iuN3j+yNwrgmBopR/gZUIcnyyFnCx8skRpTKoit5UC4NLVaNb3/8N2yBq8vygZgEqo/usWb110szoW9okIKDx4RAbvWw8lquyPtISEgVAQVA+I2XXSsM+WK2EZIZmpZ3mIBoghm8rxyr30BJKccGSEogicpHygSUXcC1IqSLzWCKUCOBSxABZXRZIqc0BZjQj47ZtiDG2skwAWlZmo3UhhJb9EVC0hgjimK8Gyxh1niRLgCSLiyCWMn4xRHH6o3YDiyvQmZZ9l9k7/rt31Pi8zHXPJDS+O6Gxs6Pv5bs3Pv8u+qPcy2WucDqx/243GAcWhIKuA0Kzd2qplqhltoR1c+MlXItkLq3Cd/uAGiPQHWXHNNsSEqo6wNYqmYO284bT8YiHh7e4vRPHkts1ImDB92/f4PvjEWl5QFpf4ZPXn4PogOYkbjN+xenD6GY9B/ztv/jtXVrv+cCsIfXAA8b2V/8A9a8IR5heeIu7TzbUTwsKVRAvACRjaQgLPv2tivWfnbFtBTc3lg1VdL5aCyoVIBJSjF3WUgcKQIzt60H2WQim5UUwIoCickdGPW94889/iXofYZJjpUttSY50PrL342dkzxHVc1M+R7z9X34JBlD+4RHhHxFiXHDegFwsJ2hF4TNQCebswzWg1gDbaQIFyNqvGGmgPMkKb3VZLbisRyKUCz/MpSCSlk1iiIMCQWl5FYwiRKSQEL7/HOlvvmgjOwE4fvEN8m9lLKs4EMdEKFkyfVswTrA9oEGTFAi5ZKG5zmFPtoyUtUnLIuXsNHhHdx+IggYt1D5wo/R+3xavm+hp5iQ+SQ0z+fC6gextcQYKHMAF4MCKByo2bJSPAkIUelKKZRUe73vNWWFYMLqamC03kL5XciWWShY8R3kjgXpGWRICHVogiOhYVlY4RZI1UIpEKJGT6VR9IV0PxHJKoKDlWG3+xEGzArr/XGjZkKnTBkUNl9tzXIpa5srrI0bbG31XvaapPIzpXTp6PuzOS+nO03tgzJI67iflxQz0TPu2Rqjx4c6+lMeRzpk65wYiVHS6b2uzVtasTxpIGQLSmlCz6JmoFRRc4AQbH+1rK8SAmCKWdcX9/T1iWpAQYc6Ye5LlHCDT+/Tzk0P/Y24vDjMv7aW9tJf20j56yznjL/7iL/DHf/zH+PTTT3/q7jyvEZoAC3S9WORHLT2hAvY1ycQDAJeOCpdCpz9vNyKHn+UmgN4h+1wNxxLlPXQjtDwmNpCrmfocuA6IsmUpWEVwrQgqwMuj1LnFjN8tPa4b+wSKmdLTywUwGEXTpXeDQFXnHaKIJSUdGaOqAL2VDQawMySjgnmCA4Bqeq0N39kx9y68w0xzNnGGqTqNpw2U2In0oxL4vKYK5RXg6LG254g2rz+rRftUM+coA/JalAhfKqXPbbPzyrs4A/2QthcFctm5+e+fn6rhFaNr382fL9vPd1xz8+vZDISkBEycRzrtCQhtu4mDDSBOJKz1r6VMBZHU3Y4xIkWrFc0NeA/UDdlCI3koMcHMyFkcYbrRsoPg0onawKpxvntKWam2pHSNDIRQVwwz7Cmw0pCPAYwWpb9UcfIzEGBWmhs9CwIIpxS1hIrRA2611HsJFr22pRSWFmNsYEjOxY2XG5uwmtcGRtdaBMiLCS1PCzFubm7xurzG8VwFrtNjVr97yyeU01tUvgUhoAJadqniLRUkpfMnKsjUjT4MNADZDOsFaJGEnjMa+HLNwLVfhkkdOFiceHyrDHju3KUDmo5N/N71vVJFgcb00WXGtP8YG1/8/3QLTEiQOY4cusNMZKSUkVJGNfCWIgJLVOMg99ikkdISClI+AQRSniZl1HS1cL++76P34U3X+X43eo1OjyZnPNXmvZ1SGvibd8SYaYFFqaOBdHZNv39KSwMQfXdKlTTupJHXkqnGnHUs/xIanfQOPIyqdKFnIxlkQps1R3sti59lzQEqShHaUdlobW3vzN9qBGrlJ+fsxt9pXylFKQTamC3C3+7r5RSCOIXX3I2il+9t3xlYAizLxTv076aUfl/JNPkMaX/HSBhCdH3Q71Wf8U5K3N4cAe+w/p7dWnZJtxmdo4PavYe+P3lLONbqdTR3L1uIDDhnUSfbM4EoarY0y5TW90SFGdNF1q+BQSFg285gtsCCd2+Xo5sMRcNf+9eR/+2cZUbTETSDFDcDzLyWLvgSz5xpv//GNzv3f7qv9mnv/ntzcmkW2XeEucYXf2x+6d/JtXn5MVuXcaSVyvjq7+8RV5LyYhxROUpmlVLV55HEMbyKg7nRcrmf5UR5f/2v9+iHzcxspBsdRqWJ7A51OuHhvMoVUWXs7rToZOVmXBU+JHyGNS0kaRZFwTpKzrK/alEHmKqZMXqfmBlLiuqoahiMGNiPx2OTqbdtU5lESrzUKvda11WzYYmeYfq4Obez6kMxCl9m5aPLsiDGpJkfKkouOKSopUgIMYp+I/K5GfE1843qTl4e8nPum8cVjBeNsofRZbrgU31N/PC1MGMb1/Rl0Q/t3JEHx5SwpCQ6YhCcKeciPISlQCpzxrZtyFtGyRIIEUOcCB/r1PmdGHT1i7NxINGPtm2Tcl9lA9eKu1c3CBTx6uYOD8eM7STlh7hKVtRaMTjJ7NPbfkTDei52njdFOym4HdPwOlTTL9Eza1YwKmfkXFFrwNoCKcTwH0LAuh6QkpVTd3ttCDACLKtHoIAlLSirYX0ZIaqszFvHF5Hlp27I5R4bPlMXms7TulP1yNN4+j3OlMzQ7Cwzz9PFdQFYlogYV3zzbUHJXffgKgF2IjPIZ9GFGURmQNf3Vs3RBgARmAsqZ8lsF6LKwiraKH7AXDsmWyqyyqUhiEOfZBMBiCRAJkZxBLEBzhw1xIDD4SDnhYhTOeN0Ouk9pf/btmHbcsNRjL5Yibrm1Of0ELJ+uJKxjRa4z55uzk4XHg8yfNK+0xd4oWkLnZz4A3v6cym7P0WX5uc+JRPz9CMX91VlGBIBiCEKL2l5aRml9BKAnmb5Z0twgOm5spaDEt5Zpm5+1PZ3oGHe/VyYUufl9DET6GUzPtX6CBsfj3tfH/GhBKWuBz9+w3kt9Y7M58mdWrkrAIbWsJVmZxuf8jkBG4QfBOD2cIMtbDifziIHxAjEgKwOsX59C7Yo5RdTSliWBeawJXjBnq4p7Zqt6KV9uPbiMPPSXtpLe2kv7aO3lBL+7M/+DLe3tz91Vx5tAzhOYThuTbzoLUpKfktaWuye7/++dtw+ewHK/947191lOuYFcajgZAJXsPKkIDJDNJywbOMSwbNlirH+FSBrxgAPhHglw8ZhgD2p4aNFVLvoYhMUT6dzN+ZASzGpgVuMugJSLEmMqq9ev0ZMEfcPb/H1119LVQGFhIOCe9bvHjVApp0B6Ab5vbmej4VALUWvRIeNRpnh3bSe9B7M7XHDAO325TntQjma++bW92P39qWgRGgvF9futceUx71+fKy2B5L53xeNGFaaq+0irgB1I4qe6J8yfff+/dvt0lN9xggwPPK0d+3ee7f3cX7au2ZPAezOW5Yq3GhmPzcEA1o06qk5eVlGBokUJQQU9AhPoWWSASDGoE4yhO1cGihFCGAUbFsFs1d2ZR0YjWCzvQGtj1aXPCjwJU6HvoRKdy4Ed0Ow0QJmAoeKrGCcf+9F62B7oHpvTTRQOMa2dIX+9zkCLEKINDM/t+vSImnBS6lg7ul22YwtFPS70gyRAtSLcTKlCApAxVt89Xe/BgiSZny5wbqs+PyzL5S3FjCdkPEGhN+ymVGYlLFRxYNwCZxRUMDI4BZZ6IHf8bOHPo0/XDrNeLgsQDLL9H/oUVv6vZGOoHcaKf8ehI1mzPRxa9ZfiU0Up5kGql3c5T+u9j79J4jjjO4UEIBf/ZsDvvnrFZQK/uS/P6EGRikJIRyw3tw6BxhxsbJZjYlwc3ODlJJE9m5nvHnzfY+a5B4hbVnw2OSFD9RMLlqWeJHp7Sl+MBp5MOzvTuMueZ7JOMa/AePtqX1PDRAMSCmqccRoptwrBjGT2DUSYV0Hm1CtaPJXjGJAEtmYESLABlKylIqYRyx9sXKkJnN1+lerjols7mwudI/UKpF/6PKF0eikTtbmuNNppTl4937MzsImy9r8E4V2P/9e7TovN3X5MTSH87131WVlGmQvyQC2vyZmRxn7PBtW50xGOeed9WZS6+P8+4fLbP29dfnfjv+g27lj6ijTDDKX/DAEQkoLUpqdZknLiUE/FwRsEpmdCG/evgGXA6JmCmCSqN06WyEuRnT5/d5fe+EQswZBrXcjr9q9tzrUaBKJq5LsXpaavX7s/7XX5+tnP/6kPiLv4MPTMQZalplL3t15uu/dx+ah7y75fpy2LAX/+J/+GuuBkAvw9qHgu/sNmRPyllCRRJ6spHTLDG7X9TPhP12e9sc/dJt5XKOjO8etr5f96YE93bFSHUzVcXvEWzrWI8lnRh4hJEppOGlEfi0oyodiIMQUm/O59c/4jfCLTt+tpZQu9OsQQnOiMUcaO278yBwricxRleU8lcOJSGVxMbYeDgdwiuLgQ0BKvexTm0u1xHvHewrUMtDJmDt/tZZzHtaBBBDMDqXOOVhprXeoeWr3XOM7ntfurYN5jTS9yQzS7RKyB6FoiZlAm37XZSSuBafTCTmfUaoasofyTvKBNZOc3bl9pfJDw+VIMnnIey74+ptv8d133wNc8fmnn+Mm3WGJARQS7r+/x5s3b3FaMuo/Bj755BbrATg9vMHprz9F/dWX8KPxHMfIe0csTFdhd9w7y3iOxGCS4DQLGmAAaWXcvgqSqaoUVD4jRnWsY1ljMa7oS6uAwgbJKKJZYuoCgCTbHAKWRdYcnxjH/2nBeYtY//R7LH9yRKQbUFwAzvj+Lwnf/eUBW/kC4s9R0JG+/lptp3l+NOt5jzWbw/qIZMR/+znqd69QF8bNH7xFrW9wPmXUCgS8QoxL288m31p2llKzZHslIKrDTNX9Q6zGed5QcJaMLXVFwAomQloCUpL1I1XjSQJZKuHu9jXqtqBSwHZmMAccDhE5n7AeKniBK/8r7fbuBuunn4KZ8eb7tyj1Ad2xOEofo+gHpZTmSNNpEaRMmcrJ5lDDzDifz4M82uaOuQUvzHvV7muOWB7X8AF8/l5+zY/Y5yUNswyWnaZN7/WKTuVlyRlffZdGEDmUAwFZ5i8tCVvOAAWE0MdeakEIETGk5lxPjWQprdb7jvMcmt504eBDQru8Y81jWEuYzIIAACAASURBVFx3RnEAlztntlVY4EGtRcskfti2N+9mQ3iqzQ4zhtMNGPc0F/N6UJFCcbwKooSY5O91XRBA+Pa7b5G3jBAilrSKc2ThHnDrxkFELatcSgk3Nzc4nU6yDyiKw9kjs7gri31EjP0/tfbiMPPSXtpLe2kv7aM3IsLd3V0D/n+2zckXTdlk+80tq4wp+WYsxI7S/5hzjG8z+NOBeRPKnQGAVWQd7tXV4N7fLtyaYGfqUR9XdfKUAxtcSkMzRvcxQxUmyVjTDdhtMO7+XcC0NIkSgbLn3c1O2DXFKE4GHwAcsSwrDocVt3e3WJaI+7dvpERKzsibeeOjKaf2hHmcvs0C9OywsqcoXbQLgdbewb6Qe91bfFRAnuPg8li7UJTcPa+tST8fXjF96vnPVR5nAOtDtmuOPY86+gxK4BSBP5gxJgX8fbrOT0dpeqB47vc1Jf7a9z92e6q/73Kf5qA2vE8PwI7nejOSOXoY2F/qpleTo6GjOcroDmlqdvEhic1ZLnBEQdE0xN0oz6gIWmKiuWdcGAKNhgSz+LT+G33018mY0cZZ6wgiGSBV+dJg/tR+7YZcQq0925h8B1gqaDMYmAGWQgA0mqyPx5jLyDdCkKwUpUABBSCGgsIZ37/9DW4Or7Aun+Gw3OHm5k6NBxtqPaHgLXJ+K9G+kIjGTIyKihMqNhQU/VsqrPO0T/2sX//LjgxAm1LxAEKcnGXmu5Cdz2gp7efzZmPkniGvtjEovaGZq49A8E/d5jF8lAfw5Z8P3wbcfwssrwoCHXG4XZELsGVJ1F6L7h9iAAUI4n4UeMW6LliWRcHeiOPx2BwSOlhWtLTXhzcEAkbXR3DuXdpzZIH+fWhj89cEiggKZgbqxiCTZ/sPNUBQguuVZpCmDGfNW8HcMhIABApRZULlo+yiH6GR4K2veg3BgbzkQN6OW0ofogLj5tDTMxMSBcToaVAd6KV3fGlzFVx6/Enms77OzjekJZn25KrH3tfeO/J/G7/qDi7ifHjt/ja+a2U2Pe/0Y/DOOXMfn7MaP6R8sQe0fwh5sBmAofyYJ/mXgGVJOBxuXKSnlgrTdcwMRDJjOINCQSknBK5ICGpwqmKq40t6PUbTPn9M85luVQ58513uRZD9/L4z63ljux+gZtfLPEh7z6Hh07utoc5vrAf7vL6f/+MXZrqu6f24jQLw6rMNoDNO9yfUxHj9i9c4niWzjGSXAYAq/LKS6CRD5qd9p76BdtBjOuz7z/3M37pT3SjXeudDryN43SmYE1ztpUONJ/pSoi1inqVMNdjzF4N3LIhKHDilP04WDr2PHs8xutv65PqdUmpONcYfr41rdrZsjpWkWbBqBVppYRlMrVWd3ReUjXB/fHC6hmVlwcXz7Pp5LLOh+NKBZrzGO0T247LeOv8BnkPyn7Om9nCNPdwDGGmEvetaFdOjft6yrIghtT6WsqHULE7DijPB2EZbp+4PpVlNxoLIVAiMYA6NgVBKRs4FBRWRA95+d8LhELDcHMTRmyuWFLF8GRAi43ADpIVBR4C/IZwdfxhRCl03MN2CBz1lntUKiG7q/g4QB1RzmJHjWhYVSd9n1JIumCrYOHwQlkVFFSZ1lDHXlhCAFCrqtqF+ReAHwumLN9hOX2GNd0jxBjES8ts73P+HG2w42BPaSGYedam97Y/bf8PTPS7P5/7/cQGOC3jdkP5hQgyLBAXWiJvbT9Ux1/ZqBVEVx7uYkHPBljfdgyLrVc7ijMWSFTfnM0rZtCyqaIoW1BITIURG5Q0hADESKCbc3rwCcwI4oBbRuRdilHrGekPg5PPpyYhDCKgBuH9zxv39WZ2EV6SUYBnJQ4iNXsUYsa6rOpBlcXCPATnnlinD8P6ZDnqn8D0HmJnOz84xrSzdM/nMNSyeyGcZ84GyzmnwEYzyvbEtfXggAlNooR2BnN4ECBZfISWbQAhUweznbuzDiFVbGafLPrISXbFd7OPbIw03vjmMYPfZ1oYyfc6B8kO1PYxrfE3X5cye/d540j6/mHWTPewVihaFKHzDysrXUlzGJ7OTsDoQ4WJ/+DlPVorOjk3yz7X2HJ30pb1fe3GYeWkv7aW9tJf20VutFd988w1ev37dyi78HBs7Q6UZBM3AYbKTCY5NgOKebPXqfQcF+vrT5VxV8zQSZQTsSaNFHkMY7D79iAdFah3/lqapHMlShBKqAcjoXv12fyu70QVGMZhYSkhrAsh0wa9qGPIoXHM7R35YDRlSIoBZHHRqYWTaQETYtg1rWRECYVkWnM+bQyxoAIXkMeOcWHmlWTieAfvRCD8auM2Q/T7C6eNGgX2Hio/hWPJcB5inFEd/7nPbx3CW8e05xkV39vTZI18efnLwSVtX7zaGd5mla8a2pxwint+Ta9f/tArX8wxnCtrrb5CljRfDCkjq0VsWFGQBIsgBzR7MK5VhkWq2B7kyYpCIXKvnHJOUdiEqzcVKom+z1ApvBqQOCHca0o95PtNGRB3m68fk/FrLULKjOVbaSbjcp16BvgCOMa8fTTNfJM040J1lShGAmKkDXh2K7M41HajpBpZaGDUoMFUymDbEVBCjRKGt6y3W9UbGTQXbt8DpmwX1fIdUJMMIQzLKbKg4I+NM5l4yxzrtrBGI+0+Hxa6dJZ8EvhVnGQ8Q+9YogjdCsvAuTy36G7/caQa5mqNPbZ/6+XNf393U+OEbTZ8/Rn8sw05Ej+5sgD8AFMav/x3h5lXEzacB8RXAG6M547IvicaNTgSSdMnMjHVdJP019+whzIQejvthR2f70ox3fo92OePd7jU7PVzjC93ZRWmfGfycrEEkzm1G+wgC2EoKd1IriIDUAz1pQDipU4vRm14SqMs0Kl9riTh5sPxHoTtli+OLv6Y2eskAoMbOUlwZOTeDs6HPA+5jZkFW4/HlvM2GPw/c+wj/+Z3Mc+6db/xrGcHtS3rdywHuU7hSRn4w39fGPWbUueIoY4bMJ5bghwVi5ZnP4/Xvc3tGi6Kf5XSG8p51cKSqVaI/SY0JMQYpt5AIjA2VN0QGFpA6ykh6enN4HKK2NYuYn7GnpC0z4u5IAVf5yHNnbqbb/rnz5/3raPhb+vg8x5TLcVy77nF5us9Lp83sjo/njs/4MXjnj82bY2L83j/YICXrKs5bRakF92fGlive3GdsNeLu1QEIkoGkYwoatQ/2lb0uDGX++EAT31HveU6bdXD/t8mY3uBq31tk9kifFAdg3ZtV5oiHcVkWM/uTHT/TEkVGo4OV9Os7wK5jiNMoOUMcMBrFzCnGnPi9rO7HYuMG0B3VPX6CkXc0jZSl5Ao5DMb4VowBqNEdI1N/WsZf/zpZZSZ2TkW+XeMns/Fx93x3hseAHtv31/jONXnnMf145jd2blX9TzAw/24kQ14gQmUtlVPNxG33cPe7oN72WfgB6boR57URXyAKiBSRKOHh/oSSK15p9qJlibi9W7EcEhiMcz4j0IpljcCXK8LxiPPxCPr6c6AGN5sqS+n/wt9k34s7ORqdFFXVzrXey/4JJIEBATKGXDfkUqCWYoQgWloPNjL5TEsNyxH0ci4EcZSJKo9W5G+A7dsAPkVwUUedrxPqX66guIBTRE6E8k2AH+G4OnigTabB7etfl1f3UV9y4f5d/+SdrmrZ0GhGWHB781qN34BkK84IsSLEBAoLYqqIZZG1VbuuXWqW+3EBEEG0yPqsBFRGWgjLQlhKwvrNKxAB+bM3wCKlRw83CyQBks49E2rJqFWyXdTIF6OpXLCdN9y/PaIUxpIWrMuKmCKaTkAi74QQJdP3q1dD9sUYImouTp/qjoEyR52GzZlSHmuzfOxxj/G7/ravyeIzLZkdZiTD8FjizZwVvbP9h5KFG60vpWXnqVXWn2VMtpJGPVDAYUU7GGfXv95Nr9zjvf1zx6Ka9Lcznz7I1c6kprh9vPYcHWKk/Zc84DE+M/O7nR7AstExJPNaihKcEjWjtMgbQcti7et+QF+TvRQ92vz/kPG/tPdvLw4zL+2lvbSX9tI+equ14le/+hX+8A//EIfD4afuztVGKmibUguYkLKjNBlA0HSqx5X6R59Lo9AmzjJd6Wigtxoo5+48ChywGYw6EE80piPuOJAC9E2I6yCLzYMAM6OxRn6rCtzq1FI3VrdxkgiK8EIiaYpgU+zVkMxSAkqQmxEYe/PmO5zODwAYJW+QMiCEEJaWBtSXIej9HA2gl0ar8bi9Gxu3KQluhjto1p7lAYGn3/1TBoPnCsLX1tmeQD47wly7n1cSfqhAPq+Xx577IYX/978Xux/72+byPe/I/R5PtWtGz733fA0wlC+v0CVcGcePjPrvKd2tK48As2whnbb/GogSYKW0qkWEgqXECkmpFQ4S2cMsACLXCuQqjjDD+wlYUkIBg0oBBYjxjMTIYACSAJGaenbgF50WGmjQ7bMjmDHv09Eoa3vQ02KJVhGQ/tJR5hpYLKD1eF7PUkDqHMPt/j5Fu/GhGA0A0PFzj2btAJBlMJO67RQkHwwh49XrAw7LAbe3B9zcHLAeVsR0AkLF/a/vcPxXv4MIIHEy+AsAkFFQqLZyRcF9R41/2F/2CRBnljbxsE86s4MRMIJA6ixj5ZjkFp6uj/fA9I0/062EXSOhAdmWoQaQLUs0U4p+9x/bMOd7cB14/nCtAijE2CARdXP2nfOJ8a/+h1swgD/8rzP+0X8FlHyDFq1KDAHi9b2pIwwDoEBY0oLD4abJFDlL9ikTl9CAxuePzkDFnS/afYhI9/WlsazLGPv0fM/Qs8fT/WN3HToaHRX61a8fs8kBMo0hsNgRq6SLFxtkFRrhaBsRtDRmd7QTQNfk5F6GKcYw9K1WqQtftJ8xRpRaWnamJs9hdAAZ+mvPcEbdeW5mBxW7Tt47717rDZaNV3EH/6/R2r1j/vy9vpjMarK5GeYu3y3pPMZ2j3ntzAC/fXfNaeap9mGdZUYA+GM5zbQACPTxAhB9iLox+3w+w6ib8UNCREwJaY2IqaLUBzA25Uta+FU2RnOzJeqlDkSFoUH+mrONGU+Z6byZ6+Qv2jkHo7PmI40e+bTHUZ5zV2LqetrAdx/vCU1/DYbadvwd1pmb31ErG5/I/p08/+7P7wYu38+P0daV8d/8d98BdMbDw4Zvv8/4zd8XfH9kUEgIh08QC+F+27QUJ4NrUcO2ZnsgfRc7E+PpyuAs03jahx/1nt4jgTi9NMelXn/lejLzqfKGilaKFTD6CfgVYxlzuTgpjoI6zFhmRTVk6ddgVif6Ua+2vuech2xnTUae+C0wy/1oNMrOM3zDnlOn58lwRvlCrgu4vbtpWSlNXq5c+vskdY/wMsDET2Y+uSerWMCSyQXDNbRHYd5vHXmefIlHXfbPxnCZYQAQB7LQaJq8O3IlzBlSMsccZiC6V5MVr4xh0jvsIIUgZXdaH0SXAtk9Rf/atiPwkHGb7lCryI+5Ftw/HJGWXyDGA5Y/AtY/+AbffvUb4J9/CpwiPN/gRlVNVxWH9EId39BwvC5n25y5Y0QSlBIYqHVDrQEcMgIlMAoMp7N5b+uy8YgCVKMbqkNyaBlpHv5dwPf/+w0ibjVggRH/5rcR/uZ3EEHIAM4oOKMgUAHByiH6ReG1ulk7E6WKVS+owzjnt3QNN7niMIOKLR9BoSKmgABxKpEyVZrpMjLWG9t3ZyAExDUghIRaKnKpoI0QSmyzHtMq+ARX1JzBJePu1YK0MNa/u8Nn/+c/BgD8/T/5lyhfHpESI0RG2bJs6SD8upQsJWOCZfkZR1pKFXyVCIfDLQ6HWyzLghDNSUadYiINjn9DCSACQgwDjSOiofTcUE5OdSau+3I70Pf4vGcv5Gj4fTjqVTMt9J/7/UQ3jIp5++fbNTPtey+ZmHSttWyGXb/JeUPH3NHmGzCaX1HVuYw4gDmaCtZadU43ws/SFSwIMAe+3W4OdLPL6tbpx4Zu81stOvc9ZPv31zc8CrM/buYZ7xd7yzs/Z3oEVwZrNtYQJQs0kZa9UrkhQrIj2fi88293muuyQnOYaaUld3ri1rWM8adCiP7/214cZl7aS3tpL+2lffSWUsKf//mfi7L+My7JRMHSoosyZx7aXSCBGgBcWvcBex+FoD1D78UznxAmh9R9TenzoJAJgfbs7twxPsf6qBEBAVqPW1UNYjVyasrQYBHDdj+JtqH2PG+4sOMEZktbbMYNakL8uqxgppbWE5Bax0RALhtKFvBGshAFnE65lR9JiVr/T8cHnE4PA0gkKRAzsg7UK23MLNkmWopmAU5MoLVx7NfGBWK0CCRpPo2iF1ZH4P86oGi1af1e8EDY7ETwmIFjVijnNit4j/d5HN/eM/fAsmtreDbmzGN5ylDylCPFtbbXr8c+c1XggwFJmQsYGlqrgT0MSakbBxPGPIbHDFilFFGaQjd07b3Px9pzrhlBY0zr+TrY3C7AbN4Y7zvP/x4AebU/F+2yP97Y5w2TQ6kw9PUTY5R0tno3ikEMvLUitxTrAkGZgwslgEJEbPe0cfsMBJYuWtcAV5zPm2RgCUGBcgbFgGSOh2wAQ9A+97JQFbVltzI6KmMUuubXhN8fIQSs69rAd1tLQuMwzI2P+NpToA1cCmqAmNfTsizYtrOA6kQgijgcDnpfAEyIcWlgF1DdWOQ+lhHMotQoBFDIYAo4nzeczg94ffsL3L064PY26ndvcN6+xrl8hoK7/h7Q958HOJUztywwlcfSRlWBarI10a7igTLT8FmcZAKCOsu478zhwq9aYvjoUpoMpNeaQF97MLo/dt10+dPCIbPh88M78DAYGUClikwVkUnLVHmIWuZhKwX5DAiksZqQpoBgBnEEoHIOkb043N2+QkoLzucTjscjti0D6GBuihEofLF3AFzsTX/M9lQrY6ST1UvoUKMNfhZrra08jO113y75SN+3QVO7kDvP399HrAn/EjlnWZZGa3LOLRLUt2VZtH56wbZt2LaMGJduqNM3EUJUAxJUPq4oSqtCFJ7n+yOp6Ekd6Bm5ZAUaIxgVOZ9VDiTUWpDLNvTLQPpO7wBSYNkb9vZ4pY8qtf3qS154/m0gv+dDMSwDrbYf65OVVrLnye8upxNRq09v/GtuZrCTtdyBev+MPYcde5c+ktfOtefN64PoaTeFazz8grc8oc80PWXaA7OM6/lg/w4ALt/pzOfaGAHEFJX/jPvtdD6hlIqHhwecz2es6wHLsoJIMqblUhEjYV0B4Izj8RuEeEYg7tHtDIDEeaagomeV6VRqdpIZ+s07806XegPt3OfaXffOms813mnNZ4q5tg6MF+6P55o76GW/PI/bu+q9zSS+XxMPtufsyQEfqv0UPDmXir/6f78B04a8AVuJOPGqNmMtnRdVLqoitzIKmDIo9HJ5tQbUel1/3NN3ZSu+26jZhGNt1+jFrBut64qYFjw8PGDbtkZrPS3397Hv8lbE2AwMvG7WJ4S+CyYCEn4DlsCl1if44B9u9Nl4YNiRDaw8ifED+20GMU87jTbvyRszf7D7V2aglTkxbE2sm8yMlKJgJzHI/qiHQX6w5xp/8D/X5nY2Go9Zb2SmZvxEeJw65av81flQPw94Praw16+97546PstVzAybbhmT6P2MglJPKGVzPInAlUAxtv5rJIXeADuOGNZhnSuYzrogpQXEQM0FYWEwnfFwPuL+lHHMKz4PnwPngNO2AWHBw/EGt7efoCIirZ/hd3/5BX4TFnDTnTq95XZEPgdUBK6IYGRUFBopolwz09E+li2fcD5XlCyy4c26ql6oc0vQEk0Ec6QpVZyNSqlYYkBcbkEUUFDEEVv7wpDAFmLJZxOEarXMk6Y7EUjL4V7Se/9/D3uwE3TtNn3RZmivXNUlX+RpZhiy/199suJcTrovC0BHMBG2fEQIRdZVKPj7b34Npg3rzYrD4Q5M8s5ubu4kExRHrIcbLMsBx4cH1fklQyuQQbRhy0cUXtwYzoipIK3i3FtqwflcQZRAVLFtJ3zx26/xcPwNzueHi+WYtw3MwG9/+Tt4/foXKIWxbWfkvKFWye8qfNRmiHA+n7Ftm2b6jqglYztvrVy0yapEkhUcEDrsS9Gx0itfrsk3j+MCI2/wP6WUjlw5Z+j2xrg7y9l3ggOXnnUS1LKE2X0NbwHEjmH00c5pa8BhV2Nz0o4jdoWLZFDVfVEUv765XQBWDEWfczisOJ3OSrclS3sIEaLzmt4Spj507Kn/tEl0i5wbvZr57syP+pj3aeh8LIQA9SRtmd1m/naJt4/Pu4ZrX8NAn8KF6Uo/jAf6403fc/qcPUOcXtw4ydm1THesBSUXLGnBshz0uZrhXpnMtm0t2CznjPP5POwfuaZKZlzwRR/3dCFb6/Ud5bOXdr29OMy8tJf20l7aS/tRmldIf67NC4tVlftLEMMEQqDBjly1fFBP58vsBFQAs+rc7+kNqBK1aAIvzFCkghaAVingMQC7n0+gQOBaVMCrLWtAACEkc25hQFM9yhgAiXiRfs+PMoch834nkv4US/DKlgK56P1tBhjblpuQaUbXXM6qPEGVa5lfL6i2tUOsBpxu0ORSJPqiVo0KkugdMyAZuFT1vcxCsf0YMDVHSBCJfbzBrYSWqUfmqR8f0vNeWeumGO4ZCRjUBF2vfFx7308ZKB5rTzmePKaEzErSnuDu53B2lHtM6H8OjXjuuJ9Lb2Q7s/tj3KsyxqgKpp3TDQ+Pgb/jPI5zem3unjuOp+eB2+9xzq+cbUCeA36f6stTc/y4EvvopegAiJ0vkx9jwlAajshhAELLvFJLpMAZBTVEBr2vAOG1VjXi+WcGpYUKpjVFVGi80T0BToukrg4BMSQ9BtTCSj+CAhihXePnp68Tof0pdeMvIFGb65pAZOC6ZmqYwPSx5AjcPfr8EWhYi/0dj4B1fzeOTsF4xiWY0rJOKO+TuQ4NXgxIIFrANeL27ga3dwtizDjdZ/yH//UO9XRAfbNACgISjpQFQAZQwMitFJPlWuulXSL6jFZAoiAJaIUEGe3Ki1IZbUtTK8fU35AD664Y9zo8zRdG0NnthSEArwefCZCsNu5UYka1d+hAW3qGcfJDNt0p7W8bq+/7JbT+w5s5SFVQiyKdgWpA9rpkewiOdkWAktovWv4HyL7WvRgjFl6aFLFtZwDcwWnGBXF6jJ8DBp7ZXrlM3y2Rlp5umFycm0OuOTiYvOwjoveeuwceW5vlC6HpRbIMMDcZy1opuUeL6nWn8wkpEMBVjasMoDYaK2TEovJLo6XMLKWXCOBakEsHnsWYuel6ZnAV+pZSQogB55zBXJCznsHmCN7HbeSL1fk50CW4bn9bZsJLYFci7P1c++9t3gZ5ED1qc5ZxxLE7OT1g39m4OY246MJLo4A5Ufeow9mI6cHRPRC46TIOZN2TU9iB5j9m8/Mzf/a/Ad+963rPRSNzhi7Kk+yHcTqecOTT8N5tTTAR1mVBWiKYM05fMb77334XtX6O+t3doHtYuT+jy9fazEv68ZkXGUXdv35v9E+9Oc/B7DPx2KtWiW6i7M9ZFcbL/Ll7M0HTbx6ufrfWnrnnSOTm0JcA6U9ysv07P/mnb3/2Tyv+6D/f8P3be3xzvyFnRq0BpZIrPenNwAwmzc5CGahdl1aBBJdv8OO2a/ve00PTk0upyOU0OHp4eudpWqMDLE55HEwW7dJhL4vkHETACJWRweBSWtCQGFCDlpfpZTJAhMKlranKIhuVUprBCxCDWIySbYKZm6Ok8QozOvuMDX4e5uZ5CE9jFwOfOc6PfAbNYdJkk35dzps6hmbHS3QScRlUs0drTZ64PPYuevr4Pn0QwIfFDec+eXpgwTGMEIVXiCxyxvF4j1yy8hINnFF9R8Yw35N2PrszeDxOKp9SqCiVUVGAWlB5w7YxatlQv/ptbH/9CWgFtv/iDWI6IqUD0rJiibcIFBo/spESOl3vx0WqF8wuAFw162rV4XTqbFd5x5Ov//UX+O7fMtbPCz77z+5xd/OlG9PelBNwivjN/8wox4DP/hRY/lScFQIxRMMrmj1UA2IIiKrr2XML6pDFzdP74XHTjx1zaMhAI4f3stN9r4PtaTucE/K//iMEBpbPfoP6xbeofESKKw6JkH71JZZff44YGL+1/SEka4tiAqpP3//pX+D46hvUGpHOK5Z0aLjksi6IRCg5I/0fv4/D13coN2/x7X/5z1EZ4E+O4tweAkrOyJKuURwrgpRLWtYFx3/zR8Cv7ob5IAC3t3f45Ivfwt3NL7Aud3j79h61VCAB28bIWQPJUFtgqTibyAyHEIBAIM1sM+N93mnQHFxaBhKEYc8PNG7ARtx8TzK0/FZEgMa3bjiEl7flHv5eHe/o1z/uAD7znV28lHWtWeZ23VukL8D4ycYV5/MRcVnU0azfM2gWYaHb6jCf+jHbHU/ie9zXbqlSvhFE4pDqslXOY2xSE5udQrGOHb7t+216BYUA1LGs7awLfTD6/oiD+iDoXnw36k72e9bLWp/Z62D9FgwGhYBAglGCAWrOvQzJgNvnyTuoMvOQpdnOMezqmn5v5w3T0JTzl/Yh2ovDzEt7aS/tpb20j95KKfj1r3+NL7/8Ejc3Nz91d642E2AIJoB0A6oJiB1IUAEGUIXnMp3ePoSoApCrRTobLJtgBtLLTFnTdK3UBSSrtyyf+zjs7yb8M+szBRzqgARpSlQBgwxo6en3R+i0K/lqjA4dbLe0/QaymLA/Osj0uQMgmQyqGZXNmIum5DADpWwtijhGaiCYCZMERooipFokaS0FTC5lKGs2WCeg248XWGelCuhpkts7t75Sf2d77Slla45CJhJPfNTLKPJZaXwOiPWc9qGcVa6DaL3//rxZKXlsbD+0zfee2xCB5MAivQJ+74J0uTe6oJdN4/TNQICU0jsj9PN8PXbO0DxW19Yo75xwcbfd7x/rx957frRvw/ePfu3o7zzHASHMfZW1ZGC10WsDiXtt2Mj0AQAAIABJREFU+tABFhLgQcowdJCkgyetJ7rnIwKTZmDpDo6VCcQGgkkpIYnsNTDGntfBnAuQ362zqFGLxivMmN1pT49wNQc7nx55VsQ9qMEs2cTmdd4MsqSZW5qdXp0R2un+HXejrY2zx3IL4KxIDSSzdESKN0gpIZcHPByPON8X3H/1e+DjisgkkVeoOEFSbjOAE2Vsag6yuwcAwcBqdUIJrpuBSZ1mhJe22TWAY/qf9Bqf28aDrB5unndBkwMuZsfP8GXrzii6hqDrFiwp2/U6A7G5Pf3HcZohkCRP38mww8QG/X2U/pjUU4e/xxZTwLJE5FIxxocGiBuVNb/vNMPFskjZlSUi57Puj3MzHBGP4K1ce8nH/P4y4NUykzVgceJxthe7AwSG+/tzLuZF75NzHs65JmN5x4+oTnvM5kBt9yw4n8/qsJPU0Vqy3pRAIFTUqga1UNtKtHJX3umAq9GkTmNkCnwWLpGVNxLwNlCQMkwhIBdxpiklt3cndF0yzjSA2wBtIsRASHE0sNn4Y4zyJpxztPS1O+D5CNc9uazLsRHrcmjzfgnCM7Ztw/l8HvoQNNraA/2zvDnzUTFKjFH8c798m9fi/DOPa1xPH6cs0rXm9Zx5nfpzusHg0rHIn7fXRHTYGRNDHaXkfmZosi8JAYf1gCUlME7I9wX515+Aces4iS+bdHH7XSPcPl/Yd4LZH4/nWOPNd+9Bl/3wpZyGa5imfl/e8bF+ju5CPI31ET2oXbH/3TWewtP313juYCAZMhF8PL71sdt6s+Hus7c48j3K24iKII6ljr6wvnvBEexfz9FHKpMB76yS/IBG+9vR0cQ9WrBtG/JUpqDdcYcmNPo4PU9k6dF5tNSii0l5lqOtYoBVJyRXgtDuJRtPpbHaHeo9fV7XFbe3twgh4HQ6texfKaX22QzJndaNBufZsNjGb3SdCMX0jGCYRx94rYyaxenDjKMis5uTTEHOZXJM6U4zg6HwI7RdnXxHn5zPe19+Nd7GUT0nm0imZLQ52s4POB7vwVxATa7s66HdhuZ7K4UZnjlTNsJwrxDAAS3zLbPIemCAjgfUb14jHArK+VuUnLEsq5Zci00H6tJnf4Z856mx8Tx1mrHsLgwtWUTtLAINvGP7bsUZQMURr3KBz8bUx+T/IoAjzl9VlAdG+V15bq0bBIAsTR4zqZFRke3ZOrmdivU9fp2Cj7qdNU8JZ5cZ/2ZmB33vNDM/hSuBv30tARd3b4D4LRAKKGQQFYRTQvj6NQiEA7re5/uVf/+I+uoNQjqg8hnnfC+llEoEY0UKCXnLiN/9EdLXn4O/LMhffIfTKeNmvUWgBbUA59OGbSsItACxIoaAGFahaW9egR5WxzelB+vhBq8+AW4Or8E1IaUNAKHUhFLEES9GWSMgcf7fttKcuoV2yZuqbCVFe2ZL+00kzjLbppmaQhQMGY/rO3s4oT/X8JzQMB2714g/P9ZMDu76kmSY9kFIxheMLs78qN1n2uLcv0QLuoVk1AxBMiKfzmccbgsiGYphfbHx9fk0jIcoaNmsSz3U63gkSi9IHXesrK7h5U/TUgJNTiV7WO6FMwyh6WjzHM3OMnsY8LvxnCfGcEGfx/4Md3pkrcmtTHiycRYQquBPVQJu2DKAtoeP0zBnc/O65zysJrNP+MC1vv+Yutx/Cu3FYealvbSX9tJe2o/S9qI8f25NBBcGQTKRiFAMmPAtxlcDEqzJeCz97jWnC33CxW8D//eFsz3YdZL62AusHQzoRgVRZGoTXOVq8WxXY4fLrEGKGXH1kRyjU8+yrKhq8JAySnJWbpHL3XArkVo6HxPo3QR8fbY60neBu0paQ4v6jtEJlJUbIGjPMsHTC6KIAiL053aQfi/ydk8gHeuKmwFkHIN/Ic9Z496AMaa8DkC4BN7s97uCVo+dv9fPS8WrH78moM/P2lM25nvN827Xe+XpQ9CKx5Sy3iEH6jM3YH00lPYfUHex4SvvezT2YFijvlzuD1Vurs6TgsD9j1EZtWfP7ZqR4rlreu/Y42v2sl+X6973rt3YLlI6IIcCCQhhUR2sILjBcHKZlGjwwAoBg3HFcoBUdjwgECRBNCGwc8MgVscNlueTWiuCPXM0XM78owPTnbdYRgH7kdTHLkW8LUbuf880Zb5Hnw8BY/sUynOtVB1kiia6o9Pf5kgdBwkA+XTr6ozQIrrk+lIZOQO1RNwcPkEIAfd/X/DmKwbngJANljVAU2ION1RUklTdm85zp8KjKa4fc7SHofvVg59h5zpIlhd3V3Lfu1FPf/tz9h1pDJide2HfyapCP4thfrEK7Mr8W5kpax/HfCHNZihAnGUS+tozILlqCRIDuGv79sO2x+DwlCLWJaBUgdYbIWhvKUx3MP6tMkkAao24u3vVDFfbtmkGlDo4ywL79LrzCS8fqDOvnUsYIuR9izG0vWcyjAd5H+O3e8Cj9dN+97r2FTXUdk9xSFFDX7HMWQmMisDSp1wyuAIESafPtQLReI7JueP8sAKzuZX4VDA79LkrJXTHlVqx1YycNyBI2vfDzQFmdrcdZ46QgsOqcx4zQg2SYcb1xZdS6uOdjYKQtUEd1E8p7c678e+UFtwcbod3YOnU/WdLQd9pMjVZ2OQCbwjYk7W8PHuNZ8/XWmmvvfMMZPdrxWj/T6mW7ckwM8+61r+r8o/SgKBlVuwdmx4iGdJ6uvXmzErynpZlRYhAyRWVLd3/IIFcNaDNhrY9XnP9O9o979r14Eue4zqy6y/iVtoA5gufenohdM3yMlMaX3y6fr/xrP0525dH+eK8+b67z2olE/d7/TH56Q9tMQG/+wcFzAUU7/HVV2/x/dsN4BXmEszcV56JY+yGK3+bpBJULvbSzMdtTz3F6LvRvGVZGj3LmpVlzv5qbTa2DYNGx1haZliCZtvlrstLRI08w441ecz4jZTLAAEUDUORM32WWuM9h8NBy5xujf8YLT4ejwCgpQel3740s/2eHd8b75BJ0L5XhJhauV9zmimloJaMfD7ifD5rSRQpP7FtpWWXmXlMn8Nxft8RfnhW25NxRv70sZx1dii3rhFxVA3IuTaHGclC2DMqm1x+TTe+RlWGI06fkuyXlhFI9ExwAFNALSzljw5HhC++RVwBogICY4lStpw3asEBRtXqQCvVaUYzV9tR7yxT4d1BO3UOu3xGsiksy4qWLKSVpLp8n5Urbn8fQI44/CLAsvcQqbsf2YrTdT/pOsYZjcrZKPf0Kv8zvwt2P+P7uM4LBp4eK+IX37mzpMRxDAlgAn+ygVJACoTwd6/E2e7t2u7Brb9ufwFI3/wCAQtSOsgaZAa2DURADRGFIlABPqWmb9USULaAcLgBYUXJLNmIKiMkcZigEHA4HIZsbF33lBaoZ8CtDHXCSigli+MWs5RdqhkgxuGwgrkAsNJNWZ3Cu0zqMVbb4zlnHI9HPDw8SCau5Hg9jboZ3PEZA909B92hxTu3DM5c7KWNEd8zB5Ou04xlwA0HCaFn6PIZcYbsj+PiUXrRJ5z0vBh6YKiVxRrWclNpSftbUas48jBLoAChbRw3ns47SGkK900q8+zKZnk5esZ5L/FcXNC9+Zx2bR/sLha7p7u+PwY87ql3u27sz/DcHTmj4WhkQcgVgSpADCbJcG+OsSktQhe4qgzm9Zo+517vG/Dxqbd7ut38d8MHX9oHaS8OMy/tpb20l/bSPnpLKeFP/uRPAFymavy5tSZj8M6xK61ybdFCICdwNtV17xkqHDVQx863h8+gnuvWjiDZBa9R8GQaQY6ggnuLNtV/BG4gmxyt4JrBrOBLA5QZ6yEhZ4m8KeUs1zE3UMkEdAGPumJTuQ6AUO+3S++vfZHMDMUpXF3pkOhlVemZEUK6yKrQjCTVZfwJIkRSA8/qIKj6CFyvlLXeOiH3MUHe3/epdimgj3/PSoldc025eW57V0cNL8zvtdlBZDY2+X7PitDHAcP2lbDrTiI9cniufXxdcbuu2Nk9PEBqWUwqzev//d/jc5q/5XPu74FY+fj0u3p35fayT49db4AB2luSPrL/ngiFATHO9ntb9pOBqIfQ5sWAla4M93dR/z/23rZJkuQ4D3w8IjKrqntmdrG7wIIgQQoSQBmNdmY6ne7szmR3+ni/++y+nUwySieeaCIpGkgIFBbAvsx0d1VlRoTfB3eP8MzK6pne3QFAY8duT3dlZUZGRkT6y+NvGmdHhEadAUiaWVbYiwTsl8AgBoo5ygSpWw5zzsHingDB6rsrktnACHMwtWa0zeiq7CWAYuiGMAWovLHYz98CFMf6PZTjpZS+T5tx1b5fZskhCpLZRcds9DLGhJ7SXoC/MgGlAAF7vLh9iRgJ97844O7/+y4iAlIDsoBCjMLyO2sKbqth3/MAvVvr0LHBrdgu4/DIb7h7eocZas476zN5dVTO9wDwW8ftSjQ1x1XzonFw6/ugnARIVhkIuB5BSCtnMoZm/2FodDujqvNMj2N/f83mPRAjxAyESVPIRf3xjjIXkFPn+5DsH4fDjTjfjGMrkzAf5T3cep9aT45+LxzO3L1CUJC/yRT9fQbMGaPzVnvPr/HoawZDz6u2QGYxkk0LhwqJoC6oFbi9vQGjaJZB0uwz/XkCmdNWn8Og6dlhhlg3ppiVxoQlsEwk5YuEVggtm+d5YZRIQ9RzJKuiRVOagwfUSFGrRNDWWpCLpI03pxVzYvH16T0vBoDK3ZHfp4z3Y+1OFYSUBux2uxYlO00Tjscj7u7u1KEmtTnwGb+M/q+dYR5rolNcGjN9P1vy4TVZYg3EemPBb7utZcMtOfHaONfPae81q85AagCPLZqXNQOUd2SVawMZf00gFHTc2aTE5b/rEjjX2trRsh9dHjPedG1JHpGQtr/zeuzV/mjBT95GvRuHs6w0Xp69crfGU1l13ovBXDrNrBu7f7d4nz3L9hyJ9FaZNsbb1/Z3tY1jxf/4v91jLid8/sURn/96QuEEDoPyEhb2V6lll3GKq7wMbBEpocmdtDjvt9s83TJeOU2TMzz1Ukdbbe1cYTKufrs4z5rQfKXHisWEsJIBQwBRBMgy8Erp55T6WIyO2PhMfh+GoRmJc86t5OKajptj7jXnkK3jhgX1MSzxC2bJ0pbnCXk6IU+SYSaEXu51Ldts6fhLo+bXifx/e/Nrv8ZP3hc+sByAPWNFKU3DxDxPmOcJtUwgFMSQ0A3wIicR+uf+049ALOb9mMov3oIuOJNsPA4MURwToAZvZsbpWDDcfI70z77EsBsRhhEpqNEdwFwyAid4L0nRW5dIpKiapEMwfTogssh3DMmwYxktxCmzO1e2pyMgxQG3NwNK1lJnYUs7Yymrxhnf+VcJ45gQSMpAESksp2P1+pTR+GU2GLdkAMxdps/19Wbfr3Orrvtb/3tx3pBx+JOfo9AMriJfxDhgTAfkXIFpBvOAgXeI/+UHoCktk5uh7wu/W25/9qfgn/VnsWf34zP9lyFlko4PBYFuEMMLEI+oRTIRpRT0PRdsdbffodZpiQk4vjfPGQ8PR3AdEGjXSouazDTuBhAxapXgxRAJOafmcDfPs9A/SgssdZ1B0WihZbNklmzg1kyGXjvEvI0GiKzY5dlOP1b9qOwhvMFfb99yG4f0tZSzLeuMx4y9rmC0C7X3RTaoNvEEi4ghooat11KBlgVegjm4Ck3ygaCmZzYHfPAS5EP/yI70+HXRGrZv1TOXDkXtmwtZfE2rl7L7uysY75fWPyZVL7Ey/xvMWt599aPfCX4n6y0BdoYZkjjMpgE5V8zzCaCwoChrZ6WLkZHZPMpVyXatA76LjeK5Pa09O8w8t+f23J7bc3vvjZlbxOU/hCYRRhEtGqt5rEMVa1FCmjGcgHE3rABpE1Q9YOOFMhN0HEhkKVjBsDSXcq4pHKYadmEe6NkEAFOUvLGIkcvURK0QAqClSSQdr4BpRBJRbApgChrZUguIGIyCUqoYWPKEygUAIaYokQXMYJszXkYY2HhrqarEudT0JEZVccBhhBCxG3cCUDEhJsYwJDAX5xAjdZYDSW3eXGZQU2JkjYZRDRcsjjpcGVytQvJSibPWlB1tBiSZ0cPAJVMifbO194aZa+CeOff4rEvN4YfVNO08/61/fx+//n4M79rexUnhWtsCst4GdPkouWv33zLyPTb+a8De1nNdK0fQjrE6iaHCImcAA48YxBESDWVZRTTxsZWZWI3Br73fF9opzFjjDUV+3Ot5utYen6cl0Lke4/Z1BuTVq/trrYyto9bX43u8bY9rbfhdjJls3v3e6e+oAZn+uyUthhoPpJXCYJ71Xr1f2TJsiAfMqdCeudNvQikMqh3wc648AHzUiEvxqyOqVQAogmV5Ke2ZjQatjQVGX3KxqKHlvKWULubUl6oiFvq/nmsBrAz4tO/03akE5ksDsDeWE0UMw4BhGEABoFDxcHwAMzCmG9zefojvfvwRMn4B5oIIwshSxz2q48XMFZkKimaV0biczsPgAdxetslA1fUu9EbINYRzFYRYfd/XtQPOfgwLRxqXjaWNse+EFQTqx34Jz1q/7J5/CXW+vzZwRGQpz+V3rI0zsqVIlzWoLI5NhSqsQNL7bAQgT/c4nbLKNCNAA5gHeIiDoCV5WOQqaSbHyfsdQsBud8Bud5BnrIz5dIfz+YTz+Yzj8Yjj8bjg761/R8ctWt1H+OWcV2nKlzRPaNYyo8w1w9nVuXiLLGCyEVFEjEa/GbXGNidClpal3ASQhfDHWpGz8EAPtM6zj+A0WmC0mpGoO8d4mk4k5XCYGeM4CutR+fo8nZUOqtyVKw6HFzqHrLKq0K/KBVGd/MzZaZ3tMThw2M9NDKmth43RZwnIOeP169eYpgmlFAzDiO98+NEC0B+GAS9fvkSM4uTj5fG+Nt0p0zINXYvstLUyHjOOY5Olfamni4xj+nscx+7Aj74/zaixJXO9S2aRb7Nt7c+1fGFGm6XR4rpMsu4PqjMFXVfrL5esRo+ecWe32yOlKFkaouwJCkAKASldGs4qWEvSsTNqbVFwHQ/WvAQXEd/r8/zxa32ujzzt/GUz/gknvVw7r88Ia8aC69zobfftfdHVO/PFv+u+L3l8WJhSNVBEPxbqvNiuFK35aVzV7vV+OTGQc8Xf/PUvUFFR6w4cXgAccDxNsgcJABNCMYeZzn8rBV1cBlizpKhXjUqvAMrVe3+bbW0E9XRgmiYAwov3+z1CCKojd3nW09WGIazooOn95HiRlK2QrCGi31UwonNcVf29ZNQCjIM43Ys+EHGaZtXLCTEGUACyZmiTeRTHCcO5jN+Yc6qVQvLjPxwOLRvZWqZY67Jrw2wIQTLDKV8O6jRaSkEoBSDSbDpL3iLySB/jMAyLTGwetxEe3tdpPaZv17jZ+1obq685K/vnetKdFn0tJW9bX8HJxFUfVKVsTO1leKUf4FKjuOxb7lcAhMVXcn0voUJa5jtXRlUHLaFGIyIRHt4wDvuAm9sDEgZwJYADpvMZ5+OE+Q0Q6ndh+SEZmk3G0YIln+k00jSs1DLEAIWXegyBukN8i9IISHGQniiqjszuDtJSGjAMe3DNck4tqDULzQ1AxSy8GnGl3fUMMpfc9ZJfbO0S42sEv9rX+bRxhuu0PWAIHwJckCsBlVAz4XgWXZxASAMw8ICgc7Yei93Jr816VBUiD3s5wX9fCnB+CPjuJ98H1T3mLLRgTDfI5YhaBEsIUco5P5wmwQtWT0wAzqczjl+9Rp4Jt7dWwsloT8RhGBAiY5rOuL9/g7uv3mCaJpzPD2DNDlQyo0DK0Zjji8ldRg/HcWw0Z7/f4zxNuLt/WOBghrMCnfZdrJPDK0xuN1xCsPnScHD/vq91gIVDiDt3iV93GriW69c0sZW7Y0+zLABUlp0AceImaGlvCSrONeH+4QHjbodhHPW+peFBu92u0cNSagsoKKWCAiHFhDUPCaEHAqSYMGg52QpG0fJMa73MP29/xksnGXtmf76fO9Mxr+mzfn79Wvh+nspjLEfwY2esm2G8W/ixrbkPcAFk/UCdhls5MlbdLwBNl5SgijOYgZjIRIamn9p9/BiWGfOLOMy4/e6v2dJriR7XBZ7b09qzw8xze27P7bk9t/fecs7427/9W/zgBz/Azc3Nb3s4V1sXWqDC0FpQdDAh92skELe2aGQDe3206bX7LZp2f03AXKji3AVwE6zkeE8B3xAxlfGpldnwRuilNzIRtdT2lUszqprxoNaKV69eISIuInJLKU2AXI5/7QSxfOTKDJTaamhL5Juqwk6ZaYIuO4MTCchQS4/UTkNSJaQLl1Qlq4cYxi+fecsRwCtu4zherIc3qnhheh3JvG7eAWBhlNJ9x9yVZg9y2Zj8Wl+7x1PalkLyuEPF9T78HPm/1ymlt/peA3vvcs/HxucBwK2xugP2R/toe0SOCrLVV0UgDsnsbmmFl12uFW3fArl3c6Nde/7HnvUpoOE7r+07LP0W8PDU9tjQrwK0DDAtHXoulez1O61OhHS5B+1dt0wPRh8Y3MB0cSBZpfeFAdkyqFp7Saa+j9bPu/3Azv0DzD01u8+SYKnb7z7b4f6XB8QR+O4fn5CG7jRp+854z5peEHXFHlg7sjn+x91pM8YOfhqIZjSZKLRSVaRpnZvDDAEUC0gyzyPGhHHcI6UdSvWpvyWjSVT4VsAcMfws69UvfwA4Q90SbHz7btwGFHr/1LPZ8PIa+76b6PzV1+/WrmMo4NxH3rKyWD0mqMGHetEEXvRnidSf8szXm3+mABJHGecss3QNgqOGaHNkbNqiVt+WMeDrNl9Q6+f/9YAvPmOEPeOP/5eCNEZ4A8hyTTzP6FnrAMCcRmRvB4QIxMO+0aecM87nc+vJ8/EFkNbeb27GqWkWJweRI5bAl/B7NfA5uWB9j7e1a4bItXOEnwOLlu/fL58N0MxZYBAzuPHo2LN1sPVjexkNEEzDoEbHLlMZb/RlIBrgHcWZey4T5iwZZ3pGQnK0SsXARpOoOdBY6QuTq0w+9QC+l0VKmTVjYX/2UgpOpxMeHh6a3GvXp5QaaG59e8DZntPTXGBp1LXSHVvyib+mlHqRecgyLvhIXO+8ZPvFy1Nr590teVcMBr877XJuHpdx/DP7ZgYD/66KETuqY4ydF5dzGcRgzhoJ7KPc+9+d66im0+jyYgxK87c4Rv/sKSxWRy5nYEnVLo9vOd34KHfemE6Gp5zv6gBjSivhIoz+W2qdovr5Y2DrGeF4MxPSeMZHf/LvUHCvASlAmUf8+r/+zyh5vLjPdePs9R34vt1XP/nehD/9F1/iv392Dw4HEAVw1YRqTOoMIk6e3WBt/FjlDe2rs7/QDr5/19Z3a0ZXjW43o13oxst1xgLguu6x0uxgWA5zN1gJTVAnewg/XJIRmdecZ9X3Ot2WMpCsJQslcMpKp45q8JymaZHRzPiSZbIDOh+xc7eeadPgKF80/th4I7oea3w1oKLmqCWZ0mKuPe9YYjVLqfMajf3mzXTofi8/rssyit/efS8/d4zKB63JZ7+TrCRW++fdbqHHrj0NQwO8uqrbJPBaJPtNyQyEgsP+IAFjP92j/O0BhIKHn/wVPvgkIdAR0/lz5PsThj//NwjzbpH5UWR2daKG8Sxxjo4sNEF4RHfvMN2AwT1TF0uw2ziE1XtzibvUWlFLQQwASHTlVoqJCJECIkLTu+TuRpGhuV6XtDnoOaYnEjxvFv3Icjp4enBlWa6siUN/iPVdHwAGAnopI1AFkTpVxQrKqkNywPTpL3D69BdIMWAcb5DoBkM8gMKAfASm/7gHT9R1QB3P3ff/AufDLwEUWElT4j24JswoAEXsxhvUKulIpBwyMGdqMl0pFafTGQ/3D6il9PUcC179T79C2kcca8FD3aOegdNfHEA59TXgritV3iPkWxzwIY7f+yuczicwF4Qoju1DGCF0din3mgzunfT2+71m5FjTnS4/++vX+8mCDPs5ht+gZYGR1uXyRxtv07gtTHPr8+JcJ0WxEmWTF4PpnR5X0LXNuSAN3VlFaB907bscW4rpUAAQMIx9nvp4t8dpzhQBknXdZzxb6wdfH9d7nE+s+97i5e+P31yM5q1nXOBocHOlMgXBldAF63t3wul0xnSecTjcgCjKnnD48KWOvrzvNdz82vy9H175j7s9O8w8t+f23J7bc3vvLYSADz74oEVK/q42EvVHwU0TGmsH0qrCpYJGCDBHJqRIOnhTnkRwrxKVDwhABQGuJUNKVcVoJXCr5cmiCsSgws0QQZAIFzN+EJOWb1AArKr6SwaoVBCzjgVynAi1WHph9UAPogqXUlFLVq91Uw4DQkoIlNSAGwVE5iAZaYjASADHHg3RUvoDtXAzpK3RAgJhSCMiReRSAIakvw09c4JoGpKu0vqWfJURtRBK7obgGCXiZZ4zSskLMLPrJyqsOkHZBGJvEJeSKoR1On2gp1xegzntHHI5JjyoQkCx1JpqpK5cZZzUDbKwrDj27K1vgIIzrKlz0Bpw2mzsQGbqYFgHJ6B7zBQAf20HYEFd0PfPvhnpp20dxQZ0oHBLabjmLLE+vv2caBagxYzw+oB7erZoJRufRh0iCHAk4T4AJF1/oLA0Oij45FEj9vPt7+j2w9pR6Joj0WNtU0Fqyys7yvaH/TYAxMbeIbHFIC/Gt3Xf7kCxObrVFFDfR8DFemw9CzsAMbiUz80+o7YaLlaBHYY0Kol1bz9Z/Nry/aQQmyKsyAnAAuq1URPcVTqHi4wV8ru6jvt7aQBWh98k85VdEySdPgcwV4AzCAUpTAAqIhXEMCKXiukY8fBlQtoBMYyIUdLAWqr9yoxaDAAPCJQacFN1PLUGVERwIL0fw9JwVzYDn4GgAtgKmBvAHIUnxIAQI2KQaMigoFgcIigJilAZqLkiRcbNTcCrDwDEL3GevsBc9qh4ZbOjsYUCjHbQ1JdiWpocDcrtAKk3X15+GHByAAAgAElEQVRvq51+9ZwAQuC2YxffvQvIsj7D5AgD2/uYuWXJkfN6AnUPal86oNDCOGv9bbV3gVDMUSbq/Ee3Dh565MVvap/tnMrioNo5zLfXlpSKcLyLON4B6VAQ8s8xjgMovgTTDUqNul93YN3DwqKoP0TLnWNR+NTkOqIR4xARaIdaEu7vzwhBs4wFoQ85FzUsSbSfiFgMaCQyMSFB+FdICWxRuyYPEaNlvmfju9Q+N55NjqQzNxZn7arR8OK4vGmAZffrzhTB5Jx2rcpuxkc46M4NTfazzWmOoxZpByJQDJrtgFqnwfqKGh1JusOa0YFBSIhhEPAfETGI0SMof62VUVAwz1mfr+o8VcQIpBjQsghqJGcggEJROVKdAWvBPD+4TFvA+RhAQQzSkRgxBeyGvUYLSj16MzhaaQtmxjCIoUDkyE6hqLl3UZO5YuplSU1WNMNn488Agjq6sK0jEXb7QzNgtLuQGM8J8py+7GkzOpM48ZsD5oWRApfOWVtOV+u2Bfa+C9AeojnGy5o6cRRmuF4YDdmMqEt3lH7PbiwB0LMrSEg8AGCeMuYsuk1MCYCUD0SbC/kdIyFSAeoE5jOYM1SDaqUBK3VO7p/U+AZ0zJ3mA56TtHds9fnyPDe/q/us21ratJKBvt9+8iWnUPJ3taTeI7tArl6VO9pq6++fwiO2uPDWEYKWHIHy0sNrhHgP0dmBMO2Efj/a9/YchNWZ3zZ/22oUC+LhiBxGMI1giqhVgk04GP2AyFsmTwBKU2SUpJ9D7ceaAM3XiyhyV/y+/vip774lLVHabedpSVPJZjsjlyz6dxTJ0IINSPm3l+G3h0+whBnM5sQus9E+g0S61MyhFEctWx0hyRt79jU5p6KUWcr2kDyP6AhBMuhSUEc86T+GqGPV+hoQmdyypPn5WUf6bxlnvd5dq2BTKUbJMoOgHAdIFDDGhCENCCQ5hLiIrFKKOZ5qxuAyK++OzRFVshnXi/uunV992yb5vHl8yR8Wwg0EO1FptoqepBEqS3qx2pLvZihc7+PlOORZJatGjAO4AoEigBFcd4rn9YxszBURxvBlzE6z1PGuKDdBBT2C5Z4ksMomQGR97srK9whcBDPMdcJUAnY8AlxR5xn8mkCf7ZD2jFf/6gPsPiQAI8opY/48IwUZbwWhOC2JoHyVjN6JzG9SSwQvngbuqQLEaaYyY64FiURvM37ezjUSQ4xKM5gqKpHu0ghSHVFGx1JMlTu/FAcDcYjpeV+cAwtoUbbIj9Xo4Jo/X676mnxc788ebxwj5umMQhlMEQgDiKXcWRoCEM/I8x2S7YKbDPoeI6YPEIcbpLBHTINM0N3c/Bd5JVfQBwnh1YhcMgpnAAUpZnCtqJkReMBcTwACOHIbJyV7+qoqTsbD8Q1SmaFFfBAiY/huRjow5ruA8GYE6oDyeQSmcDFX8jkASIgpIH5a8fLlC4RggaEVZJl6ESFl7BIIEbUGUEggFtPzsEugmLDbET74QOTV6XwW7KLKuKvSK64Aml5h9HxGrZMEMrGWdmICquoRMIe/nnGEFG9nK3vkaFh3+hfdoWUobvqg6GrgotlCRc5nZtSiWK7ylxhTc2hhlbMMdwFYZCyqipcAuRZUIoSUNOv7DK4RFAZEGhAQ1TlWeghISAEouYCoIqahPQ9Xhjh22hscdF4YxBUBMn6jAMHR8/Y+fANHGetr4Tjk9OpA4qRzGVDY361v0sjwLIhOYE5HTTrekE/lUECgzoK4uvNY+oqmuiuG2OiOqaBkqAmJrBAjprlgLqVVxGyBUmT0xAfP2n3Exa9mw8yBIQSUmtXJkGQPMquO3KZPxtco5TeczOfW2rPDzHN7bs/tuT23995CCPj0008B9GwZv4stUECg6IAAi+6uDZBqP1Cgw/ReBE3lKtcWTfsNFcYAASTAXYFm9NIv0iF6v1DBxwlToTlUNHWqgYBJo33N8CO6t8K8XCBpiK0kE6FUNAGNmVAUSO7CroEkQaMvI1ICQpjBsBro+nxqKKUaZdSma5ghCLx4Lt/EmBHBxIhkUSIVQG7AmMnU3pBotdqLm9+qWoUJyZLtpwvh3XBDG+KkpTD2Y+3Zeky5MqeQa1lTFg4GDcHtd2JIulBzhGrXMfexMsDVwwAmpPe/qwJerbTMuyg4i3MuFRRvGlUbjnt2AKsZWzpM0OKz/+2bzaGPFnxMObvmqLF9fPkspqz1e9DmdbaH27tFZmXh1geroZUoIoZBjaMVPkK/gbmPNj/HT1NoHnNa2XwmvV9TSZvSbgVidDwEfcBlLfZr6/fosa3pXSjj/nyhIeSUWHbr1fdRX/O216q7kT5XO+fKcbnj+jo5lmIvfwb3bkaK20r2mkc0BZjbe9Pm1t2OqJeIsxYoiPLtAJ6cT4ihYEwMkJTBm+4OmCbC+b6v6ZAGDIMYT2osKGUQ2peFfgSyNMWMYjRL9zilgOAMzqwAvE6KlLluBsqgzyLlCikExBQ164J3KAQQCZUqSi0o5xm1ZOzHiFcfJNy+mnGaXiPz5yj8Edj9Zwuis9jWKoDaj3/D2J3bV2y1Tn2Z/Zu3cebijehZVlb39ONbXnv9zV+Dsx72t7fRcfTNcdl1lp2GVk9mMLLByuu5WPO69X0IaBllYnv2ZbYEWv32x7sBAQ3Uke+umeK+aVvx1FLxq787YbefWqaSXCNqjSiccfgAuPlQShUESgALkMvNkVmflk3mEHAtxIQhDDjcBNwcT5imIwpPINLyjhUgiiBO4vTGLOtDAIgRh6COMqzZQqxGvdIlfYJFCU4rxchWE13lOnL7ma/t+EdaYwS2NnEJUHKXaaH3EJnQ6C+aPGQOGkL77P03GSkqPaTGN6U7c/QhICaE2N+BwlqajmQ+x2G34BVMMkdCY0ROY84NDA3EGr07NPkvzzPm6SR0zbKs6BiCZhApdRaHGTUkz5UR04BxGLEb91Kix5zgSRwEmcTkQIGknEZl7Hb7tn4hdJpozw2CGoQFEJ3nuWWaEQOt7mq3HjFdwnRpoPZ8vUSpo5ttrZZlPHxpqk1wXOW7LXnsKZGej8l+6/NYgXtPKdgMD15mZiAQwzuu934us+voNyCWIIeapURcqUWz9qjDsxpGJb266EXiMBMQaUYpR5Ryj5JhxTpF5nPcyu4W2viplVFoNLs94yXl9e/wWkJZuodi8TcB7T3WD0s+syhDeNlP564G21vmgK5rvAt9uVjlldOMW6kLHur/osWx9dVvH4mfM5v7MJwRPvzvOE8BSHsYnWAk7F79PUYeMB9fYn54tdGXGoXdsS05YHvc3057+eEJIU2g8YTPPs8o4YCCBOZeGgWQPQ7lKxXLbKQXgQbGcwiOblyf37bHn6aqtNYcAmE7YLULbe+yOqdrzaxchC7H5Mt/WvaVjUFe3lneZ12hbrA0HMCkPNMrVIav3aVZ8AALhLJxFtQs400paeZJo3mGAQkG02mzlTiSEtKBghg7gc4rV+u0dkwx2rYZMMIWvCVOOkGdnhMFdfgWjCWGQYy7lQEUdZbJLSsOIUi8ldIxu//W7nhXoyq7ee/Oof17mWN7j2S+zKnWjNid/zBMTxc+sZQu3y3YhK/8bddE5xybUCsQo7pBM3A+ny+yx3ErZ2a0jNzHK3oB+ftz/8UQnYyFhpNmgJhqRkXBXCrCDMQBmKeEQCNiFReXSIz94Tsa9MYIfIMxvcKAAYyAolK6FSTrNE0D45SeiA6gOFfjdU5fRZf3AwE0BBMEF4/jM3OKZw4r3YHK2WLQF3k7Y/hgxs0fnpDPE/DLD6RuHtQ5jHoWGa/jrA3DhpqZu8iS4izXYpukeWec7f1NIIxjwkNmVJYsU4EiuEZxcEgJFAvmODcDeRwS0s1LHIYfINCgxvkJc37AaT6CsQdUrvSyRUgHjPuPkCojz0XmKQ0qs2XUUnDOJ8memMRYX2oBk2YFL7PqQwW1zqhcLdcuKlecTzMyMUqJiHGHMOxQP8mIDNS7gPJmqWe1eWPC7v47GG/2vXxTYHB+0PcioKaM882X4nSWIlKMAAXUCoy7PSgE3A4DbtNLTL8knI4n5Bf3qLvc7lZKl3H7+8bq5A5wUT0piCbNZHiSyOuC5dkut9J7azcqNDptZKaos0KtRfrXbJy1ZlRe4vYhECJJeIllfEGQbGQAI0TJDsXMJmZKMGcQXbmmilgrKEWE6QzUinnKiEHsEVyoy3oAUiTlIfeqQ4qbG7g2pzUCgUnxNV28Whm5Zn1+k32HbZ5y8blL6k9ypmGd/RBFNmYGalXs1PM8buTD47VPbUQOByTRuX3G0c0+CU0fWDqv9HMDERDDcj7Ygl6VsjAAdPtRSKIfxjRgd4i4ublBKVUDPaqxM8Hy0fV6mJyDClBAIEIKQjhjK48OySi4DU9e4zrP7Wu2Z4eZ5/bcnttze27vvTEz7u/vMQzDNy4h8z7b0pjb21YJHIvwARgxECgkWMaYnDOm6YwYk0ansApvEJBWAa8tgFDGYDWIWQVfdZhR810DlZ2XvDi2qABWCyx6SLzhJSKhCXIhoNYMoiRGnFpxnibMc0GMsdXbnrOkDOZaxaDRwAt1dNAxd/Dt6V7NzMA0nVsq/ZQSdrvdoszRZSSTKKoCbifNAmNrktVZySLBSeeEG6ANBkJYgRtYGisuHWEuo3KJqJXhWgNdkrUnLvrp96HFfdbzgba3lqmJ/XgugNCN9nZQ61IpWQN1XXFYjrlFuFFP6dkiKtq1/d7JGX/Wz781Rn98S4nz41yevwTkvDHFn7/qUA0Mii6amZhEKQLMwCZRM6yGmLe1pzrEvK1906gPA6aXlKc7uC33/9PGYFtk611dGriW7xtpnWl7f80ZzJ9vl7SSCQr+Lc/p7+XWe7LeB97hbQuQ9rWCLyehA7VmfEBLX94V/6333miGKfDy7oQ239bLPGUgMYZ9AoWAh/uKX/2X76HMg+sQGHcDxr3Stxo1crW67Av2vGTYESoDpZaWfQEsYFApBYhBlXZZnx5nRkgUgZD0OjUshqAlAeyZK7hW5FrEYH2aQAQcbgYcbiOYTpjLa6R0Rky1GX4KGFkgc0womEhLYUEMAMNiJHov/dcDjG5qlgBf+00X/SzWSL9PHJBgKcL7/Qyk3XiLFveG+57dSNdw/eU3l/30/lf7ycAxBcUqdSD5slL9xnVwc8LOMYmXZl666EHG7F2X/DlF+7ket/71m8KiCyBc3peE//Rvf3RxvpxX8Af/w1f4gw9egzggxh1SfAFgB+IB4ATwDlAHGhWvQOEs4DxHDGPEx598F59/8TlOpzcSfR4Chp0aMAuh5qoALrDcdRE9K6AeY4aV2wKZKeOSpnk5s8uH+t3XKaVxhd+2oSrJMANciFEjPWujWSL/mTzcDXVmypDU9AocWgYEOJm58QRytzV5QiI0hyE58HIpb9hPlxMzUggYUhRwWp2lH45HPNzdY54mDLudGjcFHN3tdxjHPWJ8oQC7OUt0BxmTq0HdQTAEQq0T9oOU3JhnMTpWzloaVLNsxaRyp5QbXb8+/pm8jOfLAknpoF5SyJ7L93Ep31TM8yzP6fpan7+eW+1xuR2+ofzy2PVr+d7O9c/cxxyWwsmqBZUhmvOU8lXjxbI+jBAjdrsdYgzg5gDaxyplriJiJDDOyPkB83yPOcfGp7Z4TecPqhOZkQD9N3DJf7DRF1bX9OvQs3cCrW/rxDj9Jc+j5bnu+21+Sej0/HrboiDtmotxLnnOerf5Od0qFdVHz4vrFvdc8TQCEG6/xPhH/0Gz98mVFRWBZrz84b/HbiS8/vmf4IuHV5vzY9nClnO6MtIDeCqXW8sH19r3//BL7F5+idM54/4hgsMNuJKUQ7F14usOMu+iL17Tv34TjZrwLK3qexOCldGLqrcDbZNv9nNFkjO+xN7ZUleaLIuAfwOFJxu+4vs2euVpNCB9l5JBFLDfHxbnWQm93W6HnHPDNlqZ1RQXIz6fzxd0eUv3LUVwGgoBJYvDy2F/szAuy7g6rzBMyIIT7Bwrs00UmsFO9oPQ1PXevqaT9/HJ3K/Xwq+H74uVYMqUX5Ze8nNwgZvQ9T3hx7oxSlxSXvl7GBIOh31bv2HQAITig0w6z/JOqVuG52/yblnZS7uH7C0dN4nD1uFwQNLSgoGBh4fXyLGCCyElwu3hA0RKYM0/FFXPyupaF+zROytRNzKAm17BjSN4mh0AjDHiZj+CqqiOgl3p2rhOCUEzXcv8y46wvQTUCuz/aMb4wy9x98tfo/5fL8EltvMra74U1XE8frosS0sLp5lFtk6s3WuWz2R/X3KZPmrrgWhU3YHBHEFI2l0F8wSiCWkoMs9UEYeKww3jdldQa8Y8nzHP93g4vcbd3T1u+UOYy5IfTS5vANwjjXvJeJQHxDgg5yJ4cGSgDgg0YogjQgjIecbpeIdpEicbcMU8F4zjDgixz1ut+PLL10jniHF4hf3uJcJ+xPQnZ+z3hOmvA+a/WM5GkytKws3PfnwxR4tyWt/5JfDP/xqICYebDzEMKsPWhP1BMh6mkFDuB5T/fMAtgPynfw96dcQwjNjv93h4OOF4PLaM3gBwOk0o9SD7iiAl82ZxVmTd0EQFiF1vlvgHc5jwkog5R+g7S1Km1ZwazBEil4KSC0CCK4eg+EdMOBxusN8dEKM42B2PZ4CoyaExqmM9M2KUEtalzHpvxvl8xul8RMkTeNzjdDpJNkQ+I8YBJQIpie0kREKIgleGYCWbfHlyeabKIhswfJAD63MVAKSZiSUQtu24DfreMbVLjGLrmrWNhwDFuErjSV2v7f1/G3LImgZbCVb7vA4YsBFaEKd/jnVbY4wBUAKqe8zJDPZ8MUaMuxE3N3u8fPkSD/f3eFPukNVhliiCFYsTu0ZV594AoDTcoO2dFa7+Nn783L6d9uww89ye23N7bs/tvbecM/7yL/8SP/rRj/Dq1au3X/BbblsC3DXDOzM0alEEWRGQI2IMmq7/Ej6w6xTWuzheG7gj59gwpHSPOxe8UgFJhWERboNhwiyAb1e6qwjiJTcnlXG3wzBwM7jWWlpdVdFKoAqKAimMR0HspzQxLvRa1afTqYEpAmCL4rwW4gX8qS0zDpFE5OQy62dIfXE1XAhITrCMC93pB67/pXEBQAPitx53bWBvc8xVszdcCrP2PL6PWqtmeKBFf17I92CYv9YbQpbP8va2BcrZ9aJI0qL/RUTs6p6PAbPrc9+1vQ2E8gpEew+cYrPlSPHkMchNm9Jo6ZJbzv3f9aaPze4ZtoDYb3SLK+vuj1060xhodn1Pe0W9jZ/44h3yhkB/bD2up+zLdj17Gq1Qoe0F2BYwFwG79vLZH9uDqnI3Wh9CQOGCh9OEGIFxvwdW9IobwC+G1KIpjEPwTlDd+FiKOiNpKuGeCUJLQ6lhQdCjZYYZgR4FpA+Ln+6sKPfkBqYaeHa4OSCNAfN8ROYJ5/k15vIGtX4Ib3JqjjNUcbIMHoBkPEFAsqhXYvjIx6XJw63/aobp4tj6PG/klLitAeRcZnqmAQNtt5p3pvLj2gZm+99+bAvjomY72Rq/SRBBAWlLakfojiX+7AAI2AZbH7oo3RHsvCvP189c/t0MlZaZZwHifXut75h3OxdgnE5f4KuvfoYh7TCONzjsZqR4C6Kd/FQCMIBD1LT7DI4ZEgULAAHDeMDt7StUMM7nBzDPsi5kxgDW1NyEEHq2K3PU8KOXV0xWigKBIPXo104EnmZL8/zsa0weEShep3cEWiwtQaPr1bioGbVV3rXse1VLgRqNlci7LDUtmkxMkEyIJscEJ9+E5rwnsieAhQMugFbS1eallKLOIRJVe74/4c2bN8jzjMpiUNrf3OI7H30M0qwu0zQh54zzecY0VaTxBiEOWkojYhhGLccQL7IJiq1KIkaHQYy68xxV5t4y4chYU4rIJWOec1tfyX7Y5wZYynxmdJX57HK7Odj4Y23tiJBixOH2tvED+96exxzT10a+3zTgeg0g92VJzEErxiS8yvbaSt8RY6bX0QDJqtmd+6NsLokIr1H5ljl+oV0v2TQDTucjcn6DnO8x573Se4bnN57TGB3Wt9uZZdzfK0cSAI1e+9aebsN7ZNnnkgZfmrf7ub1fz5X62Pv314nK1jfXxu4/LzPE9etMe7W/VQTZvEegfq6Nc/kUl3MMdCcMEGskLqNwBWoG0bDKhibXM5lcRxduA338285TT2nrlVi38zmDdkDlBCCBa1JZVJ92Jddv6V+PGaJ+044ym3dTnZuCZRaR8yrLexSTOKQ+dajNAOpWrtOGntnEvhMdRMYSXcljP0fGDzyNlgOh0a3z+QwiwjAMGMcRh8MB4zjidDopfxk6znE8ggK1En9bTjlbOoM5Tg6DlAeMMSpfE7xpGOT5u0M+UIoa9ok1iIoWdPZCx7K38wpb8PzJNzM+bzXp91KHtzkVCro0oj7WuG5jF9+keWfXS13y8n26LC3yzd+rUgtS6PJHziI7iKE+oDLj4eEB4zgCsLLBBELFPJ2BvZTNqQXIFRiYQBw0Y5Zk2SKgBSgA1PxbjH8ZBVQ/w/5sgCVhlPmqjFpmDGFEKZIZpGeMXWs13mnGNR1/jAOG4RbldsbRYXF6pfAItkJD1Bx5zH0QK37S6TYv+DCvfl82bv+ueSppFop5rpjmilKlBDxYZYoAAFLq8/7uSyRkMAJiOWGY36AOb3A8nnE83WHOD5jno5REc/KjlytCKMj1hOmUEXDAfvwAJTPKlIHKOOz3SJoFM2lppIqCiIBIAQWEkgseHu7B7Pmv7OPpfEaNCTEUcJISpN+5fYFxPOCrccY9zovAh6XEYXpilxyW85lRw2vEcMBcgXx+QAgHHPYf4XAzgFkd/jIAHAAA8zyB8oRhHDGMA3ZVnM2zys7MjGnKkklSS8tWLpjnM2oRzLo7sygfsHJOkAzoHUsFJCsYFCMumOcJ83wWJ3eIQwk4IM8ZIMLt7QsMQ9SsY7JnQwiYckE5T+BK2O9vWplXoQ9B6a/QzBQixnGvtESCC2JMyHlCqBW78YzXr+9wf3dEnmecMYtjXIqgAmTNplOqYCS5FmCesRuT0gxzvihNZi5F6D5paUEL1NrCb7cwMXNKN/l7m35v023xa8yNb1mQqegyse2ctXPk1yGjvoKB/9tj6f5Z/bnv4rSznBdqFQmYWUumAUDQjHSi44GB6TzjDd6g5AzU2ukgy1rWUkSOCFL6iavRZpnzrNnyTe81/XEYht+47vaPsT07zDy35/bcnttze+8tpYQf//jHOBwOv+2hvKU9TfDooIwqc1WEHxG+l04vDZSFAYAEJoNYe/MKuCjoTiHnDhlaZK+k+dcIIlOeCaCgfWhq+lbjtAmEASlJaRkAYBXsQ+gp2luKfQoCPFZREkSZEINJiD0FoXnjP7WZIuENAX3uluCfHe/GBPMgl4itQBGpRW5JSk1zAAIYoAiEFRCkQi2r8OqNUvZbxrg9fu9M1cYKiBc5AT1aGc4Y4lPJA21nqFHG39vfZ8vAsZ4ff77//trY2zM0SOESLPJGhbVBx5r33r/mOGHXeDDwMUD3mjPP+nN3brgCgTymDPHqb1p/wfDpOt9lj3/bSsxVR4t3vI+/nNteN6ezLSX164DsbwE4L/auNwYvAUejB6IkXkZ+bO2NDlBgsc8Anx79cs4eNxwugbvLz/6YZWexvrbnYUkvjI/0KWAmxDSgVlGOuVaM+4rv/uTvMQx7HA43GMY95pnxN39GqDPw4Q8qPvyBlU/pGSC6kcCUb+7zQh04M5qv0AWUATj6EBbHGm0BazmT2uhk511CfykmMFcxQj5M+Omf/QBl+j3Q/Q2625OAneaQUsDNwBbaj9Eme809wLjlQkHu3/7p+gr6870jDkt0GnEbg0Vnbhkp+xMtgVv7XFdXGPDYx7H8Tu5v+0kAYljZCfc8UYFvKyhnfhoyVR0sXTjLrO75VKp17U0gSMQr09KV4LfRGMCXP/sUx88/EPmAEkJMCEh49UnB7/+L10jECGEEcZJ02syoIbe5E8h9wP7wArmKjDDPRzAmeVoCKASkqDupySh9d9Z6GaUMiJOA389rwHLNJ7dkgyfNx1t4ie+31ir7TWlILQVFgcBQuuOcOXQZCFwZ6jzU6a/07fmPzkwzTgKWe1EyJC4jzh8eHhZjTVrqCqhS771WvHjxAmBGVmcay7Zi15jRMsYIUAJoL6A4UQPAGZYK3vEYErMLSGV35ka3xYAyK+9k1GryulzDtaoBuPO1lATcNqPnen22+Fvnid2g6s81pxgfUWmy2tr5aL3mfl88VYbcalugu29r4/O1+7V3iL0bYhsx4ID2BV9q89d5melD8rJVTcPOTThqfQShkaf//AnOv/oEdfKcQ/hjZICpOyCuR6VbZUF3++9+djCRH2hyw9Y1rd/+RH3OXL9ekro8x631ol++OGZnP51uL50tjbcF0OY8WWVNkzsqLh1/bB5B2zzer0FwT7refVIqS9Y7BCAlMVCQXt96bKWuGveHzVJ1c7WUWr9ee2yOmRPEZZckS45muAxsafy57TWju3Jd18Gu6T2P6Wm/seb0yr5axie7QRMmqVyhJ9fozIKGuBeqy8Ke3ijNWIxleQ/DeoAeWMTMakAVurvWa2OMuLu7azR7nufm4MIQXmJ03Ee5+8xgPoOtfWe6jugHop+GmOQdCN2I1/EkIMYgRlbXVzceGx1c6mSM5bS/y3559Bzl88t5DWLIhegu676u85HLvt4+Do+3SB/L67vsRkQLR6ZlyY4+rnXwxuUjP/Ed4+XzmB7V1r0UlJoxTROmacb4B2+QPj0jMuHFn38PNEecfu8B8x88oA4B8//6a3A9Iv70JcJPvwMwUCkotQXaXwwNRrjUDTpPYXEa0eORLCnpjFKs7Biw8MAxLc5YseFcuscIJtdEECXEsNN8OH7VjA67SdJxiI7RdawKRqVOnU209s41nYpv6/QHrgUAACAASURBVIP9eamdf/jDz3HzR2+Q0i0yEkoVrStAyrsGddKY/tuI888+Rc3fQZ7FIYD/7mPcf/4hprgH1wNQXiFwxcAFIVdQTm5E/fc8n1HrGfshYRxGDGHAKUt2EpFXDUeoLWtJqQXDkABU1Bpwnk748osHHG5G6GjkXwJSHBo2OgzifFerBC2e54qyzY3dnPW9QKtZjHcf4/bP/41inSYFBNQw4i6p80pl8LlfN/7se8AvKupHGfd//AYAsBsHjENSnYCR5xnTpDpwCIgcNINWMVFPRkY+oMcFni5KvXUZspRZnJdYA2BDQEojAo3gnTi+H252oMDqHGaZswm1ZC0TLg5UUTGPdfYXceSJHSepMk7B4gm3+wNKKQhxhxDeoBbNKkniSAcwUIQ/VjaZHmCeMKSxZf81XL/tdIZ5D7dM2evsk4/pl51m+p9L+rzmLfa7qqOMz8huAVcAqe2ELu79ZNKpdMXT8pQGJAuAoN5nk+p4bXdZ3tRnzFnrGn7+SvXPbNfK75yLZHWGBFyMNGgm6NnJCgFDkqz/FQyQ6LSiF2umTXRdL8ao++/tjj7P7Zu1Z4eZ5/bcnttze27vvRERbm5uGnj7D62thSN/3JoXVwTIYPEIJwIzNeGdq1f+vHokbe10sAC9uBsd/BjEQKHCtIIlloqwlFm8mvUeXUjm1lc3YHRAXxSPprlDpTb9uzZA+BqU8ZTmhVAbo39+S+O4dDBx8LGLaLH6tDFaHwaAdCV5abDpzaIB1vO7HqdvW8qCRQGxu//l7Qywsx/vwe/npj/r1r2/maDcgR9WZGwBshNtjPvy3t55Zp3y8rHxvc1Z5tGRb3z/GKh6/V4bkHUDDLfu2aGU34X2OKC4ff4lLPOtjET/X87bNYPYY3vLvu9RLX7scq+rEKrrdP1+rN9Vvye8AW85viVAcGW0+juAyN7fy3mwtqRvlvhfFe9GpQispibJ1lDAw1fYfwAcbhKGkbDnhPmBUWZgd9tph9jlrT+pZ19qlSithoDHnt7bO1PWTtvFSNVT+gIkh8giEM1ZRmBKbygwg3fRMisUJALndDri7tc/AJ8HjBxh8UUGz5tDiRmmokKWFqFusxrYUoUvZ3u9o9crt4R81hAfFkY9eSoDhtldTy4WVlZvTTH886yfzyLYuwmYWnT1coy0OkYNsO7jWAK+PepPjChwx2ndF18+vx//u+z4rb8VHl/lXPrttvm4Rz7uQSB1LJLf+U0EFakNrq4dsNxBhQgf/bhgfGkSW0BKO+x3L6AlyDHPtgsqQrBo396WfKeDeICjCdxLG65Lfnr6fsnDnkq7df9dIbyXsrnQDSn70R1ZvKHRnD/6GC0TClpqaT9+A0iX5zojHTOYxTjkgVVvAOwyS3/ra5ayoyF2Wd2i+b2TSXc2iUAYABqE1rJkkGFiHY84VvSSc8rHNEI/TxkpRWdM61m+5HpbWnW2DhFJHXXM0afzOFxZ337c7r822Hm+FYIYmfI8r4xttf3eKjV4bT98XYest12/Nfb192vwnrEsprB1Ly9r2Ptka6P2NcAyiKgxwwIBzIAhOhAjpYDdJzMwnDF/FVFe3zQDUQtzYMBi1z0NFrlfx7U11tVRA+6X9HrrOjdHF+dQ+/ftq9Zl3jV/6rqUjfS6Q+i1njsPUP7E3UHTNwaBTE9q+qQYbL1jyvbIFx25+wHjp38H7L5CHe7cndzJJeHhlz9Gjgec33y86ciz5JyOzqzO+7bbzcsZ3//hHU6ngvGmgKHpQprbMDnRnVupKVVqF7Ly2inm6zq/fXuNF5vzUjdQcy5L+QZbie6o8nR+5++11CXQeJGzZy7O8fc0JxS71pwqmOEyrS0zX1rppZwzhmFoWIY5xlh2GKNVNs41H1jTQ7veZxgLlCSTnY7NrulOp5IdzgyTzOLkeTqdWraFRtP4sSwhb5lx9tdtf7eWWG1STTa5pi9e9kWN0L47r+LVGNkRlT5nPStnaWWrcq4XMtnbeNzXedeW5Qg7X7NgtqoyUSkFx+MD4kvC7sOEoSQMX36McEw4vzqhloqagPLRDIQJc/0Mefg5aj7j5md/ilhSJyVtRqhlcDG6uaSNSz5TviR89e8JoTJ2/7Ri/FA3IBhoRvvQr2RyvYiGZdAiV8acGRMX4E9+CZ5PoF+8An32sS2QK8yL1kOXRwmWB86ywTVdp2UY2+YpXt/qLjK9jb//S9z8kzu8+D1CooBf/7oAiIhBHK8ZUnonxorpFJB/vUPFHlJstSA8jOCHgIogGVM1449OyoXuaE85/vL3gPuPsPuQsPuRZI7JMzCUoOVbMgKJM0UuPoN4RIjcHUbAiFHKRvm7DeMOGIpkVYLIqufzEaUwpimiIoKGilc/Kcg44Xw6IuczAgfwz38A0j20RZ1p3iF99b3lwRdn4A++QhwPICSAgfo6oLzWsmIPB5mPKSNXcSg8/BhIH3RNstSM4W/24B0jfDxpRu9JMlq24EvVhM2pqsLRuY4TM4v/CdeKrBnXASAmda5PA1LYgShhGAaEwCg1A0xKv+UZOAYwixN2COI8xZots7/HPYOi6DYidxLEcRcIiGkHCgU3ty9BlFSnyJjnCaVmmNMQM4FLz5QTOWuAppSlDVoKl1u52YacuOxlnc5Y81ku2zoSNZ6yxMUuadtaRwEALlKWduEsQ9SCbT0Odukw8zT6GYjcWw/R4WJ0JXJXGDt3+uF57FrvvuYUtNA5VuO3Mn7NRlMqYiCM44ghRcx5xnk6q7OoZLbzDnBEFSBxX5RsrIqJxa431VquQd54PxLqP8727DDz3J7bc3tuz+030v4hOcqsBT5gKVAtv/fCJashpQuTpGn2xGEmoBKjFjRv76VQ4yOTzRHBJfomApygb9eY4gmCGCZzbsJ/F6h6VKoZQAXk12dzcOYFQG9GDShkZ6A70UK5exf57JoB2x/rGWYuAYcOBGlGneCfy+bCAPGuGIWgBmiK8GWwFljZahxbY16Dj+uxLQX+JSjUQHSy9L5LR5MG5lwBOK85R7wNvLm8wMbbwTVpywj4x57T/20/PuLZj3drDdf9vMsz+evWmUT6b3nAx4xAy+86gCiX2ndeIfTrUEG4jCj7psald3UQeup9mB08srrFwsjEnqZ8nbatQD96BXlwqKcG33r3/V4iYL1N2zlbf1/rb6v//hkg8kasrWdbgb796ivnr6524IIZjsAG/AWAkpArdW6Zc5HIKkyI54JhGHHz3XMD4o/H2sAMomWUqRmmhUlEALWlfCU3VmNJBrL5fVeVFwjbs+NQPpJdBI/cM5e5pelOSVKEH4/3St88ZNrLB0l0oDjDgMVhpo/N8dX2GTAuZACpf5ZLMFSBja0VZFocM+CVsARqL0Hm5XF/lNvPpfPMYs4vxtOdYrh95tU57kfH3ktX9LTqazCzrfGVe182uvq93Zsb+GtjtWhOm+unGV6/7WZz6cuDiMNMwq/+fFjMta1TBeHwvYzxlchVqIxAAeO4g0wgg9myeRRUquDaV1dKFTm+D1IGtZQRRGwR+htjxPl8XhjFdrvdRZQ54OWJy2N23H9m/cevROuTbbf0DsU4UwEuzmmm30fecwP33DXqMAOSGWfXfyBHbXhL1jaj2WUkn0RmeiNgl6XMSblkicbsJZYGnWPS0li6HyU3OcxTTZwquGWCYc2YUyl0usCSeQZ1Uqf4hHmeUWtpKdhN7mzpzimAmZCGAcO4aw4zFlno12CtI62Nc2vHIX+s8ThX1qOD221HbPJC8muCS7ntXWSOt8mJj7U1OO378w5Fj/FUMST0d8Ei1pmLc+i290+yBdSaQRxAIaLWgFozSokoJWIcI27+8B5p+hwPP0s4/+0nMi5sUdQlT2H3hl1SvcvrjJtcOqdckz08v1v397aZ6mPa4kdLbRTgzXFdtiV/dWWYFplfLsfa6C2TSw4pz3fN2fKapGkjSB//HHj135Azixyl5l8iRgwEYI8vf/UTPEwHd91G06w2flT+9/to437CR7//OY5HYJ5GlJI06w6hKp813ZGNoK8kEL4g+u7jFRl5q31dxxr/DhtOsCUrrS09LSqeWFIPEUPyX2y5Nr/zaBb8rN9L32RTQvziksn/5qgQ1JDaHRcWxjSnu68dXs1BxmM6dp442siNjd9bppqcc7v3mt+ty0fYmIS+YUG7+3kMqPNgCIR5zpJFQktIdcPf0vHwSTPNT3tDFrhZm3fH90GozhH/8T7eva3lIpGJrNSI6Ukyx5alTrJ91os9tJ5rP6anvD++n2BZr5p+KKVLBF8RV5AQxCHr7u4etWYc8g438YBBJ5JrQa0ZtY6YJyANA8pHR5xu/x7z/Re4+ft/3pwdjPeYLB80k2ZtukfnD173IRDKG8Kb/1dyrISPT8Dtue3bGEbEMLSLWuZTABZYQvqaMwPH4xmn8wNqzQg/OiHGOxAP4M/kzt0BxviJL2TkdCxXspf0SjE6M8BrWrSknaE92XIX3/7wjJtPI2J4gZIHzPMJISQQ2Y/oABSzyB2qO5ocySzhHj6TqOdk/l9P6/Zffh/4EojlAenHnyEFIKaKmApQCkqdgSKOO1VpjvhKJFAoSANwiHukuMcwDpgpqBSvc0mxOYSXmkFB8g2FAFCQPRBixfDD19jvM8b5jGk6oZ6B/FkFyuP72uvJAEC3E+JPvsDNrTozl4r55wn00507l4DjAPrpB/Lph28QUkZVnIHpiPH1R6BXE+jmDQDCVGbECtRiNMTeScG6a3uvZWWEwOsYlT6GQBiGpM4m8nVKCbtxjxBGdcDOQCBEpJbJnCsku3mUbOwhSpZzCVYipfdLedYyp5XSZyeEBAoJAYRx3INCVL2JtUzUhJxnzHlCKRk0S0mrWgEwSTZNIozBypsNqKR6ZJH3IUZx6JHgjKWDh7239rmtmcNWO41b0VBbb6fPNT5Vl46GxvtiDO68oOvz7vqGyfVLmhyFanHXta1kHRvG2QRNc5btAsDaWabvD6yO9TkjEroM6nSbwOBmZ5F7+YuJZFxcK8bdKPPOQM5nyWwKaMYoauWM5QURudp4pWWtbXKMyjveeee5ffP27DDz3J7bc3tuz+25WXNA9Nqguj7ea6BaanhzcBHvdAM6iAikkcMpRcxzAeeKylUVYBPIqAmhBoRZ/+bgEgioJSNnSRspBgQ5F2QRU4xpPqkBM2IcUzOmLQWogF5CiiSCqgmVWg5DDRSlFJHVNMrKhH+bDzeBjwJb6zn1YzIQyTLj+LT162tq1VrGVaM8Yo/OthJM85yb8YKhaQxTVBA9dIEXlgGog+yXgvHjY9/63I1ja0G7GyNMgCcyIK2Cq6bJbYaCLrz7CGGvgGwZN7YcBJZj7UJ/70thkhWAZvNg/dRVFhy/htfmaQ0qXYCqWM6xN5DZs/t3cBOUIlwoClvz4hvbC8fdLEBN17octylXHQzGZX8b99lqTwHULsHed7kntf1vNKKZ4Z2yJ3sAoBaNItc+9bkauLZa2631aN83umfzDDVsdiDDr7cY93r5D/9uLJ58BQR40HkBTLp3cTk+BesfAWq35mnrObc++35kD2p2K6UbFAYwov7I845hh9O54Hw+air3I07ns+Mf9sya36MB4LLuKQ0KiEkJvwoDMHpqeFKaYATCUrgLbQVKXa6FRD1WTNNZU0QbzxDQ30CclAbkSrh/eACYW0YVAzczV3GcoZ5hptFd2Fvn55AQmDUdtxn1loZfl8x/Wapho2zb+ohC5gobB40UNIhT96czOML97j1efrPeBbT6i9ynFqGvRysDBRWZuklWgBRndmWNRFIDJF04AQEtXfojz08bv98VfjHImUBalonfhqu+t2ZjFgeZgMjqLMM9O0/Axhxpy8eC+Y6QYsGwy2BEpAikw4gYb1DLuRm55llTekPA2VoZCKylsQIqFdRqTtH6fjIhBUItsibjOOLh4QG73a7xvMPhgNPp1GQCO24RbICny51eyrFO1wiGI8Z2nn1XPc1ukyfjMzq9pod2S4uW7PeyudfIYva8QVOMM0AhaORcNwSLvJwU2L1MGe7lpwa+agktrsWVHkKje21uWGmclTMiQiVNra70jqEOUDC5gzE32UzAX5SKmMxZRvhKzhkxJnXQ6Q7yMSQFiCMo9AxCPhV3n8/Oi7y849fXA9teHvR9WRRrW9vanVH9XK5lx/V3y321wbs3ZIGrstnGeVvX+XW11o3QaJvLywuAvGvGj4hCe8+maVLZ36LpKxTbBlUGUBDAKJUwZ3U+CgOGISLFHUrcd5kJnh4uaYYdMQfLzq/ehWpeGujW36N9vz6r34MuruhnLJzkVnzL/9VZgx+Roy2PPoXnuXSRrW3JnTfmxbKB6rneVWf9PFutAogAaikILPIDmFHPe4ACEgFpCEjhBQJic//zq9TmivrfSweob9au7YY0ZlCoyDzhV59PiOEArkkcuSB2ycLVraXKjLWiOy+7+e5EuO3Vt+mvW+/uU3SUdV89kt3kF8VXSBwadRD9GnTeAeWPfPHFZdvUSah3vS4T6ukLm+7XynCt5KIN/doylBGpAyU6b/KZSZi50eI1XR3HUTKVZeEDlg0NQHOYWfN7u/9F2SbdwE7CvdDXfEaaECJyzjir7jCOI2K07GvmmGHUzDvJvptOc611o95yj3ldesFX3N71z99+niSV+nH0Ur9NrsDls9kcWbnFGK1kzToL8OPzck1ft++2svIGl4limmbN4seAlv4BRI56eLjHNJ+Qyx7Di4iynyQUgjPCPYFKwomO2B0i0vgBbvYF98cMkDmHL0ummn5kTjM2M52nAbbhupwvMvTpyzucojgwpGGH/e4Gu1cVcRQHBZ6TBNsFhmROEMcfMFBzxd39A+7uj7i5GTDEHQ63N6i3BxxvjjInpz2YPa+UjDJeZyyOt/WxU8tk6qm9lOhbcnDCel9JH69efordoeJ4rLi/O6HUipgGABGtXCCdgTBDMs6g3c16kTEal1I3QJVTa3uixc7peyIT6hsC7Qh0YvCpgnMFE2OqGbvdTugSItKQUOcKCjOGAbgZbrDf3+B0PmIeZ9TxCBAhjFK2VPT/jBQlE9b+MGAcA/IBeAOg1IovvvgVPv3hJ/jk1XfAzDjdzfjyVQSfK/hMqOfL93BL+iEIjUlpRJkTMqsDyq3OkJa6QyHQPIIA5Psz8hd3mOczHh4e8HB8wO35e4j5BDq9QUoDRi4Y0gF5KJjqGcziNCYOFMaDsuw9rg3DpBAlA16TzwkxBpzP5ybT729ukdKo7+ggWUCCvZtnycIZopb9icof5OlDjQhTREoDeFfAUTPCtEyTVv5VbAcpDTJzcwTNA9IQEF5UULjFPE84n084TyfMc0aei2bAKphO4tjHYMQUkYaIl69eIKQBx+MDjkdxxEipl6Q1p501n77A21a0qa0lXdLx9bm1KqZN1ErPmrNOWwMiWMbHawLWlu7hj9Uq10qAmY3LsooG9CymgDnmdhlAHLG26PSa7y/2MsWWGa7WWXVN4y2SlW6JLQo9Pd4/YDrp+EvFbhgRQ8R5OuF8fMD5fMZut0POGSkNiClpAAouMtia0xFMZmXN3hOoJ/h6bt+4PTvMPLfn9tye23N7btrqBoBtbdvQv92PCEuWkjHjfC4gChjHKkJuzgJDUFAcyMGwzQjZo1XlHAufJMSQmiooIEhR55HQxmU1LmOIGvW8bF3YXQq+15X/9+exLGD3MqJ2K3W8H3uKEYgRpKk3RfEo+lMVONdMCsWy0bAK1Otmc/wtNjKAqBs87V49qbspyQYkBTV2XhqHFqPd2Iv+u/U16/VVHBlQwK+lIQ1oQM26T9uH1Smb1rdXYLb2kB/rxTRdWWNTtrbO3VLUrjnePBnUc/c3gL8b4LonP8s/7+2duBjXyihmx/xvG2tvW5DF+29b4/qmbb2OUs8ZF3t16++muLv9Yoru44ZDAZevm0nUOWExzq/1eOhGMYX5atVkMxEUzBkSkuGlSommcj5hGHfKh7yDG2mpJP9u9GiXqtH4PXkONWWbq9BJrgBXyVbW1jNoCmKgAey1Fsx5dpEuNt9FMy+UNqZaCcRLLZ4BFDBAAs1nMGaXULu2GfGQtkGmpBF7zYVqZXjsYK5Fuj/m0Hm5GpZTQ2Dl7rxyCbAvr7Vz4Maz2iere9HiWjTjY+QO4QJAAYE0O1BdzUjvXD4Fx3sWBkF+dEdv/OXGt+FstNkPWzYRbg5Ndv/fdOvOO4TEoWWXsecyhxkD2YG+wj/7f3agAHz4+xk/+T8m5KKOU4EwpIIUGXk6S1TgEFEHQilZ97/RLbnTPDOIansfDcgzWaHWimmaMAxDo1EhhEarYozNmGaA5xaf88Bed0LwtOnSoLMGA3tfIl8pHncVPG273AzVAKLetM2oWCwlAjZQA/bMYacZcNQI6Us9+mfxrRkqKUiUZ+gGTJOPc56dYQqayryIwUSrnFiv5rhsTtlgcRDuvJeQKMp8qBN8CAHDMAptrQWEgBiTgudJs9+II7g9x1bzzjIAcDgc2r6wY1b33n9eGxljjJpdsi743rVyTNX2KF2f42t89jEnGuurlOIMzd0IvOa79uwLo6iTJazrWmuTv5i5EyiC6EhWNqtIuZSg14ojm/QRBH3WfgpqDeLkSYQ4R3DdIaQDUjwjRikPszSnbfMT40KX2VG26R8t/u5GTH8mX1yxoc9dHLm8t/zFjqdt02Na/MXur0tuRqvrGq113zWHjcX5l7KpferZ3PQdtrstMr7IbK12s9CPWoCagUrgaY/pL/81eN7L3JI45ZYcV1cuR8MbP9+0PbZG3/tnv8D44g5CIkZIqbiw3A+LmiJuRFrm+bfCXDeaf9ftnbYMqqWqPBmASF7X9PqNc5CTb54+BieLmjwqY3MBMUyrOXP73cnNREFLOhi9Qssc0+gZd97eHMXRaa7Ra8NljE9agBAAnE4nmJOElVVZO+v4IBLPtwMF5GwBJVXLc0wrPUf4maeta77vdX3vJrYlZ3yb+p05zHgH0PV9jDf0vYWvvedtbc2Q6jMvmwwgDtBF+Vc3Kq+xjq8zD2uebNmIiMTRsOrf/Ty6ek2tBacUcL4946t/+dc4Hc948Xffx3f/7T8B7xj5X/4COWVxEo0jhvEFmMjRNl64Ri3Y6YJ669gv6Lae8Z++D6JPAQIyCHcg8P/+FXY/PCIQJONMjABpqXguGGiHGAg0JLx49RLjbkQaImJiDGnGwx/+CscXf45ynHH77/416Ly7nEt9hgJGIdOLljyPFyO9bJ5XLR3ohf+kdEAIBXk+4nickQbNNsKiQXCtQCgIYQZoGR7g59nGaeUDbUwEy4pjORmNv8k61c8POP3fP8SRgMIfwVJXytpVPFDX5+1e6Ud/g/DhgzpkQAzyn36J+TuyF3a7Hc51Bh4IQzpgtxsxjoPgzshaGjEAXHE83WOaXuHmAKS0w+0HI27/T4DpHq//44Cv/sPhyswueWutFefzGafhjP24wzjuUf8w4/zxPeZ8xsPDGxyPr4Ff7fHyr/45AGD6s0+A8DHAjB2AkRngANx/CPz8+ygAdnqP+E8/w/ijz8A5Yp4CqpZIDUxA1Ly6XFG5AJVRSOVjXTKjv/M8S5YYXTxmqLNc12OAiv1+hzoCwP/P3vv9SJIkZ2KfuXtEZlZ3z8zu7C7JXe5yueQRpzudBIEHHfQkPerPFiBAgAQJuDuQ0B1ErkSK5HK5szPTPV1VmRHhbnowM3dzz8iq7uGAOB3KG9VVGRnhPyzczc0+MzcLCBR1r4jgvODx/IjydxFv/lzWRPnXb4HfKUgpoB1agFvHDYc+/eozpL98DT5kPP6bvwOdikbMnEEUcDwQlmXB5bIAuEjqtVywbivw+ICUIu7uTvjk9SssywXMBblkTJirw2ed4QP/eo6f7ekIvZze9hYiApPnKMq/gh6m2ZH9gzrLWkQv48/jXujbICKUXLr9zO/P/tqIFfv+j3q0x1y9Ptqi9ATnrO+jwanETEOUzyJRUDlLH2KIQAHOlzOYC47zESlGiVqnurI49Ozj6uOYunH8JyIP/udQXhxmXspLeSkv5aW8FC0jQHvrnqYkq0pJCeANopGaABarwdAEKKKguTw1vG+IXVtPGX+bcBtqBAZAZKIQEkKMNf9ljGKwsedzyZ2q6IHzPQGL2QyQBkhrqEkLY/+dC2K9w8qHCOxEqYaUtPyghQu2dcWWNzk1pdEUJIoOIKBca6+C7c/Azd9ySJB3/nHKCNAL7qMDzHOOJ3v1X9cBwDnm7M0Fud4UBqNXYQt227e1p3iM83mvPAU43VLKbo0dMCy5Vy72HIuGChpEMoRgZ9WYvULyIdP/Yx2Enivju7Fre8pf3/bt9mRpNzhDl/q3K/t2nA5g/OgqnbLZrYfqcHbdzh6d/PMGlH7oetpLUybr2mCwBrV1sNhHj1ejcykIxt2alDknaUUiLK8xa8o+420eAKlmJT9vWXM4a39tbucMZHUEQMnihKh8Na9bdYaZZztBGxTkF2NoLrlGN+tQ7AqIEEJIOBzu8Ob19/B1kNSEmcW0KMOWNWjchWHnWwnZ4DsijUyjhk4XaUXfSkdRjbNTHUccha5oP74tM1LZW/Vgsi8GKmP43u7PXW3QPuPqfrj+RfQOPmFolZUmrWZfQ4OGPehtbdlYPIhL7ul9sFzrv+Esw3RjDbHM2cgAU6hJwP4pixlvAzcj7vgD4IqapMC1ZlwCbxmgbxCI1JGCME0BP/j8FZaLRI5Zc8aaVxSOmrqMAWr56S+XC3L2AKE6ExQCgoTnzjlXRwkAmmrtsRrgzIAzGm+6MQ/7cuWj5K/1vHlvLzdK2Dpmzm15E+qGYSkEuPLKa94apMGuj1eyrpAB0FOa4z17Eebs85Y3cYzWDkrXpG+HwwHX7Fgi3+SyiamCNWphNsfzoKk2CNEd1QsUkNR42sYoNCIQAiWIca2/x8BsZk1P5yLT2H0WUdEbB4G//gAAIABJREFUOfcizRhQOxru9CH4eVwNqsFA6Nw5pgOQfaRGFuBd/WB8n/4d3pL1njIoejDap4q1qAf+1Ku14Z1/rP09sNj3TT5AjSQDv6Q2t6vBEoQYM7iIsXqKJ0xx5OJ09Wks1zvMDQFpd0dqXLnnSb6u9u0ogfjvvANgueJye70hJxeiGuyknWbAG9sK7vkA7ESXeb5wbbPVY7Sou6ZW5vcsP6YCicJKeUMgiQhxyRM4T23PI90Fh734mi5PucU+X26NeW8mZC6gGDDFCSgJW1FZkJxhu3ClkfG5KgnrTaPsOcrBzxUvF38bmX2vLitiDCPVtzxfATzP9vqIqehy/SP642QS2+vs72cerPeMxj8bk/HklGR+sV6PMWJZFgCoTq97hz5q9OEgEeUA4OHhoTo6MnONAmD7gTfWje9I2mHnnA4AGTn7k/Q9xmLj6IqbP0J7dT79jqS2xp+vX0LRlIh7c9f2w16X4aZufGSR/YUqpiE6Zat3WSTlybIsbj8M3T63p3c/1d5e8Y4vY8Rg/9mi7ZmxvlJR10QpjMt5wduv3+P7n0+IR3mGtgCkgmlKWLChZMF0ShZHANsTNtjxhMZVAwdE0kMQKCgiDe/qLtV5vwzrGkDhFcwZCDNiJJSygnkFQkEMjFwu2PKKQDOmacI8HRAiofAmTmhxQjrNyCr/DpRFJnFAabG39tMUypgGfWrQsdrvXvchENZlAy+SjvtwOKLwhi2vACdJ80cAaEPhBYxco4NW7BeobTAYhfzObO/CNNtB79K+8hZUPw66J+pxEvI6XdPvY4iYUgQT4XJZkHMBJUKigFwyHpcHbFvG8XAnh3C2DfOsaW7Qr8PL5YK3794CSDgeX2PWqBhEAezk41GOqbxc/1q3FQ/vvsLh8BlKvscUj5jShMOrI+7iEXefHHG+HLH4bE+Z5MfVzxpF1RTtOhe3BczvMR3uNEoHYV0k4jiogJgVl1/0sMLUOVXIeo+4u5uR0oQQJo2SG8AckPMFIOEfJqPa4QWCROElAjJnXC5n5MeAN5v07t3bt8jzGdM0qTO98DXvlDfPB1m7CMAWQBNwd3eHM90DGYgpIaYJRAEpHjClFfO04JIkAum6SYTT8/kBX34pM+R8WVBKRlRHmaKRFc0JcE+fes7+MV7r3vqItxIpphQbj4PIASMON/JXq8M74Bq9/P3Go2OK/cql67rH9w1cR/ny91/pWDDZhJUn+8N4bU/qaCWCJxiEQBHTJNFIi47jcj4DJJHnUpzAYEzTbA8iJYn6Nuo/RHbg+Br7/K727Zfy4jDzUl7KS3kpL+WltDIITKNwcv23qEGiDajRQMP7+VygZqRt+asJGFL/WHtegLTTSPW7oggBA5ZjuT6rocZBDZQRQ4aGQvTgQAW5GxAgeVAdEFMKSvGAgD77gSfMv00ZAYmninwvp4xKVrGSAVFONQxniIiaw1ZAs/7kWjN2fCik+6GlB/3GoewJ4PrNLia4Z/gfrxm9fOjiW3VUA7ve0hSIEeC7psueIWXvs137sPf4jytXCpr7+ynlb+iIAtnXtNYburrJ0e92ld/dnLoFuo3XP9xZpq1pvQKbfN8WJ/8uxyv9uLFOCPUUynjvrT7snaT0v2vVV/N7VDyNZ+gvJnTrhL+9w0xl4EB3Koch6YcKC68yaG+KE4iSWmD8vG1p/JoBYKAVDIAngJyzDru6uI/2xZBUS4GCAvt24lOcdxisKQIkLULOm0RT2xjbBoQw482bz0FEyBCjXNa9rJAAjD5ySlFgMUOcawIKmAxyvA3l+92ZzODSqKHfNQOMN07ucOR6p6XbGOFYD4a2tg2OFgDUJ1O47mnrXwQhahSU0NUoT0d9v0ySa34wedT+jA4zRgdAsMdmCrnuQ//shxV2P3195rAC3Xj4qs8fyzU+ZmXZu4nwoHg/zlv1+u+Xr4G//d+5RiFkECgIuJo3wg9/wbj7hLDyBMakBh2TsQTEO50OyHaKUOWxnDOWxwds64J1lWspJZdaSHpl4awlVeUEAfl2w+UBsBDXbfZWEFzXrA1MXklbC0IIl8KnylShrgVjfzBo3+WEb8+w8JXKD0sFGa1dc+Sx78R/gToZxvPjvbR69h2XAs47q8E95+VL4WkFGZs4ARczhIozUYoRwVzuFFi2PcefxQ7BTkSmbizMRWUEE8q5grLtZGLfrzECi0Ue2AOV/X12Te4pQNk/kelpOv50fOCGLLf3eXRo2bvH60K3gHEbrxkobbweGL9FBy/r+XQlnexABnIDFMRgZGuZoukIBI4JzISyzSixIIQT7r6/4Id/eo/z45d4/OsfIL+/k/bQ9iJtQq9fF9q5f6+Qu/vWfdT97fcHdH/b/sj2j5ozal2xN9IT7mtE/QjHfpDW9+H8nOv/7P72dRvnKV2v3Nof+s9grL/9BfL7H0n6D57BJQ11Kt0YmhLyekzjXvax5TkaEIDj6w0/+Ok91o2RToTMM4BUZbpCwjcL1JGYWrw9qaPNEZvbe7NmTz+6dc947dvK9Lb26vrUvV8iTFDFHkDeubsl9GJbsFnkyVvdeEovsllD1Ou43EWW2amYIWefqOct8qyNDXUfD0H6m3O+cmb0/MjzbGZGyRL9LOeMw+EAcY6IuzwRQBd5RuhFtb8972x73OhYaRiIOWn49H1FU2J4fITBHe3/MTpej7c0+jOLrGAvpcO8dvYL6z+ewKKem+s+RVV7n+19bduGnLOmq7L+UKXzhzrL3Lpn3LP8PIkUZc7D5BfDr3wUJq7GerlGeLi/IMZ3knbue18iTJJg8rKeJdohElJIiPFVPZBhVDdnDZP5g/4vu5YkZ/KRW4wTe90I6FcTA1jyPbBdMDMhhNfKszLW5QFbvohTY5rFJYeOqlsyKCRwSUjxDsfDG6y0dvX2v5umZVd63cVkftrR09p17yzTxmL6XQI4S2QSCjieJmz5gpI3hDgDVLDlR2zlHdZVoq0ErS24mqxd0SUbLQuA8sMvgOOKwuJ0va0Lcl6x5UUPQMq9OWdZq0QISaJsF4isxJcT5sefAADO5wWP3zyglDNyoXqohVl4aowJx8OM0+mEEAOW5dLmIgGPD0cAR1AgvHr1BjEkOfC5bkjhIHIvHz8YE2YA9HDC/MufIf/6E+BnZ8TvZYDvVI4GpgQwX8BTfjKNLzHtHtSg334GyhGIExAOCIWQtgLKBSVklJ/+BmliTHNQfgrBKAojhIQUJW11jPK37FfAljfwxmBeQQFIqtOt24oQ1MmIJbVujBHrckYpK8rrgvtf/AoM4Dx9g3xZsa4Rks5HIsUX9eQOMYIJCBtw2A6IEN7w/pt3yPOqETkjKCQAAdPhgGkmHA4r5uleIuIovy6ckcuGd998jVKAQJIWyhwsRCdsPMc7ZD7FO73tY8SgPb/20eVAluqvyW6ii/b48J7Th2/T6rPrLf13rm1u6yr6NgVokBaY/aXnWtZmO3xHtI837mHtYuex8VhK2JbiSSik35NyRyZIoDtxrNo2cRLNpUDsQdZfQcKmNGHLG9ZtFQ5GQ7QaNP12j35XDrEv5VuXF4eZl/JSXspLeSkvxcqOwHgV8lyLNzQzF80XKULkljOIMkJooG4IAevaBDsKvcC5J6RKqPeptpfXLKfMYACZng0xZZ+sPw2QItITsgwxYOZcAf2UfHjiciWMXTtqKFAwAB7/6KICKKkK+TwYYYKjgVINTImREIIaJdQwJE5BCgmMyl217zSB97sq1Qjkfvf9b5/l/jHY7XP1N4WiGRMAmQP7IKl5pVtDHfhTMAjZVI1FY5u+7g8B0Tpv+++gjIqN1e9Psn8osOVVqKYCOXqyA/vQUkrA3XdV5z8CWNwrt3jFnmKpdz1Rm38eMJ7R6v/491Sf3jHSfZvigcFbRrbxhN5eCo823xtYVeum5+clu4hK3fX63175+HEzF3BRqJIMrGx8ooAUmBKnxcBBwrWaw6ajkxkFSfl+43EGCCqv10gyDTrVk0A6AnY0NucaLpozvohBPyXhs1lP2hTluZaOsGwSfaOUgBhn3J0+BSjATtTZgsto5+rs9B0BNS99Jkbgdv1J8td7qPs8OkhY4+T+UkhRv+3BFdTvxtp9G317jaP0ptL9Z+UdG3gb3PPjWA3U3pub3uFlLx0VsdDTgG52ddqzYeh9TzFPD//TDLJ+kDabLTYU4Gk8/t/X3drsade180yp4+/ocL1GzZw9zi8CcPmG8Os/I5iTURvzBgbw2e+uOH0fYI7q1GUgHdXKpjmqY7LKZxBe9BCB80O7d9yzJNd9S20jJ3WBxisGusniFpmKAHPqszVdnT3t/QwiHel/JieCAYI4jNT3oPyztTkQDQTy515LS23UU7aNM4QAJkbO+6l5ruXRxstJheI90NVO/Rttq8ExiNFSUvwAKIQIAbMJEShR3lVIIIoIms8zFzllKk7ZAYygfTbAVUzcJn8HIoQUar55v3+BUVNceoPYGE1ldPixe6/lO0vzeh2ZcNw3Wz3X8+dDZTo7qW+g8egANMqIo9OMyZY5b7hcLB1ZA3y9IVHq6OU+o5MHz5klQkOTCVDBZoY474kepc44LAC77FNmRAnYAiGlGfObjMO/vMf9+y+xfPkJtvcnZ+rq95TGH2/Tr+0Iz9AXuMnj9jimmy2VH5szSHHRVHrVY/8QhDdI+W/biHsKCH/t97/xqf6voS90va/4sQagOc1YaqYbhrr89mc3jW1tXxSOKLpZ27f26P0h8sZ474d8f3pd8JM/WfD+/QX3Z8K6zZBTxJLOjjVdRPvn4+8pXxcmfdW/0YD1VLllnLLfHyvH9w4aVCOkFC4ISQw/RHXWONoYZmF8UaMQPqW7PSW/1z2qya9y3a/RYUaaXmB9qXuU7JO2r4egzkCmg7A4s1hkmHY4qjkLGj0tpSJzc4g5HA7IOXeRacZUfOYwk1LqaAyC1tnSRokzRTuVb/xUTqqj4kDmiFv1wGLOqzs84dl58AErhAd6wxyIxUjvo43Z6X0bv5+TpRR9R/t9enresqa4yLuRe2pUH2Ycj0eVvyTlybZtLXVIeB4velq3bO+lcwhSOlzrKqqDsRjFpX2RDbkwtpXx9VdvcTpNwJuM7XsP4DLj8WFDTAeATggpYp5ew/SRulMM/JQgcjOTb7lKkVdv2hzwfZohBjSCzAMIR0wQp5d1u+D+4R3Oyz2mNGM+3CHQAVMipBCQC2OaJ1CJiPGIeX6FGO+1z73OgeHz9Ypusr/XaRpFx3/XhQCEIOuaQkGIEadTwLYmrCuBqKCUjHV9ROb3yNtn9VnvoNM07T6dLiD6L3/+JfjTR6AcwUx4f/8ejDOW9RHbusi6AFUZx+PDAGNZVoA+U4cZxuWyIscLQAlBU4SWwpWHvLp7hbu7O+U5AaVkXJYVpTC2FVguEYA4MX3yyWeIByHuum2IcQWDEENAKR+Om8bLHdLf/wyFCdsnbxE/iTikqA4rIkOu24JFncX33kUtKgdUbYIJ9PVnoK+F/qZ9EMTgzYcV609/jTBJxI5cCNtasPBWdSU5pNoiwNihhG1bNJIukEKoa0ec2jeYwlQKcDjMADHmw4T8+YrzZ18Ij1s2cC7YckGM0AOwNi7R13LecMkbwrriCIBLxtfv3oKOBWmaMaWDpoGFOPSEKOn4ljPu7u6QpgQKwJZXPD7c4/3jI5gJU+rlcEdE5bHhxvftvvEtVNMBNxtE0zNkPKwbp+mtdp+5jFXMXXFba99SVMneDXfNORZqRLea8pUCtizRjmMgjfajfRWwDMwtIgvMPuAkvOY0Y7RhP9BGDTYkwMbjbUQM07/ko+E0LcJM3gq2ddG9PiOEBOaMbRO7DCoNgbwVdeDd0/VtbzQSBtT0fR8g+72UDysvDjMv5aW8lJfyUl6KllEJ7pVdL0S1awIymIFEjALm8ZwSIQQ5dC9AySoe4hrVZdNINJLqCE1hZhbDhhoziQiZuSKShAagSB9E/TJ5qinfzWtZxuOUbjQQqKqO5MZcaUGt/hARYgTV0Py9+il49rVgvQeFetBV/nShvq0eFWbZ1eaV4SbY+v6a4G99khvMD4SpCe1NoPV9vV0+2umDWZWCPhVUMGeLSmqnwrv6O8cIiIJ1S5+xEw42Xg8utXsgc8hUBBLaFrUkmEHBviOYEK5QCZE61bQA86Ea3KmBu3qCYQRwb5XnwLlbhrKr8eniuHJuw3WY3usGXf9sbpM+XZU8O3HHblYOz7bO7LbJ9b+PKx7M23fea+vJz6dGHrfeBsho6F33qa5HV0P/RHMyaMpj69f+mvHrjrE3NbzDjI2JqHu645fGD4U+/q6+72xouTfGQhxBPA2888ngBvBMod32rc6nQWcFMHVN1Zzk9u6pOc0AQKnd6o0jZgSCWyNyrTdWiIMG1+fB4gxmdbS6jFbt5H9/sr9FqzFeYe+1UABCAkUJcRyp4PQ6I8QNeQngJYJBatDjSgWg7Wzyg2r8oyfmrL2Da8peXzW+1cMc12DrWGPvYvLUzjHse+7Gvb449wrXp8ZLKy0cSBgqJ2o9p1ofVSeR5oCj3yuIk6l049a3WO+x+/dO83FnaOQKmstp+GtQ3YyUIlG0cdIOnfdW3PW1W+6KrdR6n4l84KQY11q71n/f9j8DZbdzxuO7DUsmwKKRVHnEACxzdNETd5ZObZsxRQIdgkasWTVf/VTBwMbjRY5rBqXGG6uRtMqDdnqblJn4qFKOJ9r+D0tNoHIXA7nLY7NPwbY/oo0VbU+wR6nKQs5h0eYkUTU+ghqgSWh73riPtPECKEXE4yYEVxkyUAODR74FjUAYQKBISHECKEqHVSblQmAiFMg561wFtwIqAEGdbpwsRBQQg/a9nuKX/uZc6rjECBKq3uANgyGIUVXkKeHfMfooiQ3cbVuOhRd3YDV6uaEw135WBx/H341WOpKbDK7tw53Y2t7nYDi3PliKkP7+gJTECdT0CK6pVFHvN7DdOIcZHLs+EwEM56DVDGVVjg66ZrTukrMa5wkRC7bDhrDZWohI8YDD4TPMrwLW1wvKRsjn1I2j30+eljmflkYbR9+XnPZ2QO8Q0xxlRJS94SyzU7f/fnSa4au7/Z7h1vLuiNhRxt/DwFX/Rr7eeK5yJowHHz5GpA5Vtm8PS8aHcWfvy/XOcP09dZ+ue8gADseCmAiHVwlpeo0tZ8Dx9Jyz0qjJRCRkkjq4r3P85Hnx0z2+Lh+l394otvYNB7F6SykatUu6ZFFcahd17VdeVujKsPxx/Wh8phmUqOEL3b06dktRq/cac7O9i6oMDj2UE7CVreoeZszuHCCAzjGDSKL+EkjTBUrKE6vTFzv9b3+PTpCttIjBblSV7vIuLEYi614SEUKCpVztjZ5R9uGORuSbwz5Xef59PT3HWCMpBIjxstFv1AmfYaI3i9CwT4FklVkEP6OPpE8J6rzkIu+5+fDUSf5rvqmjHHAeL8NZeiooblQ09a6vVBx4CQgkqSiFdFiXDYEKYhJnqNPpiPfvF/AGbA8JvE1I8xGFaTfS48gxWlyGFgG0yfwAOx4F9AmMGQBdZuChgEPCiox1W3G+POLh8YJlXZESY3mTkdKKN6+OCFPAVjIs/YgY2mccjifg9YqcNvCSwGtLsQfXP9rhwLf3qH607L5nAIgF4bQi0ARKCSFMOB4JKQVMKeP1mze4XAou5yyp4B8DcpnASwTAVTdrrfh9nV3LQEYBsCIEWXvbWrAsGw6HhBQTStkwpQkBAdNkfETW+7osOiec4wMIsRyR6BMcDiccDkcQBVyWC7Z1RQoRr6ZPcYoncc4EC923Fcf5iMdlxcoRTII5xhQB2pDLhrwJnhrjijklZJqAk6ShpWWCd7zq9/q+3D98iXDecDd/HyVnxBTAF2D5OuPydsV04zn/Xq8OQA73dKUA+b6AF0s1FjDRAYEnFAI4AiERplmcZgxrKUXSvZZSNA2VCI7ZnO3Z6UAqWxzvTgBmrMsZj49nmBbO6wqAME+HK/5TlO8ybygxYzsuyNMCgKWO84Jp3nCcCu7wGjHp/nMuWN8XnE4nxByRpxWMFcyEFJPrZ9H0wN0KBYB6uPfDmKrnaoZ3mY5CdV6Kw4rGUiIACFq9jw5mmz7V/VZ4oNWn+gCk/60NcyqVvVn2sohEJHaKKleojlSaLsHsUojKaxF/TaezCOMdJFHD5VwfxLlX6ncKxUCudj3qHr4VSZGWkjhmSmQtcZgCzQiBsJGMD7oXgVpKS2P4pt/InuH6RM9hjS/lY8qLw8xLeSkv5aW8lJdSC1dQxYQRCetXkDOcwt4EJoCq0AbIPUHBBgOzJbRuRilZnWhEmZpigOX1RFGYkwJClJMEKCzhL1ME54yyyd8pRqyrnY4LFRDhQnpyycGqRY0eIFCYxCDAAGc5TRAoIKaEoGmbAD3xSgCHgKg5alk8PQAKqpiRCL2sqmoQ4yuBG9iE3tlAhGuuwh4gzkYIJHVDwV51yIAZAmQwIqyStsMMS2HS2iqV3hY9x07syWtrf4ucSXBZ4GEngntB05SK/RPO1/e3DnuPcxmyjUsBEUhHchZjeK3bjPhGR6ND4Jo9QYBwaacwrqACD8AYrFG4KBhpwXcDQKkZQ0lO344OPcwZlraFSIV+AxXdvK9pWRpyq3WbMuSoOtDyFj3NiOSvj2BTe1NWjw+ybjeykpuvrnN9x0Z/JYYqeUxNMYHSkYvNc2mogaFG/9YDOxEma0Z+i3MTarttGAOIU+nigdTmgCVthaGOdh/VcaO7d8/A1agoc7AqZqpH2zzzCiCFAM4MLhmgPEBEQxStSjDUSpkLSjazc7tvdJapHXZzGl3dqDRvjmXSRggRNWiz0YGbOVdA5WtNV8A646fs7vP30vBMxTorIHLzJGFXCymeYKFyqa5zGRZ3xivjsczeYUJ+pG6haWF2pFOF26BDNhcHuIjoPZgi43BhwaWF2u82LugJV1mz2yaAH8WIQjMYRwCEad7wX/33b7Fuv8b/+x9O+NV/+BzVqRH9ybueCysPu7ruZ9veG+nvbd/3T3qoaExTZHcYWGKl6O5R3DdUv6s7nPyjsW/j+8fuSf/6PHrnIc/FQq3B19ePqa6F+gaL9JvDlXOLRWSR2ej4tDuFOjrLXPd7XCU6n9UIEx2nsLH7PYy7uix6HiqlqdLhw0tPj/66lfY+++9G6lrfTWr55f92AOig5BHeIuk+VA4kDLM7w8+4H//JjN/9owNSfMT7+3cIxJhSQtLT6hnizJGznI42ZwqyMOvK33LJLdqhjqhkPY0dYo1sSCQgHbOc4jfZJJjHArMzrz1DV78Hs/Ef5a+NWbWKirQvlRNgoKpUAANNrW7bs6vThwKq9aS3M2zKCdpceXcNDc4q6dW0EwpyIlXZhBlYs4ii7VkgpVn+BiGXDHBEk1l0vEHuj4I8a9+V5lEjJmQ1ABIhREv1JGlXc96wrVlOE5KEZ7fIQhIFR5zUt60ZoUnbCNXLEVV/kUgpRWQy23NiUKfLJqMVLqAQ5VlNVdJST/VyVjXmoT3LuajcLQbFoO8jqkPKluUd2UlYXQhgZMzzpKeei+5Nksqsbt2SRwLrutV3AmjoetYZzvpOi9C18q3Cbb8n5VGNTCqvkKwfEqMIxYgSNuRywbLdAzRJdzkCOCFNP8AP//QBb86/wfu/jfjt//HTzpFQlr7x3WsnwN21U7lZK8+ut+HzyIfrvuN49Fh6iff5dv3e2e+j/d711FhHp5m9Nnrza+tn39/RYejD+JQvQeWmaCyKe6eZp+oaaeD3seveeclA/vrj//odPvu9hEx3eLxELDlhk9BjsjcSZP7WdSpOBExq2dG9VIxBpd5XdRt2/LP+T7WuOrYnHRd6vv7cfd6JwxyqLerTtm0gIkxJojSwOj8QM2KQNZpLQaCAEAmh6lsFYEvJ1hxPR4eLlpam9aGbLWR80qJvqeRAgDhl6EdqexdFi57FyGXDVrJEqXAHnJa1nW5PKVV+7elgTkPMkmrRItAwS0SIeZ5qOiaJQrxW+vnUdD5Sjb9ur9Fk7yodMaoTTzXMAuBcEKcJh/mA5bKgZI2sy5Ukem+be0ZEHnUkZnV6sntYdQV09NebOx258ipWXqltshp2A8nhLJMJlssZJedK+xg+YG7eiJRKKAgqf7D2J+p8DSDRR1mkZbAcEuLMkn6HRHLjklHAaljva/djbjNxpJ3eXTGNAs2EA4QxXbsYh2Wfl53lMB9xuVwQQgLFCC4bCBsCAvJWcH64SMqd4x0Op4hlWXH421d4/evfl37lxo8IhGDvfpD57XsbGQHqOFzdsq9G2jgycP63v6/zw6TlBOAE4s9xAIMOBeG/+xtMc0SYAARJWS/RBsVxmWLC8dNXWP+Hv8J6+QLlP/4Y+L9+4frf+h6ZugMFXrfw3PB6D5HiJfTwg29w/Dd/jU9e/R5i+hzACfM0YUoRhR9xmCNC2FDyPe6/XnH593+EvBBQAgKJA3d1EOzoaRJ7WwcZjEhnpAREzAADx/kNgDMIC1JMCEGdERBQMrBtIutu2SIrR8Q0wXhA+uIPEb+QebzpGgvMiCgoBHxFhK90/wvmmKZMwOBVmyWFHnG4OwCcdH0XrOsjQp5Bv39G/N4jzm8fkf78FwirNy/bzLher4XfCw3oAYwND+cLlv/1U+S//wmm0u/D/h37mu363p5NldL6eZ1w/LP/sgaoq3XpDfnn/4D8B78B8xnrekYphJQOmNIBIUWEDESKICSACXnLyJkrnzGe//j4gFLkPWwbg8IsPDwFHNNB5XNGXjeRxxXvDYgomRAw4/x77/Dwo98ilwWFVySewAXYLhvO7y/46V/8Mxy2g+o0wI+4YAvAhoKHn/8Wlx//CttacJhO2LBh3STabwpUZW4mBigrhZLaErjbb+qqYI+82Fpu6Yl6LNNsEhbJS/DtYnogqdNpAUAMigmRGSULb5fUumZnECxJaGYOjeIck3NGVP0pJklq2evjAAAgAElEQVS6DL2ei8kNos8UjWAfnJ0BZPyXAEsPSTJeUYRsHcg7rti28mGzbbDqypzt72vZyfQpwwcoBHFCCwGBZO8mjgAXiZKDKOuURSrMVX0h3QNNH5MUcUH3jPre9BDES/luyovDzEt5KS/lpbyUl1LLcIIFDZRoAiFXIUmwfdKTxO0++2wADJGB8JIbVUKxizDjU8iYwONzXZecsVaHmA2FCjJtKGUDkGvEGjvJLMJ3aMoF9XmxG/C9qle5PJe3DAoBKUbEkFRpKjivEkY1JYkQIDSIAjSBICd0+7QgltjAqzY2PgOyvXYjXtTOJGmCngPiAGeK725r76sahsnqLe79BdSTw4ACjc0g7N8r6clvc0rwzg97J533SwOIPPBZP2uH2XVahGr0NLABcbvGMHqhIj7VyKFAownzcjerwtPgZ1IlIcRQFUjrN1e6NSC6gpwUEWgQHx05zJHmqlTlBB9Iv5Zn3YdA7k4R75Q9463/7tb3V9erY4Gu4+Dnpf7UuSF/A4CP8iOf229TzppBvgfF/Li8Q4x1p1dKx+evR2T9a+SmfmrV6UDVkFpXk7Znh3FtVZvyaxQLgERtMrJUukkl5mRiKdfEOKn8ifT0o4bfbWPv37V12laH2Detp1QBNlvDMcUGLiof8zyjnmDxc15Bdj+/iHyKMu7eoX83vnQOZB84z+3VAM7MxqUedm2MTS/ovUwtH7V3X9hbBcyQEP8KiQZn+LTR9JOln6Os4DjsRE2lB1ejrYEY67rhcr7gcr4A6YjLVrBm4EgJh2lCChvePxLk9BFX14E9oLYBZT21/Sh7UM3myR5E14DcVos3bBok0VMArh++bYIBrAKS+Fz1zblln+OMEU9a/e1UdXMKcU4zXSSe/vm+x3tjh6tv7/nrZwD0EQo8b8P1O6hjceGyRSJRGlnUDju97AzM3vHHw3UMMfIXo8NO9JrarptJz62+Oq+GUPQERiH/HvrZZC3YtwFA2dzqo5bqyvfDnGga3drMJRDmOYHogFyOWJcF6yopN+fDAZdlRd4KwEUdM2J1hGYYT8sonBHtJJ/KBhQCwJpOSXlxLvnqnVNoaaJYnS3MgPgsMW9QWNhJ6Ix7sDorMYMzWso1izbj5WEA7W8nF3i5QkJv65gNnIWb37anMMAINVS9XROgVtaJ1C8nAOsJQhJZ2BwFPQcxeb32mWS9gtUYTLEC0uL4sqlRtYA5Y55nHI/HOhYzmneG4Cou6piLrAc7USm3FHEoYmfGItsPdZ9E02HY1VfboV6W4zKmSFIHSjIZKCBGNcq4UPZgVKcgMxRYWZaLnH7lgkCkRqEmx5rjZ9OjlBZ20p/EeB1AaGHllS5uwtbxmFMHGS1V1rfVXAgoBVwWbPkRRBnMERwjmCNifAOKhGnOiLO+264t6aP1IHDbjQBcrTe5y9/hrzceMz7HV/87PuyW1l6bu/XdSMvE1Lcx/v1typ5m6KWW23tK2+HGMfS8fr+Ht/YLsPDvaGyOmrPrSONb9fjIbV3dV33QRmICpQNKmXHZGAUTgEVkZHUkIZKDEMXiQLDK2kxt3bKv+1qv3usJu0E0Ue96VB+jq3nH8LEO70CTYkSigBJcv/RwzJw0TZ5JKVxAXBDsHVQ9/trZfO8gi9zb9Hg7YW/fhxja+Jn1cEqbX5bOWfbKIs4U0XhuUd5cFO/RCA3qGOR1CO8gY0Vk5FWdXYVGkgpE7lvXFdu2XUUTFWNhqlFsegchT3clrdPjqwN9sQMKmsJiy4iJOsbR6V24/rMvbgXXe26/n9vP15trDYFIHf650hyxRfvh3VX2fClu8VTZQK/ZvmuHYtZF8C8xwsp+TczIhofUtFBDX1Rxtr2gp4dc6w41WfsIGvXT5p+fz702JM5awV1T43DJWNcsOtjlEYfjCaVcxIFjC3rowBzXzUnc7yUmx3KNMtb4btuvLIKKl4GsJ7WurXcY8dgHAUASWSImiyi0wQ4HEUidfRPS/AqUJmBiXOY7bN2uK32JpkHw9cGL/qfpaV6bGveVGAjpMCHM4iDhsUiiCUQFKQApSmS8vBHKFmu9mVTWNnoonzXnlLrnkfwd0woODC4ZMRxwd/oEFGecl4yHx4umQlJtisWfOGtqVkDkrKBOxQyASrSGhzfT6yFB5XSh985S54LHyzusjzOm6Q5zOiJFdaALjBAZaQamozo8jM+3HnX0TWkB6BtkvEWMwLq+Q17vwOsRjD6SKmDphbnut6Os5/XCoOT2K5MBIDf61BpMFy8bGPcIcUJKE0KYJAX1dpF9F4RtZVARJ3MuIsdTbNh6iKKzbFuu6dti1MOoFETGjfK9RToENFowSB0Fk4w9XECZEUtAhM1BQuIJKUektVGiIEhfQdguGXnLOB5OII1gCRZ65G0DouJfGs3IHO5NNr/eX68ohp6yFtW5X0HM/v6oM42avEEAQkFARAgt/SSFoAd4N3FM5IxIsj+mlBBjqnu37Jvi7GORze2QivDYAASq0UfbQQBqc5UARjvoIN/Z4c8gf6sOYXKCjI87zFRweaOfw/86/u5Q6BDUYUxbDQFxmkBQh6UQJLIRsxxcZiCzyh2Gb4Ze+rR31bIJvJTvorw4zLyUl/JSXspLeSla/OnUCojfAGOuCjfB3X5JPSJgpRQRHUgTYkCKE9a1z9Xawuc2AU+E7gCKExgb8pYRYsAcZ0iEBgERtrxJtJIgJzAFiDdjuAebTDDW07cFDuRXsBqEOE0IIbl7ZXB20lMCpYyCGTtQ3Ye/l+9q8042TWlqoMigVI1iekfywSjtnSrs/ZlRZZomMAjNOcaHSTbgwuoxgXPsRWvnw8sIQ1i/rS7U9psg3rVWb+x65EGVwsiUGxDgbjRdp56cM4Fe52Z1B2ADKwfggHyHmtA/0oPGhneocA3+9MBsM5Kgu1bbGJ656TTzASDvddkzsEPobq/A/jcgjGSujO225necq0w5rwpme1bmYN+LVr/1Yw98u1Wc6cHV478jhuIt7AA+hdNqNAlHG2K0c1imMMo19+YAQE83ugXfRdWROgMROLQQogQCBa7GMTkp31It2byPMVUFvDrAgBqorQpzVSCdQtk7GymQM/Ap44tjmoo25/Yd58a14eevnfa06/1cNzjL8wv3y4yf1MAZAVDcu4BEDgE13iZrqN0rpxhVgd+Btnz/R+c3iTBU9FRUqOuCuSg4JCDR5XIRgwAR5sOM4xwwxQLiC9ZlxXL5Guv6UHOf7zlwtD60PPC+jxWk8Cf8WRwzBMa+Luz+b7U3xwe/k/Utjg4zbT5l/SQpo/oRNIcZB5Kghy/HnY3cs91YyVbZvrPIXh0CBjEstYzvfXWc2TGWNgnB7sfQe/9Nt7PpHfoenHNM4699/3taSBGwc+DG+p6z691Ih1aXAoDu84fs2P59B+UL9qavn/dUUqeZoV/jnA7Q08nXXAJf/XpD3gR8/smfvEI5nnC5ZCyrhKcP4YIVZ7FwoOCyPYIR28hI1v40RQAFJW917ZM6a8gebEa+UOVbagsZJgh1e28d6zgipRH3I+4B1lb1LWq3ZxVX1GgDFHp5Dk4m752hm7Pn6ByuN7R1bdcCIRAQU9A21Om78tUmjzC1sOsmb8FoafsykcjoJA6c1RhTNmyQk6noUkNFjV4JhLAhF2CaokSTBGrEmdE47mWf2keTSaitML/f2I8ZWru3YDKzvoLaDto+6Q8NmCOqOMw4rkDq8kZuHVJAmCySjhj2ou7P9w8P7Z2XgkKEDRtCCTWVkuk+owE4TQklFwHTLUKE66/Qxr17IhnbHue068woyMibRna8vEfOM1KYsMUJW54Q6IAYDpimN3j9+QWf/6vfYF0fcf83P8D6/oSRSzJ1otUOB71dPE8dV+HInY3PO7HzZvmQtoG2rw7SyHdShKf20uIoA4xcpk8003i6PTPy3n2Of2sUTV7QwJHVGep2spWxhn4/76VLxunNBb/zs6+xlRmHU8C2BeQSRAYy3tBFlYEyQ6uHu7Xs5cjx2pNl7xbGh0+MJ4rnu2MUlBijOjFqyhsAW87gUjBNMw6HGeu6SnRZInAQZxkKsXOyu5X+ZtQVtUdXxiuLfGN1lVJapoj2lPB5TZPHXCT1jR3aVl5rTooSdSbWfoxOnD41lX2XUmpp4Viiz9j9hsVs21Yj2BgvlKgija/3Dv72E7r2gRb5F2Ccz4+KOynuAIvuVqlZf/dGz5G+QqPmlCPmd+Y96fv6fY3vrr21dr3kjGVZ6j7QdJ99GfC5YvucjWNcR3V8pU+jxczq1Bld+l4a6OxbsbW7JzddF9vnQ7D3Kvqnl9HscER75+09h0AoRJoyncGcsSwr3r59i9dvpP7l+9/g4fVvcDjcgSgiIIPCCnxDKH/5usqmlZeZg+mV0wyG//u9LX16wfGP3yHGkzgDcoK51widzHktA6kgvDogTZM7aGg1BgAzgAgKM1I4ATgg/DShnC66FjMuywXLekHmTfb7mGR8NT1zAedNo/RtYN4QwgqigvNf/Rjbu7thr5WSC7AuAflgco3Ie4UZ23ZBLiuWyxmPj/fiQFXpwHond44ppnMFaumjvG6YsICxAeGMaY7IuWDjBQyJLiTp+jZEimA2WRPqnMwAMsp0j/XzX+J4moHf/hD8cNqdb14eYQD85rcor79AyRkI7SCnOBxMWP+fz5HDjO0HC8rvnvHqNCGmBN4YeSsoTIiHiPTPv8Ll8YzyxWvQV98b2ux3/sOv/wjpMWCd3yAHQlkP4G8OQiun71p/LZHSWPw4mg4ukcoq3lZvbvpSk5f0vi8/QSw/lb2YIkqQtEISXV5WxfSTd6DX5/o5RgIoaiRCBmfCxvq+MlDYeKzpM0l0GzBCnEDkUoeyzDHp0wZQlmj0ur8UDro/Mr76g1+Btgywpm9cIz77+58CJWD++jXe5B+Dp4K3P/gVaAKmaQYAlCxppZhZ7QiMmGZ1Isyyboa0fp08fTV79IrDgwBoRKwmAxjmbGtcVC1xaJHvQ3P+IEaIESWLDYOIEYPMtxgSGIxNU1u1w3G6AnSvjeaA62wCtS9+RlQ1oelm7FJGmQ1nLFVmdeKabS7e/7g5zbS9uO6XzC3tOlj1VHVfdDw+RnESMttQZkZAqLqYl29GXPGlfDflxWHmpbyUl/JSXspL0WIAiXe4aN9dgxNS9k9WAajh8oEG1OS81RROlvPaA0z+9FBKqdYlgIoIuQzCNM0gAi6XiwpSBdu6gQEcDxIhZtskjDu50xF9qEV01z2QxAASRcS5nQyVvrXQ6AWi1I9gPnOrt10bc0ajGkFijCg5i8I+GHB2RT+W7zxQOJ4880YVL7jL6SERWA2cMzBfjEnNyemp8pzTxk6H66cxNcveqbkPabsDnRTN84K/COXUdESnCDGr8ZVUOTBwx+Ut985VFaipIFBP633gqOv1s6DsHogGNMer0Vj03RWD36872GjRPjk7XL1BulOGcZDQvyr97QT0HoD21Ly7PT2eowMPp45dI7VB/a0WQXFCcakl9HWbE4s3kBqP9PDZyCtjNINnzzeBltJEovjIdQPMJB2XRNOS1HUulz02UPY8WOZ+CknvQ21flPWejo2erZ9Fw+L3Y7xemyPQOn635wQ2zm1//971sYwKsf1wN5+4Gmh6Q6vMQ+E7Bogy9k4Wd0ZoDOCCgphE1E5GqRK/rivknW3YNgkrH1PA3WnGcWbM8YLAG8r6iO3yFTLfg/moFL6exba0wg3TVxuxf6g5afg69p4DUMdnqZXaKnUGdjez/TWLZyAwpZ1odO9Y678Fl5Ore39s8oScQOKbddHOX1djJa6GwDZbuHM2uv2s+7trhev/3N3RxtZAJapOM3a6FQ6E96UD6rvrykc1st1o/LY2A1raKYl9R+pWMlK838Oo+1/6FyyK3tCO4wwALNJQc5ohbjxsbGlcTfbd2y82vPsi43gi/OG/mDFNR8xTwPlS8HjeZK2GVXgwMtZ1QQoHgCTNEqmhap4nbOsixoGiRjEQUpwBChK1gMNV+gegj8gH7MsZfe/9bwx8s41w5H1Pyzq6CoOlj2v9CmR56zXVkL0Px7NGcHQcj7UfgsahIgNuTX4iwzIVDC09WMysKaVkRhKhGj5b+yZ/itzrtxrj2zGF6mADTti2FSBGLqvuX7lGQRvlaS9nt+heLtQ4t/tsf74lK1fHGh8xwe8vLNfHtuVvlReG92mytwd0zYFSHIUIJWelW3PsKaUgc659Tik5WdmNQeUOttReaH21+4jaemdc77M9gK7XCyNDUm0gSpqmHGbkKE67EcBhDpimGcdPNvzgn9/jfHmLy1efYHnfG6bqPmxzzPG0QXq+4jF9LU/dp3vCExG3fJu3vr9q9R/hLNOP7an7uLY11r+3V9pvo2KbWah0MWfScV/1XH5v3wA0DSHZ3i5Gj0K6F+z0aSy+X+N1BuH0asXv//FXWLYTCr+RaARasekFzUndjKnXOpHn0R/tLPMdlr29wTvLeJyh8sUgKRPSNEuaQCbERDjdvcI8T6DLpe5HoqsXLOuqznEt2uhzfZL0ee5wiPbTIrQYfrFt2w5O0XiDpQP23/txVv1UefCIg+zhSF6XbfxVZb2dqGk554oDSarTDfM8d44UQludN7a/REtJDUiULskkwUx4eHio/Lk5t3jJsu0ve9Lmtb5ve0TTdMd3ckvPsf2FVBf193ndYpQbuBobP4TbtMJo6a/3jIw2d8dDa0KrJj/U/cXtsV66HsL29n3YWasj1mLzomhqkRhTna/WZo/laT9Jkp0WAFve8P79PUAR83zE+uk9zq++xPxJAFECcQaFM+jXAfjLNwAYufLWge8NjH3UrfzMSW9W3P2LrzBNIheXEkV8JZGUAYmGyMgAFxS+A8Gczkx2LgAiJIK1JIECMWKYEX9nA34nIxKDKGM6L7gsZ+S8IoaAaRKHoBiDOiVvopfmC0q5AHQG0T0KL9i++D62d6/QtDU3/xjIm6TJiQkqWxSUsuHx/B6XyyMul4vqu3HYrZvzhh2m8C1IZJ+m06mUhJgWHNKKFDK2vOLy8Ihtu+g80HlB3GQnlkNCgl0X5PgA/vQ9wmdHlPdvwI8nlWOv5QGLLAQA/Oodyg//Rg+MCtlFRySgvEb6P/9b5HVGLv8AfPqA0/QaMSTBgFlkkzAlpJ/fY338CmUlwDnMtPnR5Jj5iz9A+EIOQeQ6M1pU1jHlbtvvfZ3NIck7H7GOsMVfoqqvMxhlZ33Su08Q3n2CAq46fatbSvzddwjTGdvG4EIShYZmgEW3Yg0ZYpGngjlfaDREwFJ8i/wvE0RaKzp6kQw20UmCRmAKEaWQYPqU8dXv/hoFj5AolQXxfMCb3/weUGbM37zC9P4O27Tg7Wd/h3AQB00uUHtDBIORuTSZg2VvEGdRajoEAPMofUrGGHUAn0JwT3dpMvt1PRYlKbPMw4kmzJOmxWXoYZB2QAHQvpHQX6LBhY5P7mF2e7je+Hc9EHxjm+HurzYzK38kuDE6ZxlppN7T2tVMtE5Xk8PWsY5n3Le8fujH908rEf7nXV4cZl7KS3kpL+WlvBQtXvDwAguAKwDIPQUPVLTvxGAoCpZP6yGGTHOcWdcV0zR1Qp2PRGAna+wZEwijpr/YVgm/KuCOCosaDj2QhJaNMd4Efqzd63Q3KpwzYZpSzRu6rrkKaWZsMPVLnjMl9RpIyzk7IEcBAWaQhq40kEIE5h7apO63KkY7QKH/7MdmwFUpDWD1r9Dq8++x0aONY88552MLUfsZy8fgnl1/Qqj5cG1QFcDr/tMUOXAONjbO+p/eyZq71gn5cv1a4XgOuKUb4Nbt+9tc3AcrgY9VCW62Vf+//U6ZvRLl5gQaeWp8C/vSNeco/E9aRtVpBHuvkDAGDF7wve2Vv1IHzmwRsoKAK84pxk7EDZ0Z1k4BUTPU2TVTLIkkGpcB0qSgW84X1HPHCkCIQ1gGURLgsIKa/RFS4fM7zk3g7jNRcw7saOrm+ZXSDermrr/31rox4txy2hrb63lrG5O9I1G6e/Db2mB93bdmYjM6ujF1axEVPLHIMuu6KhDTnqcgQN6UCAEXEDMiFcS44WElbGtCWSP0zZmrWZ2Ndr3ln/fAYr/y/U7Bte/9CP0sH3YMtLOT6Bxn/J5D7rPcx0MEEwHZfP3SDe76O9J9/MzD/+yebz97OyPv/OXGTozA7XOXWmmIMjO2e11GmKjtDUYP/32Bm596YwGjenK699vApn2OafNkjOZj9wXuHWSCXjPAtB8FD71ttZnTzAiqjvSo7QJ6qlRAYaPFeL+fGx6ItflZGHj/9hHHIyHNJ9ydJpQS8HAmOdFJDC4ZaZ4QaZIQ3kHyvecMTNOEnFdZPyQIIoEQozicbEzgXDrD3TRNICI8Pj5eyT7VILbzLrpxXe2tO6v02e1aeb7RTo2mIodAwlUL8xaaqyELAMzYNhooRznerolRFXrq2EcalP2C2QyYjKgphayH0QzCbIYLSwcIWPQuiZJD1ZnJ0hS1vaBUMFf6IikUmIuTxVMDVWHD9M4hLR2hH7s54fvx74PW/fuzOutYn5DphIaswHS/X5geJQY+uWbGPkvPFGIfgcLrCP5z07tIT1nLyflN0zjGmGp0hzbHek5v63CcA/uAuaY2K4xCAQERBRIl6AKAOaEUwjxHHA6fIoSIw6uI9dWCshHyZWptoO0uXl4kwPG+1s/ny8CLqOcf3Vie+XxV8w6fa3U3Oo417dX7LK+4aqfbwdv7cq1owuGuXdL0p9a7vV3xw3rs5Hjv2KlyPmvtt99Sv4+Mb1Y+BxROKCU4DidtBjWmFXPO07j/oyFkz2Hkn9pR5qlyjYH0DiKBAtI0IcSILTNimnA63eH161dgLohpgkWjKkVkS358wLosTX4aDHC3+iDlmvftlfEQ0Si322Gi0ehWMRoUcG5v2vMWw15GJ5hSihjCUqxGsPGwVghB9/PGEy0SjZXKt510E4IY2doBGYk+Z8O8v7/XqMXxJk0+plzPwaYv2O+Rpv65vf1tjzePe9qTiswTRdI2tnrs/aaUOswIQL3GXLCuS12Dlg4phJGb7Uv0H9QvMgec5vjZz7dS99NmLDUcTc37gSASMICcsW0Z5/OCoE4zNYEHsWY+iwAl0JuCgILyGCS4hZNevd4F3JKY229iQskBhQKyOnKTpnEXWUeiXEjKQ0lvBQaILJ2RtGqOBS0vtOkMEkUxl4IUWfHTO0AjexDdQWQnSfMErKCwaAqgDaBHZD5gWb4BXPonbdW9j4AYDogaFUToXrBtFzw8iMOMyTRpnrDcMTgV8Eryo7VlMGjaEOYNoCj7FjN4jShrrJTj9YC4JUzxgFAmTESIBOS8YlkWAECKBx0joaYyhe1d4pBMRMgbg8MZmO61+iAOLmZwp6a3MgBEQgqvEVJALhuADZlXcCnImVHmR1BgFFqwLRvyuoFSBEHqhR4O5RIRwx1KmK50tH6mtOLlDPvXIqnuSxPNMUZklzEFsr1NkRtCPTwBoB52kZSHWt8Th0f8Wggrgc4B4A1IC4q6mAWaQCTpOwNp9LA6hy0io7ch+NSjJh9m0R1JD9RSqLqJOYv4NS/OJcqvMiFTiySmvcUdXsvBssBYw4rlvGBbz+IDk4LaKCxKkXMvqvzWeLREgX5O3ri1PzfcHF0bpn8BzvlTdbEYJ4RpQgiEKU0onDXtYcQ8232l0SMEsVPEWDH/W5h9P45rjPkaY+u/t73H7B9c9dImzZKDD3oUx9fTqpZ2i9LFpUwnv7f3dqg9/dYOXT/lXPxSPq68OMy8lJfyUl7KS3kpQxkV+2tnkh5MNuG3/3GClBYLsQuQhmo0Bc8AdO6cSnJuIXm3bUPeVlAA5kkUn3VdcblckHOup6fsNJIBAYAaToZ0IMx8lVvbBK9pmgAQ1ixtCHBzwDxFEJYWiQEqFJqxQS9YmEUP9Fj9Xogz5c2ACFM+7WTqeOK5f0mode8BM+P7aKfFQn2fFm5ZjHfoDBhAM9D7E8Z78+CJmbT7u++zCeQfp4yM/bG+mIHLcra39lAFc0Yzakg4UnaAsTjIiKBvBqumALAahIiu23+qMAP+1v11NBrq9sE2U+S+O7C4nRi77vf1+rDxtHE1iN8cJpid4jRA6UYHez/Qp6WyPidtu/dbjFXfrVY+jmz4235G2P/6OTMgAKWegCMu4HqKxvosvK6C5s4gaXOyFAYFpZ2uA+ODpUjCmwoeapuMDOaMlq5KHJUE3AGmKUhoagdAdiPga6Nqm3tq3gitn+BGhQZQo4JOV8WR8Sk+4fmxBwo/pnB9t0qf+niDN6UffbsFpuDv98n3fQStjG/mnOvf8ywqpQG3gQtiCIiJEGhDCsBhAngl/Pv/5Ud4fPwROFM3654a+VPfO9jviuO23u87gFjbxbVAw4rd5wxyjznYaHIWZBrW9I02r2FAW/V7hrnn9hga/hqAX1utQ0SXrh87qZmear/Rkrtrnm7GERuNWGlGSnNPX+p6DHj6+LfPVxQyY2rkgAhCAlUnGRs/uXfre01QsJT7FfgUJcb2+7lCNQ0LU9/bW2/Rv8HlAvzb/4lAOOPn/5LxB//FEXevAh7WBKwRW85AiDhNdwiYQYh6UrFgWQpinKzhOvqoYbBL2bCtBcu2IaYJy7JUvjc6VXseub+y+n3R/25/+1ny3Bxu9xVLg4E+6k2MQY1V5nyhMLjybbtvTD1k4/PyQ9vL/fwtAIsxxkBuAAjRgGnNoYSs0Yd0PXFBMVlLT2MGjZBT0z3ZHCbAz3zm7OT4rRpD7DeXwQkXvfx4ZcBllmgxtB8Rc5SnvMwINJo0WVOdVoPf13uQVpotbZ9l50CkBvB5niEguOzLj+eLGnWp6goWhaYZCLjOw6j0L4U1/Z8YfENneLje67pZNgDL/np1OtKZgFJQaBMThvaB2KJnRMQScQh3SCngh//qG7z5Z9/g/d/P+PLf/bxbL7a22x5ikQa9KmUAACAASURBVI2e3uc/RKr2K7HOxQ96cr+e8dq4ZpvcN+xcO/tGvxd9TNH55z7v7Qb1tzo1ehqPEqwZvMY+XUu6pF94juzdaa/LyA1HSnipAjQjxAMYM7JG/KsswdJmFlnz1RHQ6r8ynl/z3P/USq+viTyd0izOaAycjke8fvMGd6dTdSoJUaSDnLNEl9EQtpbUyB8msrpHGlzRhKtmJnNBxWS5rckJ9pRFGKlGSU2P1PNL1Gg1zNBoV31/BNuQ6Cg+WrA5XKQUu8+2T23bhm3bkFLCNE2V36WUMM9z5ZPWRskFLR1gc/5o+ovEuDDnjlJy3Wuas+i+5Nz0i1Y6Q69caO+6/69zmBpPx7saK+3GfW50Vuqf/3Zzn0vTBcb9IMaIaZqqvGDf51x2IvChjuuK23V0u+7rnlHZ1xtCnyLe9uQQSOU9dntuk+RJHyYGqGhqdj3UcLlcMKVHHE8XTNNBnPQ4gb/PmP/Hr0FhAf/Pn6H83dz356r3PZ/z0dMAiesRKIEoISCCEUEctRICWFIjQfV6qJxQJXmiClsQA5LmSz4ETf1CLG4VBCCGgkClpsoqfEBBEplec05TSKAwg2gDyBxHMjTHaXsv7u8QEg7zK4RwgMhqRZ1XLljXMwpvsEgi6Uj44b9+AHjF4y/vcP/LN2AwFsooBHzys1/hsz/6LSL9AMyEy+UB7//v7+Hhr3/YZP+/+G/w1V8CbylIAisG8PN7cDDZKGJKYZgzegCOLRKROAssy4by+X9E/nQBhYLjacbdJ9/D5f0DlmVDjDOmdMR6kajkaYpI8QQiwuX8HlvOmpkoYMMFj3/w7xDSESBCeUx4SPeIccVxukOgpGl+IPInzx1dryWGJkl4WalFdLmea3V1aQpORh991T/bVl2TiizyqNWlqwUEw0KoOs14Pa6lhJJ6zn/2E0nl+qO3OP7pL7EuK4AZhAkcArgElNzkUG8bAJoTrGHkdQ8i0iiPOump9YQ5IGdxvokhYUqiPTMBMWXEKA4vTKiprBgA1og3f/4LgIDLT3+L5cf/oHaDjJAIczyoo4zszYEk+o31qVG/vaMPLaMNRehhcoCTrxwNDHuXPYtAISLMUQ/rBmx5gx3Ik72LVRfMVV+ilEBORriFT+/z3V6natfcMSp7lyy09pHl+gOm6owlwoHwpsrUGo163PlarpGfPsLnKAeONoAahfU/Ydnw/2/lxWHmpbyUl/JSXspL0eKV9tGQ7wHcztB50yDaPpsguCxrD6AzIyU5cbFuuTonhCAnJ2OawCUhl4IYCaeThOLd1hXLYuH0xTNcFOmEaUpqyBSnlhAiQC28vfXVC1U+HZR1PU0zTscTKsitoSTFmQZYlhWlbBXsDiFgikGB7wU553qvz8Xtw/8TkXjiB8IUk74DFYbV4YO074I/mFHA3lMf+tnG5o09Ph94TBNikhNuUgc0b3qp7YoRv+UNF2H2+nSZz0vu2zWFVcaYu5CQfj6Mz8rcq7J2O3nsxvPU6cIm0lsfmwJQf7v/a4NOAQCKRPxxU5lCkFPdwJXgPtbvv/M0sfHd6rs9t6dkjfXY6cM9hWgE40YAbk/BMEeOsS8fVtqJCe8009ree8ZSCu1AA/pKtLfu/2GcBmSyV6zHwhW0640z3kBm88RdVycXqzsE0lRJAh3EQHLiU539otkYyE78e3BT+lYNTrD3bPMIkHQYUEW+tJDA+g5lHUh3CzMQGKQRkqTfQftXzeaIetoplwLW8KZbaYD06Bzjgc9xrRYNj2HTsjnQCMhy/ZKlb2JzK7i1RoT2br7voZKu7D0v/dvc3FPoiD2fKALOwBwCuL7rBvCjNm7ztoEb1s9SnQ5JTz4Z7Yym67ZATmJesG0LQjig5BXf+2TG55/N4O0d/uHL32Bd/xB5Ta6H/Vxnd914YoGkyKG9nOTE3Rrm4aeS9kbqClsnFiHEHDt2naH6h4QG9UccNYprh7v7e2DZ96U3RPZ39EDg0yDINTiJChvuRZ4xTkQKZFH3XWuv7/l1HUatcRQd/aHRhJTpRHdfzTXfGT8NSmZXZ+uhvxb1Z1KnmQB/5lqBx10KKnirTjPSlX6e+He5X0drxcKcS9QkrqDsdX3XvQDk1COvcuV8+TUelweE9Aaff/4JzpcDHh4DzueEnLk6ueR1Q8kZ28rgdUHZAohnSOQuWTPrRRwQs4K1vphsMaZm8un2hMX04B2Aupfs7d0hGuBbhsk+7v2QtKEAJDR/e1t2GhwAyrZiXTcUi8ICAheRM5lJx0Y1lY9PWwE0PuVlKbL9zbFhGRd0XKTGxa3KZCmYs7Xdw5UvShqAoKCtOBBKuglGD7zKnlKKyInrumCeBewlmOP4BIqkBpGevj4iY2c85aJyxL5MM9ZTZblA0I20OsHaHi48uMDSPxGpQRkFZdPUUTDZvTkwSR3uFLxG1ITb3/3cm+e5k93M0GxOmZu+/9NJ0ww4+ULqt1P/Ti9wusMtObW/bvSVeGE5M4JGrdu2gvPlgilFHI8Ttu2INN1hPp5wOH2K8Ah8icbvvIRnPIzc92MZeefIc29IeTe/+5Byqx+395mnd8Xn6q7fPRnBbG+faXsM0PhFbYh0/x121b7f7G/H9Vj0ZLeta7L9/OnReDkDO39LiWCcEOIdcj4gF0uR6eafpm6gahT0PPZ2uTbwjPy5/263uK8+BN94Lo2f3WPrbFlXnC8LCgjTfMCrV6/x5s1r3N29UscTkd9LKViXBZdFDPyffvY9rJcTvnn7VqPyls6Z5ZYBSfREKA4CxDhX5xYxPsp+HyhV45vm0+jHpePx4/Vp7iQVadujPO+xvWjUS6tTRgq1vhgj5nnG+XyuWInHMOzz5XKpdY4OSYFCrft0OlUHRuaCklcwr+qMs2q7Ufe2PrWPp4GOSvS7HdwiBJVwTIesTg+9HnULN2vj05aZu73N4yy31sFTe9te8RHYRrzCH1BblsUdcuPqsGt9tvnat+M4OJlxuHG6cc/2Mor9GF5lUTvNsWlMzZHz1o0hTAmFClKMSFEifK7rgnXJKOWMZcnIqzhVv3n9BofDK+QcsSwb1lgwHyJK5Yzyf3P4ljk+OnqaPkY9A0FhSaWMCJXEA4iDWpFVb9b1Fsh0Qd31NIc0kXOpNxYp1asIKY4EEiUmVhqzAgaN6uJAZPxVZAYCKIHROwd1Y6OEeXoDoknnhESWuX94h2meEAuBKAFIyJlwmCacjiekwxHgCQtlgAFGxjRHpAPjcn6P4/wGr6ZPsB7vcPb0zgkMS0Uk17/64jd4mL4AkHA8zFUWlD3C5o45G5lsLnwgQ6JxxBgwHw64rASEGWmekHPBu/fvQBRxPJ7w6tUrTNOE+/t7bBsjxAMOh4QQCZfLBWtewZd7RIqgcsAj3SNNG+Jpwul0QDpMAAMbZ0xUwHGGRyGanNJrqL1uhU539nu0oXS279t9LdXVbZd8iy5jR9EieszBy/yG5wkqT05i15mYtZ5tw2X9NXKOSLEgBsG/uARwjFjzhhDlPcgeAUm7isY7rHVS3GyaCNtlRSRxrrSoLqTHQFjXo/CEgveP74DLGTFl8ANwREZE6vX6rJGRhIVhnmecTgnn5YKi+kKPeXkqmrwvcnzhHvP2ZeRhT8napHyROSIldVAtzXlTfiIiJiSauv00UJCDxEXTE2t64RgJCKT18NX++Byme53ebrT3RHkXVhdrBP8i0eWKMMeGSjCDS0axg39s8oQiE1XPELwuK+5pzq6d/k0uFf3Oj7er2JgtMtpL+W7Ki8PMS3kpL+WlvJSXslN8SD8AN4SwERzmq2esiLE26akiU3jb6R5vODXQO8YADoy8bMhZ+lRyEaNBybAw70QtlHqMqTrLGKg8iop7Aq3vrwjlchrMQHIRIhmkqU5CyJ1ziIVatb9HJyPfVgcgMQBkwIWBz1sDxWKMoBBVCS8V6BLNpne+8WPYMxjM84Q0HUAhVEHWhyX2p8g8+O/7f8upw9O0S3/F7blxjjSP+vZ9UMPFnpf4OLbmCMNqzBodQq6VF72KBkSQm4M2FlVQ9TqqUSwI0PA0ftuVNqcA7NDN3zP+/dy9I2Dqv/9wp5dmzNBaXf32eeyTBwIxfP9M+9Toe8vMsffstYORU+RvNOUdY/baGJ+TOnVOdXNBHDGKnuYQIE/ALGZJ7RUodungRocZZgkb3hQ7ODCQYNFqWgo6rv0wA6/x3BASJKaswSgRpPnP5QSKhCPnQuDAKAXderY5Y0D5nkJf+QyAPsKUne7jOo5rwqO752q90rVDZntm/13t/W10hoIo4kglp0n9/UZfBw3JO91pqz/ZzN3JSnOYiTHBIC5SA0/hFvnBIqMxMwIx7o4TvvqHCX/1F0d88+4zbOsAvI/j3SGnGcwM4OrucY4O7RkFTI2H7bS1t2wa2NRHv+mf56t6QgWXxeBWrpxzHNfl9h56V58PK55XeVrQ1Tf7z+1xNOAWbfZ611xArpwNrz5XWPD/Y+9dmiRJkjOxT83MPSIzq6of090DzOK1AoCQJSgrpPAlwht/MY88ktwDRRaHpVAW5AJYgpjlgphnT3c9MjPC3cyUB1U1U/PwyMrqmQMPaS3VGRHubm5PNdVPX81jLzgF03Z8bS5tZ9uzxAJIemMm63uERJdJkOgyEQGBewjuprKgbgzlgdreWL78zd3njWU8iLrtg293WzE7dV876ez3736RkPMB85Hwz//yhJtDAjgiUkJeCbUuyLWisEQ8mdMEcAXChByAmnMDnWupKFX3w46SERh5s9aWjXJr+93X0evB09efXPG282y3+30kEDm1NdBn0QwyLJ3Q1jDb2nFRLs5AtzfZK7E6v8+eX0c/W7yHpK08rgKSdnrZDRLlVT3kepqmdvaZksw8Prd85/Zs6YpcFuMXd83/3Ubfkd/R3uHv9yCsRTXo0RkzRuPMnsrJt6/PPZqyB4CE93cg8PaMs9+78tQURBUhaBqT9ry9hyBGYv35EMLlgnyiDIaXLPMjihNNe4vOy8RQcKgTDocDpvmI2y8XfPOffcCv//YOeXV0R+vT0bzY91u6S45uefq+R2f68596inz8DNiWT3/DTv1P0NgfUo8vNnaeNu+Va2O4PUu7RPuM9lzM63iCEiJARzCnZixTq+P7HH2wyGTPHaQ9uv1DypbOf6zsKW78Z4vSIfuFxBAyBEzTjNvbW9zc3DanGktDc/4Z8PCPEYVmHP6UcJhnBDDyzRHn87mlJvFGndfabfIC0FNVWyo8uY/cPdx+G+pw9W6Vgf1c6XKDN2jYo2uDYQQFMMmZdTgcdmXXp5xkhvoQFP9R43U15JHxMX6fm4OQ1rZTp+/1frv7HPdbCVtZmNu4bNfJtm7Qhsfmriz0OIh/ttH1K7LyU/L/Hr9j9XtDHYv04xWX2zna4i1D3662YGzLXp1bYynf95auzO05IiCmiJzFWa4ysGq69hgDkIU1PMczTg/3mFJECAnMR3ANWIukT0x/eMb8zQn1PWH5+1eXfbgShXKgqSTnO4I4/7GwbQDrZyKAvWkjawU70haNv13SWIalbGrjR0UNMnWBsrufo9IiMW5+9WcRdz+RyDWMoDyK3JteE1IKatBTdE2syHnF8WZCCBMEExMcNKYZoIAJCbeI7bzPJntr+0oF5nRApGlzhvfPJmFVneMUJ8SU5Ar3pS98VVUsRQwHpinhcDBnRXn3FCes66qG87I+SgFSEj5zWc5Y1jMeHh6QS8arm1eY51lO0zmg5Io1r2AuQGVwBVLKiDAnRMEGRfEfEb9ZkelbLOcFtYphYkozEBKYCTevXuEwJyzLtzidf9VwDPy/vw98uB3WlDeWwTBOZjTTx23kpbojhciItj76851nUElcaRgpUfIYQDA5FAR6/xr87/4CkQPW3/8W/OY9UhAetWRx1gphBhAaz+plCTnvvCwQEGPCzXyLWgtyPqNU4wRl3cp5xUgl4Ouffo7PHt5gpRU5SORQznFIC11Cxtsv/wNqqKjHBbwuIJKoZUtesJaMdVlwmMWQJzoZx4z/hb6Uxo9c4zW6/kFkAItM76/3M7TTzdhSs1Z1kLKzURJpeYwcMH5CDGP6+S18BRFQcCkrfQw/29MVjPcInRmwdFmQbdWZU+lgPNra0f96JtOfPX2VdXonY1Y10thocOrPRG9Q9LvgA1/KZXkxmHkpL+WlvJSX8lK0eIZoq0j1Qu0InHQOaN/AoTM58zw1r+AGWpCCc0FymDdFEveoIhbWt2QRdkoWzxLBDDYwn3oXiHdRde247OteeGOtRX8xhjU6JlcEs5TEm9PnWC35jBgDYpyH9hszbW3ZgidcVHAhb0lOXRCyexv4Jm2zMe8RYkYG3RcLbzxNSWR3FiHTPIIFTFK/AzZFsAztHtCzN54GlJkAG1PSEKKb9AIKlvXQm1ADHkZMSRh/p9jYRr2wtdkFiYpauvKiCwF70LB9vg7ndBBupzwDx90dry0W4u699pwXBLZt267bPbDRX9973+V9G+BQx6A/4oWaH16eAvMuxf7+uwElWosLB7rfHg/w7VxFp029Dmoym0UFUoGvpcLo4IwJgoGoedMIKN0VmECnM0bnukAIoAVb9wYd475m9JQJgYJGBQiQ1A9GN6KCcLZ3gyoOuQvUITSwgrmo/NoBtaaoclPA7e9GYMbzlAr+2WvPmMHMteq2z1/SgvYNFsHIQGhZM2rcZNATm2dRB98utiuLx74Zydh8yhj4Ngg4ZMZOQBfmhb5KSN1f/zzi3/3vRwDHZ41Zo1CuXVtI4QJs1At28nXFOg332V8D4eweArk6TYUFjJFZ2NXj6IXW0TzSWIxmNl3YSV+xJYwjfent58313lbfx7GlY639Dl//Nv7Jfku2rd5r08dMf4bx2QGIfH3b+SUAkXVGSeYWEPAycsCEgMSEhIDIFn67xxQQ8Fkq2kY02pZtnxl9rrezsNeLa/Vdo+z+Xf6pd7+5xbvf3OJww/jDP/8e6XDAzXzEFA7IU8SyrFgDUIoYLKY0o+aKZV3x+PCIc5ZUQXI+mgeuB+lGIPOiTe1cZaVPFazxc7QSx+N6oz0AxKIQhj8Lrq2mzWhxbbSrK471LFElo7frMwWAsIh73uudP9/279LIzEBsO6d6WiWJagPImaXAsoYCNzDZIuIMfI3W3SO0dK96AWMJ0zQ3HrmKhaekpqo0nEHeQH3vTGGGpuDqfRz6uwuq7lCNYYqUGrKkUoGmTKQw1tPlGh/8fm8uRvMCzztbfy4VidTqMMWm8LzSWBmbeDEmT+3La4UAgKLyfzSsC4keFFEZWNYKUFWn9YB0S/jRf7Lg27+/Ba+erlqf3bm9+dvGyLXangKuU9Y9ev+p/X1O2avzU9+zbyxz7fTZef4Zs/nxq+PZur3yQ7l75bzaavHzJmJeAFPCuooRcimOd+cCcO3922PIPlKelik++nDjIT8mS1nZejxvjdzsefs3TRNCiIhJ+MFoUUVURrE0OedfAo9/GxBuZnz+L8QwO8aA4/GIWqvWE1o60G3Ejq0RS9gYDwqtsOu9jf0eGfs9Xn+Uux0tZcAUjT71nx8LYIy4Y3WbPJNSwv39fatjL6WCx2y21yz6iGAcU3u/GDqqPxJXSWuBrrgcVjvRwHTbePg++1t9C+zslaA2teEne3jPxbriSypg926j3dnzpItnb5c8Zy9sx2+rhLQynFkX476lIE+9yz1v7d+MR++n8rahrzGJwkYohVGZW2QgOzftHKws8hiyGdUAoC5z11qwLGecHh+EZ5zEcCYvFUstoK8LwpxBv0zA379qPdvj0u3ahWxAogiPoa+nLk35GtyTV4gvm1J6y5bY+FF/qNVOBRzEdIDYonk7iYUCQjggRcKrP7Y07GKQkNeqcm5o6R77HELnztJzmtQjTjy1MpZlQcgTZhwBBgoxItTIBIT5cMR6ZonMu7N462YADjdHpNtXIEyIQSIpKivWx4QExzTaKv+S0NsIrGvF+bEgZ0YpNh4ymhLdo+DD/Xs1DiuNx8y5NLyHK6MqDs1F8MYcM1I8YDockWICKGAtC9IUEL9cEe4eUT7cg2sChSM4HsHpgHk64ubLhONxRlxW1MfvYPju+e1XqB+65HbNWGa77vY42gCRB2dEJBajGQAozCKfDKY2/lmlzdyHigBMHHpqp4c3oJ++QQXjfPevsR6/RwkMsESmoiDReYJGZxZc3ugWgNrTgVlE4kARKSYsuUB8ZkPDaMQYXBoSM+FH/8+XwDniFCoeqeKRCrJbPQxGDRnff/EfwXORFFzlgHlOLcWs8PEZy3pGDBWYgBimJqekFMGQFE45r43e7K1bfz5auSaj+OIjhluktVafWdnpeaV55gBNhWSGPQDU4E0iL30Uh3gmj+PvMzm09dF4Fme4rz1tcjG7iHXicxzEGHrArnWclDoJNpmdnNPT3vsVv2cE5Os1h4KX8rspLwYzL+WlvJSX8lJeihbLl3wt/c0AdDRQuoMKWwAJqrgE0MAeb1TRPTjHFDNEHXwuJTdvkkrdm9NAfHICo9QFdKOZzkhdAiypMWVbg5OtEY4pCpi4WXzHWMG8Nq/eNEUEWPhBHgAfDy5tgScByyq4MkK0cMXiSWFePjUXlYtZLPxV+W1t9CCUjwy0tcIW5bt5LBVIio4qqVuYQQHCZDaUU2DQamFk0ZnTPUZ7MAJiRq0SlpZpnIcpTQrkyT3MLN4bVTxKQuSLsRuYdyeY9LkyyNYKufWxFS9HdeeTxb1TX/jRB7d75+OvuF6h33PPFXKe+n6lBTpEpEqharsaAmAbYNNhowZ2y1vGugCYQm33XfqqiytPjEOnEd2rwuq59lxfj5fX/X6U75ZKiXqPmCSlkUYQkd8JaZrUc4xRFOBNcVLvxq7Q8oCrPDtG5JL3mcAbNciUrEwX3BS1iHAaAklgGSZVQihoyipwsnpkoYe6F+Hf3m00oOAynZKB5X1+7fKeUddzDJGulb1n+Ylr23XkFRQWvl/q4AZcE1i7YvvVYqDACfRWT6/bwribZ7833LPxtPQcRBKmtyjQ1oFhM96jZkBl6+c5xfbe1ojFxmkPph7Ae0t30nfwcE9XXRLMiMObn/inbPfsmZVobxu0ZxyBqYwxnNnoUZuG9l8Sgm17+47c/rIxmtka42g6Hl8nbfrFtB3Ry7aMRmXyMZClsOLhTmv5dbWCf8J2uYFSva3bWVfOBBG2/qyLGrCaSY1mQjOW8ePYI9P0069Txv7/cffaWI2/8M5nbD5vi18rHQq+rgL2VLtyxf27Ew5HgGgSy59ScXuUFEulAjFEHOYjagGWRSKBnc4nFKWbHAi1qiflhrcAOt3Zo23MAup2ALA2mtH2Nbmb25lk9MD/1b5fO5cViATY0aVuhBPcmWKrpVaZ3UBjWGorXulk34fUQao8aIg0wnBdjJvtr97reFifNkrOF24guPa2K2A05VSbZF3ZKU2aPlCjyuAS1N0qW62vJktsZRTf/8th7mMUNC2qhXyvtegc9JJSlw1qNT68p0GoakQjig9SZU0a+HJv0FLqeAZ5ucufsYfDQeuvmpKlyyyy9sIwFz0lJNwa+dRCILZIQZZixAxmVAkfCKVW5FKxrJrCNSRQuJPxHahG52X8GWTfR3ri79xv/x6d3ytPU/bnF3Kffmh91yJsbVt+jXvqtNn36pJij+3d5Xyf3WZ/9z4XfdlGbxblxw1MyAU4nwskvUHQSLIZzBkWgoE1BtvzhLNntN/Jjc8pu7zpFX7XfvOOKh5P8AYk8zRhmg84ryvyesb5RAiBwaqgDUQSQTYFhFcR6ZaUb2ekFBHUYMZ4UkuZ43lh669FVeHNPun92M5QN4artfNzWzrraRnQ5VzDYraYh//rzx+LzFssMgRJCp51XVuEGDMKuoYD+PqZJdVGCBKpRqLVAOtq2JEZtK9Y1zMqF8QgylDvtNM5Xbi2d1nT8wjbvrV/FTDP++fIMu15T/k2vMjWWKb12239PYXtx8pTct3eObpncOtqw5a2jLKWc2ZCp1p7sh2jgkI3apLogBlUu8GozB11sdUwN7cXQow43Nw4fk8cs9bzI86BQEw43kakdAtCQckrzgzkUhFKAN9J5AmcIqh8fFz9mRbMOQXWd23vU6fSdr+SnqLtfPOSEA+yBGC3MUAFQJHTqqXCDAB7vjGAMEm7mMQwuRLyalFUCSEpf2sRu2HOgjMIUdpAUc59DljXBcCKQzlAYrNEzGAkTQlFCJjmOzzenxC4giJjuhNHuXyKKrOOo3m8OQJ3r1BLBFicgnIWY2Foe8xIrvGsDJzPGRJtL2FdKr7/7gPmOeHm5oiUAtZ8wrI+NMendV2xrgtSTIhxwul0BrPIXTFKtMrlfIakBktisBUz5sOtRB5GlZREMKOHiKhpRUOcAZ6wrsIb3r55g0CzRrh5jTev/wA2de9e34Ae+iwTGPWBwOvequkSpK27La9isuFBHSkIQCaRgSqxGpkYxd/W3tckAUiQKKZm3gAABRXhHFHeB/HfYgbWCtxVMAoYASFCg0zKXqilIJeCQEUM7nUTlxpQ3lWsjwtwUxBfu3MnGm1jMBYwuPUtQaK3lfkBNTBAUmeNZxAxQowISs8OhwNiiphSROWISox1PaMEPbMTKQ7HsDRMOS/IeUVKCRLJeTNOeub29HVbGWs/daNcV/mBR8fXUjNs5zIiGAHMRfoTCBJlGh37YnPo4oEqbN/pP3t59DllOC9UZ8EX6XIV/2r9rY3+yjjo/a0NKlOQRGcy3sX4Jq8r2pP9tmfyZd9eyu+ivBjMvJSX8lJeykt5KVqMmbE8koATRDegkc+tXMrItDQvI2Vwq2eeSMLlllLVMESKMIqdufSpMASsFiY4BlFK232eMRVhuraoAFYv49JQxTNfHoSR6xFk+YFV+UokTL8Pa5zzCkbBYT7g9ZvXePd9xvJwHtMpEQ3ftww1MyNzAXNpDG/OlhrEYEoLS2iW6AUhNgb9CgAAIABJREFUJkgqlhHA2hrneFBrWRbUMyNr6hCbR2NIt7lDTfEPdkqaHaWF/zxayPe++jZZTlt/TYQRUf6bYG5lu6563wR87clD0IBCryzYM5rZh5pbqwBYSgBWqWQE6faAKROcfJsbqAa+CgI/N9fqc8GwTwHN5H6ASHPJFm4W/ebFcAnQAx1IHMfVq0SaJ77vOO+D0u3ylWtmqGb3bL2xr/ftadDyUuDq8y1KrR6xJIaAEKN6diudCKIIBFuY2dGjknlcC0JnAKiiM4aECglZGwIjRYgCYZK2iCCdxz5yAGoAgkINpKnhmFCWBavmirYQsSEErNm8fMaUHTZ+Pr2c/AZt09iHvmvs33atPb2z9kBaPyfX1u4eSD3SFYv+0MHZ/qwZGJjC97pSJGv0Mq/I3IL1/nzJZVWvNEuv1Wl7jAG1ML77/h3u72+hk/pJpY+0gAzimfcc8NafHgaueh9/atFlOhBLA4U0Y47nmPr01eBTD0HAWKApDPUkGZ7d/jbAOCygL2/u8SqfrVGM9UW27eW7BuBZybJPcdHHxdc21tHPnR0FCPXx2LZ3W6enlpd3WD3UIgYFJiQKahgnYx05ILr53FLsa9TR1tV2TPr1S0X3fl+2dRrc7cYULSr9Ez3ev7acIv63//nH7izKmI8F/9V//2vc3UqqpVojiM44HI+YjxMeF4DeZ5S8AGAsvDZDUFmXPBhMX7Sg0Sb7W9tZ4HmZLV2SZy8jLT71ffNioJYGena6iOaB6PldIkKpknavbs5Fe561r0bL/LUQp8ZPy5nuIpnpePuoaOKZGgQQhdKi0sPid94oaJhw5akpOoMeUVzZODFXUBCFi5w7Mi8xJPjVZvzVduyMTrf55DJc9/O7l+JCj3cB9HGpdPRRLu27neM+gqQZyUzJxrQbsXgDJOaK9dQjo9mZknNuZ7DJDHbWiMK3NLnDDHLNs3RIh6VyF8mE7K+zpwqLesSMals6rkCokPMxxog0i9NBJcZSGZQTEt6g0KmdV+yMFq/t/i3N6bTRPu/T2fY8k7zniXo/vXz8vY3TGfq4c58zlvHt84qqJzhiMPpZQe653oqPl6ffMfILv23pZxq3tIClMs5LxXktKsNXoK4odUWtq/BsxqNBDG1ph0Y+lz/0vz9XHtoziNiT6fZ4Vs+XzvOMeZ5xOBxQa8WHDx+QUkJMEefHe3BZUZYz3r/9TmRvxVuOhwOOP77Fj/74Fnd3d6DEAKkhHQhv3rxBjBGn0wnn8xmA0Mrz+XxhDAn4yFzGA/dV5FNP2JjbNbuXnAGmj+yyTQcVkhg/nc9nzPPcnJGMppkcYkrF0+kEZsbhKFHFlmVBKaXJ957X3s59jLHRSas3pYQvPv8CzN1A6e3b9yilYJomiTxXF7x79w4PDw+t3UZjr8mDFg9QePrajOlt3MdndE0Ew3XoYh3tnfntWXfNp2Oyc2ergDWlY59fx2u5e/aKl/P2ij93RqOl7dqXSCQX9XD/YM4D2+i/Ho/bjk0MEZXH88/Gw9biNE0tTSKp0W7hihQTKjFKzUCVNKYxKpZTC2rOOJ8eQRBnrcIZx9sTjodbHA6vEULCWjLOXyzg/+7XCLEA/+ZH4F/2yKBbWtr53T4fNRNCSsIrcdC1VNCp+Fai2B1AuXblbFHRaPgucp3FaVPDV7Y9ricrM9Zz5yFSCqAYFEeQtZ6SyK+sEuTj4wNOpxNKrjjMNzgcZ+TCEiiEIqZpRgoF4DPoOAEgRAATE2ZEoABrBsABj4+Mlc64+z3C6z8KOD+c8au/+hr53JM2MiRC6eubW0yvlb9HwpRmfP/9W9zf36PW2mit7Wfr0zQdUCvAXBBDwNdff4HDYZIIQ+sJRIzb21scj0eUUgGOCHQAmLAuFTElHOaEaQogVEwp4PH+HU6ne6xB0urFNON0eo+HxwPCFDDNR7x6/QrTpOsXjNN5xf39A5bzPQgJtzcF53zAzFmNmyfU8qMmq77+ryWdruBWGTFUfPs/TTj948ZQgwlE3IxXRtmqxzj0EpjJi4llbDP7SObXnRf6qpQ7AoBga5ICvviH/3JwZmUAy3/xM9TPz7IKCShlUQNyO6Oi/jOeGAiPAd/825/g9nHCh7/4DX755c/x7t1bMDNevb7DfEjIZcH5wyPOlBEpth1V0hk/+9P/FfEVYZ6OIIo4n1fk+zMOQVIfTmlCjAGlrFjzgrWcUbiCMiGGSfC3FBFiBHPGsq4otQCoSBOBSNOjcmgYjNGv4/GIdV1xf3+PZVnwox/96MLx2IyzjAb0tLM99ardX0pBJKDELkdM6aDnnYyZ3BuVTqphSRQD+muGJD6qvsf0rD+XPI7iWu0s9MahRRxsWXlvZoCLRovXyDCO/ot8CjBZRKt+1pmBZNBocymlln5SeDDBVvd0D17H4efEp8h9Kb9deTGYeSkv5aW8lJfyUrRsraG36X62Qq4BwJIHlgdgHlCPSMe8GSgi6YEkTLFZZZuRjAcHfPh1CbEnrGZwwLmPFOMBncEwJe5Hu/Cg+QDWqMeUOHAacCRhOEsoLerNmjNKEcGTwbi/v0dWLykzAPFAu43PFnBKMYF5zB29baO1v3mRXiiyMYzbNix01cgxxQHu/j4LeSkCha2BXoeAbPvGMt5op6cwEe8tMb4YQRL/nNXVDLAUwKu1R8XxyvzteiXqqj6J+uHBwP75EqQwjGoHNLI6STSf7NsL79PR58i3aa9Qq3Qse2Pif99Tzm3XxLWyVdI9cSfEWEbylRvotxW57V7tkPvTofzWXxqNR8by26kypP7nhhW19u1976FNQ6QB6BMIogrwUVlTLk1O4BSAyRL9dIB6BM4G5eQAskJpQGsZLBRsNWc0AAEVXBO6MYjcCw5tnZJ6jwFAjGkAOaVFpmTsHqYCAnehX97f22V/LbqX78N4Dlyfo2tldy3yE9dshGj0Lr1QQoPb/PZZgVMachsnG3sxsBv3lX/f1limnzE9W7bkuu7tMFCImZFLRS0DHv7sIt6F3euuKXWVDrX+PaWsMyVIa+1l2aOO/W7Z1z1hGLnrHf7Z1mz3Wr3W/26U0//vv48tUJrChECjmtAbtVzrPYHc+7bX+thY+zxg2Md3Q+uH58f3dwWGRdnQ794YR37YPKetudIRM3UiAAFiEBpIQmYH9fqL7L3/+hw1xfXwjy/++vZdrgMaro/jNPb9su2Xz/g2be+9Vkoez/80Meb5EYcDUAqwrAGVxaMXnFHrI0o9I/MKZqAogB1NmeiUX/6c9b+No2D7Gm6v955fns2+Dt/bvTPVF0u35GnzJdjpaZJEeOm0fY9uAZsQ4Zafi0d+xlZ9bc/0qFvSOlFm27sCoZ1b1i7WwREjYWe4MSgm7Z/yaCCkOCmvHjT9IQYe1NPf7VlkZ5Yfs93RHe43uaTqCEi/PA878lnUAGQDseW7RViQea7MCPBh0+ni/VFlEg+Si3I3NblAUgTUlirAzn9zbPA8pdRRlO+y0PEaxfOTDmndsZbKwa3FnjZSPebb7XYCiHKQIQqZtmqIYYaT29U/0hFyNKKNGCoszs3zWn/xmyOs+2mR9p/f8vl7dbc+XYly4++zN187g8d2jfTHG8081ea9a/vnFG/612nVJeX7AczLUEPnhTpNEt5aopCWxmEwRrp6tV+OF9zKQh8zGHiytZtnjM5cM6p8qpRSmtLH5H0xbDdnD5G7cpboFiWvOJ9POJ/vseQHTNOEw+GIGNNgJGnF5GLDC7rMv43+O/TogiaZXGB0BWwk4/JM3GIR7XxhYGt0L4rrLjMZLmPpodOUkPMKiz7sHX68snFrYOGj0KSUcHO8QQgBj4+n1vdlOYNInIRyJgA90kxb1dzlhbGPfVzM4cLkpUtlY79ubb22I68ZzRD6mt2LMgZ3fdvOtrcHWe75ZYsxmOzo8bXelrIrgxkvMOxZ3cPbNXPtPBx4lgDU1afiMH6q6vx2vCIEQkAEqxG58ashaErB0FNz2OlSShHjXFRwZLEgCKwGKBG5AJUJlCLWkpG4P7tHCxlwZyBQiUCYQEgAR9QqEVZii9ps40X28KbGLce8wyvbc7skSKKxEAl/11I3w8be9hUjKntg8tCQil3H2faAGaiJ4x+jZI0larxPAChS85OSRNEBCQGlAst5xYoFMU5AlYhaBdx4c2njOMIhiRGyGSlM04S7O4lit+alGUH4tFyA0VtWHLFinmYgFNS6ACialkcMmwWDJqBOcs4ygyBpJ2utmKegEffUdaGdTyzpvc6POCw3SNOMKc2CCdcVFIDDccL3338PRpS0UXPFdCg4r99jrRXzdIcp3Wn7BXsGGc+WUZAv+JDWSwsxRaSGqV2ijSwGS51bM5mL9HpAIPs2GsvsS8y6tsGo3KPSBgZSTXDuSiAAKQTkAKw5Y10WLOsqRkbBUvBNsq7I1rrunwKJ7lQqCp/AWIAA5HIPLEFkurrigQoiFVQCMioKKlZexXkgy1jmXDUNecA8T5ing657eadEaokA1OkNjFJXrCuUFkqvTHSRNUWQkR11Cuu64nw+N2PW0+nUzsOtkYrH1mvVKGi103obbaNx8rPyDZwQ1TC/clXjY8HzYqIWSdbe1dYL7aUVJEe7L8+24exhjYC3kZ/EEFHvV6N+tvTkJuQ5FCFQAG8MP4nk95giLGWvj+7sz4Y9R1rfn8tz6aX8LsqLwcxLeSkv5aW8lJeixSKnyOcOsntg5FKpCAW4i3tOmUJ0nkkip2RYlAMDjLFT56BmIQLUu1EEZ6d24R7FRaLW9DZI3b26QPvKhg6+x8E4iEJAZQtBGlFKRS4FyIzHxwdh6GpWLyCLNiBK1MoM8qAHugV2jGoQYmlvqDPRVjxw1Ax44GRjxxSWcpnb2oenN2CfmWUcwgg4dcZUBE6JoOOBDDRgnvqrL4oxtwbyEwkD38eXAPj84+O8m9LB2H0f2cH6ug1N3NZCy9vqPaVHo6794hCnzc8gB0p9It/t29baTPtgll+Dewz+pSLu4+Em90DOj93fIjMxY04zphR1/9oAbAC79j9fvDC2t1Z8+pv9OTHF22Ubfb88+LbbEN/KoR1WRacF8j+DDQz8FdFfvScCWto1Sbfg0hsxuojqBqULxbaek6Q8U6LIzKilgKIZr2z3r/WUQEEoiKRLY4ADSNNB2LiYss4EaB/KFGx1d8/T/k4Prl+OuffoD25PtnW5efLpmfCic4d3Orh6KQTLHHnh+lJB4uCWNh/U3rMBCWBroCtZt4pYe6c/I+z9tldM4SGGVBZVq3vbEADWHNm5jN6pHyutL+gnYWu7HJkdsBru6WcetX9P0L6rwBhf3OXv3M73dRXgpdf/to5Lg5auGJQdqN827pS0+btX/BiM7RjpyF49fezGZx33sdNyPxYOYufte+hiDO3DMFZk0X2EOonZrgZDZ2r55FteeQO+XBvtL29maTvH/v+jSVO/RsOnJ0/V4d/etb3nfTs+VvIS8H/92y+RZqBWoBRC5YQQEr754zNKPaGyKkWoiAebelTaK66d7Rc0yC2ATh+Ep/XnifE1/nza7rOn+RFp1JC6jJxhGHWveFNulVIQUnI88nXD5qFLZLRRwXl3Rihb7tpq9Hec/0ZfsTnsla76ia7Cxvc6yY+PPDNNM9KUWt98W7e8YH/VuKq3fd3jmbaAsIC74klqZ0N/r4yH8HHcosUIX03KU0fdM9WNo//XjWxsPZixTc5d8TdNc0tNYnz01mvSPgeNbGcGtsYfEwEx2ln/Q4vj0xyvwIAaSClt5ip7ClHnPyBMAT/5lwGlLPj+n4C3/6RQq0ZhuX4WXKGJ7fslvf3/S7l+kvbre5+vFX/e9LrHEbg8rzy1fi6vcXki+r+88/tTbfW/2d+v/uQR06GAIrCsGYTUFlMP5+/TtynfvXt6fFp5ruHMtbnze+6a0czeMxYZpJSC0+nU0gTN84wYCCWL0w0ARKULpSqnUwseHx9wPp8QY8LNzS1evX6N29u7oS/eOMWcckYa59vUjR73DC+Abqjhx/2p8TNMyBTV5Prux8loudFgw5NijK2RLQrmurZjpEfx8ueK/AvGb0M5zEBYlgXn87lF+bJoBubVX0rvmynlJOJxl3925W/tlzNPH/rWIAg5rC/uuSw7O6bVv5UzupHV9jy39EN23gOX5961cinPjEYz3uFM8CpbH3s43RPFyXNentpbV4NClHobOnbU297TnheICTnkGQ6S+UhTfAQ9u3NznpM2V65Y1hW5ZCAC05xQy4y8nlFLACOBwgRJbpqQf3IP+vxB5A+qyMtvkH7xE4SH176rblZJ6BwCahYZMFBAmmwN6jrhHrlhK9F0NqTzmyZPSXojt0/de/svytNZOibfUED5miD+abCUwdRwCKAbTQmZIaQ0Y5pkbz08nJCiplFioKwFBQUhZFDt8oZxiJWDGqUU3BxfYz2vqJoKiiIh/f6vUH/+Bfg0O/kPuP/5Gzx8dwPTvz9OM17/XsSbz2TPExFiCGoUB3X24xZ1S1IoBYkWnMVhkCH093Q6I8aE5ZzBHBFoBkEU9xQJITJiBIgq0hSQEoGasbgwRrlkidhNjMgR+a9n1CWh1hn8+gT6vUc8Pt5jmo6Ix4T0GIC/vkHhgvwnv0b4KiLxK7CtYwQwi0GGyLwBxz9dMP9YZRhicM1Y8i+w/uwVyi++buuiz7nNuqyHQhUrA6AgRjTKx0dIOl/jK7anG29WNENihhOJCXNkf+94f/yPbxC+vcVUgKoptITOG6YdWxcZsq9DJqwZOFPF/Ks7/Hj5A3y5LOIbFggcGCsK1rVgKUGM4UTCQ+aK+w8P4DU7A9OInANSlEhmh8OMXMR8qNQVOS8ISRzhzDmulLX1t2pkFCOrzAyuKmkTAIfL25kXo8gCHz58wM3NDQ7zLPS94cFCD4pGeReD0aKRbHoJ4qngDMEYa14klVWISKlIlP40N8y+SWsXjPRIZ30hABINbaTm/XvXYRhuCWZwldRarOlrBSsskp5M911o76M2ZhQDmERe8JH3p2lCTHKu57w0GcjG4houbPNif03X4R0RXspvX14MZl7KS3kpL+WlvJRWOlNiANEWpPWhAz34XarZl7OGaO/AvgmEVdOWiJMVo5YsaY28UK0plzp8oBb3YITQPYKIgBADQgwS+UXzosZoBh9WX2i9arwiQZWerMC9KA1CTAK4pIQQIyJpyHEu6g23Ys0FDw8fwBDjl0gqlOQs+ViDAEGlFHkhQXPbaj7gXMUL2tpDEImzgSbQsKjSN4MQvWJX7lcmlRnEDvghDc1vTC5RE0gMzG/GSggIBHDoCpFlyQ1oEgBM0wN4oQFNymlr5jJsroR5HCO8tMFvgj3pQDQBXpUvptwX5U33fjMFROf7TRgI7doW5N1ntR3Y1awTCGHwZe3e1w2ufjIdigpSBgg3IOqJR6w1G2X9haHKFnXfaYa1lAw40TqoPcbiSdF/ULBaBDNZhkEFztgEwW2KG3uXrUsT1TY6s+HOscH+t610R+66e5MD9ho22QK+y35oz7VwsbWDqhev7gYTBEKt5lWv0ECtDWhLIWnEKE1/EH2KCigJVKHYtI2w/Vo1ZVOVPOFdwwpR0qVBIN8Dq8c0FAKigAQOYRNeqwAB0famtkU8pkbjsaa22gjTFppd7D4qEKS/bPtNl79bPgD76CPoqRF0j5uyzR4YIb6+YuXa/kbZgqxeAUqhA47dMMGIgGssIOtclZrsvGV8vVsvlnHsla6akoAkRWCgqGCBAENcq4AdJctvvFmDHym8+eZ3cAA12m9+gxZ41o+qGVAYcAZcplZiTV+3B4H3lbidMdsje23d+0Xevafs3DOV8XcLLFcHo5mPpb94qnSqYm/pv/fR7L3wlOiSSnkadfm7f9e2tf29jXoNdbT/a2Qd21+9HWZAI4BnUI8/q6FFrIFxZLqziNu8+n+XbZA3bU3p+vvHEfF1XKvbf39O+di9OQf89G+/2L32+ssH8LyAqSKmvvolLRBJ5EAOrVHNSFIIlxu9nXbxQOJ3Crn7+sj1z6PiS+7lzeMKdfeDTq+RKMkaP8nCd1dGiNSUr7ZaWsomVTw1Au56FxwP3w1Qpc2OLWp/CSTGL0Cnl43HFLrI6IbWrPeBSPYzmTF3MPZYJqHWxvtbKEk5Z3kzZkbrHZBr9WwUhtuz0xsc2XcAzXCclQ+PIbW14OecVEawKEXCdwi1BVkIcFZDFkttBT2nJYKmvKeCQpZoj+ui/PKMQNS8ca1q0jGjGCSyJvfw42aoY22zVKS+b9h+v1JGgxw0GQUKpleWiFYWfXOYg3aRESfCN38h45BXxvf/5GiFRprZcoL+77bs0aXtvU9Fd3kquszIYV5vg2/LljPdXtt75ocW307bJ9uT1Di6sR1bP/3nv+dTynbuePMbgfDmx4+4/SJjOU9Kc0n5VZVpK+nvSoOZRR7bIbBbw7ennAeee5/e0ORMzwd6XtBoaFPCNOKo4+3PDSZkpTs5r3j9+jWmZAYcESsLjmDpB4jkHJ/nGSBgWRY8Pjzo+xjHmyOYK9Y143w+gwga+UNwlmmeIQHDVjVsUG5PNaOdju9wa2z01Cf18IZZ1PAYaCQzEwa46t4nm7puHLM1ivCOVxYVh1mio8UQHa0OokBUA5dBfiaFPuyF7RyUfzGKzJrLisqSsiMlS6GNZiwrdFkMTL38agc7NwccMsKve0q5O7+2hk9KoUwLDOHVjRNvMr0ZfzthyoJFANTSbTLb2gwDzWFbs2MDbEafXutXeeeOhwDqJEJRlZgMKkJ7anaRxSCy4vjOzkPwhu/x16QLtu7QznKGKmK5R5GzqDLdoAuOp0GbE0mzVGSWYrQmwtZRoAhmQi0S7YpzBaWIec6Y4griBK4BQSMdgBmBItZvHlG5KP5YwPlXwPuvgIc9XteMWgI4F9SlohYCxYgwu8jPiLB0KvJEaOsMbu9YH2qVqDhTCkjKC8DolT5DLDzhw/IIJokOlOIMMbEXbIvIeEBNKU2yFmX/ZcAwOLewSmEACTEGpDSrwVuGpSCuxVK3FxgZYaBFHQGAFG9A6TWWEyFSQFZeJmdJpRW/fgf6/g58mvvyAvDwq1sUMCr1sX39DePmVuYj5yJGXcQaTQRCJ08nMeglgDkiZ11dVdq6LitOpzOIImoBUoygJK4HMaXGq8ZYwHhECBVEGZJWS3DR0KA04X1QKta/iyDtQ/264vGzR+SyYponpMSI7wP4byW9V/nyn1C+PHf5o9cGWGRFBBz+CKBQ5R9VcM0Iy69Qc0H5xdc9JeVuSl4xcgFJSpwIwaytJL272D5SGtb4P1ePyeFZdqNEutWonvaccSj0s1e6wjWajVtVDEhkITAyccfDAZxZ9tjtdzf47Dd37t1AJsZCFWdUfc50DkDhivu375GnM2JKSMlS8Ul0p9ubI25vbjAfxCA/RAaVAuYiZ+zhBoyMUu3ssoiRcrbYOWq8PEH4FEs7yyTy13GeQawGmmrlxU6UMyxbZAHRf/QeSrF9ZR52FmG2FBmbUiryKgb1deJmHAoAlDyqwOJsVwXnIeOtbE6NN2BWidPwcy9fVV2L8peM5nAF6W9Vo8zUFmFGaXqjz9T4JFsBpp8wAypGN55e19z4A5NzYgzI2WQ3avcCJtsoT8JAzgXrmlUn9VJ+F+XFYOalvJSX8lJeykvRkjTcpln9+tzYljfYe6KYwrlqbklhwLgxTEU5TQPlY5rBJEJdUGC95LWBAuLxIIEk5XuEqMyUcQsMQlFlrghelStylcgYouyfsNZV3kEBMUSAizKU1ECj2p4RYbIyI6UJ0zSDQkKICdN8QM0Fp+VRosmUBafTI9a8IAYCxQkxpMZ4tjRSRCh5bQZGzOI/wLXifDoBJHmaQxAgJISIFCcVZjXCjLpy1ipKkVqb2qsppUGkwn233GcirCW7lFRoYBhrOGILVQodsxTVGIArHh4eMM8TjscDQgLO5wKQgRpQkA4wg6NuxOA8x6CgEotQzlWF5yqMdfOQjcFFxBDGnloKrBH4sQg1I+7fFRp9zUCFG1ZwjZ11+igEbgFfYex73lMBOAO8wQg3wGEsHlzt4I8IHw1cegrIwlZpoUKAKXesfQYADaAmGkhhwlIXjEZwL4QO+omgY4ZOGhYzpgYsSbhNm29v0CO1dVyb2v5vYFm75uGkDkQzGxhrABH3ZxzY2AceQFPubxX2m5ls8xNcbuU+Cr39IuwFBGSW+0Mwga4iZ/GKiWlCiAml9hQHrFJwM0IhMZbr0ZwCiHLL8cslI9eic2CGalXzq+tYsxkiMnqO34J1Fa8X21+Sjk1AIlBRYbSi1oxVQUUJfasKSApA26vcFGzeY1D2owG6zkgkGCAndKdYagig1TOuNG7Xhb7qHmizQwp097XUg/E7sJV7255SMFeuDdQGi7EiQ2kJsxofyj6qFioWQq98yHcP6Ntv3ltW8jhzAwgsLG4MMrY1C4jBXMFF5qLkRWiuzcEnlMsx9dfEkEI2/QhGofWuG8w42KKdIdt3bCnkVuHmv3mjmfH3Ty++zeT+NmAFhODAOk97/fsuKWvvFQ2fR5rRoZY9k57LOv1YDQCnvqePzH6h4TMNv40t5vajpKPq82f32NwGV1vffQZ++m/PK/5+Z1439GE7Ett7mMa3+9r7eD31/h9eYmQgVo2mN2PNFVxEEcbBjbodDSx73bypTfliKGlXyG+jLFK7H7hMETQWt2paFBdTVIy97tFI+njImJPSdKV3tYLSJKBtS/9jCl6LNmKpRgPMBKrh8yPToO0p7R5ri53xLe0S9wiIFhNQQGvhcY1vMkMaIjGWqRpuvtTSDPkkLDqhYkXhiroKw2GG3U2JqfxTj7Bj4658CY370gz7y0b55uUZz6s243AKjeczx4BaWaMWxBb5sM+xpAoIJJEoiWTNBDKlVtUQ5ZIm5Hw+g7nieDOpfFUwTQccpklGsRZEAGmSeeVaEY1dgKRSAAAgAElEQVS3DAAXaDrVOPC6zYDGlNn6m2eYt8Y0e/yoPG4AvkYXYCCw8SlqmNoiXAmoz6zqsaZMV0U1eKBRxtMRX6eSWwphCoNGJz+S/uhjZXsCbo1ZbT1vzzdsvm/p2EgR9557Xrv37rK6t+fH9rd+7/OMZj52x1ZGuvy99543vwUQylIRkHB7vEWtwLqWZuBdKwEaiSFoyhxWpUwbe7d+/Xr1hs6Dw82wNzd93fy2VbhvDWa20XW78R2jFlWakfGzfSyjPpPzipvDAXe3N4B6wOdSmzIopYSgGAmFAIrGv5phCMR5J0TkvOL9u/f48OED7u5uMU1zcxKaD0cgRIQ1YVlW5PPa+mVR0KSZPpJIN8O1YVFS22eYe3+YGdGfWcWl63bj48fM/+sRS4RGCR3khinlrOl1gjlbleZZLiRbzrYKAhfpR6IECgmlAvOcMAfC6XTC/cM9Hh/ucXtzA6DqGVYlzFmF4g5iFLmWjBZlDaSESvjMZvwPYTtb6gm3B4x3NM5MzlbWNW3tNnoLDUImZwS5J6sKv8ab2tqXqJ6CE7V5AlQ+ZLcxuwLxOs6g+9LR/+16j1EO0kixKWJbFKFaUWpuc27njOdljA8a9xgN75IzW/drMGM2Myi16HLmuKOjzBXF8x3B9jxUBjUls+CNSVmkUovyErE7/HHVc7RiPRWcwhkoEYcjME0HpFQRUFGq7EtwUCMoafvt7T8DvzqAz6YQF+MJPkUgE3gNKO8iuGSsi9C5MCWgzMjrCgYwHQvCUdK+Vw6gkEA0iREC6dlealNyl5xx+vABdDtjOkpqG0bV/iWJ8sZALQXv3/0GOWTc3t3i7uYVCBOAAAoTQFHtkSUlEciilhTkukp6IwoIFAUbrYx1WeQdIaIyoeQKhvA3ISaEJDydwWQ8E/hVQeWKCsEPD4c3CBxxPj3ijDOq8plCD1cAE8LMSLeKJYNBEGwXGunXXA0rLRDjhoLT+UEMCiHYMKEiUgGQEahKmpfIyGVVRbpF70NL9RSnqHgsYFFimSWtlRhwZdR6wro+glFAcUZlAihhnm4wTQcAjLWeEW8WcIiozDjRg0YaucXNzQHTHJEitX2/5gdMOYLmjkkpJ92oDIPVcSkK5sNA4IQ5foEl3GGxfTYYy5CjSz0dUyWgoCI63iswIZHwcpYY0ZJA+TOt0RhQM3BhQHEIQoUYwTC4xTSyRKc0RBdk1FiwHs4oJG3Ka0BZxCgz6hnEBCxal72rECODsVLBQ3wr+1gEDKz0iLpItBZUgAtjXTIIAetyArggBsZXP/4xAMKrdIu0RqzrilqBu8NrPNT3qFhQiNS5TZx8zf2IWWlnzTIPemb7c26aEuYk8x9CEF4A4lA88hWWel0FF+7Gg52omwOp/qKTUqtENpKyoJTcZL9EofHY/tAglRO4NpOmngZK14OlAmZdM+JIKYY5kpqqNjSASPZ1oQpUcRQza7nGstm5pW0hsNKEfhbEKDqc8zk7B48KogiLhj/PE2KMyPlBx0y6ZZ+93FMrY1nEcPi3BhJeSisvBjMv5aW8lJfyUl6KlmVdUDRKS60Vx+MRzBLeUhhL9SDlDoyAgoLkPUemCcwpKcPuwusKf8jqeV8wT7Mw4dWDBcakBlT1zCnMiBAjHDahPQScTsK8NoAdUEFb+qR67QFgA1T4IlUHkRjOCJgPoBZQVRADjFwzzqd7rOsZMQbMx4gYRFHZ+xYxpQkUVXhUEK2FzSfCcZ6Qbm8RAqHUotF1INEtcgeUUpokdGhljcoZRTBRgEE8pZ1xBvvIBx0U84w8yJTyPfVSoKlfB8AccHd31xQjpdTufcuW8zXo2CYF4tQDSpn/wWjEABJSANeBHGYgsyqzn1JqHmKmHGnz14D+p1avwfJdsfMxAxV76uK3C4VCH6NrTDirIOPBI7/mmsDzOy5DlU6JNLzbDVx1qQ6aIilGBBYDB2YROJqyogFegAFf9jK/dnqdcM/ttlIjmPSfSZ/zcy03dli+KbfArZ9D33x0keH5bgDVh8kUlWo4FnpqN1GcZQl3Ok0SKrQpHfc9VUXQVS84axeAEBMoQQwqagEX8YZiFAXcR085KQIcLsuyu45KrUAQIwzxxC1KMeXz6fyI6XBASjOMCAoAyU2Jwny5RsXwQkDkEEURFqJEr1CHNFEGNirdxxIYt0UzFrPn3HQwaJirMRaHLYrnS7rVQBMZIAW71GDMQHAYdqDKCf28TftmYzWeVzLnpQgcRKSewHoOlmyKiYB5PiIQcCbgfM6oXLDmM+4fT1jWI/bW4g8rCoChmzPsGXw0AI0NKB8BL6sLfVR2Rr7PifddIlxGrLG30vDJ7r4+p9b2sOlB0F+rtvpja2OkONeJ7eU40TB+/i3dQGXvSd6sWP/WrRq2Pz+Oj79mRpa9Tlm3Ov60PwJMPaT65Rv357XPzHiXI8vtGT8u/g1jreMoSVQrX8sIwPa6NmfD7wDlyuWEeSLc3hzw/sMKrgHzFDWaAYMQdbyEOQziTo3Ry16NBuxwwpaHHIunIeP17agZ7e3XBTx1ytgrjnHNeKUpqZSPi9HxHZfpMOx3AhpNCzS2a8vzmAG2/KYG8Mo6+NSl7Omn0V2QGA1aRA/JaSj3BVKwOUr0FebmUS58FpoxvCkWfRv7OAudN+WzKWy36UBG/pZxOBwGul6rKbAhMgDslaEpcP2c1Qr93QyXejutD8IrA2aUqqOGaYqY51s1ehVFVc5Fed+AlBI+BAKK9hUaLbJWCftvConQ2zkaC7Se766frWxw7VqFP9U1haw3rA4CsrOiqJLCVnZMLhZRTyN92lzt7nb3/p1PlxTo08o2EhltlOD2Bm9Q2e59so0/tHwabzM+SRs6vG8s42n3x4xmPtYSe09EQHB3C1kfT689IyZiwmGeEKgiZ1GCT2nSvSY8c16LKKcBELI4lgTPl36kkdjKGvvFGzMCGD6bnO8xDJHDE8xw2svSJueRGsU1I3ktZlh3c3ODr776Cnd3d/j222/x4cMHxDSpYk3+ipxfQSHg4UFSPRvvP88zYopY1wX3Hz7g22+/xWeffw6iIPSAgZubI5ZccAhiYACKWHNGKUBUfMPOhnFA/Wnsx3Igua14OmPGhp6O+FTenpYYP228tuEhADQNQwIFwvF4BBHw+HgP5op5nmBypznZSBqPANa+HuYZ82ECM+MffvrT5hBUiqSGKCXjdD7JWcYVrOk2pmlCZTHeMqbKqJPIJ9z+QmWewhr3bXu2s+4wO3+rPaNctpNp5fyzYTd+o3NgPnqnf0eXXfrMmQyzdz5u5wTDk4xaO0azvRajpKSpaqiwLIumDZHr5iglAZTNsGJM42iYQZeXn6BBQ/trk8t6jEwdnxAxTaQ8kDo/FDupxCA4hAQCIxAaVkWUmsOJjVEIqc1PqQUPDw/Ia8aynHE43GBdV8yHG8yHG6nPZB2W9ZHzEcd/uWJKH5DLioeHd7i9Cch/9Q3Kz29Rfxnw7f84qZGA9O8EwjtiMCYsqHj1l+/w5i/fgzEBmBDoiBBuFMJiSf0SSBxdUEEBuHtzixgqQEWdFNEiu7UzNhC++NGXqCQRry11o0TxKmKAwiyiaDCHoYoQgTkyal0AiIFGrQHrkrHmgnk+yBqvYggTI8upwBW1MCIRCgdJi/UnZ+APH4B8RqgFdzHgwz8c8e5/eY063eDNf/4dwmQy6YR5mnBeToh/8hZ3t2LoIymTTnh8vMdJ8ee1LEAA3q8Jp++T+AuFgPNpQS0FOWeUNYvxj2KrOWeJzhfEsJmrnGgxkBqEqUEUyfqLISBGYIpJHIhQEaeI92/vsVQCxTtM8Q7AESm+wmdvfg+v3nyGaYqolLH+t/+E87Li8fGE87ICmPHFF2/w+vUdbm4nhHKEmTrUekLFAd0xbG+f2B6O7XIFY0pfI8XpoxFXOwfVZctKYihjT0UOIOWLzDGlaPwW36aoRoCyIn1kmG5kIaZUhsTKSmKlbXZ9+fx73P+n/x5pijgej8D//RXy30m0UInhk5FRMVMc4n0zxJToHO7xN5/9D/hwfgcuESkdMB9v8Obuc8zzQTBrdU797vvvUEvG4/0HvH/3HT7cf48vv/wC89/8Gd58+xls5zAR6F/8Hcrnb5HLghASLDKROX4SBVQmUEUznrTzcJ5nTcckv0UvqxA0CnG1oDMQuS9imixtXI+2X9QYNUDO8IaX6VSMspmlZJUoMMsqEWv6WaB6GhA4K+ZXu3OvfQd3bEoc9wS/6jKkxgQy3LBmdQSoQodZUyuaTLSHk+pBG32UcygJo4R5njFNE0opeHx8dPxYQEoT5nkenAftejPoJIm8d3t7CwCY5vnKrngpn1peDGZeykt5KS/lpbwUVwwcmue5ARxeEBejlNiBZgBoFr5S9hQLgzCvIfyYKw6HozJ8uTE9TenfVUZNoUOOGWxelvIGEWgHMJgBjUYjDe1KCXH6D02ojOrJ4/tgStKUEujmBtMkTOX59KBhyBUEIfEwlXDrGVWB/OhBOgVmTOmdc9YcnYQULXKK9LLW0kAY61uzRN8BUPxYW9+3Xl5doVDafRRsnvocmecSs8LzbOmVrgOTrIKAtcMbFoyAfod8RxBvU58DM68ZKYyFYKmfngOetqeu3Ovf6e/5eN2jMcLw3FNh4zd7R/bIMzpwrRUbYHh7zb+vpd7aAKK+nq3xzRaY+9haHK9dgoIDGPjEmvDFr+unCg3itvs9EEi9pEDcPNaERshiTik10Nzeub+eoYTLDDhEcWhbVgwrCoiLi3YkY18NcEWHsFtKNVbDm2DhmkV25vYOaWszM2MzjFHa2VJkjN33bd/+beMpDQfI1ouCl6rzaWtiO67bCRC8QZUs22ng9sxTO+upOebNFAj6Lfmf/fMXa5L31/q2eCWJf96MrQJxM57s+1w98asYHZbK+OqfnfCTnwA/+fGXeH2b8M2Xt/irf/2Af/Wv3j7R86cLg1HJIt9o39HBKgI0370bLLLwu20Y4Cflyu5rqr7tbro0mvB37X+62Ivo+3Rr6BLcp4rRKORjxhXe027v7f6N/V9XnbC7y7eVhxp402N/536b/Lv3nrJtIgBmv8vm0iL+D3NBElHNv+PinSz/u5yl8U6/Jq7363Ll7PWYGpx6WcO2pb/FkTeUn/71V6BUQfMDbr/5BcLhgJwrSmbUguYxBx1PakYRvSVi+9C9/rbn6b7h5A6d2SnX+OLBaOTKcz4qFoCmjLSIKgLEjh7eUveoQDMgNcTQ6Pleu/x3K1b/lg/Y4wc6aGxnSUUIYnShd8s5yYQYqUVlWVfGsiwXdVsfttFjrF3bcX+qH35ct9f2lI/+XWxntKoVApGmB5Q+5ZxRoCnVFCVPKWKaxGt/mmJTRJZS8OHDBxyPR/HUvNI2i0jZ5AG26G+dr+7P7ffrY0YzJmP0d3evV69/3fJBgUIzeBTv0EmbpRGLhtbtlS092fboOXXgk9L17dEb2tQh9HbfkPBZbXDP/lD65vkjTVSr/NSlWWiLPgobr/HEutaGvXG3doeBtxhPrvYu50Hur/z6//wMcQLm1xWf//kJFNKlol6XsC5p16/rJ/we3vCxskefmLlhAN7Yo2MCdEHXQwjgopovd32P1oQQ8Pj4iMfHR+ScMc2Hds3XG9x3U2ZN0wRAUoyYokjEDNZhE3ppjkJEfa8GijCsZOxva92VUXqC196Ms0/Z3Q0d+r12/zRNw5mUUtJID0UUYdOENa9YFomX4JVgEgnX0vJo3ZUR54g0JdQqUXGJNDVIrQhEmI9HHA8Hraug5KwRIHloX0qpyb7bnje+2sQe67/Jdg5n4ma4z+2vH5u9M/LauXRNnt6Wp84yvyYvnlE8rBtiex5kpO1RjXGFv6gIgd25689JDN8/Su29nKlj2Hkfa9/YB+F/ZKwNlwzUsbNrMty1sSOSKAslZ5xqFeM1hjiopQSshJRmpCmBKKIykEtBzkBJVYx6icEBOL46IqcJWVO5lEVM/C1djaQUst+At//+iPc/S4j63wEJN3/OOP75A8CirEcNjcegyJhjRF4X1L+bQf9wi/VQwP/NB8SjinbEQAASJXBLeRm60U0baZUBaoWYRgC1Zjye7kXuYUKKR6R0UMPfAoneojSeJQouETcBhQiIKQBF5TQSjDWfFuRzxuMZWPIEirKmqinf2xoLiBNQsOLh9AHruiIEwuP5EafTCUSE+TC3SDElS0SLUgpub26Qc8W6SArkQAFTOjS+SGcAhmGGIYq5NF4MH9VQcopIszgp5iL05d3bDyAccDzcIsU7gA9I6RaH+TUO0yuESMh8RjwEoD6ihhVpjnjz+g0ONzPi37wGfze1SCoAhN8NH+MMruyjesSrP82Yv/4Wj+8+4OHf/AGwjGptmWcbg/6bHrFSu561USMGVjuPEVrEGXvWokIaV2gGMMYfdTNrFsMSfb/UUSUFEypOvOBheQ8+Zby7B+r0j8h/JC0jIqQQkWLQaDMSoXHNBetasJwLTssZ75bvQWnGfHOL+XCDw+GAaZoltVYgBE1DNM0PyCuhlIx1OePd27cAV3z5RzNu/uwO4e0rlP/j98Fg5HVBSsDheATXgJwZlReRGTXaNtUgkc2oG4SWQjqfseF7Eu0+IhHB0js1g0qW0SQyesUq1DtJuaXO5T4DPr0oe450NKCx3+yzGPiawb9FFY9g1nThVdAVq1cibxdHT1UXUA2XrC1itckM21W6dwbYeWopDwVX6/KsjadEm+sGPeYUYU7bXv7cK+Y4cWkw+lJ+aHkxmHkpL+WlvJSX8lK0WHocA22MeTEwpEWVwSjwXwANTygEhGnsqWDkpv6cl3c91CdAZmfEOkNmzFf3gRPBiBuonWBGJkATygmAs9T24Ie9ndlCt4unSlDl8XI+tfeAzYxHhGkEZXGVoe0gvniTGurMVcFMfa0HlEop2rbQ+smq+RYGtbpwl5d/t0CJN3zoSplLIc2Ajz74+x5Cfg56vXJtVMrsM7S7ChX7nS7vvWaYMfZ7HxB9Ttlr51Vgy162Kdf61K5fEYqfAr1+27I1dLHiPcT3jEDMe7A0z29t61YA2psPXdNPKQz988/tvwdnn1LQXbRmUKCM60tTBAtgEOw9rKl8QqN5/h1bxZld4yrRCGSfWho6qDBJ6uVohoV9vD1U60RTpVHU5wkappgNxGAjQOLdWyW3scIVqFUC6zJLOoyIUZnojUVaH3YA8dYw0g/ch3GPNjBse/QoL0a7vYh/vezP5e4ca922H/tp5AxCuNfZSbz6lF/Z93599c/NNbQZyzSwgMT4St5X2jkDFuOnUoCbu4rjdEaY3yIdJnz+ZcLd3acL9AaC2cgzKjIBQEBkD2jpmiIavMNbP9tQcANnrs3OBRiy+daBMg/hWHu3kF2/6k/cviuuGV4Y/fHvouF52tx7zWBmrxW0qWPs5eb8A+30eL9cjt32DVtQyY9F/2ycToACX55y0PZ08aMzjsveHO0VD7Bau3m4gp1vnYbt1X/JYfUxMF6vbsb9h5yE929FKXn8rCCmgJjEU7aUAlLlWyPPO/xGW2Psf3veufxDzu7RsIF3abHdtzWCIKJ2Tkso65F/N0M/VmC0P1vFwEpT1BmtNyWxvW+PHm5T111TGLd3EYmBalAlW2AE6gBtz0ClyfmYUat4fBsPvZcaZa89xrfsjZuNi7/XG5D4ufBj7Ps+yjLOnCSO7ycQphSQQsRal7aOzbCpcm4AsPH5PY3qlZ1Jdu52+YKGtdDX7FN92eO7BqU6tjuvgtmUolfoYvtIABOIEogKgOJ29FP08ika7en/p5WLk6ZrihpNG2rd2768y/Lvvmsvqs0lff6UNm/ptWdgnzAoge915xf2aOolF9eqV0NgV2czZtkzduwnsf2/vI2oABKtuveh42m82xjBre9Ffwq6Nu3w/M+RNfy9WxoaNnsjhDAYyxsGYs9IHeJYsqULRqt6eoGiUToypjQN8sQe3bQ6hogsuUgqZ0Cif5IofWOIqgzzY6IpiDUCpVypA124Xp6/Sv1ZtO2D75dPhePpr3mOm/e70UUx/uF2djFDjSIEDwERYpDoP3bGSUSZruALMeLmeMTNzQ0AYF3PqHnVVE/j+RqDpM55akSGzMC2DnaHzis4x7NjW4bfyK8rR4c363SvDn/++rH3dQznNwwrM0eosFm/YoSCpvhNYA56Tknk1UtDFj8+Xeb6+L7cygRGk0fDnTae3LE1v5a27fBz3CP3XY5pCJJyhYtFqwEoENJhxlRn5KxnXiDEJM41kSXSXskVC2TdlZWxLBWpEiY1NDBTGY05If3RX1eqWO8TcB8xIYIQwRwRfvKIQCeAExgBTFFpJBAjECKwnD4gfP8K089eYb2tCPkE4gDQBEKyZSj9o54ORjst/YGdApZipeJ8usevfvUzMZpg4Ob4Cq9efY55Oirj2B2JvHQQiCRVpKbrkj0mjnmSds0i0IV+OpCkXeuRu5IztiNdYwBXQikAV4l6FCiBqLZI2rJG5B4ziAcToNH6gq7zwgW5ZAjmaWm3tzytGB5OKSImwjwTcl5wOj/g/fsPWJaCebpDSneY0h2Ijgh0xDQdMU0HhBgQOAAayYp4xjzP+PyzrxAiY/1wRP1lHGTRlDSl85OnuP/rfq8z4g1jPjLqseIx7teydefw2ICZ7jBa8h8APQ6uPWtUrb/ddqmUurnOACxiDbi3q0JSKuVakJcF5+URJZ9R+QwcMmKIQE1YQwIRoyKj5BWlZixF0o0XMHIgEI64ufkM8+G2RSenaKmvhecKMeF4vMGZCHyWNIKnxxMCAYebCfPnKw5hhkkLRIwQgZQsQmIGNbRNDd+rRpWjCDMuEWMORikWlTIiJYmwWKuNVlQZi3Uf2rybS4zncG3MPe0auCR9vhvFmNg6sE661+W70lfSaD8a5rs2Ax4zhoP0CRsZVOmej4TaiL29i4y/cmulNUAeqeaosjnrANF7rOvashxIvzoN35MxPX3f8h8v5XdXXgxmXspLeSkv5aW8FC1N0bEBpj1YfQlUBwmn7IRuA9/3wOlW1Cu/CcD6swh0yhTpZyaWnKKqlA4uog1RZ/WNjxKBrTNZrCKAKSSISDxrQ0D3t+6KBesXt7RH0o6g+UEP8wE5lya4CaCj/4IqBzRcM1iDWDKDS1E+U0LIxjiJJTecNsMxrpdc7wiMWbmqqHDjfgFYOWMcf28LL81o3q/yTAdC+libwMVDPbtrawNwXgODPpXPlbEc2/YxoMmXj91zwdgT7Uqme+M/ChxPh0e/KL8Fv79991ZZYr8NQKsTbHcNYTzotgOMAt3oK1wJyenb4BVV1xRWTz2/BQr3i1cbtId1S+m6AXcgiKGGfBpVioJbj9QAXOa+/nsbXD1tvDpQHTUFhdwHDS9OQA3tNwOBiEJTwDWgWNtu5nnBIkUwgFpRyoo1L2r0aO/RqBMUQDRG0LJ32mcPvJsyw4Rq1vEypZl/bn+dqkeLPtfJ2HYPKO1tBhufvPlhodNtW9LFWxqK2vo2Kmbscl9Lu1FntIkSQYga6GFAYIMhK0AWsh4V61qw5oqcAx4r8MtvT1jXgBjusXLGH/1zxpQS/sM/iOfis7qt/7cRW1FVD6g5zpuCzMIsdzjmGrW7hGW238ntJvuV25U9RYEbNnSTiMv3GCDnDYH8tcsWjWk1HD4EM5MxT3y4v3Az5Vuxhav81cu3XWvFeM0+7Y03Xb3qjY+o/e3AZR8P81wV/glDSox+N23a4qPLXJ5H+72xOruC+Vqx9rH77uvuo93b1o2a0N7QYfneoh9yHMYYcDxOeDydkcsqBoU1ICAqne2zbsBn6wuPq2v/2uXnT+E9ts/bMz2Nz7b4M6HfJ4oHDGei8bq1FuXpsKH/0JSfIz/g/23bZZ+9oaX1wRvh2m+tLlMKaBRJZlav5opSiyjmYyOwAItxuXiRXxp6bo1k/HUfdWZPiej/7hm/bqPz+HdulY9Az7CxB+xKytG1yUPruuJ8LqJUeixqMMNIaUJKSSNOjrx7+07QdB+b6wTHy3ver9Pi56zJtg4Zkr2BNOEfs4LyBCJGjKJkrSpjmac/ywsQQpEUCIi4/Szg6z8uqDnj3c8P4OIp9Vho89d/Do1KfFrxNL3TF+P56CI9094ZAFzSyvE0cb8xdu+xVFC9Hc9v/7Yvzx4Fdn2nfjpLlIN9Gn15PhttVEUrb+fp8vzyZ1t0NH6iipQioJEJGFXT4o09HHmzTxmt55dL2tbfkVLC4XAYIkvuPUuht9XK1liGWaJknc9i+GdReyXiFJSH1OeNlW7zRqiamoFrp6/ruoLBIk+EiFIr0jS3tkmah1nO0ZwVo3juOO6t7P1x6+/rkXnM+3sb6WtruNDTXVnK2Dykvep01Hhtq0fO7/k4a0qrgFoljcXdq1eAKuoJaOl0JRKyi1O4cYAwHmC39Am54By3t9gZIHXKvePf/SKvJ11Prt6NfHz5nNXb+/Esj3pdClL35bpoPGabUzOAqGrI4NKTufUyyuLKgX5ElmejJ9T7BH339j7fTzF6CC3CtJ/LPX5si4F53iTGAA6x9fW8npHOj2owJ6lJSslI04wQo9qO/H/svVuPLTtyJvZFkMxcq6r2uXZLM5oZyBphDI0hGbD9YI9hzNP8VP8KPxiG4UfDBmZsYMa6WLbcarm7dW57V9VamSTDDxFBMnPl2vscdb+5eE7tdcsLySSDEV98jGDkFbZ+F9RMeH3OePjiCqICeQX4m/Mm0qd3foVgGValAEYUxgRG+jYh/lWFOusJAkYBoZAgs4BYUJ8T5HuGUMVSKvj/CVhmk8+2K0Wgc8Yzn2iAO2kCPJwF089re4bLkvHyzYL1rxMYjOvTe9DXAefTEwrnns5oj2eJQKTo+szAer1iWS+WLivjulygmCKBTlfMv0cIE1DqgiqdfNWiHNeKkvU7TUtTIJUQOCGECOYAFkGplpbFFqVaCYSuWWIAACAASURBVEAAB9UVNDVOtyp0ACke23QnG7N9I6iTZgCignV5xnW54Hq9oFQgTo+Y5s8wT++Q4gNSeAB9+4jwzQMoMsKXFSSE66Lbkx7O73A+nzVNMwvwjxglVcgLjDgDMJ/BPN3Mwa0cZtwUIRAmAARGRoxD9J+jedZ0Lt2QwOikGe3CThwmkKZnJ8cR+rm39pz1sio5TXaMdjxZ5NMMIL/7e+TpCnl4RqAAEkLJZgNQUSLHQk3vLFJQatFIvRJ1voSoxNMwYZ6eEI2s5DyZIl1+CAWkNOsYA5DzivV6xYWAH777HhSAJ5nBv/8NcsmoaUG5LKjlGSlOqJWQfnhEvCTUKWN9+oAQIgI8KidB07hK04U9VV0pStoKsSJEtOiTRAx1PTBqIZCl/ZUqKGTkHAEA1xHq0OOMcbNXF7fjWmu7AHnQ3cTtcpd9TlgrGl1NNOWgVqTr533d8fT1FZ6ab69Aus9mJC+OPgK/nuvS+w2QezzX5TUw4Mq7KIC9zbfnpJSMjPZWfhfljTDzVt7KW3krb+WtWPGQtUTUwNsY4w24vAGtbYfQqPQclQ2JxnZH+e4EgobvZDLyiRl8cAVL1K+ciwKcwcCsUgpi0KW8g/aqDJZaOjYr2xzLzIQYAoQJxXfg6kWGtunOOJGiiq0BDDmvOJ8fcL1ecH29QqqAk4JUAREcAjgwStGUS1KLGSWqlJbqhpo6XOta1QAUAKT5htXZqs5ZVQvN2U3DngADxe+B4P4sxvCEI6DX9xT08zW8P5vBmlGKh0DU43rYYWCMuNCe6wDkj0rtmN9873DZKL8OjNWuOI/XvNdWB1TGsbd36hz1z8d+u0ca+RgGdAQoein1Fgj6eAXxW2HFR86k/e/u6CilwPNS7MlubqSMpBh/7zsvHfQYrwvgjizQSXnP4PlUe/y4e4Sg4YzNq8oUAaAENfVB2T4OKUDWVGolVxBFnE6aB9d37fd+8HzXLvN0F4kbsQ2IY0bOHcClEFUumFz19AotLZP/4dYhedSHPicJjFJWLOuCZbngfD6DA3r+82okGx7gTQOk9v3u922h6IedXArqOgTozrWDObJ578+61/sQHPLwM/+A0trnAPIArvYqjnB3H3v7kPKjfHIArzkxuTsJiXQHEbNu63IQgQxcDzFCkHBdFlxfXnF5XTFPAKUZKZ4R5p/hV9++x/nzK/6rfw08nCP+7r+tyB8+3gl080lBKt255bsI2XbE9oggLuXHdA5HboJGmG091e81AmT9+O5KvAfY0TheNlfc3xs4GgQOwh0SrXbf+N28nbxryb3e3bfrjsQ8/OZoRPtvRwScTxU6qOv2vY1daL9US1RVBUO0oKNrGpTZ8DC5qd/2GdyCpPd6sD/7Yd5Ro/PcbaPfhaU/JQVqB9UNuHn6P7akFPHuswd8993fQYqGps85G+DMzWnXokV5KzZOF+/z7W97x8y9tf++HrEFB/u6et/BNq47gKY1qhYhRp0/2K3H/UIt5aiMbYCdFzcyT699HH1sv/aOOubROuxgdSmrrn2CFta7FJWvtRakFC21ZwUJFJi2ejEHhBBa5Lt7uqVGJag3/Ts+j7HOe31x7NujZzZen1nDr4s7eGtp5BFmhlTB5XrBcrlgnidLQ7JgWa5gJqz5av2t5KDeLm67jruuTQ3sHp+NiK3vLG3s9DZiM45+NGnG+w52AQfSMdoABbUy1ryao6SCq+6gJRCQEigyvvpnhK/+acby/Iz/7b+bsL4Oa8Qgq3gnD7aveyvlp5ctKc+/M9KM1wUYoqcMfdKqe1CDXZTO7WqzXaOa7jX8cqTiH6+Wt2vUvn77a2zeb+TrPZrnMTUVsPVUbp/DrZ6wraumedCnm5gxzQHLomO9Fp33RK5X+8aHbrf8FHvgY2V/rf0cGGXmNE0N8/DUAH5Ok4nSSZ37+4xyv9aKdV1bOiXmqI6n4tFX1FGrcrCoPqmXV7IMoOtU0j70FNh5XbHICgIhpoSHJ7Zd7REg0vrXiuXyiryuG/uld8O9EXi/n8e+AtCczS57vQ+9nzy6jpOPRtkdY0StsCjGBVUqPH1SHeyODdkBAFgJ5pquStq9/9k/+acgCHJesSxXXC0F1hglGTBHWgiG+8gnx87YU3s7wr9q8hJd6/a1en+l/TjcjJmD/j7C1fx5anrtW33kyL7Z1GKzlnu9+piFqE2sO/6XFplHncLS1mIihtT+jNwZe1sX2rR9sy5Bbb/R0arH7TACs3l1vNU2f8Z7+/w5GrN7vaDpUDGovVYrlkXn6vPLB9RaMU2a0iumhClNCCGqfU4JGnVH6zmlGeuVsP7xB0i9oP5twOmbP0Q1HdttEh8dExgZjGLxFAMIQQj0Vw+gv3xSoqEQKukYXajglTR9e8IDBMCCimUByv/8uaXOGcfm7nmjp9ARCOZ/XPDVf3MFUQBxxPOHBddfJXzx1/8SQQjf/cf/B+ZJyQalCOZpglRC1YyfvR9rRc0LmATzPKGUBR/e/4DL9RUwm/z5+RnMwPnphHc/PyMw4/n5BSGwyccMItXFS9G0SuuasSwrXCUPIYFZo4hUqSioCKyRpkrJpsvP4AhNj0yMy+Wier1HUhTW5yxiMkbAgZBS0ogiPk6koCwr3n/4HgIgphlPT19ACmGeHpHSGaf5jHP8DPXPvwL9gpHlPfjLZ4AC1lwwzROenj7DaT5jXTNiTJj/VPWm/DeC11+pbh7oMzCOCDO7J3lk01FAIAA0oYTrdlINz92vdI80Q/2Aja2+18O2v97a3tKF5EaTUJmmv1//4C9Rv/wOJGdM9YwSK1CB66Lr37oW5ItFJgaZcZgQY8B0OiGmGSEmW0ctyhsHUEyani+vyCVDqmFsYDAnTAmYpwl5veL9998hLwXfffsez68XfPbFBT//0yuu1yuur1dcvl8BXHE+n3E+P+D8iz9A/PvPsH71A17/7P/G4+kdaq62YbbLEY8iV0pGtohnKU2YTydMAELUVFGBg8otACWXoQ8JpfpG3zER89DXw9sm25tuRwARmCN07vWTStEUaU5+ZFbykOK+OgZK3qXrJU8vRY0sM/7e7RPHRLfymtrA2hYecDQR2egGIQRM09T6039n5qaL7TMe+DV9bfENviklhPhG8/hdlbeefCtv5a28lbfyVrwMxm40ZUMB7e1OgLHUUjVeKG7PHUOMO9jtu0gEBAoBp9NJlSBa9HiBMc4JivkLqu9irBUev50pYC0ZFKmF5mUmTYtE7lDugPpIIBEAkiuC5QgXEZRcmlFRckWIAgqx5SWVmptzQkEFUsAnV8RowJYpxe7AzTnjNE+IgZFXzaENwOpbjZSSUeqC02lGjAG1aK7ONJ8QSSPguNktbbeB7jYhiJFcesQdB672qZF0d1sPCQ9UxKC5fEcwSRXhTrCZT2csy4J1XeF5WR3oV+VbyU9ABy+8jXuny/j+iIBRS90YfrdKeN99Nn7nEXBGBf2I4LW/no8bAC0EpOZO3hIW7hN15Ob9eJ9xR5NZpIflCMghWBQk3HfweDv9GAcDgJ5S6Kjufi2d2+oYCUxtF8S+bUcpEbzf3InkYVFDCJuUCFswzUl2x/D/x0Dyox0J/v1IBuvnG1BXfYyYI5IItSqRrYrm8CYRixyi4MsYIWfv+BydYv57I9OwgjLssmp4diVnrNcOlItohKti87uKINvcPZ/PDZCS4d7dd2UGpuWizzZnFYSuWJYF4IIqOk/XIqA5IIV0M37Gtnkf11qRjfBHRopkIgQDumHt82d/AwJbNasZ7j4ERawNG9B+54jejYej92OR5sMQwOeAVATq1AMff4FHZ8bWWB9fvS883DsASy8FUAiW293knTnbCQCbDFHnkvUDET58eAaHBHpKmKaI9x+uSCEh0AMu11d8//03KOUBdwXE0Fu3DisnzfSc4oV2vjwS8OAMPHa9+YzZO8FuCTYDRHMDoI0zmw6OvOeicZfD8NSGK+/PuL3C1pmnZJl9ZALZnUmH72+dgB9/KnQDVu8JIfseP27T/SK7GngfVgM/CwQFVYkIrS6d5LQ/75aANNZ+W8uPtb3tFttda+znJo1lT5yzOsq2lrq7cTueep1/WgnMOM0nTGnCtWjkCyVYK1m5kbFr3x0/OpPaOuPOu3Gc79aFnlIiNF1inxpoX3xt2Ee0uifrRl12JLh4ZLNxjS4G2DIHvLy8YEqkuql0OR9CMJ2v6yr7lExHRIuc841sdqBzPN7PzyWjyopaV0C0HsvlCgCIrBEq87JiSgnTaUaIRqhHaM/G23Skm4163NFvG91/16Yj/WR/ja3Dua/hZXweMSK0vs8AdH2Z371T+0EERJNG2YDgRFNLWaCkLdXjmbjtrt7cd1gn13WBj2HeEZ076YraunTkTBmf1TjW9V5oOoYTjdVso7YpQURdLu4Y8x3aSkDWNISEAOYZFCzVFlwGqf1nq2X794i4SLtjfmrZrgv9PhtnkuzX1u6sGNer/f19Z/b+fp+uUZfoB26R2/sMx+yP76+yqf/+HG8HbRvazr2995YgMz6fUUcg4JBMRNhuyfAjQggoOYMI5jT1+efyZhcddvj7VOlEgn6+2wVOXolGtljXtZGhQX2e55zx/v17AMD5fMbj42OzaVxuxhhR2Yly47xDs6v8/HGOgQQhRJClc/AoWi53Y2SzU7ptEWPCslzw+vKi1yN1JkEA4oCSC5ZlxTQROEQkDmBSpxIDWDk0Qp7Xa5RjW5sd2G6KGcmZt1FDXabmnBFCwOeff45aK15eXky2CaZpauuFk1VaPwbG9aqRMWOKzUFWK9k5glI6xpFSQrBIH943p1PF6+sLLpcLpqTRgeZ5AhPh5eUFHz58UFkqSpyZJk3XqHaMEeKHFC0344zIIlNwI/a2DhodwzZ2BQSRYpEqui0x9ueN7iBb7cbH8WjTuqNwXKNKyZvP4xreU9xsn5eIkjc6MXaMSKaRUENk1KrXXZZrW1uPMMBuN7HDgNbGcQNVbes4keMJhpFIj4KnekhBLYBGRO19FGJPo1mKpvsZ+6m3r5OoNn280530vTl+q0VhsTGw5hXlw3sQPeN0OuH88ACIgFlJHKVUBJ7AHBGjRnNal4LvrgvW/IrphzOeRMO7OClhtIqSMCZirOhysZCgiNpuLDDCedelK4CMgmIExAJBpn7EKKfHtLweTWwkry/LFb/+1a9xvRaEOON8esBpfkS18V2zAMJIYYIQgYSbQ51Z03XlNaPWjJfnH5DXCx6fHpQwULMRgxcjCy66iYcZUgu+/eE7SBWcTg8gAlJinE4TiBjTlPD9+h4vLx8AEE6nM2LUSCoiRq4uSq5m08tRtT0EnacIARwTpinp8dbsWnqUv1qLkjAmTZsUbIOjRgO74IcffsCyXvHw9ITTwwwgaCBgZkynhMfPTpjAeLFnlMsFdfkWIUx4ePwcp9MZKQKCjGlKEMOKiYLqVToykcJTw04/WnbEXB3PV0AWgF5BXNp4AboucLshwnAKbBMBCQRCY1zarQ23vwqG3/a/dB2v3xMAiATzfMIaIparRg66Xgqui/6VLEbSCAisz4RIbesYI9J8Asdkc1axM1A0fIpUx+Wo9qMI0GyiAJ9BIQIPT5+1yI5lBfJKkBJwmt5huRJOaUJKE9I843x6RPANuQBK0dalKSHG1HQVJbJWEAMpTJgIeH5+hpK1CnJZkSshJdP/ySIhzanpHFhHG0sJ+QQlD7ncVmyN7HdL+WgRehSeInDostc3Jah81fNqrXh9VUKb2nojguRrk6BKhvMx3ZXArGO425zSsEEnKwLDOjNic+jtG/1BI5nVsXdfv5wUk3PG5XLBPM9NfscYNzan6yL+9/Ly0tJYvpXfvrwRZt7KW3krb+WtvBUr8zzjdDoBuI0Ksged/TfQXi3v5R5A4KBuKRXv379vpBwmxpwmNfalG4F+32CKUgyxAQOusKojGxvwyxUzVGyIETEG5LqagScAGNNEiCHCUysxBcBY1kxA9XZUgofCd4A7BCXKwEE/dEc+EaOKGuGax3wLZDATYEpjKRqG0R2vfq2enmEwUwzk2Pfv5tnsyvarDqmO4Jl+RrOmvA/34NoIzJvWfXA/2YyZ0QHQr7Gtq4g6/sYxtKn1wWf9atsPRySZIxBpmqZGgnBQ76eAtGP9x7rdAm8/6lKH5QgI3jvWRmDTx8VRHW+vC31+d5wqfu4+GsfYr/sxcnS/8fh/SDka5/v+3t7T5yhhDCWqTRULWarpBUQ8z7eRQ/hePbuhelufrTNjBCFpN9dK0TFOIqgDMOqElyZ779TBUQlxEoTYXYgscldQwLGRhAQlr5BSWxv8eY0AYotaQwSqBGFzhg9zuDkZ0Odefww+F+sg/8Z+6o6W32pCjMXWoB91KNDcdqM824+jcVy39w2U0bzo4/qofUrm9DE5S6TAvoELUv2+jEIKhggSSDLWsvxkMsCRcwwY8pM7tu/tsh39YegJ4L6za/z39nndUkJkdyxtfh0h3Y8DcJ0osyVI7PvnXn/R5m+vm3Tqzr7VRyPoXs/sS9hAhAZpCTafx7ObZDheNg/v6tcbayDQXaieWNJ3mt4DTPc12jpKP16T8Vfafbd5Tjugv/3R7Qig3Z//5qSZsXa+I/InzRNS0kwMASsJqukJLax0my1OsL5d99t6e+8Wg4wYiR1HOsH+msCW5PKpwszmGBjXoE6i9muP9Wp/zM1BNK5hTlLe13eU33sSyXj+6JDa991IZNXdlZ1o7VOGiHA6nboOwQqGM1EjWR31z+gYI6JGbhzXz7GuXp97esjR9ff6zNi+bgfZMQIgdJujFmkpr3o482JEGGjUiIN1RuB62f1Ic82hjn1bOrB+r4zt+jH6mG1t0OMhlj5Fz4sx2bWAWnVnawhRw8uL2lWREgQF0twxfcWoBATXXXC7fmxWHCEcOY5u6kvS1rSuge3XsbEWt5G2Rlm0JaJsZep4lf0qOd5XrP49bd72qH2r7tXm6FiX4jffm2J4u74Puihu11k/Ylw/xsh0QNcZCJ0Uc1vGtIhOOoBFLS3IJVs0R3dodccQ0MfwjyXK7B3l4zXG3cxO2sg5N31bHT+dNDiSFVyejISZDAAW/bWnWujOe5dHLy8vjTDCHDSqrRFS9nLVNxm5Outten5+Ri2KD+SSN/dzx5inGtHlbZTLfswBqf1G5+3PbR9Fcy8Dx2swM06nE2qt+OabbzZrRo9EQu25OEld5XUGx4BTOlkUHo8S5kT83k629YughCEnT9aam13vTvWcVzw/P+Py+mq4Eu1m8b2y0wxp+CTb31o/bH7X15ZKCtv0T/tCtMM+2vf9PvsNMZt7E7d14mjtu9tG8nvcYjnulPW5tN9wdnhF2cu17fe3p92uU9sx2OeA35uJbVOL2/L7cTxI4x+5tvXaDH2vrDFtf1YSBRGh5qxkN8MHal1QqxI4IADzZON9gny94v1Xf4F0YlRZEP6vrxD/5mfw1YBAYGEEgqZ3sftnCNjifzCULOA6veu+mfRdaavq1vIY7Z7Rkuq6uEaM+frnX6PUCJGAUoBCBfJffgNBwSlFnOYzCB79VjHJahGHcs7IRQnQVQo4AJfrM374/j1eX1/MCQ4juT1gmibUWnG5XlTuBo225072b7/9FtM04fHxCad5Rnl6Qq1iTvVOtgILKGBoseI7Uj1iCwEiuFxecLleNT110I1n5/O5Ra0IIbZIYroGqKx+fn5p8ux0PmE+PeB0ekIME9ZcdVPjbz7H+h/eoYAhixGuKAN0hUAQE+kGShZAerQQHe8B8efA+d8U7bcvZsWZD2XTKG9u5x2Fgue/ILz/y0dIPaNcVD9qZ0nXXfbayRj5iNoxXW70d6MFdjtfRs3jyFYfaN5WByVQQgjffvsKqUAMMzIXZFFy5Hl+QAj6XDjYnAew5gKUCuIAoggQW8ox9RVIzvD9tAxWm6ZWsEWprDWDiZHShOV6xeKbwSQhr0ruSHHG+ZxwOp01wmVMENu0Ov3wCP53/9zImhrFt3z2gvUPf2U6g+k5rITa52fVlZcrkItuwNUNpj1qCkuARk7ilpJVozR2rVOk+xscZBz1A2JCNNIV0e1YUXXB5A6h4YztONF/nLCo+NVo6zhI4baYDPhp0M/o+obep9/vU+rbKKe3m0B0zvs8naYJ7vNx3cIjyXh0Hy++eTMZoeat/PbljTDzVt7KW3krb+WtWOkGxHH0gBEUb8YqbQGzvQLkZWNsE1ShhWBZVzU6QbAMF81gDaQKsDq91RBUwoXuCmZWg8pBFg956FUIQZXAbDmyXdGapgnlkiHwyBNs4ZEdlGEDnhw46sCfgn5qBGnoYwPYiFCkNutE/eV6jocdJqLGTPe+EiFUUcPLQ1TzAAAKuCOY0vtSoIprGAgoI1iyB8i6A/++Irs5Bp2I4iDimMPanwPZxUag89DhNIAYI/CzdxZ4247KfRJLB3uOwJLROeV1dOV8VLg3ZIWfANT+NkSQ+2UL0O3bd48AM6bKOnoOt8e3Af7x2uzO35MtxuP29/5d9M8eXBtf90SeoTb6J6XNORDAwXYjwUKjiqBaeFQyAtFGqjUZ10FqsgThUvuOTMEwb8edp2wTzv5EKqQAEAFRGsYjAyjD3NzCHb1NB0WoyRup5lwm/d4Bxz6nBWPYV89l30F2gu8g8Z0+m1u1CgrGIeXyrF+r13c79BTcOQo1/FOLrxfbq+8EZq94AyL2joCj8TXKCUViNAWH+kel9TdRv5P7Tt1xQQSIhegtpaJUQRYAwhAKCJwgPOGTE3BobyP9jE4pUXjeo6p0qMrPo93ZOE4zsenH23djPY6P7bU8Ou74LtujjiX80af7R276Zjh6P5s+1etHv3cnyfZKtP99+PYQcNxVf3+v28+3zskqAiIj+xmI7v8d9RINf/s7+RPb9+roUNj/st3Z+NOKoKcIGX3hW/D1jkP4RxQiTb05pwkrC3JbwwQiZUPMHceUHH7/6Xs5GXh0vB6VvdPx5n6H6V/0H3duObg5Kof7SJAjoUREcEs42N57v1N7rOO+/qOT2tvsx+/7xFOcFMsdJlIxJ90tqg4oC69NDuHbmnRXR8XmvqNeNPbn6HAb23J0zJ4Qs2/naA/11CyAE7wJQBaPFjQQm6uN4UEHdVC4O9l7VD5fg935PpK5e7/amtSe/08r93RWHSN7qTHKT9cbuOs8ps/UmlEKIJJRKqPYOkgcAUyoVNoVK/WhyDsdZ5ShN2vUhnTykfbtSDO3Le1rzoGWsDuSDnpi//neHcZ/P75qbep/59OR/B9dprI5x5ym3l/ej424SBvZul8PdP2km3RMe6osHdRq/MR+pgAlr1iXK0q1tMmlmo2+Lz+2p4YziDbyYJRlTq7wKCW+KcLD/HsK5zHylp+/rushAfIeAWWUQ445qPyDkqYH0pTfS3GBuHH6+Fqyrit8t3zJ6pzu99Q5WcVJmnpdgcteamSSfVSwceT7Jgu9rsuXrSzfYz/7vtgTjbyMG5W8Lh4FkzkicgCx96cg52VDTvIoWh4hdKPXmAPt6elJZaXZ7xop4mpRcUkjqw3tF+mEjY9TcLdzS3V+tM8tVsRoD8HxA+8jYDuOBWJEUBlk26jjHK1t46Yj7/sj4tN43v45eZuaPNqsKWh9RYQeOUE+RcDxewM0hK/a6jT7jV3DMnNQHHcCuk7CzKgWKQnDXHRbdcSffhLe4HY8AcRBo7u4HmDj8Hq5IK8rYgjgEDBNqREdKvkcZ3CYEEICYsYlvaDMhFyvmKfHYaPCaJNBU+naAxHS1KqFBAGECqCgNpKMoB+31Ri3RJlg8lYIqOiy258kMZASISJCasCaVR/GtAJUccozmAOWdUUpFTHoc80543q9aIQraCr5GAQxwCLSGpmmRbLSjTvrumBZr0owqhWSBDEoEcCx0ev1AkAQQkKa1D1bi8sn1XWLFMU1xNPVkcpGEjD5yFZ6UQiEGFW/jCnifD4ZqUEJ4mSRlTzS2LJotOUYWJ/xaUaazkhxxjw/gJcVj08PkF+dsXyTBikEjVZcM5gnu6cPXzF8iAAwIAyaCOkfE0olEAVrw04L2QxfwU46ACCU+ozr+4DXvzv7E2/HEKit81qNTo7pN5DdN6Ocu9XDjsqmZtSP377r7cp5QZAFQhGlZsQUQRwgIJSiOkFIsz5vZo16w2w3MXqYR/WTCqICEo8kyxoBOTA46LjIa4ZjPmRGZkqahoxXxf8JEdfXBcXWkpQCUpwwzSesuTTdhnJE+v5p0zqpF7z8/BlEsMhx6quY56npNQKNJE+cUYpgXXUMxpjaeFT50aNzu4wjsWg6gAnNLld1LkmzH3yTn4iv1XWw+bb2XEppu56D1fciXV/qvh9X5AehY2PL59wNtgdfWwi7pWdT9uvTljCDtpa5TnG9XjFN00bH2PuYXPYcRcR7K//w8kaYeStv5a28lbfyVqxI2wlZMZJl7oFD3dl+ZJhvP2+u4eo9QdOYkIf1U+OViZUdzuZr1qOxD6MfQtzkzibbJezhXskUTA5KiAmBNZyn3QeAAWlpSMMiZoB1k2GkcCiQ7wCAAku649f3mbsTeXC2QkGoNAUDwT2ErRNmfOeZMavBLVWBNd2rcuNkA7B5Vt7v+zDA3jYHI6hdaw/mjGCEK9C15Vvv4UO7Mnzj+LsDKu6Bn6PjKo7JNa2Gw7n9rwMwR2QSP8cBu/2u7r2TZGzDUTlq11Hb+/c/HQCWXV2O6rV3fHyMVHJElmmv9OkdeEfnj20cnXPj8TfPuQGOx33xU42cI6djB9E0PQ+gedlFxBwIDGq71ERRKiGTE5ojeQyLvq2bG4I+4BiMvrNndLypjWvgBKlR3wDVXtv+3uSh95D+P4ApBPjOIVRqPhARM1oNmFFwHhAioEXM4kGmdSDXZcAIhnfwsUcqAQ32roey1pvr/SDNqO9AkVh8aW5gn09WcpDIDGMMIOlRuT8uHH0VbLqqGfO39f5KAAAAIABJREFUc7t35v25fAtMcyPLVBsHJHac+Fz0fmIQB4AyCEBZFyyXV1zmV6TTFTTNAE8QChCKoHnCz//gGSyM998FfPvNx0M06wjuBJkgvNkFLvBkGXJzno/UfU/T8O/47ojwsVmQ7s1j3O7cv19Gis9Yg/uywGslQ122/2F47SDgPxRCuekvue0Xujn2mETjsOZRxJR7+BLdXMt0HZACa6QxHAjV0nM1bWTTV7ft37bD6Vbj8ftzmguFxt+H3Y0+t/wX8iPGPmhandZ7eDgu18b+uU+jvV8ISqA+z2csF6CWBVk01UMnedh8MJT76C7bfbz3i0ck+DFlJLZAgCqDk+uIMCObF0gZ1nXydnTiipMtXLz1tXq7nontaD7SW/ZOYC9HJJPRSe3HuOOZCChZgFIhRrqeZt3FaVppW3cq+nqm4cjvR9Xzdo6vHXDteqKDp8e62U8rG32grZ/9t6bjVgunrkrBTZ9qRAWLUsmhbVLQ5WybFmu8H2iow48Ylr5Gj6Si8br7ZyxWZ43oYnf1JdbrYLaER1JQokwFUUXOrBE5paKKOkSAhIrSUq25GqBqjKYLHGWHy+yRLNPe3SHN0O77LWnm3lp0b+26L4d/SvkxUuPo973VcHTdozuNsvomNs5OBnsfu7Tq9On+GwMI4pSXvqZ+rE79d9/Fbm7MUvByedEIU9VlvtsQaDazfne7go5y+cjG8+99vo/zdAzvPxJpAJOTtaBYJJLxvH2EjX59QqnbcTLaQX6NMYWTpkYQcBgdTNseJ3I55Sl2xEgvuiNcU72ZpOch6uO6tmi2HDSKDhOpZKeAwKXdo9ZecQIsJY6vHz7PPe3aLXHyyG4e00p5qoVx88koY7ZkGGvNsEaN2JNHluHugQbQd5Drs7VNL5erYUXaT8WiXHgKPJG93U9tgpK/byPfH+pOfg47/bvO0+eVwPtM5WK3pUYbBA176TIV2NvfbisL3ZI4PUXVOM6O5Ll/3q6bfc0a6+DFPyqRIaNHZr0vBatFZ9UxPKxZYrJ3GDu9DtuIMi4HvBZjmxsR2XUBP8oWkX7ubR0/vs6rxuz6OCwqKwO64cUixlXTWwobwS6vLZUO8YJaC1KqqMiGLapWtRagVEZNK+Tr7+1OFSsKCmVUKho1hRghRFQOqBSwglCElMQnFRUFKAB+8yWosOkITWps7BwCIfi6J0AZVAWNWgNIzXi9fodaIkI8oRRClQIijWeTIgNSsS4vmtKorgARcl5RyhVVVjAJpF7t+oScC1IKqDVZiqNOYqq1otQMTxdeimEhsk2VlfO60duKLAghar1rAWoGocKjWhCqjYnV7B0C5Qn48CUiNL0YCEAIKMsEySvo+gA+XRFPedAVgXk6YZpOmqaegPk0QaDPOKYZgoDTwwnrFHEFIFxQv/wOMUXwO0HkJ0zxEcwTIIy2eamtbRoliKFkHSbeyZxhnHoERu09uDWvHaX99fLLiuu3PNhH21GNNjagtqGRZno8I2qvx5bVsNKfL+Df+xbMEYwJgqg6OnST6PXXE/A6Up+7JjdGq5HvPkOtCUgF8/lVI7nwjPBhQqkRVSo4GeFFFV1w0PSssUqLdiRGtDJGmM4hKM7P5BaszV3RCDEUtL+zCDie8DBza9+6rlhzxjRNuLy+QKTisVZclitO5XME9B4jAPXLV+BUgPMFxKKbZr8/o/CK/G4B0QnznCxqnaBUAQcBULDmV9QaUGoC0RmlZEsPKGD2Tb4mz4pAKILdvmt2qxHcgGbLWsYx9eG0iMbYqhhwmRlM1yiG8Zkvws+VvvbXavGt5GaFQhXvk22U06bJ73FZH2vDutDrdPsK9EinezKxX/t6vTb9Y9RHxnTqb+W3L2+EmbfyVt7KW3krb8XKsi6HuYHH3MijQV7vgNh7xWcEY8ktPcAAjdSiGChWIxpi0KK1SK2oRXcDx2iK3mBgtF1h0UMhrwaoeN7yjCnNdh89r0cRqQooGfiiOaGj7hIwZ7MeCDPu9NV4OQZqqBmiaaQsyoyxxlNM5kTRyDJTjMjrsnGWiFRl3Oe1gWqCFSy628KV/z2YQ2b+NqAd3UlxVBoZCGhRdZpS7aCkt8mAD8IWANJ+pZYCy8M4Ojg6Pv9RgR13Xvfz+rjYjp8t8HhE1BhDX/cxdh/Q2TPS3VD2nWieg91TfPl97pYd0LM/du+QIfrUTrbjckR2+RSRp/lSds/Ay56R335vxvuny578NNbrFhzb1VFv/NE2fOz7j91ndI5VEQtlXtQIJY3gVHLfce/hrImAFDV3MYcIcIDIfnyNuzj7jsr2uzssrE8bYcTrDRgYZwAuHPjWPO4ekQYwwqCBpa3PYGOcxACZ/oumlVKQizkCniubWN8zg4b5P/bXWPbp0lSeDtF5sE35xaSghkA2YWPVwDZgXIIZ9YBHu9H0Rh0YUGO8DdyPPv998RzxfqrOtU0r+/nkz4NwL7rNxnE4jjly+dhlJAgWPBsoddV1zB23Rff2MYC6XnF5eQ8KEWE6IZ5O4DmhECFQwHxK+JP//Blfv4v49//2/EnCTIcpCFEYUQjBPgPUQnhnqi3pDNBBfX/fV5Tx39vP+56Sg3eHfXnjBji62vi9bN6NMOJ9h+e21uMqSUBzmrY91D8iQsFhjXfjZXOPm/67bSXd9G4v+lxkc9z+WnvCTHck2nuptmZzS4BSh+sfPzUarteLh4PfE0XuEV9GCuA+4sE2As1RHQaizbiuApvzfupTo+Ei59MDlgtjuRbUsoCjz2HVt7oc9HD8fgVX9Pyi2/4Yy0gaGdMX3q3fAZjYW35fNu3loMu1FqBlOM5TEXYnpjQZ2Y9TMHZPPOlpLnqEhlHvGu9DRG3n30hg90gOy3KFFNutaeRUgjoNBLoW+NqJ1ve6i1LXExmcK1sizKiz7fXNo34eyTfj8UeEoP37kZQzklaY2FJ/edrMIc5THXXo7vhY1xXTlOzZaASIdV3VTqGt7qfPGG0NUoc2taH4KZ1wbMu9dbSteVDTq3kJgObgtStCoOml1MFVjfCj53JQ+0fqBKkE5glcEwSXYS0yfdjauV8lRrndPmOggPykSDPD/XaryEjTvLVAfjfliAq6v8+9+43f36wnQ8QYP8K1yu4EFvseG+myv4tHLJDhcp70i+E7uLdrkF9L7tSyu3C15JJRXj/gND8qISuwpt4ralt2VXkkZVCr0I8l3+4xCo/w4rICAC6XCy6XS5OLpRSQnTvaNSP5ZjP3h9fWFwf27rquuFwumOf5oI9GHVOjxHmKHUCj2OZcMM8TpnkCpOD5edHICID5VNXOwboCOQMgTPMJ5/MZMQRUqpDgEUcCUlSbd0MCqhXu1iQGPFqdRo3apuX2/vHv9umCFG9ZW/9r+uvY+qKU0qIYp5Swrj2Vtkd5Zd5HURnlLWnEiOhpNjRKESHjer3idJpadF4lldj6UDJ8jRtloOpNAIVxrPanKpA2HxqBZbDp9PRhTe4mULdrPuIM3BSTvZsob4PucUSE8T7Yk0vG4/zY/Xq4XQfEbEh/tn09ckzhHhHY+1qrdxxRmnbKXSe6+Nri9dHxr7pAJx1pDTWFOzXFToun6xHp827s948RmMXaqnwEs02DResgJRIHJlQUtc8FqLngdVnM4az1j9ML5tMrpnJWp32ImM9PKFcBEPH85TNevvgAlgxCAaApfIgzQhRQZPA8IZ1OSHFSO18IdV0gdQVRRrgw8v/0BHpVWbLV/wcJb0PGkTnX5buGSyjlig8vv8SyVJxOn6FKQC3AHE8oOSOlWXUyUztytk2IXDFNGTEV5HxR6k+uWBd9lvPpAWlKqFUJ0h7BS0kFBbmsyHmBCKHUrLUhQgiMzz57ByXNaLonQJDzFUQJIFiU8II0RXBUUi4qkNeK63LVB0kMujwi/+IPQVCOkffRC3n0TeDpn36H88++Qyk6VlIKCBw1DQ8Hiz5T8HpdLIJ4wOmcMM0zcgyqx8SMyx//Bd59/g6n+UvM0z9BimfUqtFjmMJmzVB5kJ3fAY/8AUyAJB+NfQG2yDn9OyPOGHni/b9/xOVvemSw/bgebWitg46JOkSbcWrJ7Tre138A4K9+QPqv/x2m6QmRvgbJA6QmSFW979v/kVFepzYu97ak1QDzL/8F8EugfPVrPP7ZN3j39IgYHsFhQS4ThAiVC9Kc2nVSnDDPJ43Qm/VvXResy4JiEaeU0JYRp4S640gIgtpHSV3+l8sFp9OM89MZgQVlueB6vSCwILDg5eUHfPf9b/D09IhcCn6+/B4ixsgyBPmPvkX9/RcEInxe3il+/H/+Pt7Tb/AS/h4cgDRpNLtSdR3nGJBLwbpccCkVcU1w+3OaTtbaauufbqqtlU0G6fOrUgxXKybvCIKCNS/2nUcz8mdOYNYoT57GF7D0iOJRad33ooiB2mU6ANyyL6VoFCVsZakOTwKTDOtOH4F0oKM328v17gOseFyH/PicsxKB2WWG2n0fPnxon4mopbbUNv4uNfn/f5c3wsxbeStv5a28lbdihYk3AJEb13sSRgcI3KDvqvkIDOyd3I3kYMBHUC1QlXlDZatULOuKQIRgkWJCCIjMEHADdd1xq+EF8yYUswIqDgx0IKobLlqvlBKmaQaHiJwBj/ribWQ2FySpItkwcuYh5UrPp0lEQAWKRb8xtwACRyCo8R5TRC3jztcK5IhSVqtvB6hrFQOxqDmCXemFJ18YnDN9x8R2V88IzClQhwZMeBlBqb2Doe/OU6XUwS/mqdV1T34ZleA9eLN3SGyB/KGfD65x/9xx55RsXl2Z1jDQqth76NjR4VJKwbquG8X8qBwBUPv32+PRgIwfWxyU3ZNS9iSOsfTP9yP47NthR+MWkr89diTQjfUZr7W5rt33R5GQPlHuAY+j82sEzEopKDmr+1iUmJazGpUxJpxOGnYY1gPjebrdtkeAAgTaBAZzB0Td2drbNezg9vaLgVVHADugdat9bBCR7uoan4nPXf9e3Nx0wEQBNiXSaEQZcQOZfL4HywxVezvR5+0eaB3JR+PfmCJinH97ByLgaSfCdl5I76suj27n9m9TurNmN+69qwQWwWw7x4/mSQOEPTWeOXTM39daocj+eCMPW8uQmlHWBXlZUMqKKhlFqu5m44AqhBAm5Iq2U+jjxYIJCyMJYUJAEEIw+k6FIKNiBWGlCk+GIaS7gnqg4VuAa+/qGl93EPvg/sTNu7EnsDlSdte9I2Otlbz5bksruD3Hd9EdyzMCPpmGal/be+Wo/+61aX8d7wVucGU/h+6cT5v31PoH0MRybOv6/mYjmeWelPe66DXH+twOxjbe7dMt2GrfDeSaRiY8uFoHd3v7742zn1rUUZchQpjnE1K84nJ9hVR1+quMcznG+JHBYW7ucbT+fEyWjfKwkWsGUX/vzPH6fm8vnj5hdFaOjjuRCjCBMdZRnTs9zWAHHkfHsRNl/DdfO0bdZEwDMYKcIoKSi0aR5IjKAgZQ1oJaFdCNSUPT+87Iakpwi+ClrQXbjk3vi316I//+yPYYn8leHx3fH52/1+tcF4fp60LVAO2+Y7lW3ZUOJts1Gmwt1LYIPB1MNee49hXTlkx+O3b6mCNfi35kObrmvfuIuHPSov3sbTgez+lE7VwyiDJIoqaUqJpaocoYxaTLBid3dtlETUfwf383WsG2dALOKPX8t+M17cdIon1dzXXwI8/er5cby7rXrTm9LCoTdTnq8r6l3/hIvfwuHo3OSUzaN6roBgii6RWjVuX1HN+PNe+WRT8vBHVGQkwPtQ0om5Yf2k/bOXz02q4yfDfKJE/F7Me4TTtGegJu0xqXUjaRSbt8NELJTl8ez5umqZFDlkVTfySOGJt4Ty6N+natZYi0e9s3Oh89jbTtym76vx7jbffUBmPfdMcumrN4tKXHvhy/8/v7eydMjrvBRxs2pYR5nkFEuFwuqBUWlaJanQrmOQ0Rwax7LbVUTAkhJRBg0U98HbJnJDaORdeQycg6MihG2j8CfFJuUhvrR8Xl/z0CNtGtvT72yfgq0ufdfr1pONQGxxnHW9c/js7d3/OojqN817bVYXxwsxk/ttb48xo/+33F5/twjeNrmbQkxs1cqDKctx2HjpuN43TUS8ZNQke3rFAb3HVBV6TJo7MGtI0QqlPCrq2Er1xXjQLDBRETUjiBqOoGGWaIkDn6h2ghKshBuYCp4nol5GXGwzmCOUEqIaZH8AkAZSy14Ioxooj+p+snNYIMka5qLH3jhEc2aU2uGZfr91iWirVeEPiEQDOWmpGzpjNSfbiCA6NIxTRNCAFYc8Xl8oL3H75FiAFMCRwjAkc8nM9Y14plWZFiwPn8pek1Grkm5wWXywuYA3KuqMXI1kYKzDmDAyESI+cVzIKYLPo4CXKtIBYQGfGbgZgIKRnJmxlyIeQ2Qob1U7oD33VHJfep3FjXjHWtOJ9OeDidUEVT9lQo6W+eZwhEo/4Ym7gUQgzvMKevEOkBUiKczEzEbZ3zzZuu8VTJIHYBmwCLEKonVPhmIgxPu5NlejTJreTZGn+GrOicMV2nQuc8byLv9eNvrXTXMRNC/AwhPIHlc4g8ar0RMaUE5jKcva0JD7qKR8VdCVjDilxfkeIJ83nCuy8iiCPSeQZHxnK9Ii8Zp9MZjw9PqFnTWtdSUXLGulzx8vKMdV1QS0alFVKKrYFGPDWfAbH/ER7fTS1F4vVyQV5eIVJAXBGiIIFQRLDmCzgwhEaat0WfMjnmkc6YGdIioQGvr69D2kdNI3aaIqYQUApBckZebSOBeMoxjWTl/VeqRtBx4hUzocqKWmHjMWFZr1iW1zbLS824vF4B9E2lmmZqBlFEMqIpRFEiammZAKlbrVdaO83uxABSwnwqlmYMMupN9rR3Os09bG183W/QHn1RTpJ12e6p1Byv9+Nqre25hPhG8/hdlbeefCtv5a28lbfyVqyEGBEtv2V1tN0BywbUooG13EKqj7CmER7EQtja191AVuXQQ8o7uQUQY1Cb08tygFap6lwkHu6k0KAaPIJSFWx2cCrGaDsgs7LQk4Ux9LoxQxCQs6DKCqIKkZ6ORRurxieTO6CN/mLhQJujOTA4BiD08PoK7vfdBRwYpQLX1wUP5zNAHgFDATcO3MAxgBDjhFLtHuKkGXsIMFNJbCer7fB0IN0Be1cwbx04o+Lqu3i233cswwEIbqERlf2uIP88e1SfMqDM5uyAOkP2DiUAm9Q9/Z63EYhaLeR2N9u2jGGusTluVLidIAOoUh6YME+pGYhjJKV9EaCnkRnqO9b/nkOmO1huLvujyr37jL91gKgDV8zjnOvA0jiWmlMEvY42fTf1Zd/CbgcJtk4rBSnNJTK014khfq0uBhwwGB52Aw2of7aoKk7WAtmubUVHh/tCMQVWgLaWglIyQmJQ0BRniTTH2+n0ACm1pdZhYoRoKTkMQIP4jvwu87T+HaT0nXWe4o0st2+FO5sMznJ0Bz4uPfUaadgql0sm247BSWoACOxpdRJKe5wNPCdW0oxL5lqr7hAZ5kQfQx7+fTu/9sc4sOqA5ugw7REKfDwBbZ+beLt6W/SaO2cHbUHX/sOd8eJfO1g89NSWWkFaF6kfnYf7ubSRNTZxNNS9tVEAD1+v41OBXRF1nsLSYF2rkrBiXlFzhpSCvF5BNIFqxWVd8MXpCS+vL/j691/wr/8N42Ga8D/89xMul6MOUUBU9wcxWAgJARHcspmvqCDx7VYVZSAwVAgKDDAX77H7pbvq+jVGKK8ftwXtjkG9/ZWlvbt35BGZZF8nP7InDNze5VPukfG++3P3dT76/bZu96+xP24PVvZXGs4Z79O1ID/XVyyyBmxX+e3nnhiuX1N2Le/tOXL0juPAfqf92OjO1CN4d3ul7TV/2/KHf/YLPH5RQTjh/fuK5QKgJpSalYxt5DcagEWdz2Voi9j6M3w+gpSl2k5sWNrKvgNu1FvGMjq/Rvmp78f7jh1la4TdWmQcI73XVHfRNB6+pihIChCFzXptorPVUZ2QPd2DrxNjOpO9XjXK75G0PupHaZpAUiBlBcgd56yh1mMCMfcIZeb0JeharXJ967R1J+xY7/G+e+fivu8dWB0/j7/vSTRHTnlfzFKMptSIkej1GRKRRtEwHUyJMd3JG+L4vX6nRG2yXfNKKGr19HFK1Ii6+yEyDBav/abO9xyeG3KQnX8U3UCvuF1dx7v4eFIvgM4NqerokIP5rXehjZyoMGdYS9N03MoxBVNLj7eLPPMpcuQ90sy2tb1tP574Ml5hoCCaLBnl4W1/3JZer0E3Hu8mrppTu59LHR7us3u6m1o0UqPLHk0MjEIVVXiIYAfTcce63rZmfEcgBNORNCWTRlBZPbpXG2rjE3AH531C9X5eAjpPfG64zLguVxADl0vBPM84P5wgELx//4NGnGQCENoccZs252xYgpNj0K9dtmmMQugRulxO1VpxuajjTeWeEm26cDdZR6o3L0tu9mcIwcgl2i5N81ZBFFvbN2TdppdrtJYaKlLUtBCBNa0FhwA25+3lerUBQqDqdgOaZtCjDok96629IbZ+ElFzDr6+vsLJOeMa0klM+iyqpXj+7PN3uF4v+PDh2Wz0MYJZ7yMmjVaWphkhTShGVmIOCIEhVVPb5Ly2cZBSxDQlLMtiO+QrPO1iGys7ubKd6+N6798Po9T7op0kTacYiTIbXGN4VuN7ajfdfv8xwouvvYrFlLaOjSTS25QUagd5/27JK9z6Z7wv29qs3x0TT3r7xvnqc8l6rq3HStTVab+Tfqp8Kd4lQxd7X4jPGX31dFHdRNO55RiILtOeLupIspKf2Nvro4IIFCOYCMUJ1oDWnc1OJSOOErDmBXy1fmXCcnmGIOF0ekBIEZkIl3VFi7lBip3mVe9XMlBzxnVZEIOAKeHhIVlGYwZPjId/9WuQVAgWLOsFr5cXrNcXlR+k6wsBOMUTCKwEgpqRAmE+z7j+hz9C/vYd5PvPQf/rf4FZgEAB/p9HrS7sn7S2UQcCCml/xlrw+bqa3NQ/jQ4SUKSgSEFGxcVwTY+ASgKcDO+IItCYFYLMgg8hoDreKRqFZRKxlI5AEOl0IX9s9uxS1XSPFYJaQrNd9qspgfDFP/8B09fPKKUCosQdgJDSZKT6BJDqpmlSwgyz4tHX6ytev/gB+T9dkKaAp88+x8P5C0zTExgnVCEILY0opYKy2vqgG6Gajg+0ubH9a9PodqyKyS+q+Ow/+yWe/uUznNzIPCGGGWTpkmpRGSjIeP/nj/jw5+/gtkKlbkd61OL97KjSoxNVMIAH1PoAwgkkJ8UukFAK8PRnFQ9/soJoRaULrus3uP7bf4Tym0eXONAVVkdY+P5nmP6XfwXmBPzpNzh/QXg4vQNCxK+++XtwERAi0qSRkl9eX/D68oLH//dzfP6b30ONGe//5DfAI5nNsmJdrrheXgFS3JmZIaR6hm4OVfz58ekJUgXr8oJ1vSKvixFWaotKFmPAui6IiPj11/875p+d8bT8HE9/88cA9J6yKOmUSVEY/IvvMf/tA+iv/hNQKsh/9AtkZF1/pIJqwOmv/xCnK2N9+gVevvg1RHStLEUJPKVUi7opKHkBIyHGyfQBjURdisqXNCVcrs94eX22qE2aijBn24g1rENqw7FBkB5ZW9ON5dzJKSKa+sx1Czc49begmoGtcyFEBNJNwSU7Sdb1GTL56zZyXzdFtnJ/XGvGdWy0w1ynGMnL67piWRYAwMPDA87nc9O3lmW5sePeym9X3ggzb+WtvJW38lbeihUNzqvkEEOHTHGyA8yg0feO3d1Cp2r36nnNgQs1tlSR8d2WysomAapkoHq+cT2+1gwhQZrnYXcpNxILM2FZFfjpwBNbrl0LDR8jhAMKe95OjRZRMSFY6iYQg2wngRJmrPnmYJZawFKRGMgVWJeL/h4SOAVIYFQ2h0QkgAM0vCIhZ40qUGoGAukuCYpq/xTRXNu0ohq4oSDQpIorgu7AjcqWJiKUWjVKQSkgM849RCMRIQZq4ZohVY1Pe459L6eDHAaVCtpuEntQHeYlc2aIpakBI8YJzA5AdWOPKPTPzbsDa9dxuN6x6CkOo5PVw4hXokCLo8FipCMdZH69EQQycMM+e05lEc1tPCWCBMZpimZked5l2eAomvPZwTC/yw4sQwdoHWDcQMAOBPh30n6BG7E63vpOKmvNDVi8Jw/1vuvGRXsi+1DnGzKDgwqw+c6tOu2qNBxHQwcwg9FBIwe3WbjNfYJe0kcdKhQAFwOfRpBLurvWAah2e3eKkINgNtaMwKChkj1FQUHJBixDEAP7yASZER1CBHGyPqytDUIailSNxQBI32k/hhYlgu3C1HFRa0W2EKdMml+7EZOkNPAGUjsRx/IEEwcNId4Hij0s2eB7m02MFp5XkOG74YSK9jVxw1S0gqWBoNWBRYGBx/ZkfVy1P2rCVFPu0fBMndBGfcerbB0nmvNcUGxnH1Pf+coGsHWnK8YzgVqNNKNEk7aetCk+gLI2QoK/Fxn6aTSWPbS0A7V6saM5BNxGQ+qgg/VJex4uJ6S1yZ1UVSzaAAKEEyhoaN7r9RXvv/8GgQnvvvgKEx7BMYB4QsGMTBH8cMUprjhHaRkB98V7hkVBqABGACNC0zOR9QsICrJQd4hpjcUCPPu89VZ4/6J9Gp/QvdLxvfsAxSANb1pDu19u38tNbYaVBYTtnbtj8Pj7fu3b+uxb8DEqEe1eP/Z+vNa2vrSpxacgniZPhvc35zfdzFfSHsFBl1jayjRsn4/YmQOEe1N2EO9mxdt/9ymyzP2R9Q8r588WPH5VsFwSlouSlSEZBRm6e1qj5Xlnq16paWaqDMmoxPLPw5xRTVaa88fkSjBShBO/CYBYqoQmIsZ225rlIoRJHcrgnmpvXIO7Di4aLpuMVDGkytNQ8gkxKFGaQ7BIOoIpTS2SycYZRqRrkq2rTZ23Nc5lYJWqQs3RrLniAAAgAElEQVTHxAFhZiSpjDsD2SMylBWZBNF2epLt/BS2KD+ARZ33KDNZ13x0Z+1I1tmTYkZCzTYU/q2OpM+KN9eCPycZov5AmrOwgcjWCx5dosjaFmhdy9Ve8BmUzQ4RJ8GYHkgSUHKBp5RQLyEj+65Pl3lOeibV55x8qsKtr329jVZD8QfpY4cwOkaOHErDCO0kFJiEcpWXLEVPBaRYBDl/nhIAidDoJAUkq7kqR4mylamqf3Y9w9emUQc0s6Adv6vqpuxTOeGTn7akmaPLex167Y+Pu1upm1+2q+EoN49XyH6cEhlcwMvBcdSuBYxRffq3o2w/+lNtjFBQUVx3tJb7Xfv2FdnteXfpqdfpZ2hEgVp0Z/5agCIFGonBdSiChmKNdlav/Wj/9PdmUwztqqhKVgZAwWrMtmMbghNPmoIjCFIy/RlkSqZFurVp4440Edad3sHSGzAjMoMDWzQGjXKyLMsgGzWyVBXV+7jZDIthF7oGeTTGUj1yQt8ZDiEQmzyoRfEQiWb3ajppYjb7XdSRL0pIqoxGsnPCCbNGi0ilaCrYWlFqJ9G7Q61UAlaCkOIvPgE2dq/pluPIcOKMk2PEZFRMUbEfO5dIcZEPH77Duio+klJU8iTps1AzQkAUEcKEwBNimBDiBCmL9psIyppV3pKg5gxNB1cQA5DzFXm9IucVtagMq0Yi17p0wlaf3YOsa+u3yQgbamqKdC3MsQaXXcQud8lsn3Hs2lxp0eCU6DSKp3Fd2zsOR3yjlgKpFsHDw0dIt/McJ9vaeqajuHwlvX8ImpIGII38AU936JHrgEbWE58vfq1OrAVwmDppdKSSbxirGj1JHaFsKddN56j9OTTcJkQj1xYEnsAcIVKazT1Sww0e8B7d1MUHsdqwZOQc2UTuspwklkFyS7TimPSVdb2DCHJdsa6i0UTzFbICISZkCGiawGCkOZreWAGKRnbQ/q1grDWgLMWW/IK1apQVYkGMjOkhaOQTyZBTwfQYEeXBBuWwtgqMECLgqhsK64lQo0WlXhPou68agcE3X+hzMsKlk1zQf/NYGwwgHax4OgQLNO2Ukmb0eI992q/VV4wKoQKPSUWCzbHHNtN2LVN6QDWybG3HHRFh02PGdAZKOYEpNKJ2jEre5sCKrpSiMplZo+YZzjw/zUhnJePF+CWm9AgEgqDY9NPNg0K2oYaqyTGYzNDea2MUgGDZ9aT+qc7TAB2ME2L64lExOdsEpJFIEgjccL9gG0P5b+PB03IB4ARbHz8mzcntG6AiQehLZJlBPCG0MMtZ6/huQS0XVFkgpJHSMW1u2K7LAGidEL79GQDg+uGXmL4MeDhPqIh4OD/gw8tLixx0vb7g+eU9rtcLph9OCN/M4DmgImN6mnGihxZx5vT02OyAnJVQEVNASipXOAQEEqx1QcmL4eRJ5wlFlGxYVU2gKkAJyNMLkK6YcW7En2W5YHl+NjJLwmk+I31BqL85oXw4g+eM+eEdarwgRE0/liiAfjiDrgnxdEJgJeVeL1eth4M9gRFiwDxHsDACaWouEWBdXnG5XpDLCmbC5fICkGBK6k8omRGDb6DlNlYIFSIZxSK/+QZYJ9gwBcT5ZHI8WlTWAmLHzW0eUwRsPXG9pUHwhi2Pa5Qu//vPvonO5mW7gI077qneXayVUs1O0og9Lt8IjJQiSq54eX5FqWrDx5CQS95g6W/ltytvhJm38lbeylt5K2/FSnXwiKiF3N7uLkQD1j2SiR5zz7PHfWckYBqThmYPnMAU7BrmQCdCjGo4u/OCY0SaJlXCLdc4OxjPhFxW+EYad6jnvDbGc0gRlRlEQXdB1IpcCEIRIc7DTqhx960BZmTGrShsGEjZ+XlZlMiSJlAIEAIqqaLHIYJYUGsGhFCkYC0ZqIIQGEUEgVX1FlKAL689nL6CaBqtgAyEiLZbihhY84p60egywUCIYs4Z3QkcbZegdCDMdhVVGWBOBx6loorlLnW1SB90e7ZOzPHAr4EjmFSR7imgsItQofvY9zlVO5t96+xoO9w8TrdH5Ki1GRTdiU49cimkA6c0AqrDDq8qBphCd7dxQAwRuolZtO/FQ/JaG6BgSnOEC4DBiNyOc6+HNGdHP0i/CwOM7N8Nk6LNLe/38ehNXvPBaXRTjcHQqLWq0d7qN+5ibyf4HXSu4tYVsN2FBrdt0EEabyvDI6yIA5AG1DFII3faDjAaWufRVsQmHQljbFp3ZjnhaQDhoM+9AZswENGOYQ4okkFClm4ugkNCrU7iCDZuHLjxcab7qjpZZtwd143DYvUqWXdyVRRsyTUduhl39PszZ9a0c+p7HZ5t65t+re0zrwpWEBupRUGaEENzlG+daG58DmN0SCfV5okZrP1zh5H1eer4ag5J9DntcqBf3540D3LEnAF956MDQdXGQYZPbLJwqgoq+bje7NfucmMzn3y4dODUG+K7j9uQGuTP2M9j2faPX7CDeNu53AE6J81oWxIor1jXBR++/w4BgvM8gaYEDjNSnJCFIWFClRmX+oL1+RW7qmzu6Z98FyCDWlomhXsZFUBGRXYn0i58vLtlK7mD1OkVfg9qryPMeQs+39ZxHDdH5/QWDODdnSK742h411eE7TW29d1+1z9/zGm8veb+ekfXOrr//ncafr/f6i00PN53PKI7MGm4rkKcIgbaQobf+1U8HdT+uibtepoOT/fRnCTH/eXnbT/ffvfxJ/3bF9VNA9ZVcLkK1qvqD7WuyBbhBDZDgFFfsbWJXXa6PCua3g5Jd/+5EHdZLUCKPSKdr1G1Zowki21xmYguj/Zyf3SAQJqcdb2GyYmX+lsICRzSJiJMEc3jrpH+ACUFjaQSk/et5zxKjstIrUOtVaMy7gDIUYfz4/raa6QZsyWEAiJPu/P6GGwufNf/7Bglet5GMvP3Y7TCj+lG2t/b3f7t1Z9Sc9aVpn9WA2FDiJvB68NIyeqjk2RLxmzEfWYjGjcVDaWikZhCCKYfVK+s6lrkOmkn1m4IPv3Roa9FfcxsHS5dMh/NxW4THM1TwWY0V6iUCO7gcufhBA8PQFTUuRJu7cNRfutb1eNrl2DtqEbOHuQPCX00gswoD73etPttrEenFt7KN6/Jfl37MeXoKBm+96chB8ceyXyVzWR6b9fJb4+Xoa6337b77bqw96naulWkEWf0Kd+uiX7d7VyGkp/bp4paMkpl1KopR5SnWMDBxh0H97qafqf26kh82743/bDN/9rkhZNW1CmuTmNNSarR/V6ef9AUDzWDaGopV/R+bqNW2/UNxBQR44yUJoQQkUJAiIQYA0QqXl6e8fp6sQhSWueYAkoR3TBTAI8sqxG20tCJZHUOtvtb52CVqmRmcTJnaaQ7NV5VntTqkRmkObzHZywEUGCNIFwTJlFbJ+cMsVRwnYToJDgBaoUG5WQUykpmRN+4IPBIuaKkbUtvrPq92gshMHoqOrTntCxXLMsFHCwiTeROKrLZJrXqNTi0HfEE0s0XgEWOMUKiVKAW6Lqt31+vSpbx8VJFySCaanuwke7p/1qZQR4O68VGmJh0IJ0/bGSSpnkN/bXVidGvI/75Ng2z12skisLGuW9zq4JGImo1aoSZWzk52qZdZ1A9wUkErS5GznIsR6T1go2HThDTNe/YhmrXlE6U0despCgj3LiNrL1kqbbECDOkGzmYo0asOshh221wT7k5Yk2ud1m9bLypjjscgJGQ207Q59D2FgUjqClpQ6oSLepaUZeMlBKQM+qaENKMMJ0hRmjomOiKYlEdYDZmqRWlrshZCdKBCSFG1NOMvOqzDjxpirOUUA2HI2vvsiyoUhCIwKzpZfIaIU8XIylVFBGIRfkTIVSbZ03fMjyNmLDmFen7r0HXWescKuTrb5DFIuZQADIjfvcFUmUjrrjUt2fx+Ao8vqKYflOlWjtNZsOc76JRUwMHAxRtri0J/OGpP2OMlqnOMxZpmz0FQPriB/C0QkgTCwoAStnGcWzytmGPECVxViPZU0CIwTZICQInPFoqbyWY2XxBAbNG7kAt8GFkg9HwVd+s4/rYMK/RU9i1YqKnbRK8GeRfgPAE8IB9jccRkG2exi8YD3+UIWXF8oszpHgfuVXoUcR6zViFGcLnK/j3MxDeQSRoX5KAqpKiiIA1X3C5XlQeUwVohnxxBckKeQ2Q7z5v7d01EfKbEwQB5RQgTJg+I0AWhJAwnSKu64olf8CyXvAh/T3mL09AAq54xWenLzC9PKJ+q1Ff2ObndX7Gy/Q9csmYU0JKtjFWBMv1WdM9rYrPM6emL9RidawWV6kSSAIkMxZc8OGzvwWIcKUPKDmDECCVURMAo20JBFIZ8fsvIWEBZZ2LLBH/H3vv0mxJkpyHfR4Rmec+qqp7Bhg8KBBDkwiRAmUmMxm40kZLrfRrtdVCK2khM4ogZUYjBUhDGTCDAWamu6vq3nMyI8K1cPcIjzh5qmqmZ7Thibbqex55MuPp4f75F+61ygE+SQ+5oBbCvu1gTbNk0fZTJCBG1F3WruwHFefzK15fX5DzrntwxfObR0m3SEBJBWWXg6xih3RNgHXdixwVwsy+X5BzQQhCVpUobxG50KR7aAomSpAId4ZXK26HMKZodXaWzOFx92yyXTHR9v1BxHKzEFpkwqzynqmtwX3Pzc6KMWJ9PCHnnlbyXr5/uRNm7uVe7uVe7uVetBBGhnD7fDDUHbBqkJwz6v3f+ff2OphR0+7TDUgLYS6GqYVXJBQDOvTWpiA1vIFrC9nXQ8g27LbVlWEAdXcKCD5veVgFhQsKMHGtsK/MGcIMjVgRnRO2G0KC/QXUwrCTnhSMny4nkcwOTymgFkKBnb6RvgkaaSNECe8v0V/UiaBhzs25XYpFRWAQ9dDR0i8GLDZEZhjP2enhnQqjk8IU19qMbjjDeJ4zzHpC7/C7awd3n0/jXJIv/Rw6cHiDp/vYuGo4Xr1165OqBmItQJWUClDngoTo9uBpQCRLAaDQypFDxvXllfOeDz0Q4/dTm6kBcVMhXacKqs7P8v3gQbejdT1ff/Q80uddt7kbY14W2GdXqSiaE5Ab4Hir7kefz3PUz9PZiWZOK5mjvq4mu+we0DZXPfEmAJNv1zyfDGyrTnYRdYfBYKU1cXI9J1q+dFf8e78Gh987WWbgtK1/AZWPx7FOjrxbz/P9C1A7kek/93PrejwE5Il2CKmBu9bXXmaYTAKo2gljL7f8Wp9bZGvmOFJMT/fE7bdsKcNwW/6N7e/3rS294DTXD+WYA8jZ9U8t2OuG19dXDRWfwbxIHysYLaBxxGXbwXwa7+1eWwhqEy0HK7c5uCITCmlI6KvrXFP0/51e0eXxfNWtepH76389Sof585HSMTstPZGPhk/baDbg9LhW9ixPLfF3OS6fapf//BZZ5ohw47+79WQarvSSltt7/1t1K7qrCJq93cWU+/Qz7O5HJBoAQ6qT298ZGHY9jv9/YldcA7aN8fLxjPNrBiGglAt2PSXanJK2fnRdi3MpqkNHeydCORwdgDQdsDmW2BECnJNNvryuX0870feGMhA9w5V89a+9U22WXT06Sr+3pVry+6XkpR/v6fdSTz4xUrk1z/ZuT5Sc9UZfvxADQkBLU9W/x9B2+33S9IilZN1/Rvthls1H/XT0/dG1JqeF3OR/M/7te4e0X8YQoACJWKkOwFv7ie9DHamhnvZdCPHqt58rM0loGA9rhxuf3q4DGTnda7yfva5AIEw1xdg/koo2LlE6ifpV4y+uJWHfpdm9V5LIZ3vjWsZOrWkScZbJDNtrvkRajbLz+tX8rZEP/bWMebb56/17kVbT2E1p8Cbq2bC38nRnhugQnlbjRZb9E3c5o4ARII4/DPef28otnc9QF5a7lLIjxhWMCOSCylHSHNtiot6uq33Q6a19jfWayxoOYBb7lEKAUXYqAyDC5bLhJe/45S9/pWSOgHVNKvslxU3UVMKW7mZZRC4uS8KyrBLFiyyyGGPfd3z48AHn86tiC5ICWFItW2o+xSsmx5KtKyO/i1ws4MDtc3MeAegRr4LKBgZabMPe8WBmTVlNLVU1kUSB2fe9XeNl1WA3wfYh/ZypBTVi9wzW/a5ICNH2+0ZYCkFTJLBiFUJkKSWDwUhpwel0UvKDkC2EmOn2kTYN5DDUrhGEVblGIFIHmUQWlQgDuaVoErIiwfzS8/5xaz/RD9s8u5bFN+SEu5+kwYWOXe1774HNf9WvB3XyNouj3TQ7qWNRt2V5SxeDY1ygzQOu7p7U9pDrevPQh6WU1k4r/pBU0XTJABSvK63eREDO3bk7d/nQH6zypX00Wx3yGbs5K7qL/dwcsp8Y/4Ny1WeBAUQ93CUyY98uWJZFXu8L1lPBgk5gCnEVUkgscjBP60qwdV0kIheEQMI1IO+My8Wwv4ptK1iW0mRCCLLWS+16JBEkEnaKoD/5BcrljO1yAXNBWiSqtqzViIf1AXuRiE0UdqSloCbg5fweb//tv8Ry+UPpp5SR/6u/wmv9AGBFDA+oLwk/+NfvELakKQIJhIILJKoN/eE3CP/kp7jsZxA0usVWkDMDNYA5QIJdRQRKqDEBy9K7+Lt3iP/hzZVd4UdcaXBt73n+x3+D5ffeA3gE0zNqDSiZcLlo1IoiBzpTSkgtcoaMwbqekJYVaVnbPsHVIoDb4crgyGEEORV24/DoF2kuv06RFkMxDumII/kU8PhjxuOPL6iv7/Hz/2kFv6TWR9afxekBXn9Kf/qC9c9fQPROCHUOW+fKYMVP855172fksmP58S+BP3lB+dkJ+Oad1bZZ4Pbc5Sc/Rv0J4wUAnzI+/sXfg8Mr1uUdHh8eUMuCy+uKvF3w7bu/w8cf/hIprXiqbxCJsPz0AfxvTkNAG/4njO1PP+BhPWFdE5Kmyt23C14+fsR+2frh1ibTnMxuMrbLwtf1W7z/43+FmCKW5YSH5RnruoKr7GnbdkEuKxgnlJ3w8d+8HUbc4prZ4dMYJX5TpoBd00It6YR1SahcsW07tvOOfRNCXdUUkbUWhJTwcDoJCTjKWLKGZewkScAOfdh+ILJPtOkYE0LQA34s5NkYQ4vuD6AdbGv2YfNhuAhyNlcO9gb/t8tMJ4xx22bzsjiQEAZ9fWx2A2jr0XB20cHisP/cy/crd8LMvdzLvdzLvdyLFRoN6CPwdy7Mlpv76HY9H6UpNC20PUs0CAGSTSmLGqVEQuxKVAhoKL6MpYV8Lc0o12o35TbnzjZmMLgULEmhRmZASQ9LTIiz07p244M0skwtCrxwkdMkzIgpIUQ58SQs9SQh8dHzPXfHRFTlmNvZfwuVT0Tt5FcpSU/ciAFCITbwZ993dR5UbPsFed8BcFOO5WQP0HJQN+PHAwECeFhrPTBmY+X/ehDEckJ7J4iQdQKMZX4wlYb7jXPmGMiZ6zLMIwoNwPPGjTRtBL76CS2ZPyHE5gyptaKSARs7wiqAvoSnziilYkmWjgdg6u1UzO7Q9D12P2hbDz7333uDgnrHgaeIGg0AMaeZzmdmD51dj6F30M1kB30UDHw8qqvh2GPFBU73MLud5CKriNYbJKcDWqQedGO01+GY0HNL/jRnnJ6Om511ABpoLuBNn8sxOiNQTzYbGiz3lVN7duKtV4swOs5IT0VK6FtpoIHXHUy2usi6CS1FWqDQ57DrB78+ZmKHRBWQE5SlZJUZJgtuzTQyi9rVe7x+nn9Sh4M7TdcYCJxSaidhmCUXs4VRZbBGwartFKlNEk/Okf6lAXQ9blfvsAaco/ejN84bDESsEtgTaa5JbhLO1oawp/mQdTWGTne92/5atCP7xxjlWSkZl8sZl8srLtsZwXK3B53LauPnYoB4dxt5Z14FY0dBAmGBhPTuYCKhkEaWmepp//w5tzH9xrF0Y+eY4vbpp2FA+cU1iE2Yf3ew7ocnYWg9TX3S7zcSa66f82WFpr/29Ll28+cz2Hj9OQ3vP0WasetGIkx/pVTQdoegDq0OJZFNvvaroV0araGPal8vFe5pLqqDfPc5p8Jc63EUPzdnfhul1oiSgX0vuFw2gBn7/hFEkFO/6I7K7jjqDi0wNcIMUUBFUecRNflxpMP8umWWPUffS3tEBvUT2J10YkQMc1B5vc5/Pj9PHGKyriUNahz2Gite3ltaJ3+q2xNt/GtPXJVnW197mYs2FqSOTw5jn5oj+1a5tZfNwKv1gT+97/tZ+JA8fO/HefwNqZ1SBwK5d8D6frP6GcGVyCL5yOdms/hUUlbaWOLT4O/s/G2fY1xvs3PT99ctR3L7ndtjr+dI99eYjiopa3pkCJPOJrcCd9kd2FNneJAbs7yc91dMrzFc69pw8Mo/we8v8xWM/sy58PT0ee8S9XIksvh//brreW7P5eFdf+1JlLYv3KA8uutwRYCkaYa5GIIoxAjMqmHUYZTsfn5v8fqBewAIRdIDpQjeAa4BoNR+Zx0saYiud/BjG1H7gftTu8yQNAzrIsTj7XzBx48fUUrG6XTC6bRCIiQsg84XSKJH2rqOQRzLli46BMK6LHh8PIE1lV8IAW/ePDcbXjdZravaoTEgLUkiuzS5RIoZAFD9vtdFDxCJsaTzUuR24CAOejA4oEWthcoZAG1/kJPrdiDpWg4OzizXz6aXt1XRbBIo3tDHxtxsJvtNJvQ6RGzbBZfLBczc0l+v64oYktO1O5FzWRbUbjRC0l7tyNWidvV0fgopNdvB9vJmKxfWSGHxSt7NpbX/yk4m9L1gtNv6NYCPqusxlqN9teEMB3LV/26srxzuENuqF5t3ltprttWOy7wX6r+Ddteb9xh1kqZHTfeQ6zqGZOup1jjUsx3IMn259RWGPr+2Ea73v7nt1/3QpfA1LvJp/a6Nn9rf0GhMBCDvG/Zdohvt+4Y9ZzxpKvoQI2LQ1E4slptEnbI9kABUbBLmBBaRO2cWB30Fas4iH2hv455iwrIUkAVn0YiC27YjhCDRvYpEmiYKyAXtsE1aAmIEXl832UVoBy47KMhae6qSSMj2mVIT4vIOxA8I9IC0rJJ2BhELAhauuKjMOFPGcnrA8/MPEF8+Ytt3MHYEqogBgnWSHBSR6Nqif9uhohAJcTlBKDi391nTI0BCUCg1InACc0TOFfteUAvAHJFCxHp6QEoL1lOSNH1JoiTFJJggheRIAmL7XOtIut7ZDgf6iH5Wq3owlz5nR32uTPtjB1WmZ6huQwmBHuEo1G3/NlKs1ckSYokuIXu0pcopWQiAkSSa2Ha+CN5uej0YcvAQIF4R6AHVReYe7UKvE0ka1o/nn+JMZzy9AYgS9v0F+34GlwIhJEmU8LzvyPsFpewgrE4nAUrekbczuFbkrUj090DY9wsury8S7X09yZ5JJC0+WOvev2B9HoKkRNz3HbUCJTNSyljSDuwnMJ5u6JlKloHqGMwIMSE8RLz/8B5ci+oCBR/ef8DLywtKYRBZ1DYhtDw8PCKtsp9TiUDo1HsKCaeTrZ/a7IrZ5rGonKYXCFFV8ERr67Ik7Htt9zL52/EznUH6cj4geYQzazcADU+7LasHO1RtCYnO18eqFCF1Lo0wI3VaTytCCDidTlf3v5ffrNwJM/dyL/dyL/dyL0MRgkByKTHk9GR13/OgRJoyNRfP8vXO7Wg5Ns1RR1Dw5xqIB7rDoLKQbErOzYEg4Uw7qG5hXgFxfkrecQkPThSwLgGcIiylEylSx0w9xL3WQSIASPqTzjgHmANCWJSIIef4A5IoglQAGIkli+lBAgyQgjk967sYVtIf6ijWPKMPT08AIOmllFlthkUICeAq+TwhkU/sZISioVCE0gGPatBMKWPM4eCLPw3ELMpzV1JNATdHdVeOZZzMyWEhSGcHyPXzumOlalSh4AxSMd66An59P73LTUBqVuwzsgAbIaJUYNvlBPayrHj3/AbraUXeM87bRcBNqgBXRGvPAUHIOp/A/SQe2Jlxx+DL7Oxp/Skv5D7MCoShEUBa/wQShzfZOMjjrA89QOgdacPfdhLzuo69e2fjR4gREhupDUEzCAmypouBfdB50Qx4LzNGh58fSw8kdtDMgatMalja/OwgdUokVAINPWwRWIxg4xtpTh5x3Emim95nHUygvrQAspMacgKMVH61czu1A4RUVXgYsEtyosooDbOT7KbzDYRcWU605NLkoOWfb2u/ldD6O7hn+Hv6589OQi+/Z7BoJpwYwC6GNSNERojS7FIKcimgSm05DIB7W/cWPQEaVaw6WWLrjts9YhrnSe/D0vreOp3I3D2hhfeeDXvp03GN9IgMfBM0NjCXdZMICp4iMGoJWBYJeVtyQeWMDx+/Q1wimAuent/i4XHV/YRBYcHbr57xP/yPAV+9fcT/+a8L/o//fTP4uM2wQowzigBcbOMZEMDIsDDLMufs9J3coadyoua0dHPBtav/ZgTn2f39NKxs957AaPfNWI7gJoNG+/W3nvm5729df/zek3HGT4/aTe57ez+3s8OcNPzmU/VTyFXSLwDoEmbsf7tWUnSNxC17Zn+erKGjrCZ+tGRbs/3IxuHYJXv0+6PyJXPmNy0MgPgZec/YLq9tHwBL5IFOvmAnH6S0CF1se4BE5hIJGhCoEyhHouMIjPYYGZ+o5y2CAzuS3rRPz/u3dwiKfO0EWS+7t21rv/MEdkmXNBJlxmgyUsece8h4SSO4DPezulndD0k3TC2Vof+8Y6LmcLD7Rk1TNN63/+5an/F92B14skpmh/HshBT9mRtILN8dRZkDmMVxKw+/Jl1aPxqRVBy/Fa+vry0KJiD7W9ZoCaHpJ/NepnrSJ9IPHRFfOths+994zVxuAtzT95ZWsTmzfBQBAiwrSK0VJWdsGyEFwp//dwkBGT/764qf/fW0Oj4hLEzGhekinvrk1i1uuZGGtnnHUvsNX137KZk/7pDcCDK+DaPcHr+fa3W015otwe1d/+Utsgy7z+zZlfqns+Qa22TONCHgCmEqtH2kO7yOWnxCiGwAACAASURBVDDVnSpOp4J1fQBzAW8ErrI2YgiIoajWIql/oDKDOVzNb/96Jj9I6hgjqzPyXlCyYAbb5awnuSPW9YTHxycAhJxl3dvvcjmOFiVRZhbEmHC5vGA9STomi5ZRSsH5fAYRYVmS2mIm46TXamVsW5aOOYmDWewXSXszHjCSw0i1FrH1/cZq8o0ZPSqVkA32XS7yRBmJuJKxbRsul4vauxLdxctXifgR22l2NcsRiFDR5WAbX2ZA7Zg4ydaUItZ1xYcPH3C5dPldSsHp9ITTaQXraXr5zg6mhGFcL5ezpKGwqGjBETwro7KcvheDS+y908MJeZfoNrL/Edb1AeYAnMd2aI/+Dc3eH4knt+Vkt3+aLYAxjeC8V1n0Xh8V+fr76zq2/ZBZDyEYUWoksALXe0J3btq6EcKXkTntAFSrK+tad/qBJ+827ErXjNk6XjfwUY3MWWvfWQSE/nzWduhe01K+q9Rx2JQ0idv8sTZbxW0N9agLbs+wfqy53V9+PhLIuuRntVtHzCa09S4VYk0FZ/2Rc8a+Z3z88EEjlkQ8Pj7g8fFRoswQUHYhvcUk0a4CCt48PSItp+akTzHh9fwKugh5KQaJkGIp6GutuGyb6LlRHMZpkRTx503wwm0HSukRGcyezQXY9wtezxfpr6C6ZJRUdN/+Z/8RH/7o5yBNyVO2ijU8IsVHMC2gmBA5IDBZ4jRJVQ8gcwXqBYSPeDoR1viAXN5iTwE5Q8lsgpbJeuZGKH58XEGBUT4uarvrHNZxsb/P//znSD+4oFbClgvOW8W2FOwvJyzLEx4f3uHNmxWBhKiX4orT6QE9JVMFkQg70UMjGGFIc5QSgQzLbTp5n4u1miz2cpJhacXaZy4y929e4id1wqvChLAQ/uC/L1otQmHGXjMQK0rd8PJXC85/dXK9DFz2gvzxguXCWOKKx/VJUvTlgrxnIaDWbpWK3EyC89QF+c0F25//JULccPrJn4G//bqljbbDF/assC/44b//b1FRsfz1ij0lLPn38HXe8bZUnH/499h/7xcyBsz48O2v8Pr8Afm/BPZtx7IuklbstAF1RyQgKVZec0XZs0QSStSiwxWWf2BWuFW1GTJMtB9CFeIKI4UIZiGa5FyQ8yu+Of8KIf4KT//0DR7XZ+T/8EfgPQ7jTNMLrkLczXnBtr3iH/7hRZ7FFSFEIX7ERXwYEH9EqQVV0xGd1hPWRWhspWqU4pLBpUp2QiakuGBJyUWh94ciCCEK4bZWQs47Pn78iHVNWE9y3+4LALhFgbZikcp81DJrIGOOoi2qQkctRnxe6xMIXs6LwLU0ddyCVZptxxD8HhD7fVkS9pyxbxnny+XL18e9fLLcCTP3ci/3ci/3ci9aem7WoA7YblQC3YDujtERWJ8dsD5Unr8H6akgH61Bkwn3azR1kSlXMUZECtgdMO/BBA9kGIM6hIgYggI/hBgViAJJfmwNkdqRKEspos/lDm9KSMSKvRSUwlggrH1CUMd4B/ut7fte1OAKCCFJi1hD9Lq+q6r8VTUWiYqeYB2BlwFE5R4lRrACic7TmOAdI2/Xs/WxKewO6Lc6ewcBa/uFeR4a4an91gye5pywkMMWeWOcXzO46YvdL/A1KNVwGwVH/Dy0y/qpvtGR1DtuBFgQBFyrlVEUtAlqCNei7PwsRKUUowKUGOo1tM1XlrlPKQVpbh2SvnUCHHQN0lUAgfl6jIbxVGiWxn9zvQcixgAyfUlRA9MAoqlx5qyrRCBzSpKeGIIYXR50sj6IMerpy56uwYbQh+O0k+4Wnco+d62T+yX0sW1Eo7EdHdDvpBkGhMDHul5hjkjtM3kE7LSF9GGXIyQIozoIZb1UXfct7DokoBVz7RPc9Z9/Pa4HVnBS5KnI2NRARwNt5zLL5k8Bv22dgsYQ8vL4wSnjT8/Lb0fHhskBtqgNrnpELvKOcxYAnfjU1utURncPN6DVDHCRnx0w7v2qp6qmEzG97WNfedn2ySViEYp0bAkQchszUAnsZJI4Li44n1+wrIvkj44LUhKgJEJOt6X0Df7kx2/xs79NANTp7f7PkFDKFxLSDBioCkdV1EaYIfgT40aUkflrn8/UlU85GefRcFvKzXJEjRmh7c+VTj88epZ8++Uy7Mg5eFTLXkf/ze2oYTNZZiYiWU+353unryezTmCoET1mGJ9dy8d/c1omu2YcrWvqSz8JZ8+4NUbfB/L9vnDxp8q3374iPF4kvYPqZeuakDML6Oa6tstAkxOdZEek64P8/gz32mScd2p1GXSrHEU5mff00ekln+37PjlUx6hqDLQQ+0eEm/EZOhcOdI1P1Uue1Yman7IBBrnbnHedeD8/g1nyzg+EaQWrb9kh/hnX9dQ0mtRJ9/4an3qk7etNp+2pRXo7ZVxrNefgHEmi61r2HIvwYKQj+25ZTrhcLth3IeOntMDvVXNfygb3afl2RCCw/XqeW0e/u3U/X8a5daC3cG0ypbJE7mEivPv9gBQrvv05N6Jm+91kqxy2rf3fjRLxlZw8/s3t72/tezy9Pyom6Yd54/55AgtPr4/uA3fNWMcu59He+2v44FnjPRhwUW5Goou1we9UrR+IUZqdHsAktIlh/KY6H0k/IkYIO0KQQyGBFsSwIIQVkSJCkIgJNWjEUq4Axd67B/LlU0XmaABYiFuyXhXjSAmoFeu64nLZ2nc233uECz10M0XPSjHiXCty3pWgsgOobY2bnUFqKAQXmbBqyiEvt0vRaChRaM1dvkmdSkv35tvWZ6pgCBVUAzgYhjHKQnttMk0i7Jzk0JEegrHDRjnvzvaZB3W8HwBJMRESVo0yaRF0Sq3gbdP6xna/lDSyTIzYdy9nk/a7uNyNXFiKkH1CDFhOpxa1ps0/7n3u2zzaOJ3U4eeIL3O7QKREc9/X7errOQe/Xq/Hyt/fbORu+1/dbqiXb4vNzVIKwD2dUbOXh/kx7pNzW+f7t31RbXbBZar0w6SXeOzIr88ZJ7I627UUnM4yRFTyhJ+OERzV/9YY2O97nx5E753aL1GdzK6/ZfnogmZLGz9e16JRMGCxoMb5JhhipR0l76hlb2mbDCddlqX1AXPFup5AJBFqtn3HmzdvlGC7t3rK4R89aFIkom5MJ0mZuMihPsaOnKuI1JAQELtdrWOYdb1WlpAVklZJ7NCcgXI6I8aCQFFIdCUg7Obc37E0e1Ltb0g64MByUCdFYF0qChGACOYEjisIAVniwQi5mVhT9Ml8SCkiRBY2roymRpmZyJqPZ+DtK7hG8FaxPq9gfIWAiGV5wNPTWyyLyLtACTEmpJRkL6xKlglF9T57AqZ1ZOt1JHr3+QH02K1fOl9/09Kt+i8pDAICsPy+HHTU5S1RjqNgUfnnhNxihcn3lz1j//ABC0Wc1gcs71aAgP2yY7toFCXbb9o6ZsgYByBuiL+/oeIjyt/uIJI0dR4yNJkZOWB9/4P2eQGDcMJCjAQGf/WCGr6RrmbGfnlFDhfw18C+ZRQ7pFQZvOmaXuRBpUi0+Bh6uOzKEq2tWEq4pmmp/uawYZmPoa21kgsyZ+Qsz9n3DUQXhNMFIW0g/AhoPozeygCTkXI4KwRGjEJW2bYdj48PWFeJmBNSQlpPSGlRPSNg0T4Wkr2OK0gPMkSsDw/Iu6Ry6gcdCLVFZTMs1GOqASnJ/nw+Z+QCLJwa4Z+IND0lo5brfcX2Hb8XyPpQJILMbupY8ChmvVw2vae/ts+BHu1e9iVqhyxtP9n3rPbe7xJh+E+v3Akz93Iv93Iv93IvWggd4AVEIfIg0BEAD3RFyV8z5zC2z0i1IWNse8d5O/3bde+m+AihISKWgqzXG8DTojg0oGjwiKgVy+25Bvp0wo4SaDxKyhU1Z2E2q7KYK6MwQDEBlotYTx23U3EOTCaIEmugWSA9waUnT0RpzZqz2aLiGECgjn7qgA3DKaNm0JLYkj4Usnf4aM/DIFxT4L2y69OqmIPAAAUJ1Vjb2HQnTj/v3vpwAKhUuXVAyxHoMQKhNCjSbX6ZWdAU6RHIF8BQxvcQHMK1M9Wc51UjFIUYwSDJx6sn8XLJiDFiSQlcWU8SmjHgnuHXAUYQfpxnvV1HoN7cF8aaCmOngAGdF2gO+rYGcRscmh1nHli6Ar0PcOnWrbaWqswLAZlrA159SG4zDhsIBosi0sG3Od+sjfHsADJQ1ADSo7Z4sNkbbBSMHtAdZXKFAYMqf7jLh7k/zNDUWrpx0ztxn1dgcumgdLyYQBqFydYxDx3rn9eBwiFNhHjA1IlnwKRZlSPBxdfvyK/U2sjiGJlB1vEeCnyynfPioY4dBEbrYwMZboXp9vXo7UT7ewTKjo6COtRtvuZTMqceRYly7Z7rJYCQEcxaFa5kntwDMCkgcy+MAJGeSpYQ9WekuACUsJ4YS1pBgZAr4VcfXnG+VFSODVRqz9D/MzEyV1xgpzOBqECN7XakoKVKaXV2eSfZl1NNZsnqa4OrWl6X6zb01zy9Ovolu9dzDWY5f8uZSod/6RN1o+EzdnXkG9d1DWCQ/O47XC1KYhnPo3rTwXNv9VSvg8oeXa+sr43S1TBz6nPF/9bvCb7et0dn/u5TNfztluVU8PT1hm0reLm8R8QGSZFZkDOQ7JTxND/9epfTonNo6SD942Ww+zvvtbYXyuvjtnuyhpWZHOP3NZNjXi/zMrdfN97DvjN93re37UHqHPPEx3kv7RFRipwAnsDIOUreYVsgcs+cnUaKNb2xEb+HtgkNwCI/Xrf3eL/yfRsCHfaZT10F2P5cm5PW38fr1fY7izzXbY6+Z/sIjXa6XkK4++g11E6gm87t58dh+cLlNDuC/TjMr4++P/7c+vz2c8z51LZ5FrNIiMFmx/STqNYcBqMSEHQ+fGoHGd0POJSXn9uVGNfyysvptrd+trPp6r7+n1lb/j7jfnE9nLPcPar//B3feG8ETNa0eq2vpzph2Dev+99SKmhSCqEz3NinmG5N0YpAO1LMCGHFQ00AVsiZBI3SGhKIhOpbXFQrYNSH/WejbdlHMZh8YEINFSFGLETiMNOoL6VI1AVZh64t+gixqZNEabA1rs9Y9GS3xx9KKc2GBkbsgmH6vpKioxzWsWuabHK6s/xYHfFBnM88TwbTkSujUkXgkXhussr2AYssk1JqdTU5Jbb+rtFxGUO65WxzUzUtdvYbSdTgbgNYdLaKbduwrmvrK0v/J4cjSjvcZHuX2FAFpr2YnBRnuspGNmef4CMhSJQgWB9WlkiOumdL5MZR3n5uPo1zr9t43nbrNiY3O440SmbT027YsW2qDTjAgUyd9j2zL9lOaaHbnM3OvXEP38ZZqlzjEU46MeNKJl3dr+8Vc3rIYa+dhF6PVNbHRH7fx8S3ccQyfB1krnvs0n4nkT/G+s7Yi9Xt5t5rdRjmqpHVGEnrjWrktYlERAFhIV3zFfsmTm1LS7UsS1uXzU6mgBAu2DVlSkyE8/kjSi1IMQq5IVju0ArWaL+nh0cgGI4rBweJGBQlYgwzsO9Z5ivJoSJZcxUpJtkrmnEQkYukiwFrxDGNOLXvBbVuCIlAKLj8wS8RMkGSAReUCtAvfgiqQPnwiNeffo29ZKSvz7KThIBIye2ZGq2YAK4FoAKKDAoMkJH/u13D6wX07ltUjrhwRjkHgBYwIk7rW8S0SpqqlHA6rYhhUUymH5Q0mctgd2ZT5RCcLU9dZwY8Bti/w5Sx2S6hYU+cZQsDt6fcTb3M5d/94sLQvQ+qjxEEY0RWShwhwSlvEPz/9XxBBiHvBU/rM07xhG3fcD6flWwmDSdIlPZSK0JlIV6FhCU+oVQGEGHx1YnMPrcep0Y1kqd3m9T+hdcnrL/6PYAKyrv3qCEj6IGxZUkSEb5WIaaZDYa+5i31oclzhqzdsY+7pSt1NjmiBFwElFyROaMUsVkEO5domDlnfMzvsTz/HVCUxBii4DoqpwiM8MsfINQic7jta7I3P5xOkvbW0rZCyHYhqC3GEBJwLqjR0gxGpJjw8LAiB9mPLSWTpUGc5Z29t2hOQddGKVUJQGj7edQoN1VtxKOIn0d7wWx7AZ+etkc2tlWZqGPezR7RSKmscrfUikB0hSnfy/crd8LMvdzLvdzLvdxLKwqAhCiKh52aMGPQXQdgUGS8sQtgCLlqyo+BwkZuECPfIr2wgk4VwjGhSckLKOgnUE0Z2/YNtYrSZ8VSCJGC4CkuSFHC/fr8nQQGV7lnLVWNEFKjt2DPZ+xZosQQJYS44LQkLMvaFG4iiBnHGeDU6m1koIeHRyHDcAWhIsaEjc8NaLtcLuCcxQgNASFEgAilZKS0OLDGipiNFHreTgPfpL874NGAKASAhOwjVsycdqkbDB7s8OPWnRqq9AagJ4kQo1xO2nUGeK0VKYZWp/lkki8xat5g4qt5JdNlTA9j10hYxjpcb8XY6B3w94AUASQnJkO0sMiibDeQEQqQsgTmZPKhk70JrPcsFUwW7lMB86o57knC51o9rR0exLP+N+c8618CMBvNcjKitpC65oiKQwjja7DsMMRz7afuzPA9dFsMQFM/hRZ0TPc9D6CxGNICFklTdC7KzbTd184o6xPrj/7XTjQFBYH0ng7o6u1jMWxrlhMbRj5jUgLYRBiyflIcoqey8iCrzfcRcGvfg9QAlxoEnUEClhsIQwDFPs8bJnmNmvhxG8kjASmdGrBda0d3QogKHnL7a6nOQCNg6OfHlSNZ613d3DBQ2Pf1DOgIGNMBUpPpBpZ3kqRvn8gIf1IEQDuZ2+vLOo4yT2u9PnVr8iKEcU61yQ0GOJgfYujjue9n450MMLXTbtWcogLQREsBaE9TvCWQJZSochIoBWx5w8srCeATEyiuCCFJyGhEEBIoPuKb7y748FHlHvhwZTLkNFaGpI0LTO3aqGMZ2GZi/7V3AX2u8MEr/60//d7veBsJPH7qLUDF3/v6Luyumkkzx88e70rT5/7T8TP/nONndLiNhtftO/5M7W6QZfq97fd+RHj4mWK38o9132r16bSb43r0MZhHT9J+YXi+v+bzo/67K6e3O/7on/8C33274XJh1JqEFEeMPUuYatJ9oyqSfaUDmU7A0hpxvqHLPAVbe3j/Ue7Y/tRkyYRpH+3DRwChycEeKVGuXZalgaB+vzDnJyMMkdgEDO0pl65I7CSzwTtVZ9KHPxlu++McNdKeNxfvPAN6ZJZlWa5ChEtbrwk/5qgbyeC3i9+PZ33TA71zWo5KAsTueVfbxenFhEE3sXbHGBFTaP3hx8U/r9Y6pMWqteJ8PreIQcuyDu2e5wugMoSu+/mWQ6Xdb76Pe86hI+bgvkaUaZKn9XHvlyATA3aA19J81sLIxMiRu1P9QHqaKkROMl3L3muCCgFXpBkavu3XHhVy/+Znfup3/bczwYXB1NMhWkJPu/5497z9pCNZzbh9L1eLfldHiGSgvabpeq9beFlufWw8ObHGhTSDq/scFyJGigUx7VgCI6YIUMT79xcwG/l7QSQgh4pcskY5mHb8gzk72E8Um85oymGMSXSwWsEarYUAvL5cYA5Rcao3oa4yS5zO67I0PbPUAs5ASp1UIrKtDrLaIseYzWk2BsWAlMYoBZ0sZyQVsTtAQKKIGAjrsqCUjD2L/SO+Rm5OJKgTt3qZVjtB0eTu6XRqDjCTZUbYizEgZ0JKS2ub388oBIRmU/SU25Eiai54eXkBkZCJ0pIQOLTfy4n40GwAkYk7iIAYJWVdVpJL1pTbDw8PCDGA8679KCnsYjrBopOkJP2Tc1bdpuv7ZqsbYcH29E/JvePvZLX5yGc274JFAq4VTIxIyYZyuM7vo37vl1Q63a6bn2HjaHOE1IYlMoyttjkj6Yt81DcMWIyNsyenAt4O7nMnxqAYIOl8VPng9mDb233UHq9PlVIGfcW3m0hwuhiDWzvjHkg0yfv2XAJRVH1MtF2iog5st39QJ970e1if2vw2297GXwavY0eiuzSbftD3rE4VRKkdqGG37ze9i4JETWXDDPUwmkZjilFsxxQljVkIAa/nCyhGwfpiwPv3GZfLRZ+9AIWx5037UNqPSljziphEvsQgqZmISCJaKCZjm0HhCqpo9ncIat+yEN5KrgAF1MyoyDr3IlJkIGdUrogg0FLwi3/2f4NoA/OGQDuWsoD+178AXSI+/Mc3+NX/+wQ+7fjhv/wJwgmgJLIjJALtBMpAZSUgUsWyRCBUFH2upZo1Wya8eQH9s/8HtT6BsYL5CcvyhGV5xLo8g0JESqH96/qlpgSyaHimu9uOHqLa0C5qcJuIdSCMy/qSFzIvLEKQ6TIdU+qF2n3b42+UGSsd5NOvk5IJAAyHA4HJMOEMhkQ7qSUhGqGG+vNrLShMqPkiKQdXkbd53xWLSqBAkhZIRUHlnma0IiHGJ1QjjkJj41DXUwiMqukeTVspYBTqaXzSN18jffMDYNnw3X/xb4BTVYzU0tIJYc0i+4rua8Mr41OZEaqkZZIv5KBrcHaSRGKSQ7R2MA2QvVjImQUWvdL6aF1PoADUuiPnC/Y/+HdgLqhcscQV6flrUFCC7E//GPH/+jHWNYO//veIBCwhgENAYCHHNJlUM3JhVI3yXjRSTDQ7jQKSpigUWVw1TaOlAY94fT1r6viuc1jEOo+/AqS22a62CTWCbYwJwR3Os371+4vcu8vUvtePGFtoKc10X6XQDkVYf4LRIpExo+d7ddq2YJoaZYYYgX2U/I6338v3L3fCzL3cy73cy73ci5a3b99iXU7Y9x3ruiLnjBgSwP3ULHAA2qJ2FrIDWWcWcgebJQxhikHD/+pdqjpod1EWfdSUnDO2UsAtqowoaTEFJbBIBBABhoRx3pztMYBraczzEAJCSghBALCaJa+rgEgS1q/WLCBfSMhVjLSKgCUtSOtJDIZawPmMJSaNNKPO0mY8BTBZNJqKQIxcz4gpgveMXHYw74gpwcK8EknUGQE5e8SFWgFGz+kcg57VNIY/1OhlOQFikT8IQkpiMEIMCKY4g3E+nwdHCjNj27bBySwRVkRRLgNz305/SWhqU5x9iGFPAvGG30xs6RPLIrEIkORTenVwb0y3VGuV+RevT24JucGUZvltB5GkFQgRTKQGFjXjbF1XCQcbJD9u3jeYm/SIlFIrIwYZj57OR68ngKKSodAB3mVZhjrPJI6ioWGPiq03I6cIwUchb+cguiYR1YN+6o4h/VT+a2CS1cncAPJfTGIQbXtFjAue3zw459tYX4YBENLvQgaTi2S9dQeaELR6P3WQz0DFXqe5LX2OqWlVrd2luQnmHORm+HWg7Xh+GoBWuaCW7mQMISj2wQJYhtSut3aAzUnkow3xlYdmBkuvHH0sebYDASWb80lALCMVGVrbgUAaCDPXfTWm/+j9SvBJvMPUL4f9pHJnXZbmEHx8XAEAHz58UGC+n2wFG7Gnk1qI0ELlix/OQOba9oU+Hgvc0EG9JdpW+RcVI7R0WAAQQ7yaO0f9Mo8HoYJL/z4FAkJqfW6REwjm5A3IyJBUFTJ2QEUuG7aPZ+x503m0gpBAlBBDQoyPCMtX+NnPP+JX3wQwFgWadA5Dgz8bsqUELHmKJWaS/1JzIYojrzTY6tctfPiO2rt5zRDo6jk0vPqUI9MgR3L/0F4f32cA2M2hd+VMpYN7zteMdbkmlHUH73UbaPgdaR1o+Na/6s7NT/XJ/KuhrQdXGWnGkhx0aSHzqEw1+JIZ4fvs6Pre8l+vTd+3bJeCf/iHM4gSKEQAO4gzUiBQXUDsSWcKyk9jKmTDvg8KhigxFZyHaZIVM3jY/8F+f+BkmQl5s9zxzhagk5a9w82ubUAveDhZ53UkI3t4PZ2IEKIA3keEEumTMOj+AGlkOU+GQdOrvUz1+pu999uF7e32+5LV6QMj7UiHmhN4foYnsMz9OY5rT2PldVjf11vZW8S8l9cP8jsFXWvNco+gLhSXkmHWle2zy+WCnHNLuWB93OpegNP62PboFtiIwzQrfc8ff+Pnzdx+HjfHLy7He6Ptv7HZCkQ7UpKT8etJnbjaPdJ/AtrXKifSS5X9T9LDjjsHkxCLYTrNQZvHPeCg3r5f3P+9ZJqvPyaI2z77+Z2S1G4wi0P+drIMTzWZn3Lrs3m/u5b7zpGm/z+qrSfLVHBLzUTs6evHe6iX3dUdZgDM7XjclrkeKQLPTxVbfo9cNgjZ4R1SYnDNyFk0G+XWIYQE4tDXBcY5CWBYT1ZbkYVmf5j+0cmSjCQYg+q15uz3p6wv2xlE0Mgo6mgOUQ8EvCLGiNeXbxCCjPK+Z+z5olFKTR/vdgoR1H63FHHjLJ0jWUFTQguppGBJcq89Z7l7ICX/Q0jbxKik+1oe+yXGiG3b8OHDB+z7jtPphHVdD21xoqBtBs7n11GO6G5pctSILbVWiTCjv7VoWkICkPa8vr7i+fkRRhAxu/e0rsilKlkpNVLPuq4opWDbNoSQO65ERuyxaDayZ1S1y8q+CW6jJBIhKdq+UJHiit91Yda0Nq5vDfuadYD+/kh3nu876hGSNp2Q84a8a0QekggPxP5AgtzXk1XEEcrtc9ujut5R1HGsJCEAJVds+4bTw2nY8/3e2/SQA32m6RvWZh0zq5McspjbKfuvRKXthCL5TYE4pPvhNCO2+cN6ErnKCM7u0IncRTE2sdnGucVtbMZDTX28mv4SLNJzENyRgA/vv4VFvBEdqKLU0tZ4Whes4dT6J4SAbduw5wxkPeyh9poRja1fhGgU9f4Ltu2CEAKenp7x/PwG3333LUJYsS4r1nXFsi4gZtQihwuXZcHb5weAgG2TqIw5VzkvqNGAawkacUWd1xRg6ekAUoIOAyWg7gH5DLxiFx0pJDw+POH54QfYfapoBsCEfVsQAvC4BDw+ncRG1pQ0pWRQYIhvvuL9h18BKFjph0rY7wcGAj1gWf8YT08/xBIfEeIK0vTUQmASUqcQOz0m1XGsYddigqXQDkSOPwkKVQAAIABJREFUNGJ2PSsWgWZvd6xF71x3NPCBDb8xvMH1xfD3toYxE+t/82KIgaGY6PUkIbiAa0/hq8SZvO94efkIyozT+oBaJGJi3jMoCFnjtK6gELCXHSBgiYSalcTMAMqKUiSdkbW3yqpuI0AQ/YK4E40rdbxCatvxhIqK0+lB1iuEFLtA9pd9yyBY9Ookv2IAS8KKRdYzBKSJSrqwPraDZjEuWBbZ85dlxZs3b/D27VvEGDWV6t7Ssop831G5KmGc8d1332Dfd0SIXLgoOTcEwlqU8sVAzRvCWvH4sGBJEUsK4JpRGFgC4WFdsKQVzCu++eZb5CwHElNMWNYF++UM3oUUF1PCd+/PKLUgaoSplBLevn3bZGfOGS8vL9rG5Gw40n0gACgodcf5/IqPHz+iVkkPl9KKkkU+vHnzBusq8st0AQCNJFmbHAdiC8JvB5aBmGS/yTmDAxCD2EeSZtDrQgB0Lc77S/OxsNi9yyLprCyqneky9/L9y50wcy/3ci/3ci/3MhUD1S+Xy0B6mUsHfqi9PwLzgdnJoEZ2HR34FpnAn2AxwzDnDKgjvpkZDUg3o0iKgV8NDNeQhB0oTyhlx7Y59j4Dl8tFvo0Jy7Kg5gwgACwRXWJMQm6JEVQrOGcw68lYNc7QAGpRxM1gI3VRlaxhIy3cMYmSSQw4Doaa5VWNNUILq83QZ1mA0n5yytrRDHu1RNh9xpWx10468s4HK9dAx+iA6eNrYx4RY58DxjaXvOWHU+dGkVbPJyoCERA8Gcfmy3VbRye+XlcVICabaz52amfd20dGSmJm7FvGfrHQoxYtZXR8jVEsfP84MFIjB81OryOCBIAhuowZDQLEjtdWYUcJeKKEHPB4os0TIgYQdHYwta9urHcP6um8kuAmJKeLYwKogqI+36duILmuVpaTGwEtRLhf875+3iF3RAA6ki0DoWPqJ386rN9jBPdvwZZdbo3rg11fC1SupBXtn0ZNsLrCn5LoAMB8z6s1YI5H/TjqqQp73+fU1ALGMGeOip+P89oZhnxYW71f5t8ZGBAoCplRT9hzBShG+NzbFnlnfK6AerXGBmjOc1IuD+1E8dzo3lUGbjapPAGivW1+vcxjILcancndaWx39vLPAcYI6GRAcQoFktN923bBy8tHPDxeEDXKDCqhpIQEIKUF//g/vyDQBf/uL984id/7moAGcKk7EkBFQGg55a0vzIHH7rPQ7nIM4c3uvlk6eLjfO93kybcn35GUGX/To6FA2xbd82bYkfy/iSQjUp/8Ch3k2XwvTP1xuxV0+M56NAxEGTr4hXzC+v+jPjl2Zt6611iXACAyhigzvucNlDyAjz95Xz9GR4WHa3+35c2P3uP5R99iRwQ4oNQMRkEgc14CXJSESUoT0vR7bYmz6WuqJzHQooCpXuGVGS8/rp22QlPidv9RRno56mWF1yfGaHrcyC7zfexvVaB5Jq20WrnPPDlxCfEqjZ/fa+d7XEWpce2Z9+b+e01TgJHsaHqrl8ctygNUjvq9mehKT/W6l93jKC2Db9t1n3S9OlFqEQ48mOz3B39Pr1PNeohdexTN0XRnuX6sz2/qHLkmEPzm5Vovlb/R6dgWGcHmZiPzBokeIsQ1cZSUDFAkJQ7onoxRjgNebvRr7JNZzuOKhHgkE68pm19aTM651XFzX2z7apOnOJSpXmp+rl5+Xz36lt118/0BOMKOSw91kCZufobfP1tap4Pr2PXOfNeun8hzX3/xDj/5X/4bTc8VACTEtxXpT9+jZEl9JGufIRFnNOLrtP6B67U32zXy3n5r+p/+tlSNJmuyMgiplLs9Kb83uULYtg2n0wNa9CRI6t4QLbpMaa297iivy+geox+bNkLuMnNQd1llpEyS1ClGuInjaXywEhyoyxkfCcwOoMxOpOM9rPfvTJj0+8Ms50opGs2zy+7T6YTn52cAtRFp7H4SYSY0An0MIw7RyQZie1mKxdjG2M8FiRhRlZBXNX2yr+fvvOgcMqLKka16VOb5e/T9vJ9IigwfOVPvU51mr7qHf7bI6+v0h0acqUoarRrZAO46b+96u/14z++/u2pHsBRM2mmurn3e+/THY109LmXSh7moreuILPCknv4sqwuIQLWTh47IPr4Nth7M0WzzvJaC6LDKbduH9soBtYjIKlsJABlOQD1SQoxYQ8TT0xNyKbhsF8E8o8ynEES36W2zqL4mp3Ywf8TLy4YQEtb1hHVdkCzSAxeN7lCxrnp4q+4IVLEkQq2mlwRUVI0IIv0Wg0/1Rv1gXtONgJwDUAGOAbWcUMMC/q9/CdoylpqxBGB9XLC8e4O4CJa65x3blptsWNcFp5PgSGkJOF8+4nx+xfb0HukvfoLLZVNSTEJ6iHh4/AoPD28Rg9jOoqdL1zY4jBgg1r1Mvwcf7IVudya4+WmRvNyuzhp1hry4Z1DUCOpesxne22eftp/muXdVbqR7/Xzp9SCuvUaVYfB1WTK++Rd/jRx3vNSPkh4xM5Zk5DJZHzFKGiBmaJocIZ1Vi2jMAFc5aFo5oP74V8A/+lbmmB5WZa6gIJhIJmDLZzBXhJ//CPR3Pxp0nEZGBQNKIA0xIS0LcpV9vZQqeo/NgxBQq0WUIsHxIZHFOUiEmnVZsK4PiCFg2zP2TQ7xllKQa8Xz6YSvvv4aT8/PgOq8PbowmnwJZH4HYF2eEUMBiFFzxvnlIwA9/JUzVhAoL6C/+jMgAPXdT1G//jtnMwKECuLaDvtGALkW7JeMTIS876hFDndiSeDSD7V67NXWraRcLIMeNWL9un9BDjQ+PVEj3AaNYmMDIgdlcycA6sFNs+98pFNfjzDtFxIFpx+KvpqtKqe5rUlyZw6VSGMHq/Ug8J4zlnWxBXwvv4VyJ8zcy73cy73cy71o8YYm0I3NI0PYG78xpmZ0H0UTGd9D800WBX8AMyL88wAz7ns0GQIQ9eRWM9ZhIFuvvycHCKs5TwZwUTKQM/IZLSLCuq5YlwXnUsEa2YUoar7U2IBiRlUj3U5EqD5J6i5T61hY0HKqLRflyysYJhFMJFSqhcMEJuAMZmR7oGCEms1obX3sQLdGeGGS/PAlt9MuMyHhqByRGfxzewQIieSRc1FlODUQw37/aWdAh5F93ewZHqS3a4giKhMYY93NsLe+lO4bnUnMEnXHjBSrWQjSv7VI2NFqJ4Pa6ZruoLE5CvQTxkdOGQ8yzuSVI1CNiPS4JRlyj15DBcFZyCdmGLQ893SdLuea2DD0lq4le5y7hicHBxEsJw4r8CN2aZReJgWBycD27gKR51wT8GaSwgiK3SAv4Hg+zv3eQ1kHrdehe6AZjLdAPyI5JdoAFB2XBiAbKGJ4DfchG0gD5N9zq8FRe66dACwnn0DNYAf3SCZzqzqa050HX+6M42HtWh1uXm3zSx1U1h8EwrYXXC5idEvIcIvY0EFTW6+yTriFiK9VcqEXBcAPx4/da6u7ORH0e7bTTvDO7HF9eFDYOwb63f18xvC7o/7xe57GA2t9EiMhV4Brwfl8xuVyRownABGlAKf1AW9OK0AZD0+vePPOp8aSdtm67LFk+ndGmkGjzPRzdUaSaD2mQJk/Md5EzjzOB58dX/F9HZVH73u7+2zr19gnX0qWoeEO433m9/N10PocX6vP5PFZt55hcCpjnMEADh2c87MGPcD98+4UYj01qX1oUYb6vEDr1e9bPneXW3PrNy0UN9ByAeVVwsiXAgoFFNxcZBJdLvT91Pb90XV/MFJt75X9C+jy2F4D8x7b9TErXm+x97N89Wl9/F7kSXpH+oLoiXx13yN530km4qTBgYy/pZ8QUSMT+/t7u2Gum1wnj+npPSXyoZ0q7/3Sw3D7dJte1/LPPnLYdUfVeBLe9/04JtT6IAQf1tv6sKLW2Y65lgfznuFtkdnh+alw+t/HuXtFIPitgcYmncY5Z3/NcVhqAcgIvgBXidLfxq86eeeizABocvu2DMaNSF39nZe3o7Z8VD7fN0d70a3C7R+71xhSRvl73ZLt7Vk3+oMPXl/L7k5W8c87bsv3nyPXMt3qLn/LtuDl778a6rzSK04xo5aAEC1ykVKCueu4R+vuyIZw2rJM+6aDWrF52lMlCdELzREGqNOvmowSR87pBHWiSfrlnAsSWPeYa1KCtX94PdWmR0u97s95bbVdKsQmfysXqWMU3ZIw2k/zPSwizEyGHPeU8bP2/GYfj89o9+fraKCBxPkfQsDHjx9gjrXX11cAYk+lJIdTcslyMAYYZLdPS1iZsW0XrOvTFU5SSmmRz1jfW0Qxqct1H/+uypF+c7Rnf/H9pv3D+sMOXxmG1teEkazk9S37WtaJ3NPSdclBqoJtD+33PbpGT80tpJsxDZlv3629ctxXZW8dUzop3gjoGu2d2esOV/8AZoIEjeKmhxipyEegAzC8tvb7KHj+OT6qX++7ah3bCwNB7dXL+YJtu0y6iKQRrqH/LtihN9cXRAExRSzrCuw7tn1XfUuimkjUiCg4FDPEViw4nRbEEEAhamqdAq7ADkLNO0rZwWDVbQLKvqJWiQqdd4kKYsQ4iyRDEMIJDcSl8SBIIFZSuqQ5pVpVChFKJmw7oz5fEN9ItIwYA9IakJYTQozIWSLxnc9n1CqO/2VZEWPEni8ohcEcUCoj4wJ89YKyFZzWhBQDUlywnp4R46LYgs0tBpGQgxjcUy+5ATNZ5lYZrq0weNVQbKqqNFTJFyg4F9sakQgj8l7G19LMw2NhTefxzzwuR1ji9yvezlEyuFdWAFBg7O++xRYvyC8F9aUClTWqsq5BKKE8xiGdDhEpWcP2POmLWgn1cQc9Qcg0QZRD0j2UAgv5oUikG37vo1kPPQIGsKwJhXbp35hkTy4bij6bNDKWEWGFP0KIaRE7OFRUSCT3tCTEuMg61tS9JRcUxaFOpxOWdZU9dM/YLhYNqYAhKZAMW+IquGiKKyzSmUWJAiyKvlrmTKCPb0EgpDffAusCgJCzyBguGfvlFRsD277jct5wPl+EmLqckNOO0/qIJSWkIFgZ3D7siTJAj/5yJI/7HqGykDAdPCDB7pIeQtZI9MuyNGKrf6al4pv1kDTZZ3NUrzGaF3QTUHFnnwedszrHJOJObDpCqUXH5LeJMvynXe6EmXu5l3u5l3u5l1b8CQZhGYuy1RXg0WgXpWc9LY0dPAP83kgfHIhsLp3RGDVDdS5iEKmh2T4LLirLCAx0ok1pTg4Dr0qpKGWXk5BqPIQQmnHU9EkF7Xs4UlHsciktTLy5nALktLb1o1hSYgQbscaMjZYnuIjxz5Whx6bQYClmoBYwRYHKNIoNnMvPjC1PlvGwXINPvALKZsR0gpONV22A09iXcoKOxvFr/Yk2N5gZORcFq2Kr16ecN3MxQMQY6w0IZT+XxpCNgclnjmmF6Ehn7gNsPTUbzzautY453onklJ8ZP+YEslMF0pcGVo3gVeFyjbPwdYoFX/lAoTm2bcz6192g8OQYAZuOSSafcvZ0E/6aMDI/M2iIDAaBovuOIUCBzdN2StR6QuZxPyKgjn4jdMFSDkE/k2ts3fr22eekfdDbMJJfgs6Rtm6cHeVtsn4itcu34/lq92Nd3+6Uq80lnRi3fm8gC5EZfg5scMal7/cmT/W7OhuWmNZ5EwA0tsWt3RkkvLrHAO9fl/n5/QsjzEhu7H2XHOQCbCW9pFM+hoo15EbWqeSj9melHbLT6u0BAAzvweZ8RZsTMneuI2r5fmlOQEeYkf1H+6U9gt295jYANk+rtsHmZFoiKhg5i4G/7xn7voEoAhwRworw/IDKWXK3h74njj0xynsGmiPSSDPmOqtgF1HEaqdrun3WyTd+RfRnHZcZepTxnR2X/vtPF1vLR3CZuY8I09jr+rbf938jWabTTT89v4f7DvXye8cQ4BpAJx4pdfDqt0dt9ff7fH0GSfWJK3r7u9T1bbeR6v166443JOEX1Pb6N7/pbwHg6d2Gh3cbahFgsRQgrBtKIYloofnniRgM2XMDJwUCqctmL0Mwttlt3eP7qca3AexjueidNv79LOvnKDFeHh0RU9oJarqtY92ScUUJ3B7EvFUf72TzusTcVq/TmL7m11DRtKqWtsT98qq+rPtjd9SNKZVMh/U6pjlLTcf17fL2yUAQJ+hewU2f63uA6Oxex2pSznW3v6fXlUyXbc7bEFDLbw/M/aQeME/uX/Oeg6PW6S5df6A2LjlnxF3SPoQoId8pSJj9UitCZTy+BX70Y0bNO7772QLOff/CUNVxXhAgpL/h22ne+WsxSsFbcvVLusfXye+c/h798/mvXql7Ml19e/zeWyifKzf3DI1K2us46QuOyOOfy1rf+bu5zP08y/RxTA/GgIAQCkD+ZHFo/xh50FN9VIemZx887+oTur4WqgvGGCX4HzoBYFkW5KJkDdUpYhQCQd53lGBEbo0XqXZA5QIye322J5nH4ZyH1unl/TfVYASVQRqNpZ2aN9nEut/JWmu3JJNRnZRwuVyac2mUZxh+58kyndDQ5Z3fAypXBJaUOO0Ue+inznPOehqdmhwUubhohAJxxsKcbrFjEpamKYQg6bhLHSaa9LWkxQJD5bSlCDwml/4ui9mBYmf2eft9it/f/F9zStqBCTZAgt2+a0vAtd+wO9sXU0qNMJNzxrZJpGWL7Fk1IrIRmgTfkL3OnKXy+bF+458LcnrnZGPN2JORTYjCFdFlLjbmKV0Ti+ZDfDMWOUbu81GJ5Fl9HYluIREMZQFzNbvOUpPsQ4Q6uy8RCSnAxkTHzOstwq8QAl8uIktSlIN6jXhjh5XAiKEgWtQZJQiUkhEel9ZLpWRsF43aEcX23Lcz9v0FRPK9pPdKEgE2RESNJkEhaNQMjaSjWGpLeUesJBXRrXMmMEdQEEvjJSTEFLGeViElJOkDkBL4iqaCYjl0ua4PWJYTcCHsfwPkwCinICnTEUFhxXKKeHx8ixRXxJCQlpMeZANE+QcIFaSRJPv+1HcpbvvBkUywgy0qT2Hzzv5JoiwCtN21ybzKGTERatE2hYSUTgKFaUTLcVekG3WwOX0d6fH7yTGCpPwM0h9UQXvA/tMIfn0AvunzBkVxjVpBjEZEKKWALVQSvP3hlDOpPQwHlf0LMBKR/LNIhKxjJVhhTA8AAuq7iPJHHyCp12S+1VJkXaSKdBJSl419QET61VcIO6E+nVGfLkIslY2+kb9SWrAsSXBLKhq5XGzJfd91TvZDn6fTA5ZlRSlC1tz3Da/nM/Ztg5HQOm4C1fFIxh2iE4N3xBDlkDBX7Ok7vD79DSJFnF7+AODYZHIp3IitJVcQSdrB80VS70n0KsISE8peEU6PiEGRA9VXUkpIS2oEZLM77G8ntgSH03c/h4yZyDU7QGwRegJ8OkaWg74xAbBI80nkR4i4bNsVzlgVsyXd6y0doO1XOavNbniXLDTBABUP7EfP5Dsj2QEW2YYa4elefjvlTpi5l3u5l3u5l3vRUsxIS6LAPD09ixKZcwOTgO6MbqSZGEFFDSpAT4apwm9GMbvTGSRkgODAL1OYgBGwMQM6RiXMOIMWaNBfh6cYwtAGgzUssIFJLeoBWy5tUb2EFLPI6Q01Irlq+MnKoCSnR8DAvltYUwBk5JyqJyuhWpw+h9RgI5IQkYAaowGVd+xZuiOQsLeDkmsaEUdChShJSA1HugZdLUXR4BAGhp4h5yTyBA8PLniQTIAncy54p7D0uo2Vd2yUYmQSd7qX6wHwOkOr0po+3qaEm7NFHXoNWJnSGXGPNORuJyYvY/KAOQBZ56cBQwK6CBmBCO3EGlHsoBDkZJ8p6xZ5hoBGogKk0gKSWh3MWCTXf/6zuTeo3auBw9zhbtKT0ND1UXnsTyMTTTfVedX7wP2gzVX/z57NOhBC3lIwSiMdtWHQ+S/zlyBIgQHFBpsr8audICVXEbm3gDDyXqadrA9rF5nzakKczY9lhBl5rXKLgpuz7nkDct3v1/qeO0jRHGltLo4ONJ7WxQSbD/fv61jX+TQiM3nGAHSLKmQhcOUkDQE6l6M5IL1jT4fAOw2OCFVj23U+hLlPbhebc9ynGC6XDczAup6wLMtQj2EY4N6QhsmmTohi7n/byBNrBDCebuHHxKVzss/r6Oi8TY6yWo4yMoRRhtjaYA/qUt+ZSossZb9PWIlAlBCoqHMmI+8bYlzAsYBLAShgL4SQFtCVxTrOJ5MUEpCeEN3nsM/JyBG978m98sMxk0ksao2d+/pUGfeeI9l2XI52Bd8GgSulbgZnWl3netvr4D4L7bN+zW3A8rruNL3m4a9z+vJ1vY6e5Nt6q+1ztByJEnDcp5M0bCSZoH0VGJqaqdc4sBDBjMLIYFTCZ52lvk7mmPUzyUmyNseOv//1ytf/6D3+8M++wXaJePmQcXmtyDmAeZFxjRExLpJTvggIK7iZ23tbrUyHlGJgHrRNXW3oACJjigqDSU5bQ1U/tD276QIAqF3n9nbbD6iTc+2erUpOH/alkwbZ7TtKWFMn1agrQYmkqu+VqmkSOvmE1PEm+3Ho+wD3Onln6/yZ19/nupZcUAsjRF9vIRWbetLsAeaWakNOuPZ0ElLf2EmxLE6r3U5mtxOMsvKDq5fVRaIn1DYPmFmcT1wbsUeu71QN0T91T7bDouinSFX901DhpM/36SFsHNHmpI3Nr1tsBnObQ6b3fZ9V5scxtP4ljCQoAbZJ2yY2FW2EmBhUCpYUgCVJmpgq6+73/oTwJ/8UOH844y//54SS+37k5TYN7/vncN9f1bn9d91DOFjv9lSTTv6XXq7P9/G/nndDX/dGQr0lS+3zKdLMl4za0V5y/Tur4XzvsU+O9vv2HEe6+Vx9jnb7eRaO9WRJ38o7as1q/07Ef9g6CYpLmCw1W9AtG7JdzzmmeewBiToQETS9EkMuFJKGyImUIkJIyCHr/iYOnFwK9rxpzX30wb4GYuCmpzbnkMlSjHLS9EbrmC7X7Rq0fiCVwzFGt1bMTrqe19KHrPWS6Cs5S6qYFONwIMWM7PZ0ZtFH865YSEEgP24a8aWovss9Mtf5fAYAnJYTYox4eXnBvu8AWJ2mpZ3aDyGhFo3Qqu2QKL6EkUih7QtBo9Z2GSv1BbgW7a8+5yxiBpFNBlxP0M+ULiFspbt/lrLR3ZcITe+yj21flz/XOuEYubL/NTu22bPtd2IL5ryDuaq+AN3He5Rbs0Da73XtWOozUFCyROw4hs0nO0AFPXDG3NaMpN/WvSGq/tjsZW4px2fyqI2PXQfmFkXK74VB12MIUfdiJbwaIaJtl/LMdtgLoeGKNt/HNMWe3N738RYtBHCRCbqu1ZYIcZtfRR3GRCIvSinIFt3Q5k3Tj7jpdebDpdbf1NZ+rRKN4rLv2HJBWk4SqYJSk4WerEqQFGsxpbYPM0vUF0lLVrBdztj3DbVmkKZrKznjwjsQGGXPouOFKHZLSA2jlEjLmuqEs+ouuuapqm7IemgxoNYFzAmBFuSSsZeMh8cHIBSAVkQQKFTUnVCLRLMgBJxOD0hpFXyACfkXEfu/epT2/IsPOP2oYllXrKdnICx4fHhGoKTzwuZ7EVvH6sa7rs0AoTUKOcP0306a8auU5IsmC1U31KhLlTOUXQkEQuWAXCv2kpVssWNlQtlFj12XFUtKek89sTNEmrM9LrRPpHJqZXNFLhkxWFQh/c20T3xZsbZJv8t7gC8Br//bArx81dcGA7Fq9BcH+0rKo4zKxSraCGNWnUYk0/TlkoK964smN0jJVgjygKrXRFoRKAF/uKH+/rdA3QHeQaFiP7/i9XxBoIjH9AZRYrwh5wLsEY8/+VPQtuD1j/8W56efNTKX4ZREASkmxCVhWQLSIvjktl2wlYy8C1GmqNxa1xOenp4RYhLCSs6o2fwh3Yboa5dASZ4hUp0USxfSWOWKvF9wfvoZXp/+Bid6wvo3PwDliJwzXl9fUTLjsu2CPXMBkFFLxbZlmLqxLAkxSfS0Wnbs2ytq3sC1IqVHLKcVKQkRddsKLOWc9LuMQXBr3GxQk6dCZBLyDiCHV0thlKykFbMz2PBykb0cGTFFxEUOFxcN7yNdZXaw6GAxip8pxtTIyMxQolJQAozqUgBgRL4Um0w3TDTFVUmRFQiEFBeUIvP1Xn475U6YuZd7uZd7uZd70fLy8hGXyxnPz08AGA8PKyQnPWAgCQDY6RIDnF/PlxZqkDUqhwFzZhgLcUYSAQQQop4iS81OYRSqqJGdk7aqg4gRmMXZw1CFaplOiXZQuhuPkgqJqaAUNMVNcgEvg0Ffa26Ad6YdRpSQkw8RMZrBWrDQoidB5ETVZRNySTppGFOScPOEMBgJISWc4jOIKvYsRh1xwbIuCrDJyQRQEvOYKyICliiGgRE5gIBSDDkgMerMiGpGuBnV2hcEZbhLxCAioNZ+sq8BjGCk1E/lxthBLSMuAf30nYWbNW04hISURBmWPNgbGGoENWMvoJ9UEYO7lL0ZFwRCLQw7jesdLz3tkZ2usxMwo4MluH6wuXqKDwgk81BOClXk3cLdBhQAWZ/TnEcK2hSyGVlRIAASmQO/9FRLHdJCQ2yZgICEFkmFvNHr7HZf/j/23qXHkh1JE/uMpPs5kZm3bvWruqal1kCY0exGkAQI0EJbQT9Xf0FaSAIEaKSFhMZoZjEDTL+qux73ZmbEOe4kTQszI410P5GZt0oLAcFEZJw47k7n02iPz8zIfF1chJWgyqD2nCgOWTSRzUvP9mlw77ExnHPLek+o/m7qP2rUq6rcIiIEDggGaAiqdtexJwWZBVNGqzIoRg2PDXmGuWLTqFQ21iEEoNKxGWbUIPR1DhLPF1XOgSaDmOk0Qc6L3QALbvwACTUKiGDfaEd2CrPRU0361tODSfQpVazphJrC3EAUtj6GeQc5zxubD9n3AlirShMkzzNXnWsC0nqxZTKoWyt6mGxTQIpgXfpCIwh9akpeeb/orU2hEZsQFrqXAAAgAElEQVQiwCtsfYo+7wFlRl42xXJoI95yO1covfaWFVWUsmtb0FDTnSZFhHgZlKqsc0lpilAGMWIGsohhJ2A6kjE3T2YDwVgdbX64olQMc9ZAl7a3VMkJZuy5tCgQKQVUjZIU4tpINVBVaVoQqQKxgjhju30CISNgx4INHArutxXp3TvsdMUPZQew4bUialJGQRUlkQEe4dX93uwxqtxo+vGRWBgQuufqw8mzxzbNwLavL3P7uilhNH0y1NTlUliQa3uYfg9GTVNgHoyW5232bSK9bxg3B5bp3/d2+b7o6fDFMfDvJU3byA781OscQSsWt8tAM2LIsf53Q2mAgUh6nZV6Goi5HNeMAdq+DJoZx+JLvT+Wl1vFb363Y78T9juDS4RFK+R6a3VyDeCyioIuRNBSlDcQMHSIEWxREQOJIlg95hqIIai3NAkMTZ4HwG7/t0FxZ6iduURwIRAPk9k8rFnmxivCPTDG6Julu/Bnkt0XYDxnB3FQiJrCA51H0vdEA1paJLcqfFFI1EJxSyTGgl0NT42/IY346AA2vb3G33VQcKPPhZH3glr1ngrk2hW6Y6QYA2B3D14bg7TEtuYMdF+qpCEgMJaYYFQKVdMEab9zzsPxU2tFbMCaFSDCy8uLnJfgBnrxANkGXq0VAZIewXgeSSeQ5WQJASgF++2mURaKno0RlvbAcYt6Lh13BOturWS79rgzWc85m1/jPX8a5VWeiOZ1bh6peq5pH6wXwqsxCBmMjA0VuRbEeEVKF+Er4oIYWcYa9IX936nnka4eezbTdsAM1+dUqV+xsXt8Vnm6Zeeo/zyMnd7p6bPn02z9NQjPDKj5UqqmoUVngJjxTjE09xNT+IR+ZvX2vL5afDos/wZ6APw5K368RK4Abvcbni5XpABEYgQSaG6BeJ5LFIwIEFDyLhEeWJxPssqlBuAPlHr0V1ZuSHIuiRE+RqRLQEwBz5+fUQsjhohluSDGC3ImIDxJ+pCFASqo9Rmfb59RS/f8ln0Q+3gTENWqUFWWt7THBAJFXZc0j6CnRp2/TalHbrIUuwBQ934uBPW2lsOkyA8KqCaRRYrKaCDUGlAYyPcblhDwtF6xLAtQWaLtEiEkcfzYtjtePv+A7fYMMBCDdKqtXxYHjbKLMdfSZDMqnt5dG6283W6NZzd6TkS4Xt81Wl9LBqM2wA3A2PfcIhaLXCH0MhJhSQQ20FItckZwwWWJ2LddPdQlxbWclVBgQlDa2IS/vhc7AkP7p7NqUSF1fgm5bRpmoMsLBowKwluEgKgGbnG6Kp2v0JcavZb9V0VuZjmPpa6eVshS4XS5A3h5/giCnPclbzADprTZIhsSIpHuKUIhVp2M6NWW5YpEhD1n3O53QOej5B1cM4gzQBkxCIg0kPBOl8sF8Sr6s227g3m3ARH6H2Sug+rQLPIuUKDBlpsoGghIwT4LVU0pid4lSgTpWnb5TBLht9SCQIRcBAC277IOLssF1/WCXDK27YZaC5YlDSmziaLw/BQUoJGRy135lYpIUTQ8XBBJnAFr3kEQPmFZIj68u2LbdmzbhhgDPnx4h5fnZwGk1YwQZI9YmiOJrhQkrUuxyHoC4qhV04elJGuWJU3lenlCWi6oHMSxDqpnSJpyynQTKQExiENEreBSsQRJNR5SRIqEd1GQTrYfYggIUfjB++2GbdtQ8g7iqplyKnJmAFnBT46TNz1FEB5DHJiCyttKowIjFInWcbt9xvp51bQ2izh6pRUhJtUxSDr7Wjfc73eR+T9dQFgBAN9//wtc/gyd71BQJVdWhQgjqKNjp6cAW+hjdhKsAZqptj2NpgcgJ2DK5xQYATu4PiPnZ3D+iEo7agB2InBYka8/wz0ueEbFVjd8F0QO4fuOd2XFz67AlgtouQJhRaUVzO9UXyZAf9FpF9Edh4JSX1DKC5gLXu7P+HD9GRZI5BXUAKIFTBmgnspsLjMfSSTgVKaCUgOYzaVmh0WcaVweAe9CBgJQIOnOSmGsSfbctt8QKWBZL4OMV1mB0+ZwquuRa0Fs+qAKcEGkJLSxiLxiKU+3/NzoJGvUGdSI+15Q64JLXEEAyp2x1x3Md5HpNsLP+Z8igLHnG24vv8OaVnz48B2Ys6T0ZiAuF2w7475Jj0upeHm5N2DJsl7w/v3PcLlcsa4XUJR0gfkmsiUqI8YFSe0P+y6gxX2/o1SJhhY/vFf6XRFiwXIJeP/h5ygl49Onz6i4S+SnvTtl/PjjZ/w6/1rkkJQQQLikhHV5Ai/A9YnUUTeoHncDiPHp82/x8ccM4op1WfDnf/nPcXlKqBW43TZs24br9QmllJZGKcaAlETmbdHg4tocBC6XC9b1qs7SKvsRI4aqNG1BfdJzes94uWUsS8KehaZaRLjLJTXQKjMj5x0xJiRN42TRfiSq2YYQgMtlQa2xrV8KSleI8PTuPVKSSGgxRtzvd3z+/BneyZaZ8fQkKzmmN5jHH6q8jeRbeStv5a28lbeiZV1WANxyTBvj00Lics/r++nTJ9xuNyzLigqoF71Fc+jgjsq1pQ+JKahxXxl6GhVIPYqHafzNskDdGe+05RZC3SlE2t3cmFdvAAd6PmPLoxmChVwVBL141IjQG5lBgRG1zebBRSSRX7ilkPGvZyeUSXssjCeqgGxyrlhCUkO5jJ0EMKjNkG7AoFpVtCOAKAFmaHZjeFTIWfGqWxw+O3wEmncvKoBdBabSFDimnGw16zPNGxVimLjfX8S4QhXSqa7KbvNAvW2kBoPKjBS6sr6HyH2gzKY5BQC3z35M/DXLGuSV5N67ejaSs6LlLUeuVxaAVSClHgljACdoF60P3lP88XzptUnwtfabJ1Tro7XVR1+a6j8K0UdAjR8vemVdibGviI7W1WvtavVWi2egP1Nqg7mN87vbXrUx424gEDV482np+0DdIZ25RcdTnhoAGq2m1gK9l10b0J7tnjNVPcz8mNg9o3HibPzsAYvi5Lex77uFwx3Hx83ZdL/Rsz6vooyuRY1pQehaT28htC6lCCC1SD6N7g4mnrE8Wl9BFY2P1rkHUp2ttflvAeTQtK7H34J9tHayKKFbm3n8TdQUcH79G2By7pMBK89Co4N0hYUgZwQZmMjGQwwyUMOqEh1VtBMMbLTvG/b7DXsIKCmilhU5bwh1BZYV3/+S8F/+9zdcw4Z//b8v+O2vJKWTnLG6Dtl7ywtoJri1rSr3Nip2PPVv3TmlSvcEQmLNB46ATBW7ggb9yrB6gHGlkHvzl4vfMeOJxVMLebp+FhHF7XyDRsEowgFgw5Px9sz4ZwbDk2tWh73Bt2aEkQwVnnx6XGx0SNvi2zGDZWyuPVcSIMdwpA6XYV2P5krIgKR1eHguze1xu8wZTh/352vXwnkphZHvFfu9iPIYfc0bXalcFTTSQ9gLWJgboBuE5lnt86632dLIaAbqtQ63HeJo9RnIAUCLmDDPrtEtnui6nfcllwZ8nc9owEDhodEOo1E9CiS381kaYtHZdG3auQvqOB9HryzkvKT6UHBi46UJULrJUHCy8SrgdjZ21qV7RM+8iV3vgFY7O0cK0oHI3AzQvU4FDcH2g53zobcXEz/B3PhFAApwTG0sAwUxcAe/DTJ8alfjyS0VgtFzXSbd632Qb0j789PXv43JSKv6dyMFtR36+5fOdzjeRN8x8El6jwQRFLlNwEwZUUG+Fk0NvA4t9dHABsDhaYTKcZWM59DX0VNfPOcA9/7Hdxv/OZ5DgYFKEuHtLMZg/2lc63AN4HYWzefq/Pb52fb3cD6xfal0bDz/NYZA768DxbS3DuPfz1AC6ZmnrWz8Ym/HGKGGWrQzVl563zMIJGkFFCxuQAVj4kMMSEvUFDRVeeUePdDT01yK7luTHX2UGmlnZQZn8d4HCEEdUkqpIKQW/YRQEWLFjz8IOCFqKLYCkXUfL5AvyXZ+bjzYUEdplhFB8AqQ+dywCB1SpRgoBaxphmHxpJfpJ9RcsN3vAFes1xXrskDSDxcEEgANa1SadqYaOKV2x4l2ZthZwiOtt/aZPDKPh53DBtAUo1oexmMG5QcicZBoRzK7tLYyDp7iMbOG2ZtktQezcfzGQG1HlsiL5+0eQNFo7KuQtmkkWhtTtrOxAUbR1rEtrqM8L1TSzp6g95vehKudgeE47iw8EmmEZHJpmUwHBoueq21TXASIJDJR4xG4wlJW2zh7HUI/y9EAsfNIdzmptr6NurnczumYlI6Q8Zl9XchrZD32qHC1t5FlLddaEEJCCIvIqCGgVHmvGIJJ5bjUImuQthO1pyfjWlGyAYsKbi/PIr/tu2sTt7HtzlSWYkx1VbUCkGhWdr4Goka/Gq0NQjlDDC36LqmjR4oBFEW2JCaUIPPLMGcbbmlrrJ8WIVuc1RJSEh6Ia+nOBQ4oPDomkq7VIEC+qO1XnQvbeyi27wAIb02k6W00DioBjKIRqGR/L2nB+meE5b8V4/r6JxfExbhP2XRCN7ity3Ff2plqsFXPFejaO0RNY93I7QRGZUauFYQd+y3j7/63d9hvF9mzxOBLxYf/+h8Q3m/YY0SJAbWs+O3/fAGefyZAxD/d8N1//hvse0EqT6B0BcV3iCmBsIBrT3ePIOl3Km/Y9094/vsNn/6vK2p9h/W/AtZfFAFnK1CIXpWxjoVbH2XeK2sEmcDT6Mi/gIyA0tZZCKS6u4qSd9GuMCOFBGjqI4boR7OgwBpoxui8zUdlAWuc6+Ak7HqLKlk7aF7WnU04Kz+QwSgIgfDxn/4VuAA5Pcs+yQnxr/4SKAn0p78GfvlbBGLstaBo6p9aRN4ikuhll8sTLuuTOIoyQEX1NDEo/SAQB5UhjJeP2HcCV8a+73j+8Yb01/8xqCRQZQEbLBX4T/4DlkWA4qVk1Mj48Z/8Ffa9YKNPeL9+hyUtsj9VTl9iRIgCAt7yrnuHURUIJuCZXcG8Gdu+4UrAelnQoz+WBkC16GKWYg1UB52f0S5L98csUV9k3XTePyp4x2SmZVka8CXnjBgjnp6ehrSMt5uANUvtKVz3PbbnjE6u69reVUpBYQYotNRzRNKPFCMu64I959Z+gLGuC2KUNINv5Q9T3gAzb+WtvJW38lbeipZlFQZDPCdiyzG5LAuIqDE13utzvaiypJTGAHdldFdWmMHCDIzi9WreT5pqhLwivYnVJ5oML3B7RcyseOqKh9lAb8zZGbjCK6y6YqAoSES1JGa4tzbLw10QNeay/dcF0byrcpVIo4IoM0qAeS9bv4h8KHeAK0nY3SkoyFxmI4sYFdClSxbB0F4L7Xcg88wTvWVlRik8CTcYxtnPu1eS1FpxuawDuMbU0qYgYc0d35l1qHKKHr7rzFB/pkSc51Mesf4xLESlVxrNEW18aap0VWaY8sqaYkajrn7vT7Iq02Zl4FkfMT3tOtq3glOoHm/j4fMjQMojhe4jA6AH/AAWRrWPs7XL98H+KqUMQA4Ah7/n9g2/dQxNyWjjTrrBWjVtMuyX1cPuPm9qOPQSXtln9dt3BpjhptQnt64wPGvtfzSefp30tTPdwX0+zub7bJ2fXWsKUHiQkrVVDI8x2rXuDfkIZHX2vkY3cf6c/z1/PnvH/J1PZ9H34ThPMyjttH5QC4dtCmq5VaMGhLHuuY/HUONd8TzSpW5EtTfPn+2ZbRMlxbZv2PYFS7xj227AviJEQlyA7/+UsNYNcYlgKGAGpL/RaHll8fGPqA02ZL0xIIzonp2hzMbFtc4iwS0IiJBIJZkrIlVsKA0048f1/6tC0+8v3ef/Vmrd+kfA4C1/TmsfrE19lgH1Etbv2b/nvF6LSnB4lbv+pdLnEU3xe/bUfJoIYMiCf1tUmYBo8WeU//Jq40ftPH8Pgb6qB72mr1X4xlTxi//0H5FrRri+CPivKoxjMLB0o43syTjRAhbAYFMCh2asM4Ncq0Nb2NJBUDfUHM/3B4UUpPXgjJ7pBhG1NJBDNY7OeANVN2IAFirf+JnRcDnRddha4+Fvo4PGp0MVk0YbDZQi/8xVnDQqm3mRi7qdlG+38TM+jxlO0YzWZhCa4dDviM6fjYZl61uPDNbnqQ+fP+uOY2m/5zVk35vxqhvBqK2jasYAqmr4qMMZNb/PA3S8jPN15chPPr7T6M83veC0+HO+f6ffn93rXmtR6gSQJ5NCYPVUZcTYYVgjjR4jm4201P8/vf+V/fgaTfuacqTjfaV3StGkA3V4OD7ddgKNHKivTzhd+//LZ6p//tH3dm2MwHbGC4wtPp6lNDzbz7w+M31c3PucgZLaPRDwSSmIUVOKMKsRuWLeIMxijNr3zdHqHp3SimADFcyvAAFJidZ5uSbXM0lKgLCI0ZcTYlqxLD26hVSdIdG7CBwCDIxswKSv4XVfk5/t+pF/9FG75u/O6wU6EIWIlTarfE6yu7iNT0Ted32vjMm9bNi2ezNGmt6hNsCA0H2JohKVlvcoIjPfPdDTZrjvRjk/FmL86xGDvNzTfhqQlYc14g36ni+Q5zUt9Dezp/Mczd/z8L3tXw9nbNcmtqHLdaP81sfDInj2FNk+ohwAjdzpeAHP51Cn1TaG4syiLWztcHxIFNAIk2sbkauHNGJKAZEZPUuPXtd4r95vIotQ/biMOh2jLn09pCTGT4nmMNevvEERGlNrBrM467XUU9C+VwHIpbS6qDcSvcSi9zFLNB2C5x17Oy2qxL5vLerdtm3tup/L8QcNtMOctE0GktJ+k+7RBtQVeSFqxCKKFjlYwCwB5BxgJLosc+k6LAW9GchM0uDAtUXWTIwKQi7U1pCPKMiMllbS8zMSqKcDZvr8h8ZbS6Qn5UVLBUdG1mjeFISGl1Lb+1JKuDytWNfUQMzA6Igl/dN9PdHHvqiMC6IRG0MCXDpnBfoGLSGgBIkSm1eA/qMNtN+w/e0F29++Bz1lLLEirhW8AFQDwhax//oCfJY6Xu4rflVlb4SYQCEJICtKNB+wgC/auUoSV20vAfePC+6/IgARdcu6PBSkyV8pf0xda3RZzwZwBaEiImmsKpUKckL6d/8MV6q4X3+L2/U30lY9NzIIqFV0/ssFFqWSARSWFNR1z+BSDqnZHuk+O+3jdjYI+G10dPV6e7NBUGCEFFA+fGppW8XJlrF/9wMCEvBuA2ladov6JPcKBklozEXSgymopUXzjN0BTEiKnCeWssjrjxkVuWx496c7SCOZ11JQkMHESHEBUUApCTVV0NMd9faCBGBZ3iOGKCmhWOHWCkYqlSGvM8Iu+wck455LQS4F9/sNe96RlgUxyR56edkGh1dJ51cbaGqWmwXIssOfNcNSUpqR0tJ4lhACnp+fcb/fG3Dw/fv3Llpp0ehDct2cFCTdk4DmPHDT0+NqKRs1qnzOgEXflsjl5rAteyOmhBRJ+Z238ocob4CZt/JW3spbeStvRcuyLOrtvjemMsbYGFcRFCUMqoTcuzTJdV0WmMLE+JSsHhjCmJPeI6w1gZFIACO17JqmQgSEXggHw1UzVOsdk6Jh9uoEyNXdf4tNIKDf6hUD8rfl95Qc27t4XkMNlE35RBCAzOjxYMZLdoKvlVIySvU5gauOyqiA6Yp1ExSjtlMVCtP8+XE4NxabaNa9psxa0Q0cbqzYxmFU5s1GBqArLk1ZZ5GJlmVFLaYUUXWqKcJggKTuNeiN2FZvF5Jng9hjw/gMMvApdfp80+Bl9ZrBw4ooSqPOr6rGuKvKzGw4zA87w+qJMtW3s107uX6YzQfCzGvlzBj3CMTj65zBMvP3j+r3kX/m+84E6NlAM7TVr3in/zSvE1OR2JwANGTEkLU3/t0qM1U/qzIBXeHo16NXClqYaDPm+bU9tPtkP5oizvab/e73dY/80SD4GKxihgRvSJXxkXzpkaDp7vqe8PcEC61sJhBd4yNd7AqCec32ex7vn0dza2NyVs7WXf99NEScrdWTt53WQ6QriMXLCTBPop56ZAbMnL3fG3CnO2CKOQHcdTrHLN48t9sNgQjL9h71OYFKxbJGpGVFLiu4tkD8kOQF3cgIQDzgmMQTGl0F3WaWIaAB9BPhUZETmbAqQrOAkFhCvW+iBmqGwLmeefRfp0xfvve1djJGDKlbrYNRT/pPD+/rZo+xHXS4H00p5698SUVjdbP7u7/18RgNOl9XTwfNHDkC3xaLsGMrToI+V70ikKuqn4LyTHOaKoKlOHlcfNvmvj7qz5cKxYKf/fk/oHDBfYvIOSEgYh7tmRfw+7XRqimSkAeWGE1rxifYHu9Akl6/jd0rhQWEdNbZxwrj0bA48wue7vq+ibcgNNT5bFT1CVj0neh0DkBTbBeKQAnqDS/8UUuZRARC1HHRs8/OBvJG7uqMTGhGGEYVfivImpV+AXYekQbh6uPcI010Fp7bb1LwDkgjBlqf3Vk5l5nfODPKtjM2oPHnxoePZ4VSXRrnauZd/dnd+/YlSjEXH8vpS/d1avatb7FyHLuJAja+xZ37JjtwBDgh8ArwAiAghYAlAJEyAt0Rwu7OH2pyXgdlzL3tdPyktQ/7wSefXru30/1z6JGn1zNYZm7Ncb64GfA6OLHT/RZ5BcfT9MhZwT3pvnOp+hpwxd1lFMvAMoEt8tpxFPuM9L/9HIznaq+jdurS79MosQOwiAiRApAkXW+pEh3FjDhWQa0V9/u9gSmseMMZADXe2j4WnUWIEZeLRDKqmmKuaBCbdXmH6/WKdXlCoCTfXS5YlwDQDuYNzBuWZZdUciynaAyWXrenupp5zZFHPx4CZ8YoT9dHmjHef6Tvx7VdqzgkVe5zLtEphMhKKiNGVBl833fc7y+4bzfc7zfcbi8thYPxqmxyrJOnSY33RD0KqB8Drzfwn+cIXH4e/fN9DNw5zuMY2bPM3IZ6lP/Hvf1TS++ac+6Za2XWFCuYaH+X+WaZDsGfHWj3N6BBrSASfof1yA4aNY6rjyxjY9bni7nraCQykDn52M710Ze0XbVHJ9HWACBN0VgByD40Iyiz1N3GH6Ps1SOx9vns54Y5LoXWNmlWl+NMrr3dbtj3Hf7MIZ3cyuLUlovxDfJTmgytabMRBFTHFbtGMwphPLu93G3R8jyo+b7dmx7UxuFMFzXvWUtV1gzxED1SVcpv+ijhJzpPQxSQYkKIGq0mSnQFGT1J15y5gMsdZd9Aq1wJYBSNrgOnn+BicylR84JGhuYQGmD7jB/t60vGw2QBiUQ1nVc6ZymmtgZt7VcDTkfAg2sWTdViKa5t3NrKIb+vJO2n/B3c3gQGqa3JenoqtjXK433uHiaAQwTHhEIJ5Rpx+c+egfpr5O3noL/9IGN0JSxXBiWJaFkvFXJ6KY37vOCHf/tH8NRHdxJIdeJRf0weF3l+QUEEgVGJUeoNpSYBLQWobHIS0fwLhSuaPkzO2Ixa7wi86ArUESgR4a//EgtVrP+kIn34jaYZLMhlF6AsA4UJO3YAFmURTYasuWg0zzLQ+df0jDYHzHUAywDHs8P2Wgimw7fo9V0TwoFx/+NfyfolgG4ABYnqXrIwYUQR1+sF63pBWi5IaQUFhQc4p5oAAaiEtkwYQEApsmdjDABFMBNqLYi//EHWSJWzad92jVIuUcEQA2IUupmigFnSktQeUnWhy3XUisIseudgGnzhQ8B2v6TOvd830R8FBZylhHX1+5akN1xRqh2WHnCKDkSinp7Xxt3ogaVUErBzwP1+BxFhWZb2/LZtDXgj57NF5e7OBTbPs/w0zr+A/0rewJC0nEGjasnBWkEWQZYZXIBC8sxb+cOUN8DMW3krb+WtvJW3oiXFhHVdNZ2OeBkRUVNWpZSaYeHp6QkA8MMPwhh++O47EAk6uVbNQZ53lJyx7xtSinj/9L0ywzsIBSkE3F52VJb8okQRhdEF50HYGZVOj4z0R4MyA1XD+MILXL3fhmjuigxlSVVQrFxQ9gpWITmmVRnHhJiWFkHFPDiawAuAgwgqrIIylx37flcvrg0Ao9SCBoGhru4EjCck9bZYWvvGyDq9eMH9CPzo/e467v69KZfERAo1rgPLEpyCpIdHng3mViQf+tIiVlTOqEXGR/IVy2eL9CKeIuP8+bbbPFi4ZrtvBMD0MvffvFQGQ1StYCJNH9MNG/uenaJvVLwBpMCD2N9TazMocQu134FOfQ5VWD4RHGcwhNRwVPGfKWXP6ji751E5jl9/8+N1ZIpvZ1x6oPyd9+PZvHpFsf9uaJ96QwBjJAAit5ZtvkwxCVUsWBUqHHYF4Ulx69Ar0qyGdpuBKMw44IZxVppZffN8ybU0vONMKfBoDubPNqai6DYvMdm3SxLPFlFWZXd9SkM2rFtyCgkc5sjaeVSoeRDRcUzOlP2zwXIG/ZwpI+Xd5+N+Njb9RqvPQs0KPSJC85TrUb1q84SpVehDM9C4+bTxm8dCzrKeUmRsW4ABBlNahR7WitvtBUDF5f0NOxNw23F9eof3338AUcD13Y4P31XUArw8s6S+MPrUPOusq6K+s8gi4A6cwKFV5yo4AhCYkLSWFQELKl5AuJOAZjDVc1a3tedReQ004lZ8+9epkO390ajaja+PVYt8uN55Dm9k8XX2J4EZ0OufedxTPz/z/+Nzr9XRWuzSbfjxnXaDpgnRtCGm1KUWnwiY1N5n757nj923Xv3sx+Fr+/GocAU+/bgjrRFcBNARw4Ks+3CmDVZ8SO+2VxsQPDTFHiC8xdPTkwOg9HSdZnwdI5AEEClU7QGdedSu1+nU0ZB6MBC571p7WSFTw7lrnrgdCNpfrcZ5Dctd1UgmzFkAat+9VVNwxBAQ1EMyxuCAhD6qwRydcaTrYugTw5s3qEp6AOGbapUw6ZVza7+dsRKJQpipEKG8o4sywYxa+pkyGi2PPIifb+Nr+xwxygCW6XWmmAACIo7AUT8Hvu7xvDhdMudFJvabUqV9mynlWIPxSCNv5753nwHjbwmgCKIFxAuorgi8gAJhJcI1Eeq249PnZ2wvEq2UAJca0Nru6CwBwUkAACAASURBVDaf03By/39LOdmN+kZPgx9TcF2J4AMl7C07nhX+Kpq9hfULT/fHHx6uAednZKO9E1jGv28cOz+m5wCl43k4z5H/5GWW/sY5Sg7x2NdAZviNEn2gCs0IpKl5tB/mwLOuF1wul+Z9Lrzujm0TY01aTeZkgCooMJZFUgMQAu73DZJarQBgPD29w4cP3+G6vgczYbvf8O79FXy7YXt+wbZ9Qik3XDnhRht2ZBDEqFYqg8ZQQqe0XvZPH73ZiD6XOcrVXPfZs6f1KR0NACqJObQSVP6uyHlDKREfPoge5+PHH/CPv/4V9n3D/X6HAQykvQEpKZ0OhJ7up599pRaU0iPGeMOanVNeZreIowCaXkH44DSdF10eLKUArPL8JBeZcxdB0/S6OojGFNI/tfTx9ZwtuTkG0IAjBPB4T5PpYLRSveDVoOujybASB4I46Uj0W+l3zjJ2NeceSYkllWCIUVLAkjij2dlvtCSECA4uMhMJMFRwVAW1ijOXgSlIgcm1MljToVV0fhtswBxCi9gbLPqCRnoYxomG9SGfe0omGWeVW9z8l1Jwv99xv99b5Gubj1ILct6Vo4kSJVmjrVhayq43U/6jMm4vt+b45420EvmoIsRF1ykhhJ7eY7ttjTe0eTXd1MxbyD26r1E0ik9RXkN4iFoqQjSphhsfFUgjcRNhiUEBM0UAM4naEiOq4LKBywvydkO5BCwpIURCzYxtu8maAlCLghrUWC28k8ScbAAEUCP2todn3ZutY5ORzfHM9CaiG2OEJSBGoQGlSHSioHQkECGmhGVZcblcBCyjETDE0L432dvG0daF520bJPBATk33w+hhZioait07BLQtLTx9YICrRNEqLECIvWQULi2F4bJdcP0cJOV8ZdRPFc9OtiI93A0cOxfPZRhVmM99ANjzDblGLHEBBQMHfSs9E76ZNV0cBYCRsW8fwXjf3sqQlIMGvA2RsSwVuTBK3ZHzhpgIiTTVzl7U+VN5DyFYUyRjPfeafGp7nVU+6GeNpcUFjNXt52eXK6RHQhOFVlqKJZHHFGCDgH1nALmdL42OIiLFBZfLFU/vPiAtF9GPVUtxLQ5mzKKfBypSWgCL5Anh4VMSWhtTBApQq7Tz8+cblmXBui5YlgRU0csJXTX5MeC+vQCIiHEBOCDnO0phOQfBApQBgBBbarXKDIoJMQWJ0oSAvQCcn7HlgpcXAcxcr09YlhXXyztNiXTDvm8IQewJEvVfUoKZHs/P1+wkZvdY1gEDbeac8fHjR8QYxYkawKdPn/D582fc7/c27gaIs+gy3hkW8NGWt4nfETk176RnkpydrPU2QtiAoRl5y40feSu/f3kDzLyVt/JW3spbeStaDCATY2yf912ElnVdGzNkSo+XF/FCul6vKlBpqEM1Am7bHZb3E2Dc7y/CgNUMaEKH+3ZDKbUhlXnwAO6GHFGSj0bU2XDsFSTjjVrFpGSa/25eSvqQhHbtCnTx4iVQLQCC5H91QqLgJSzsqRpTVPFuWtJSdnDJqHkHlyI5iB8ofuWdJmBUhODCDqsQNhsEzorNaU+hcxRmbF6PAAELsdoBM94oDHQln0+xYwy2rAt7TwVKRQgJzEUEtKYY620ptbboHSYkeaWaV7wZM2/PdgM8lElPQ6olG48Qowr8DFhOdvTw0kdwgyk7WXNMBxX0CN1oNkYI6f2GjuO5kvSnlDOj27ym7b5H68KDEnp/zxW2XsEFqDo8mCGOpjpUkdXyDoemHD27z38/gyLs71oEhBcaKKkb5EYDTwev2cZvRga3NgIFZwEw5Yk+Y5/bPVoPqyIODPMO6xGSlEZNYz/3eSxO0YquIPDPSe7oNIA0PK2bx8poGCktMmOnecpZurVBn+ueN0832QvqRevGzxsA/TvbnEIF7eAjhT0eizM6fGYgfs1Laf5+ft9pIb+3bb41PDXBjV9tINAQYltfQ1WTAtifQzG4iD1twRVVJJvyx5SMAUXX9H3bcHt5RroErGtCYELJBOKIf/EvC55SxW//oeJ//Z96tBkzmrWUQTYW+n83YXUDWd8lvowACLs/shiIAYFUEhGIgY2qKNnak74mX6PU9BpoZixHP3s/il8qZ/f66DJz32n4PRlF3LVm8GgjO7f6rMxPHRWj7Xt6fXx46odv+2vjSyAkqMEDMroSWaZHH/L1zeuCp9/Wh7O224jZGPt7+/VvWAl1QdlF4S8A5OJUvK7dJ7TBAJZVQ9Tb+82L2kfH815v0vqjd618tlH6/cp8LrR953mVB9HvfBrJUDWy3XQ2dHBpp/cDjaUgwOEgHnuWZqMZI5ixpNQ8UwNFpEUj7JGADkVXeeQbGl2F8XiAgRQtKkEDTrPxu9XNQ23nuj0jBkIbf58uSceoVJR8DAHfxveE55j5Xnu/GVRkDO3clXXblL3ohkkfpchHNDyLwjjhQV8v7D98S4wn+/v3X6evvpHMACW8SggLiBIIYpyIgRGJkULFX/+bhH//V9+D8HMgByRHF31LCXBgmQ7n6Pd4iofpGynHU+xRMVhp/7v/P9/pad7juj0ApdNRGq4PMoI7pZnYxVY60tiKTmcfnzX909kZKqmYxnEPp2N6XDvj3Mwzwb1vh/qmU7OKzqHsBKLYUo3UWrHlXQz/ECMfIWBdVpFjC2PLO/J+V96MkVLEkhZcni7Yth33+60BC5ZFohzd7ztKYXXYCFjSist6xbJegCpG5utTxO/+1YrbX39AxZ+joqICiP/irxC++4SMgH2HGK+oHuhJG3dHC+cz6ZFM1mSdySkF7jmrc5gPx0N32mP8udVdlfZIhIfKAjIw3vZ2u+F+u8u5yp2OdV52PD8AiZRroBmvQ5jpqTkk5ZyHNEx2ps2g1rMxa/XpApqHvVZxxtGHRllfI2x+u+hNTabzYyljoWfoNB9MMr6h59XR73s6Fft2NhgCpa31OTKPBxeVnJFSBJugYuQ3Rk39oil2EHu/9SwmpdMhiL7Nog4RcUsZVKsBXeUxEYcDiBJCsOg23LAHHhBqTiYVRWgbjdFZ/JzMDhsAwFVByhSGNWKGVxuLWYaUZ0Uvx3C8BPsoAwRJu1t03kROtjYYL0UElNqNrSmtiFH0PaYX7XugtP0jRuQxOmDTO5HoHEqpQteYUXLWuTDJTCm97dkqKXoAlhS7VVOYV5mPGKRNMZEyxRmoO7hmxCDgirKTRJ3RCOC5FAGyKL8n80lNjm8ybO38jAex9b3ACgTpJ4DXlZlzTi4FsQFeZC2mJLrImBas60Ujm/dxszaM+lhZi8bj+jnl2j8fuQE9AZv+2GJsVhOkXFVKw5gRK+PCAYQVO11wCReEIJHQbgD4JeGH/+Ev8AO5SG1MoBwQfZVAi9Y5ytNj6ad5l6NHOVB49d4XfHMJIQr/DEvNXbDnFwQegbbCf5hsVUFBHJMqszgYBq+b1XlH/w12umR2AMbW0aNObmRk+t5p3zS5xpNVggRP4kav5LpFrIogKghhgeAqCMuSIKlCAQoRcbmoA6ydD9a/0GQVo/EEoZWSdkr2famlge4sqorQg7sCIFlAwRSUbpoeLzQ6a+klBdxHuicS9iIg1JgSQEEjuMHNfQSFghBXxLSD4o77tuPJ6V2NflqRlEZiq7FxraXifs/KJ3UeAkA7r73enYg0DR01kGdKCU9PTw1ctyzLcNYbUKZMOmd/BhjN9vozhs0tgw0Ao/RpzxklUwPlivwasCSh4ymOOsi38tPLG2DmrbyVt/JW3spb0bLn/YA0BtCUTp6B3TYJ/cfKLG33O7Z9awykFFFkESUwV3z+/BkpRvECQ8Wu0VbMqBvUE8HUbmCnXGpC/6ggsnKmuJI+CKMql7tg74V3ZmDb9oZIHkOpd4aeVDkhhmXNM0peSSQ3qnwMCxkvSgoB0oxGBEnrIjgckwRc+gB9cVcqObXrVwpMZ0aDcXzG+0ZFFTVjhvcU9oo0oBsYmteSjpcIaPug7Mk1YwlmLB4BR8ySz5i5NgHH2uLfNwvuZ/0ARDjy63YQwPUesClQx/Y/BFexeVx3rwgrZ1Ex+h+ah/kg8OPwjAkKr03yrFx8NFb+3kObTq6ftc0LNsP3MHDBufJ3BCQcAVmP2jKPK4gP94oiGRqKmiWsNUwJJvseJ+86q2feb3aLVwT6NpmByANIVA+JWXnU7z/2czZnsNeWDfd1kOKj8bJ3Nk9Ltx5E+SQ5zA0MZEpSPw7WfmpK1PDqmm5r1Y0DM0vUCq7DPWfKj3kOzvo9/z72f7zfj/m5AReieyJv5DVlMlq7tWVohnalh96r1uo+a2tfU2M0MzQjfNHXkrtPaS6AXDKenz/jiSOWeAUqBDBDEet6BdMNe76DIdBTCbUvCsFoOR+mtxY9cwL3/g5j6UZCFGZFo5JEPccCEkijzYgCqZKEoGdU9WTugA12dQ5j+oqh0dqBkxbKKH3dwXf2JIAO6JjSMtF0t//k/7Z7PX2eIb5WePhurPW1EaAh1dN5YQVG+WfgwCrzmM9jKpyGGk1t3+v3BpOzOl9t69QX33aartva0Jl4tX/zW4gWCDgjAKyRsvQl1sIzGtCNLmbAEcOIeQTO9NWDZgAgxn52HQGm57yV52vOij9zDme11enafkbHPBBjoLEM9x2G5xpvam2jIIYpfSgGaOh/B5gBsKQFIG4KW1OE+v74cZlpoleGnskX/rrn0SyV1Hx+dJ60DmCUpqCvI2/px9mPlZ2TFnZ8Ps+Mtwd6lJ1GhXQdpRBRw8gLzoBr++2jxp15CJ+d74Cnh4+L4yKgm2K+8PjZYa12euDb9RrP2p/rBlMiSTIQCVgi4bIwIgnireYgKeLYA2FGUAy4jfT4fevhkT9+nWN+XNj9P3736P7xfPPl7P1+KsZnzkGrgvXmltoI7kxt7zg5Iw7gxfYuGtrg6byN7uy2MQB+PC/haLt/l/+rAxl9++16N85Vrii5IBfCkljTDRw9yQEoLyoAvX3PLeoM0KMgEBH2/Q4GI8SAoOkQfvzxI4CA7b5j38WoviTx6k5pFfB8JCzLBevKiFyVPbO2VwQw4kIIFJGLnWXfLmP19DTHa/bsTLf6iL8uu41T0e8XfYSnaxbpC/j48SP2fZOohiT32ViONEvfF0KLPGvySktb98qu8QY4bxC3aEG+z/7Mm8/c0NKYjvLD+PcwEOp0EDTqyclQPaC7vnxJh+KvH843i1Sq42tNnXkEO/u7TqQDOWY5q1Z9hwIfhGUwkImmyoJ+1+ZRlkUXeZzsQ6aTkbRooxwkrYPW18fN0jXOVGV8jkCT7mCUiUIDM2ldpI3UPhu/YToIA7YYwKM5RMEMvT0l5DBvnmcjW+e9TuMDSpGo2Lnsyh/Y+/qa9Hoif+77aMbDWmbRGeW9ACGCVc8XIYZkk6GgfBcFSdMj9cuc1BBg0UFqJdQofa2VUPYd1dKe5Cxpd120VGg7JRKH0hibVb+/dd21SOHcHW7mfSKROGKjZ/36JM/rRwEdJYSUsO0ZMYhDm6Wat3GTeQhtPRsNaNmiX92uZ3y10r1hPQjYaDx09SMYoVZNPVwRTa6liC1E3EDiCLl3ZxWJZuO5lV4CgNpkqWPjPTcxUjJ9PkQEilpTbO96xOy8quNjNIdOrhlct3Zan7+bEYI4Coag52ogt04DiM1ZVOnLxBzUeqz5kf7njJ6e6Ya8/AO485gBPb5BBi4ncZBMbY8r/VE6yTDgh+nFXKQrk6MIuk+KRFPLWSNbCYBuWZYmj/i+RHWyqqXzKr4Y7fKyjNBiafMSI4I6u1oEMTCw75vQ/hpBcUFMF6S4Y9937PvW5CiJqOrSFXFtgJnKBebPZbTL6zztjJ7b3fmu2L6/Xq9YlkVTO94BoAFwTMayiGYGSJp17bMesPMB6rRB/cystbblP0d8tvPyyzLLW/na8gaYeStv5a28lbfyVrTcbjc8Pz+30HrM3IRIA8gAUMXU3pQftWQBzsSgaGpVNnFueY7BjDVFzWsbwCi4Z0EpL0vCuko+zKwKbzBLKFQElKyRXeBVjMcyGyxN2WQKMWO+uuFGGWxA8ztL2yX6BKuBxsQZMVaaMG8Kv5lJBlgEV1PuOMUEawhECckqHlEEC+vfFVGSJ1r6KYwfADjBUY0c8yg8Ejo643k07trn/ueZcNIZeVMIeObeGOXZ8yCQeJjaGgqhC080K3tbmimo1xO193jFqFdOeG+eM6FqVmoM40MmNDklFailZOk6uK78bXJg84jGMG722ZRTnsHvGqLRkOIZ+0eKu7nts1Lx0T1zHa3vXyizsWteM02R8ko6ihF0dqzLC0m+jnOAhu1bGfSauXm7xNDnrbVT/zNBVwBR3SBkXhG21s3Lw9ONbm5oaiXth/9taxkn9z0e59GAd9bXdqddOa1jrg8YPTxH5XvfKyCvBLf5URoEv3bOlftHujK2yc/xvA99eajYoVHpdPYOK6Js7+16BLzxdUkfZQ592i0x4PQEQ11haGR/pvXje47CvoHkpL7pCQjdt30g34oCQ6Kb3e93EJ4RacEaLsjpCloiXraKHAN2JJhZp4D1yNCQ0hOgovUJQNaQ5ZYK48wkafdnEDIqWP3PDSxjodYzArJ6pNlzbGfXodddMTePxFmZv39037xbrUfH3Tu25Evgm04xxtGx73jo77e333iZU6pvHXqlnIJm5MM09u4ep5gNhzFqmkGnTNdWOuDMGVV6TKnQ2kLDX19+7vLdj1i/+ySKf0QwRzkF7Dx9oIA+O0+9QaDNp6MNhwh0zcO+0/yRjhndoEZHR6AGQJNxb1YCn/NigETgO09POBsx7LyMGqlw5gksHLaN9sCTIKri3SL8KVCm9OhXREApsa9UAijUA13t542dJeQ+C08rEQmiGxfPF9hni9zHkIhe/bq0h81GqOlXLJw3tfeGJQyKXxsLfx6GELCuazMOmYHIGyorl6545trewdzTg4BGIJDMRQes+vNvbEf/+2uL7MfpfjqhYu5cPxzgr9Wv61nG+vzMbTxK28Z2UuiarozKBSkmLKliCRkJwN/8GwaXio+/MdpypM+vtbRTpt7FM9CMb8/XFKvh7Jw63Gs8Hz9q6fGcOHsXHtxle4whHuseNPPqWQFPZeyuaX8On/spKQkjj4a+eV76dB/b/Xqr+llr91mEnAhZWz1tD8PS38WY0BNHilVn3yVdg0X7M/qwrhp5phY8Pz/LGmVpea2M7b6DSJxmYkgIQdKAAAG32x3rWnG9RKRIqPUO1AsCIgwCwgAuFwKWglveQHoWeSPr2X6Z9718N9L813joo8x2lKeAI6jEP9v4otDTHliqCOaK5+dniTRTdm3bnFKUlO4abejQqn6u6FvoGE3EaOUYuQ0HYIHvp9FIH5GrAWi4IFCPfuMNpz3aWI8cV6vQ9RiOa3Q20B3LfMY9vt7GiMa5sX4x6Q5it1baeSSRXoAOZGqcORnQSMAQphsiMsCWnN9atURcAAv/r5EUmqxHGhFNnzUdBiCRNUMkTc9keh6ZV5OfYwyabqmiK0j6ORMCIURJtVNraPyQgcSIRE5v8jcDSJ4fkzYwCMu6SESCUjQ9Dx/Wlf9NRCAGYhAeUZxDYnPA6lRPQWuY+Twe1pq1txl6XfF8gv29ruuw7+e9G0jo33pZEUMUwEttTECjyCEQ4iJR/somBnku2p7Q9XRie1aDtkYHKqWAELBtGZ/wGQxg3zYxuJsutKVSl4hHDKA0fVUf2zPe6Vj6emf0aIaWsu16vSLF5Noccb2ugEZC8rSi6+BkaYUwGr7bfmJLCWY8uH1G08sBpseruhdUrjZ5nG2P2j5zW46tvgxGReE79vsN//ivV2zbn2H7h/VwyhtbMPIzXbKx08+zDv1kHF9uUrQ/z0O8giiB64IYLhqjxDv7fF2RaOlV104B1xfs+49YPQ83tSr+9o9xWW7Y//hvUDaLSBRAHKU+7qBO0hxiRfN+9bnLzdlT5skDYsd90nep042xPyMVKKzv7KxOj4/HjB5AiIx+SZbZWvUdQWitpDSSZ1oLld+H/UABa1wBLsh5Q9537Dkj5721v6WKqywRmkptckIpHYAm0ZQI+75pv20M+rqstQBBzwUWAF1aLrC0fDEmpBTAe0KJC1JICAh4vn3G/b61donTqkS9ETDN3uYgmNwFQkqjQ6TnI2ZZT+hf0Dkt7Yxn5mYXAjoYyNdlgB87t+d0b36NAFCQkKyKXDJiipJSmvsqTUnctyRyHuPl5YZcMm73G97KH6a8AWbeylt5K2/lrbwVLczde2JdVwBd+Nv3fUDy9tQfhLzviDHgskqOSvEc2lFYQoDWUgAC3l3fg0IPFyxCZ8S6rkhJct1HNoAGIyRJrrzv9zGFiuOtHinum8AKFcSBQQzhxsCzfg5ifDdlk7ahG02CGKjAaLniVUgNsYA5ohYBwgj6mYAQm3AGrZNrRi07wFVUiGxhQkeFtQlzRD18vQn+IjLGVzXMZwZ7X+9hIN0acE/o/QqAOQmdaKEWvReQ90pLcW2ioMy3B3b494riJIYx3K5XiBkK3pQbcyQN/4yV2Qt7UHQALdduUzzZ2DSFzDgeJh1zZWBSjKEphe2np3cx4e7LSgjX1niMbGLtn70SbJxmQMM8Ho/KI8DR7C09jHNT5B+LNzx5Y5UvPrWPPXNU1lRVcKl2r0rKLlG2aToKVdaBSITVpvAC+hru+8vCMptBcFBuDH00abxH0jFjab+u/TKlJY/9eDT2pogex39UAvo2nT0/0zpgNur6+7Wfrr8eCEc2hua91OroAn0fw2Px4BiZi36WzM/Myk5fL/XJ+qJCuyvH+3qbr5+2VZVXpnS06ZRU5HPaPzQtmA9VPr/n7F2smhtqrnG+GFima2pMeUFEqAjIe8a23ZAoYo0rrtd3oHDFPe+4XAg1LAA2AFDAiryGdN7O3ir36TlC5uWPw712V0DFjp5yiSDPqPkFO4JcJ0ntwzgCZTxFPCt+R71e6OTT+V16kj68czYQPqrX3+drU3UtBHrUv3utPf4NpM95Q+gwblNDztr6QIUNiz5g9fnfsi7s3X2MRgO23Bk8x8SEQL2vaPXOsw0QS+ShY8vOoVQ0jEK/kt49492f/iMIKypfANZw+8QK4Pk6ZbHwI2bk6XzHo6hdI+DQHrNn5xRN0vJaNdc9Gz2IaMH2+Fj/XDyQwhsJmqHQpa7wdXTgsjVlfLan12itbu8TAwKBgngxCl9fUZ0SV47czseQvssiKnra69tv7zEgTq0ZEu2xe5R33la5cw4IgR2gtc+V3C8gGuYjUHqObDKfvcziqW4GMDOGEUl4cQ+YmedEzrEOFi9FgTSVUXgEj58pfg8yyYPz4rUy7mH3fWdi/Fv7/19PXLVtU03DGW0t6e9hVX7beV0ZQC2IVBFQsMSMyMDf/zvCdrOzxp85IyV+xE/2Xp31sj/1GkU4f34+qx7w5IMH+vjb/jqbha/5bq7H7vKgGaHZ9o6RTvLwPx/aqOY6+LGa0111SubPTzQQ5tcsod6e4xjOYBkGACIsMQJhRc6W8reAVK7k6iM7wYHX0FI4e13Fft9xe7mBIcCYaM47jUYREKJeS8i5oJQXABvWNaJUBvENxH+kBkFpN4NxvUbkWFHrDaCLWN/Q2+YNev2smK+NPKmnF55OvCY3vFY8D+zbI/WpLoEClmXFsiy43+9iyOOitLifbzOtMkwOOTknpajfyU+d5AlgPLcskowHFz5yavH1+GvMAII0wNfbnxVnilKKev1rOtXa9Sxn7zoth8uvcYzdAQcEULC11zkwZjq8WzztbV/KGvXpkGQMBTAj6ZIY5p1frG57LyT9C1UGggAFaq1OJpaoBQTTpXUgkpzLjTtQo250hm7SyHOsqY/k1XbUBwIodEBY2zncATMSWTqI8blFZR0BryFINEsDwe37LmAvp+fwe6SBqXSjC6ALqIjKrxJK1X65NQl10LI6bQ11Bwxpl6Qjqg3wa3pDP4+1VlwulwG45fe1HxMBqhn9WoAQNVKLcNsxBVyfriACPm0fkfNd9YrB8Xh9eZYsKZsoWDpxmbOX+71Fk0kpIVsUpxgbtIAJbW2IPHzc+/7vw8qn8dTr+154q+v1ihCithGN5+JgKW/6c8247oDqJp83fpzQUqrOfAi1KMSSJj3GgFwyFLmh+jIBFjGLIyZRas/3TsifNRUw7mA8477f8Nv/53uUl5/LWh2f0LPUt2fkR+wMqe7vfi6z8kGOToAlcqv+FaMCJZBASAJ6w4Yvp+f0Q6T0hSIIGQEV4A379hGJa0vB5M9uBhA/fo91ybj88u9wr3WQnSIl1DLqZw2oREEcRsUxNMGAFeZMKPSynxdyTqHtyZn29iXIJ4xclzfG+2VMhYaptB2qRtiRlHYMQqnVOZ4wLL5utwEU1CIR6Jkr9v2Obdud0zBpWrGoPxLFRvaTpFKS9IcWrWVpNhCjDeIEMOpaxdaga0TtJEGBv/LOiLIl1H1DiQnEwOeXz8g5Y9/FWTmGvkbMMWBdF9m7wTvEHeUl25ded9sBhTzQOYsWx8zDMyIzmYwsNL+UIg6PLZpUfx+1vVpbXaTnWGWGwTiFZCnvGqIAEouk0nv5/Bn7nrFtO97KH6a8AWbeylt5K2/lrbwVLR8+vMeHDx+aEsKHGTRghDFOpmTmotFfIhCDRJgpOaPkXVDSJpCb4qNkcDXvTTOohnZvSIt4qdwvWPiKEgo+8ycRhuMonAHnyqg5LOIgZTpRphut2d3XPROkui74olbxjEtB+XYxkgT1nNq2GyyhbgwRiOghhJX5Ljkr2rw4gWFUpM1Kt65gOfGK+MbS+/TI2D6pb4ma0sQMJbNiwCsO7Bm5zgghIZcNpewQ43E3ojSB2YVftWGYgRS+jd44D/SQjFZmJeTcH/stoVLR+8w4CA3y2z0Pt5JMiU5uTUFC5ppnvlxXgM1U96yI8OMXoqg1XuvLl8rXKl4fKSr953mdMNuojcYfL/j4NOk+NgAAIABJREFUHw/sedT/1vdBiQoRwIGe0szqqBrXQkMUD+1kgqTvqKpPtP70dTz2tStg7XtT1luaJ29ExdR3r/w5U3r/NAV4/zwrsEdQUb/m++DHs7KnZ2JIPR3/9p8oL0QR5Vf9cS16GmDhq+H28dlzZwbE+V675p+bf3ujN3OPyuD774spB5nZKUX6uPgzrtPo2hRtc52vtd2U5HLf0IyJjitNQwCoAhQh0ICCmjMy3bBvz9jzDUgk650SwkJ4/52E1b19DijZ1EI+5smoylOVYlPPVTJghBrotJSWeoFxR8AFqgRBB+IQgISABQGbU94x+moxBaEBejoEY5qXwzfnxRSNX7qn33ty3dFmbywcn/f/YzAy2t92dHQF6gPF8mmbTV1q17qqcjDO8rEd9qZXR+EENPNa6dxPbwtNY1DNLoGRmzr7OzCaYXQeFbmnj0hwrWNixKt4FIsz3QpgARBH5bOdqY+6P50z5u0srMcMKhnP2JF2j8a6DvilYU9X5mZ8CMHg2XTgKYAjTRx+gBblrgGyJgPM3Fb7u5SqSuqxfjEGAeNZLbOQS2iGCTFadKNHp7vUeVSydEiYZrZ7y4viG8N9AoKx/vdzqZ/1PWpfM4xCK3I8PJHxWPKuzr/b/VAFcziM7b7vQ7oRSwfi07tYFAQiUgOgpWzoQP8GrokC0PVRf+xdHtT8aO6/tdBhJ/WZPCsStV/PoJ/+2vFd1NfH8C4zApGJOgUEieywECHQMgBlBHRJLsrZ49JPq/6NtubB3+OdMw2agXnD/V9IhXdezk4klbFOWnW80tvvDWfAETRjT1YIjTVgojsxHC3X862lg1B6zv2egB5TZD4DzRA4jvw4PowxeszYm2MxoKPRuXVZwLSg5J52OAbxjC4Db+b65+iH33OlVqg6QjHfZoQPCkRwZ1mtADKIgD1vuG0VZS+4lhUhUzcqWx/zFXy7oN53xASUyhqcq8s3Jhs0EWSi2a0HJ7qLs7/HAe2858xvel7YjweRnuZKI42mBidjxZSAwqg1iLwEUro9QmPP+FeT483oxw7o6HUCy7IMzlbz2ezBD95oZvd7Ht+MbrPeodfVgaQy7wp4qNzot//x43c67K+QgwMdnOVtFwm4OdgATSZoA+nf6eRIO0/na1KCAGKIQMY32I4mkQAMLNONjwkxLigVwpGz7WcBFNdKKCXDRwLqc0CQCMnyLCkvYSCaDpYRfmPPW19vjYdCGy8760ux98TGh9AUJdWvE3l25H0azwa3Lto4EwgK7FJnEG5ppORbW0Om97xcBKxz324gomYcN5nZIkH76NIG+DCeYlopwrcEkSlzrrhcFjy9e0IICXvOAElkDgqSAirnjFwzclVeWBcisa4oHT8QIYQOHiQQEASowJC+UgioubYUXWzrVPnYauN7Ip9/iV+R9e5kF7dIZUziADLKpYBgvKDMj0XmiDGqvrTzkLYBTTdYJtrXKTTD0k2bhEtUAKqaykl4ctHZmQQ7nitNiiMGx4r9XrA/Z+zPFVTpkMZ3Tj3rT0o74xhAIQGkGADGHgp6dlY3t/b+CqiTCgsgICS5zqS69Efc4KMi8x0piANrqAIoKxsqqgPzDCPazulljSi5Kt2Qg9T0ZkRdzjG9SgpJoj2pUsEDKoylt2iNdk7LtPbIz3+IYuuzVqFPXBkcRJfDpYIpS3uUnkVdK9RGoIK5oJQdWW0a27Zh2zbV40skr6oRZYwWXa9XiZJHhJzl3vv93mQsIEgE/RAP51ErMkgaXSbhsi6IYWn3XdYFBZJ+amfGrimVuApA5/nzM7aU8fT0bqhWAC3CE4p+T8bG0kt52t+jyPXx7O3sZ7RFijE65CPOa2fEsbZUZOdsbc8/oun2rL0jxgRliRVoqs4qXJuce7tvXQ/5Vv4g5Q0w81beylt5K2/lrWh59+4d3r17h9vthlIKUkqDZ5D3ahXhDGAirJfVeY6KQnnbehjVoAKcCePMjMoV+15wvV5QqyizQYT3360gAn7xd/8c73/8E3z68I/49Be/UyZOQ647L6gzg4eVWdkyF28cn40noguppnmT+gdlJjcgSYmEnAO2uwBmlhRb/s4Q0yBM7NuGfdtQ6g7xmBWvilHv0gURr1CyrpFrxbcU0+9QU5514aSJvWyeLF1p2/NZxzamFur/EVNqua1N0O3RSiQ8pdQdVMmu4TGpRxfyc+a90Xw0G3lPbbmsZ2Xcsf+zQouaccrqOjO6++ebSNnAMmjvk3rMe84UD10RDD5TsI5hgb2QcCZIzc/7OubyUAH7SpmVsT4KjFcwxhgGRa59f6bgOmvP3GavKJ0VqoB4eglebtzvnj4NgpfAocCVBsX2LJz58fTlEfDk4dp4aM76aaUrrs6vnSmy/PgeP3fAB8gipcha/pJgeWYEmNtic9DaTuch6e3zI4X1YY9O/R3vRTuj/Fx9SRFuirWqHs1GW42+dMW6GE3H5pyP/VzaHgDGfUJ+X4z7QYp61BCBSCKRlbJh316w3T8hU8HThw+Ia8LP/3zDf/PffcQfvQP+l//xPf72PyyifKMKYlGoz4ALrxCT71WxClMAqjK4KfiAhIoXFDxRxYoqPm5Meo/UEyDKPB/5oyvd/P9wLfEts9PmD1MmU8ar94z3nn16/DyaMdJoQFei+lrO6hpXweMT3bfPg1j6SGP61rUN6GcVTJ3sVdzuPQqQO46JlAhC4fF71tfw8J2uKRaD7lmvyP1uPxwQ1h2//Jd/g8IZpURwfYecGWYyYIhSrNre+uZyBBwCR5rReV3x4K1O6d/5Be5skn8D9dE7MyTM55s3vAQihCWBXbST0dtuBBL3M01AfZV6H5pNZGpTe075OVF+M3oKUov4Mhq57D5ivd+sNlp3CGoQJDubzYDMqKXXRyT9lIs9Mgm3H6lPAiqqyd74g0mhOhhAYYafOngpzoZV4xn82Fox443MnY8yyc1rs/GfLOkMqgPZeBlpBu7P6Ur+/1jIrS8MawuA7nkDmRIBy8J4ty6I1IGWBpaxn0f0xk4RA/G5V7Y7+pVz+ulpZD+V3PUD4OSVvn/j970Nx3tVsjq5cwTNMARUFKhDUyzSjGHWKvX7oTUQ1CxoIE9nYCO9Zxj7w1lhd/Vzzc6YecTGc72P6eA0cFJCCFjWFYyEbTOZjh275E+J8U2WwhcgZAPbFGiUBfFcTmlRgxSaUShQB76FAKzrglJ/xO9++DXiFvD9//FfAC8XBNQByPn3/+dfoOKXoO8/4vLP/j32oiN9upePoAxp85Fun+keRpl/rP+MVzej1nxemIc7M1BrBlFoKUKN/MYQYPb9HvnL19PPjrktHdDBLbrMHKViBEUK7TXAoV2fz+FZhjye1T1qjdTjZfo+vmIYFICCAePP6v8pZZ47XypzT2yl14t+1/kvd05D+QwezwkbuzM9QSlFgQAEDr0ev0eLP39CBKUIihHgMgSnsLMaXFFqQakSSUHOyIgYTCYy/kC5flYZu+mHZE+aQ5ismceypfXDxtO+AxPu9zsASBSHfR/O1nk9kPIIOVvKKh+FRNLQ2BpmBkrpqWWGedMzfFnEac+AQ7fbHfu+Cf0IcmrNe9XkUIvEbcDcfo/Iqi8vL8i5gihhXXZQqNhzEeAagFoKbrcb7vc7tu2OotGfChhcWQHREnm7R/FIqj8TOhdDwnLR9my7OPWpMV1GhSSalq1P9Hb+lD3BjQccv8s5Y1nGfZtzBrGmx4sJMQYsS2q6xBCiplwzXtBAeDrnrLvIjitilJqFpwyEEDQSGTJCVDqHilp3OTdjkr3JUObYtVtluUoVlBg//t8Jv/lXP5O1no8anhlA06oZJF75XTo3ic5hy1XbsyZ7eRm9KG1tNXJB+Inma1kbAYJRKwihIi1GO9hFfxvBPYGAJUWUpQq48oGzlVYkz0SZSwK1aG5EkhpRbABGN/rcEj2o88s96y8+6bONrVFfZpEtxBGvghMQKSIY1daUT0HBMlx2TcO0SVqjbNFmJPKLATkksgxAVLGuV4QQsG13jZLFQhOpYtsZC5JGepGIWmzyguP9iCB7PCbElJBixEVTvxmwrxAjQ8Bue0rtnMs54/PzZwS64/3771CK6Ot7+ko0ei4/R72rp7f+e+v3siThKWqXt3w58jY0yEWz3g4YHWL97CJI9B5JKQcIMFTu3VqqKcKyJDAFPL3/gMv16duX0ls5LW+AmbfyVt7KW3krb0XLjz/+iOfn56Y0Nu+glBJKLYIY55578unpiloKYpAwq8yMbbvjfn/B7fYiOY+pGxZKLRomU0MDp0UM2qoKJM3PGQIhcECoAUtY8P67C/JeJdRsZRB35YFXmoiSJEk6qGLfdaNBL+MXc1hgkLKsTWEjzBmg3hlQAaMyKmeUO0v405oRCMhZlfK5oC4LwMCed+z7Hbfbs+QLJ0ZUAy03VbIqO51wb+0yProJlD/BXGQGjma6JJNzzQAEAAXmVyjGlNA8ybwxycbscrkgpdSMDDFGbNumn1Mz9JjCxYA2Mq6aBxfUQnuah/MQbcUp1bxhwivlzgARVux7C/+INtKhCfoGHqBm0BahxcIjU1PgimeiGX8Oawd9vZvAL/V6EM0R5HLow3SfVxKdKWPPFLDzGPZ+juVsrOb6T6+7cM1jUXNAe74rYsY26zw4I9j83hgjQBFgU8KNSmcL2WmlCeOaZq1W6nt6UnDa875vEoJZFJijl/o47iOgxYw6Y4QmM+I9tsZ8zR72Huz2jBkye5u8kvxMydzNKEJtZT9SU4h3Q5jcxzyuRdfZ1i+LZjCsOf3BifLtzNhrbR/ay9pKMmNpX7fzbwO8+HGY98owHzqORLZ3VZGhRUCdaAodS2kioXB7aHqrz84fP+4HIwmxKsPdbOhcGm3p3laymgIRLusVkTOoVuz7C373w68Qt/fYKeNeLnh/BX7x/oqC58EwWMEoCpohsBrG7HyBu7MNt6rAZ6WgKOyeKSOA8ElVSgURkQgZjBcquFHBDQU7VRQXS8a/6RWVFuDa9vuUR4bXn1rXt95vI+j7dFYXtegvx9n42ggHfjbPvvMtIKY+/lq/eTBK6G/lCKZ3e4phVwKOsRGMPWE6me+jLn2oH5BICQqdReQALqTmygWgBFudjAJRsRZUZI1Q8Xim/LkijRLgtnho1sM+PRrm+hk6etpNNF7BsN7Q1SKSgFU52enWDO71xr9g9NTxWEHD9Vu6U2trVCOI8UsWMrxUKLBEeFfj3+zH8x217KKsRWjPhBh6fnvlfxu9AqFWv8vEaBODGnwMPaUGj055ALBGqApJ+eugYwM5b9Qwp5k+9JyZ1rVT5lq/mZUnpG4gMYW2n+PL5QKgRySMMbYxncE1tm4MUC08bTeo1SqAYUoAdG0YP2jGRomwGBpP29dX5+2/rZxRUTr5zr735pc/BFV0/KyTU2ycKAb5IUZagKd3wHffAU9JdnOLKqOf+4r8MtUeTyW3b0+p6PHOmb79VNPM3KYjtfd/H98yU9izWj1AqO+dDkYzKcRX2tP7YRjXPrLzWUEaXUZoqIFDzoJ2fXmslLbN4CPi1m7jLCQqjtzFamCuHAEKEomkErhK9Fk+oe1dNtM3M8PSq8YY8XR9D6CnbAJI0s5RVHlbI+WGgHVZcLku2GsF3z8j5AAuaFGP3FvBRXn7wij1jhQXVBYjUXE85xnPa+2cv/N9ePRcH2G9TjqWrr4zsL/UazQHAAuNvl6uuFyuWNcLQgi43QPu2wtqLahcsO8Z4NCiAQDGJx/BCn3sFfwSj3qZfd8b+MH0Suu6tutevvU02I+Nvbfx927M7Jqdz6yy97JI2olubA+H+o8y0lhE9niNLnX657+yFW+yobwrtH1BZOlYdZ7t/Gt19rplPnuEvHHsFSSq53QICRapV0dPwWOLpDwniSIQQ1BAPmFJUHAHNEKTyNkCbCrCw0TpU+Wqeg0bx+yclUymIsRIakwlABGBIkJMrWdnRtEmi3EFKiPr+e3lOR8dzq8PUv5jY4lebdFEmAGu3RnLIhmDA8gBgQzTY+263+8AcXPOkvQnwt8EChJpYzrADUhrjiNjpFIBiuRSdEwD9n3DDz/+gBASQkq4RovSUPHp0yfh7biAoRG8SR0F2fMOhL0IVxaIESzKTWWEKmuqgsAcENIFXIrIeszIRXVL0XRgKrk5B6mvKmRro69Po737vqv+hposr6oYOSODRdiQiOUhSLo44SFI15rfX6aTtEgxtocYROK+kfOO+/0FabHIVwXgqkDJBYQKQNZ7g7Cxi7Gm8grXF9QM1Ly0veQ73XeYP/P6/7XJVvI5E8MPaYsq09/sPo9S+KfPP+Byu+Bp+QCuGQutXzc3rpgaolZLmVNBxPiTP/4eP4aASt1JxgN7AAG/XJ8uSHFFfglA7TQmUAQit/mv6Ppdi6q1LCtS+n/Ze5tf25YkP+gXmbnW3ufc+159V3U3drdNG0sggYUEEkyYMuIvY8Q/gpgjJEvMECDLA9O4sdWmqrq6qK6q996995y998rMYBARmZG51j73VXVhM9h5de7+WitXfkZG/OKLu1FZzri8XmDGdqVUTVfksdddD+71rP92T3ZWI6BSGcjSJiYxNIxgxCUJzaCKyhlUFKvOG0rZcL294nZ9UV6lNhoraZJOknqMkqZqrRo5384zaULONyyrGfIab2LnH6ESwKiopWO2y7LqOS1GIGW7YYM6iZWCskmX12VBBCPfToghKS0qOJ8CzuenZuhnr8uSkDOw5YptyxI5p3j6OsrDhmfLvUv7TQxfxejxcrngdDoNjgomZxktMT2ArQMA7fwAdRpKRIgTrScSYxlJKQhwlLizRMCWRe6NalTz/ovvyjmUFjzKH6Y8DGYe5VEe5VEe5VG0MIsZhoUvznnrYC8EFFXYpAHxrF6lFAMqC+hCIWjYUmWkFULsqhmAgijySslNOJJbCmIAPv7gZ7h+8RskrPjjn/4HQAV+872f4XX5ACJGDALem6AuzHZASuJVJF5IrKk0DDSRfnrPV7nTfPZMwa1MuAeEiRqUCe5gCoOAyiicEUkUFQbolJKRNdenGBJdUHKWOs1imgKKASuMBn4YQNWU5a4dFhLWmHERsLjJDTMY0QQQ7VcLqTvUw+O1rWa7bgT9TYlieVuXdVGlEaEUjSajIWrX06KMd0YuGVGfawYzzABbomkDB8IkIimwJG87HG2CN9jPJ7fWQ8czpoiY4s6jmHRdMExxY7+YsGMipKVZqC6PMtC9q/oYmoGFjSa3OXJAuANYmQGvVLGrK3ejhEAiVAyGKk0htQc4zMiqGR24/vbW7kHcQVR1e9cUUqCpBmYFNdxzIR4Iflz8jHVDnj4uI0hj64PaPTZOpriTdRnauNh+ZtjY6/4k10/WHW7CYJsrmfgQoqZ6MPCx740Gare9hPYsAYEYoB4VoI0v2/wPXWv3W7Qse4bBLX0tKf1il9RGAT8b7xlAbMYbM/CgxmBBc9MbNejXOgWLR3JsDHT+uWjEpEiIFOA0lUM7Wrv8fj0A4kaFAbUB8+0Yb7NxF3DChtzoYBuDoR1u3nSdGB1rEFdrQwe+bC0ZTRZds63V2oAhOVN6H2x9ST9sTofJaGBjxz8nyDyQzDNJ6r/tdsESA8JLQilXRE4ozycgrTDU1+qqkLRKATwoJzE8wY+oroXpKjGsqHihTbOni6FMhBh9vEIMZm6o2Fpw5xFODK22ubzVovm73Wo+7MPnikynHrQARt/58br5eezuu//U8fN89VsGHke10GFLfP19/fT5axzB2CKn0LToQAW1vbc14NvdR4Zdm0aAlyEwNHOPKDPMLNuzpxnVddkUt1CDGU6OjrMY4rCcEz3+zdvjAvS9C+hZonwmoRuxtPPEaI9WPRpK9nPHmDRbNQyo1/7IH9k4e+Uc4OsdaXb7g/Eh8mACufQipB523itV+hVCACOiVvFIRlDDhEaXWUdZFL8GUgZYpAabX/X+8/0J/tCytB3WL2tHcGMEMCqILTKP8ThyZvW0UTYm3fOZ4I2Dx7HyfKoNn4/U15UskurBeHm7j4IqLWlcE20OefbkrwPozcZP2TNy1jDsFpksqGc61INdr/dRFHSOh+XL8747WtedTvkio3RnHzDA07n87cu0vwb+rgKq9G1zRaHJNKCKlAhf/yrgN38VsFBAubmIMuzT+s1n09Cx1vP5TBnbObWcsLvWX/Vtzomp21P9PNHxQeJozziexfEuTyfp4HtPc4WMyi9BDS5nWgz3eRzbo7VDO+MQN+yuH/szjXdX7vt37/t28nLFtl1ROYBxGpRHtVSwOqgI+dKnGi3WRlfOgjmQ8EuJSJXkui5ZPN1jSGogFxGTYBen84L1FBB+8X3QT5+ADCCnXVsDeupeAoPpBgoVKOTotB/jdmAME2in8iAjNNrWz4nZcKbRMTtDyGQWO2OqPlLlMOocp5pcqkf4CevpLArMuIhyi8Wwr+QMr7DzI8CuO35lM6uBA3teejzPYoxDxA0v91qbuwFFVyL68fGGpZIue1p7JErdWisqi+I1RknzzXr+gGYZoo/TWNj9TO5JfSJpvp7cvA/7yZgHP346Ry2ik+1Vf56inT+l9NSwA24RRJHJhp2pMZgY9/cNEmNShXVCNSVmYASWtOFJI0HImcQi2w0pmWQHVBYFsHn427ACpIYaSSIlQ89+i4JCUaLbxNBxC9pHxG0GEFxRq6a4RDcmnqMdDAZXZBGaue0zmW9ZZzGY8YreyxVh4L80kW2LziDpl/y6bFFH20oYjV7NWGbgVdzRawbBy5I02osq8IkRSfeSps/abhnpOaGFbtQ+iVMF9bmqVbAA5TMCydwzcZOLowJppN8LT8AaxYUbD85TdNA29ein2/7k1Xsdz0whIMSIaEYBzoBL5lQ3g6YXqtVSY2aN1BHBMaLzqmPZnWUWcQdVjRs+4fXyEWcEXP/NFyjfnACwGoBHfPnnN6zfuYGxijG0ciIMeabwnAUoN6AGMJaD5/vP5MbHcdEkziYSWUZeh/WA6azlfm6HoX4g5ytyYWB5kjFpBHk+uY+K0RnpayUgRk0DxawRS6wJ/Z99JgimfYoRaSVcMqNuDKCgUgZC1GgtarinklytQnBD0DWh67cyAyEi5+qiqmQ5f7gqvjLKR9p8adPwfcdubUQNB+xFORieUqcSATWKoRlruvfKYCoiE9eCkm/IecN2u+B6u6gxR0BMQtNiCIgpIaZF+lxM1qli9JsVx+OK6+WC9XTC6bRiUVq8bVuPzMu16SrsbCwxCh9UM0oFcim4hYS0SMTGmjesMSFFUgMRMTjbSkEtDCIx6GFm4BfvkX77DvH5Cvr7L83IUda+nfHOqRNomFbjbc35wuigRsRhyLlyohMYFtmsqhW3jH0gAsWASASmAAtr14+RAKaCymP0JVaaEVW+IFhqtS5bJbminRFLWnC9XVFLj0T/KH+38jCYeZRHeZRHeZRH0bKk1KLCgMV76Ha9NuMHsIYxZzPgAEAiMoQoIQ0rS1SaZV3EU6VIJlbhCxmg2oCWqFbWgLmUZtTMiInw8sUvwBTwxTd/jB//9D9FYsLHp1+LwYw8Vpj5JF6q4nmknhYmPHOVUO/gplxnqLRv12gRZQRpyEmnVJ8ALCiQIQKqMrtaVaDQFD/2eykbSpaQjrVkSPQAjaxCCXDhXQEVmrSdBqSYZ0yg0OomZfA7EG8gC1x7+6t8p+C/Kp8CRbsRorwHgC6A23O74mlUCrXILwRN0cNilMILdDaAWhHTCTFFScW0bXJNKV3YrRUUqc0pWp+pzV1UZcvOE5hN0uQ+DgP4JJV2r24NM21KIGbxsgGpZ5XV3YUXhW7kfm9wY5oTr+huYGCfG1KpjnR8Pfg2etD1akFkbqMdojPBtHojB1uXep1JIFpXS19Wu5FAX2vmEQn3nVTWvci4rQXb6w191HGawSNdZH2Ltf1o4C63H+x/M36TNnTlv13fxqnlaEe734ebDyHB1ilDgLhqkVSseWThRkc4lBWsI3KKxd6oBkz3tshaq1wVjNJ+O3C5gw9eoadiJgMSkhUgVMCAcFS0pUuiJkYTXMXztgEDjGEdiBKEGmjY5lnrjGr8Zp54JnhaLZ62CqZFunZkjEII4FJavnUD3hqN16gKbgm6NYG2P9oecmusXaL/2v3NfshGnJS8+zaT1q3erjOwajTQgfzilarjYQYUbc+GpkwygFh9pNFTDQhAWYOBHM68of1HrgPdnME8ThvY2OaLBKTgCoSqAJOeWxBjpe3yCtQNOa7YcgSfTwB1AzVPAszTraVmmIoH7TpVotbqAPE629RohsG4IbZ0DjequGnMj+Jm3j/NFDcDQDis2eN29ff7K46ARzOs6OaN/tpuTiJLSear7urqbeej50zKUhdQA/3k6ZRtaLMP4e1SOWG6dyClbtDs7Twa4xx2uurrsugvjA7gFvcdK30m6jvPVu/8FN8+v1NtX4J6xCI7BwSQd3e7yANzpAPCAqCgcgZz1moWHWy5Itj5eK8YU9Z64M9ouHO6n8sMMeJm3fSeA/PnhymLTAFh4wbAKQQB1NpSVeyUhX4MaZxR1meYtzzp0BdPN3XUGaS2SOItzHpWgFj5OIbw3OT4PKV3pEYsFoFIaZidcWK83XduO7bdKuA2zi5svuuJAdXi5W270sBXz1v6nejHxRvN8GHdRPZZ13cpIqOQeT7XxseSrXGyeRSjS28EbZF7JIKkjEkMSbxLbZwgaQ0kioxGSFKFAINAIamHM5RvsvmqbmwddTG+Yubr2hUj9fRroFO1mVr1675NGYy7dExtrEx53MPmG6+jazRI/4GAGBgxML76dcAv/1XS6DKS0s3O1HYO3msLIGuYe5+O6OP4mff2jAfX/y7l3qjaOTCOdD9j5ut9O47aQwf3+l/nk9NHKTMp2u6THXtkLNNPwiOzo7fmYl59jrL37/RMO+7j/gm1MrZ8AZCAYLxikXRfAAAgAElEQVSYKM1Kraika4qVp2W2bJoIQTZzRWlnRCDBKfo5QwBFRFrFYCZEhBgQozxuOQWEWBC/eo/1r37cWukpjfGiLbIaASFWjcAyj0K/k5S567ICDd2/Z0C5S1Fk/4yOk2+jzqLJ/egpp+zcqvpdjAtOT084n5/U81p4/xQXVPXwp2Aza3R8PNP0UTBZorI/y3o0EC83WppTi1jsI6SZcj0ExQPcaPp6pO4+TmypS1paQKNZKhtDsIyqStiWFohMxtyfwW283Sb1ctwo4DZOACDPacpPzVyp8W2eznGjbXB9pfbe6HBBKRo5o/EQ2habH4fDxBiRFknNI8YBEhUzLQuSGtKUKoZLuYqi1iIuSeQS27pqMEBVIwYlgKLwjBUIahDJVfCbuCxiHEE9ap4ZvNg5YvOkLIiMgp7txNxGxdJtlmrrgNpaGedoSucRXbtR3TyjRTS2+xqfwIJPCQvA7vcetTRGNSppdBMtVaZngygEdUChbjSkvCXbmqI4Rn9VP5MQBQMUw+IqRjQgTRETUTjqGUgSmqsRAG68l0SXMQNdS7tTxFDQIjJUIOg9kSQCzrZlMRwaCR5Mlge7U/eI/XBjCpiMTIDhhkQo3Pcy0PkEc8IzIziL5GMOaiL2mnE23Pq3B3d6yjpnt+2Ky+UTbtePOKeEy0+/g+svxrQs7370CeH9DUxFMdhFK06osDMog2ppa3PoL/ZntXwvv1haI3NCMPnbS4aHZ7zKruaWZ1fJ/7rfmJHiAqrJpJKZK/AV7l4rkRh6OqzFDNNGerc/6xcAxAUpApkZYg/B4BAlKhyCGmyZPGF7X3jwEAIoRkTId+upp0atIOHFa0EIhinySKONXoB366FxvxMDM9P40Tg1yJgHgNTAtrAZChaUsmHbbih5w5ZvqFXl0BAR4iKR6kJESiuIxFEBhBbVKOetyRBFDTeXmHBaFoQYsd02MU414/xSRAaxaKNF0ReWtFalVGx5A4iwpEWiysQIOq0QcwYGRWBZzyjXK8wALMSIXDLqr86Iv3oC/fAF/GevuuUJFCJSJMGIQuwLwaIpG1bKwq91BwyT4QBmpaOKXbbJ0WtJmDOhA4Fgbi9mgNiiI1IABdthxmuo7OT9VqE/EgCqdnV3juaAUm56HjzKH6I8DGYe5VEe5VEe5VG0BI0KI1FQJGXQ5vIHby5XcUpRQwsKM2d8TIgBaU1YyoJShKUvFj2kceXqCVQlPCZX8SirVCVsZAYQCBURt/KC2/oRhQMyZRjqbcyQMOmmgGY1eiiaIkoVmc6wQxSmRb1SVIhTAVaEXyBYfnRBtbuQr8YWXKuGzDehH4r1cQfVIFFSbrcbbrereP4GAY7l4ggR0kRAs9IVCCYGiCenebA2xQx0PNuMDP9Nr6aoMetsBV1azlYBd0I0wwgFeVS4L4WHutozFdxhVVqUWpEoYj0tCClhKyIcLaeztD8XgGTd5GKpn4BcC5YABbwKuJQhJQFRD7kc2Alalnyd2SknJrGRREinICGFmwILMn+1mBBgQIow3QaaADww8b1eL13y/rvBMKXBqA6IdGtPAS7zDjeAz8Bawet4+BueN8n1A4gIwAOPfnT2nhiuaTqv/dcqgI2OVbu/tcXdTNNoMUAaackL5h0AhAOA0MDEGTBthnvQUNuFNbx7p0uSCkMAG9nuBZF8tBt7dh+byiPQy+iKoCbwERAQBbdiZwCh1zR4xAHfx0o+0tfawOeGWOh4djWYtCFGU1pWNI0Qj3/NhMOBhbYGBmVXo+GqbDFPPzWyaffq3DTQE70ui9rTolSwRKloodX7IGvX+hgMzTagn6itde/lAgVf+1h32mdQUUth0pTR1NaZPZCbgaQDMm3pGp3XqBG9qdT/Wh1dyW7XEIn3yxwWH0yCyUDHnHt9NIHsBl60PpLMla0R1ACKcmbUXJD5ilAzygrctjOuGyOdK77/wwXgiN/8emsjpFm6YSaYnvrcg9h6gGoN6a0zekFBIcYVxVo7AIMN9McM5dHwvNkfu78fEa++FI+/9+NnIKa1YzaE8Ve2T6p4MR2w9Sm4O8ZihOtoPfP0rP68ub3tc4vMdV8ZfNzPoZbdNf5/nybDqFaBhAg3D8jhdGfZU301z+ZD+6cbJ9Harpf6va6sF/wK6LsezaBLflU+R6MHCKMRlX8hmLJPvASPxwHAjv4SzRxTNw0iIokWEs1Ysys2qKCBe61D6JV5PsUbzhj/ORsZ+1SJ1k7P35lhX5sX9aDOLlx3Y2eBYWczlB8LwuPAGzBaqo5K4MCgNnbUzhAxHlZvTCNbwXjgI8OV/r30dVKQEDQUuCpGNUWGfO6pGZhdSjrbj32jtGd0I5t+jY0HtO9VDU9CFGPUWriHCnfz32g2kUa/cbylgt1EQccEgPO8DyFJ6qgEWJpUQNLOSp2hnRfM3YATg3lD31l9VGngHdsI8Ei7jt9/7rujOt0dbj02NlUYB11vntfrrW5GNHpOhsgI6ggxrpZjevgWzRy4p8HA8OD3A+rpzyJ/7vkr7hejuP1Kf783mtm3qJsxjb8ct9Jf4SnuXOtwl0vjEtyZ1A0P9/e3WWs/0q5ddi6C7TS/8/zhf6OP40k+ji47w02AuaCUG0AbxEhSeFwxhhFlUqO1pEYrxh9XAoLx64IvMFn0Kkm7AgQEJIRwUuWxGnPFimUFlqUi51fUEsB4duMznYkgBDOoDISQgG0rUBOwdrh50ij85aj0I5hCfW8E4ItPBVvVixvmea94hEWZsXPK9qkKvLpQtfUhYllXPD+/w+n8jBiXVn8gifxRSkWEGjFWAig2+V76Y3S600we5CYM55o/Ey2Fs6/L0pyKIaXxKWzZS93YWZQvbs8xln0+j/qJLpXkXNz5YLybJh+b5sbaNWhhbUVwXxEjD9GxlB1fZDTUvtP/bP0aPfdT1/rX5CKLtkPNeKPLqEqvzegoph5hRg1hUlxb1A6AQKVgPVcgS8TSRBEpJIkSWrtRfdDznqFe/UHSYsr7oGcbKy6z6NkpsteIUcgAVDOAsKiosKh8IpfIOJV2fymsz5Q1FC0VB5lBTl8TbvbA3FM29+/k8y5tGRdIJOq5ze6aauvaYy9o82YLgvTVZFFbR9XntyNJDVc0JZPgW3I+lloRNJqDpaoXZXRsqS49PiLPMwMlCNOuhiYSZTuhbhKpO6UkimTSvVWFrkYKKABC9XwmoZIbp7uCixthHb+Wtl3pYalVIl1gQ4gJQelATLJOuYa2VqF0tfPJUrfgc7YWqY27or2omVFeGJUlrczttuF2Kci3glojkPd8BL9WhG1DPDGKRjZjNZohTeGdPzCoMspFx2ZO9eO9GAYejidjmfEqPhpA3z5ipHPBsgQQpdbvZYkgPc9iOoG3CKhR275Gcm20z82ET+i24zNqYeX9lZ9ovF2vj3IAfVhQt4JQCaESSqjg0wW1ELJi2cAiModG+wjBUn7JX5vjIMYckoopN4c25oAUGJU31GLG6iMXxsOEcnvrDetG+WPiQOx7vZGqGO0FWEq6DbWKsUzOV9SaUWoGSHQeRAuW9dSidi1J0uDly9bOCQbjtl0BZuQsqZ2ezk949/yMFDVl0pbFoNOiTZVO02qW1Ii1SrRV0bGUnma2Cv2WdHIMpqKRpYC0nrAiYF1XNYxllJrByxX1xEC6ILa+sq6phKjnjhi9Roc5Cl7FzKqjMUywEyMKASkEdaRGi/huclOjwSbT6rmFqrgRQyMLWapCMaBqtIDFUYxRgWR7T81sWBx1uRbBZQngKrSv6QQe5e9cHgYzj/Ioj/Ioj/IoWkrJLUUS4LxbIco7D4hIqNgOZOSyNQYlxoTn52eUknG9XrFtmzD9BE0zUVHKDa8vn3B5eUXZxKI6hIplEeYpLpJ395vzr/Av/sH/DKIFHAqQM7iKgYkxyZYWCACu1w23263lzwwhqNDJuN1u2Lat9cFAHS98d6VFUOUrwQRv80QJUbx4uBbUukEAjaRhLkmVOBW5VLy+vmDbbiAinE5nDZUqIDyR5VcejSFm4d48iIhIrc+zAx3C0OZRIePCoapbtIXOt7pk/FL73D1jHEDFFk2mh6c3YyEReMQ46XK54N27Z7z/4gucTifUy4bz0xnvv3jX89duG7Ztwyn0fKc5ZyzLgsvLKy6vMj+n0wnruqKUgtfXV1wuF6yrCinLgmVZJC+08yIbwTFu3kUpifBZSsGynGCCQIwRl3xBLtkBfDZWFtabATc/pIqYwQvwYN68ksx7JPXb7DfZF7JeRVjxQKBFcPHP+TbFQghv2w0A2vqRHNv9utmTz64djLOcIsWDVR7w6OM1huVuQq0bHxuTGfSa39veHjyzqM+T64U+7whI63va1+MVmbY2Lf1CV/KNIYGbAZ4BofoaQ5SQ1UyA5nkn9Sjza8LAUG1V89zwQLKFZW4ArI4BGh2GGBi2ehsUpGu3uv729Qed++226T5YECj1sNZzeja2NC2i+IshKZ2XPOhpWXU9iWKxh2D2Xu84WK994pri18BGp+QxT9ROo2Ibb2sjTZocT0O9oee6rgrElmFMBy9FD6rfVRHZXtgL4l7564E/CbVr7Z2+897E5Nea0vIoSiTiCFRCyWLMertecQuMQAXf+fIJ1+sNf/ofRvxn//E/AK7fw3/33/4bBymIP3BVwNRmpvdUz7e5n82AQTZE0SsyKgqZ0eGo+pVIAkdjR298wjDv8/dH1wNGcTpkVl2/LGi/tElAxw7fT0oSCI2nVqcYtYWDp5phwgTJT5/h6nq7kPsD0JSJ3wbmma+zuRja4hTMBuiKkYxEBMqaQmvug9Q3gs30mV7ZtzZuRiZn+775GYH7cwzEvFyuCKvtVVZDV4YG+BLwn6BpwcZzeKif5rZKK2rtZ4tXqFhYfb+HLW3mrGAbFKEOoB1ouUujYHTG3zekFQidj/Pgr13n+bW5GD1krsilyBnkAOVaa4tqaFED5b7aQFjjoYVXYjBnlQeEDicFhmc66pVY0fFF/syVcaY27vZnhimeF/fFp6LoCtv7fLIpEu3c9bzAPG4+PLuk7+PuPe4Vk/rn0y3Ys8yD22h/MSNwff7tJo4HRAEc2PFUQpV8nX5c3i73fp+pwd+tjFtJz2F0Xs/ObeNZKBq9ZURiMN9EEYJFHUNHI8bd85QGGf3w1x3RseM69hSKnZqKp9d+HuzphJtpd/+eCvKsTJMv3VP2bdx/HhVUd6+anuWjxrWogrBkFnayKA3wyiX0+T06L3wL5hg6OPzEIDUomc/GfpUz3GttkbTFla9Y1jNael6LJKaey2SRnUh1b5D9VyoDcUUKS3tSUY9sQgIhAiEJnpAIT88rlpSxrsDzc8Lr7QNePvwSfPkxFnzXta+vM79W7H1MYsBAiOJB3yKndLnlqJi87x0O5rNjlitLqaAgRtk8GGcInWnnruNLc8mQVFSmjGas64rTaW3GDYCcT7loJIoQW8rdqmkXrM1G24zu2zmRkqhRRAaXM8KuCyFgXVasp3W41+6R8yKhlNpSNpncY+dmM8B3RozNiFwGqEV8JZL3lmqibBtyzmIklaLwsLkMNPZIlh5osDOUmGVhWxW9Lj/H3bjF+ip1WBqMNsNtLnqXfGpYWxt2XTcmIJO1pzPYxkyix3TjLJsvogpQVhxMsJ91XRCoYrs5ZwrqjgcShSAhBEkn3lLnqDzhRGIIDqBRU5Whs+ic3jSPTZANATGIc5nhYKRGb+RkInLj6M9uALA0VOtpRUxxiAK8LMsQ1ajzI6y8TxjWuK3Rvh7hcCbHL8z4jptvz98YPxlTarJDqQzSlPEhBHU8VCW3RmN6fX2FGc14DMhejY8ohVWW7LgFBVHuhxQk8kwEClcQiZHQ9VpQc8G6mqGI3Cut3/Nhny8SjWJdE6Lu71IKUAIYhEQBaV1xPp+xrmc5KwphWRJOpxPSEiHGS7bnlUYxIYSlGdURVVQUEGUwNtx+wfjqnwZt8xMYT2D+AQgVXxFQy8wJAH/9v30XKwX88T/5Bh9eL9gyoXAEwhMQzigvhJ//Tydsly8kUtKUpkoMgrp86WyFm7GMP+e6gei348n+5J/8Gt//sycg/QDXjRFCQq4/kfMmnsQsijYwzdLebkqmEkCcUFkNyAEEilgXSYXoZdGZy8l/+wW++af/UeOvK4D0R1/h6T//S3x62bBthC0HbJyQ6ITz+QucTmKYaWvYsGgicRoNIamhSEFKCzaNSE8oqOWGvG16jtn6EtpvZ9RwZmpUKaDT5457H4chNcNPZnGuzZmRtyteX1/wenlFrYJJpxQR1ZgjxIhlOeP5+R2WZVUDXI18XjIur6+oteB0WlG2jE+fPqHWivNpxZdffqfRItFRbCiFcbncGk2ztsqZKLyOYfADplQLXl83dQLN2Lal4WPv3p3x9HzC09MJ5/MJzBvev3uHr//8F/j6B9+g1IJ3n97hdivi6EwBKXWa6PkRG8eZ5vqUtQyL1Axs29bkOSLCuq4DbYxBzOiFUUJzxFB48ojzBwwj0CZZxgKLQhSKx5F1p5Huvbci0D7K71QeBjOP8iiP8iiP8ihavMA3K7dNSPZGDgaSWy5sU1gLuJGbAHQ6nXA6ncQa2sANXkAhYLt+AGpFIEYtN7y+vCAtASdakdaAZU2S45xZoq2CEKKA98ZEFw0p3JlO8XzpbasKEnJrk1dQWJttDARAb+pCgPu9gGPpCBpaVCLbdC8ZyfkMizhB6pkWAQtXGqPkQBWG8kgJMgrg/ruiXrQMM2oyo4wOIJkHbwd4uIExUuf4PK+08MKIMMs6CHBAK/vfWfM+OwUNszLMkqZKPJiApMZGncnO2OqGfNtwubyCK+N8PuHp6amtNWO+n5+fW3tNuWXztq6xMf21GCO/yLoNUZlsIMXVCVWhefCIIGyeDl0JJZ1VoUGBn0B9bqzcU8408IRVkRVGlYBEnSUwq6EamVpzXAu+viOgb55LL+h4IdJb3ZsA1kC76Tn27Hk9zH2030bjkH1dMxg892cGn46UYgYK7o1ZeNdfX+c9kPSeUvWof/O9u3kQ1ETRJ0GgGuingi9YVDhiIBJgkUe4Mrq3G+CVksx+D1uf4jR+x322fmy3m4aWLRD6qB71Gs1piYukpmBTaooXnKxJTT0ExlayAFkk+xiBgNgNsmopYvzY1FEGjroxV+WJfUdELX1Jf77cb3RinFOp5WhdzvPlaaD/zhcDjHaeZL9DuavoVBRqt8oYPTLZkbLTlEaq5AYRKFQk9WyqdUPJjNfXqwAeRHh5zagvakyq/1cSIxeJPQxEBkbTpH0RjKor2MipSr0yaYTVqIGGPi8GuWsxPNffifbrPBrjULp90GoYlVrV5mHe5+3OGQ7k1ke7jhQkHRSSQ7v9cu5tuddWgFpqEb/yjvCcbwerTkYmrj/eg9+3VoBOjQhFQIYYzth3VgLMoxPDfuhjNPbfj71vU1OtuwgMPZ2LjvVsLDP1XvYl6VzO4w4F+z9/HvpiZ7vxTcDoGd+eOwOu7kw6rndPi9jVee/6o7Pa89m+bTMt9M+01ETrsipgWJVPl71PEaJEaUppbucGUa/DFEO+bvsuqFf06XRq7ege7XFoiympGlgaE1IyJRs3A25RlBHGVD+AgORvj/lsZCTP71EErdw7y9tZAzGSrs6AxwPEhA4SW7G5yblHh/RG+u7pw3qa23RfGfvvtgz8m9J2WSddaWs73cYwELBEQiQx5iRnplE0dIQB42ZYOac2kGhoaCcGu3Xhz59OiQ7ajj3s7gvtvue7tM0/5606fd2tzUf5oXwdFuHUpXbiaUya8u0g1RETN4PD/keQZB7WI6tbarJUeUfjRywKQmsTtSvH/u+/C+1a4w1MxXs0TjaHFkezGm9s9VZuvDEZz8wamcNkNCjNCwlgi1xBmjLG0kMkxJCwxIQYgRgqTitwOlXU8hGvH/4WAVcgjkpOTQrSPvdf4WTG+4rlmR/f/ca9viO+1RsG2IZpykoX5ZfbuKEZx7f5aecK3JkS1ZO7pxuWMVT6hqpn7TGtmg0EZtnMjFoAS49FgyEq0Pl5iwIqUYZKx2GqRAk5opdN4Uq6hnRMTHkXSJ1ZmLE5Z66q0TuiyjFQeiUpgjpmZLTJtm/pQMAwDm99nmn5eH4drwvWZ85nnZ0NJvMC7ne2lQrZLyTfSYRA2Y9VDZeMCvQ9Q31zKh9kThg9OieDqxqYhCjRPuoYSc+woZbemHtUPZP55iOtrVmVewh9vzRlrFu/R5jBPL5izCkp5YNGOgDGc3jGG5i7wWqLPufG2977a+b5vIdneFyxn++EXCTld4zeka3zEGLgJY4cHz9+xJKSDuC8Zqifwww1njJjIE0FqelSQIwYxaAlpIA1RYQt4+P1goU0TSYfbvtvVcR5TAykohr/pLQgLQuW5STGfilpRA6RXQkBIUVJa6O8bpcYoOtI2kzokZoq6zkYCoANhArkM/Qq9P1liYT7mdloeyEEVJzTDZewIdeCUANSKlhOjK1E1LogZ9KzoA7yEbV/XVa8e56Celrnz2ALdv+6RJyWJyB9CVBAWk/I+QpGAQWN5muR1j9beHof+94mbR9ZuufOP1jf2ugxwDm2bwiMiIB3Z8KyrABnfNQIP0wV75Yv25nVHc+cPMWd/hsPn5KkNap1Qy0k0ayyOIaiSuRG+V1TFhmdCzrStcsb34aP1mMAMYrxa4wBtXanAUAcM2MkSa/EpPzEIm0PGrWn9pRitVas64rvfOdL/OZvf90MRmKUSP232w05i7Gi0ZRZFrFXr6Mw50fmTguMxghmd9M9wri1ugug6+T53Qm5XhFXRqJF6Z0YtyCMDhqzsad/P8pbo/NgW2UOY5udKBpfxP2MJf1s628/UTJPwXBzdyYzS5KCfk50efaIh3iU3788DGYe5VEe5VEe5VG0eBDEvIQ80+E9L7wgX2tpoXQBA2+iXrcgBFLP1YpSMyzfb4wLTudnYAVQGZfXT3h5+QqMgJAIKWekVJrSkBWwBbyywyvXRRhv4JGBF0E8hM2gwpg4L1DvQWtlTp3M0QQ3VU4oBzeAGLWqT78azEDTKYmlugKLFBT0qY35OypHDJ9nsL3BTPutefGOAE4Ls9siYBwohabnTK2BKZoM9GgggV5hSngRCAhpkfzBt9tt6JN4BCmoEGozHFrSgnSOeDqfG+MeQsD5fG6gnxcuupIGSGmRSB+1opYNYBLBXcMUy4VqCODAGIs+Ubm2XO7dy8tAEOclBqiH+x4QOwJougFH7QOlzL0IXRWoEiI4auhjK90bcJqJNwQBW/bHSprx3nGdjPvfr7P52Ud1z2Mxg0r3wET/ar8Na7zt7XqnT7Trk38/07C5vXtl2vj7fL1vo+x932a5v4cVB47ALkAgzAZUcb9WQASG5SXufbJn9fma6wSgobt7exs42AzpROnpo+p0aMT6xKrQEFMJkXNHBYr3svNeez3Whw2a9e8NOgcJweojF/l5bUDvBFC2+ZtA5nnO7q1jP//s/n+rCM57vCfnNUtE8MYiY9Hr1Bix8n4dM0voYkuwEENEVIO3kgmlZHz45gXnpxWBAn7+17/Flyfgv/5vvg/CFf/7/3LBr34pigrJFG7u2Y4UuV67UbyrLAN6JJP9aGlvPTjILUj+rIaZPh2P0r5+/2nsA7tZFL+zfnU3U+wKSd8mHnpvYKi+sp/HPQzp7zlqG4AhfcdRH0eQcrx3vvLoOXOb/FgA3VjGPCDnz74FrX6mnp7joI++zO0+bCUfr4Dx1aLuZbetu4KL3Oe+XY6NZo5pewfg53u8QcpwL/Oh7vstY4dmbEHjd/5aD44e0Q679oi/sPvnPzEmFz7ZAEXx4NY/EkMU4ZWr8oUy797gXNo1GsFIe8ZUmd/2TJ6Napgz5oh0h6v4W4DgI32nYXz7PNzndSkEkAHxKtMMvAyNymGvbPPz2bz7XeSiucze8XM//v8C8o5zq0oi99n4CHslVXqsa8QSCtYYECM5+tSpx0izDuQMdIOLmYoc0bvftcy0ubdvf81I8/YGPvfqlgfw9PYOH7o7G3h4/mgEObXTCONUO0GNH90dGoigGc3sWyze3/008PWOz/B02N71thNoN6JTn423DZoOBipbakRXqtSZ6MZYW8w8NWghQOKMOQMWVQJbSt8UI05LwLIA5xU4r4wYNlw+voD/4segDOCr922c2t9keOoH1tIqHcnunfYc9dl+UBOcOzRiPgfITRVP8yXygCqyIIpJDnZWCG6ypEW95ZNGxhHab2lckiqtS6kD72BtAbqyzBcfIQwALpcLQggSvVLTMWwa6aUbffh+dtmjp8ErzYDn3jganmMySdvP9tmfGWQ0v4Ao2SD2HjJaOj3phh/v/fkB/6w/FK3m/TqbFaj+ezsrSQ0jECSmIqvyFlxRq/QjBNLPtcl1USPGEItcUWsF54KSS8PTapUIxkuwCM6EnLv8acrPJo9iirzIExXgkSKIUZestcoANRwP2LJgL8GlmPL1zkUUs0GjuPS58fJk67/DHPx7jy944y4fnWZuw71X4xX8WW9j72Vme64ZGFv06xACrtcriAgpHeEX/WT09QnfbIY5GRIJhVCrpoCpFeuyIKWAiiKHUktnD4xRTr9N6XwB2OOvQnPWddW9HBvmKthnRFLeAXQ0p9I/ZhFUTfpq0VtqRuVX5MIAzn1ecOeMbDKPnBu//L/PeL1+D5etYMsVzISUJIVN3QK2bZSX6hT5U1L4zIaq/nnzLGEn+xyPpsiaVAO4JFBN4NwxwVo1iS4XjEkXjyRSfe9D4Cg2056j+9aO2rHNs4SM4X35+gkf/9mfogDg7/0cwKtERmE9nTX6iO0/aX83pPO8v/DMAVwrSgkoMSKEjLRo1LYqRvu5ZJScwZxhYZWMH20GUix063OkmcFCF1n2ikX2DjFgUaeDWiu2raJkBiEihgUxJgA9+haTGtu7fVztHNW+p5jAXFp0dYJJaPoAACAASURBVE9rZhph8osY8lgES7tO2ujpQS43XK9ZjYkKtrwhRIk8g9fv4vTVH+HyN0+oX35AWCVNUoh2NnQDNy9n2pyMxWTI4PDE2s4P60+PUHonEqlFi522PLU1ONE190cQeVau8vKI8TOjQe/vFy3rUY7Kw2DmUR7lUR7lUR5Fi1dO55x3kVj2QI55mcyhxSWdkYWg7fcDzLEJVkQJz+++RFR11rJE3K7foCIjbxbiMCClihTPsBC0gDBXldXHhgCLgtDaZoydgziNQfT9teIVFAKghKZI6P1SgZglSoMAKsbwVhUAGOYYZgyleH1E7bNF+dCxZvWmm8p9BYwLIQ+vcOj3mXA69s9C3PY+mdL8LYOEfi/avR4UtPldlp4XfdtuGlaSQSGp15BX+AuAIR7HJuaSplyKGjqY9JrUmXQXBWhcb+IhVVoEHUIICWnK691Du3arfXtOKQIY9fu7MMrcQznPynf/2StV5vGXdEujEMocwBqal7kCJMK7CZUSveiI6fcw4f43mR7ugJk+39ZfL0eqA1fTHanzLaDQK6v856PXI0DQ5sM8rY6eOX//uWeOAulYZnDLisyHAbCA7VfFhtDTP40gOQPqdTeDvdZ+VWMY+D3p7wjiXdNBQlkfMp9+Lfi9PT8D8J5+IrjLngDQhHCgGxQxWOgnev9KFgyNAVSNhW8gi/2zphhgYGO0U3a0do1zQJjmjWysq++YoxM2zgxvxHBUt333VvQnP5z8xr4yYFhR3s+W1l7qUQzs+xFg9vSgeyPKcwgSGSY00DEYYJ2ChBB+uSJvBXkr4FxQf1jwD//xTxDDBX/xLyr4l6ogIwCswDoFhGGsprOmq14GINxTr4ORNpOcoVYmi8zlqc0duvK5MZ1e/fveNlV0EYSWoqdo6lDgfcXnWDcrMMNTFID77ZvrHEkAD8ApYxwTYoDe8EScgVlfP8PXx7vvDSwug9ri3lP2O2GGZj9zAoGGOrrq5P6J07+JISr8qXcH4eeCRhpksjPO9knf2/eUkPYIH/EGMODO+EMfIjo0Wi8ILwO1Hj5j5gvaedDq3ytHPV0alCqOz5vLbDTo62rtqIyqvDaY+k62M6sBkqx9jq1u4V27MbIomvo5LJ6VcTAq6feO7fEGF/M5bGPf58D/7ft1VPyzdzKJq9OXN0FhfxTM83jAb97r39Hz5nreAqZnfuhe2//tFD2D2l6zfUEgklRl3nAmBmCJwHkhnBJhSV1Wk79+YntaOdOU+VzEdN0fqhzR66Pn3Lvuc2VIQUXYBbAjNUiUZ+xPJNnCPIzfcVvt5LPvpDb5Vka1c5PGgc6UGe16fyeGd60rB98enz/731ydFEAh6XoyYx45t4V16qnwGKJEN96SWOR0SVupUfjU8zvEgKRpSc5LwPOJsCRGCjcQv6BuH4HrhvCzf4jymnb8RB9zP/Zw42RGhyavaZ/6UbQrZBohsnNhf14A4/4f6cA82nL2EYkhtRiRSFtCMKNTGVtLlyqRJ5Qb4AoiiXaxLGk0oJ8e5ZWeI63eG7L7e0opQyobryDUi9p4WZSNyoxEPmrYNFZB03SprGIyQlfKitENgJbKlrkClUDRnfztzMBOrpLH3j8/3jrXZuMJf59/9sGAHfIIdj+5fjbjVQhtNopaa0HJpH2v7WwHgFpEnhIZzwwXRLaoVVK9bltuRjPCB0SVOySVU61FFcZ+DK2dx3K+dm0gfqwyoWFHcmlXOBeF1yLGcfYRjOZ5Ebl5jBQDoGFIfjw97zKfyUcOQ/P6vscXtLEeZGEbj04xCfuz3DDXWiuWZdH6hb7s6YDb+1GjVceeMvN6u0rE7xaBqKLkImMaBXOK0fBMNTSw/dQOY5Ptu7HIwLuTyadjuwyf9Ma0oUW3kgg4kv5N8NrdOnGjBDDAVdOu9hbcbq/Y8jfI1wjCd4cz54hme/mHifHrv1nxq79Z213NiMQ9xWQlM5Yx5wuJeKN0tt3X65jL23LSnqonKkB9QanfgLCCSxLZw7k3SFAbwogNsnt1B1L73Ec1kMqabFwCt8hyvs1Hbbf2lo9nfPiLP0IFI/0nv0J6L5G/CrMaRNjIH9AHMt1AN5gBJPVYTFGMYtIYIayUrEYzYvxVNDUP2RoJ0PSOrA5r86nuWy/fSRTOjNt2ReIk2wA9Io7hYaTn57KsCCT6i8oSvcX2spfhLpdX5G1rTsesctWWi6SRVPpbapc/G77U5LaO47ex373v49pwvihRc0KsoNcF4Rc/xhWE+o8jcOpOoIDgibFhjQe85UT7mPfYa5/f7nBifIEZB/m0tWzXN/qC/p3OUWg4ICn9EV2C6GS6YQww0nJf7snQj/L7lYfBzKM8yqM8yqM8ihYvRG7bBiIxYjDvJJ8Cp4MhFSGOjJNnZoZQwSQgVimSwglEeDo/I4AQifB0XkG04eOH3+Dl9RNeXz7hdss4nSvOJ7X8TsaUVc1prqoZFSKIuseQgR/shGAAjZmbDUuasEfinVUygVquWPNYYqDYeBWUkvXegGWRthUXpj1GERrBhNtNjESMae0C9+jR6gGZI4A9hmASOJqBBVjSpKhVeimidLaQhSkZ06peSMAwp0dzNwJiXUnVgabe1qRetTlv4CJRXi6XG1KS3MUhRlR9lhinnLCeTiKUVBFcGMB2K+Ba8e7duwaCmfeNt1j3eaUDBVxzT7Ulc7EgBAERQohY13VU/JCE2pTJFAE4RvW8Ct1LuJTcvLWotbUM82Fryofv3SvReNgLMv+jZ3mt/h4DMMaUA359zG3o9QImAJlhkPe2GgvBjGnMAMTaebQG7yltbO/0NhwLYB5I8p7qvv4ZkPR99HVI/0YgdwbsLNz38TjtAVRZ566/OqD+dwEnx/kGmae+tdP+9qCnFzxFSS7ri53yd/TKMS+3w6H3PUIpx4CfhHcWmmBRwWTNm5dORUwBtQbxkKmMUjZQkPC3oCl3e+skUFHAuaJUMbqJtg6or0WyNlUH6MjAiMeWoKcKLkhajQGCcticKRysn63uaY/Y77YG5jU0FMPnpjVkc7OHttyoH9Rn9zXZn8f1hoAWSpvZwYSNpgbxtiZJoyJewuKpFCMh0oqcEr75cMXHj6/45sNH5O99gZACvv70DdaQwfRDfP8HT9huwMcPLN5QCqP2lFkG+OkQcOjpdNzfPAIjXINWF+++7dcewVaEt58zrZZBcXXUmhnos/ulz14puW+nf8b4Sc/9g/aQu8wD4mNd9r8a39zpGwEtddPcu3nM5P7JMGZQrkqx1BLqm6h/darpaMaOxnnfrrGf4xz7NfSWMZofMSIgxYBNN7ztwUABTGZ4q0Zk6CBcq4kI95R49oA2fgMZ8mfQvocENCNsuWZ/dsy0Q+h/3dGl5onoIprMYKNda692n//sny1KEw8einKCGY1PBzJiVD4pEggSwcrOATnL0NrjlZBAT71Qea8oPVIeed7B+uvP67e8vu/xNzOd7/UY7WT1Gh3H1qdJmJ9bSgF0DK3Oef14XuXo1c/p0RzNxT9jXjtHY+DHc1cX3jydmmx0r2+Hd1XA8gnI2MpTYiQ0VZEqPUxhGcCItGFdMt6fgdMyUwgaaNkRNTBjxn4uGU39fHmbWv3h7vm2dRp9bhRHDS8Pi/Ef/W2737+fS4WkwvJKIomnoXzk7jFHVPt4nnDwv38312Xt9MaOR61uZwMFcWxIkiqI9Ay1oIdmumP1WgpQoVwBRAkprqiVAESJarJWLDFiSQGnNeK8Au9WBn9i5Msrrts3IH5BzCuo7k+lzi+w6xG3T5WBkqEOIQUmnwE43O99r+krS2SQGXPwNMB/V9STXfo9jr7dL2lV7Lzh9p0ZRQSNZFrqBioFMZDSSUZaEtbTCcv1qkpIt34nujzT5/l8OJ1OjUaZAcysTDMaKQ4R3B5mtJpc3UKrx7M1ECGbUY8b9xgDikYhgNVFJCmsWCOW6D1ElsqiOzk1Gc/6XnuMK+uTj1Y6n8lt/Uzn07wOjul3f/64ZsY5sOd7JwcQNMpURdkquGjqEnUWKjkj3+QMTMuCZV1wy/osxXW4QtOaZ50fmRcxbhBnLzPoEJ6in7kmb0Z1jPLrl0LfQb4/Ep2BkaI4sAUCKuf2fCIxdJJ57cpWa4MfAz8XXCpyydP6qcNzBQtLuIcb2DW2hr3S2upqqb8dDtEjqIwK9NZOHWsbCj/Xfo6tzbKXuvPNuI5kf8cg6ZCipkUCZD1erzcgqHOPrmXmikgBt+0mRkRrhOEBDEAicyntRaftDcPw65e6iQlDZJYYAk7rinVZEePSeEWj8RJle8WS9DdH66wE8nRRqHDlisC1p3gDcPnqhuunC/DV6vaQnT0z1e7vK/Xv+l3zuy4vmqzs6238i/JFwX1nKQbbXOn/987A/uf2+41w/eYTNvwC6xcJxIv80QKJkBX7H8+nOw8CaYtyDsDSG7YokxdCuUTkbdWobntuYM9XEvxutt8SBSAllDXhukWAovKGtm8KLBqMjy7uzzAAEOOwBDOksfXQnDq5424lSzSVWgtQC2pJuN0uA2/fZakujfb1xhAHRcHwjdYYPSQinM/PSOkkPAnLPZYaiqE4pu6PWgpSSliWhFwKrtdrM9S73qSdW+lyFFNAaU6qaOcSV3HvCTECLbJMVbrYZylqetvTumJdF92XjJAygIKYIlJNbbZKySAUEBJqzTon0p9Q76e4Hz/LWIYgRrqgPsZHeO31ekWMUVNbRfthlI307CP9ra1dEFCLqFoYqKXTSllHUl+Mzcy6tY2ZYCqSR/nDlIfBzKM8yqM8yqM8ipacy5CKaWY8R+Bc8mmXkhW88t4FQevLyNksjCNKyWJwAAAUEZeIZT2DShWPsPCE5+d3uF0/4Xq7oFQB+rkWlLIBREhECElTVYQorPAENJgi25ir5IAdzwR6AH8AkaXSA5SWDVvRCA0RxgdavzvDDjWOMWHWlCdQa2kV5RiIYQSmZubT2tqYzKpCbuiATqCo0VlWBRhuKAXDnAgDL3PmjVC80H/M/JqAM4uVaO0uZVwbRBFpichZoxUZ2BACYgg4n054enpqRjsfPn7E5fW1taOo0MHMzWDr9fV1lypMPFsjmCWSz7Isrf2zQsIUS72NQYWH3v9FUzR15ZP8NYAMonidywzi2JzNoM0shPj3BjJaHTkXdI+WPaA6P/uewsk/y/8+j5MHmY48Cj0gdE8hNAOr8+9HczMDT/5a/94r3zwg5QGso77N67m3EW2OjxRJZmh3NA4z8GlAr4U1vgeczvV5cFfojgh7ZtQm/Wl3DU88mkv77A16ALQw8uKtU9AjDIzpj6Bh0olIPN0ouHFSYKh5Bdp9jFIIUT2A5Sdu+I2pTrTVYEViTNEmvyp4N82jrevsjBDHOSqH37+lFDwCpEVIx25nG6BhtxjQc6wU2bVuV1ebd+Z2zDBL/0cAOMAUkhZdRsLdCghm61fAyArOFZfrBR9fAvB8RqGK//K/CvjRdxf89K8Y/8N/vwFgCaGMKsonaxcE9CQAlQoCAgKPUWZmMLDd59Q481w3lQNBAafuRT7eSy7xlK+9G3vM4OfYluN4Mb0tVtcYLeeosPvr8M1o5DKOwagEtuvHu+06eddbNCoToNeM3/TnvtnmyVjG6lZorwPAdGxu5F+H710UBGnz0Ujve43DERsB17k0ADmEQbFQahVvSNM3KO2QB2qdPBo8AH2/+e9sBQ3PdfvOX9vovb/34HzzXt++zkhiojWfn7PR6Jx2YObD/Lk7t3l8ZlADyIAWAaEWiCcwtTHtkRo6oDxHkxz6P7Rh5Jt9W+x+P/5m1GxR+sxAc9vKwBfZOeLPOqmr98/zCn4s5VlyT62iNDviOYzXNM/Ho2LPGNNHKT1z/Jx9P4+XH6t73o9jn/38HRvIz9cc1cXT7x2QNsPr/Z6YywhI2/ya8n2WSdRIpinlJSXTaSUsqeA7Xz7h6Wk57jsAMx5hZ0TC4xU7mjc/3X93n9M6ePZUvg2u7s+Nz9FiefW9kU8BhCOjmXYeuEhm37YtdjpVNcQ0wxmh/wHHSV3HGjr97yednc/H1H4/AvO509pwaCQk55wcKz7qq2+X8Z36Ry7ujfJHMUY8nVdVcEWESOC4YVmCpGFKwBIz6ssNH//Hn6C+fg+Mv9dWV80Rfq0xWM/R+zNQa0XeCkoGajlO62wyxZEMVip3g3J335Hhhf4oLSssDkIH2IDJ3saPG8+YNLKtKNQBUQ5W5ctFWRbj0lIiA+oogk4HrRgdB47TM9k1lkbCaInJIB6/MJltXRZcLhds24bT6QQA2PLtUF4bxsscTxgACU8TQkDVvlOQ9SX4RgYIYiAaqqalEucdMDdHH3uC8cVFhRSiEWuY6fNs3Hokfx/R23sywyxn+2fYffabRBGx9SuRjSOrk5AaSImMEMDJog2ZMYqkxgkUO18q4qik9XZGvEWNcMzYyZ9dnRfYy8P2ptEXooa12HmcYkJlVYBr+q6Y+tqydTPjKFZHX6cMaLRekZ/lGm8s+23KWKcz5JpwEr8OjvAPH4Wvz5c51/Th8vyCRVYGgHVdHY55sF7YjnTbW+akopQ7BFUmi4wsTl8kmmfI/Ep0a+tDhUW+9mXGfK3N3SCmGwqdTmecn56QlgWWTtyuTXHB4lK/EAyPFXo0GkApLWZz5iMgJOU1GPg/vg/+6XdlDDAatZhhSzd47JFlZso+8htmnMl3XruMJVFNhL+vbLKxJaM+2Ou75+2msl3zf/2vPwKI8f6PPuHP/ou/RrkRSnhCjO+xLO+R0jMIERUBjPkccXW2PdrTgzb5CozbXz7h0z9/lrFyEMrx6TfKstbmxrcwgysUW6oQQ54uFcv6Hau7d0bebre2D4wup0WcHalWWCR3SwPKXGR9Z8K23eBltFr9yM6ylBiHEgU1dDFeVRwoJVXRCoI3ZhUjQIsEbntP5KzubGDQnaUnkjOI1FBWoqgFEmPVRk9tAvW8F5mSkcsNFs06pS6jJcXILYKNOcLmLeO2XbAsCedcFKuWqO+0bQBHlFI1/VsAUdQz8O3zSJo3nnE21vO1XvYZ/7rxn68rDPOi19YecQwgLOmEZVma0yxgTgobBF+ycylpZDlboY/yhygPg5lHeZRHeZRHeRQtPbynWAUbSGK5N40hMgU1t5CCgDG/o/IV0Gi48pEFCAuBEFLAsq5IaQGzCHEeuE9JLLVb9JFaGxPFxZQkVq8XouU5zMYsOxWOA4K9wOvb3Bnt2phInyaBiDSMIaEUn36pt8GsnwMJYCURZqQerl0BNSoIsB8/u2pS0lQVJEJLsYQmhHRQv4/nrPDwQNYMgtnnOf9oVxTPEWekPeBJYRQqAltag4qcLd858PT0rGGgoypQxNtoXSU/rDeAsPXmGWoDWJtSqQk4SwPEti03zwHxyDCBo4+D99gyD4iFRTnPDdgRDxmbqy6gHAsK83cdCOiRaWZlyqwY64opFc5VGSQXy2efsxcIPQyqCl9EBiyrwt/+mUxGJp8ZYNLX4D2jmaPilWoeQPJjMY/LDgCd1vvnwK1ZKTULdJ8DyPper23vzn2qNQ/fz/TCBH7zZJDxBu4JaT1qjY0X2noaUUU/hnpdkEZyrQpyybpknX8iAoUe3SpEAY0jkexBSB5ziVRjz+QmOHewLsBCzJtnKkCa3sbgEgn9bW23MNDSkN6/jqwwiDsoQOCWlYaURnNVMMrlvQYUvGUDpO8Iv98SCN3f1tdMW7fg3fTtFJsq+H9uDfvmkQPk2zMhwPSALEPmtf0Fe6V2lLWkRyxzIJG05Dy83l7x269esG3vcEoLfvbz/wevH17w298+A1hbGwxYdFCSrLWmLKsae6IbsTCLsUvoDXYAHAYF5gAy6lMjmdGMRCJgmHeePCOC1Einq+hapAFiZFTnPYj2vz3VQ2NzkfZQe+/vsl6PQKCHUsff/a/2fZCJk/pa6qbeShsTP17HwO1Yr/88Pt364tvcx8X6YGHFM1XnMckNTPZtmSjw8ESv8LyfMmoPtss3NLTYm6X5cRwKA+t6QlpOKHXDb776GoGreiz3c1C8xzvN9+fVm+VelIepDfYq7R8VY8DojXxUKguQWnlUeB0ZcxzxD3vjhbFvxheZwoTIDExI+ZegPP0i9DqShuI33q1fr62ZaNs4Q3af97r2fPPIv3Az/GHmxm9YeO2i56vQQscTcH+mVxTOPPD83axUnJVVdn33oq+DrFFyxlauw9z6Z8zvj/gdb4w9Xze3/d58+zH9fcruvHrjOj8+3ujL+Ik+n3ZP50mp2TWbgj4gBsKSgHfPC370oy/wxRcAcG3X7dpgKW6bscde3TSrb8i90vDN58s9qnCXDh1ee0Stj6857ouX/8Y2EPqY3HtKHa4e72Z3f7XzksN0po5nRa9/kpVhcYQmWfTwvVfb69nj+lgP+tvkEURJsQddu8oRgEjOKgbYjBaiEBFRGCWc1hXvnhdJvRsCiCoyMoAN4IKaM7ZyQ9wyOP8YnLurgz/FZyNVxjxO/R7xjk/NAHjoE2l9bs8Pe5E6lzQb0830pD9U2zYd1ER9VisDlmZYDGREOR2jyMTn0wmn00kVSVWi+7J5rotjDwDkkiUSq2I+nm5tOYMwGiDYb97QcjYuiDE2musjqRFRi3YhPGxoBjc+oog3UGx0HY6ekhmsmtzheBtrBwHgipo3hBRBXBH0/ghJ5Qx2RtGVISmr4o5O+/NupqH3zvG3eARAcZwIjQTiFJTu3AVGpykiiZ7Dwx42/kzO15yLyocy7rlk5FpAuo8045niav3sMYPbXApCrIgVqMVSYnuDntGQot8vdSAATCKztgbqNTFoFAUi1FIHJxjbHzZulqrozfPReAmuAOLAN/m6jV86OiePeBo/135OgW4ofdSeeQ0Y3fL80dyfmdfz49l5VqHMIB/BECASI98YIpbTGaDayEVakzjJ5Sz01PFd+kHpicMjtN2drya9lNt7QHjKZthMkv5NnNYiGJIG2hud9TNG6iH/FdD2diBCiMJnhMAIoQDIqCWDcwSXbuAisk2dHCswGMn47+Fa4s8woJ+vZl8+8wb2XZXQIirXdqMZ16u7Txqf6H9l1CIyE2rGEr8C1wqi92IewwSqElkTFFHv8HmNp2cnmZNIYkQVQY1YKStOjTpE3zkymfHt9fIlIAagTAFk8hhpSkC3TjxdlPl1NBt+z1Usakhyu90QQsDp9KTGj2ZEL+dDSlFmnwvKLeB2u6LWCzqGv5dLAKOjcOeRGvJxd+ypVfUbVBttoUAICCiGSzkcDzE0Z83X66VFWyuloJYKagb4MjfMEs2pqqERB1lDloJNaHBtNBdAi4ovdQc10DH5Sfpa2eiM9kvvDTEhxKVh5MyE23Vr+NrR+XQPwx0+03g+2ZiaPDTWoePWaInRL3GkMAPXEKJGASNYxKEYIl5eXrGuEmlZ6HiRqFPqUC1p3DOW9axnzrFTxKP87uVhMPMoj/Ioj/Ioj6Ll/fv3OJ1OuF6vTZEKOMFRPkzCqzFKpuCEguVJQ3N2ITyq43CIAWlZEJcFtYgAyBAmN2cBVpaUcLvdsOWsXrICDpTqDDYgYAgzaz5Q8ZIwYwf5WZhJA2osrOtssNCMgFjqITjhlQyM6JFqDLAiiioehWapT6Q5ekNEDAuChphdU0IzdGi5g7vhz8yUzkJ1+50l/YkH/U0J2z1jRkCg1oJt48Zcei9aL8R7oALaZ8llHRRgM7BAxLy+FibIsUL6WnsoTa4VFAh5u6GWMwIBS4qoNeC0LLK2tM/X6xXrumLViC/mhWbAn3kFGCDX565A8nJvCqZFhIgmGIgRloqELYy1rW7zKAvtesu9bCEsYZofNz+zsDF/56MYGcDBbGN7ZCAFbYufm1H48wszqDBnQmKfiiMhXdfbIMiaR38Hcu5Fa5nLLFQdAYT+mqPQn/M1bwlvtld9OYocNQObvh5f1x600lGyoWxrw4Q7Wye9LhFa9Try4EqHRJpKgWXPt+7qemhCOZGAGuqJ1qIEgEFBAF6jfcEpsiw1nHiIWg76DsL5aDMmtMIBz6VUkKNFCBGxmTb0tooS2ITdAEsj1o0M2YahqUT6uPaxtIY3mJr12Zq6zK/FNm5H5c73n1Ma7n+3dvb1MD6btM97g5l7e8M18uC5BlhCAUsf5SEq4BRBFJCiRY5QqKrKPDSPRUgO++3G+PDNCz59uGBNK24vFR8/bKjbC/74TxfECPz6l9/B68s6tIpMweDay0QNpAsgySPfj9V2/77XnVfg4X2DYR3wZuoxQuKABUGNdHpNFYyNuYGfHT7qQKOuZJhxxlG7uI04uU97KHMPbe6VaXOxqGMVhNmgpJOPA6D4oPg+3SvzuKJFl+H2uxnLWHoOH178qA9+TDG893AuxHjmDaOZewpu69MYQBnTr3I+fP8H3wetN1CoeH39hN989RVMGQZAlMIMoOoKotErGOhn5VEbD/Utno4cdI9VsQr0PTzzkHN9BAICEJ2Xp/02G1TM560ZLNt5eRRBzgBJMSAmgC3CYQdeYwiSqgQClvddZf3sUVy6MbQbLepnnX6xo7l2Rt7jG5oik9FScppCNjTDDFUcBqEzMr0WTn6coyOeuM+F0eqRn+jn316pu20b8ra1VKqzQsvqN357joBm703x65W885rwyraZT9rzd//flZkPGtvZzzx/fTvRqSvQamWI3pOQohg9/st/Tvj5X1b88q9nynnvtBgp8j3qIrKS0c6Rog+XwW/hbz+W8znw7a6929q79xydTW+1pd/F7X8nATQuqyn7MI5MUjNXT4tH7hR6NU11Uns/nttHbR0Vk/63+frzH32N8K4A5wIKS2sZEcAasYgpiFFvBKLK0stpFceKJeK0LjitAZFuSOGKSIySLygvn1D/9Z8Am6R9rlRQMoO3iM8Vbn/7U/L9v/8brN/NoDOjvPsePn79ARy6gZzQF0uhyirfTfJFk62Etttv9xT41X4cngAAIABJREFUc+PYZL2GPcjsBE0hLAYyCcuy4nQ64+n8jHVdNS20GOCXmsE1N17+48dvgIrmJOJpVEuFUaucI2FMbwegpbfxsp/1zTteeFppRhCEbvAJdEP+/ux9+jyGc+ZBp121inMMOfynnT+6E2II2G631s4QCLfbdZRJjc+wa9Rg/d78eAzl7tTdk10Oyhyxxr/fGVmo0t7WqqRxZVRkPWs1xXLDM+TauC5iRBslPQtDeISoRlZEMoYSrUUiFW2c25nQ+YFuMGVDR9RlUCaNXjexDGakKmMnabxbeu0Q3Bk78kBvja3979MmWT1Wt42jfZ4Vun6sPR44R7Xz7+854B2tiyN+ZY5Qt2sLA+C+1+H2vRmq2udaZJ0/nZ9BMUhaYyKcTgvydsXl9RU538DqPFOrOCQ2/gpekW3zGTUy355rD6HjRsuScFrPWJKlZIogpY/hIMqPYF9t4hwvoo5CoYJCwVf/suL2tZxupGN0+6rLgSbreEcAiwQDd81bZ+zReWan2V4e7J+ryiFmNNPP2AMZ0H928hODWgRLf93rN2f87J/9PeTKAC0AnfD+u4Q/+UdfgbChhgzGqsCKSvA6F1Cpmi1hFGt/mEGcwXwDWPAF6NXUpnY2mvEjMBod2ZO4FnDdQCAsMSEFoa3k5IJBhmjruPO8Tc6JEaUW5Lzhtt3E+THfRGJxdRBDoyYHgCWS3rqusIiZtrf8HrOzxoxQWkQYJpSs50xlSJqzJI5KgBjKkKRIKlXXWDsnOu9fmXF9ecH1cgWR0JmqG4pBoBARQ98D2RsJ6l/bJwN9Max/T9O2XGDRZaBG0qVqyrNbQbKIee4MXpaTGN+kIE6kUVI6WpnlkrZWvcxqQpryH7PMZPTV3xNCQC0aNV3vr5ou3Ry4YpCIN91p1s5hUpmxYtuuIqsGwrImnE4Jp9MCVqfUXF6E9+Pbrg+P8vuVh8HMozzKozzKozyKlvP5jHVdW1hEs5g2obEBbtwNSwBWwdwgOwXyzR/dMX5mgC4RWhYEWpBrEYUcgFIZeSsgEFKUULGSo1SYQXBnakPoTKUHVgCnxIBGR6gsThnBwJUeLhXAsdBKpmAYBbvefxH6gv3I4vETYkAKPRVTDCvM0IaijJmpsVrg0AOl8JEg3xj/Sk089AYzXg1nSucu5EPHqdwF820sRg9iUajEKF4q3jq/RX+QC62m9h0pbGvRgZjFsyFvGbfrFdeUZK4NdHP3XC4XCdu8rnh9fcXlcsHT01MzoLE2ijFAxqdPnyDGMguAii1f1bhGlJiVC4i7h7EA7wGldLDW+mseM12YcYogULvYz5sX0OzPK41kHQngb+PvveKtHpsrm/N+Px9859eGPMM/e55bE5pt/fZ7owNleuoBG+cZ7DhSEs7Kl3uKIF/X0Tr8XBnbMQJVvsxzM45VB5msunuAqIFHvl4xzHP7bhAw2TaE3jipVixVkT0XHYwLIYA0nDRDwKxScktHFGJPuQEmjTBloUmFFoeYkHOFeW4MoH3oIGdvlq2Fvi6sK6XOY11RFYSV7gnN6ZEeNJpCU2QbMEYd3Nal3PA/AxTad31918pvzrGO8u9c/Fptew4uMhNsfuY1343NPHj8xpNAxLq3xj1na0SHvoWZt71sXkKBAmKUNF1ikCQewj1ikFPeUgLXiJfLFR/rFcQLtlvFurziez8JWBbgm6+fmsFM61t77VAY6ykVCAjMCAhydnPP1U7tHnnnVZn+//5nV9PwvABCQsAJAYlDywvPAAoBERI+v1KPjGN1knudAd25zDCmKRTp4NsZTL0HnNq9CtMNSsdWqG37QWk510l3vu+/9ha1MT1IxWTRZAp6SqZyMB9HxZ4/cR9utACfpmlunb+Wp9/6Zz9GI30kCnj37hk1BpR6EzqjbrED3EoS2c7vP6/oe9vo4IjOU9tL92Zgvv64Dj68zgOKs8HHfGZbiG8QdvXNvEZTwGj6p3EmhCcQ1sXMzYTvFI/TCKLz2BfuL50n8gqb+azvCrSZ9xnTF4lixgBrf/Y3r+bgzwhuXp9z/+fx3Stp85AWxCt+O+/a18rtdkPJGzApsIaz0wBfZ2g+j8Ws2HxrLczXeR7p30Y5etb42e82S79AkuohxN18B5KoAajAv/6LgMvrNtT9Fu1s3ymdPCqN3uh5Kvd3M7aRho+t/33KYfv+DvXdq2c8K+lbUJ5eWoQ2FwnV1JptfKiisEWLARrPMbVnLm7W2+l+pHa0M93O95meH9Udf/AJ6w83MCVsZQGhtnmX/R+UD1R5jBaktOL09A6nJeF8SjivAUsqKNdPCLiC6g2on0DXV/C/+nPw5TS1gVu/jAeZDU89jzK3ffnJr/H+72fE+CVeX96DwiuIO03oBh6dXhj+ASjdUj64pZBBp1lHGITwpdpqcnU2Ot95RnMiSWnBsiw4rSc8Pz9jXU+QNMxXAMIvliIGgjlv+PrrrxEQcLuJAq5IHuc+h9qWo1TH9twjGmg0t5TSHFvsTLDfLfWGN6xhM/sy+r9bcF0WD2TKuoBSHDenG6zRbO6R4ATD6HKttc9HtWnK0IkRms8D3+e/i0zLFolOz0ZvhOnnwLdDnDQCoLwxrKnMqGq8BUaXw/Q3du2z1CaV0aIRxZAgqWAtalpCTFGUsPupcO3sspSNeac1SntU2DEjCiJCLaVFkPHyYi0dS7TxODJcsfFhHcf2ecIfdvzVdNYflTmCzNGZORsy9/nZp+mcz/jZcNfjkiZf2h7vdQN930PTLhHA6jBFjNPphLSuwocT4fy04nZLqFXmGTWLEULJKNC0R1WixczzKhGrkjiguX706ByCR5xOZzw9PWFJizqpJaRlUTreo9TYamgGf8NwSvuJCiRCzg0ff0r4+FPqawgSEaWfS2Ym4FMvtdp2Z9Zb56un+/ZEL/f4M8FOjqoVRgLM6OCt3d8jwPk+ywtrlFdi4PXjGa//55/IT9qn/O+94E//0a8B3rChgukse1WNRmQP6MnNBKIEMZwhlZ8YzBmgkTcj1xSLrGPmdfBy3zBGyrsjgMsG5g0xJFAMcp5DzjsoKW34zhvFjv4KSS/98vKC0+mEZdXzwwxYgAFaIybU/5e9d+uRZEnOxD5z94jMqurucw5nOAS5FEYkJUErCgQECBAEPehF/0ov+k96kF4EAXpdCVppF6C4EJfgktwZzo3nnO6qyowId9ODmbmbe0RW95DDhbBIb1RXVkaEh1/NzT67haDRUySFj61RoI8+KunIN1h06UBqXMTNOMPOUjPaaPgqaao+HQsZcNmHIeB6ueD19VXpuWBlMUaElARLiS3lWs5ZIniZk5TSuc4ADxL9LYSgDsyGza6VXm7biqz6kVIyJKqTOB5Q5uryFqM4VeSScY6h0o40SZT3kpuR71EZ8VHRrTTMzBvN+sjwNQq83gOjiax16kCyylVe/5BzO9ugtIiZsWXpbwqh0iWKBEIBKOO6vII5o3C/zu/l71/uBjP3ci/3ci/3ci+uhBBwPovwI54FWSK9qEcoMAC98N8BxsUGMmWegSoKArCEI2TW8N4kXiaSZ1e5YBMY2cJIEsaUP8BeQbFn9aR1mQuQNzE04dIx0/XOQ4BbxTBrloIxxtiaMheQ8IohSLqmlCQkKThUD1pJ31SsYghT38CQo5Czt5hXSbcSlIlUy3GXykOKGPs0oVyYZGlHrlbq9p4W3aD9GNO7bRkxSijMXplgAOe+nUGBdetbL/QTLpdXbNtWDWFKkfQwQddKzhnPz884nU7VyGVZllqPMdXrumKaErZt1e/NMKWoZ50IFUQZzM3oh2tkDO27epJJv81jsFTQgU05RyosMO/W39Hc9eCOfWeAVL+GQujBt15IIVTvG+oV9U0gYd1be/VB27PeuGzwXOL2Xr8m4yDM1ZoVVOzHoBkGjO07Um6N42eC6VHZgWRuTD9XPFjV5mYE/Y7f1eZ/DyS3+wZB2mCFrn/tvahghIBEIZCGNyasa6nhSWW9ZlAISAgAEmKE7vfWr5qvvGuLzIVE1FLFJKF6D7ZQ2HA5nO0575XfK/YAUq9FAOQ9iACyqLz1XMgOLLHxb4BwpR/cQKRfR2l4y/vwS0Brv5YqcFXf3wOuNtZgcvc0ZfHtd7QV2tGGuu/2+8VoAhkMyCSRfCAh3CwItSg/cq0jxRl0egcuEa8vz7hcLwiBkZFQKGJjQpyuOD1OFbA8zROePwFrhy140JHBZMYEpJFnCJGB1jPbh31HDFirIJueGV3dTpEVmTBzQHLg6AYZ+wzGxgaIsqtfPpni1ExyPjf7BrC21dO3f5xRHn63e9r7WlvcnNdFxS7liI9Xcgyw3l5RVEetD6MtfbeIMpKKiZE1VHlxb2H3f1uFUHDYFIkNMvbvra1wZ4w3nnGQ5q7l7O7x4+MpVuGC55cXbHhGLgteX19FiQRJyWR7h8gUYS3KTM9f3R6/26DgjVl3v8ZzV54b1r3njYdrI5/nDV/s87Zt8Aq/UUnp31P7fUhXNbXCtqoCYgVjqx0KJF7BwRmAhLpHuf5tEUV09DRizXGxc90+r0pYKDRlcVavwnH8xjP2qBz139fR7eED/mw0ZmFmZPM4HzxS/b2j578Hh8d2mwLYt2NUkvXGRNxdG9v7j1GOlH/2vbTFZAb7oWoo45+3NSrpIADmFUBbL2+Vo54dpSu6eQ/vjfMAoz7NoJPc9/2Zhe7KUftunQP/0HJcz2hyIqVvd087qUbcIQRGZ0AJ+BROPa1/qyfk9jrVv/zZcHC2H/x0dcYMOi11zpgjKCSIU4proxFZ0cRIZLtAQEiYpgdMU0KMBFBG3jLyRyBvpaaDmJYT8pDa63h97Is/R/t/wMvLBfMCPD3EFolFDTraPt7LQkBPM0Rp1N/r99Ko6IfJehRU9hzarPy41Wc/ORf90VgMjGqUvW0ZLy/PuFxecb1ewVUvJZFFQuojwgDNMOBWJDSi5vhipY9q2feVmdX4vmExpYjDkcmo4/hZPY3etr0sMnmjqcHaT6rU1XM1BEJKEYULtrx1ithKz2H16/l945w/mrtbxhpvlcJqyJPbmeHPAn9eVrwn2jlDdU9JxA+jiU3WomCR5mI1VCFqRguiYI0oQbAXEuZDZf4etxnHoTtH/PrnfgeZUtrWmY2XGc9an0WW2Stib5WRB/DrzxvGHBm1HNXbr6++3yN+cFRGrMP6bHLi2/hQ347j1KEN+/F19+0HzEglaHSMQBExJISJANYotCEgxoJ1WVAKkNKEnEvF6yyiheHAttcBibyc0iRRM2LC+eEB83xSxb+sM0t3g924tZO1w4NYpZd1xfpaUHjDtqbu5DG5zaQT4NhQ5tZZeqvcuq+Xh8bahUYUXd/h9rLYvcOfn0DjafTY62QkK2UDrt8DhTfw+wV0IkBT1kDpQH4NWF/kyeldUSMNccQy584mhfp+ev5A/vUJ3/btEVMTAq4n0OsjUojAozg6RJ4RaG5j5PY4kRmN7nld5oIpzdjyiufnT4rnkp5dsKOsGtiKz26jVxJtEzv+27/D90aiyZgBvRmfpnqWeVmGuSAXkZ+IBI8RIzfBoQVPl3NwuUgqUlJs+TiFo+Odq2OinH/bqikQU6p9WtelRlkR41hzGlV8iIEtF5xOamAUgXx6BQDMdEK+nLEUYC4ReD0hTqtGjlMnTbNluSEzdeNJDtsYnrHP0Z81jsb5+kbngzETALNEHWIWh+4YgTRFpBRAlHFdLtg+FSyrOIKkFBFpBp+ub8MA9/JrlbvBzL3cy73cy73ci5YYJaqMF2ItF6dniJonjHqilwwiAxxMMR065lQEDwFkCAWI4lWWUgLnLGGCYR4WFtoYkEgKVFn4pohtgjm4KVICkVjHu+ulZGzr2hmDtNy/rW8NpGlCnBggGMAlVQaK7rrcL8xuH6q9GlMzlNkuGr68KUmPwBXPOFp9HcjfAUlUhU1vUCHzYEIJIUbCljes24otN2bcxCYz9jEw30AaG4MRLKhCyMA4j8X3xyuLLCz/5fKK19cXPD09ISYRtkGE81k8BC+XV0zThG+++QZEEkLZctuGIHlrP3z4gBilzzmvWNeC02kGwE6QAZin6s0EiOciUVJjBRMcCpjF063ksS8qdNb57SMVdeOy+5uGtdLWXa/0b8+H0IAW2Q8GcNn6BAxCgFf9dk1QIbmCb6PHElWgzco4V0deVhXwKlnDmFq9uk6p74t9KhYliptSqVNCmUQ8lFuGEePzMi6tApsnW4ceCB49wHx9oxHMXh0wgD+sQMMA4Pk9PYYubcBg+wFYo8qsEj5dQ4/G2AOYZsBogKAJ3JZWw6+xbct1PiooXPo12wHZxQB4oKWh8v0wJa6NcQNCiAT8MUDDR7RiRkeD67ur91lbL0cGhL+pciTc2xy+/WDDz0daeAsUP2x5m2ylnaaSuv0sM6uiRc5AG5JmMFMADiCeEKngdJLw+8+vK65rwOkkhla//eO/xnk+IYaAh/MJ/+kf/Rj/y/9M+Mu/OG5/DeRetUzWbsA8/C1/+62ToBlrEGqEJf1mQ8GKjAjCSgEJjGhpoOyc635MhTeAOrgx1u66v9NqEKMZbxgy3j9+HiPp3PpEfbu9gcnQjrdKA4HdO1wKpkaRuEu9ZOHJS1fHSJF9GxyIXa9yd3cbt2E0DyLOHK2m1tsetOzGjxnPz894Xb/Ful2Ryyah3aHR/KitAckxv49e9raS6giK7nvZxoLQzPh8WPH+fPBny/jeI7C2Kr0qL9ro3Mj7eaOMRuP79zG3lWC8dwgNAE41FShEAa2fJZB540+Eh9Z4j2z99UnSuqnqzjHfN6+oMo/5KU2IMWBZlnrfTZrpaGPP6x6/249TKRm55Hq/52WPIuXZ+RMgSkWvAB75nyOlr/09esH7+sdi7faGNWNkG7vvH7McrU3jUe3V3VmnRrJkTEuQsYspCu8eHep+UFjlns/R6i8tRnOMBtXv3f/tzOivDjV1VzyF8P7Ve2rVf//Z9tYaRypMGNtwVDp+wO51aarGXWPnm8jmjf7uT090T1v9GTWpQ62rpr2o7Wh/841aGcD09Sd8+M//Att6QoiPAJ1QWOhLfVIXBoHAQWRSpiBK2RQxzyfMU0IMkgJifc74/n/9bdCrJJcIIOE7c9yNVU9NsLvKYBlLd2b6s3VZMxgS6Yb5ipILWvol442bEftRIZIokYUlMeER/QD655vhA+0WIItleo06aQaTXFzLNQowka0DSXfx+vqKjx8/Yp5PsGiUEuFSDCua0vxtgwWjrTFGjTTsjMtVZti2TbzZkyhv85Zxeb0gBMGbpmlykWdypYt9Wun+jCESfr1o9NpV03fowMhqCEAohMIit8dTOz9zFowpmByjMqk5yYSQ2rqo50wzdPJncLeaeG9cebAS4M9dOXuD0E92aX5cn/27GFwNGyyykYyL0uZKyJTfrhHCoPzAjBBEIRxiBIWAgozCQY2HCIQoO4YlYk3JhqH0Mm53hoDru0sRTEpkB91bdV3q3YW7eSYiSWHCjJgmiXijUR688dVRsXbFlCTNkPte1mbu1s/R/IwK3T0/1+bK1mObH4+/NOPneh1yVo58261oiPJ9iwtm9Rr/2d/LuuaFUysa4VUU8bZ/A0JMsBQ2qWQQSWSldV5RtoIpPWBZ1oprmSLfUjLZ2icSB5t5nus8nU5npEmjy6jBTI0qc4MH0m2nlErXMa94/umGn/xvEUwTWDG4umoGY9ldvWjn0PFJ31/jG/eN4e68+U0vkymfWTmFPR9yLAsdF2+II3+3FfDtzx7xz/6nH4NA+MP/9iM+/AevICQQIsyE6OO/OuO7f3FCOgM/+O9WzE8shqlBzpySFwSsMBX4rdYVjdvjHS00EaC+MbRx+Nd/jECM0w+/Q/yTv8A1LyhlQ4hTnXrWiTZOZd02mDNpAGm0UMY8nURemCY8PJ4xzQnX5RXncBb6bseg/kdmKJUFt5zmWdI6qYGXsKqNnx5pthnIiLOuRKfZR9VWJ1OWiM+I7ihWvPhyvQLMOJ1m0UFsLp2c8jTF0T/5TPBG6bZfSpFzNQaf7lFooDiBpipnrFsz4ElpwnyalWYW5IePKH/wp5hSxPWvfgx8/B0QgBcKoALgj/4KfL4CrBFKLbp1JwscrFHunQp8FBkb0ybfGq1TfqlGcIMar6Zaj69v2zKW61V4x5kQo0RFPp/PePf+CSkFXC7PoACkP/tdxJ8/Sdt0Yq5/8v+IYfW9/EbK3WDmXu7lXu7lXu5Fy89//nP87Gc/E8ZzmmpqpgZg9GCopSQSTEaYqBQtOklT7jJLvs4YA1YTkAshhASJFGgCNUAK9OcNAE8KtM8iwDOBmEEsITmR1RhDZciSRUBPYpUibQwBoIINrBEbGkAdQhNMDPyyfjEIm6YcgWOcmRkIzauBYgO0JNUUoXAGZ8k5WlBqhJQUkxi2cK0NFEiBBWg4S+l/IY2uU6O9OBBCBQ9iBrh5H4m3IddQkESk+YqBjQO2vKKUFRRYBOmghhiFAZbUH9smuc25iBeJMd/Xa67jRwSIjN5C3DehxARrqKGKgQulgpK5SHhJCjKe65rx6WXT9CNJDLeSAGvL9RXXy0sd35giaiwBLogBeHn5BIIw4CVnFGZMKSFvWwXUGMByvTrjiQCKhBQDwAV5W8HV8ECAMUmPI2skRUtEAjDUWIbUkEvfK1kHHIiP9p8ZDACqaAAZ4l1rFcOnJlSJAqIvRwJKBenYFF7HxiUyVyIOW/tsXI/eMwpArR79TJIHWF7HFZAmaJ5wTStRgfChHlPOVKGWoYGkVGHDTWWeaKoA3i2wctc+1w8Pko0g2AhyV7UzF/UM4doWwcrEGK3wCi6qvCVNQdeFTFfwWDd8zkX3o44LGHm7VAHU9uz1ehUBWAEHaQIjb4xtFcPCFMWgrIaULZJf2aekq6uRA7YcFHySe6LmCU/JItMQhDQK7TNwD0VAibZgHACh9ngEyZ8u4ytphEDiOYkQEcjWNmBmj2BTLhB4U4MMtHGpa0OVPbew0noi1fVgbXUKhrGwRYZtnqqkcxTQ8i6bgVpVJmkI85qUiFr7bM/6JdkU2aauUXpS5NwANUCRScCTUmGpgKTGfFJnFtpWMkrZIDnoN3BYZbyIwSGgUABxxOn0hG1dsOYV6zXjsqzgkrEsAY8PGad5wusC/Ouf/grPlw94SyRmNMUbcUtTGCwNF3qjmbfq0MGQpcRCiTYULJSRmBBJ6iIOo36olr2ZiYc9W9QBa8vYKqNSRpqa0cy+VrufD67sDWf652zltCgArS28uxMHn1trQd74pTeUaZ/RIsyQ/PYKTf+G/ZuPjHf8nf29PH5SgPnGNj18l7+3jjUzrssVHGak6YRTCHj3RODMVSGXM+F6zZiSUy45xdJbihVTHMoz8uZ2O/e0065b/5gqIOfpRgi9AtSuEwIsApd9Zwog+/GKHGu7GZmM0WXsnlG5KrTVpzQwJYzyYtgqrSVOsv/UeDNjawoSpyRsXry6vhhVyRG4N3y0NgOi6PHpLlpEFaFX27ZUPqjJCU0BCiZ3PdaV0YDUreN/RgMp8zLV2UGIEVNMrQ49TJhV7AAwp1TXhDfkGY10R34opih8XzVTkz1A1WC0yQ42jqWmjSgIUdcDjBeTXdx5o9q5WA1C9rv0LWNiO599u/14jn2TwmBk4YtLQDFHBog8VUhCvacwgSODEyGcAnhe8Pr6CYVPh+309Moa9w+BtDv6cSMyjVHoUI1KbjMFRkPtPlv//hwZ3/zr9sXTfXK1N8OcA56/tmPs17799n1wffHngz17y3ykXTc60OpoCrRmINP+UhJ5o06mhDK9B6UIRqzRMShEbJt46BNJpAtQRAqEaRJFYClADAXnExCwAOWCgFdELODtBGyajkJbbrthPOPY/fbt9DJb61f/b0rvsS2Mjx8XbJs4v5hTj+yr2NHxyosCeg8k/YwzPACO925H84k0coHwtcyi1DPjHEJABGGigEQRU5rxcD7j8fERD3NCKRuuyxU5b5jnhLIyLs8rXp9XcI7ICwCKbrUztrxhY0nNFEKsqYwJ0DSw4liScxZDtRAARIQUULYNuayQ1B8F8yzG/mDGumzIG0CIiDQhTTNiTGpwD0jqqKxKNTnLADMYNTwiAMVFvtSxSNMJrBFqEBLWvIGyyvnVsatg2TY1BJgREsRoQ/udQeAQNa0MwZJZAgWBnIOF8XMsaVABUgOqosCI0XhZfXVFksn9BMdIaGovNVoigoTpbGd7iBHQSJ3GuUp6CoALASpzUZC2KEAkfxPARNI3jiBMKHkCIaEwyTwhg7EA2ECWXJQZpeiapSu2vNT12fCedu7aHJmBl/E1RGKMCuUdKATMMWIKkh5k2xbkvCBEiLwjL6jnsERatYSi/R4xx56aapHE6HXZNjXSihW/9LxKZxgDCO5mxmYsKezA0LTw6OZK6KD97RukdISh53es9woGIDiT0QLPooqxmo2npXVj7RNggGE7hUZMAxUX5FLwenlFnBMeThOiRsqIiRGLYKCBZrx7+KDK9wBS/m1bVsTLK5Z1wTzPOJ/PGh1D9pUZIWx5w9PTE9I0Y54fMM8PitvNkjY6RDXQ8MOj/F1hRACJGUwBOQRwIOSyoZQrpvIt0rqhbD+o6YFMNq8RkNHGpI5h/elPoKPTyN873tdNKaO2gQ+eMwrvzxelSPp3O1lGlo67N43t81xCS40IBvIm+2nO3+GpXBDjCRQSckgoHPGJIng7CZY+FWAGSiAwZyRcEfJ3SGmT9EmuT2PfAWcgS9KryJKaWSg4ITIhk5C7AiCUghnf49ML43X7iHn+Ck+P3+D88Ci0pjA4AKCIQkCIMzgIzUVQ+po38FaQ4ozT/IjrZcUvf/Er/Oh3foSHhzOIJE2RpPSLiokzpvOEJS8IkREQMTEjbxI6zfYll4KwkUaUEWk6pYh5npTWQM8ZieKzLdnxyOIMHEC2wcWRbUoAF6w3wKpwAAAgAElEQVRlFVkgKEYULKq+zFsEkJkrFg1mJAqSVmjLQvdInFW3dVG6U7As12pEas7ERluLenRSiGpcQ6oDEdmv5IycV+SVMa0ZsYR6/si/iOt1xRoY75++co5tm9btHTv7nVQ0BbzwBHYeNeNNIkZAqRGBS8nIuSCGSSOaCl8T9IwnZkkTWYpExEoRMc2I04z5LGmD1+WCMD8CiVFoQ5wDLs+veNwYscRuDX/6dsPr8+Dxei9/73I3mLmXe7mXe7mXe9GybmuXc9qE1bc8Hr3XQ6BQP5tgKPegKoVNxSkeNRqVhQoQWI1lTJFgXk9R8yhPYI1aw84LNKhQG0265J7xtzdaeqVSzMCkCZutbwZ4MWAKcPMcIQHaVYKz3quSwqJHNKDV4EbxotkEMNBUQWZH0JS8lkbI2oIqiYlnmf3ImOjDKsir4mAUd7h5sDIzEhK4KlWkfTmvNXcph4ioTDLr5BH1ucgbCKIKZtJ5DC16RikWKliU0s3C3AwdWmSfpnBmERLIcoqzeL5BPMcsQkyggJNGnkkaqtIAkepFHCOSU6I1QGWAnNnAic0BKLG2x4yVpA7zRJMxLkUNtpTZDwQF7NscttnYKzqaQYUvTexuirwGut4qvYeXggp0VH/F0dAAeHI/VkNfr1dMSR0OcHKidt3r+k0IEUwtnGlrw9ifBjkw0HmhmZJO/khu3wG3aJI39BnvPX7/Qal9bHPh62n1OdATto/7sfdqjEARxQGNrO5T1k8DGKdJQtnaWrQw4daOQLHmJKZhXTbDLA+DGKAv31uEEqLsgJs6c0pzgtIAU1o6kNENoRkUdsoCVYSiiPeNjWOAA52pgUZc56Vfc8AXzNfB3FYh/wum+mh/eiDYQHuYksKdCd4DqW8SVeWy7XbbeDY1zRCTatjetnZIjQebx7Ktg6xGM8ybhGZWkLWORRAAOBAh8IQIQsEmkbeWAny6Im+E5VRwXRnTdy94/zvA/D6AOSOvwC/++huUbUi/BjV4IVS0l0nBvErzqPqdsXtOR7QDHYM2F6xpl1BwIVXAkPh6RbT0QgUaddrVf2TG0oGlhni24fcz7Ff8Lsy3B15HUHEESW9Dn+362yDu7YXqU2z4PtvncXwLGIVuh9P2fALV+vq137d7fwb1d9v4Kihp7MmOBt7uMQN4+t1XPP3uFRQn5DMQygQgIcWIKUUsy4t4LQoWiG3dnLFfM9i4VY6NK3mgLz2d6/s77vW2EkYFSPOY0/uop03jWXrk0Teeu0fncW8sQpW4ePrvz7HaBhCIhb4X1jRvBBAXAV4JLWIHaVqUytDzYRvGNvpIOG2sjfcHfJXVW7GmKvHjCFg0Oot86Q1mbxngVmVjMK95rZPbii9Du2/tQ+8B2c0JlL9FW4fjmiI3Z+yiASgi3t5IJIpdPwBd+Ryl+fXLeLYe80mivC0MAcABiHc31WgUMQrATZGQWVPAHLReanNrcKA+jgNw/x/X08aOBnp0XMwo8tYdR+eVnQeEvXprT8/H1t8u/Ux6zq6v91hy4N23exre+knD0+Tq2J+e5L7f32PGI+3z/gwCgPnDFe9+/K1GKiSsOYLPBUwzQC4lGQOBkzrKSCSZ6nEdIBGfWE81LkiJwHnD9d8WbD+ZQFsEr7RrZ+tta9fIBeznu+dRxmg60/SAQCuWJePl9VL5S0a/j0b5w86BKsbYvOxkibf3o9E0448MJCBq6YdiiJiiGHxMUTg/oiIc4LoAXLBtK9ZlQd4KUpxqXaQyvNh7iNNJ5VvJeFhdOSYDMOQ5mzO0iCTMGSFZVDRxFti2DdsKzFPENM2a0sV4aVl/NVWHW9JGP83oIeetDqi1K4SArcrlSv8hBhQ1IghZpVQjYBimYWeHRV0BWNPO2jnaxpwNd3FjIQYzLf2VNc7L+vWz50W43tqiuxif6yL71nVW22BRY+wZ6ycBFsmL2nstUlMICZa22XAc0piE6vkGoxSoZ2+uytmjUvkYsxnt5C9pH5dSU0NFMw4pgr/Iu1tqSZ/apjrqkRkT9TxGPZN1MI8MQhv22JdSSk0fPBopgPw8jc/epvDVCKcuA0VaOj7I3994IfnxZ5S0q2I6ZLxN//7Gf8kzuWRkiyJL7ZxOaVJnFpJUPaE5thQuKNr2GBLm6YTz6QxmxrIueHx6AhfG5XIBX17x+PAIhIhpPmE+nSF4bqxRqjq+EG3OrNMimrEuD9mbL39OyN+esX0s6EfBhr2XycZz39Pvt855Hq7a3zs5rfJoJlu1dzTun2uq4RZlprWhvm8w8NFud20Yi61pdm+zlfiz//cDPv7sEYGinJsaY+31b6fWH1pljkMAl4x8WbD8y3dYN2D92Xn3XjPtE+onXE9DnhhFz4oagc3xsASAPr0D/9l/hMcr4+/e/Q0u7z9iSifBbFloEGvNIRJCUrpGsr/FuXTFiSSi0evrK15fX3G9XmCpj3qeX9LNXq+L4I1wDqaQ9VayYWwi43Axg0DB3MVRzaLaK16OgrK1FGTNQLBFg/LcUpWhuCBnpZ9E9SgwnDsQCf5nPALJ2bnlBRzk/Cyamk/SLXFz+hxklRAC1nVFSqk5xzo50uh21uhg2/xvMM2/wmk+4fTwiIfzI67PH8DfPiK+y4gfZJYFsw+dU0KpFvyOdjmgm5Q2F27yGgVdOxqhurB3DBGjoqBjitLSi1sEnykKrxjThHQ9g/7tEx6Wd8AvTlhTkjOCGfPLjPAsOoH8+Irrj34uZ9xjVuzyXn4T5W4wcy/3ci/3ci/3omWexKtgnufKNBlTZnk0DRAaAeTe67Xg2OMKqAK55lSVMJzyU5WCxRlnKAMcY0SBRFHIQ8hbYxjjQZh3Yx7HthwpIqpOoAIRPiyjCC293qV5eoQgnkKdQqTwDuAX3tpACRP8mxX3Xtnd+lHbyw188UrW9owwuWbVDQApjfNAyFlyhJL6I25bRgjqFRQEeMpe4GBT6vvxaP0PIeDx+68QLwlLWvDx6Tt91gm/2j8BbFofBdww7xoJLzlGNiooCGtbZ+bJ7NMj2VrYtq0DHO0dDWARwSXnDT70M3PvYeyVcV4osXJbgYXdfUflaF2WYhFgBnBNhq4Ccb3hTQMDPwvoNKlnGJe+TfZ5VEz1HbP7qGuqhMeWlF9mZOH3YV833Pj37+8NJ7hbh6MQ6QXGm+3FsA4cmG1j0tbo0EnQDnhr875PK7RTgAY3vywetinNIsQTdP0mt/bFu1HAaJi7mURainsRpl+f1H0PCggacpVQ9LMHIOFUKQ0UCDpAHZC0UzQel9aetjZ8hIXuXpCmoqbu2aM9d6vPX2QMZR27dcnWlm+ZDH4FBt7aX137AZgFQQsl3QAUA0EFpBcDKGYxwLOc3ea1087EUtOaFQWpeXhvBWOUFhYFqEsUz+jL9Sop8baM86dnPHyd8f6HEYEK8gpEnEEc8em7hO+/bevMQEN4406onSqbV3uvqLJ7KrhYh1+MawSEc5HrSDyxZgqIOnYbCjYNEm2xHDw42oOUAyhKAjiztmwESt1rG+ju7hsB2hGoPSpvr5C+HNXn294DvP14jvd7Y5nS3WHtcjTB/T+OROurQbUjlLwHq1uN7S/u7u4Vw+ObH377ih/8Z88IeIfvfjljvQZRuAIKil6wLFfEIF6F27ogphPA6HiskfZ/jn74ckRHhF7qjCpA/Dm615X90HV71c4iH+1jjJpjn0cjlJ7XFMWHVxQd9c8rj/p9qjSZuEYRaP1s7SFAFV49TzimmQRafvpSPQ/D7r6O7+EWTcDGwYxlfFoqP/7ea9x4hBFg7oHkvXxQ1yfvgWlfvJxT15xGCzw80w5lo327xvn5/0XxhKnyeErDnYzkQ8pLoH6f5mtfJZPJA+2k8Hd7GnxEF7u63L2fLfW9h1vy8FyQXW+GNu27WzPkz5ixT7ef2b/fXxsp9uHY6gvGOvzutQhqtvNbW49bNp45vpWjsUyIBe9+7yMoqZHC+1c8/vjn2DYglwjKMzImiEOCRY+0qK7eCaNP9ckMlaEZHBmCEWQsPw94/dOpet6PEhB2K6JFnWtzS90Z2ffJKQkhvNs0zQih4OXliu+//77SM3/u3EojenQmjfeMMsxuPrwsAS93NJnJ06+cM0C5Rm8pZcO6ZlyvV6zbCgqENKVKX0nl91KV0l4ud2Nb+XnS6BURQY3xt21FYYkqBooAmZEjI28FJTOIYo1gHDQSsMc+eFxuO5nA1k2fys4bzJq8KWywKPDBhmv09YUQmkNOCBjpfuMp4NrHdrE21CKDCKm3Xbaf39Yxt7st+m6tkrp9MK4B+WXGQeTuJ6ED1O6net2n7TKHCYjPT/HG+FzXF0hbOpzVY+Fu4lwUWKtA+xZjUJ5AIiGs6ybpgnW8LHXW2F+grfmxHQ3PcRTS8RRfUjy2UN9Xn/01eD23do2PqXMgh+eN+lpUvfHgZX1OsEXPR9ziOYw/EcMZi/hHGr3ZR6kwjHVbV+RthQmTMQkGIalfMsCE03xCKYxlWQEQ5vkkkUWDRDcKDovr29PTOoKsz6K/xVgCIMq4/k3Ay18/qXFrqXKeP+nbiB0O+69VxvPPj3x1gIPxLf5caG2oJ6J1rD6F7tmxnQSb1743o1xEw2f7/Yu//rpesbjGCYTAkqBJDK0WjYZSQFxQlhXXf/U1ri9x1x77HCuOJ64vMgcmUUrk88IFWbmJ4tpAr4/gv/wDvAPhu9//Ja4P3+O6vuKxPIERNWIkVXkhUK4RtVnluBBYDDc1miQza6Qj2eHeaOZ6XfD8/IyXlxcQBTw+PlYDEjDAQQxOujknP8K9XiJoxPWSW2QZOyM8ljVikBbhyuO/geJOT+HlOqMLHrOWutjJOUJXfdRLey6lVKNoNUzNDPi5Oh/Y2bhMP0WeZ0zv3yN+/TUevwko/8fX4J/PiHwF0d9pW+UnRp9iTkdIz9QRt/X9rmMiBwfMcIdVbmZb90GNbMzQtGTlBYXHo6Dp5Tgjf2Sc/uoDHrU92Qz2AZzxTmePUc5XLL//CxAiJo6YphPu5TdT7gYz93Iv93Iv93IvWs7nEx4eHgAA67pWgxlgr+j0AqkXlPw9XmDvrpEJ5QCyMUoSsj3nDZsT5uQ5Y+ib0sKuGWN7BNhzB8JQ/TkWphtAMbb5qBgz2n6iKDpdPeK50Rhzww4MdBmVw+P4NUCsN1qwflFtn9Wjz2sDS2nPliLqRhA0Kg8hk1jtB7XEFk8iRtBUSTFAI2L0bWgK336sAOC3/vb38eFXP8Cnr36JT3/4L2u7AoKC5Q1YtKE1QcGEGOYNIVzr3Nra8/NtBjEppX7OqwBD9Vl7TnLAttzKhQtQeuOvcT3dKl6I8ePT968XkVt1tPuuCjsVYCGQS0nQqiGYR5aHi5vg/3mA53NA7bFSaQQ/GgBSFWrWPFAFvmR5GuAYHKjL7T7dN7KejnN6A01JZZ/Hvnyur9aXWwC2rcmebrR7jsBUT1P8/cfgW/9cCBIymosToG0dch08VVD6vdfTul5huO+/gZ8VoeE+Ass4HrUPpWhquOMxPQZPe/B+NBi8pTyENu9Lxq9/355ufu6ZDoW6cUP1fnfAtQfA3xrrjn7bugbg7JMAm+sgkdYanbJnGUVD45acFfyUfNW2Nrno+aBr0IByG+MYRCFRSMCHQIS8rdi2LDmi1w3pFLGWgqfHR5xPJ5weCH/0J894PAX8xZ8+dQYzAKoSycZQfXfr+UZsIaR7wLDteL+vqAKH5t1awNioYEVAMiBdv9tQarSZBlX6ttkPdcBmizRzPOkG2RtFax74PZjaX4W+adjb8FS59b+GE3duhT7EuG8dd56U1t++nx2Y6z6L2Wmv0LR2j+0cP1mtIxhNsDV2qzZ39nRHHh/e1X82zi6CaEakGedzRABjWTO2dcF1ueD18ox1XSXcOwBQAyntTPdn8G4f3uDj3io9PdH+faESpj10fJYevcuumXG6v9/3oYXndobYNe1f3tFBoy0jTQwUEMnObW0roypPA4XGswJgS2sz8HEG+tp3tX5TZq6mFB9B49YWbxztedq6PrQfNteW5tTOlHYOlN6r1LXpSH65dYYe8UNjXX6Mx/Htz2rs6h2Noj7Pz3yRWcg/aunmxY1tKaIMRwyINN9sZ6VJ/dTulEOknzT5364OOPoGNOOPN9sONHrE1NHhW5TBzjNrW3f+H9xP8PTzmN4eUUTuvm8jcItGH9a582CX1gRI6kQzZ/LPFDd+QC9DjKer/zSeLWEu+N3/8qeIDwVbCbhcGd9/X5C3ImkIQgSFhEBFo8RqCwnNOaDyWdRdkyAJQouy5GlGZWeHkWzj2MbQj8hoNDM+1/9wz7swsCwrnj+pgo5jG8tBWeTPILh74GSIt3josTCzk4/2skgpGZviNQAwTTOIChIHpCRRVAzPeX19xbZtNQVMk4dR2yNRFM1rXuVpNBHC+hZT1PM4YNvkHSECaVKnlbzgcpH0slwCAk2YpxPmeZYzyeEbfhz9uNS1eUDH+zEoehZIaog2Rj2uc6S0rP0+uF5XVLe9ehykXWMAsa7jcWrZDtOOG1au171rXBNHeIJEvY2tHWa4CUdHR7zG2qh/k/WzFMHdNk3FQcIDWKrlI9nSy7tVbtb+1bGXV6mcE1WZLU5yW16wroumbWztDJbmvR+6w7PVfy/9oS/GBcbi18MxPvjrF7++mG9R8Xaf0UUbw3Yd1dmmfgeT/ZrcYpuUGCK7W5owHUzDvXK2CNBZaYdGtYgBaZowpYQ0zTBcJ8YZQJQoESDENCOESVLQp0kimg7GMuPeqsUwEyMoxMLLY4OlsyaoEQizRhX1dH3kE2w8etOat870TkSp519v9LJ/bm8w41tQz+BBzuvOku697YM/620+xcljuHeowz6bYVE9PrkggjGHBcQruCyyB2PBpwMOhLseidEMU6htZmaJoqNPSKI6rp9tJMxoZ4KcOxfKWPMVhTKIxWDRsH4KIi/kLOliLZDv+fSAQAHzPOPDhw8VS8ql4OXlBSlFTJMYfn369AkfP37E9XoFQHh4eHB8fdEIVj096M9paBv2TqFAc8Rt69gijheJgK/Stp0b3thf+H6GRakXw9X2vJ1X3gHA2pQ0jRoRQKm13WQeoOlcuugyKl9lx1OlEMFEWEvR6DrSNl86PsbTb7s+8DEdzdXPLTqPEH0WRqEb09pWW3VcFONSYz0UWErbnFcwAtZtQ74mnGtK1f36b3uJJLpMJszTSaLU3MtvpNwNZu7lXu7lXu7lXrQY88gsOasfHx/x8PAgoXQ1NKA3JDBGyDOCHmhoDCEqMGJKwhjExytzBqmFcV43LMuCdV0lBzUiEAI2LuCcEaKE8osxOca15ff0ihNTCOdiVstNqC8FyLkHTCowZGBXYIDMkKMH9OyzV9bEKCEGhUlv/TdmOgRVPnhmlEIVfNt4yjvEwttYQfXksIgnm4amJxoYSAMdlJkNjFJEMFnWDSDGPE84n86i4Hh+dnMPyTUO6sZiSpPmK/URXUiEbacUt7nfiig1M0sYRtK+iLARkIsa7xR275bPFmEDIFwul/qdjb+/3ytMrG2lFDw/PyPnXIUte9bWyTRNAuZtG9Z1w6xW6N5QZhT8/Rq3d3mhwtahb9uoWGmASIM4qti/A2fE2yGGYzZVlrbGP65wySiSH5ej0MSjZ/W4x630YJJFMSq1DwSL0iSRoMBe/ephDhWMgP2eit77vTcyMhpi82HtOzKW8CDsDrhGPy97haoYkXWqaq0j5xa2ul0S4dhCgN4SOL3Bj+zpgG0rClADzIScBewiijr/goBJZKqWzo3CHhg8AjVtPiVYuNFFBX9qFBt7oIUwLSpgxwo2W5sbjfDj5cfDA6ceiDyKLmDtrvMAB9ITHa7XsY9HZRyL/uJtSI0USTbl8FinrPf9etuvIWuDoEG1mQqkBVKQsZ4fLcKZTNGGZduQlc7Ze9u6hxpEGuBCAEv4fQk1XyRNIWno2yCpvrZtxXK9Ylmu2JYVHz+94uW64LuPr3g8P+Lp8R2+ev8BKDPWdRqHTX8rBEhBPB/d9yCg+O+qsYzbMxqhxnZX0bWyAYgoWFXBlyyyEqiCdKWq+dycwdSDCiQ76lgpozNa2RffuuPoBq3/Y6SaEbr131rdhFGhaWPjjWb8eLXvGqRr3xkA2yA7PkjFdATrYtfONka8e9LPbKXH9d7++cPWqmKa3JXdGOizJQfkJSFOMz68/wrbWbxZ1+WKnM9Ic8bryzOW6xXMwLv3T6AQBBibZpRS8PHjR1XADOnEhjPgVhkB/kq7lL4JCfxy45vxnfac8Qejsq4qIp2BsL/uveiN57UfQqgGtz4inuefjn6SGcUADbQsel5BvaRdBL7CwtuZ8Yp9PxrqmHcoAFyXK5iLRjrQaIGFFWRO1cOfQAouG8hMu7nIOXfG0qP3pfDOsTtr/bOjgngfmaCn7SN/6+coBOrGZt8WU0r1fLIpE0cAvXmD79cq0T5yyT9macC/qK8AggbVqLys8EIis8VASAzEPO1aSe4HaLTxbZrc7vVUyf52O3L3riNF069bRnoshie3a+Xd7DQjHu6+bW3s6Xz7NCoG+if9G/cj4Mc4ICAxyW8ERKXflmoIep4a/bda/Tl/VO+uZUx4uXwNKgXbVrAsK7YsHtIxBhQkMEdkS08M0kiKEcuyDs4J0q4QIgqAKQTEOCNNE7a8Yp6AEFuv2wjfnvlRyWJnqJ2bGXBnZzth/Xn6tz/7BfjlWxAFPD0+YrnmZrA88LP+c39WNHmvKcn3z+7Ht51hQaNFdP0jYMsryrog5w3TFEF0wjw/oJSM5+dP+NWvfulosrxrXVcXTVicZeKUlPxTrTuEiBgCAjnFGEuapw1ybMSY8P7DE0pZcV0uWJYLtm0FiJFiwnw6Y54fMKczoAY2xqu1MWqfmwKy0WRpfzOUbWeFnQU9/sPs8YOGEXjcyM/FGK3Got7aKjJHBftsWIisV9kHdnY1GYldv5Rrs8+E+rvuAcbheWPGJO3sDrDUUMNqqX2vO4pZosiQnjGh3qljsWHLG9a8ouj4BpCmmjFO+miN9++1tV3nTvuWUsJ8kmizOWcsyxXX5VLxGztPK36HcX0fUMMdD9aM7Dx/8yW8WsNl2vu+hF8cy/hMx4e+VR2PdNX2nqZFBtXUOh5nsb1sqSXNiQohohrUFFNey3XhZwMezg8ABN+UtUVA4RqFphpDp4CHE6mhXcHp/B4fvjohM2EOE6Y0IaXpTYfK3fiEgI1EJiIqCJRBuIJwgiQE2p+Z/lySEZI1OZ5L/q63Z97LiO7bQSYbpagR0Tp6vm/3rbc3uZHrX6j/4w3eaOSHChUEFvm5AIjEmCLjR18HYJY9PU8z4uMZ3wZCdu0eT02LREcuYrTQaCCTGE6KsUzu5ESCGNoYj/H47gHXhwmIjPk0yxlRI8xI5JDr6yuenz8ipYDHxzNCmFByQJoe8PXXH/D111/her3gF7/4BX76k59gyxvO5zPev3+P9+/f4+PHFzADHz58VdefGM800uodtrDj5RvfbRi+ORcYPR6jnEtqQYmCwlCH0zAhhALoyIaQ9EyaQJpae56njicwZ2STSew7i/Bv52vmUtu0LMtwNqE6NBstoIgaWQos+paUJpGxCKBAmOcJLy/P2LZ3AGY9B7Ji+uwwMD2Lo56phbtxW7M3PiKkKWJKhqdnMBMUtkIIErlK6BgDsLM8i66FCxAKIjFiIizLC0JMwi+W6Yt4+ZIZ19cNp+kJZUso5d+VtPTvf7kbzNzLvdzLvdzLvWgxZsw8XC16R1PYSfECFYBOMG3KYa+kEOY7hggkzacbAwiMSAQOKtCR5d8VI5eQEkKKkhMXocMMfWj0sS1eUVtKAcUIOOBh/LF6rE4DPZgiQujr9UKgt/JOSZjazEBBFhxEc7ELAkHifR97zwFjylWPre/SINpO4R1j0lyrojwvlvcdzbtIhGuNbFOUwYVTVKMoMy/1yxzVlrR+V8UwYP4LNgYeBDCA3wxiAOBnv/fn+Ntv/hxbWNV7QAQKsjku6NYFbHhCcEIKd+8YFUr22Sud/Dqw6+u6VpAw54xpmpBSqh53y3UVbzxQfdaEE6vTz7P3VripXLsJ1tgzplABAHYgHLt+awSc4p8fS78ev1CHt1MeNpCD3frr+zcqkCpQUwQkbLb/sgYFJyOH2ImhRwcU2n7lBry1/N2qHCKG5ev+jN3Ero9j28f5eqsQDCwI9Rtrs6Uvq3fKJlYQi3frtKt3aI8AVSqK6HqQfke0KDLqvQ0AiJrfncGcd30yWuLf1yllTeFzoLyvUZcUiCVADPJI+6iPtEhQNm9u7uuYHK+fUYnQ7Z0BsPxchCcrR3vSr/FDsLWM8FsrRA2KY7j1rumBFHfp+nUEynYKbyjwyW2x79aHA7iJGCgFJW/IZVPwoY96VcFybmC6AFFNIUAxIpIYf1GEWxsEClFo4JpBOSPnAMKEEDNOM5BCxA9/D/jBjzZ8/Z7w/t2Eb7464V/884z//Z8tSsolXRiYNICzenG7ra9dq5905p0aogcAsw6EqiUciNgDkZaOAfZZaY6Z0wRYhAIoMNpHFbBafZ32LmIPilJ3v7XV7mX3dH/9tlGNY2N20WfY3TN+8n+bUZAZEmUqLrqMX3s9INr3qQG1QefEK0778W/P9kYz3NXaK471TDGeDYTiWhfmFd/88Z8iPn7A/OEJzLPyNREpydoOAWrA8Yh1ecW6KIgXZA2fTmecTidcLhe8vLwAgITwdgaVX6o4OTq3TYnl+/el9R2Vo7OJWYxHpkkM1DxAa/e+RQ+ZWWk69bwwjttZDUg0VLZfYyFEIHrDj/acjc9oDOz5Ra/gNEWYnS1E/j1ACC3VazW8HaDRsf1+LPwcV94PBvAfPze2+y3a7fs1nusCKrfzceSpxrGooLKltgVXQ/SxX0dl5Nv+3RR/rutakEOx0nH7npWKBJp2tcidw7zq07eMZv1ialAAACAASURBVPZnhimgenrT2jk+h4OrqO8i3p8HRy1o7xS+ibidTf1dRjPb6dBT+vHuo7cdtPfgPf1T7dwh658Zo+vVCEJCQILwgJkkoQv0hMya3sXTdD/W1qdxlj78wTPe/YcXbNuEhSPKhbBt4hQBaunUWioYT/eazOnXEcCV149B5FQ25VKZsOaMUpKm/joasX7Ux3kez1dJD1Kq8UwzmQHmb77Hh3/614jxh/i7lxXPF+EdY6Qq2zOb4fJtnrPRGKVOg5zQ3zMUbYzxnGNf7X1iuFE0Ogdj3RZ8/LiCOdeoMq+vr5IKqRqZRJWTF6HVqtAKOi6sTg+A4QTtDJCWcE35zMg1JZM3EiSIwm6eZ8QgaSqEXmpsQkaloZayD+DOkL83gmnGij2/b+uBVImZ6rMivzTjF39e2FgcyQ/yd3NmAJrTS22PTZBGURXeV9c0CZcs9clzpZ7VjfYzm+zvOa7g6iU396pwVqeKutSU95e1om0rzbimtc/OYZlbWzsxBMVx9P1mVMMFIJPHHcUlcmsSMBm4kzdhfJr1UdbItm3gYmMfdXyERkhAlFLP1reKP79Hg8VjDOaoEp2qYe/+fc/bN5///HHTfSZLCa/rUHioUMeebc10/RR5z9I2xyifs7rMNAX+3BkfxxiRQqrZcZNGgDJsakozYmCJKhUFQzyfHxA1mtQRJjyOiX1mJmSWdZiipF8KB5Fs23CYg4AfqL1jw+1z9fbAM4BdBFT3d233wd9v1XlUPFdwtGqb1Gh7imERa7y86Je01VX0ezuxL6+E//N//IBIjMARU4iYSsTy6mV17PopT0s7IgselHQGiFsKJoakSiYAEQSwOLckECITnp6e8HFKuF7WSquMdjEDMSRMiTGnGSkRUkyARZdirusyhICnpyd8en5EKRnn87k6Pc7zDCLC6XQCUKrRfqWXpU+TCGZwpfsuMimO1+u6rt2+kjRmpfIsbVXKOdjomNBp2ydyVoVOTjDaJc5Nue5Bb7ADop0smJIY45hjiNVR9SGVXrT1QaT1Kc0gImwbY/u9n6L8KIIeklvQtn+HNUGoacr61eewe0iKJZO/5ByO9V4KDc8sAFI99yXSkBjQGGJT1Li6GXje2nOffv8vwF9dEGahYSiafo7ijSfu5dctd4OZe7mXe7mXe7kXLWYswcyYZwln55k5U8T1AEYDh1s9vZpGmCJh/tI0YZomxJQqiBEDYc0F27YqQ2tAvgpYUHDagRt27SgMqDGRRcGZaZpFQZAlZ7Jcj7WdpsfsvJeCCfDNaMJ7f3og3RjoRS3G2xjAcZ4kIJQ0VNqr12Q8GxjjjUd6UF8VIhCrb6JYBTmGSEukgFlhrsyyYD2hAm+lWH+hilhvlBN3XrfWHz/2hQXwN+Hd5nt9eMaadByKgGWFC8rWvGz3/WI0ryzUMRm9rN7yHB/vXde1s8j3BlZyTUNYK9Dk1/X4jL1rfJ8puEZwZFSGG2hl493WaTOIapEr+v6N9d8GY/flCPDZK3Zut/0I1PWKNHmcVJIxeL5/pwfbx7414VaBNTJguD3d3u2AQOZOiDzq6xEQ/Va//O+2Pm3s4UCsJpB2AnLdaOjqGks//qjPOJm+G09mv+Z1jKkHf33ZhVfv5s61QQe6GzfSvMI6h6Hbcz3Qb22Vqsbvj/erKVvHvdT6v1/nRwBce+ZtMPRIifm5UoFpArhY1Chtm1Dem0DqOAZWCnPLBuH3MjxO4UEdCVucsxgdVjCdewBYoC9Wmu49prIoY4mAEKUvLE/EKEoRChGggMvyirJl5HxBKQHEM55OwDoFTDNwesx4eJcxnV5wejojnZpC1HzTFWWEntTSDd83eG7AgZTapvG+0WzkgIrV+k1dGAjN0xIStam459spfNwm+VupFcFFzml1VDrW1XC7x75nX7b6jos/4xmoaakyCjI1T3kzmBmfvV1vf9Wgqn1fWl3U/XVkdtZaa+9gbuskVKBWvEunDx9x/uYBcVZlO0eJosXCgyVKIC7ARdplytYYAwprOopNolxYTvdbPOmREcWu9Ttw3/ZlP/NvPbenbT2vPEYWAXp+8ujMGs+r8UwmsjZ63nPfnkqrwZLZUaO9ye1GKMz3f1jR3Phda+fYbuOfRl5czveetzJAud5bRp6np7Utml3r42goDc8Hu3H09drnMVy78WGjYc3RHN9aO75dNg7+DLO6TSFgP0fv7N+xN1gY+3ao9FN+ZWzHrXb790klEMVcvadRAVP0llLEEP4NgxkzwBvPAXLX/N12l4fo/YrsaZHd08+XPz0Ox06rG3c2H/yuhphDer+RIgiHYKYzR3fcLkctvWXY2193JpDOAInQUjFFEFI1si0AoZrJmCFjT9O5Nyg6aEZ6AqYfFGzPG9YtopSoezjLOcIFTJZYyxRGrkrWvRrsPBeeoGIOFKSdXIDMWJYFr68v4MsDAL/OuHJnXTO5v8NcP7j+g/vdHrHPcc6Yv/ke6xqBJSOQnjnV0K2f4yMeszsH3D1vyXGedokRguEeAaZ4s/va3lUDhCBn4vW6oGi6i3Vdsa4riKgq3Nq5k6vjS4dZDO0ppdR0sTGqbF4KqHo8sES5KQ0vanKARMv0Z4TITAFUFZomBwZVnsmZFqjRRaOR3qnFzgmJ0Oj5A68s05l256+XQ/x55se0j+TTHFqODDVNlj56ZycvAW7FNZm3lFL5+a4NcP1yspZNk5skua+os5S9EJA54n4uOWpjrC11b4ocEUISeTCaafr+LLVzWN47tMeNhsmIEtXXFOiyt20tGf5j9RsWN74TaE5UHV/FYjTg1+0XyY51DPbyZpP73j73R37P7juSiY/KLT4jaFQZoRu2BzTNbs4S6c/SeIdmSDPPE6Zp1mgxYqgQanrvxr81mmJrvactgpHKGEyzOUEKNjnPM+bTqSrBPQ9zxE942sIIgOIaxBsoZ1DZIPHOYt0dB7upfgZQ5c29WT9cHe0cGw1zjxwUel5jX47e5VGvo6eaJHlcp+9PM7ntJS27byeFuAiuwWgJgJwJ3/5EkjBGDmowGzBBIs9am/24HqWjCqzRcPUErbyBmwuLSiPvIswg5HnGlGZcL4K1zpMa4iuPH2JCioTT/IAYgUgSFUlko4J1aymEAMbT4yOYgWkS/CLnghQnUIAai4YaqbLJbKOchHoGCua9xzo9vmj8u0XJL0UMY6ZJjVaKGNCI0R9Qijp4wGhHiy5v58fI56eU8Pr6CqA5eizLgpiawbG1D2jRzQ8jlMIigwndAAOBGKxtMBq8bRmlAPPXETGJAV10comnWQ03H2ipnd+k4+hkWmZdHyrbZdbMAiRuTKxOd8IZKpbJDb9iZiAE5JJBUVI/+vW/K+8X8DevKJjAiy2Zt5CPe/l1y91g5l7u5V7u5V7uRUsuGcuyaK7hBjiYsQiACryMTFufbqSFXJfLjTFNMYr3AgrWZUHOr8jbFdfLM56fP6qCUKN9pIiUJjT4XsoILllbLIpIB7IraCzArgo3IVTrY4PaTLCUOi0ii9naQwVFYVbztknUBxIwYtsyiAqu16Uy2FHNouVZA8saSNiAWqr5XQ300Z4pEy7tK5FBKMibhb5XppxIAEUdnwCHGZC+BOY9KH3iojbcpY0h0HsOGwgnQFlUYUEVIaEpZIQJX6UnHujTOiV906YW+F6Y9gAXI2cWYMenwXHz7cGuUTHgBXT7bAo0U9BM01TXiOXqJvWC3LbchQc2ZYa9ewTXDAz0aZh88cY5rU1Bha5mgNUAOknpY0IWdA7tu04phhZi2sazTjXRri1HpRcOrX1w3/UA8P43YKKyV13cUvaYN6F4czSAtIGGBgQL+NL61SugxvbdAqDG9XF0zRdfZ99m2w/WXwM/BriERGBHjzN39R/OTY/vgdnPfRO625x7hca+vAUMVrJjbTSC1LXRetR6a/TJ2mL3eHC5f5907Jai0CuJu32rPfPA4ufW8ghK3ur77u83qhW6L4PV6tZ1ip523QIFuz7ADbXuUbifQFRnmCHGMiVnlLJ26QSFPo/j7cAgNbgjLiAW8AzsospoFDIzBI0pYAIhs3kGA+uy4gUXvDxeQSEhBcIyFVAs+PjygpdlwYYJf/gfP+KHX33AP/+/X7Et6mdFqEYmBmTysFvG3w1yo3FHdYDcfrq4Uh/ZpbZw2d1cqnEGdT8HNMHVa+f9UUCrRrE8yOnbN0I67e9b8M2tsNt+D45vEGMZxuaMZeT7BmfKk7dBIz8XvpUWP6tBouNzPXzbZmkPcPfvanBwq4lA4YQpPSCmBwAnBKQKqBEBXBjX5YpPH7/HdblKygAIP1I443K54HpdanoJn5Zz1/YDWrHnWY6/c0fAruyVZXKzj8bl6+0UIvX5fVvHdxy1v/IGaHzrW+difTc13lwvtr2rbsadyZgeIKxpAnbv7877/v32LiIvS/TnOpECo2zGf9zVX+uqfFN7/9G4jc/fPAveGKOjMe+es7qpnXFHZ8JoeG398M8Yn3mr/H3hXwPSD9uPG3uio4ioS7jyJCy8Cte5sucCYkr40T9ZEGPC938H/OrnzYSvGcb0dJJ6EudobLuv0bQ9Ld+bdu3L5+9w/R3orb3BdkVwnt/9ffvP1uaj7/218bthSD7T5v0ZavWoqQqCpjkkUDWUOTqb+xPEfad9Donx9HsrODDi+4J1jbiuASgRxgMDm/IjGVVGYFuHFrHD1qLw/2aMIXLmhjpjxBB7YVEkXS7PiNeAE97vRqGtldYpbxBjKj8zNx/POP8XQdqYN+D5+QXbiooRcDGjmV4W+Jw8AnYKWkdbdmeNl6OCGRu1CBPm4NIi3DYDkJQk+sr1Kt7ZxJYur4hizHAJ9mS8Nzxg9rtNrxdJUSX0kSEG3TJPgQIomKxfNFKJpKMQPtrovdEPBsiMJADWXG9NF+doJvWRZG12PF8O2NqRflY+1+aYobSqx6j8uB/x7tWIg40f6aNgyDpuKapY+1IjqTlcxkdX8+NP5Hlkk69anwB00XY8rmKf7Yni8JSRstQ+6u9QZf4ihiwa+aWUDJAooQuafGXG6HZO9dEu5XpArPeb4tscYQQD2mpfeqON1mcbmzaWx3tqPC/rmn1DFjzEA2RwduNrsnaNjDXs8xET6Z/v+RaP6b1VHJmQtaFODbqJYFEVZbxlviNZpJ+AEEWteTo9YJ5PNVVSCAEpTV375Nxu9IRqxGnFY0LoHBQnagZwFALm+YQQzQin7d3eUG3sn+M1KSBgA+UFvL7iu58AlxdLEdho8SiFMFANYCwSbjO1Qic7GoU/3BG7KDLsahjaXX/6U9m+uzWrX3p+Hz87GhG3b+3do8GPT64ofyvuSxrBXM+/iMYLVLqDY5nX3hUc33DUMqtFDHMDeN1wfpxRHhKePz4DjwkbSVTqEBLmNCEgYp4IwAYozShZ4r11MgAYp9MZzEKXhDaI8w8qbtoM6RpP3TxDTWaQyEux0h25zDvjdlvrhlcZPfAR8QIFIEbM04xlUUsN7nEWox/j2QNoqjqN9GTviDE2o5bc0z+fgtbuBXq8ObNFfEkyYyz8VAgBW96wrAuen5+R5jM+PL3DfDqDKIBLrpHyzcBWsCdb81zHyuQ4GK0M1MabIeceC4eZVT5gcuZtROBSkLloymZN3VkytiypIdMsTs6BAsJjAf7Jr8Cq/yi5YWIxRNB5k+wFhQAWNMT0SPfymyl3g5l7uZd7uZd7uRctl9dLzQF6vV5xPp+73LTG9HmB+Raz6cMUhyBCXUpJhSxg21ZcLi+4vHyP5+fvcLl8QtmuYPUYZgKm0wmnhzMulxVbYVBkkGNgR7B5VHiUUlBywfW61vCK0zQhxeSAdBE2U5SwpaJ8IBAHZfAEeJHwMNKP63VtoEABBBhUz7jQjAi8aGWADToRpTGPMUT11tAUWNkp64nEQIfFsISZFQx04SFNaNDaTQECGPjQxKJSVBDIOlYkHoZbXlBKwTzP1Yp+27Ja9DejEgnr3LzI1lXBuQrCNIaeCMh5q6EsJYywQlkacqcUVG818wMclQ/ynrUz5hoBRn+/N2Zh5up94JVWRAHrutX16+83IcZ+7B5LneA9A0ZBJqVUn/ERh0yAaoCSB+to11+viGtrtYn/oQplJFOONh63jCdGkNZWyNH+Hp9tn6Hv38+B/e48FrVQ8FF2CECs/W/j4MElgjciuWWEcUu5dlPRhR70Gr+XnwjmFkmrCrykRnQqsEkVzQvs6B1vKt06IG7XnFpPV3T/H913S0iUiFNGH1V94MarMCMydwBzpVnVu8RAZAxzVhtWfzyg2VKt9bTbg6ZFBWjwuDZx8J7+2ueUDm3YuHuu/+zu18ns70c35keKUd8eKwUAh1D3J9V72+dAQAxQIwCJsNaMigJCaIZz7ZxzygylE0GVFyG2PWMRyYzuik0JgRERIuHx/IRcNmzrhm1jrMsVHz9+J9E6UsTDOWI+nQFMuH6/4fzVgv/mnyb813/8Df77/+GKb5eMYielAb5ATV3R/78vBontgcfeSLbd24oZinSUyk2lXOvr9r/9+Ti2sZADSrndaQY1+x7Y/Lba7P2tUYNh0Ge8oPSUdMo+VAOZXH8Xv+t2dfDw+Rjo9O+jCr76J8eaqd69f8/RuysPpVeIBHCcpydM8xNiegCzRJjhAljUky2v+O67b/GrX/1S6lH6sy4bKASsy6UaZ79//747u4/KoYHAkSJlOItvlaNzWn5D00+wKiwaT2D1j0o6D3weKV6O2l+vWxqWW4eIe6f9hGDD7OpnZciIG52x/cSqaHH028qYvtLzAUK3JCVAjMI/SVSgxntN04TTfEIIEdumMgCLstCnih0jINZVS20VxxhqveOY+zOnnn3FxZ5w58g4ByPPUUpB1n55/s+vgzEqpfGhFunB179XDLv5vL0Eb/J7Yz1H7Tu4U+/3xtD2nbACoofgel8IUY2iAtJM+E/+iwt+67cYf/Z/EX7189Z8o2dd2yFGemaQsacn3D3fPrnz250Vezp1i+rd+nqsh7vPt4xmqhc7jLfd83i3Wjj+9UW0FHt6Pv5N2M3gjTe2Gsb3d5+JEeeCH/5XL+BUcL0wLpeAUpKoykii2REDJMKl1MBuDCstaa0lWITTqA4NK/JmUSgCChMoALmIQU0YBojdb/8zflcOro21dKurAOvGWK4ZJUcAYoxScqkOIAAcPW204XB/jWwm9zz46AziaRo41L02paSpUaQ905TUeAVV6bVtV0xpVnojXvFm2CH1o6Z43rZV+csIsIy3LQsyGafy82I4UkpG3lYAQEoB0xRxPk94edlUBp4QQkLJjBgSgODkfcUK4GWCth4kbR239oaBRlYHgh6DasaXQDKDEjY1ccOErC5bc0fzJso6NZDSVZNigI9+DFA9n+p6JuHKAKUJrIY2RJWn0S3hzmJTeh5H6Ki2Q+77Q+NYJ5/aJDcDiGaYFlNCSg2bWZYrLpdXLNdX5JKrMY7JuTkXWOSgUQZp72eVDx2PgahtlzXmjWU8dgc9U44E4PFsG1No1bkTEOnN5/1+6+RFJ0/ZeHV/D+fNEd4wnr97HtObdWC4Rt3vxs+0uTbep8p0LN8bPkIUEUJESgmn8xnTNNc9SBQhGZbaOAhPZFFk5F3W5BB7+TyEANJUkvZ3TKnDO25hKccdVn41LwjbJ+RPn/CX/+wb8CshomGkRykTxUhEdyCpwwS3KCfy9d7hgvXZ/rQbjWaMXzg+g9vpaWf9Xp6z9u1r7Ou5dcb7a+Pf7kVDG9sbiz5AMCcc7SdlMEv6xYBQDWnNyIUgNL8waq9kzNqb+l3Qt7tRREnR9Prpe8y/RZjevcNPf/otkBPWhcEc8fDwDuf5fT3Lcrmi8IpICdu6CrV2TnQAwCW29Wl7IwJi1CE/hlvaTy4MuIgpgJcBbK+jOlF6mcbjUobbW1RMw8FTmpDSCfM8VSyYqjFrEkxfHe9Gua8Zu0Z89dVXNRp6CAHn8xmX6wUlN1q5bVtN55pzrvTA8ww5Z+TVUllFScXNBWXVfm3Atm54fv6EdzFhmlLNJMCFEGMB0YSXF8b1eoFh+57emgMXkfQPcLwCKQ8IO6uFxghtEuzXFjQzC80OjBQCYop6jm7degYT8OEC/O6/AZcLLi8XLNdF9AkUMU1nEM+YyoNgX2rMuy6NP7mXf3i5G8zcy73cy73cy71o8SEKj1IQMbdUTcasvaWckHoipmlW4LogRvFAapFHNuRtQ6SAOE9Y1TMqxYgQJTznVoX4MNQtgI8ZUIwC8ais7phpZxDhI+g05podI9iDzJ4x90B0jBFQzwyYIheooSWrwt0ra0GYT6cugo8x5L5PFvXEv5sREBT0YlMQsAvpO7RdwihzNcYpmo8dClxZSoNpShqRJaOUBdsqnoICxmlIZ7aw+6iCvI3r0fhLm2XNdF6p1LylpKkNWPLglg/DO0aouKUEsJywPnKOGbGIkU9Wb/a2lta1MdkjgOa/HwUfe9bC1TaAw9qvsz2AI6PnQVtPTRhs7zUw3sKAFuSiCuEgqgcvZB4BFuO7vLHACNYeg7fQudP9eKD0PcSKyQSrUOd6NMqx8fic8sevCR/x5yhN021DlRttRFN4dPuUbhuj2D6Xz28ARRjXkYRMve3b85srFspZxr6ofirp+uJGq7xyg0jSEnEP4I39sHEelY3eQMYUl0RmcNdo57ZtIiKPAPAXlKM58XTorXJrf+wgr2EdHMFG+3sMdBeDRKYWTWYHdOse7NrLDeyWsUWlVTtDHoO4uLVfrmmoXQvRC1KDHK0PYqhDICAGlLxhzSsul09AYJx4RkozXq6ERAUpRTAR1i1gW0sHlEGVidarHsAc/9fnXPoIBiMi1M/2pJ8J/+z4XkNiDBgt6lHfe9PbP7jWwbVT9z2q6kIvMLyxB9yTHijk+qzV01/37/ucsYzvpyn7MsRAZiPGpr6Ydt2P7pHhjK/TnvAtCO5ZU0llZzbjr9NuxFrNGOarH60R/CWEONf6QggSYYai0o4N27pg2xblkeS82VZG3ggxJDBnmLHuqDi7Vb6UPtvfb1OR/XONDh5f75RFaDyA/928IHuevK/fGX7cilS0O7s9/1R0hbZYUDH275Jnam21Ds8b9IYnR/yyev4H/3wQeqJ8k0UD9AaZXmEzKs6Mhtk5XcekXuvHe2yrr1e+U9XCwPPdchKwdTHygaMR/2j4nVLaySWfW6//kGIyh/X58LqWxgu6sSnipUtRon3mXJDdGMUYMc8zzucz5nkCwgrwhL/521/il383AS4SSE8hWoSTGqujYe8dfTw+cRvV21Oekc44WnykhDv4bW0cvwvuvBmjRuzf60+l48KOFnva/FbxdzQdRP/cWIMZWQLszg8++Hf8PvtUiABMmi4yS2QJczbmFutMnGSa+rHtqVbjEU2sa9Q+q5JflMETynxGUMXR2GefgtHWFKMZ1pbav3Zf+zEKOHIcopSWCLWiADI+bDdOn+M3QZJCxd1/tCd7owNthTqoTGnCNKdK03IuWJZnhEA4nWakFNS4QeRHMVQoeHh4qPKpx0OYWRVxJEZvMSBQ0v5usJRNBDNyNXkdKJqCaV1F0Xc6zZWWiRFNQglAjJIehhm6XkZ5p+edjb7mkquhRhtjmT8baj+GY3SL5vCSUbjJMUaXTU4fo5fWtaov9OPV02p271BaH+RcZWOwiWGe+k2u19VAZswCMVQ1Lm6g1+MZMvIF/nsdHVGJV4WqpGC11BshkMh23DsElWI/LLxBEMNAMR4ndQZr4+5xg+AMeAwLM/7COxyN56WPOOpluVtyli/9fvuy83O33yoPdSzDvfks9nNl7fJ8xlvP36pP8L1G3w3nMMc/c5SLQVwCYhB+apo1FVOMEkl74DWP3mfzx2iYWYjKz5DVIfJkv/aMZ9rL4G/z2BJBdeILznEFToxMjEwFrHFBe9lx/xlwsopFIXOy3sFb9X/qvinozzx/FrR3krAN9bxv0hYdGM0ev7f9ddu4t5ev/Lk7ynajHKWxZIQ3IaklWrQTqPxIuf4lqRrlnoSIBAIhoBAhsEYtpZ4zGMeqtYS7lgQGynZF2a6IacLDHPHy/B1eLxmECVyA0+mM9+/fifMhCFuR/s3nk9KEnh4bbgyg+66e0QjYtrXx4SR96WQkeAfflu6plIJ1XXFyOLyXObJGPbHUT8uygNmM2CStLEj3qBrJCO/SVpHh0B67tPq9Q9n1esU0TTifzyhTxKb6AItE41PaWkTVhqG1NcSlmonWtgWxmkOIYlzH7IzvwLheryBqEdZ7+ajJQ/8fe+/3I0mOpIl9RtI9IjOrp3t2dvZO0kk3u4D0ItyDAEFv+qf1H+hZEO4gCQedINzeAXuzezM7011dlRkR7iRND2ZGGt09sqp7G3oKNrIrM8J/0Omk0eyzz8xqrS2rjBUglT5R29/6OHN/J5EAigihohKBM4E5S8YY3dODZdViLR2Ylfwyz6g8Y7ndUHJESmcNsAhYbxogG8QfQpXwennDsty2i/HRfmZ7EGYe7dEe7dEe7dG0VVW8zGiymsN7xbUOSh7QDS9v9AoxYQGRZN14eXmWDClV6pNyqeIQWReEINkFrteLRrfPqKVgWW5Y1hXzLMxlr2ACoggaicOY1wbAe3KJHetra2/bCNjtAS3/rNsIWyJJDyiEGYIGU7WsAXpJSeOo6LBkdunGpSmjzNwcJv6zDjioE9SUctE0FXTpTdIg9t8pSE1bDzBZRBozIZYJQTMdCHGEBaQkUWTNmOipe7uDKgQpewT0aNueTSI6YglgcCbJwMHqIncTdp862cbcA1ae1HUPEPAKvwdloxoNKaZh/C+XS5tTdr5lkPHPZXPB7i/GQb/vfgwspfbodLK+92NkPlQu6qzgZg73qShRa2rFi4Gipbskmm1f6sEbPX7Odnx6dExtQc3RSSd98KDZ0Ag6P7/eCTQawUdAFDsDbx+NvTXs7s2JI8ebiW1s1QAAIABJREFU3ccDoWb0+Wtv39cgi9hAm697Vr2N4iA/JXXonTHXdkRCkibyRkSGRRTZXNwAXA186k6HezJz65zcAoVHDl9rHmwGqUvrK0DFe/ffOV3uNGrr8Hh+yC/+vfczv7YNgImC1pIG3YNu2geGOgcquBZQtSJDQeUjNCX+CNb3e8nfgQjEHYTmwC3yn7QEYa32XHKFlCYEq2HNQOUVS74A1wrgjGlirIvUHyeKQmbgGSmdDoG9VnSDmr/gcOTMOdeGCJBa15sjj95Sh2r71Yw80pxlZNllgOCAww6oduKMB0ftd19wIYBgKbxpyIIwutbsuhWW1YYbeUZIKNzu+7XNSkcUiJOzkJBmLM7Zk4t6X/Zj2Efq/u99POSvgNCckO9dl9w1tm9s36u+Z8k+PCPGSdLPq0PNShlYZLToF0qK1PrrIUzDXuUBun9Ku6tL/FTZDtP1uPXNH7MFTrfX8LrmkXz1vzMbWfb4eY6cNk1ucs+8JxGDVfdZc5AAA1hP2JG9vHzfOvfk3USU6jMUUNOxYkytXOaqqciNXG2y10iDgMtOQEZKoRGIZnNQHusD2/3e3o2J663z1MB7ovG9SOkPiGPKfefJ7tv+2ngA+wyI9/bX/z/aVic13aftYSTZD3IuKrMJaZrw9PSMaZoaARak8iompNMHxOn9+5r8Mrlj0DupvO0H0h0Zdux4AkYpNB51PMZHVJH9Ttvl5Jas4a/cHGc85rfZ74F+ZR2RD7eN2v+Pn0avqARPsaZ0nKkTIG3/GAkz7zXGN3/9Gb/6myum+QVhDqhXKa8gfO/a+8Ry12Z5smYlQp9jR7v6lqzQ9MfWA9ENp2kG/8s3rL/5HrhlxH/7O2BNbQ4d7T2dMHPwnrnbM4dPzoTKLPKrqK7M4hzqZabGZ/D9HxqROJo2x98jQ4hd0bUQCz46n85IkwRMrOuK61Wispdlwe12Q+UipRVyUeceNxnrZaFluzLblJmBClAMAJemZIlDXciUwrUQOy3nANSCylXLh7ISpSyAaJJ1bXr/duhhOkAvMyyYhwWY9DEZCKSQcj8+iGZrL3qZy2AELeW4fW6PB233XcGqzJFHzdFaueqc8XpHz7BL1AN0pJ9+z/aEg9h1BC0tckTA2D7TPTsM5GwbcgROR+YUp6/qpEom4kaIIv1enZ9GtqECU+qHcXU2u9xyb3uy3Yc7luH3S79eGuHpHVva6wEDFnPHzvDnfGl//do9+B52uL3XHjP58jWHd0zUDQsiIIj1IuWXjDBjxJiImBKmeRan8cE88biF/55ULoWoQXEarGhzpQe0ddygYT8/Q98OxKBQkOoNE18QUwZTRdECu5L9RPuMPgRmf4ltaTul3zvH3XPbs+3e2vY92uwK8uEwlySTzaiXvBf0cDQq92wv/5nXLQgs4n/IWHc4w4dPW2kmAgKPdm3X4cWujUSiC3DEBDs2SNAJjGiLpivUoewxAGJkrlipYOWAhQgzBfzVf/hXqH9fsf7lFfhvf4/X1xXzzMgrgeuKjx//DKaCc55xfk6YTxOqykoJpjX5oJnQKjXswtZ+aFnZC0pZhGRiBEAusmt6kp/q8pa5zOawEVH6dTu2n1JqZH7bh2UvEvtlmmacThOen14kIxkRUpwgWZ2EhlRKxrJKxha/jwESIOsx4lKkNNKHbz6g5BWfP/2IZVka0d4weyOqS6bOpWWooZhEflZ5ey1YSISukl9l/a7rCgoRlRnr7YpPnz4NMsGCo7fZ1mutoEqgSIMqx5BAJYJltEbTuwpzy0xJtmKDlPJkrlpZwIKqdXwjIaQE5ogfP94wzQlz+oB40n27Vrx+/oxaCCkyahC7NRKj1AUSTPNov0R7EGYe7dEe7dEe7dG0cWUleIjxLuVqqpbU6ZlkPPCSc0ZUo3wAmZmQlNHcjFsFF6bTjHmOuL4Z6LMgRiBQwfV6BTBGWEh5ICCXjBR6+ZtaayMzWL+MLGOgyDRNzRg3gGSICNoYls1odkbBFiCwa3rlMoSgrHxz+qixHAiBO+Bvxq+Bi6a4GhnEiD52j907shSUlRBSbNdQtEUyGti93f9h90OPzjLFG2qET9MkBpCmsTRgbJ7OsPrtABBTBDkHiB/LsR6rGPYl9/JE8kxmePf+efJFMw3d+B6Bi34+3gORfH88ISTG2KJnvJPHj/vogFN4ny1F8a1F/LRoHwUZ5Fl9/XJCizrg7jiJgQHu0DXFoGASQFrqqznaFZQCi2EyXt/+58D5zZz1QFPrk5rHzLXVjjbQTNaXvZORWNPfmRkknYjRx96nLPc9s+/HiDKdvu7aaMCaXMM7BH1/Ao7ub/3s9+Dhu71TlNr9ma0f3H6X+T864Cx6z64fXD1lO27770gw4TtG3Xukj/eBE7n0Ho6pDUYREMVkRiebRDOtBdgHdWcCs3s/4723stP+7c5RuHfTn8tAC0ABEbvul/HKu80DsEcg6eDIbe8Zw1wwOTTOD5NZfgwwfH94P+gJZKC1jSdg0dgGplu0rrwXc9T0eb6bV5Ze2mGq0HdqfxtZkxhAFWDRnBTWzxgYUbELISxVvF6vuN5uyPkNhBVPTzNCOGGiCWk6ofCMP/zjD+P6HX6zOO09OaTDnP13sv8rGNeG6GAeN+D0zjXdGwEg7zkQt/TTkiGeOpBke5GeI8f478d7k5ui2z4QtyeBxb5ZX40OaplraJMefNsYfQyMLJOVLFPb+Pln9plfxj6/93f/rI+qwc9H5KVtH7ff+6sA/a30MesIm41WLowALV+kAoO1NNmyrPj8+RUh2vPJ2wkhoDoHF7CXt/fae06RY7KMm5Sb2dd1lK5bdFmguiC67Pff+3tt9ckj500na/CguwphRgXtZnugdr06fqh6hD0TuT4yCwFa7kXwe74dvdW5vFz3z2N6eDuzRSx7AjUaSAru+8c2o463L7Z7qf+bXR/6KxxluiesWKkIr2/Y+dJXHt6PNNFHJFrf73kjEdTO89ly/Dv2z3esl1hn+hjeyyZ03Lr+5MfC699N7fIOtLb/933bolpDFMfc8/MzYvBZJ+U+BQkcnwD6OsC6y29yn9wjyWz/Os7i1R5pd6/j8eXN7/f2nuMe9M+GY7aE8aNsjO2cTsG5vzPw8P24N3UpLh8YKZZ1D2kabSvr5wkzY1+67msi5fRNwjf/xRlAwu1WsCwFNetI1VWc5bb2uD9Ty2hnnzj91H6XrCiu9C1YHcJKfpOaPMiZEWNC+pYx/QUjLhGv/w/Aub+tCtFvK+Ccrl7fGBuND97GgSHZW67XG8o6g6vu6Gz9Nnm71R3fa6Ossh54Obd1aPtL1spatoE0Gp6writiZLy+veF6vUCykwW8vb2BuLZocSPTeGdgLy0hGWZETayAlqggyHiHAMUCAHDPRhJDQFSn2jQlxBhwOp1wuy2wLLItoKXK83s7LZcCRs9YI8/YsaUUI2qg4TNxlHVihzVzNNrnfez6viQZc+oQZJXzqrb0+PY7HEEtI7KtouBsUSnJlFv/qkXMM3Ru+P2Tmr1q3zFLxiKutkZ4995t3+zXkOuYvdB+SPVZGu3hYaRI7C15J/ouNftbTBG1hmE/DIHEOapryM9Vcz43wkXo2Zv1rYidoxmPjgg39q58uWrTj4cR4P3a8cFk7+rSB+uy9QGms2yl+/6cTs3Y65o23l3P22b6fc+m7+/L3j2RlM6S7KRyA0JASpPO86RrPTXMKoSI0+mEEBJCTEiWaYac/okNkQeWNUoy1LQMM5vMNH28zMbUOU298M/mkQBHHLWPRICuiPSG5/mKb+MK0ArQlozxvo6z29c3JRK37chGZDtv33vsd3O1CXmvb9h1vE32pZ2A7hwz6gObrHjc16FZrdtr9L28E268HuTEGgIYBWSiqO1lNoxmewrBtqKS6Ax7RYtx46IBO7IvzpcX4ALwueDpXPB8fkIpESVHXG+MHz5f8Ofv/wFpSogTIU6SeXhKM6Y0Yz6dMM2TzluAq8jKHY2JGZUzFlTcblddHwHVZZExDEr2N93ATX6zvDEjTq66Xxo2FizzPCBBvgzM80nI/inger3i9e0Vl8ul+SNSSjidnhBCAlfGst6wZMl3296X2QtEqHmV9c2y/16vV4CAdbnh7fWzw9N7BjXDtgW3nxFCxLIuUoaKncwBJPOKPiPUR7IsN9yuV5Bm7pumCc/Pz4MPZV1XzPMMIsLtdpMySCEoXifX74GgJgtZiU9VMGsdPXmGOJjRJueklFNAjBWlauCbnVkJzAHgGeuV8HR+Airj7XrF7XJByUWJPUJMymtBPAWEYGUeH+2XaA/CzKM92qM92qM9mjYKETFNCDEhF4kaak51U8XZomYKROup0JytkK/1SFIGciBlqgPLotlrUkIKQIoJtWRwzUAAasnIy4I0zUoQEKJAmiNqZeRaQAhDancfZbKuKzxp4ygdqQcYPIniiJCxjcTwWUWGcRuuU5th3a5FHdAM6ICD9au4OtgGYomCCb2fpO3lKtF6ksJQ09dXfQdocEr7HdQNDCEsdYOKQKDgs7N0o0GUbj2+MjBZGSV12MDGveh5Pq2kACkxihIdSCMYioIS5DPzdDPOHOwGB3cs0tLF6pzyoAP7DC7dLCT1APj6tgYwWcRwCBZR3VuMEdM8oWhEgZm+pazye2UYDGvGQ84VIRiwKBHa2/r2oSUD6sZa1JrTDEAyfVdNrwsd5wCQZrahPudhILiCfzCnB0ENEiNjtcmpc1GsYkt1aoMsIN/o5LO+N9vS1Zfvk97NYQLIZjaN0H3ri4Ehbk76yLsOEvq1qoYfKy4Dq7ktfRqj9Xr/PThloP8IVm8zupD7t4OxtYG8DvRU+TaSoOz5GJZRwINn/b7j35DZ0m7fVi4DcIDbFri53whjYRzXdGzJ/S3vV+cO+pqkPhSgajQC7tfZAJBN1hC1NdbARQVvQZ48Y+Mg1wkaOfclf0N38LpHwhj9b4CrgMLBzYfN2DEPc71/7GAv3pzj7uqfvj+LAd6bLAsNwO7gZM3qVNV75bxK+Ss5A1Kg269FdW1ZWHeT5dyfjWsryQcFxAUkZUiMmKastfein0OJCtOUwKi4LRXLuuK2viGGgnX9gBQTECLSfEYuAX//n/+EUkb5eSAlDkauA4qe8NGijhR0o3bM11zTAYFDThS0Wu1R7xFUFhIb6GjZYKQXBIMqSTPUUJ/L6OCj32utkYK296/hxLKuuKNns2exMhpGlsmaGQCwsiD/9HZ0/xGSJPeW9sftV4MDa+8eryPEQK6MVFUuBACoqGXFmhfknHG9vuF6veLpWdJVCLAmRIsxO0vXc/qa7Dqc6VNCxB4dLMO+45Bl0XNccY8B0O8zzvYIu39f++9HLO8JlNKC033JjnOdbd81QBL7+5DbC9u4WL9VHrLuCAzNPhZ0T5DZ14Dm5oiQFVRVcDpNue39tYhOMhC3bf80PZqr6nTUMy4wGim71oqa1cXPrER+lZSVUWrtsm14bj1+97nq5d0z4MYf7m9ZWUZS7mqLEdFtD1KZS31P2hJt7PrWzB7pRKP+bKaOtbUxCL0v7T/umwP7xZ7BJFDb17xOAzTHkTkuxRmh7zYExJhwPp3w/PyCmBIoRMyTlFOLIQGIqBwkwxmLa+DDrxn/1d9koDL+4e8iSsa7zT92dwsdH9NX39cRBbfXeO/zreQaZxjtPrvXv+11/d5xdM57faPh2H7G0f7YnoPEIVTQXG8AMBBluI10b9O3N0zfrUCYEMIMpoCn37wgBMmyslw/o6ysicAY4hR3UdssNzfymryrTl/xS7NWJfY6539/sirZBFgIFyUDIMKUTjidTzjNwGsIbi9kf+ZQFvLovbQz7rzMUivKdUGtEY1G2+QAnPK4mS+0/8yOqzoeYL/WpIVNyWl/LcFcMpalYlknnOuENJ+Q0oxAFctyw/VSkNcVzAlvr6+IgZruebteUXIGNDLb5IAFaaQUQRRRKrDmAmIh3sxJMtBaQchS7H0XpGgZTKiVpkiJsCxCGim5IJ2mlhnA9kOT45WNxuXLYbMbP7H9d1mM/YpnwLK7RDO0YaVQoQ5cnfOaUSWGpBkVVe+2rb9NzAqdeBpUI4TyUnQdUV99bEayWwclZz2mE2QIaHudnz/MpTltyWS/XtvbsHZPNzTd5rE9SOcL696Cth9YVL+OthKgqukfABACIhJWWlFrFszCMC2bs4ME2895e2/V5EEVwgzASqgbyWFGLGklotB1R1LM54hMekS4AfirEtpu98fKQhhqLAGioUKyzsJml9h74s3al76OfTJ7pg/VeG97hk6qHfEtK/Fu6B6zZASd55NmAC+NXGBnpTSBQmqkGbH3dO5zbccZzcXs8xCAGBnT1Als9u5DSO1R217hsU1d06T4Rztw89Q2bhELZlxw+Zjx+mkGrhG5QDNzoj2vzzLTr8QHs8+OG3WGrWzfhk7x5nd/+JFuYffdbxd8eK3j9hWT9M7RrCWM/S5xd09rmgK78d8/s/xe2/VFX4jtnAqzO2vbV+1qcj35O1PFhbPoHGBMUhQOfCOE//QB8/wBE4ueGGnB9XzBj5/eUBGwXBfc8oIUJzw/fYPz6Qnffvst0jeTyKUQULI+O0mgI4GETFEly2QJBeAgOAUBmStyYUi2ctN4lEirZfCYWTBdkgxNtQlnweHzmoXQo3i/yDXg6ekFKUUs6w0/fvqE6+0KgDVAVIKEp3kGEFBKBZUAhAhizT6vss9IvYKzd3L5bV2Ra8btesHtepGygVzx8vIiY50zAgJyyZinE9I0N3z9uggp1iZ/oIq1MEIkpDmBc8GSF9D1ImUSKeDlJeDpdAYRYfnHiFouKPETlmVpGLnYRGK3xZQkaFRnkRE0ga4SMRiRIihasIZ+XhmsWc2ggRlE0Mz8CSECsPLxsnEDQWyMvBYQSTnQy9uC19cL5ilhbmUzRf8sJUuC87BfqY/289qDMPNoj/Zoj/Zoj6Ytphnp9CQKEQs4FChiihEJCaUUZSUDpWbUCiRVzgSgoGY4gghFwa+YIjgELLniZT5jXQuu6w0lV+TlhhSBSAVrWUAKfgQrOwQSIywwUDUbRh1JLC0yzTkgfFSnJ9b4Y3wdZTN0BzIHjQZsc7YcAOKs4AoDCLUbwbUovGMAioEi3E07AWN8ZpYIq7sdY8I8TQJwkBAtShDlPVJPPWnEJlIngEWPCJagZSIcJuCfoTvxAaKIlNQUYujYMnKWxJzW+VwWSCTymFnFItYIjJoziBUqpaApTePopDZAkCQFtJQW6gQYU/5bBJdzlHSH+OiAhxtXSxdszyIlxiSTTEwReS0atSfATckrLteL9ENfVV6LOpOBQMLI17fexs1nMvEkK3NK1OYc0ShkrgrwMVhLrYQk87sUKXcFTiCKDbiyFKXydqIQXSzCiyVCSDrda8K26C/tjzmbbH5L9EEfs3H8DiAL92zFIohJ5jcbaEYbQNMBX8FCXvzd3Bo7Iq619SJIjRvbvs73zUCt/h58BEQ/ykNI/fnkeKsX3J2J/noNF2rPNI7TPbKMb1KsxcZQJuqwPJxTa3y2Y5e5lN7Z34d07Xq402SGrC99rna2jFVzKFKXd+zmfZOTMFIIA2QgBVrKaBlILcWm80UHD5UzLCfHkfOrD5aNY+9F5Z6W3Uf1pxQ0S4InT3mHTLvo5hZehiiphEmeCQLA9O8BS5nvp6ssK1+uT0FUlrmUIiFXBQ8gQCarc6hdmTvA2F+HlC00aLmBQQY2W3QRevYNA26D7s2BDTYSh3jlrLJO3mOMEXOawLVgKQvy8oa3t4+YUgTXJ4mAWgr+ePmEUn+FAV2+O6q0+9QALB/hV2wOkovkM2Ic9uDgFky0kgsG6jGMeiR7j6X6DmgiS37Yfm9wfYMa/erzx2zJLgblUivd1PvrYoNbrz09bTvjbZYVMFaXWUZykRlM5e99f814gHdH8Ll7lh3Nw3l7YJaHZxoBZQ+n3u+dRPxpyu1SUGrBmgtKXlFKRi1Z9lvutdJBfr/1mTPc2jR5xVYWqDSnRGXXO3tZ8GvfDpD+mbNJ9naTQXVz3+0+g0FXBKAE29zudUTkJiKNCu5lKIwcwu7Ydg6UjEHdySEjYHKJlCht2WlMLxQibiPLMqHJYHJyH13vAAgICaRAq0dJiw4j634cUhLdJKjyRTJOuWaUtWCehcZmz5tzkWwJQYjEFCViEGyEGXGwGsmWmlxX/f5odrpx8rpvH8OuR0ozl407t19t85vMnUZARtdj/LvbEpm8PC9FCY620mx6O93Ck6+6IjQ8JrYSqutvRloYyfKSHSeAXd/MPiCdBqRkZItgn6YJT09POJ+fYM5NYtKqoAxQANMEpgDCioCKf/5fL/jrv87gpeJP/0tAye/LKTR5svlO94Px2PFsav+/L+9s1zy+BuBH6KiNozted/tK/H3se9tzArAr57DRQnbX3P/FB6PV72mWmkSR17bPOM0BftX4+z39iwu+/VevSOlXmOITKCRZf0WIbPmWldRq2a2qOkKgumS3tWuXPM2x0vVr0bFLWRuhzCKWc14lc4LkHoPkIEugysiFUUov/LR9o5VsfLe63sFo0ZHs6AfUIiVEuO3rAUxB7CiyUCC9+rsbqo23ssbIMk5JvwyPsHGmYGSCoD7oAq6MXBe8vTICFRC94HSaEQJjnqSEwXIrWG+S5SeGgBZnUYsSaHoJoRiTfF8LYpgwTQk5C2E1poCkP9MkRMZcNDgqkMoHJYMjgCuwrjoWuqdYVllPJAB0H8g92MMCWBiSWahWoJYRpxn2PMtqofuwOPV1jNnsW0gJm6pMqyLkjQAgEgCuEnhUvR1lRFK5dltFbHO7l102Z1xQvEPwHwKqBEWNdiRalhVWIg6RrE3jGHg9UPRTauMjK92eV+YOw7KrVNGhba8hnffEAFd1sKveq1mCSG1OMnwkCNERNJJmCYSyZpTcbQQLiOokjzDsUc0m4THLaIBm2dSx4qIBd63PXVZCMQu4ebMNQNkSX7xc3galHO3Dba8GaSlzxqjpsjj/a9U1FEStZNGdYEaak6rtPO7H683cRtBlYG+GY9Aw193XYJbAM8kCI8FZMWq2Cy0rbnhHiJPoUEa85t5Tsx91msh+RL3U2jQZ7hF0HVfVI2w/sZGWCD7Bl6DRRfJOhVTGrUS82Fg6tsSYseCbuOL//tuE/+Nfv8j8ZAlqqDrGZgN1K+RoP9yMk37U9rSW9cXNLfc5dldQeom3P9/VCLYde09/6N8c9Hx3JG3+asdTL3vT7cr9M/re+Flq8sRa1Q4Ri+5biZtOSjCkQGxQ/xTb0WEwClVclTQzsxBm6Icz4v/2O6zoMo7/6jNe/gfClF5AKeFtueHj58+4XVe8vl5wvaxy38BIacLLyws4sL5bbnYd1WgiEikyfvXNdyBirOtNjiGRcwW1kRIBAsWIECTDmTx/6DptiIrzEziXZiuKbI2gGBCSkGtuy4K36wUAME0RMUWAxG7PpaDUBbVqOSJIxiixuQoKiswxZoWQVL7A1GlquNm6CmkX9CzkdQSEqMGPNv5EAAlhiKEEZIhvYK0rzqdZcCcw8lpwvd1QK2QfZuA0TShrxuVvP4BeIuZ/ccPr6xveXi+t5CrFCdX8HAFqlxXF/BxxRuW92S9WDpyYJfNPFV8CsRKmGYqbBJFdaoREHQPRMSpCLGBexZYPQEoBMUUt98QIiIhTxFoqmKKUeX60X6Q9CDOP9miP9miP9mjaCjNKBSaKOD89uVS5Ei1SS5ZsKCujVklDG0NA7UkSYBqTgOYR03lGShNqYVyub7i8veF2uaAuV5wncR5yYCzLBbfbBTEJISGFGZESQFGUMWiKPwUazaj0KfktQ4o1c1paGSYDsmOMuFwujWRjDPKeShbtgez6vnSPL9UzkHNiUGWyAwrmEPRpkMeoktCND3ctUAVxRIwdwE8pYpomrKvULCX0muGNFKQAkxi71EoCSMpVSW9oDp8tsaj3wUcDUhs3qAnFXDGF1ADCWqvWSrcoYZkzxBm1ZoAjatX4fg4azeywElJCBwM1M7iIaT6lJGk5q5StGt4P4PrFKDof+9xgEKnxo89saf9tLpRcdFwtrS1wW67icJ+TAlwVrGSUqiSaqCQrKc1UhznngbIRFDECmAGG+p70HgAQioy5zT+Ze53Q1SPtoFF7AqRIRh9o/+TdWrrkVnbLOXOO++dMdB5BJkuV3MkK+kRaQ/jo2dt7MOO2ear6sduSC9vWSGdcYS5qGYc+D+T93s+3UCt0DdkQkK7hrH2x8hAMwn0Dq0OC1K4jL8891OZZjqLi7BgDRCWy04N8hFp8FK6DAn9SKYZNqwKSmxN3Wz9+l760vScPUlrfvfztMoQZqKz3Me8J/JyQdN3FORndoIzPiu3Xo/O5Vs2ANhBT0EBH/yBePhphZptdCvCyY3d3vX4VwBu9r6TgeJeP4/oyImEgwqQpr2+3G0Ik0BSao1j6LnNZQIWq9Z2136ggqu19CHBUGmBeikRJWvyZ7TNGGES0TDc8vF+2VNiQyKugEYxcV3ARuOl2ecVtPmGangBMWN8W/OGHv0cpL/CEha+ZnQOAuakd30FSAC2rlYG7BnAP3W/PwO18eZ7+N2lGC0JUYLZTs5T8Qh0gJLDLcNPdGNTO6Y5Hi/Sn9n8XzUduNjNgyYgty0N153Sgvj+bZZZZibGg9Gfz9xhGYxyf7RhZ24K11vcOJ/rjRrjaQ629191tew8u9rDt4LCmgNP5BZ9+/Izl8gpAnHMfPnzA09MJITzhdJ7BXPHx4/cAZC3lvCBQckTdqg5AWdM55+YIkrUl0X+AlrSIvQSIyS4rJbDdz9nSS2uvvePG5NHo7O2t3t+WDo7tpBjrvzW/ln3fTN81xzQN/ZIfy5LWyDdOlscQJQqUhLRXSsU8J4k85E5AlHER5DgQYU5CHrZjiKR8BjXQWbMNulkjuoum9Fa9oXIFKrSsKku55SWcAAAgAElEQVQNe01TDoY46oaShZa5sOsXQggZM85M04QWNbuR5228qi+fJHq0+WE9sd7aEfFlq+v4TAjDfnNwLlikUDjSmfyx1XRZoEVvu/0HCG3P66Te1msAmrlSSdIxRCE8gZR/yUDQ1PMk4D0DOJ9nnOZzSz8vY8UoedVyphGk2eTAjMIRRJM4I1ARaAIwYS0Z+Zo3/TpuJrO38hDAjjSzb35fHj/F5pvRgfRT2tH9R8eR/7SRQiH9D+q8ZttzfoI+dyTXN1rO4X0DmdPcP/9eUnuH/ZQ+4HR6BvCEWmdwkajddVmwXC9YF5kDpBkRxPHRyQTmcBenlX1mO3u3Q+DsVx8IEQLBqY+qK0s55RiAKQWkyMCa3ZP3cekO4feyuN1/+72XATHMAIeWjaON/M9I908kARcUxL6tRUhzMWhkPAJkvaLXlrKdn6FOzYJlqbhcxIGUy4zr9YLX11e8XV6xrCumNINI1moBw0oQ2f4oJa67c35dV1yvVx3/iEAJp9MJU0g4zQmn0wyg4notuOWM7OS+ZCrRPTILdiB2t4zX7Xbd2T59D4q6NzBAcdjPjmSm6PwVIRoJpYJtz0bFWpemd3EtTh6rDFX7MecMaOkNIdenjcyWPTdNY2kawTecvFfCjZVMtj17W36PIYTSWqzUkchh0UnEaclZS1KGXlZK7lM1EMmwiK55WjYD6585LHup4J4FGMxAlP3eAoliiAAn5BxQa5T9mCTTUM4FOb8hhtSeM86+THgnfnjczWNL3VYkZCU1kc0bzfDjHlR1wntr5/gL3x8j6BzZcN7W7WURobZgcGMGlGqke92X1XErxBwSfKrJth5E1vtkn1sZbYIF/3VbwR/rdYiu7whGEfWd9L4LppMcbtXffwgBqfUVQlrRQIs2FiCgkuIeUQmxCSEyYjohr0LqE3k7gZU4QwC0AqU8LwHgAioFhIJabyBkEBUEqohUQFVkdACQYsB5nnCOC/7iqeI/nTXDssprIydU3ZyD26W7bjC8/WHcgWM9waiKI1HGWyVmO9HuOodowIHs95rZcdtpNO/qIH0v2+suPcOs7984Onbedm/0Nqo/s+j4ZzAy9aAQwEgzR3bn/qkqGDdkVIpICGr3EgLbb8AUgQ/fEAqdMJ2eseI7/Hb9KyxrxR//8w9Ybiu+//4H/OOf/4iUEv7yt7/Fr3/9a5zmMyybujA2hNhFFDDFGVNKYJb5JjiUlMsDdJ01eQzkUhumPE1TJ12E/l4si6eVppc1N0lmNH0p05zw4ZtvME2x2RIAcLld1a6Q/p3Pz0o8kTK1t9sVt9tNstIAqDW3gNMYo8IdrDwaQkiEy/Uz5nnGNE1gzmBI4DLp/j5PL8i5Yl1vWNcFuRBqXWU/VpJd5YBleUXJGZdccbutyGvGFEMrsRpiRJpnrEvGsizSr0oN7wZDyCgGblBtew+gGXyUmGsBBbLnBbETo8tgZMRVFl0wqU65rhlR8TLZQwpO54jPrx+xrivAhKenZxipXzKPC7mmRMXT44Pm8Uu1x0g+2qM92qM92qNpa+AADKS3KCI1ZAw8567CV2Zxmqs2TDBDrAMItUp63mVZBMRZFkQUpDghR2AlRq4ZuVRleEtmDebQyj1ZgmXGSJIButE8RvWMwLgHpHPOg1G9jUgxZ0up++880ORBcxKtrgEYR32yTCZHTnR/rPwuGRLEoS4O/mVZmpIvkR9CFvFOHmaL+qPhHluywxFIfwTay72980F/tOulFM3a4sEey3zS4+hlLgSXYtbGXoEgBfYlcq0TKWqp6iTLu371OcabskIjQOdJT1vHkQEsrO+uvX+ybEadIFBKEZAp9PEzsKin2sdw797fcezbd64fHSwRg9j6IIf4Z9OorSBOOVIDxUAVA163z29/78ky77WjecRtrfvvdo4s92Mt0CgXtucfkY88WW07zu89i3RzA0tQfxctcs990cCgn9HuneUBrXtgsF+bvbzY5rnanzyCjV/ThnfUActOfDnw7pIAbjL9xvfYiRxK9DCwslbdH+TYUnwpDO8Ydu/ZgMSDlPT+ftb/vnZ0lAbAmNo8MQBiJ4/3V//C4AFCQNyf1zIE1f6+rCQTQeRxO1bXojjns9RcVrnWZQ7BHKOthBxbeRQtLydiVEBGR6KzR9muOQ/Edme6AsbRjhdQN4SAqNknQgioqNJXdZ4b4coiwa1tIUqgkzCORs1H/9n5HnT065DBTQfhLRhKPYK9th+DD/X/ZCvdom0JQedOQO9tn4eq76CTZwRAlCOb09M9qz/fmkHkrABnv59dax8lSIAQZcBYqUo5plaIaQuJbiFjD62afPspcr6fcfxm7a3w7sz93amNq+8PADz/7h/x8rvvQeEJawWIZ4nO00NLKbjd5ImXdYGtHUDm75Sk/EOMSdeTJwJ3+erXgXfgDFnq3HNsHbdNZliWFLe2tnvq9m/rs+kO43f3GwGImp1lu463JMfhurW2wd/qrF6+tPvYRBdFw6Xepk0fFew0ogqRlJwIMtuN8NGcUHoOm5NGf8wxVGvV9OFBS3pQy7zX5h1rFrhmT4x7h9fvrc/dCSZOXHbvakdC4XEdEck7Nue93csff6Srb//2e8w2m+W2RS2Her9f/vOxr/Y7ml5I/TOM88OiQUn1SJNbdskQJVoVJGSkmBKmNOE8PSGFydk6Qhbt5LBtByV5v2UNUVQdhAmnp4D/6X8u+M2vXvD//jvG//V/3g6f055m25p8aZnajnZw/U5lmD+XdE/l9slP1+++Voru+9V/qtsHACHNtOsf7GueIH0ky+3Nj3K3fwfdC2ujrtHuCP93GzeKCIhg1lLIecWab1iXm5ANDnSNe/NcjhvlETCurz2hQjdgSIZbiVAO4kwBg0tGyRVUCphPw/PK//W4tkT8DtV/Y+xHgUA4/c1/RH35ASsvKNDsnsyu7NTeSf41Ta5TtHgtoxQli0SzIzdr3etpQfdn1a9zWbEsVzBnfPr0I97eLrjdVpnvASIDa+/jEbHPiCId05D7SkDHiuuNUarch0iInKVkva4jhiMAQUoWQUvMCh4Cl2VGA1NmzRqk2eS6bSB2fym59c/Pq07crIgsGVYaUVJ1ZAm6GWVgJ8b2IISRnNWzvg3vqVaAYzu+2xO2j/a+iTyMgz5u5/XnELIp2j7hsn+pY1EyDAFm8xtZ14ISmk5hyv9Bs2yobU1t1uio7+iabHqPEohjQMkFJRfEWfaAulnDfk/05OOtLXaEBWzt/a3N77/7Wpyiz+t9/3a6kv3ubCF2eynJi0Q2ghMDVFlLYBJCNa191JOOOyZav5C1qCXNttszYxjHjuEowYohwRVqGwvRSsqkkVuD1iRbDANUR6PQrDF75iDrlmJCjCdQCMh5wVQIMc5uvkhJ8gD0TMVOrwsoiCggKmC+Aljx+38f8Pv/EMGI8DlpCJpFh2bEwPjxUyfQFx0qZmg2JCA6++v+CB/oArqv+oyjbgQO3xpt/hVR+L5853f+2n5270rvP1s/23Z/IxRLphl/oa4vHGk4A8ln0DXcmChRppoty84upz4c3mZFs4PHlnXUKwIEu6+wwob5T0/g//W/QQUhhyh3Y0aaKn7z3yfU7xgfP33E9z/8CdfrFd9//2ec5gkBhClOSHFGILTSghbQF0hpakHIGTHGXZBly8rFPMgs2xNkjyvtvFGvd3p1CEjThKQkmOv11vaRKZ3w9DRjmoRgY1nsLShzWRYtBSiBTuZzadm+SDM7xYBpnpT0Y/JMSjOGMCFGgLlgXW/IeUUIESme5LskHV6XihRnxDjD5FuMSbL75xVEBcs6YVkWPD094fm/e0XB2mTf6XSC+S66zTwGXvjWxkptw7YbMlq53thOVBlEaO8k5x70YLpFihFpmvH6+ln7IIGmpdaWXavpN8BgCz7aL9MehJlHe7RHe7RHezRt5phmlpSCgTVVp9a5rgpONLC9itJqMdNG1jCwy+o3GyhQ8opapD7yFCJCZDBnVM5KxKkI8YRAEZJ2VggzDAZcZM/WGjAFdmtgm9FXStFo5NAclFvHytbo34GTB4b/DiAkqHPgWFHr4IrLrKHj5UF/oCvnclxtxBT7W46R7CJduQ+ba/R+yDEdTNmSY94DJ8aSA2o0KLDmjYsQDPTT8lJcBMDxLrjqDXd5l1aSSMajO2EADECZPdMAEFi62APgxb9/P/5yXb03d8AnUifU2DHmkCtK3CEUGJFG7t/n3RHw419ow7Ds8RU9l2lDyNkc/AAQEJNGN7Ddi2Bh0MLK1z8bSCSOqCMnm3cuHfbv57T2PPvnHx+ddr/be7XPfCSffbZ1hO0cmbQHjKzZGLdxHrrs4BHqx1H76pc3tI7Hm9s8GvrXgF85pn/D7rOfBtaTIukGUTX5ppetOOiH76mbu61X1K/DupikLFdwnxuQ3iZ9d2I0TNfDL1/zLHqsS1u7BWv9XNnLu5//fnnTS3srllZ23DekHMqUOtkLkMi9NS+6F/WSUt5h32WaORUYApYUBR6FJNdKzcQAcACqkOgsO5wH2nuP5TuJNJR3L8NStb53QIhCSmDddwxIYtZ62NN0dxhVGombjgQMG6DbTXrndl4rBeNbBworxBm+vZcHQsVJ1ikd5gaU0dO09LrHWG63XpLJfjzhtFN1WUFEVgjQv22b2e08vWewz0jJMh6EHN4IGrC7oGKhihVVCEvDE5Hro7+jf1I/PvdJM8eAb18fOxkwfLMnQ5GN5zAmYwpwBjC9ZDz/sxXgGa9vUn7BDqm14na7QWSjZJECpISiZUwTgh4jxgnr2kscWTSc30u83gf0fcR+t75uiTL2Yxns0Byme73Py57jsUXr473j27Us20115SJ0/TR9US4yvB/GqN9s72m/e32PNWIfrNHEcSxPCqjOE9z+DCFEBLaSQ3ptFwVP1XSyasK+peeHktBrKWCKqEQAm1xTpyJLRsuW8l9vYsDzduy3zQjl2zH3Y7D9/Gva0bFHTr+jtr3nkf59Twc3GX5vhxRdZ6s/BQBSEsvkjsh40rkjfUgpNsJMmiJOpxPOpzMiT5oNgwCWMjhyL1snIlEV91adfxVZr/sVcwRjRggF3/76hm+/qTidvzBO+n8/u7c79lGEt36hI2RnyL93j/+ZrffHS+WjZhJR+rbdKzA84/jMnkDTpfqguX2xl0YH73vNgbxxzwTXVyACHDRQ44plvQpRjoWEBWCwm9tdD9aCyaYjmXfkPDcdTZwpUR0kWjqWKggFqEUzrvR9r78L/5nM7W12RtFfeTM+2p4+g7/5CF4qataya5VUTzI992fMKbax0B28YRkEyRRlGUpM3kJ17H4cESEmK+Uk5UzfLm9SYqFUJZEWlJoRMZIktzqmxyL6niflEUGSNWhdq+6ponsJUVWIds1W0fsIp0f1fJasVqvtu6EHYhEFhBhbaWDZZ4PuP0LGu7fHkhlq7Ws13lgdjjrOnnyfc1VdgHbXs3HZ4wqW0RStJCBXoF/W9Ggll1PPWoKmT/YVH0gCy7wMF+zB5rvJzNo+M+eu3Ueur+Tx2O0nex7LZkA2caw/rnnbojpCDjtcpu0d1IlUgcdr+PvusDNnt9/LwLvt01F7D1PYH9ym3Q4j2D+/7pFuDtm4yNDJxeyZuLLIHVbKvdm3tp96zZj8vXxfDAcb9Q7ps9e9ez+tkB5TEYtD6qeJXsSsBBZ9drMxSG0k6n0aZZxigEqsCnFCiBMoSnbTXCUTKrOVTmGQFr8T+otcUXRABtUFVFfEUJBSRowZ9Trjhz8kdZYPuxrMejK7DfJEzUqozd4CCnqAA7Wzj3XrbbPr+4yjjk7ljuzXPrJ3vqbtLaF+9r1rbHUaL9K2/dlh0XrHYa6BG4bVrm3Z2Dd98Xu+38fEDu7ZT+X67mjqtriVZDT9ptnS2gEGq92q1yaZSZEJvATUPz5B7tbHP54rnqYT5m9nxEjI+YZPnz/hdr3hx48/ouaK5/MTwhMwxRkgKcMjpRGLlKZWWR5iRKxRbYYRIzYcw9tLfm8ERG6llDT7Zd8jrfye/X46ndEyA9eixEkS8kpKol/rZ5L5UsZyWZIGTq09mIEk2xWRYMEhRMzThJvi6WmKml2tqF5kg93T8cWURNfU7FG1MBJXhKDBJRQxzyfc6k3xVwlmNhw/fgDybcH19Yp1zTifzzoe3O3pGA6yRG/0WdYsRaSBU7rX2KQVMWvn9D2nn28yWYlXVXBEb0OFYBlojOzrbZ9H+yXbgzDzaI/2aI/2aI+mzbOGBdSuSvXvzgMpb2SgkRruLpIJMNNQmMFRnRuBgLxcAWac54TTROB6Qy4L1rwi5xW1Mk7nE2ISljQQFVyKvR6uOd8OgAD/+xYY3yrDR8daq7WqcTqC0GMmlwOChlcIHQC4BccHEEv/v023368vSqNllrHSH/bZPajWW1NHYPw94HLbz62DyWonVy643fKQ8cMcJhJFXGBJ+WNIDTQQwBD6XA3rcqaV/Gvpo5sB5LKMeMMnWFpwhM286GCXfdjY/BsrtpFqCC39vNxDDKHmsCBJIbmua8s8I3x5au+qg2F+bvTnbWmVSYFn7sda/yQTTo94rqzGsIGoEKKUAMFsj9uu3T56553eI5rsG7vnc9c1kOYntPfWgX2+JcNY20akfon4Y+MUo0Ex3hnPDQi0udMArxGN/Sc3T97wbSBuDO+wRxO2D7XP/8SOOADGABZq4Ea4a2Q2mE3PYfexGbsGzEjpLFuTQCejAZa5aZSdfq72WLTD7rfjrAMpKmFGgVJz5DH3LD02DzwwaU909Kx3jW0C4KJUe+sgtTkcQgiallbuK6DJXh7b8+yyEejckDIhhMBdOhpgKTWqFVDXlN3WzxCFQOPnex9Edo/OqCyUjlbCj6RswDTNKHlG1iw4PVOQuqK2++/BiApIOWZe2ZZh6jsgte/B3eU5rsb9XTpZhvXa49H2b3ehUSPm9M9t7hl1y/9uydX17kq44fYubFez37scaSQb/dcIPxY1GfWz0O4jIOOqZJnVlWLi4V623vrf9ulWSgwA6mbcfH+PR/f4Wl/b+r07aYaJAZrB9Ql5jag1oBQoOC+9sBJlVvIjhIh5nhvphZlRqtSXjzEqSDhmh5nnCSFGLLdFiNiBRAYSoZEp2oMr6OuysHidiexv9L1n62jkzf3buJq45D2Rz6/5Jj8AWNrxXv5BruHJleQv/hWtOX8cMByoihMQAZZBpJd9sL5VxJC6/DI9h638gV5fmJJKhKFGajJeJOv1AgVNw12w8oJQuk4XKPaZ0rJqoclRUa/J9W3Uxbts3n4+6uRj0+s04uAom4/0d//e/XFHfdpezwP027nm7+H1hfb74KSn4V9PlmeGAvvVHaNyHpoNIQQEdVKHGBATYZoT5mnCNEWNold9njWqlZL+XSBc537PYjp/zADJPk+IqJQks0ol/Pg543J9p07Z+Fa051/WMe+tgq288vvBT9Ncv3zP8Zp9/xh/9/vD1zXa/HvUj62GeG88jo49OgYIAAthZlkWLMsNpaxiC+mCNr3OO8uBcS7fa1s71wcp9GsARAlByzITAZEKgAz+SFjekjhQikmX7XPI0/pCUF77s9+4aRDSCEARPg64BnUU6TcU0MLY29Ff3whSMsB6FEMA1LEWQsI8z82Gtn0ql1VL+YjeFoPphVr+NDPW9Qa24BTZQDSTg7iavRzzpEPbBxquYTq47TsQaIetHB9E1277VBtH2e9iK4+ou74S2odsw6wZi0MAsTgIY0pSMlOzzFmGylqM0MmqY2u2K3WQMREQGMQRpRIiKQZgWR/RyyU2c4tIsxgHl8mz7zM2LnIfs49Ebkr8V8/uQrDMa6FNhUCx2ZV2Xd3QJNsXG8VLrtnsiiClVdlhTFaOw2S7fS5cHi1pqParx0fafKNOjNw+W60yvtXKSgPN9mEdbylJpaVmSfRmf61tplivx2zLa3VCz2jXe71oWCvuM49X3JMt1Ab7zt7pnt0yBQuh3/bh/k4Z9gypjYmRP0yHHK3pAFDP9NnkBbr+63GnI8zC6y9tPZojvsj1cpYSZ8yMMklpljBraS3VkWTf7X2pLEEbjGZWynzSMiYp9lJttRS8fr7hfJ6QAoPriloWrLcL5sCgROKwL8Af/36SfpUVVDNCqJgnRooRnz/6nW94Q3ebt9G6zcgiF3hLmjkYP3cHRs8uY/9Vdw/f3ttf+Z3v7h37pc/u9Xnbn6OebYkv3ab1f9P+TNroQa5sld8NJYvMqCHQwXiJrIBmae3H23f+TPYkCBCKvs+oedYIVq5YyhDfbm94jif86psXlPodAjF+/PQJ18sbasm4XS8oZcWvXr5FUpIFy+bU7hJCwJQmEEl2vKI6grcngC5XRnyqf2dlDL1+4vGaGAJenp+xrDfFnMJAsmnYtMpD+Zy0XxnrumJZzLYRW7/LRz23ZUVnpBiA6xl1IeDXVzkmyHqWrY0BZqxrVsw4IqWTkFVraUEmQECOUvqx1oJcrC8L5nkeShObjDcya39+NyNVd7CsVtSFoPaLUG0PMJweaCRNL38HXJC73VjJiKSkGYSkCkE7ttmijJQehJlfuj0IM4/2aI/2aI/2aNqslqTVgpQsEBU1BkxJnBbresKyCCsZsDrKavSC2n9SIznBchpQJJR8QyTCnBLmiXB9vaLkRaLt1xXgiGl+QowngE4AWV1vKPtdEkw3EN1lnfFZRLagnRmE1ryhv42Msc/B+mzoSrLPELBt5lAZ/j4AAez6wz1rGQgi/l6S5aQ04Efql7ISjCqmKQHoETIegNiD9V0Zfy8l9raZsU+EFgkmde1LA+d3mUwCNXxforwnAIRcscH91WzUvnMFYoQSs7oDSuq/avR1KZrWUrIFiSFiTPMRjCWKsMCykuvgVPBzoSgomdLsnGGWwUbeQUoC0i7LzY1zcvc6JqJ448LebYguy5COcSm1MeatBrlE7pYW8dbN4L4WrFUdPzO2PEC1nQtfR5bp43gEXg3deecca42g4d6pP9bAc99sDnij9ggYPG4GEFtNY3EAgiwasYPXGKCGft2RZPF+62DC/jr3+ihyU409Gy/2d2Q4NMB99vOa3E/7aiC5798GDK8iVPS73kcDa1oKWRctKg45ua6k8OcGGgTq0SpyaV3j2PTjTuvzUNduGGVde8fYArP9p13Aj4miiZ7YsrlzA7f7+X3eWHRnIHEApBjbGoxB5KY5K15fX2HATk+7bpkxOiAVIwEUYI5sSd8vEcQ5ryi1NNC/ZeBqaz60dWMOD0WVnQAWkgz0+IAAMCGEhCkRmDPWsiDXar4GkYeouN2Wu+C1jlYHJ52oGN1V2zOogdjykcGjW9iun+NXyf56x0czSKMOBYCRMXdgI3ex5pOvy0oUx0FgNGecb10LMvCX3N/UxhF6rcAdOASAQgIcWux8Be9JRgrIG5GnQ68eSu65pMYTVd7oJxU8SBd2x20lop29HV12P74329aO4xnrcsLr54xpftI9zhw5UnpymhLm09wIrMsiV7zdbrjdbgrqAd999x2mWXSL03lGmiKWZcH56Yzz+Ywff/wRl8tFSkG0fTC0DGddHMh+ZI6enKUfIptsHY16mydA5Jw3kfu6tr7Qmj7QgFGoLCCNiO9kHHITU8BRT/zeZ1TpDrZt5hhpBQWJUstSV2tueiIrWEmhy1Fm2UfFQcTNmSyOQyH/lpL13m5/JdKyS2gyXnS3FTFEpEkI1Uxa4tWAYB5J0kKGrO15tyQgex+WjWib/cI3Pz5CkAeCz+rhAHKvf9xz9g2OZxurjY5t4DsAlDzqqds++Xfn7+upcw1UbyVwTXckTGlC5Z4hKAZz7EbJrpUSomYODTHg6WlWcnGV0gwkpOycM7JGoJ7PT6hcwbmilqCAvDgHKtSxnSYERARKII4INIvjniOuywVrXmDlQt9rWyfQ0ffjfoK+r/FeGnpnEx9e9X2dyt/vHQ3BYH8YSdA0hPGt7dvOybX57qi3nix59AReu/XX7rL63q5JSkIAbtcrlvWGEBgxUNMnbE5s7YJDncDpZl6W+N+9jGJmgAMAIZJYydkUVhAvuP3+jNd/99R6fKRJ+O8C4Ai+49F19wkkIr2qXV2zuPxIcx2onBKizk9ppJm6zN4hxGnScgmyhp6fX5CSkRcr1ryivK2jnIdkBsm5oGQlzXDFPBtWIvL7dDppMgpv/4cmh7Zlj9rfgUXnDBERsU2gCnG8kwj8hsH4WcYsQR9V32cMCadTOrYd9ZwYE6Y0Q0rySZlFswAzMpilBFgAJOkRM1Z12JkzjhhC8Gt6agDYMuMYUSdIJlsCYoot85yNQRtf5lbqQ8wj0cElxYrMAai+CAZimHRvs3FpuRbaG2v6bwimAInTGgEUDWuTbJOVVMcwopHbhypXdTICUsKaAATFZKLqLj14h4haadXmHOYqhG+uyEV+KhvphgAm1CKZJqfpBMsaDILovS6j7lYH8g7WrVPa9r17GZCPzjmym+/ZhybT/DWs2Xz38kX0KQkssKwOpq/Y24tx0jFjyagAkcNh0Jg106eTImIPA21tmN1lz6afEYk9OmZP7piHBErIeqos/c15wfX6hmma8fz03DIDxlazVth+Icq7JAuEsMAIyHxO04RAEtQYAqOUBbfrJ3z+9D1+9asPeHmOoHrD9fUHXN9+BM+EMEdQJORbxL/93/8Kt6ut1OSkQEdV4D6zdzS8y4PPxn1f/rasM4H7Gxptk/H6FmBQAVTCjixj73fYH1WPHTOHdXtxb+ftbaD7u+p97cJLivf0Cv//e2MmfXJ/bTK5bnWlPWkGKpfGz6if0tcZZE/tmafGMSLXE8s1YxmDEgXMGnQyIyCxkChqZXz+9Gc8/8WMp5cX/PrbbwAuWNYLas14u9xwvXxGKQumSHg+P4NAqNXWagAFRkBAmgJikVJJRBlGjAtzQMg9i5fJArMbvNzwsqpl3tfgISHHRJxOT8gEVqsAACAASURBVHh9+9zsnhAke5rhMl4dMhsPAJ6fRVZeLm+oteByfROii2ZRBdSmY0aMSUggxODvvwVezwh/+R+FZKO4kWQEBnJe8fn1VYKPTyecTjMSIj5//gSAENMJRCumSfDsZVlQspBlrtdr2zPP5zNSqg2jNUx6XVes64oQkuwJStps9pcoBk63kzkphNgJiaLaiUX3s9psTCNxAkCKQWQAdYksQR6ElGaHxS9IaY9xP9ov2x6EmUd7tEd7tEd7NG1DCkKydKwG3keUolk2pP5EMzTBFZWhhh00jTeQV4tKE3b0d998QAiEpzkhoICYsVyvWJcFBUJQYTXoWFM+gs2IMdDFGT51JIdsy/ZQe4YOQnuFaksqMAJGy6TjgIEt4OfB8ZZKOUqkh93L39+D+77Z9TyJJ4SAXLI7JiAlOa5o6vvOYo9Y17Up5jnnBpRYhhxjyMu9+vP61JRABxY8o1763p+9lIpSM0pZ9ZzuMGJmzPNJzlfn6z76EEg6TtwAAQFumCtSmBopxs7x4z2CKT27g6+xav33n/l5Yb9vyUWlFFyv1za2AmiwOs4qpmnWd9rfuwd67Vm3EZMUgtSrV2c+o6fD9n2uRaK5LSNPKcsANnmQ0z+b9T80os3e9N7O42EduOP8eB1dY/g77NfCdq28B3zZ82/7NM69ejgnt8f6dWnvxmSVv37V9MpGTJILylyqRYEpsqwgfu1KBPx7jYgk2suNpf/Xj0+XBRqNPQxPHWSZ2e3bcdq+Kw9YbltlbiCv60z7rubcZaGBnpC520Hk/rfvD+m1DBAuzCAldxS2zAiyZyAmULQyEZK2HaU2t8+RwevnkC/Pdj8r11eArTx+Zv+KfB1lRFUAPRCBQkQFIwbLfiYtV0YIAoRHInBQWUrqTIY5HzPe3t4QIinxRcCcodyMZmAwMpC1MTtBkFr1gM5fIVAUzXxlTm9AHTykpCZS0JcMQIc4rWOS9MaVBXRtybDNAdD7UZmx5nX3no6giqrn7ulo+7ZzYzZQT95phy+/dJ3j1l0YnYRTj8gv1Psresh4T9Lzjp6IAAfsEjzcugdGCYFqi560viuV56uekhuc5GHT7Sj0I9hd3Y5sKbh3V+7XO7qqP7b/7TL5DM8ElwEoIdIZhCvePl8Rg5FOu0NjXVeVxYSnpye8vb3h7e2tlaU0AunlclEALzT9RcC3npUP6JnjTL/q5S1H0NRAUStDFlVXCURgJ2/8fpNzxu12g6XxbtnLgs5d7jLMp/j2+1+TOZA9hFy0edEo8FIlU05QMm3RTI8ip7rDyOulfr/xZFNz3NQselcpKp6jjCuRSIAK0lr3Bn6qAwypJVsgCMBZa0UMdh1CoIgQunNBMs5UlJyR11X6lAiojJCiREFqiTkZu663el3AyNMmq32ZVYvyNALT9nzLUuQjR1vZLeL2/v07tve81WWOylDYWC/LgnVdh/uY3ibX7hH4fj/1xPm9TQN0/V0GOkbJBmbHCcBNWJZVSy2Rkig9EZvawkwxYJ4moEr5M5ONN77JMywLSvElWS0DYkJKM1hJ6BRl7paaVa+oKFYakAmcCc/zM2IiAG94r3XZdI8u04+zo/o5W5KfdzRxk0M/r0rTKGnHXlCb59b3vUvvvlPs3ne2j9DB9+OueOxM61fYP4snYo67hbi3alG9RCO5jSBn5WlNhp7P541c9noctTVla9O+t7WyJZoBgDmqa2XEKNkET4mlLBTK4ZPun8OeZvvNcXMSGExK1AkBrI4sG8T+pu9fc4sTmNxNKbZAk6D7wTyfMM8z5nlGCECpQlIDRN7XYDJcr1eNnFlaIIfgM0Kk4QqcT2exO3MvaWjju90LjCRaVXdGCJq5kdqP2a5ChIl6vwIrW8zMoBiR5rm/SyWlBo2ub+8dYkec0gQwYV3zsE+nZPauZRWD/q33UuJGMJmaM6Y5gYvozeZoBNCxD64gK6ehb666OWfElMpSjtwyKUcSnXzNq2YcIV0HRmzpzk2zL/v+Knq3fA9YWZ1ADldRIoYyqQDuK51ZXc26L1CQLDeWwTfECSlOSGlqQUsy9xyWFDeEy8qKy3DPLlNFx7CBjiGBWcZeSiRCZAGV9mwej/HNr+kt7mIyw+/J2z11u4/a3Ny20YaWFyp604hBeHni9aEh242OhwU1IEgehFKr2FkgcBDZZ/Zlfy6AghLFqpbHJQKF1LIt9WVEAIlEisEwKtFdZH3KvLK1VWrRdy42WK1ALRllJZR1BeeCp/MZc4qgkETVZMkwEYvs+4wA5ggDEUwaTinKNagg14rl9op8/YiIKz48vWAON1wvfwbWH/GX353xzROB6oq8XDUr4W+7rOsj0t+P7k72Hbt/fbtnV9hn1t8KbjqpkGcw2E3jOUAhLeUCt+/v7tDPb8/APZjCrkfuWY77+KXd4Oe3rR1oY2Ljvbfy3uvHaCNappl91tdRp2pPT+OYWLANFKtvmVC7etn6WsDNLs4IYAJmjmBIhpnEBEbA8zmB+YZ1EYPj+eWMb64v+NOf/wxmxun8BELFDz/8GaffTkgaQAQCnp6eUWtoT1Cr2EoxRDXDVKdmyapi5dWMLHM+n5uNsNX9vW7+9HTG09MTYgz49OkjLpcL3t7eQAQ8nQtSnBEU/xEbMuHl5QWAEkWU5PLy8oIYA65XIZKbLLDgTZElkouHAmNdbqjrihSekKaIvDKutyuYgSlNmKYTIkmGlWVZUWtGCCfkLP1IKWKaEtZVbKinp+cmA3POuFwuYGY8PT3hfD4j5x7IUeu1YW9i55IBIQBDgreit+M1yyXJvk0QmYMqxx5lJgRGzE32NAmOXdYbiKRvKc26vZe2H8tllLypeO772vaj/ZT2IMw82qM92qM92qNpM7XZgP0YSIEBYF0XZVcXAen1HGP9EkkEgDnvzHCsDEn3d11xPs0KoBbk5YaszOZ1WdW4F7OFqxnQVgMT6hhQw2ZjYAP7yBX/c+S4PjLWB8OcN3+7624d4AM45j7fOq+3zm1Anicq4NWMfPceiLqRfgQAWEYEMcilvng1Qz90Qol9RnRMTvBAwj4Dj2X0EIO+1uKU+hF0C0FrtqKibqLwWAGh0oCdPi4pRTAHEO+JLr6NEcNikm2z2+zfLcFfautQst8tLsXqudrYy/Xluc+nZ0wfzq4fjNttaUCQd3LYvSozUprU4BIwSEBBPzdtNrQTO9EAGJ7PP4M1MlSGuyPHogWOyAPDe3F3/tKxfnz9vbfryM+ve2vsyGFkjks7x0gEX9Ovo0bU4Y62nlo/HKij6ycAANXD8R7dzMNd+vfuHA8q7gC+n9ga6LPp1y/VghtnAPuxVoDaz/FtPzpZBQA6aNrlCYM5D06V5uhUQPHeG/ZjOJyPPscsm5AthZ81Dpu+tbW8mb8GnvZ52oFp6xM02ihNUUqQrCtut5tm0JAsPEam6fc8AqJZZVG/Z0oTJLuVnCORvQLQC1nRAHBqfQLZXO/7QtRa16Sl5YggkcnMWopDnWO5YFXCT5oYaZ7xNYCEW0GHYOkR5GmuRg9C0p215wHPI9CSNr91ALc7NH0fd8QeR0qy3d36zQdPRyCN0iN3PR4uRcOde7xkBzs73Ex2HjnQl8yx0vvDerfgxonclfYj02HXLZC6H/v74zqOhe89dDfVO50y/tn/+AcgnRFOCXklcI2w6PnmQNL1VWsFCnC5XBSQvCgxuBOaQ+h6k62tUnJzzJxOJ3XkKnTLPROMkS38Ont7extAwaYnqO6Djez1jhm/V1n/wx3Mzu9341rXtR0jGNXtH7KUpzQScStzi0RHlfXv+7X93fdbZK1EWIPtsx5BLqBm0fdSYA4fCpqRRjfNoGR2KQ/Bmrq7IucVzAu46ncM+BKn/j2XkhGi0+FF4W/v0o9bJyTx8P6kTKYRYsZIcv/MzTm8yT4jHCT5fFmWHQl4nufhOqYrG4huZEigR5La/bzuY5HtkiFgfB/b5vc8/aR9buCwLyEo5JkJYGC5rciZQVpO1wRfsxOCZA2dpoiYJHK9lAWsmfiWlZHXIllHAQQKyHmBpEQPiFGzPJBkOKAqafZjDeJcBDRjkBDNYppQOQvJ6yva6AgaZT8Nnw8j1s7tEkhaBUaCCLV4e1eG4Mt92tJlfL+8pKXhk1EMtLd5cF87env8kWbkdy9uP+OeVMBSem3zHOx+30p3ZiFdMJPTZ7ue3HAAoNkZW/22yRwCaEOUAbod5x3io80Q+j7JFWUtoMSo5Ypa0u4tDP3fPs87xx61ECfkSrgt2e1JQkokCOnvvba1Y/xnOdszmn0OiM25gihh+f0Tlr/7BilVlN/9nTgDoXusOZhYCH7dIWfkf82QyNCyM11W+TILXodusoUAqkK4rrkA0MxUcZuNRbbsqlNDyrvou9NSSUYokY/2Y2BOriWvEiCi17f++dLEfd7Uth+RksG7460gWgk5GKmoNBlda0XhitAq1I2261D+uc1jIIQECrG9fytPFEJF1QwirCXKiAMYRqC0ATXMBO3HxrBJAc1IQ2BUHvtiOup2b+iYRh/Xviap6fb+uI4XRSXOC+kRmJSApSQaJfBYtrtxz8Hwu82lrS3o96y+34+2/9e2Laaz1b8AxTvakN+X5b5PR8c1fQwyb6ONX0hIOieYGZE9/ijyUrLzdQncS68BXgJtMUFz1vfvelCIZV5o+4WWkrXsgqWsuLy9AsyY556pqgcySm+s8lhhK1cTEKiAYkUKAcQFnz8y/v2/OYE54R8m2e+5fIdaP+j6BAAhV9UCLMs2eMj6Oe53Ir9Ft+R21JFVd7QTuXej/xopw7bO4OygvqfZf3D/uv643729J9f1++f+/vs+/fQ5fXSdUW+QT7dk4W1/jnSRfq19v/z4NHuz6URfem5v4er9NeWMvALJdypScBxn0z6y7ptB30oFY2bCCUHKuK4Jz//md+ApYvnrV/DvPoOI8Otff4fPr6/4+PGjELhfXvA0n/CHP/4D5jQDCFhzwcvLBwCEeT7hfD5jmibMpxMAYFkX5Lw6O7EghCSBQhuS75ZMavuskPVPLRONkdosgKFWIVuu64rr9QrDw1OaBllVNDhUMjwKlnM6ncDc7yMjKERl0xMybqDf/BF4y/j8r/8lQiXwf/m34JdPKDUjckIMFfUPv0H5IaEEYI0RqIz424r5OSOGhBpFH0gptWyct9vtMBO/yXdAfEJEkoHM7JoaeiZPIar2vWZdV0DtWSIJIuCiUsDZRg0DDKERZoPuu5fLgmVZADKiJhrhuGc4dHgzggRBhX/6uny03h6EmUd7tEd7tEd7NG17p7f9LUqeRU2WWhq4DADTPCMXMzaV1R1VGU0JiYDrZUWgCqoV63LF9e0Vl9cLbm8X5FIQpoQ0nQCKqBCiTE9JqwBMM32OjeKts9eD5f5faz7iZJvBxBTgrbPeG+3b7wQ7GY3yLei9BRYqgOgAfAPde39NwfTgQ3dkWrSfATWm/FuZIgPLOkg2OlO247V1GMt5pOcVNRIkfbB/zi0Ax/53Zlit2fb2nJMIOm9g48cYHFpesfZZVqzPZpiEMGYM2pdX6Z/3d+NS9e6MTJlvHjiqXFG5SFrnICmrQ1DCDyxzQS+FwlybY2vbD1/v3f7tY0+QGq1mCHQAAFBACwK+Va5ifnJ/Pk9GOJq7R207H44JEfJ95Tpk1vdAkF9H23WgNuDueu+tkT2BYN/vozU+zCkDk2GpPrszgHf33BKzFLBmO/pIphDAoxP93jj6++yfy9a7EikITfYNzscGzNpZ3MpZ/NTm+9Aiulr2guDAW3QQ0a3z/osZr8HNd0klC3RQqNpzE6ERO0jvfmd6mpFsXTXAnLWPQVObB3utX7CX70+nLnPHOSlOArtuVRA4kpBiJKW5PPeUpgaSTHMCVwFQ3t7eJHopSMRubCC8T4/fe7Kuq0yBYPuRJ+JZXwxY6eWcGBZ1Q22cLXONPLvJczmfK6ljTfZucxLYuHIxkqSA8uGU8OHDhwP5er/dfx3jnDUg8Ags3LgNhit7gHZ/r/vuxu1R5I42sNf3waAsD1beAxztuHYFksxKUl5S7lPdMUejKW+3R++1u1i0n7sWwDB3fB+HDp/u3bDbseo9/9Kb7YQg+d3EepcUPbqzEiNG4Jt/PqPQhOslYFkY4AlTEuhUShJwk4lVdYBSimYnOCYtGJnD+k+6Hwtho6+Xt7c3t9+EQdcZnuuePqMer3v70f/H3rv1SLIkZ2KfuXtEZlV3nzk8c+GSS3KxuoAQIAiCIEBP+v96kV6EhSBCIHZXAnc5hzNzLt2VmRHuZnowM3eLyMjqPjOHhCCUN6orKzIi/G5u9tktRvHbnLNhgPfK4vtzUml9XfU8d2KQiIzGUKf7mmbN6xA/xO7OTmCb1mfbblFeyF8hluqzExeBR78isrRyJIDRXXHenAXrctX9EwwrCYAkIIlHOMm9n67oJAKye91bmG50Xij13eNn78a7n4DW/G/08VvXhv3ZG5V7ewUfGagbUzdEI+y4Hvxd+6iCCnyXzXsjL3rHc2MYSsb27cu9ko8wosV4yj9V5DILlqX2cyEl9eQlN2I3Q8mcM7LxiSkRWq24Xl6w1iuY1UgmZfXi9NSK6vzQANGzi5hMyU8AinnB6nyAGJwaQIJMovFALHICf6FxSlyjg5ptjQrH/7sx2zxtP93gUO7vNAPEL2lZpO1H9d3fJ+H/cE7txoH6Tzh7+nf310Y9tOvTtn6GoIZnJfx+1IfGNzADpTxhmgpaNWouGl3Uo8n4mjwynu7ew2Z0s99v+7W+l1MAoNUGTg0aKKni6ZxR0LBmxg3Hc38/Bo/Xyej3du5bA2oltJaMXw1G/aasJuP3H5VIM0Qs0lIiUBoOGI0rEick1uu35YL14wz+bkKZgFZXMFXj9UbUXRF0xXXfV2znMBU7OwXCrfcr0rQob/k8ORYh/Rwa65ZFIC3wnuxpfSwwChknEM7HIW9ZZNXauiymZw1rapuAPbTWzIgjysNkhjLo/LWQj6G+r+SC2+2GYlFaW20ghAgnKZnR8TaBpR8aRMkicNq9FjWGjK4KCClN8IiSIskPm86vi3NqBKOz6HPvfAizB/rY7X2vT+Q+fRBgClna1KXpbcfYHcm/8ezrBqRi0TzNMWlZVtQ6zrCcCiQLikWUVjlCDW1YttE3/XxzxWXE0+LfjmPtz0Bv2/0Zty1famhD3lcfeCvRuG//ziELsc0VLI2RWIpsi7pt0YUAIEuyyEDG4YqOTa0+1x65wqOraqpeUOQrY91iinLlX5dlGdgnAdFQpq8f0vSXP/z4Pa7XC+Z5NmV+wZQ1YmjOBcgFmllNDWdKBuYimNOKnBnUFoAvoGXFy3cqR17gstAEwCJT4fP01uegn3PxTO200oX4/dv2J9T9Hd6G7oDQn6Lwvcobr0eWGbLeff33Jcqk8arcffrjy/G5vK9Tr32+pa/VIbu7t3N7X9t9S0Yb1TmE+wW2c2DLywAjzXAjlaJZMpg0JdMMxzIJ+ftnNAjwm48gaOqf53fP+OU3X6PWFRdznCARXD69dGOM623FDz98h5wnvH//AV9//Q1Knswgs6FwTH3rEZS1fR6t8uPHjz3SzD56cbYoadN02hjdT2XC87t3eLm8YF2Xfo75M27Q7teUtld7t5ohlFIwy9wNQoFBhzyOUkrQs31e0a4L2ndPKEh4+pt3wNNqUVFvQH4Brl8jvTx33g8Azr+ZkZLSWqUVBfM843qdcXl5wbqsXdZ2x5QYQVlEtgY1Mta9ywfJZBLBoOvRaFgf83TpFm0tuYHnWH0iygvVVZ0QNEKdYuFOKzut3kSS0VWn0b4E3P70fflWtLwZzLyVt/JW3spbeStWIsjM3FTIMpzYjTl6qHM4KKJRTmRt4AbzihgGM/NUQPOETA3XT9+B64L1esXtcsHtekNdGzTl0AllPpuyzryuHQSHglTKMKG38Ugh/RoQt+9rfP7OOCBcfySwb0Ex6UJxfH98Pud8F+5dmFURi6Egugfax1jr3EgAVWJEmQHS51JAoGAZP8FTBTwamw6qBGWBenjR7js+HP8YCtgF9AF+jbkjyl14i0KtAn466Xtjp1jPxnCDPQ3S1C3gx/yMvsZoFx7CWsGJWxgLdI84N0zScc/wcNTMDeu6gGjuIXzLpPlcPYwkMDyOWxMUWxcRTOz9sD9HerGh7E6U4YmDfbx0SEN0BDFRlnXcNCKTbMbKwasvKUfr9uE8sHRZZf/c3limv8P7u9tT+714tC4ftfdxZwBXHqmQFlK0ke9x/U8NRKxd5NF9Ip2gzyNGhM287EsEq7UkQIZBybZf9gzMF8fAzgE4aYXdP6jvMX4wJq80nrTCfkcHVwECd+F4JOexWn0+IxQjYxw0bYTFVQcAckA50DYiA3DtreF9+7G7i0xjHj1EjIICytkE6c8YWIX/j8dJF46+I/Wx1a/IloJBaIk0VDsSsnnGKH1Rg5mSMy7XF3z69ElTMRn96d6ytD/L0K/VVVNk9KgVrY2IEgK4ssTzc7uSWgNTOXhFAClg6/FHvB6Bnln+Ht8jujzZgBqrizXfNHNDormH8/1TyxFQN2C/raIxtDLcSxsA1X9HJWssPvcHHMHdX0cRAGTXrnFt3MGhBbRrLaDzm3YK2mjSsh0Te1f30nSjGN+2Ao8248aa+xUeIdKjnsfWD+j59f3jrbUdEgyJKJzpDl6bMVZ5Bot60nFTRRBlQWtLH5fRKOnnWDxXtzyZ8qkjxZG2xr3Ka107PzSif+RuMOvv6/2i4VHv9epN3GniI55wz7N1JdGOlsXnvQ3jbBZT1Hj0PqOVGNGzPBKXJN3/sS2uUIxt2qdliu1woxOnuT0yDKKhtIDZedZi3vXB851U2aRGTRkZGcjDMMbXUaKMnKY+Rpp2xM4rCGB8ZX9EGE0EwDbFYU/ZRPeRzrx7LSh393zF3hDWv3OjIGCbvmQ/Z/5zlAI0RkmIdcd3HbXrqMQ5G4Yyg4eJ15w3acxoNezEpAaPlD3qo14ruegutagNda1YlivqqmnFGjNOZ0tJQ9R/w847bbqdBUl5VmFAWkarqhChzEjUwFkjnDABkjI+/FnCX/0bAbeGf/xPBSGA0P287McEw5BSdt/H8+HuPSE6172U9zo3EL+LdxPikwf8ymvvC+dKPLOiYUy84/Nt20c7i+0QHA3x/lyNJ0NtV4vQlTGXgpUJjRsar1jXtjESA+7lsi1NhaV80f3ieyvKzptIT2G9q4EuoWQ1Lb39wxnt9h788fRZVtzPn6MxeTQalBnTb37Akm+oVcDiEZxsBJUpMJlhP2qxhH1pY5CSRnJSowOX4bV/eh4xmBe0SYBvKtbMqHJB4wXCGSQpOMAIWtUULURZZQivKBpOe5QXGhGxjgz9iGikbLWoiHDwhcxgxsiK9krMcMjOfV8HnY8fKXE9nSCg0RT1fHJnJLL5l67kGqmnx/k3+HE1ImgYqaQdf/r4aQGd5s6jljwMCvU4GRECEWaOQDDLBhvCDMowZ5fB56Sc0VrAbigZT+DHpws+qggc68JkTZf9MM7cwbWaU04SjeAGhqZFtbMkZZtPfZeeOQWQ7fpT2dbPbMOj4iqXkcoJZEZKlsIrZZ2vlDOKqBLUjY5zDm0OZ9LRfr/bCQc4wJ7n2p5z6Pfs+azX6jFmuKexjO+Pkd+2URP0wWG4gj6fwkCtasClRjOTynopY0oTWq1orXZnpdoWMzaF7UPHjdxYJ1mkFoKAQzta34+wM3ldVzw9PdnSkL4+xOebyPh+we16wbrcsNxmTNNV03OlgqfzE87nZ5SkZzMlIKeEkhOmxChSMSXBP/12weXHG374PcONY47O0XtZ4sEU+M+BAeqQilyGupfSOn4SvvMi4bebKwHqLuJyx081lvG27sv+ua1MGunIz2Euc1z351v16OkhxX2uDv8sodZDHurg/S7reqSZ+G0Ksxd5r9ZHTOu5UEUBQaPl6j0MAaQiyU3TFibgF199wLpWfJ8Sam2otaEtK26icsNaK263K87nZzw9PRk5cMO1rPiwqLzIPCOlZr5aShM8ra4bxvhZCQzZTqOEaztHlJiMp6cz5nnSlEosWJbVzqbh6OkRwKIMM5wGCFMpwPkMIo3EUqs5iI1A5khpAoTB8wr88ne6qddn0HcTsKyo6wpJJ9Ato4CAU0P6+gog4fQ+ocwTeMmoP55AifD89YJ5niAiuF1vPfqOtm3Mc6SbgEWfguJv6LLiiEzv9GwfYQ8iXfbO2enhuMd1TMuyqDxi9HfoLgYfCcQUe7anR+hTxGi1b+VPL28GM2/lrbyVt/JW3ooXcUGVIeKeEAmQ1oGPCM7nnFEsBLuGx1Ulv6Y2UaOZeZ5RkgCy4sff/yOW2wW8ripwVgalgmmeME1nA9SLghYpDUbeFcWuBHxQNop5K3tL8f33EdzeM3exqi6801bpflcvbaN7+LMR4N+DAywaCri3M7y3N4VGG91jKSqH/d4YZYUt+szwQBpCzBHocfS3M88xhL2HJo4e3GOMDC8I4q0DaRqBAx14c0bXFTT6lQMCFN65BWbi+HnUnH07fCAVaLh/dq9s8fFMoLAPJIzLCMk7lFp4+C5XPjGrl5LmtR5rUfdPx0M2fdFbxPbeNrKJNjQqRs1IpgsefDeX2zG5L7Qb071SaQ9AwZpDn4kwcQSkk43vvh6/ZxhKeZt2QtdnSpx7HduDZ0j/i9CHGFLmRhvbPm/Tvd3XJ/1fBwkOAL/4ju3lCA35Z3u+f+bw/bavR2DjUfG9d9ce0F2/fHw2123cBl0Oq5Kg65IcCjFQuUNfW/B0jAN3QBmb+dquuZxyX28RyHCNm3q98wa8vuvSeOFBf7XKkYIJ4x3S/1TA38LeM0wRYl6xHhJ7ALKClgS32w232w21Vszz3AE7palOY6IxEHoUJj32fE2RevLDx8JoGbOmunBgo6897vTFQ8j7vvJxIqgyNVEygnYTiwAAIABJREFUkMujdqnilF1xEGgfM4NDSpE/pbxOQQBVUAUDkR2gN0DYAdb6ro6g6Pj9ugLyS8qdEcTBHcOMZwtERrgxAsz790ZqAFg8Cnu4G8n5TiMJocm3tcS+xqfuAXDBF8zGOK93tW1rMWpoxjIMXc7MCZQm5CxIWcC8AjKUUB5Vi5nVE5pS52f8ejyT97zdUaQD30/qHbflee7v2xqWDvotB9cQ2n1Mk53J2RtQHJ2nvR6R7jk+XjuMG9wgaHMdZgiUC1JIcRI9wH18Yr2iN+mciqogWFr3dPbbPS2IvoaMP6e+eAkJZZo0SktRXkfpxTCu1tQTOfA4PiZjPErO3SCDmbFe124Mvml3OFsfzcU+YuSe946GRK01rMuKBe6BWuBRFZ2e7NPOeL0O+joo/kj557/33z36HPtzZxyDIRMwM1auZkzr9IDUIz4R8jT1SAkKVNscmAGkGy15SQRQKV4LlJ/0eQ97o6+/rczArIdNAkMyQ9AgpNF3Egn+8m8y/vqvCNdPK37/u4x2+QwP2Xs86rTRwZ7ybNt2//n4PunjdlS2Z40bCAZle6fJx3Xtz6q9IjGeSeNcOLrncR/8HY8NROJf8YQcvacwDq2tWJaPSGkG0bNtUgI3YK117ClAeYhEZjxPnX+LSpTaWqdB+ohs9k2kj+owMXihxhWCBOKM//y/PIGv714ZjcdjdKTWjCekQEClYf5v/gM+/nBF+ySARRIhi5IoHhoOtv8evfeABuWsshzbXtUxVBrZ2grmFUQM+fACef8tFqloXNGqGstmiyyhxjJskZxs5szgeeAEWZ1VOg84zgNv1x4r6TKsnb1KP+J5lzRVJ0HbQhYhlaV7iiOOD/TcbYYbeBQs/W7gFWrYQfAIWNpH3tDqYcAqaMyoraK2VavLahDA3MImHN7wnaYSLHKaXzPZJlGPijYMFwBKpPgUhfOWnN/wfT/GLvwJEHWe1M/Hziz7vvGtYuef4h4Fa20mVymlkSA/gZx/TyNqjmwjtHh6VoCQy4hQ2+UKaxTZOV5KgSR1bOh7lCytFvsZIxgRDe/5q6hcBjzN2nY/RIXq/vljmfrx36+VLU8w5J3tuwbv6F+xiI62iEWPGfV2JXpWY9NTOaGuK9aa1GiGmxlij5NBxyVv2p7LSHPlxmKtSXeSa62GFGsW9cYEQdLG2+ch8XiEQHXk0qhcKxUkmjBNmj5Ko5nCjGUISSp4fQHXir//PxL+8R8yomHy/vwB4jnzeQORGEGzt/3wyftahsHMtu7Ob9i1bhTjW9EIsmD7s69p27fjk1Xuahttol0vfgYR+GHx+o7qOW75sVSn3+xn4/Vaj+S7vYQY+SemQV841OTP+6glITABTIImgk9YISSoEGRJ/U5qN5R6RZ5mXC6fkPOMr776CiklXC83LLcFnAuW2xXLUkEE5JJwPs14fn7G0/Mz5nnC7baGNHeMahFmRHTtOH13R6ZpmrpzRpcR9OGOP6kz5Gpykfb7dDqbLMFYlptFifLUQm1H+zRyp0Z0ab3tp9PJIkNlXC63Hk16pCJMyDQhvV+Q3/1H5Ay8/N1/Cf7Dr/t+W23ME4DybsH5b3+LTGeUMgE44/Jxwvd/pzzUn//3L3j+htBqw8vHT2it4Xq9hna6/D31M7MDSr6uwoIYMqwa5yktZcXMRI2VpklTLjn/lxKhNrZoMguWde3RbkD+/qF/GHhZkKuY7N5tmtovdRJ9K58vbwYzb+WtvJW38lbeihUidAEzGchTSsG6NCzLYsr/3FnvZGDDcr1AWKN8TPMJ03QCpYynpyec5ozl+gmXTx81V3JbzSPihtYq5tMTzu/eIeWCRhNSmpDSDDGQQbgCogEd4Rj9TukKDEE5KlP2CoN4/x54T8nACbGwtUwA5Q5wCETzYAtQ8tTv64KAefd6+OYR+SR3hj2C7huDFXHloyktWLqSggjdKnsAjAY0mbevizEO0OWc0eoteHcBHh1FLeOx8aTeGoYMpVFrDbfbAiL30mGUkjTNiKhByFYBMLxtIQzhpc/NwJY17C+g48ee3su9i3NCKcMy3593hnmapt7uMc/69+22bPoyz3N4j4oU3TuhNdxuVzw9nSz/c7a+O4JSLd3ViKxEpN7H06Qg51g72QSBAvW8VXF+mlT4mecZy1IhUMUWs88fugwSARZvr6Zk0nXha+ERwKTrTYFNDTn6QJlwAD71PPNh7R7tlfibiDYGDNGgal9H3GtkIC9cubK5D+ipiL6w7BVhY70DHqmnG7X4Wjehrit4QOpFlwaIGyMSOcglUE88+D3+LjbaFOSzI+XXdiwdMH08T93oAVtFW1T0+X71n58CLnpwCoEATboRhtZhESCs30qnPIfwNsKUC6h+brhnz5GXiYODPRKWhRYXbpDWAMuDvBfKiRTAFkivAxCUMlu0Z0LrALK32wRpGa9U+Xv082Dkra/xLLEc7mabNyJ9MeZpwvl8snWtoX1vV/XQJiLg3RNy0bPQ+3y73ZBLMnB7hO/VaGD6dzLAe3jOOOC8jVRFSDZvrGl7xEGgbfqRWi194jR1cFdEcLtWZBbMk0UjEAaDkIvmBW9tMYVMBiQDDFwuH/Hp42/B/AsblD+tRGBtOxPbWfL70s4jUADP/ACmGDp660kI0N37XitCcuh9GOt97Ts6+ByfowMY8zVjHO279nVvOszOGwkwTAF1VF8zEXptDPa7JALNcteybWsjrObKM0JBzjOmibBWxnK5gdsCkdp5TxENSS8QTJPTNA5KhMGjRP4GcIMFTzWTTNnT4Kk1dW+7UYSDqJHObCPb5Zw1f7pEIxbaPOd7Mb6vn3VJNvf5b+cPXLlJpLwWN+WFstnkRR7RDTIi7+hpK5ES1CBl1B+NRNzD+sigKCOe5SOCoM++iGCaTn1Mcy4o07m/fzXPyUQJcMOMlJH3CjJJSMgoU7G2JwAzSsmYZwWpX14+4dPLJ0v5IqgNRoOUZy1FDftcqXQ6Ke/WuAUPTmz4Ae9vKcqfRaOWeF5qKHWx36uNhTFntOXZoxLXzzSntc5Xe3hzrwcYPDdRArctr/Wo7A1mnAd0HoYM1CYDigkqsz09PYFyAuWE2tSgUh0csp2RgCBjXa/ImZBBWJsqy+fzBPRzfKyDdW0oJSEl40vYZZNBaZgEGQJkhkiDUNXQ8NzAEEynCQnv8fLdDV/Kqjgt21KZ11wnxn0eXcavHJ0zsPu+JC2T01gdafKHMUybw/v2z8r+PNoq8Pzzvg2vt2qr1jvs24O/tp+o/y4TMJ0Ea7uAW8GyAnVVL+61VjRuyreZRiOmLEKXDRKy7TnGMJzwvbmRMXY0mAhoJh+lJCgFeC4TPm6GIfb7S1bC4/Pan2ZhfPr4gtqAlGcAxWSIYjRA4A4J0pnKxyVR6uuAWSCoarTRDUvElGHmEATudLi1itoW5DQZ3cs9/fIw2kiKQZgBTqJsUU8LIJqOyQ0ol2XpZ6gbAABBtnZaxqwJPklphstQp9OTTpMSWIhUcNU9TYnARoP28wgoXpJzUeO+Vfn/qRR0ZxAahoe3263LR+u6oLW2SS8t3FRZ2bR/Pn7Pz88aDWlZDIvKPWJvY0YVhqRBgzVySLKx9vPOxr2u3SnIrzEz3r17hgj6WTPWceCMuoyuK4sIyFn5lsivuKyrPAo6j3J5eenzow4zDOFx7rjskyiDuoGrKm6zKVvjubvWFYBG2punE0p5Rk65Gw+llJFKAfOKWlcsyw1tcT7D+S/jT8jTXw+DNgCY5xnrqsatqiydVK4xTCulhGma+niNNfxYTv7pRjMUflwOsvVXps21aATl0WFqrSpNpYQMQcoTpmky3i7h6emMXArAgrZWECWTpYBlYZQyYZ4ncGPcbgtutxG9QfdtRc4nw6Q03e5IfSI4n8+43a4ABB8+fMCPP/4IStLX+BgnH4dkeFSBK6ZbE02TmTOWteLlcsMqhDxlEAlKashTRuYrbt//J1BhSP0lgKfNKI7RtLm44/W/wGjGflJ/x3gWO9yDdp9oJ593GgpCC3GijBrrMzSuxXP4c+2LRTY/4zyn8Lb47s+dOn9KiSfy/rqX16S6+xmKPNR485BNaXNnvIsO/treq0Z9RAIyGRzGI43vx9MZpGnPoNHvPqHiRg0TMorhCe9m4N27CadTwbfffo8yf8A0nfGrb36NhKwYbl3w44/f4w/f/RN+/PE7EImmRmsr1rZiYkYqGSUBmTMEDLkK1tXptxpKVqn9nIl8PQDDBDWaWwKB2xUvnz7Z3tWolKVkfHj/Hs/Pz7hdb7heF9S6otaCnKXTm3Em6rlaa0UpGr18XTTNZUoJp/mMeTrh8umGy8eLGcc2lClBHYoJlAuYK6oIGhieZArQdhYQuFZ8/PgdPrz7JUSU9y/F7hQ1Yn/37j1KKVjWFZeXF1yvVyzLgsvl0mWm0+mE0+ms2LWMiHFDxmxY17WP3zSVTju3hpSEUhJYGi7Xi9FENa5UergYPphNBwCwrFhrQ84zuuExhpzLTTFZAVBbA5gxT7NiZ/nNYObnKm8GM2/lrbyVt/JW3ooXUpA/Z6BMGdM0QqurfGkCc3ZwnlHXBXW9geiMlAqICgQZjITKjEkUR8+FUJcFvFS0tWJdr7guL8hlBnFCLmfkdALLDGpZ8SBVAYJJw9MO8FiGQCBDnHEh3xlH5dUMhAryw0hl4c/pI/q33W+AiVo0D0WDektryxwchCkyew5S1ogxRFDPB25g0TDkKVyDRQMAmSedMHJWENpDVA4FBoLiw5lw8yDqubXNi1iGZ5QDA56aaShTgFoHiOnGIvpd7uMMKLPKrOIvoMxtzqkrhRWcUtCA2UEJdLCoGyBAI1BcLjfk7IK0jmY5aV+4NixNPamj4gcYFuOuZPbQmSllVGZ4+hgijUiRcupGHRCgtjqUiSQoU0Frgut1sTWe+jtzUkAPOaPkE3DSNaftli4gVAvNq8AX43q9boyliDTEZvPw2VCFnhsb2UaCxRAwHMFgBhdOVLsx1mFKQWwlzU1dioYEhRt+xChEbljleXVfoQF9Q5iA6wB4r2188L2hgI6DXa7gC8+S9O86sCGEfYAaFyZd+bet0BVCQUi3lFCJ1HiFpRltctDM9okJqCQKEMbUBQo8Am1dbd49d7i2N8kAQVuPPjIIhyoHChy+uR/KrUd6vK7lkcLMYAoDRuN1MWMdMqEVQuYV5+BRzB2vY6UedBEE86U3vOqoj5z9CINsvbjHSGsrBG4sqTd20B4K5NrsDBpNsPlxwyLVCPvabCxIovu3h3v3EbA+sIEThkP3/YqshjGqGFdvFo1+ECCxSOd76wat8FzxwoJckr3L6iCYogT9DBHW0Ls56doiYZSkaZbAFVwXtLqilIx6u2FZrj3CjOfIrq0CIEzF0tPJNoQvgC7wO2jXYwx55B4hgMyANXnqgC2t3JfoZSwClDQjp6IUxyOJCavBpVzBaECbwcuMxGdMueBpWtDysgESf2rZezHK7jdg9kmilDHZE0PpOIBbJRuEnr6O4lvjer8H/I6Ke/USFKwdrzt+9o42HtbooKGZoBFAwhhxfYBtW/fvp2Ga5PoyxPEagGhoPSLQOajB9u/PlaN5it8SpAN2A2yNUKk/XHQP5wbKgpQJjAxpDSJqLOLApRsEMAvOp2esqxqu6DlgKRxaGF0xWun8odgao4xsSn2fEWEBo42UBWIz088X8zIWT0Pn9PuejgPYKIA3YCuPtUO2v0gEU0q+aMeoEkCZAAcCvWfBAMcpKomtc3iaCovyuCx9DMY5GxVFno5qzKbmnh/n0Uhv5Sk1FMBUpR8gSKhNPCOF8RsaETJnTVvAsLRIzaOTaD+IBXRzD0+l57VmS/0guF6vmvbCaLen6lKQ141FGLloupaXS8PcZuTsRlIKvnIbtC/OixrijOvOE3dD86SKWeefEkX1CVDXCiJGsnDi0zSBRNBqA0AoFuEHIki5YC4jtVMHlqsZSJZ5s5aG8fW9J764kh3Oz9ma7/yH9NMhJYJk5Vup5K6I9fRara6mdCWkTEiSdSxYUAUGXjPKpLKUR1ZUXimBG0E8kmieACQIJzASEgEJaVjv2XpPIiBSnnjhhkYJT3/2Nf67/3nFb74C/v3fMf7d//7YcOiR8ujhnZu9NYrz/vt3hVPE7ruv26+7kaPbz8a73exB9+hxC7cGMsfXKHy7p9ES7ht9co7mXsV5dOLFpsWx8GenKWPKwA8vn0D0ZIrKhgbjBy3HhySn8sp/CMyJhAXwaDSmcEoAci6dtvpIMbfASyn942YGHKliThNyIuW5Ik95N673ffO/99cejYcw4w+/+w7l6T1yOqvnMgMkGSwVI+KiYwLDkMHpbFfoMKNKM7qo9E6HLRnPFltDJvsrvXB6VJIbP1j0ibUC0DTJw1BP6xyGeYRaVZ6dSu6RU/YGMk4LhxODyYbqdq8KQYvuVUoBV7ufB38pwsgpRHgVVV+LMc9EhARV1jNXQDTVT06eJiObAUUFN0aSBCqE9bZgWRbDDzKQgIYKMWPyp5Mqz1pTRV2rjERQQxphIBFWXvsYtdYgBExlQiKx87NBmslsLmIzg0SQScCtIqepy0aZyOK9kPITnqqVjNfpsi70rLPvYOtC7Pzr9J08oo/0dSXMOFn6CTIZvzsc9PG0Pc7mRIZmxMZTJ5KtQ8XvPn262dqYkEtCmbKmbDU66G12Aw6IykCdyzajDTdI9zlTfKN4tkrls8yZzo2ifI3ongdaNRwi8Ce0IZS2p+A8jvQN7LTbxxKkchCLIImNM0FTWsnY9W6Q1B25AOMXVOHM3MBYIaliXRvQCJlXlHJCzhmrCK4vSoPm+aTHWgWmUlAs4gOxIFEzXEcdP4QLppzRlhUJwPk84el5VsfAWjutdJmVRTTS9lyQMuG6XDEXjeCdoGt7KsXOYg5ysdNF6rhlygnICVIy8lQwnzKenzL+479jfPr9CgKB2y+RCPj444TXiqaCBdw1MNLZYzoqYOclRe7Qjb1haaynf37lO1Ay15BB27nLO17Dg74c/EVCHW/wd32Oz/hSuelPLfuzXg6+iyVKm0MSHN9S/z++dT9iW5n56PpxO/V7JsemtnybfyYXXDH2dDPepZFgcoz537/Hj9+eQWfgq//2E8pk0edTwdP5GcttgZQJ81Tw/FTwuzPw299+h1uecL0tuFwX5KIGquJADgjcEqQmCDPSlJBL6gbvPaVtSpaC2qO5tY79cWtgriZvDDMCFuD56R0+vP8FXl5esK7VcHyXP7aGldHBsMvnKiJahGClWfNpxrqqwY4wa18A8NpAacLpr34P/MUPaB/PuPw/vzS2mwAkFNPngMQMWID07orf/A/mNPAsuN001e+HD19hmk+gH77H9fqCpd5QecHEBYIViRin+YRMgvN56jSrthXLUpEyIxfBNAGlACU7VUqorfYoy86/qEFMtrFa+/g7n8KiGJtHjOHWjN8a5yHIjHRTVnnYz1pKoFxMP/JWfo7yZjDzVt7KW3krb+WtWFEQqEFMKeFeVSmpt5eDvu7BDhGN0y4I0QkSBMlC8KoQX6vmpBRmSGO0dcW63sBcMdEZQAZJBqEAXIwpVKG4C0ekb0ZgPMlyaQ7O3ljyrnQ0EJo8rCI6gL/57aBHN4dxNQkU2OgCuoKxTbbAXYcNybALciBiKG+EFVmI3jluVBMBXgrAS8yzrGPJwVgmAZL6eIy61EBF05BHpTl6vcB4d/T6cwZTNmMcPWodnPH3DC9mYRnjSwCSeoOxAYvS86y7ciZ1BYhgeF3rtI9w+RsFcvjcfwMWulIMtx3GAtu1MYAWn6ycsyrP+ljoXM3z1JXSOnwechpQr67h6R3n0xn/6IU12m0GPLSN1DLuQe8PkalVucPR5tE4VsNAusXap1uRwviONyYQbaPGxOKGKmJ/jCHaroHN2Pe6Pfe23yv9faMk3Fcb5gKj3a7c27dVlZ9RwQlbS9heC2MjkK5cdMWjkxCVYy0KAEwYBTrtcQMQfWCoIfqaMprS96+/+0Ch+qgQbZu9+zZ8vjd+oE3nP1tTh0AoriErYuOzMUXoit9A5yhcd2HU+w6Eee9E8B4Y61YvAzzrbXTadwAHjb1LLivDaxudUtAwerr2e0Y1vYkb5Zm4Uc4OntrQEQ+Urkph1UEypFWLYCMQrmh1hbQVqSSLqLZ0b0JAjdvcMMWbBPLVliCk5zBLM1qI3lIdnRE9B/C0AWLjNqKp9fHej2MfiqRAeiqmHF5tTtRzVdBMkVAAniG1QJqgJMH7p/mQlnxp6cdebNvmE4X7TFEgtFmjPplHW0jC7y9t5T1AOFrrdHlf9hFookFarDvCkALSqAsENS0WV8MGen/4LG2ouoO7/pMgYEJPzxR30ueMhT43RiRjDGKdvjK956l/R/j6v/gO8y8YoDPSNCFPRT2ipYGlgqHphPRsU8I8FHjU6XWMrNdHkUedvqSTGUv7fvXIUwj39GNHdivHzp1+rLnCpo/O65FAtI4Dw8j4vTWE3NjQwGOBBYnpfNLuHeHs9b+9vq6YMgrggOK2Hc4jbA0pCdKNifoztkw8vYAkdNCSCGii/C/Z+ItFyEk5Qyh1hdbgq60uSy/g8+Ve+96eGAnHlVvJjFdjWsYYmUL7yHADeC2pK5S9xFReRz/O+7pBUVdwdv7HzhtbIyn5GhP0EOHwMbPUHyL9HCKfM8qgxNb/hi3/R5vf+9KjykB0jZhxOwgdRNdG6PkndmZ4xEQ/05tH6nSjVFIZy3nfwCBbvfZZ1DBKhCCcNI2HJJBkM5ghIAFJGMwmv1jUJMXvM8TC8DMIaZrx4VfAL97fcDp/wd6KZ7X3Z3MWDHoUd11nzzZX7k+aTt8PjCL9njgyFP75PWPnSm/bvtDmczzjjr7f9213X+C5uXMG2z7FZ4/K/lwiAD/+wxPWa8LSGn7xXyVYgDtb+wns6dj8HcabBf22rVcGmkXLC/vcI5pEIbz31WivR02hpJEzJaZ0ejCe8dq+z0dj4OOff/UH4Jvf47bcsPAVWd6NM42g9IWVCBDB9tc2WteW94XxUIys3Qn7ehgjbFs8aL8aDXh6Tz+KPD2L9GHbOgiN1aJ0FWrcRoPn899HkW5TSjpHQhZh1wybEncet689sjTAYDMMsbGxKDBsBhxufKPLI5rrW39kpOSKPHbI6aIGV+aoxcQa2Sm5teaguxyjCHtUAI/OaSmj1NmFVBZmQGjw3z7GBFfSSaeZaofgRlFs9Wof3eljyCRyvyhdjiI3jnE+b6wXnx8/o9PuHFDSHvEc2awJfVtUyvouGKktdS01EKlhqaaiUmmm1qppREgwZVVAukOMFo+ghnA2J0u16aZ6vo5jCnDjcfqP7fUUcR3vj5+z5F3sczwwh959uCjZaaPthZgqWqsYEfP6foYZ2JI63GSiHsmusQBVIDIDENxuF1tjakQ15UlTl8GNXAnUBK2q4RcRbP7MUSyZkVgm45/NiEgPYo1EZTSCku6/0tM32VrbYWGAGSb0Po+1lyY1lMmlaJS5BEBWvPwAfPdPPjInfK70GdQ8yxtjku15Fcbb22YTSxIjftr3j6xJN3XfU/ZkNIUodafFSHG3bfhMnzatHsU4rM++51+yPGrH/hx0KhBn52ieOu9Asnk6mtluTZCwe+txW9ykimFny0HD9+sFcMnK57Ip1boQ+DKBS8OlvEc5Tfjw54Rv/vVIK5poQslASs9o+Ap/+O4TGgvWyqaWSIAb/LHyxTllpFQ06lNtHaOuTQ02RtoflXVYRH+bkxp6BOuB/TIzEmXMs0W83KRvdV7bad02XdCQgYwuCcI8+Lni+KvTRaPfQshPDEor0glA+j2ELkgEZCTQvEAoodYV19sFOU3Ic0KeRxpkEaVP0+kMIVIeaLnitlzUwD8niJzVcC/5isrdySxZ/1xHRKRnBkvTaGWNsSxqADsixeqsr2vFy+VFjWUTIeUJjrdHJ2XlG32V+fpx+ccZBTLjIDIvt/T/mf37/4fyZjDzVt7KW3krb+Wt9DKAFc1hzOBk0QHYf3gItcIAm2e8CcYQjUYwWZjXT5cXXD5+hx9+/D1qvWFZlRlba9WcwPMJKRUVHtVFZNuaLhHvYUAgAlbHIta4T/Ux3j8H4F2JLh1Ykq644Q7iKA83wKWOAPSmqfCWA7Cvj4zoEg70u4fOAOtVGTFALX+17EBsMsBSARD1cLJ+P6gzKkci8xlLBz/MutuZ/S2zqiG4dR2op5kC/lq/g1Ns4YM1+4GYEQLDgnAOBldGeEpCUkURW7oVbBU+R8qN0faRCoZ3sy+yTWHg1476H+trzJZX1o2BXNgZIXwBDX+sYElM7eBh/rWbOn+tK7TYUm+lpHVFhdFoT2iX4YIuZJJmA1KPRRbzjBm+JKrw8/ZqHZqaZXhGbkXffdF7RpuGJ9ij+4A0wD2bU90ze2hiiPS6bByM87kZ/fY1PQT2OIc+j9vmDIAu0gXaoAquiIVsx3ysL0YzwcyNw3wufbdvFDd9vP1F94qfIyXqTy9Ha/b4zj047vfrxbtXAaLgHlOknzZ7ThPtsbgPe3o+ox/7tew0U8zjWLzdm354m2h4pxtUs/e+j8+MteCJaUx4JwoRFLbQ3mYG+hp1+ip9Xe0HJ44nkRiAD6NvGjWs1doXcKvqiTyVgsnoaUy75Eojf+dWcRGV5RbGOw1DMaU3Ya/4Poljjm1Eo0jfYv9cCa5RFQoSNXvW5t3SkajBGSFR6WfzPCX82flDV8b+1LJdZ8cGL/HeYSxzD3R+/g2fp3iPANQtBHsE9e3fQ5u/B/x4x7mgA4t2xVXrj0DJsZqHYQpwbzQDoKeL4IP3jLYFWvygZ3HcYl8GtCqb6/FNBODrv17w/q8ECs6rImC53nC9rbgtN6zrDU0E4AYSNs86QTyv/Rx3w4SUxmw5/9FphoOSRg9kbBRE47897T/6fPT3z1fCyNIY43j2eQSo0VSKuII1AAAgAElEQVQCUdvxM04Ps31Ipgy7552ictSfV2WZK6TG2eqgLfXUVmnQHBngLSVCDuHGtWe2rpxOU9pERkqmvFtX7kYjTp80VZwZyCTClEs4272/Sqdyll0/uc+x7Ob3yHjGx9vPL09710Fkp6nOsjpflPQit4YGUwgFHtrfG3n+7bs8xcXgFfY84D2fG/bDuGqLx8w2UkLKBTkXpKK0WkTDlXuUCaXlqrgD67nlodC587JDMSd3m/ue+vo9ItB0Fa31Mcw5Ia+rnu22bxtUASisxlafLitui+BzkOxrJ82eTnkcmZ96OilPp7TzqM5Aee7OjEh/5JUz6Yje3tP847bHejdtdjoQ2ve5M/G18vLtjJdvZ5Sz4Ot/e0MulgYTgxcBcEdnejv3Mo3RNOeZ3DidMIzMXA7X7oz9KSyotSG1sf7vezbOss5SHt53XPj9d2i//ntcPq4oV03Xk5IaAyQ3YommoOJ9dMOetJH7nA7pZ6fjTmOOOA0dpSi3uBGfR4z1iFxOo+OY+2+nba015JwsouqYkz6mO/oX50317gTKGeIGliBTLBpdIjXE6QYfAoCj4bbhGyCbDDHFpfWfLZUKW2wIMmNXG7ucEk5zMZpEUKNINwxRQ7weOcba1Ezh6akX3RhdDSGxOaN8zYiM1XLIM/OgW1pHuxvzo3E8mFrbo7ovY5qKPT6zecy+c1krOuf0M6/vlcDPdb8S7ucpMNIzUk83hT6e67pgXRdMJQElK/bHnuYZaNwQUwNtsLDeyfHddky36/V1wiybX6/eGfgaf/E9voOeZsXlPH25phfMqUBSRRKNDMcsmppRGMUGs9aG6/WCulZMZQbPZ+NjvK+MZbn1iMu6R1kNaLgik55tramiuraQejcFmZAEmdTx6Xw+o9VF937kW2OkOQgyaYTSLqdTwun8hNPpCfPphHmeME8C8BUkGUfON8dz8JqJ/evU1al4dPfzE/VP4agd6Upm7LGReb7wDfv74jm5/exPfFn555IUfmp5bebiVdr9LQf33Y/G4zqjkRFbG4hgziDbsm+DQB09WDRFk6cJZ+hevP6HJ+MhFvzizxdIm5EguN1WABW5FLx/9xV+/SvBuiSczx9QyhmEbO1qAKnR4zxPGulKGmrTdK96/lA34nPD/eY8sG4s5VdyhmOAscQ03cCgj87zO77j55DjxU4HBg61l1U8rTnAbHgazJnPHCxICPnEyH/xEUg/QFAhTaPStEZYsQJywzRBo4CCVC6wyJMjpSZhmibMpxm1XbGuel6sdcXtdoU05XWYGWWaIBCsddW0xVZqHX1zIxlPYahplJtGHoTh0pZSNlnUtiFTOC1Pnb8Vi3Z1v7T1hmTRpZNHcP2pAsBbeVjeDGbeylt5K2/lrbwVK5RSAI+VQZGmIcdrbT2tizI7rHmkhc2jM3WmpUwZ86mgrp/w/fff4oc/fIvby4/g6wWXywuW5ab57MsJ8/kMoknrEgshKMAIcG1tC+2MXhbdUMERw4Piygc1mCF0ll4c8AK6kZA4MzxygztoFP9t2rUBsrftjDmbHfSIjLU93tuj7XWAYfTVATQiD8u6GZ7PKn6i8cgdSBYVHjvwU9vQ8PQ0A42xmoCxrktXimwBPOkYmSuzFdAHXPvAXEGULeuVAT1ELj2N+TJAxMewh820Pri1+shHjU0fovDi435nQNPByQEkRGDMS4+AA00lMU2T5YVPhhlyB1q97jF3yYzNWge/AE2TNfKVb4FMkI6cG9cMCF/zuJq6ZoAtkACmbA03dIzQAd1DyLlf2irWhuJkiNcuBGpJume93f3topJvl3Cog4a6n1gT8Ijvd1032cKIA0EhKg5qbtfnxnDE7r03FKEOzHvZCq1bwFmNXhgi1dqQAcmqBHHa4IIcfB2h9+HnRE5eA2Gj4iKWvVHL/h2PlMBHQCOMZgqGEjIaewADKPDPVksHIWodz7jg373ObFkQ0SbyzZ7W+88+QgKzhl/XtT3WJjw5waZLYW5E94ob5kQ6G9vva3CcE/pCp0XeFo8YU2vte3qeZ5RS8OnTJxApvfB9HyNReR+jUlXTDJJ6RWXq6/hu6mhEELDW3t2z38s+DzmrYihjMvCF3XmqK0XY1xC0nlIywAXr8gw+P+HLwNdde3Z/H63GaBSSzKDy0U64B0C3n+ngO4o/Dwxxjp7Xi9u2jGcHhX7UTjq44ifmaNvnUR6CK+oHiBzrUHZirHe/HoFrQj+p78ZIgJ5+YBwLEtpq7S0V9HQZ5ygI0jL4MkMATOUZ80RofEZrCbfrio+fbrhc1eOsNo9gtIJgKsm7c1fTwDng1puz42GOyr1iEaA05mHP6+yf++cqIqo4Hu12Hsj3qxuoxHOOOg0c3omyuQe05eO8bIzqAj0gArip0fvo92iDGtQNfoZZzFtaFVAJ7rFp90g0UwjcMpF681t6n9bcEFl52p4GM4+UdILeLGMB7hWNo13NaLjyPmu7bcb7qP99zIDNPChfaamI+g5QJXRtK4jdCJktakFWw6PAB98rNvc8tXuG36/d/brrZx4sYaHJCnAKKQlEBTlPKNNsY6mKscN5hxolra3iervier3gdrtiLgXzPFlfuctDRI8omyls3XtWSEPBN7EIPITaKkrLaC1hmizqjzg/oeN4WyvWKngNkt2ecFr3a2j4oKxHCrrXjS60Giece0mPNufFvn0Uan0UYeaojFoe94ug3rzZkvi5QkkwFFSp9zestYO+ULjjvh/b+/wcxo4H00tjXUd+KPLXUca6V3CjG1v7XnbDExZGloRaGRdewDxZdKJHHMPra+LoCe/j7brg5ftPuFwq3r37BaZp0vESpQWUCKiMxu5I43mH9Yw9krfv6iPFKF6LpXQnA8LSD8veHQSb8Y31uiFJl41o+15/dsjP1Mc/ysH7eVqWZTPHfS3Az7MGYk2n5+ebAMhKMKFZmjRlK0sCcdKUckn50JKTOd2IGtrlYVjOLPCwoAJC5dZpVCSfvu6YLeqxnWFp15ftXEU6Dbic6jTanZkcQ9lEsA3reX/uHtXnz/j8jLRFW0Ph+B7/HDGMLt/JlpJ5VDjfuaoMzn0MmXVtcL1Z+i/FVeq6mExSwWLRL1tFs8gJwJiLzZlJkQbcUxI/Q/RcDesPhOPpcAX1HlM6mjfZtgV48E41mPH0i7HMc4ZQRpbJ9qemMLzdVnATlJ5SEViWFSsalrTidl1QckYp2RTOjNvtJWA7mpoJorhpShks3OW+1hitDf6HiMypwjhvAaZ5Qms3izJq5Mb3cpc4NEJoYzcQI1A64937X2A+PWGaTjjNBXOpwHI1eeFxiaupG0B0eTTeI53aRtkCm+ftf9rLHg9KDEfSDdleu9345SA7vVZk939vC923HZ9r6+G7H5cjGfTnLkf8zFG9DHVA2Yd/of6Ej5Hz8vcS9UbO3I2/Gr+ofJoAC2RDmzfs2y1kjh8UZ8beK2OC6voJt5crzlNGzk/4/rvvQAR89fUTTqf3+Nd/+TXqmkF0QionNcruYyEoOWE+zbr/eIVG4yWknEGULO0T0OoKxT/i+FiUMlJHF9nREhGNMO4YEIDACylW6CkTgWhMM2SbaBTq79wYgbIbisJkHrF5HMYvpZyx1gtqW7GuiunkpGcqM6PVRWWE7LoeN5hU2jTNM56en5GS9udyeUFrjMvlihstICTcbgumeQaDzdBS09nP8wnMjHVZUFtFSoqDOX61rhXLoinhcik4zWc8P30ASzNHMzUA8nNYdQKGhckYKzK60q/Z+dLP4iAzvZWfp7wZzLyVt/JW3spbeStWxKLIpDSYDwW0hsFFzgU5Z8vD27qArgAokKeEacrImbAsFetywbJcwNLw8dMPWF4uAAhlPiGXSQVyMo9Vckb8sVihxhc7D8g/pq+yFeIf3NQB4y7wGRMr/g77pyD/MPQA0MGoPdB0ZIzhHrJ74MS/d4VCBxhZQ77vFa/7SA970P5eSYD+95GS3T3kXEkcGfqtAYuBkAZQqZF3gab4CoBGEBQ2Ap1hYj7midLdWEzTdAgqdmRQhqHK/p7XgJf99xEIi6EzRdRjt5S0ARwFCpzGuQBgSmn9WdZmIMnWE3APZm7aKWNu9t8fKQ/3RiBxvb0G5O2HZtOEAChulW1hPSOmBdOG937IZvfYfeaN6QAZ3NtP++xeh/0ahiGAVnEPqAyjgoM9ZHt4DxrHcRr9ZbSmKeMUyJpQJldCEUQaenx6B5NEHBu6G984Dz+lPAJ4/Z178M9LNGB5TZF89P2X7pWjZ8Z6gE2NrVPS/6RvcAdrgmJGFxlgnqkI7djvqdgWIkJJqdPBjTGP0yNfJxu6KxsQ/Rh81d9Ob/U+NsNRbdM0TZimCefzGUSE2+1mRnSDTvu56fR7Dzzfj/swztGw3Nv7xvmyBept47xK3/23gzApJaCJRb6qCpK3Cg+/7rm7NRy9ru9v/+8z/s//rMBSrX8cIOFQxmtgpxqFDMMZ6lePi4SzPIKj8RrtPg3lJ/U2xef3dW2pWLxGd9f2dd+3aEvFtuDj56Ae5TuSIICMQxHc3xuMZu5p5lb5PABSAz2VqzGAdbSxdbgcKN/8Hs//4/+mSgEipPSE9bf/Ct/9r/+1hkyXDA3fXLC0hsvlZnukorbgscyaCkEO6NURn/eIru3PyT3P1eke7nmwUdc/F6R9XyI9AoaxykgL5CCh3quR73jDq3kp04xcMo6g86NxAbYrAECnCc7bRN5H36Pg7EhXac8b7W2BVvd0SjkjwVI5NQVwU4JFk0mWz37qhn99DkQsnc+Wt/0cL00IBtRh3veen3s+Qb/Xz8NwZx8JwOtLKCVjKgUJqfNyewPtOOZ3Z4yMtsSffQSc2LOhoIbtFeWlUiomlxUb14yRtnVQht5XYdR1xXJbumf8k3mjMze0unR67+vDeXZEkoIGkQy4AcFWUrI+KfWOoed9vIk0isOXbbntWBzR2M9dk/5zdO5o56LphUfqot1d9ODz9i1/TDk2+3CFk6pICdkocrOExeL8s6WR8Vgow8Rf9y7tjGZeb4lxT8z2Ml9D+v1+30VDi817bK3HPeCGw3u6FPd+lxOgBlxra33ugLEGx4rz8+21ng2+M97lSuyUCupaUaj11DPs/e/t1DfI7vo+FW88f8JgHJHnzVhFzKCPWRijSL/8WjRQivUpDd/y9Ptzw+uLbT1y+hCRThf9b1fyi60LElNWhcFqXMHV+IVUkCan/6nPlpsAQDS6jCsGu3e9zZ2wGtSQpH5Gehvd6DKm1Mg9+isQnZ+8315iejzvd2sN01Q21474jr3zxf79r8lM8fu9HOXfRfkxzpsbnCLQVB2lxzvAZTNmQSl2s2FJOSdTbgLcak9zHXfb/ZmGTZtGf2jU13mbI3l9vDve3yMX7cYo/t68j/b17fs9rg2eo2CaCipr+hbjHJAzoWSgSuv7MKcJKQ1nqHVdQJhNCS2obYUIeipITzfZ05ADFilLr2vwTl35vn7UoSIhlwSAcb1exrlI4/zVteCGXIRqPJUIIaWCkmfM85MaoVkfM1ZI2kXl3ZX9bPhvxkg79ph0HZ++UR6Jssb9GbT9JBQcCA5SJI57nep/Gc8um8/Hz/zUc/unSgv3q/7nLxsZ8OAbhhrXxqvj3vHkfoxcUvT/gf2Yoj/HpDy/v3I7j/oFA2AaLhhMwyD2aJxKEpRcIXwFUsGy3HC9LhA0/Po3X2MqZ0x5BnNBY40WDrLIiiZH5GzYtEWHE2GUqSCXjHkqOj793A0Yq6XQ3Rj+BbrfWsP1etU27/HH3iM77Xb8UB8VZ30weOee+ZyAkXVQAIyoWZsaKOE0nzGVE2plLIsa73jKWSHCNM2YpwkpKz0rmTDPqTt0trqgmvPnui5oa1WnaVYnwloZpyagrPRHo2WGc4/IDDSHgWl3eCUzkJ1mlDKjlAmtJUjHCAmeLkx5xzheLmaIyU/Gj6WxXglhEN/Kz1beDGbeylt5K2/lrbwVKxEwV2VfA1DtNyHnyfJAi1kPJ5SUsC43sAjmlHE+zXg6zwAxLp++x+XlB6zrC9pywe3yPUAZp/M7nM7vQPmk+dBBgKWtAcVoGfdCduqRFRQoeKA3vntuK9M52Ozfx98erYZMLz7EgOGBvxXakzN7lMa7koHgnVdXNZQK1xbunoBuZGNCbwe6gQ5YpOxgdQI3Z6wV0I9g1x4Qin9P03TnSRaVBaqgLT19SBw7ZsHlckGZEs7nJ6QEvHv3jOv1asCWjpMCagrYJ2IVgFjD74s0JFGwzIFX8nDH7OCXMsKFCMXAqshsO9AaI86grxIHj3bGHAGQ2htMOCAb7zkyOIhjlrOupdt1Mc+lYUTkXsm5FBTzWgAEdW3gtm1HBI7vjZRMWDBQzIFPBc3U00DXXerrWJ8BSkrdQMEBJE2vhoGY7WQ5ooSQOOEQ3DoG+RwsdCMoB80dbLV5CRCJK/70u9RBIN97AxS7B2AAn4f4zjhX90q063rTlATw/muEj/6kz232yDYCJE3NpOFDGSwVKRdQzh2EJTJDORfaOk25h1x+biWsj9VReQSq70HY8a4DBQcCeGljtweC9/Rl0BMx3Yp0kN1DsW4jbe0j/FgUmt3e3YPG436AUrLsCdJpoXva6H1u6KL3qPLD/ajEzpKB6ng6p34OmJGLg9XruqDWoaBwBcKyLLher7hcLnh6egIR4XK54Ha7qdfONHUw9X6c98CJArcQxjyfejhbmKqsdRAiQ1NEWf8thVKkVUdRbOIZr8oWHSCuMaJaQpJhhHSeT3j37h3mecILEVr7qbDivozDmO6uDAOZuMv9rgGnDSjfgbbtt676HKMaP42IRltjmXDHRimnz4w2226/e/8xUHlfBA7wQD2toWCRw5Gj7gEK33NEiBlE+pujb6AbHJAcxQOizUi63yj1v8dYjivj/3J+h1/9q79FXS3tGBe8fHyPRowGQUpPaFXw48cLvvvDj7guFc09zxMhpwIiQV1hANjY91FpGNdt9LLuvdjRsL2BjJfkYdas7I0T9vTln6ukvE0P4cDtOLMHbxDL/gzunuqUIEh3UXhi8fGIkfZEgJFqROtVuqI545sZNbkxBgAFYa9XlFysPc1obzQyJosOpQr+RIQGAosqSfM0YwpR9RjAuurZoIZXGUKCxq23zcFkomyRy9ToKjsP5DswATmksHu0VqICcii6yYDptfO0IJ2fWhcAqlj080zFlOF974o4YBiY7411ehrDA37rSMne208EghrtJkqAG8Vkiy6TJ50Tu+5yRE5KW/wsrK1iXRc9n5YbUsp4enrSMyoXMCXwBKxVKWqUf/pPH0MCUVNejQFQhuQEDxkf+zLOZo0KqYansNRcr+83p0+PzFBk93t7Omzvk939FH7rtf3JMei9phe4P5H2146UPfvyU0/Qbc2jxb1P4QzsEgnd9/RoFONZtjtKQGYYkpPSbMF9yt6jqDMbGWrHx+2jdMTnhgJeDWUICZQLiAu2J9DomaqYzXM+nGb+O16J0X+8ryXPeHr6AOGCRBOApB7XbYVGZMoQeCSrZu10Q2jdzy5TuJzNzJjneSNPRmOCRyXuFzcEEYv44e+KEVA9esaIGqg/BD8j7gGSRxGwXPaPxk97fjHn3B1XnCd2AwE0tvonpDxSFfeznCvqrWKxds3nZ6Q8AUQWYUZwOs1grpbOQfSs7PSL1WElZYhYaiYzrnl6+qrPgaay8ghZxjdkMrxB7CwZ8mnOk42Bp3hKGjkW22iSzsMfKTv3WMH+us+pv8ffHe/388HHzL8/n8/DeMNkJ5VD1EBpnJGKTTjdzpkwzydvCQDCWitAWTEEYrus63mtq0VOKXo6JfSUaCyMYuPk/YjphBwn0rP0/oxV1uvL+CrlS7b3H/FmnZ500O34fT4Wjld4ZJjb7QIGAzShMYObGXyRRo9R+UujGXGILvR8egZzw+X6AjXq0nQvrVVdj7WhVo04TEkpUGsN1LLSKcpAVu6olNmirymOmBIMI7ya7G0p4QiARfaDKL9HlJHzGdNUME0zTucnPD8943x6xsvtijIJSiGkuuI8E8orAUGPKJNTzmh4uae9+IK/9t9EueJe1thKhl1+edz0n7Xsx+FLzvJH5V+qzUdlL7uO62NO/5jnt2+5vzeOF4e7idy5dPtOufsZnJvzJf7+RAtS+w7LS8P0npBQwXXFpx8/IpPgm1++6+nUKBWUlMFkfDrM8CsDJQsyCchkrkSa/rU7NLGlvQ88k2OL3Ngi1VufjY+J8lrEXtbVHY3p7jy9ixi2c6ZKyaIJBl7KcU7A6WuzFIzqnDJRAUTPr3kqePecIQyczs9GvwncLNrVTbMGUEoo8wlEk8njV9yQUaYJT+cKnIG2Vqy3tRuyXq5XTaFl9SciNIvKldOE9++flGfOFjHG5Hs3rvEomMtSrX/JcGz90XTBZjppaS91TKgvID9nKCXkooY4RAksMJ5kq8t4K398eTOYeStv5a28lbfyVnqh7qGoSna1TnZvFlemqdJRoTmBWnLnMlu+3IKSCLd1we36CcvtgrrecLt+AoNRyow8TUilALkAlAFKXRml4Y5NYoaG4e0ewUkgzniTA7YuRMvm78FkRh3JFsiI93UvClGPk2QMHPq7BxPPzZWmVhcboE3G7JIzt87UOQPNYB7ihdhYKpY9nveQ92zpoiLwPEC34QF2//09OBEV3A6q7VOLOEjjZQBlxsjDwlLm3IF0Z/wBVRjUaqGLSYUkN6hRYxjqSl6BjjOLRzFAryOChjkAb97GPWgizObZ9lhEjcqiMSZbpacLM0deU9GQQNeIMvEeftPHVERQQmqmWi3cpcBCf1JXou+NlgYQlTpqRDTWpN/TGgJ4N56T3XxEEJRIBQs35Np20D2WfBxiCOYxBrE4+KQ0YweJGBC5fdb3JkI99ykkjv72MRt/G4i0XwfYgpVsHom+N+HtLXnznL4YPfprThmn08lCJ5viC1UVBpJM+EdHeHqVB6jKkeJ2dwdEtsBqVCQ8Kq/t97hn9t/5s3E8o8A+wFuYIlY2e/LIIGjf3h40OlEfK0k6wGq0ovErSO1C1KNHkV4zHrjvp/cjtkMNGzXHiqclAKsCb3gJwZSN6J8TwUB3XZcjctYINe8/peh9y9L6d047U9L975FlfF8DwOVywbIs3fM1KrL3HrwRIBnzpcpr5opaGUTSlcw+PzYq4WeA1OohO91FtYlpAUUYlVfdU0lzwzczyNRw3wWJqp73CTgyYv3Ty1Z55fPUlZO76mT3v9BQEnJ4kQOy+3ePOuK/I2DxGDilzfP33z/q4dGobUFC2lw/et929ON+G3/J7rsxID0OGJJ0yK2D1vG96d33yH/5f+FWPyDTpB5p8xnn0zMoF+NNgOkDAPwZUlblS0LBh1+f8Ff/k+6Z0y/IwjoveHm5AJSNn7GabA1qiPBBK/e0/0ix2nu3ow93Y3andNED6O7sOFDObJ55pRzRRIS+DEMSDxW9TWunyj3e/J2Da6E+Q5bGyc9wAKK56EsuqBaFYR8tIBrPxb9VkT1ool+PaZGUdxgGy4ApECuj8qCFiTQto/NAe4UrJYJQBpIqhqZ5AkTlBjGeEuQRZeCNsnaMw3WkIbSbjJfY08SomN8rhR9FLFNwVetzAyaQ81/6vmkqvQ7vNwTDkC6cybGuo7XL0kIfx/f7uetri9yM0IxOUgYoI6diCsDU35doGKaowr2hNoaYB6mwmIKwIRc1sGEWrFVBZo3+FD3S7RyPYD2cV0h6LhAB0HNqGK0KhjFY6uOrfTOj0zIhpS/werBax6d7urX/Ll51uigH12n36ajszxCPgxDb0O8RMjn1p52W3Qs7eNjH+seZo9K3nx2RA9gqN+/r3/fjsB3h+0SEpd5M0eEpGtE3W1QAAdis+UEX7w0MgMGr7A3XnJdnZjCpnMyJcf6332Ii4Pq7d3j57bshj9/1j/rY9Lpe6W/OE6ZyRmuEnGasK9l1S232mVGKNCVG5VrXtfN/LqemfJB+F0O2c7rr/KWnZPKxct7TjSWd3kaaUUoBRI0g7vinwN8OY4ZhHN1pzu65eIb5e0Z/s9JN1ueOUhpnq8ONa1pjLMsVKVWkVICpaHQNaZbuQp1s6qrGFlr3MGhnVmMZEely91h3ydLqwZ7xH8BTLDE7zUfnkV02Hfc6hpM2Y/aI//C/t3jBY5xmfy0+72W/tnz8a62YZ4t82vvucwy4XMnhnM6paDROkKVfJ5AkrCvQ2CL+FTUWadX2eiKdFx4py2uttq4JRyrJMX4HX8Jolox777G6ARLsZb5HZ2vkFR8X6W1rreJ6XZBKwjRPdoSpjOrOHOuqEbQT5U6P1Eg14kguN3JXHgvUsFbXzkjrxo4TmlFOomQpuafeLuba92JywzBmw2QATYGdzTC2IKWCeX7C0/M7PD8/43x+Qi4zJjYHNghKAibHLF4dnfvP1ru7c3P/3P703N93TH8fnU6Pn4gnsP/1U8/Zz5XYl0fv/VPq+7kl6D+u3gMZ8cEz97zPo3du73I7aoGxiBhOG37XNmZ5f9J+E1JowY/fvkdbE4AJ86ng48cPaBOjvf8I4YZvviFoeml9aUojFR1QQWBN9ZgIiZRbSkQ4Wfpsd1ogwzkSNC2TY91dLghYCzDOgGgIvK5roNslYBmDxjg9YxEkYiRKYEctCIBEpxG96HU57uwDqQ7OwLoklKzuCgyglIR3799DaZSNKrmxq1LvKfAkev4Z7s+MXAqkMfI8Yy5qQFjXCgF1gxnnI3KakC3a5VQ8OhtbtDLNTiCeOq6fg9t1M+g9mVzisogaJnZ3KmeVVRA22tx6BCE9q75UrngrnytvBjNv5a28lbfyVt6KFSIL+NwVpdEjzIEShZCUodLw3gzBybwr9XrDcrvidruaV/6q3j+5oEzqfSSkHhZCyhhJZygNACQXml3JoZWrccpdyzd/DTBi3z9AjWqcWd0K5PFpARoAACAASURBVP4sYN5AKUb+GIo1t6gmM2xQgWArRohhyEdKn31dCuwMA4TIiG9BkKNnt1/s69mDO13JkVLPW+p9dCDO7wXQwaiUVDGthiJkilxl2ksZYD1bfvGUBDk5GGrePYlGeg8yMMiU1URZFUEy+jA8l3jTnz04KeG7fYkgy/69e8XEIwXdftwjsBvfFZUWDnyuq659yqWvkT3IAwARVBMboC5UMh+2RYEVV+RnU/AMcFBkhPEcgOMxqDQALPfiH8/Furf7xY1ifLyiwnNfh/Sx2YNb8d0x8ojWv23Hfi58j7EM8DeCp3tvfiJCwgCZt0q0YbxSyoScGcsS52sv7oc29X0qd/16rXzBLT+pPAJg994ro/57WjEEVpiSlg6+f1C//UcwI0Tfe/C5BXS/27yRRjkZEZDQJz3uxX3dG2WMRVdxWjzu11PMo9Yka1xKhJIzaqsGrKQOlpRSNgZHzbxYb7db/96BcyKNdLAsC1ShOnUlh6+DvULjiKbt5827tl0bO6V7v3/0tY+pAa6n02kTxWpvuMPMkFrVs9FCobkntSrGtI4eYvxnhPpcseVn6lAFOrim0Sn8+iGY273qDYTfGfTEVRp37H2kmC9p6798oTs6cwRP6hqIoPE9FOoz53dFnmarXBYAePqI8jd/jyZ/jXl6xun0jPM54+nc9AyBGRYgodYTIDYLlDF/KPjV31rEuCa4XhrWpaoRSFFjQzGFiIgAvI0e1dt9QMeAsbc7T/JKuadtg5mK7zm+d3x+LXXnQ1rovNvmrB/fOXAZFS8iyueyReiIfI4bNRCxrd9hSANAFVsY0c+icfCdAUunq25ovB1fpx97pZQ1Htn4fDWQScjmad7py06D4fytGymmpFERWFyBpesCpAb43Ou7N9QcCvbhjb/nJfb8UpzrSJvj3Pl1N4QfHbCIOal02ipmyB7f7e+IUWWOFKtO/xvj1fV7zyf1xCXKJydvFwW+BP175Xu0PwyBVA4GxKPtroyrrQJVUwjW2pDLaXhwbsbD95EZLVvyNsB4VkL/cSDbldEDFNc2J+OzUq4PxyGWPVf5eFfeGwJ+qfHEvozz4YD/DPfEz19S9m2IlHl/1t1z0tFYRrrR6KBw49P2BDluHe2uy/gCII1KpOkNVH2VUur3xKhfh/00mjZI35aOR0ONOBgk0MgqRGhEoMQ4/8WPeP8kEM749Nt3m7YKxhnnY3jUoqN5yrmAygncNOVAa67gUYxi8F4E5mQGHFu6EvsWlVobOiOAWqtux3tP2yJv2FrrO5+ZB8Zi9Ub+8u4seoAZ7Ove06EoQx0ZWg664YZ5ZmRIrVfpBusIbVR6oN2fJjdCsAi1SZDS1HlNTdOqRn3qMZ/tvDNjmeBBnrrByzDEUNo4oobpGfcZ2SWMhcvAW9l+e+9r73r0/s/JY/ux9vv3kX768311CNxtQF+ZTCSyvSUD+1maOqElIkgaTkgpZTPugM1V61GlBWpkCQwZ9whrimPm51anRX6/xLUY+Qt/38Dm9mMX6/yc8ZKX7X3DIG3gFCMyrvZNeaLmjlg0UjYSmREbSTfK8hS2LkMCboSlay5t1oq+IydPpTiiQjE31CqGL2pkrVZ1dlP2tayGskQZKReUMuN0OuP/Ze/deiVbkjShz8x9RezMPHWqaqYLumlgBtQtBA9I8zBI/AT+87z0T0BoxAsjJATSMOqBqnPJvWMtdzcezMzd3GPFzsxT1Rc14Ud59t4R6+JXc7PPzD97efmA6/UDtu0KEOF6vSJnAkTTeEorEBgzzWkvPS6PZOnZdd/yzPNPRyDq4+t/2V7+LeWsDt/6zi+34+++nOkUaz3emw9n35097+y98f9mNZrmuOobc0CWTN8M7eTn33+Hn3//Xbj7gsvvfkb6uKMcQCkH8rYBlNBMRtZyoJQbgKI2RjNmslpQjTWKSetWStG6chrvcBsCuh/1v5e9dMhQvvvbGR8Bss5QmeM4EkNsH7V9z2SiNIF0ewV37yNmY9h02dtQDj3wR6KML4RmzPFhr+1pUt0Gsb2i+dEjta2aVGx5Q5ECJkbeEnIWlDQCZvo+jxGcOh26FrFuG3vD/awaOuE0L0Jfq2xW28FniZBjEQ0eG0Pk9ul9gPaz/PLyDJh5lmd5lmd5lmexEoNiklGzEgS1FBRWylwIIAbSMivIzYn7iYrWKvZDsN9uOPZd/x1FWVnSBs4XUDKlFoNZZhj8MI3cHBUyoD93toYaW70B9LQwZwCEK150p3jeX28KmSj9YnJWjv4iqKJNhNTv8Eq6squ/tzaeN78mmjHjRNI4/RRPcw4Q6EvlzMEUwTUHXJyBIAIJqyPqUSBHrQ5WlU4F7YA4U8Wg5vemqhKdmDVV0WWD7AdA6CdvGNJP7ShLsN58ln7B23Q2butnj4IsJMxjDtdER8ejQAJX/FPK8HQFY965g3l2OClTRdZAsRNnytouBwbd6eD97yd39R0jsr9H+Hfmn2Gqe/PGzxVF9TZ6HtroxBrtWtPbxKCEMU/Xz51Cc+Shn4Evr4D9I79mHcM4rzE9v38ORUXjnIlzvxl4K5gBP61jAPxFGUrEUof42IFY01J055VX2xyP3Ri+G9YvlrN1+zXlDFCMn9+DmWv/nwOSZAhz7Kv1HWdt6NfFTuhr5/46/9yrET9/BITeO1x0LvjPDpCH9TjWk7aLSAM9xU4Meh00n7WduDc5dxwVpWh+6m279AAUf66v5YudUqq1djr5lcI9OiGiTDlrN5HOQaeZHY6AQU2rt83nqyPgH8f4zKksbYAztRWIlF63CCorY4FP/V8O+VH/NwI1SLpLqn/Xrz3JX69LbjgMG2bAzV0I65sHXD3/XJdsZAd4VCIM+KUydvl475fumeu71tn/EneVODVW74kIOsvJveHZuSG97HDOQBGAPxC2/M/x6dN/icvlE7btipQuICTUquCeB1U3Ubp+dxZUaYDNrSaCt7e901KviswMvD6GYR85Y98rv+SeP6ac7ucubOB6lO4VKY9UbwMMddY09ICYOHOizqEpUoFty2hNUOsBzqmnelhlEzCfTvf6kDlvCEOe1nr0U5muy0WnbD8RHVkNMNjIqgTKcgEc3yTOgIGopVYQKXuXNzPqv10vIALEnVkqn52NRz9zuRSZ6tpXydk4buOf6rHUgd8QBAQJOlBT52EDpEqv89neujo/h85xn8pmrWfcs13vcIbPoTNFfcuDJt0mibp4kKvwINLZKVtLwX4cqLVhu3yYnLRe57HPet2kP3XogA3K4ODBlxpILy1ZmtvgOJ0k3JfLLNdo+TxKWeky7WtKCD0Ln8X9aq3HLNWnXefBHinh/+MNof40rohXCQmcmSdajg2iKUF7K+dnjxoRSGjq6fsWjXrka0W+NqQLo1oQGxFBTL9uzKY7zfP0zOEhIpoOcFl750w0dk9vjc6jAgEaUIlQ5X53j31ms/C0bfFqIQF/fINAwNcGShebqwW1iCmEbCemU18nI/hwrn8MTAYwXevBJSB1wjNmG+RMXz/7O9oz/jcwB94N+3asRf887gvx+R6wFNkIV1t4ffdsExOU+SLIL7u/tgqxuaPbGuv+lzOkqdNOnZsFx95URnhK36ZslHqzBd2JnvpvPTjB5Vu0FwBMWmXs03t7Qx17msrJPydyloD3del1T3nPrp/GJ9y7roFYzsZWMQUNyJhTbo09Yuw37hxtPeAKUEaZgQWpfna9XpCS2j4jxe1cNyKEuS5hfgw7b+4f9L1xqmZok84//ULkXPdebcB7O3LG9vx3EWX5dexERHAcNwB2wCHlPn/7HgrSNCXZWZGq6Rpkwb7HsIegTNB+cCm2y36DGPOaM8NogEzussX32VoVUxMhbNsFx6FSnjpjHEOghw2ZkqaS+/gRHz58sACZHHQXTR9eS8WPPxa81oJj36xG/3jKfV3ubbf3v/+7a82f4sn/GPr662zOL31/pjFI0DDO3+s2quNJDM00/z4f+LyXr3pZLFsGPnxM2LYrbm+fkfMLct5QS8NeDuz7G/bjFUQViQBUwdvnG14/f8a+35BSxu3trWOznDTYw989UvfNuon/7SWmM5z1fdbgt/D3sAlGcL6v8RF8J1Oa7d7f9vuKQ409RIN6iRKc3f44nBFsU3uxeFokZ5IBevYi0pR127aF1NsE1Nb3wpQzahNLu3tn1vd6eMC9Bw6qffd+mqQzHcj3hiHfXQdp8LBRZaTz4NLRz8/ypynPgJlneZZneZZneZaliACJM7as+bgTK/VrK0UBJjDQHSYKqKUtI2+DYUZqQdl37G87jrcD7QBePnxCzp/AfIVQRkPqQJ6+V91fyYxfB+r0tO04uQnMRrM7y9fixruDzUMNdzCroTV7Vwe9ga7sCQBpaCUy7RBqOZAtf/RgOZGpHbNTfg3m0b9VoSQ0jtTzg0I/Bkqszk4H8Jm5Mxu4cR9LBL3i7yIy3RcVcQcIleaxmJNM619FARaR2k8sAUCrDQVq7HvUvlh6FCY9rae5ljP2/QY/ZeqAimJjOvbep56fPaYJmMeX5n5+B3SKQF8ECj3Xun8XGXbOwDC/N+cN+y5G0++nvlRZr3WAeZfLixofRnUfxyK+J45zN8wmgMyNK+2b201zXGs+eXcmAe3QU36DQrqGeT9ArtCLICQ7BaB0lp5P1gMNrBf98r5O1UiJp0MbBK3XXw3FpExNIAM59T0g6WxRPnZsTjLqxhHBA4AGMDvmfwRxV6DO54Wm+7Gqm7FHmE+Dq39OvHlQSm8FlxIbKMsMIUap2hZpFFa8o8Hn5ZGjDvau9fsvGXrah/MJxTNQNjpLozP17Of9KV91uBDReRovzKeLff6qoa8nccQcBSnMayZbAy2cRq11OKbI6WKPu4Cztf8U4LB2BLrWIc8NsnEHLuk4AmIDLUhZ5VApwHHs+OGHP3R5w8waCLNlkNG8ujwCBkjirDSlFLy+vva+vFwuvR5+bQyki06V2CarrDoutw05qcPxOI7JMUPU7sbFwelIub+OVaf0Bxl9r3SQXE8sZZTiJywTPn38Di8vV4hUPfH7RxQPlfGUS55oZHzm14U2hZ9CI0imB8vcpbC4B+P6c+X+u8n1+U5AkLLeUdckpj3/5N1R4/gSDBw/p7tPHv/ldRj33T/51AFhP/Nvf8Snf/XvwPwBpTQ4hf/l8l/hu49/CSDr3l4YW74ikzrNS2uoraAch57WqwV2fA9lLz3N2tvrG263mwaItGNuocDcugyg3sktL8Op8thRtV6//h4/+1PCaGfP77oUadsiNbSuv4LWzmV1ryMR0BljVH56QJ6ellSnCmBOWrp3pg5q/5FGLsoETfvkYK07hO6DO2I9iQmcswYF19L1ibj/OthLRApAm4OIeLNgqqZ86Y6iQ0ApIZF+53KbWjV9onWnpso3vpsLQxdkbBtPctav8X6IfT76SMFlYsIIzImytPbfmVlTKhEjb7k7Wp2G3VnI1vGM9kBpcjevfXyH03re58m8dFIKYIB7zhsuV4EgI1ED9VRKJqHE9/0x71NOePnwApGKUo7OmMmJ8TG/gDmj1HHKf3YUYzxPo9vtD9tHpECKO2rj2lAnn6aTIkCUVbTJCAb99iLh//5bmLNf6Y57T3Y+eqs7VMZT5qCZsz1GlprOu4Y/l+7q7ukmPaVebMO67/knOgVGq4LleVq/+Nmv/+UP+N1/+xPA3+GHnwWtCNQ1wejsUIu+eCYzfP0lmu3XaIueXa8PbGhSIcyAZICAGyquRdmZHpV5BrxzzWXHd//Dv8WbvOE4LthfGa+fdyiTlDI4iDQcZUdtbHbwYKdyZ5D/rQ6mOrUr59xt6J4ec1lTrheuzK4xiIVgOjXu0x2dBWh4K8lS7qwy8KzP1/FbgzqcTTYGXo6xYhBvKr+M/UUDMhjpkjX9jekAl+sVye1xErxcN2wWWF7K0VkfE2uQVQUgUlDLwGi2lxcNwPI82tCAb6KEnJ25Q9NguAxtUifGH6JkDCEaUBFl++j/eU/0Ppj2uTCH17/jtUTU9e64J3/pPv89BrIDwLZt8NTQXXKcYRYerJV8PwG++/QJpRZI84NPu83RBGZ01l/dP2q3u3UfHDI92jSuQ3h9/V06Z2aZTNFZK3OQGYA7PO9M57vfXwf8M68JQUrGFmVjeLvdsG0bLpcLiDOaGA4Fd4jreBxHmfZzDwBNOWHfd5Syg1h6qkZPYenziomhxDQaaPPy8gFp2+wQRALBgmAEOI6Kt7cd+35YnTNe397QGiPnizHeZnDe4AwOKW/41fe/xuVytbROFtTMjO2SwCT4j/++4X/5Gwbwq65z/mMtZ/vaeXjk+T3P8suKTJoH+u8SdYn+TdxjZ23k0ewatrJdTdKDZh7ZxYLZ7vfvproI4fvvXvCf/eVvsW2/wg8/vuLt7Qdcrp9AtIHQcBxv2G+f0VpBqwdef37FcTtw7EeXl58//wwCkHLG5XrthwGawOxa6p9NOh7NmHRKCZfLBdu24fX1FbXqgUo/9KTr1m2t1OWp7vPZcCg9uATH0CbbcNhankLKO6TvyY2x3ypSJlwumq7VA2ZURhXsu+6Vl0sCoLiqsk9WMAuYM7btire3G263N0hryMzIadP0dAI4/y/IgtJpMBFrFknHA23UbO+eU72udr7vha3Lsm4LEsxuiAcULFCTevQiRNS+SMQdG3yWP748A2ae5Vme5Vme5VmsdEUEg01EFamR7qQ7+QwUZyRsmyqJOWckYrTaUEsxmjwHxRmcNhBlqCNAnekgslOoelpOKQkdgLTbZY2iHuDtACvQwfehZNpz6B489e/1/qieR7BiKMQppR5g8vr66k/p93l9BFjqGFguDATzdnTwjXL/fgQ6BKpqoinl01AiR6CFO0OjQ2Rcew46AOhBNh5A4+Mc789ZDXti6SCIWF/7vbVq9lXNq2yMQ4nsme70Tgpe5Aw3fwSibaMEpXe/BxNXgHAFl6xhd2Df2gdn5Qz4jWMXP1+BxvX66IBZx8GDDhwEXYHL1TGxgsrxb/89njLodTIHRuynM6fctJYYiKZoqyPoJQJ+Ou2UeWkYVw5uDeOa2BgOfN0JAHKzeRjnsU/IFntvg9ZSpUBwkkWWqOGos/4LJ946wLi2ubXZya036/wBQJTA4vMQ4V41oCF6Qsatd5cTXyqrca3PNL/hcl38+c4T7z45m+dnz1tBcmBe80TuiB+05mfPWxmgxFBSCca+1zTWVlqb+t4DZhAcK6vjdq2ng8gTl4YZ2/3ZMCPc3sfMCkQYgFtDAJunT3PHRt/n7LlK79uANFKB+Br0uuz7PoHhXu+VtWod20dzQ9eDTHNkDrQzphkHpANIPe0vPNLwTcxiFPpMGjTgTV+u3cQgiydMKSGne0fwtxRN+EhIwsFRaetuCWR57AYaUuQ8WOYe4IM9f/0OGHqBz9RHq861BJCMGSdn9OGy3HXelvW++Pf8u/71qD8c2mRjmXnUF3M/UG8pp4yP3/0GLx/+GY6j4jj0RPe2XcF0AZAg0OA2EWdPM72waaBMqQWtHZBWVfcLc6y2AhmZ2U9bH/ens+CRr3MQ3pdJLo0Pv0Zcf1N5VD9lNVtSLQK6Tie9MUpIwsj3jq4vuMPNHbFe+t88zxG/XmSmCY86vMpDq4/V7Uyv6XoVoMxBpZi+Z6kiXG6LrUsRwALKU0pIOSOlDcQZ1Cw4D2EfAuBMKabZ6p5vb43zwvtiLVH3O3PGdxkenN7R+S3CWJlB1vnj1zZpemodnm6E+ljFukbZP/UlEUBpqmdMfRoBYTGHt6dg0v5VFh8hQWuMWgp6h9nzJ1sNyk7kTncPIPVxY2aQ601QG2zQyPfeWPYv6fqP/qUhjB5ITFa32B+etqKf5veT8xa49W1lSMj3lnN0tsSfZ8862zfic4QEVbz2ca9YbNZ35LVMP4cuPJ4g03VeKjVAGARngrzXqwjDCRUt2vWa850wfJ8AzjqPhJqx2HjF50Bsn19Rl9LLgiynB5/7O8O6GfUYrfBl3FozhplvnStW9fCbEMDbBjkOHKXhtmvwQUoEJnckIcxXr2tXLU/106kvF5tU+roan62/r/JDsZY25k34Ll4f3+X7CXmqRJzL93UvjfJibZ/vPZGlVnuSTJ5osF6tmgZYOrbC3dlf6oG3283kHYPBoHJYELYevnJbzmXF6CNfF6rkjrq67CSMuFTfSySkg5Bub0Y7/WyceqDXyV5zNs5f0lniXhPt/3hAZsULHr3LizMUdI24vy5IpRbroNcLNIUVS0W175VRIA+bi9mYwEZwvDuKI6stM7pNoW1bg/+NsW1V/ST22XCADobpKL3u++Ksv+N3689VvjgbaGd7IJ6uiwdy/BmR1U7nBoNIGf9qLXYgbIPjJJ0luqkOaDeDzKajzgw6z0Gdyz7vNTCGaUNiXUPbdkU2plNOxn7Fww7xtaX7sgDiabn/xErv31P5ZZL+Wd4r9zbrsDOBYOs+uD7aqSPoRR5evxa3xeM+7vY0Eyw0d3wbdaW1DqW8Yb/9iJxf8N1336MJARbM3uTA7fZmh5gKatnx9vkzElJnjgcEx76jiSBbSibBwKhFI3sMMjI8ctlTfT+M/0Zgq2OUM25ypgNFu0yErS2EdRtw7KdZGnPHf6QHMwJUBa163M1sQ+nhA9NrzOYCaVurKD4qgp5ufNsy8rZhSxc0S+2kAasjbWEflc52azqIyaF4EMn75XRuqBkZvpc+U/Q+78eofQcboI/Ts/wpyzNg5lme5Vme5VmexYuo0iVsLhViDKpVBeb1tIUCKKgAOIP4Mow4YtTScOy7njIVMqAPyPwBia8AaYoTcLIT/4yupZ24fJz2mzlNBngHjZw1Q/S6SCvMA1MIipiyy5ApdiJRGV8AMKKgq+uDPEhAqdkDiFy1cmdG+kqDPIxx9Hr7Z19ziszHRkT6yanVKavghznHPL2VeKqoEZDi13sftgAU+MSotYDaDH7GU0WABXDI7GDftg2lFJRSUWvDUWo/ieM9CuipYBCDSY0TdcTVHoUfnT3xnztZIqByBsDG73r/yBwwsz7bP/drmEde8OMo6jxpI2+4fycyHP6AOhm7wUQ0sdpQPxnQpplPpA6cMfcZzkgEAJdLBPfCKS6iyVl/fzJyBByMNptF2NTUqM3yw4vVlxjsIAxpPm0GoCnZhsOdILPz3uZFX5qIIPEIVvM+O3NySVMDL6a+Gn1tDruUjOWgQlrreXVFBBJAXi81nOqO73Tnz0h7MGSN4nmtn7BDD/YZzsKpoX0c0ccsgtRjbs7zdr3urMRn9n46Mb77HBYFoxH6z43KeHJ+rpEF6Xk/Bselynnq3/l6FjaGgNaMYcpYQJo6+KrzvooEo1rroJVbAnfY5l6YszFIR8dO2+JzY9CyWopAaRA7xefpzEAu++a0Hdu24cOHD8aGYYGi0nr9/f2tedq80d9Mykbjcr7XGeaTXuRyBMjXee9dNNgQ9En+d18D9p8hHlBmJJrAfk+t6CwJx6FMMr6v13b0QSew7REVgLPQMPK2oUnD5ZKQt4RvLbFlHjRDMubZes1ZkeVfwxwscwbS9R19CZZZ3ygnvyE4RNfnTEEzy133tb4H+dbf7+/wcDX/7AG41K/X33hJV3H2DgrP/fSXgu//OuNy/R2Iv0PaxIgixik43b80DWUtBUcpxjBQoaePi7JtQINllEZan++yJSWde4lS0EOGfBfMaZ2iExC4d358TbmXs7iTzV9fvjzS67tVvA1H1lQfwxTn9vmF6Hu6O12GQ+pex+nyi6lvVnFv8xLl0qRHhVN7ENFUQ+EdxGRMNKZvwIBak8sS+qeDmv0UpQbDV2mQeoDq2C9SUl3PWeeGHLZ2dBa7qHcNem6YkzCmktTneFvlZA7EAFDXy/2a2sFfd0QOfcNSCvW5qbZIZgPVZdhHq5yfWQR8jgN4oGfGOXQ3ryDO4QfXn/QvTZ8F20b1RP0VOVl9BEjEkJTRkgZGQi5ol4JSD9QqgOh+mJKOW6vS+9T7arIvWM+YDuZBddBXk1wEMnYQD551piBnRmM9o0oZv/2zH/Cv/nXFf/7n/yn+zb/5Ca+v37JOx1jOn2m9v0ZanO1As3x3N4naUU3cfUynb79/2lxk+nkvsWX5rNeFhmx1KT7SHY09SWwHOa/X46BQL7U0vB0HEpcu02N/TEww/txgc612qE7Bx9cDs3x0O0ebpQ4aAUCsARm+ZuP+/HW7AjDJ2ZLAdAGJsmX5KXCxlHQul9xJPt4G+PpbA4a8batNKSKopQIhxU1kGfFnrOyDpRRApJOprH2/7pPdFunv5m47+34R9wC/z79ri220jmUsrTWbawS0hv0oul9s5l4hl/caZEucsF00yOAoBxIIjfw0uLHSBlkBeHqFYVqNfdMZV7WN0gANMLBUFxisr61VgJQZuVkwvzpnU9+LfUxd1/b3+H41bIo1MOms+H40z23fI/yzNWDnkQ23HuoZY+7PR//Zr5P4DN3zmBmXTVkvc96MARggTrjYgTeSZn3puq71QxNNq86WusrGg8lZbkegp9tG/q/LtVOZ0VsFTKt4OIrP9MCuK/gP8f1qBOAMu26ssYiNiDTtJz5bB5HxaTxTbUqrKmu4QOs6zTgIpWmu0NM1DfYFZ+UdaZZ87JlVX9DA9V0xj5Q0nWXKAGmQzLZtyJsxzaQEZ0LSvVsDAcpRwNSwdPnfWfk2DflZ/qHLmZ04W533dzzSprpuFJ68Pqnv0dEcW34SzMamOdF0rMH0PhL8+B8/of6vGZftBcSMKoLf/kXBr/9c0GSHM/PWcoPYmk5Mtm+p/VDsAEDLWVnjU0Li1OUPZBwi9ENzXQaTYhqs8LXtbdL3dcfKzvbaszIOWwFVKmpPjRv6ktT+aG2kmldbQGVyTpumuwXhOCpS8p8Dv27N7D7TCD3NcpNxEOLl5UPfeEUI1eRXrRW08Z1Ooow30mWr46x6iM1l0TrqOCrj0QAAIABJREFUsV0+uuN7IrcrNbXr2NPC/kLeJ4aRi3QM+Fn+NOUZMPMsz/Isz/Isz2JlKLWqaCRiiHrR9e+UkHLqKg2r9axO6bTp762i1h17eVOlEgmMjIqGnF6Q+EWvY0IjGEiy1mQ4EBya7EAhDZDSFTAJSl0/MutP8kd5VLvdQzSAdv3CW8/9pwaboCuZRzmGkwHmhO4gRbx30JlPoI6ItnfubTRpXakWiNFADoWQ1vZgBgfcoeL3oCuUA/T3pkobBonnoWdma6cZO/0kqjm+HegPc2PQS9opLGlK12hAVW0NiTVivbSKw4C/1FRJZ2ucB2Yl0pMy25ZAaPj5803rz2LXBjiFDPj1vpwcKUOBX6mjV+DPetFSA5EF67B3+niXGzz23iZkAGC2PgQ8RZmAumO+GzEWxOFOEq9LE+NaIrK1s7LSpIGG+Zw0AEdPoIcADsBoQ9HbuDrVogPH60DkzpKwPgT9FDiTOj6ksaUBGCeYFAgPJ9L7GAhAY04Nh6CNu73I89lK/1sst731g607EQ2gYtZ2u2FHpHMjMQFC6izzAAfxJW1BY1YfdMPSAg88QEO0/5LXu6jxF3E8X1MduPX7+tySIJ/cJF+Ko7923UALaLIhI9xwZvgRDdno73M5xZyn9UxkzjgdUJsbHggz3jUChgZQTIhOcGWDImZNFuKGv80vzf5lqKKo3CAwmrG3tNbASftYHcd6iq7303Sy0Ez5uZM6kKnyL8pwZ+siwPJGa33DyUgHUq1vcjLw2k/cJ8bL9QWQhmL7CUFlm4LDjMR6mpWJtY1NV33KGS859wA1l8/ECt47ENTzWYsHKA6gikAaBNLnku89w4GyguXwLscAUog0vQYA5KRBrgQx0KcCncpXUKSpLLdgGUIDUUFiP+2bwPmiFPtpZrv52mKzy/rB1w6F794vvaXkYJzOnXVVrJC73jK/50tvvYft13uBkT4x3qcN8/nmIzQxIL3z7C/X5MvFn7feKRh9Ht/54XeE7//FBbV9QGm6L+i80bkqlk+91AN7uaGUgmPXdAvdQYHaNw1RAbwEOHigs4CS6xImr7oe0xASbE3OjyDd5t6g0bIZYov9ENeIrSmMNfVtPXtWhl6h4tvfqGEMrNtg1z0BoFaltwbiaf/RFhDMUTqCXFfWl+jw9NOMoLH/x2Bd180grf899i5bR2KpVUXl8do3vk/4LQKy9KuMHgQB6vpy1yl9q4egtQIy8FdR5zTpk67LEJGlfFW57M8betPqBIqO3TkFaWyHO+FdPvr3zMamxWO+gngMh8naWqud2NS2JrpYYKU6CLsjMcyL1anZmjnpVBFX/XQgwr2v43wbuqfuDU00WLDrxDaY2scVVIHWGCBly5Cme3BiS1GSNDhAiEzXGYHy3V5gsfiZGDzlfW86QwOAuB/BAlyBQZFu807EHLEVrRZlljC69CqM737T8Nu/PPBX/0XD3/wN0Ak8v7rE/XD0H91JgfM7vZxJXE/D52mRVCcxRi8oJ+b7cvzxu9b3nki5/q3LFdVJVf8iaEpDf0Cb2krxrqlHvlTHJoRaCI0q2tGABiSbbP78s3RnvcZh7XUbRGbbxq8ZazHKOLNfRW2qakyCzMDtaKhl7qWxt33dfin6Imx0wX4caEXXSE4XAJ7aOAY8tC5X+zupwdkuo7w5O5Dg7W2ifRm/W/vJ/45pgAjo+tyX9i0JtkWTwKa5jFVkN+n1W4J14n1rsMjUJtZA2NoOJEpIvCnrRWuoUlFaRWsVW9qQ8gZUAldjhxRBQ1XmMbOBidTubN5XMjAo5gw90RXnGzCCZRSf8uAET49MrHuOvXLSpwfucR8c9KWgobk/bA+Jmoi4VjCCV9we64yohD6PHgXhrEEj+vsIwPQgov5ejP1O5bR+n/MFDUBiRqUMTTHK2NIFiZRFtYnjFQlCPGhQq7ZDcR5jmiUNsgQoHGwah9Bi6rJhv4w29ZQdoURWpzWYSH/4Z6OP0eVM7eOgHzNAY88nUrY11ZnGAS0BwgGJCrGUYiMAbYyp+KZrc1AhFEFtgpTN9pSi8tnws1J2tYHF9xDFdlLW9Eww+ZYSoVYNhNU0lhooAyY0NN1aff2GgBtigikhABi17qD09QHmf0z5u3/Ds/x9lEfj+CUd6by8H34Tn7e+Z7Clyt010cYTAK8/fMLbD5/69w2C7aXg+z8/0NqOLWckTqhGk3fJGZkZpTpeBgtoUyy8Fks77fILlsYephMAQ+nGsPvYAmw8MMTT5Q4lfeA2K9O8t4y6vZE0+KbyJPei3PQUu15Pl22tAZQYlFSmaBpAlU0Dlwb6AQGQHihrjl2S2V2Mjx8/IaWEzz9/tqBX2yPNHlEMRvdv/823noaqdh5Rt/NbsINXDGueAbGtAIRQm8vuhpGq2Fk3zYfA5kcA9UNuz/KnKc+AmWd5lmd5lmd5FitMqiCSCKSaY625A1qVDw/mSCkhcUZrhNIAET2VX8uO2/6KWm8gNCROYMpoaMh8RWILrGGAYGCqOUcivNkd2sb2EAE3QQAOuvJqOtyiodPqiFZPwQJM2+/ioAMPQzQ4JeLpK6/jxF5BlmYKCoiU0oyqNYOIcBwFTujtjlYHhAyO0bZ15dYZfmTChFdngCvB6m9x1hXvL+tVA85VsSQow/d80iyeRHO2DmZCFUHekp28EX1GSh0qNp95V/jdwOBEuO03O5GsAIMG2uQecOPMK36qKScNhnh7e8X1eoW4Q9eof7sDAkpR7laPOmwGABZP0sXP7oAvczz470JhPtjnEdNxpwEb24NPugiCTiBFt3RC+ITNSYH0QBr/1ynxoYajA90iI0e2zl9PEzbSd+WU+omm6Fzzk88rEOrjXFGHAx8ODFswSkrmVCqQKhBiJGgqteLMNTw/t1adN+40i+C4w9q6PsrcbyB9x+ToSuAE7PsO4YachtHH09wGkqLa+qkIGqvx2IOg3DkUjFV3oNXm8yyBBKhUwmlEaBtTRqaRZkHHabDjMKMHBA1jbZyU89U4PiC06iM8uwAmgPTO7lOZ4A5KOHhISr9MWA1xf7qmWzEhgx6QQgoauMxhJvWVtYLMCdWiHPppVQFYpC8RJpURrVV4AJzYmkycOutMYs2vzsxoUs3RKOCsrC2BJCG0X2WOiOaSL6X0UzjMpNS9fiKVlL1Jg8KsXxuhkaYQUye0grHMGdeX6yQXPEVJKXotAAsQZfS40UTYckYjVjC+2uAYC1IzDgDdMwrS5WrA6aD/9onQndR9joygmSq1r+MILpw5Vvo8gcqMZCekHFCRqieVai2wge2zTeurex4jgaQhc0XN2t9VLhBKEBKUtqPJBmBbJ+QXirIRsAcgARAawUxfU0Ywwpeu+xLwF///uHSXg6wO0d4CzDC6neq3ds31CWB7eNaQ7ufAooT73qvnGewUnykA+FqRr7p3q4skIb1kgHLQp8ROwOu7j7rjOHbs+4HjODRYxvagsT4HqxMalGWitvlzaIohZSY0t66n6CN3lro+BPOVDPkXnSzS1wGAheUJDi66fOytt09FZt0x9llwyjzqaV+HI6BnPL+/k2xPh55u37I5Dxd9TTBOruecpoCOnDbU+jbpL7VW7PveZZ+fZu79A+17d6KLM/JB+8mkhF4jY742gZ0cVHl3vWYLwnVGK4tvsU4nIiS2FEu+35jet+Xc9WUFkQk9iLEai0NTm6DVgmqseiknJAKc9YrteVXG/jfr9WMOEHmasMi8cC8zo+7T2nyd1jPdPR9w9VL3pmKnxImAnBKkUV9/tWoQvp9yHDp1DQHtyuBE4npLneoRtQDCsD/E9FKx4ObhBGTEGSu2B7dSUI+Cljaw6F6QEqMRodKBUhvKcaCUQ3UnEXDQq3ReDqe0Vm3owxTeFwsZ8wqTyhkN5miAVEASWim613ADibLP7FVA/AFvteF//z//A0r5GN4wv28enXt3zJnsP5Os7+0k6zcCnZcj0NOeSa6j+1qKdb2vybzrxP1gdgrNf8t0V7eArT7ZVjWD1IaktW3jrff9svxNQP50gJhw/bBh4w8oB4EqIYvatQJCgZ1UxtBLz2RnDMTQdF/3ATPx3mFbm31szLSwe4VUDt2OCtRh237dbt7fOu3XHy8f8Ycffo/jrQC4ICVCqzAnfpQB0tfGqO9JO1fwYepf1+3umXXiv3t84YFusFx79r20cXgosqS6jD5Lz+TPdNsspnaL9fLryPdyEoA00KLUBhbXS01e2t6gsgW4Xq+g1gALTpDW0Axj2Yw9Q6D2RGuWxoY1/Xdt5AvT9n1N+xT1hFIPxVvsOhbu7T1j14nz0FOt+iEmZ3aM/biOg+9Tejhm2C9+UMP1fIhBAuAeWDLm/zyP1rqtc23GgYadGVe9pzPv1yAhEfX1pTp/AkNMJTPWICGQMTrDfs/J+h1+IGwwMLlepPVqgXFl9GsyJ66zCY7UR6O+qje1biv5vhhlam9PT8/mNoWnIBlBRJwSlNF6BGtnzpAqluaI4OxqhAYm/QfyOKFhK3U5ymnsQURAc/ub9F2dIUsZhVqrKOXAfrsh14qcN9V1pCElYBxKUz3jsmVALjiq4WjsbNK1685NGjiEcVYh1b8tQCnnjJyMBfhZnuULJe6j9xqEl9WaPS8y/bbsX8NM0ytCqp6YltkPGK1PHH+NZ6/1rW8Nbz8UvL0VXC4bPlw+QEpDFSBxRTLsUjUnlXUxvWQrDbVoyvnWZS7M3mSTKQTAD3oAevhP8W1l67qglGKy3gPlh47t9mPHymjIb7ZDFlHfmO1HVkab8F3H0llxpeoYMBGEEkDu01A7u9seRFAMU/siEaGYzZNzhmxX/IxXDQbU050afM+Gd3gfqAGqI0AwPA5d79PDAUFjO9FbRjupy2+bDHd6cUdhzDZk0gMAmRmZGKXb/8/ypyjPgJlneZZneZZneRYr0Xh3h3YpGiCjIIamiYmGexWBQJ0upVWUY8dx3Mw55ydEuf9zv4w7Ef15EbRZgZyoML53AicGuERQ531HyNx2/QPdPnewKOZuXlk6evGURcBglAepYW/5SNVhg6AQEjg5AOCdo44M6ucXXemenS6ubA96R713OAHQ61xKQU5Zc7each7BIb8uOhcULGIFEliBq2oOfnX8OnA6ovVHx8CAgoJPn74DEeM4ioEszlRgCn0TlFJBJHijgtaOfm9KaXLg9BRICO0Xmay3SD+9zo91zOJ8eg/w7HP+C9+vpb9zfKB/m+HYOrC51GHcEJ/Wf8aTW+FmBZmAu3GMz1/XVSlFA7g6GJg6EEak4LA71HQt6Fp2h5eDo3GtRWB2BsxGnbdt639Hh5cHp7kR68AboMFASj2s/aDg3CwjvC4MnafSl5euLw+U4S6XnPmGbAnb6RiTT6PfZpnSRAFdZs/k/CW3xH05m38RJJw/A9yZENNK+ThHgDWOtRrOydaon7jsU7EHN5VSUFpFgjpjr9cLLvmC4zj6c0spOI6CWvRkoTpvLb0GoTvjmgCXi+0ZBjXqWGbkrDmaNUWTBlgBuhZIZtk9KK5rAJbHiZpB3x7GnakD9K01peStGoAiIhZotnVZJAEEfnt7Q63V0s60cKpYAwOV2lZPBaZE/d0+fy+XDSIJ+3FDbQVi7GFIs9O21mIsSTZHRcEHb3ey4LdH8+VLe+K4rvWTn/HEjU4xArUw/3pAiwbV9PRyKWG7XpDzYI34lhLO2Op/JwwtfxdFh3UOzOmg9xeK4j/aGzqDg5OkXzH+Erv+7Dnj3QPko+mKr2rJ3V80/aTpp0H2psoIvv+vf8Zv/rufkfiKlF6Q0q8ASrafM4Bqe5Jv5IJSdry9vWLfdwugdRnqJ4MxrZ3oqMGdPAx7joOMEDQ0C/Kc0xNM7f0K/e3vo0T9eCiJGrhqlBsGXupa8/W76iIrC4oI+glHCKFI7WCpFw989T0x7usug5VyW7q8jGksgXk/GA5cG4fm1/TW9uAothPafoGALKBwBDN5qoPV8eqB1WXfUfY3/TwxEhvrCzHYAnprGw4+IkCa68ty9y++I5bInBD1CteBL5fLnR7iY/KIJl11T2XU8X49SkFrI0go1iUGyHj6spSSsqu5blrj+vB2xfGJuqCiwgwGEoJuRn2sR+A5o5AGa9ajaqpcZlVjmkCqOqadfcGD4DW95hjjobV+o6wWlwBiDmTpznDncJ/kX8rgdIXQgZ/fPk8O0C+/amUauZeq65P86RL+Xn9brwU0iNV9Av4ZI0qBGMBD4f9nz7v/3H/6s1aJP7udpMtqdxkRCCxAo/dl5aOeTdeKv/gf/y+8fPcBhCtau8KdyIk0kLyRoLSmaXeEe3uUbdOcxjICIKf6hnW76i3x87EPGCuGQOcjBXaozq/zte2775MmDfvthrLvKvuSBm27nfMIO1jtjD9VmYJQgkwb+/HX3R/LI6eUt9Edbev3Pg7xu/Ww0JDtbHuCi4/ZlnN9O7IjpsQQO5CjEQ463opZ1G7zxTZIt4XIgiIEKemciPiF2xutNez7DUwJ1+sLti2jSp36JO4NM3uQB+IAEQNyG2S1s+a+O5+Zq+NzsusIegglSqPwntgXY+65Pe1SiOGpHLXaFkwhrncnTUEFt+F9fKxeDdgSAcwakGRPFSJjyeR+IMkl6BrAs/7+rYUMExEAfojM98R5GaieFCWq3mf6NSnbw3CCU8eQ2BhYNOA36vA+b93BC8R09KOYw9nmh1hqMA9JrrV1JrqOGYqg1YJSf8a2XXC9NrNPM1pjKPPcwF3HPNF/TGLpXoK9n5QBG6RBeN4bIoLbvuO7j1cwCVp7+0Vj8S3FR2G2iJ7lH6pE/eZrPh/fzmN4pr+sT7iXdfdvuXunr6vFXh7Wseta+r1DFI8Cnf2NfsDwb/83wv/z767Ilwv+/F//1NeJYj1q5yZmZM4oBWjtNu1Rx6Fpqp0x0pnLRADO1P0gzYSVY5COEYKuHauu9UGd73C95XdEWwxmD7gMHCnBNXh77CNoak+TKCZJpPiNp1cW03FqMwYs1sD4wUY/3ttsP3OW8X5IVETH0HQ9P9ilwbHR/sfys/WUVu/1yfq7Xu9BmeNDZzOL9wzb9pstl2d5pzwDZp7lWZ7lWZ7lWUJZDfoROHPoSdA0Tr3qqX3B9fqC63aByA170/y7BGUlSVsGHwWJoMfx2NJFWL7PCFLPDgktHqyyng5aT9avv8fPvhQIsRr8+hOdWScC7w4Ued+s79AAkuEcTUab6nU/q6OD8F78RFM8FTYVom6oTO+dnofppCsRaUqOesCDl1bHwSOAbQU8HbxUcIIgrMrw5MwFQJRxuSQDuKpREBNK2c2JkDsIShYx7/388vKhB2yllEOQ0gBR/W+1EwRA7f3lAQDuvIgg3JnjxT9fT+LFdeDBOlHhfwRSrvPJ6zncmuMx1OvkwKB++iWc9G69GKI/wJZRpzNKbQfgrperGT+jPzxQzovPweGAM4rl8F3s11rrdE8Hr7qzaO4rH3tgnEb0Zx7H0U/guzyKYxmdrROrEAGwFBMdcCMDDw10E+PDTuTpeXw9e1t7bw+AmaAMKdWBVmdxYXOjRGNNrdxpFlCYBzzPH39XHL+xjqW3IXO+m7dev9VxGYHNyJS1Ol3jOB7HgbfXN7xcXibZ685iPy3oqZb8HWzBKH46/Xa79bmQc0bOCTlrMIgUrY/nWyaygC9nn9IWW3qwCk6EDDaWGsJxDIYWrTew7wX7foQ5R338t+2CnDNSyiilKWuRzMxLx3Fojnhz4jqYfrkIalGg4jj2Ph88sAREKHXHp08fwYmQGiFnBrMMbNfvIUHKAOoAaZ2qXU8tjb7w8fDie8Mqv0R03WzbJczbhuOIzvfhjNUTu3rStwkBBSAWkDBu+4HX2xtKachbRuYMtIbMGnD5rcV6yVJGPHIbvl/I5K58wSHo70N4i9w5HN97jzkYerDM+DmeL/BkYP6+s99d0g9SYtjv+g3jyz3xXmvju7g/U3UDr7ft3rhePuLDx2zOxg2EbKkF9SGZU2dHAukJtNfXz339ArDAiQHa+XzqP22fH3uJy12fp6HuDxyP6+fvOSh/KSD2SB989J7Z2es6nz/LP5P5WhnMa1E/9LVJTP17DUZ2mawBJpfLtT/Pv3t5eblrhz97pGe4d+idOUUBaDrCpSs8LZL+Y3i+COpjrfeUWrsT099fywiEIgKE7Ay0ACkx8oer9VXDvh+ozWgJDw1UFYHKQaM3d9a7e91zTqUxnQ5tbWJHyDnfjeHKEnCqY5+M/xx87HpO6QHPPdBHpO9zWnQ/a9J68GlOW7cL1jay9X0PrlwCqkcQqgYVKBuNBvToSG0gXCHCGiSadI4pS1ozllBjEKsZgFjKEluvdQDTQxf9OjeYBvP6/BFlsixq6+UtYQNrmgnOaDLSHEIYx61+Uee9e5/3C+apHHVtvU765+sr7vek2TXjz7aDv2BxuUrGkIUgbQNYL8uu8yCNYPz5SOL3fcl/CmN5ul3nWpM/6/6qdX8kAEQJLx9+B2LGsQtut4ZjrwBdASRlEJSCntoUYs4ZkzUS1qQsPdjcubI40sLfp3aToDuiAWVRUMdQCuNNU9/ct/K8iAj+8IdXHIfO2ZiOJ8rONdBhfv5X6CLhmQIANO8H69o/K+/AF1N9p59AkM333wNzmqVVnsZDQdEGjtdoL3gyRahdQ4xpZhJDarMDMRp8oZl4xXQWTyM45JrbH8pS4mw41V+A1rIF+ymOocyT+vzB2pbx6dMnEPR7YmUv9bbGYJm4X3q79He11WIgQ+zviFcM2T36dLW33xlAmx/3rEGPnqH7dJyDtgeNO7vuRYmQswYWiY1YawWghpwJxBrQIWK2LJSprNZqqT0s3fRiY3qQ7Fk9fS/8muLXkukZKmB9bljaDfH5N2SD32udOGERXp84jy+XizG+NFwuF90bjWnB7TBt37qbxLWkQTHi7HlMytDDalfvx6HBYDVgFM0Zb9Qevt1uyDnjer3ier3eMQD7gQ2wpiuutVp6T2VmrbUq25IxTcRUK8paI6hScDve8Lp//rpB+BOUe7vrWf6hyrme8+V74s85HPnEVnv4nAn9CteKWcNWv55i2S+OARHjfhayQOBxAGStL0tgsa1ah5QFnz5ewFvGJTP+8IeC1883VAHyloAmKK0aJpRsbSvzsTMZAx6UqXhbgmF2DGMT0zRuKeueueUNW84aZNIEtRRACOwBesve8ChIhMTYRnO2PW22MYkstVwbqXtB8x7qNluUkMNGRMfc2dhiimHlmpKvoVla+uvLC263N9RSwIlHekgMmRX1i7UtQ8fRJjzCYuK+OuPnY68Zn+s9rUm3s2qtOI7SA59be0qgP1V5Bsw8y7M8y7M8y7NYWQ1zB5/dYbJeJwaEqZOTgKLOzVaVLURBEBoGKJE5ClhPTPgJsvDcFez3EsGKM0rd9f742Vnbvth+Gs8+y+0d3ze9I+TWfsTucRckhFHn94D70BuTYdGBBqgzVp8bKeq11FYth7ozPczOhBW4mwA3DICALdp8OKoFkSLSnfuAtscd00x6smcNdhqOhhGUsm2bUVrOY9uRuamcse/cz5+zeRXr8VVOPFPgz647AyV7/XtN7TE4mZMGqoooROUG4tl7zhhF3FE33LP3960AXwSkooMtOvr8vrVfO9gf2urgol+3Brb4qYb4bC/rKb743dmp8Njfca42d8R5JU3OjDEgQJZ2kMHu5O71AELZmMzz1b8bniXjtAGg1K16uQaJdac9kQ/+NE96XRZHFfkt4g4tAeB0p/dj7AEed0449qCYIX8iU4GI9CApl/uCeTw1H7KfAI3A8vhd5ywbsN2mcezBNcihLXM99PdhAA+2l2LvFAtWqtiPGzbeuuNZ69j6fUTjJG2tBdfrB7y8fAQRY99/OpXN1+vV2GdkYtYBgJQJVAXF2dPYZbw7MBtEKmpVBhnNXd8meafrzKh9WQ3+Jg2JgzyQBpAGX637S1yjY86Y+44cPI2nZwerzgBTDHAX9PQt0qAkGWQneJvPRXunNDAN99W3FoGefm8id2mLvqb0tSvqUG7WjytIe/bevh3BwbYZsonwHgG9bjG48aw+p7L5tD4OE57U7cHvj4rcXUHhndQDZggAbw0v/83f4vLhEz79JxuIXmxcE8RPDfs61BhmDZkRdarfbrdw2m7Q7vc5sfSiirvoeIx1HcEzZ/vsumfG70/32vD/by3v6QBnZdW1HLD0v5WJLLKTWIjUCv56n9m+MeTdOXsgcM/6F+u63tN7ZenLlTUhtt8ZRnSfGbK3P1/Qmak8qI8S9/ncJV+tmtKVR0qiRKzAMUkPDlS5KNj3XQFN1rPw2qcMThmMZnspnfZhZHyM7fJyD67ez7X1vvfGP/bH0DeUVY3cYRzm/LAb4hizpe8bkkP3dYRxszGxE6KTXt7ETrX73HB9RXUOZg2YgWjwDPOmn/dATLG9SQ8/1HZAxFnXPD3jrBNRaNdq65z2D9zJouPWhPqJUmX58vmvdVa5XLuOJu18d4my0csj0D305vJ3nErkKzS8Y9HDTmrgCTCcHdLb60Ezskj5WMNHgZ6qNayfnDPnEBBSG87voPBPwlN4K/izv/o/QBlouAJ4AacLmC/QQK4MJk17ypePOErFXipKVUaDlC4QIT3cArPdVfkc81wEFFhLfB9QUTdCRFe5tM6l6AzRYABW+WP6emtABQHf/wT6Fzu2BPzz3/wKl8wgaQCpXvbv/+ffouyMX/3FT/j0Fz+jNmU0JE4oR8N+VFQ58Lq/ohjDoKdecNlyL1tXeXs6nFO5kykyWMfOHEoP7/uKEu3OLmHI5HeUI4u99CUZGXGJszo316iYkUMARX8PszJOmt3AVke19ZqmuRCgsTJpCJQ5Rp9TlZ3DD6sQwHD7Ruvh+1fEabT+vlcYAw0RyHTh2MZH+FC3J4OT0suqez/q17V/z/p7+hmqcIZhzOPtKT7iZyHQESElIis7jONZIs5tAAAgAElEQVQyrekBBKCBWfsbVYNeW2+POk1ZNFhGyeDGvnu2PlZ76qFGezq/PRjO9gqJNrjbNDaz5X5HUAxs7jtnEnV94HK5gIjw+voa6vo4WO3xmCEYFgSQgFhTEI75MBh2qwXM5ET9fbVW3G43OPMuEfW69qAvHuxNgNo9cJuuVYgk2xNszlvbOQGlHRBq4PxLLbZvK98usZ7lH0M5kzDfMpYd1/rG66MmHG349d2P7Hu9f8gBmv6ZHU/AyyUjvxDKseOnnxJKtRMipdmBXcEIXNd03Y63uRwcmByDuKJWNoIVC5iBIBP3dOMQdNxKg/cTUp610i/JdwDdnnK5HlPY9WDXEmxHQWfTUVlq/hbbc1uVkb62NYDmoNiVvdnbfLlsOI4dhxxgOF44H2o+wzK1T4O+pw/86vkSn9l9TMv3eo3aqM1SobMfUv5l8MCznJRnwMyzPMuzPMuzPIuVCI5GivWokPkpj5wTcnfCCfa3N5T9Z7y9fsa+34z2z8BYJuSUwX7iksQRjUlR87IC2l9SLGM5A3Yf3f8IsBvv1L8jM8yqGK4BNACMUcCVzhHV3USUHp2hjqtmKW14nIRZHaJnQNoARc7bNhTJBcgBKcDVGgDL29wBda2rfxZB/XOs10yWAGi5U1brFCgUHePgeTyJ9OTTtm2oteE4dnXO0Mw0wmTBOaQpBEa7Xasf4P7KNhLHzfswvn8FrlagMM5/MvBCHkSur/M4PoeSO9ZPevL0BCZ9UeGP62PU04DqE2DunvLXrhPY++N8nqH4mAIAMIBZ5IvIcezD1hqYBmga27GCxh3oI+qG4jjdP07dr/OpBwqIpTUjAD2lRDel+3pAd0y609CZPSQ0bZj1DmxGIK8/K46d3debdOL1sVC5eHUYsyGD5rloRnMwHtfx9Hk/B7hoKiQy5+ztdpv6GtB0RFFmKFtJ0gPC3gDi7hhSBi1LWMNk4wo4a4+DBiK6D5RyaABmK4jsV8fhjADuXKy9/p4aaQJ7ZaTYSNumAtfJn8wxZ1PajHQGJ53D1ZioQITtchn9Zn3h+ambyeZsbDOakkYAND3NRMqU5pSwmkKuYt/fet2JCKUcJscY43SPgpra99q32ie6NhzcjmJmdVhERoXhLHH2gMFaFmUirE/6P0g/jSMVIGEk9v4jtCqQoo7w62XTYJmTNFFfWwQjaGZNc/ReiZIohbt0mayuzvP3KsLVQzzvYL4uGcQlxPi3Piv+e++dsd4D+KPpubL8Dty/c2rHnSt3tCS+DwCQBZ/++g0ff/VBGbQae2cAYiNg80bnSEMTZQi87W89WKbL/DbYzzpQtegn8x4Wv9M1UvtpcdgzB3vguhe/V1Zx+rVOxvd0wag7rs7R+PhVtyRHZ8en+s/umU/yN3igV98TjS2sO/0AOL117NNHKYN833/Pqec/3SFMRCBRh6e2I00sY622ZamH9rkO1XVLjKEWu4+AKg21GhDdDjRjDXBZTjz2PN9vldJc5SyEJ4A1jlFs16rbnbHKrP216kfvldUG8T0WELAwKMV3jRSWOrYjlYL2v0oxPZk6dDynd3enYYOgdyTF/UygoL7+Y8pIvCHnDcQZBMaWL7hsVzADedOUqkc5sO837PsbjrKjWbpABdBlBEL0sX4cYP5OT8FTz/rvnrpNWYMSPFjG14hZHABYA2YeDMeJ+tRr+t7f63dhVWMNmnlUhtyl/luzYITxrLAEvqIuXyetJo1VgyHdkTyN1thTfNX7uubU8P2//L/BLwyh3wCULWBGr1adQ1O0HDtwVELzdZcFDYQmgip62jixpdQRZYFS3aGF9sjoKv9V5rV4tuZmmet2o80L2FJo2kr+1Y706x0pE17+jPHxZcOWCJw07dt/+Le/BnbGy58V/OqvXvH2CpQClbNHA3ad+7cfE7htWtXWlHEr1MXlpdf5a/eY2Mb4U8IkXp/33rMfLcF1ffa9y/uwtW4Xn+MIj+SoM2KMgAzVu+254nui6bO+irPOiWFjQhEHYz8Lpj08TSjJkI0NQMqauk48JY+f4ic9UX/ZNhBfUUrtMraUAylt/bAAke5xOWdLQ3R/UMTbG4P954AbsiCquW/W/p/srnfYZVZb/X6MabLbz8o61uOzMbHcZmTydLm5M1X6HltFg2WaqC2WEyNdNtRyQOl/dICJ3OFq+80SqDphSzQOYkQ9ipwZYlaggkK16k0+uTDLFJe9EjTevn2qJPd56QxJ1+sVHz58QK0Vl8ulH8J6fX21wyGPA+MeyqplDHwHYQtuISIgJUjlbjcWS78rGBiDQOzzqizUrMwOl02Z5zg5Bqcd0XWLWlGpKI6SEoaT38NRxWyiitIO1DYzBT/LP+3yLdrae/ed2ZqPyyPt7N7OPteN/G3zp1/S90yyDLwH6Gy+/ntO9i+zBWmq76JWCQwkA69Z/409z9ei/e5r0poeMSnIDYAGpkMiA9TjANU7OxoAOpbXzIZA35c7c9Yt2Ig0MGgxPC3x8ON48Kk+etSjNYFA91HXeTwo1eWpsrgVu+d8L417QHxHbBfh8T53JosnG1gofA50/l/xvkpLauBfuhqeZS3PgJlneZZneZZneRYr7rxwulCREQThJxFbFYgUMF9xvVzBnHFUwc8//YTXz7/H6+cfcOw/o9Ud+37TCGtW5yRnRqtB0cT9yScvq0IVFaezfNr+MzqMHz17fa4Xv48dPA6AykrJG983FDRVPKPiV4MzSJ+9Wbs1oAgAtu06AXNReV/b0YE3nKXsUGO5BwfQ+I6ZQElPxWpbKvb96OPrJ4P1n6UW76DXolybMuqn0zvobs4KT9cCKGvFtl2neo70A4Tr9YKPHz/aaZsCNYH0ROO2KdtDM0pnptwRtzFuTkc5nBQx5czK2OP3nTmc4zyL9b0DFE8MyXWureDLDAsZ0uP96ScHAMBANz29fA6uxRKDglqtZoyMNEHrmlnnro+pN0kEkzE55tIJ4EfzGojrz42nyBjjaQla6KcVkBaR6WSY1/049mkNjjk72EkmI9DSksFOWTEFJhDR/MTDmERgUnAH4FjTfV3bT4IbksNN4rjlGdAW+39ix2oKbA0QTmdWk2Zr2w328Qx3pG689f6IaZZeXl6MbnoOlmBOyFvuzDCfP3/uckZT+WyDChrAtm3YtgsIrOwANn4pZUhrqM3tVAUrEhhC3FP2MSdjJyt9TXpdmlQDc7Uvbre33vexfyLwGueCM08xa/BOaWrE+56iwKUG86ScDTgn7PuOn35+A0hwuWzIFjDjoHyzoD06FLxkTvj08SPYTske+w60hpQiC5MGqez7jlIO7AdZnyZctg23vaCJrmfBOGEMl6MGdGpfAVvekDd1LsbUZd4Hse0ryO8BUnGN+5rycSVy15vPKwM/nFGGTP4KUEtBhQY3/erTd0j4eQp2+NaiqweoNkYsX3Zwnv3O5mjWtQJ8TdDMWW3GU6l/5I7Hs3NQwzU0pMJ7T42AHsIz/a94j340eQlsh52uOPnrviV8reCXivSR8PLhn4HwEdKu8NNzBEITDxjUuzS1TMVRbnh7+6zBc00sKIwn2aypYMbc6cCjg3EYukOsZa0NtZVpzp4FgZw5hh6VM93ukbNjdWKt138N6BeeBndAOahqT7NvKaRcmlP5AK1Tafsew0y276oc0nffp4X0Oq16ja790oOM1/3aZecdM0vy+rme733n96fpWfD9v8sK6SmXxIIGmzlIu37fGpiaOk+rYNs2XK4bRDRQZDDMkAVVWz8ZGyLhXBf2sYsBV76feX+t+pjLxzOH5nvsjlHP8uInTOMe5Xv02JO1La01pJywbRnMjL1WoO9ZJs/E2XH8ZLkGT+rJcqAhzgtG4oycL7hsL2BOFniVcLlccb2+gAlIqaCUG/b9M277DfvxhloPxBOisHAMcW+D6aZ9rEMfnRVvf7/W2iTiuiOP9KtI/XNl/dDvRTJK4zunyfQeIMjP+5/r1YFrYypBa8MvCZpRFyU6s4yn5yOM38112d81pINMkmJ997o3eBkhRuep/PqOHjaDZj3QKKPRBZx+DU6/Q5OL9j1E7fEmOErVFEwgICVl+zB9qLaKhgomwcbAZctgAmol1Z1q6cEmscPcWmq2UT9yEj1yJnmwlW5ayp4E6LxPlwxKhP/3s+BAwsePH5Dlgtd9R/5egEsDXi54rd/h9z/dcHsrnQHCT01fXr5Hw2eU2642WJApayDAmYPovbJe7/uh68xrubOtMPaQPvtO3n/Wp/05PfhyxkDOGHOHbaLsiLqXJCRLYXPcDp25ttepPFQ7s7bmsU0630J/CWBB9aZnQ1OwleMAc0bKWVOy2Wq4XLKlVjhQbc4Qq0y/bFdcrx8AuiAlTam67zuOo+ByuXYGEbVhNUhChHDsB8pxKGHRYqM/cmKKuK4++mnYYOd6hQeV+H51Ns6nwcH9ftx/F54/xnd+nm3LppulruP7Qaxxr82bpouzFLVbcmZsKWEXDZju9hYxYAxU62GfaMuumEqch/bXfK8+4K5v+vyUWSaT7ScaM6d7oZAf7Bptc7uImbFtGz58+IDvvvsOP/74Iy6XC1JKneX0OA7knLqu6u9f9YvTEthjdUYTstmyBACsB7u871urgKVBlMAnpvNJ17dUMcaLipeX68x0RaTBzRZ85POLTeeCaOomZwCVVkCpYT/e8PPnzwBe7tvwLP/kyrqizrWfs/t8p/byy+3p+M6oM51dG3e6rhm9s60OfY+CLW4yw1hrVVSYbYmGxIqvMTt7HJDSBbUWMOt1nsJ127YuA5yNd2iKGOuOqH+lYkDxxiKKU+84kHgDQEgpLzL4PFg/7ktuE7qM1dSD896/2shuk9WmGHDCOKgRmd0Ut+RILqOsk/XA7XbrNv6aJm7bEoCLpUosXVdo7d4Wi/bQhMmKIBkO9miCnetVNt7NU5f7aGBgfUnTkfvhW8XVv30WP8t5eQbMPMuzPMuzPMuzWHGw2Y3LUu7TsMRAg7e3N1MIr6jlsHydmpu6QXDsB/bjBkoZ16QGYBVCciUO9wwgzojgSmBMBxVBfzeMh1E6Bz5EZ/22badO9VhWRdadmWefx/Qw0VmJkPt4BTuiUhmZEzwNTazHCuifOwqMun1xZqgDJ7Bl9ICE1h04SdIUXBL72aPJIwhyCiAIplQox6H3l1KhNL/Jgg9mECWy0Tio8fLyYgDAoLL0U0DbtoFTQhI2YH0YFf2UGs+5quNJ6Vj3dRzemweToj8Fm7zvWIklOv5JAAonGnxFJUW67kBNwn3g1wrwxXcA0Pzw7sq1dq11PQsmUztV2zcc64M943RtQMxwvF9Pa4BDdNQpZam+J4V2x/pGJ5j3vabJSVNQQAwKcVkwM+TYvG56mp3dwQmApJlBpY4dhgK77uAyN97oN1LnolZLU5ABPg8LiDOUNt4CtoKTb8iskZ6uO+649b4mO+mrWLfLhLHefT17O2Mf+BhpoOMIovH1xEwodQcb+DyYZ3Td7Pvec7wrYKCfNwCckzppXLaajBEzfmspXRYBsNzNsf5av5zVWagn3GsPkHGAMMruSFXtbXt9fe3zxFPKteYA9egfTTsVgW7gsLzv15cMkI7ZH374g7Y10L2mlFBqsWAizdlcSkHmhFoKjv2GyHQk3TmsQUnu4BjzGuaEnueq120Ncmmixn5KrU+/1ZnrMiCCquqcsLQnRZ0FPgfimozP0L42utvEYNHUMlu+4pY2gDMoqUODABz7jnr8cRTfCnoLyPeokF5iLfcA4ADgWQjJHYO6oO/uXz8RY5nxZ6tL1UGxFTREuG44Oh1KlOmu+X3r50OiD+Btvmtu6XC0PgYuPcUHCYXrFDD8+Ne/x2/++x9xuf4WSB9R9w3upPZ/Yv+RCEgaMhFutWB/e8Pt7Q21HKA7PWecuLurs3osupMOgOkia8XHnuplCiKU2SkVnVWTTgVlQVmdjLG+6z3xefFaf18252C813Pbx5mhz1oadrcnK/vIXR9574X1qLLdAgaJwVuGyH27YmqlswDMlFJ3Gj5y8q4grWkaQx5Y2iB3APp+0HUfUobECmOwatLZUFqraGJ19C4hAjghszrhW9U+rc3YTaB6iwPUEvrJ920Qwh46bIZ1D4w2RGxz1JnifhL35+gcj/et+pf3m4gHOscx93HN3VHWWkWtra8Pr+vLywcNLgqByZ7GUSTYGkTdcZ4oQ8gCVzmDWQNdry8vuL1pwPnLy4bLtqG1As4Je9kh9bATti84jgOvr59NJ+Cp7n1edGq+udzZAMt3QgBxQ3LPuSoNGkzhuqLpX9WCxC85AaxBNMTbe/4SfY/39903Z+4hCf9/dPUvCZpRDV53ddUrm+1l/n2C6km03Ov7RtxLvr2Qr9rJedSljYx9hkEoFShvB/IFuHBGrWzzarFHJaSPpAYN5lbnK4vrvPaK1jSg1v65bgfMjmevzyqH43V3rfN1BtevtCMT5R5IXkWDtIkzbhVorwcuF8H28QV/+T+9QlrC29uBn38S1LaB0wVSNQ0BpYYqDQLGUTX429d+1JF6W0/sX2e9fHTtKRvYyd7j5ezggLP/4NHz7PpY58mmM1bDs+CNKNMiRuBt40Qmd40lMuivIrq3xX2Zgl3n8re3JSVsl4vZV1oPPRCxgRDSK0nDH3780ey9jJwuVkdR5pm8oYHw9vranWFe95eXFwCE4zhQigbkaypoXSPbtuGogzHP571jXtHO9D44c0qu+4Lv49HudNsvvmvddydMwqTBfEjlPb3ofk8b1zVrs5jOV3qwIjN1FVAZ5FRXa00ZpPT5Om/0mSMUUGTIsoi/rbqI13Xss7MOB4IFFQ0cYcbkxA7+zGkVW2sjrR2ZdHO8TYYcy3msBQ+8ihhbrRX7vncdbbWh1/V3V8Q1Z0G0ydWGZ2WAKRVkQbM5Z9Vv2kiLtc6HiHWUcuDtbQSmEycLNCWU/cDLxw05m/3fXKfw9QYgMcrthk/ff8BluyLxft+GZ/knX75Gsxho9fm9slz73rvGju2Wa/x+aG2rXSzLX8MmD9eF9M2qVhIqRAOWvR0Sn+a2NgFQfC0lxXiOcuBqh6Hi2uG+NmNA6RoAaDUQgCwgg0SxQk6sNg5bilRi3d+ITcbOdoXvG6uN4dcwJWOEIcOzRh9oQMjAdnzPUkwvKyNgrSAAyXAt6gEu2iZOCa0HptaOn8T9zX0U7g+I9fPPSik4jqOnL19l23ww9f6w1Yr9ntr6hmtHfdIng8rv8V71CYjteX8/6ej+/1CeATPP8izP8izP8ixWWh0O1tvtprnuDVTwiGJlRXBlhjUIQAqkVqA1kBnAJIJW9WQPN005cd0SEmWUo+K233rOz0cgkr6DJoUqKpyrcwWYTzetDtgVOOLFgJ1ADVP9V2aOs3p25U5Rqg7yuKNFRCPcRaSn7FClM5kyrIpvBF4Gdf3oh9Ef7jSiuzpEZ240R5gtHYAMdhc97XqfWqHWo4+5OjXEAG6LmHdneu8bhPcMIEUdBWriaP8OsGXbMoiA17fPuO1vIAJut1fNaw5CThsSb2DOULR0BTEIzINdhpiQKRtzxXD0xbKyBJ0FoPh38br4O2SYh+v9cZ6u47b28fr9XQkgaXzPWX07wEaMkVX+7JHzMyO4CvLgptlw8roD0se5t4NP/SoAZqeVn1gYFQYuC0NGlAMeCDCCPRh+Yj0WB7h9vOfgANY1Rw3EouCfOW0UKxMMDJqwXbb+fGdOsFaH96rTwAO1IttGZ54B+skVaVVpvQngpPKkthJARNKUCcQdLmBSY1bBTB0bBzU9R0Ztc7CQ9xmRsqh4uiXvGzV8K5g1QOk4DlyvyvqkzChlCpaptaLVhtttR8qX7hhUcNccaibrmBnCJrv6nCFgEyQLNvGTK97uTx8/dmNXP/MTjGTGb+1U6rU2EFhTIyX0Z5AF+9Q6UsvEdeE+hD5V2eefARyslN2HpQlBHfLXmQI8z/y+73r6SAiAMxMxQDof/N2eDslBYAJDmp42rM3ZCLRS1+uGnLKtkx0pDQdsq3rdfrQJWJmZKoYsHWOm42wIkjLVYIApus6SpVTwfnEQmkGNgGasDw2gtCFfrrjkjEtO2NIV18uGX1p8RRUAoAYS7sDWmQP0TLT49Q3KbKHMPXSHEAo95iqITtcBubksc0fDubNVls8eAZOLttCdmxGklOlqGvX2k3L296MigAFd1OWEACBOAF9x1A3UroAo+G4eUpV90lQ+tWrOzx2vrz/j7U0ZKJwiXno6Gb9d7BGR1cPn5eS27e0ajiWGx9E52FZr7fP7bC9cHVf+Tgi6ky7Kff8Z93cv6z69OkhiALF/r2sspCpqnurMg0BNJ/FcE2Gv6GxSYQhFBJykt22cEB+yU0SBT98HY/A3MAOLYx+oILp3ssV2xwBJ+wKcN5AdN3S5roGMHogewUvToYw1kjxY0HQi9cepM4wiDTlsT23Vxkb/pZSRmcOaovHTpnXsG5eB3i9fW6IOd8YwEx18q2M02hprIWZkinrDYHfcttzH5Th2k/MWwEsE2W8gSmF+Dr0eFE6RO9uMfc6UVDdOqY9RrQdePlx70EJpbziKgPeGVl8BFKBV7HvBjz/9iNe3n8GUwXzp7/b0V9r+hjUAMbZ/nV8AtH4A9CSspfXQsBE0qWitoDVCbQeaJDCp/l/R0GrFJgnbh18BdAAPpaq9q/8/hjuey+uvKwQ6kcZnz/K3OJcWk6BZ0KLKAO5KR2SCWfeMR8GQsRWTfbc8g8IVfl3r341EBQkJnz78Gn/74x9QW8G2kc07AFJQqx50IQiypQHRsVJG2ZQFLKqTQBpqEdRy4PPnn/D6+tblt6bcLH0O5zwC5pVKf3am++9x7a1jAgDC0vsT5sCXRqgFuDXt+1yAnAmXoqkXpN1wlIr9VlF2AWTTuZ2MTbJWSNF0KMIbUiaQyVi3SR7tKX08+u/3oxjbeNamR+Vsz9L+e6zLrH3Z+xSzbRaxjrh/eHtHW0T7pdK05/jhhoi7xOBvAGiloBqDB9nBm5yz4jwp9TYQM7acUZtgP/Z+SIOZcb1ee7C+25x6uIpQq9oDrc4HJEQEnz+/hkCONOwiGviG20MeSD6nb5j7tONduA+Y9P5ureFyucxOPplH6gxLWOdR3CvP7jkbX+0X+v/Ye7ceWZbsPOxbEZlVvfeZi4ZD0iBh0ZAFyrAtwA9+0KMf/aDfbcDWgwHZEAxYMglZIEiZHA5neM7eXZUZsfywrhGZ1bvPZcghUXFO7+7KyoyM64q1vnVDpNSOyG/MDEYRmcJ4ryLy1LZt6GhqzLGiFsL9/or7bVOMx5KldlSq6KgA2zn1dnTJPEZkcnbmbTkM1GMsNZ0QwftRlkXakaZFcKqMNaVIAzp2tZBHpiUi3G43jVwchoCGS8wY0Sg7Ho3mopDwLEnkIBblMqV+tz0U2ibLk1No4x/zmSrOZvt+x/0uvNHL9QMWqkrjlUfdd+y4o9QOXkSmpC7OFYUZjIrLesX98x2XuuKf/OSn+H/xzZvz9iw/THnEM/xdvfuHuvesH7GLcx0hQY/c06NxCJ4NgOAplJ88vjk71BDEWKZyQQVDzTinVpEb0BQAKAxGw7ZLBOBCRQM7qqyXzrCuGPdBfgJp5Eu5vu+bG8MzM+oi7RbjkhXrKsYu1DuoKD92csacyRT2HVSWQykSyY/D8VDo/640T+R6Sf3WUPRMJHUCM9mx1uqSeVOjvpJ4nVKB6zWieovh6V2f3/28ExlT+D07V43+Zh3L7PgIKF1lwyqC7j7isfw7MmJL03fB0+x7A7ALdsOKgXyrXfEsb5WnwcyzPMuzPMuzPIsWY2JMAWcWxoPQnhidRUFbdGVmFeCVKKP2HCvwXbBeVizLFZ/5VVJfIITTWckxAxQZ9M8M7gyAnz3r/Tthxs6YtBmsyOWsfr9PAQIiw/jMCyUwv8OIJ0Zwft8MoMW74Yzh9MDAI46AJNwjpRCpEUMA9i7cM4dHrJWiHbCxIUBS1gREG2Ma7cyg2jxWzJLDme8CUn748AEWDUJ+BHQ1oMcMsayb8oe0gRH9zsx79niax/VRyYqTvEbiORmLR+vg/HoA+odiCwRH9n4GoM4s5vN4Pl5nxzoHYdCUUhjXWvThCCqZl9XjbsUzGdg0yZundWElj3WmPSacWn1HAPHYRukfA9xk7YsFjSqeEoAPAiCgk6WTcIVwookWJSS+j3e6osnoHQq4aAQHb1eEW9VBj+kXraK/d3cDB9ufDaYkJpaoGl9ax3kOexdP2oJxvT4E90k9mAlgox8QGtK7EHyLulMgEV+oSLhaMwwwcN4UKhlMkRRZYTgIFLTG4L6jN2jqqKQ4LAtqHSNqidFKNqI02jGGA2fY3hEjALAYjmxNPI0bs4P6IPI0EQRG35tHsCo6p8XfCQd7jW6Z0gGw0PBdld8k4I/uNYlGZCnZ1KCn6vqCgMOx7sZ5zXMHmIGZRl3ySD/6Xo9akPeI7Tv2fsBTckjKNMnSZqBEQS0Eakl59R2LrYAGgEiMocyDzKCxt2AO40BmmOygbrPxe2Bw4mA3fLbgail7hs9b8ggYPX2XteNECXrWJprq+dJo23j23CqqILqCu0TlghrkIa1P5qZPdXTe8fr6SSPL7LI/E33x35A1PCouoji4NV51/iOfreJNuw8Gfzny0kGpNJ2zuY0z//ZwrCZ+6hHfN9eVQb/I3x4KHqHf+b0MS+nHHPTCvqulOiAakf0iGhb3qO7M+DZfy5EBay2niqBZCTv03Rdd/g7eRxkzbT9b/7umaSCg684xvs8qCiZNMFIWQzSyvzsEhFaQO1gJgvuYUnhv2zyYsUzmU+b+znzfI77fPs9r7a1zNd4pA1d0DeRnvY/OS3B8NvpVihvMG9Af/MEEFiuDIBF/LrhcVt9PRMLWrJeCWiWqjaRX67jvG26vvwZrCqb7/Y7Pn18lhckaHrWxNAOYtn7MY2ufD38zQ8MoKh1VQ7mKc6wAACAASURBVBk0EBd0bmhdo+5wg6ozsPeGAomksyyE/+Zf7vjjP/wZ/uRPG/73/+NLir7wR37vqXS873By4D0RZ8TsVp8gF/3A6KiJX3pEjZQKf/Ed1qbx3MubNk5NW0V2lxtp0gruBX0X46RSxdiUuzGSwhO4zMZdjVELzCvYIkNy77jfb7i9hgxPtQLcwa1HlBpWY8bWACqoB2/tt+UmphTjURoLZqGPvatRKZUYYDZDGoluuO9N+UlCLVC+D7AFz50ALigaXQRJ/h3m4OSMiGvfkhd6i7HJt1HgEl2dkN4qj2ShUx4l8YzA7GAEACmVXjrnWsvRaOwcmqK/cUoZSPAfMtlG60VvKCQyjhjNSrq6uhRP7SWsiq3oIkZpXWhoNpYxuUoiNXania11b6s7QExnqvHrD3EeRH/OxhnAmP6vpygEwHFNT+eM180QuYPO78nvjvYd51banM2yw+iSSGXAe0NZ1ICGxTi+UEUj4//NuE1/q5OAUJvHBjOP2p2Zi/HMjrHKuBGg6e501Y80UD9PEScYyv+Ueoi+mvFBK2ZYytycTTnjlx7xATzze84XpbNwGptMM+Jzlr9pqIPI0iMXVIbYnkKdGrGrsQ0JPaeCXgB0lcm7yNNVZfN/CGXinv9BlhNW+u+lDd/2/mObxytHie77tCF4trnktxJChj97exGEbXpfyKn5bX1vuN1ecb/fUZeKbB4teOJoMCPGeTzUYfdCZU8VjhRfFBpOCB1I0zThZOmjJxrkdT+QOW0sZloafAGjVuULOx/Oh1wk5RSwVIuqI0YwpJEwS6K/RHaWRgR6wz2lfWU4p4wnODvjch/tHPoiXz3JGjEWge/F1eB47VmJOlvOAg4/y/coT4OZZ3mWZ3mWZ3kWK4nJMGFzjOBCLieWUlBqAGEGnhS1xHaFujFiRZSgRUMjGhP5PnD6sUJj9ro/e+aMUT2LVjMI9IwAeJAA7Lfa6krwc9BNlMPmeXoM534WBefsMysa+36eUJQVYhwgLT1r3+EpnZ9aNCSjXhMQ79x4I1d1VFRE9AYxCOjgdcHlImFmt43Ueh243e+T8odQ6gJq5nEn//VOqiSWnLVZIXeWOutMwXa2RmbDEQd1e/TxkbIle+9x3PxQ0HTMd/78Bnj78No7JPbDPjJofVJCne6LXM8DsDG/4wCMq7DcbawkV9LDvgYAJnnus0LVfgwUO31n70DRNcvF1yGqqRhUwdWbetMnA6xEA+SnqRcqQMRIdgcw/14DIEjnO+ilGnI11qgzcqeEDx8jhTCLh4f1X4RY8ShZVHnZ9/MICualmcdRQF0VrPV2U1YbTcrjZt6VRDXSfLEpbJJPD0ENeDg8cEhmmLt5HEvfhO51BSYamGaDKVJhXtMEFQJx8XOFqIbhie8QEZg7h+isOIakOjNgFoSctJlV3dWaRAAiIj+XOoeimAFQlSgCl+sVxCQGNGzjrvPItrbNKzWU6qJwIG27zZOGQc8Kg7paDxzQsegv+ZzKwMQh7QrFOhsAr2EPwsER0SGksx3iA9k7+7iYAkPuD0Oy71MYQIdGmtExrBxg+VvFlGgMRqcMp5+TPVGsPSaII2Bon0yHYYfssW0zzZ6Vn7FHGOwGQTqfaQVnWG4+IfhwzzmwHG1XYysqqOWC1lcwG9SRDdZkBoyGtca4vb6GpzfI1+7wdsaJR99Y5rWWS7Mzf6LVZiyTjWbyPedR0RhMYVjzFlB3xk+dnflnvMHxej5jiu8loedpNZHQWztXIwoaPDx2rtPTVzLQ2NK4Rd+MTuc25+iHpkTMYzQrR3M/O4vym7mASvA0tlYl0l/iPy2KBsg94qOE0kvqgJ8Z3eb5wF+YAttoZvDPvt8oIt1kfupMuXXGT+fPmZ94D8/yFr8ffK6cJDO/ZOe4rfdIjWdmDzAiDJQynGe9yT2FGZ3CIId0LJZlwbpehjplept6qG+6jxnb/YZvPn2Nvt/B3LFtO9o+R86w+aJEUHT98gnPl+ZhAMkpZD4mT1Sk/FRHR0fR32znZiE05R06Fey84Y/+Wcf/9K9+hLXev2gwI2uGcS7VnN//pSs2D28x0bHLld5qC5hi7VcUmGrovHXj2fVWyzi9sZDwKMXfPT5B6S9Tn/dd0hcxA9x2gHZ05dGE1TVDva7rQ3muQrhvTddBQSGgo2G737Fvmn7ZjNe77guNQGvOGda0md6+uQdN1tTTxuXd3tBBEENbgErFwkuMAgN9Fw9y8S4HULUvzisRCAWlV7Suhg7QCIAPosmel/fc88MU49nOv4szYo66Jf3tA13K6XTinqB7cQ7Y2SGfe49IcGbE7zJND7lXDN0ND9JdwgzR1Ykcs207tu0OVv5yvSyScskMHdhkMzkTmc3wRVZFPsPzGTfTK1lzE1+W7s+pHM7o/RzhdTbAyJF65EbADzMteT29d22d3TMrJM8+u2zrhi9IDhcS0YTR8HL5gHWtaPsdbdtBtGBZ2M8GMbAm+a375Uvtnft2dm5Ah4f0D5mvJH/kc16vef0wVpycVzDW3OrLxjIzLpPHyHix1nR/nIz1w7PffmxTOmkmGKYJj+JcvC9HLOyIqdh1W1fbvqG1jmXpuFyuLoP1LulWWtvRW0cvXRxhquIqXWR+YqBrGrJ/SOUoGz3LWTnKoD9MnY/4Enrj07d9x3cvI79nGN5BFiblz5ixt4bb/Y5t2wb+P++3XP/wNjsbkvwie63Co7aTySoqv8qDQSym+vLvXAaao4z5fOYZXc/neT77SfEwaZcYFPfesW87LH6463VKYDxmPGgplu73+8BPZGeWaD8NdM76kOVPu9+/T7N/hvmeyW4upMD4oJARo+6QoQCarj3L9y1Pg5lneZZneZZneRYrFhrVhewpr7LyH8Y8cmdw6ZLGQVOUWIj21sSKufcu0GlnbPuOvQN725EF5Hc0DMAICjmzW0sA83wEFB4JvrOhzayMPMNMLWVNhG5UvvgdfbD6l7qAMSo7ZwMAA6a8Le8tNj9kjc+Cf2L8U9QKBhzkLFQUQFRDBmPMkcABqFGB9zsAfwPoehfghjRFUAgm2iqSXLLMwLKIEsByS4tiOUIqC3MfihpAvWjUv4AowlKapb30LXuFH/NUj8NmXtJHZt1/YnCTIDMy+fnd752/wzunNptAMrf7NHrOO+SDY//TvHh7rO35LjrsB//mDTB3/pH1E/NTVGFkIu+Zsk+Uhcec5vb7rbkFMSQbkwLtRLCQ9CZQSj0pmlaab5fP2FLVCMBWatpnlJXdpsbpPi629kshVyQY3pZTr0nUhezFF8ZxNhalSH5kTqmAslBKJGGpbf1YOqx9v0M8wA347RpCNvZb1QgrrOBqZwFNLRR+AcTTjfoArEtEFKiRhX5uorxzkEEBbUuvxWy0s+N+7yDqkKx+QlPAVceoOE3QCLU+Ltl4wwR435dQOqEGRrUUaZ+2dVfalxX1rHMgaz0B6R5JzeY77TtVJMs05fg9undr1eg4lspIFaodOs7Sn1DA2/phcyo8gO5Z2SmGVbI3Z3DCabf2UwyYMu0K40Nft6xRb9BRioHL4pH+cr1iXX8Y0ZmhRjPUdVkWiRgyQCojKOg/JKq0OfncQ/L3IFKM0bzYs/Z3fB88D9A1zPNbgO4MXsoZJXvJ3mUU9rEJ5VjfbIwTrU5tpTDZs/Qtsp4WgJSmsNAqebIDvaFzR2sb9l1ykNcS3shi9KBrQ1/Vuynozwxm7R/7HFHmLKJMJs+276qCj6bwyWCg/cxh8rueJfNZnH87fcyRCIb2PlasTHemPRizPx41ecbZF1coQEjpH/mzoayzYZPxNiXkzCPm9zhPk97buQMNSl80qhost302RrJmkqRh6IFJRjqMsWvCH+m6LcYHZ0Mba1d+bFTG2rlKVFGrvJTkIIVSGcQ+tJEe5+KMf8nzcyZTHHj7VE9WmHo7AT8PWA+qgaYmOQSE8HS17xK/aXWaESrSOFOKkGCVkfLZTMGBmMFoLZIOdamSppTQlMfo2O43bPuG7X7XtI+Efbtju9/Q+yaj1Lt601ZXbOeRtvkb5nDq+2wsk+8b58rGoqOooeWQBo4LChYZDyroALbOuJSK29Zxb+8zzJxp9vmqOaPVj86OuR+P35tFRGsHG/+D7pJRAb6Tx2t+pOsbm+5D4WWsD4/aK2upty4psNS4ue8bwKQys9Aq7pJ2V3gu2aOFCOAiUWgKhBdk8nQjBOFFe+uakutozCCKd+3Pg3VzoLes/SrsPIytX6ZdeC6lGUupEum2Fvh/FUDRaE4kZ17pytswwEzgUkFd0gLKERejndtzlhLQ2v1WOccdvhQr5lFdb3+f5dugdUajdOzYDCYYOe6E8dEDHWL/B0F/hBeszmMaLy/rx87uWie5mUhlLTv3WIxlACyXFS+XCy7XCwBSI03bWaS8f0Xvxt9qKjGYrCYttPPVDErnuTHZo/EYIcXOvCxj25jk31bGaDyhIA2HDatzfO6svlE5CmSewC4Sjc9nvj/4r3w/+fCFfAXhBZhhDkuX9YL1suDee6IfOtbMsFR6kqqR5V1vEDDvSzo7Yx7G89WY36H7Ka0UkbGcxi/I9bxGicKIx68hDIdNzrEmHddhrPuBh9YJ9N+Pe4zgPWUODAowgxV1M5nmMzo9GzFnXNOU+q3taNC0aARUSw1KKpK3gtb2NN4yFqWovAvh1b/6aQG44/UT4FmDx578VpRRHuKTv377yzlP8cP14fxUeX/9X5KE456ZuxgRLkx/f5f3n9UzfNb0xPN1c4BJO+vwHlZ8YNs3cG3qHKD4j3pYGU0wuhHb8yhTwmRq4+WLmCNzN9qkOGbv2HlH2wFaCKCaaPLjyHqnvJG/PzC+zoF3Gq0xJy83IjQ8w64XidxWSkVrrNhfGM9aMYNQSdPe/FyV7o+GMYbJs4m6fv5H6juTbe2g9T6mBXuGo8/FOJNhNVKmp3EGxLw+xqWf5duXp8HMszzLszzLszyLllIK6lqwrJIKp2wF1AldFZmuhzF5sXfctx2fPn3G66df4X7/Btxewe2O2+vX4r0CoBYCuOPzp8/YmzBaa12wlHqSUsmgzADg7adoyFUAEg6a1ItJAQJwBtQDXKDkiRyyvXlRj2DTIDgkEL2QhgtmU9ao4N3Va42Sp+EQtj8J+UTYtl3CD2s4xN66e+Hau0RhMqVFmtpkHn1EJDrtCfAnTcWhT6G1XdEhUdIyjR51vXfc1MP8crmgVPLxbdyCYQYU9Bbl11JXHdQOQuStN2Wrex4mIQS6JmoVwOl+u+HTN19rjnEBdT58/IBlWbBtuyvH9n1DLYtGq5A1WS8X9ZLfQW3MP2/jYZ5Hc5omC6NsTLYx8ZTmS8bXQBQBn11I5I48RZKSZky/kH/PszkIehNznwWULFQxJ4jHwJ0MqNGDCmEgjYbFd4AGaQ1YtfoOQwDtvrHx0tdqfgvH4oJdE09WA+5MyiIiB7dMcZqjWtkYSDSUBgPkzaCMaPS6z0pW+wzStaefiYFShG4VMmVt1dDxseYdPDTjjkIQhUER4bux/JCk2KiLgIvS/gYTWKU+83zr2NvmCuBSFlyvV0hUJaEXtQB1WTQSU8O+mZfZilot/Dc7/bB+2t6y9b3vu4ZilTHqgCjcasG23bCuVyzJsIZqRWMz6AEYQu8krD0UKKiSv50t9U+k8eGuShxfj5Y+g2HpgkqRiDrMluNdwL7O8jdQUeuK9bqCiNTgEuDGgOptJDOV7d2OMkVVmMHvpVbUZQFBjEtIx4gbYVkX9Fbc+xJgN+ACwRWabd9x3zZQL0Bj3zOGknY9Czt3NAioUYhwvVzx8qJRgkqkNOjJmEbyXwvA6cC2IsrLqvf3LoptBR5sjRrAUTRftSlCBGxl9LYDaLq3FkjaJTvvFCjqkrqJdL/LuyRHN5WKpRKoyX1/9F/9IX791w3//v/+fLrfv22RVcLYktGMAT8GkCjkHn8To030Zgb0MoA4AOLvbNPZVQGFGGAa6ba2CYxDTvahTr0uhjPZaEZarPBTujb2Lp8kR9MeGUdr2e2+4etvdtR6xboyCnWhY2TeaA1tv+N+v2m0gA0ojFoiHHVvHXPaR+HBjN8JHsoAxt4buDU/j+ya7X9Lk2BG2Ebzq54hEo1DUsds2+bGhNfr1d9j9Uq0rNkznGGevh5xBZBzsqtBCeKMOBpfhPHKuUFANrLIKfkg8CzrTOgeXWpFJZJ1A9ZzZZUzyZDGJStx7GWWRq2nd9n2t0glQF2AhfRMaLv0r8j7iq6m3mU8a11wuVxhUbrkfaSK7hjD0ZBcftsZLcYWQkMk5UlTnjf4X4DVUNGAUaFlHSQR3phAlVDqRWii8TcKvnZ7qyqMmBoKWcQJURrJ2dBiTqb9Ef1T48TW3CicUl9tnWR+23h9kPH2eq4kQJdKUaNtpQnd6GZz2l3qKsrjMqfrkPbuVNSwnPScKaoElHNN6I3QbVFUL260WUvBuohSs/cde9uwbXfc7pImhzsr/12CT19WLJWwLKvKSmUaNRt5W+fZKeAoG81K3LyHYk9JPfu+o+1NeBZWo7jeUZcOXgrkaCt4Wb/Cffsaf/pnf4m//MXb1DoksC8Xnj695xywE+hL9853eAQ0oyPW1sGoOr9Hb851Tin5bN267gYAUYcY62Iw4hwjgKk8ujMqVSwXMXh9fW3Yt+57j4wnALCU1fmM3hm1rOjUlQ/ZI/Kcy89hkGe8F1BUlih+nghfY2ORZGyQ8ptxFgrzpQb1qnBxkZvh/EuB7I+lrmpITqhqtLw32Redd1AReZQREa/k3KlyFvWOypHeLntt5/PBeCbOjfme5UzGz+cSGZ2Jb70t9ne0M2S1zhrViYQn6az0iQitM3gTWrVtO7Z983N43zcfK5e3isjjgMi/EhVRnm89jK4lnVcTnGYJxWLbGz7dPw2y3suHD1jWFa13fPp0S3KYGN0LpqG8uPZNZJmqSsoGEDwNz+vrK64vLzBDA5O5LP00o6DfutN6IAx2jc+YsSBJIcGH67HO4WPhRhpcU2oo8vmx983yicwiH+bc595kfGQ6DJ/nKBYBklVGKFgWGadtazKHHz7iJz/9MZbLos5SsvE+f37Fdrs5TuJbMPEuTukcn4tFWZfqtMkiLUi7u8vCwStKj4UvY38m+q1OehRRbxniYBBzGhQv8DBZly8vV2ybKccZbd/UKcQcG9pgQGyyLEPkS6e2A7CDoaxVsIHemqZw5jReEqVz31vgSiDHn2ajqRm3s/XS3biVQNSx759x7x2tf8C6XoUv6E2ix1USo+cihkREHQzhu3/6c+Bf/c8v4P4Z/+f/wvirPx/78v0p2A9fZBX8MPT177P80K1/i99572jNfBP7NU7fj7U9Pu2+fQ+HWmn8Jn/nxh8qc+f7JH5h5iECM1A0CgzBG3/1q1/iRz/9Ci/XKz5cP6LdN+E/haqgNZEzry/XXJl22Oi9ORsUNxplNIUxWWlHx7Z13G43tMao9YIrPgAkkYUfzd0jjN/+C0MeTWO8bWh919RDiTNgQCIFdnjoawZ6Y1wvH/DhwwuoEL75+m9x3zZADdiLnqmX6+LYaykF67qorGC4WvByhQrWtaIz1DG6WWZPp9mlCo/feEdvu8tSy7JgKZHGsG3HlHlENKxTBvl8TCOFrNuRw0n5vAf6k2f5buVpMPMsz/Isz/Isz6KFidG4o3FDoSqhshlgSzXBwlDVQiCEorJUaMaLDuaGUsTzq7B46y+lYlGBtdaKQlXzoyeGkaCKhK4pmwiRwzqUaQL6E15fPysQYiA4BADk8LRwZdNg2CCsf2uswDoBxmgiWyYrAJFFt25Ko8XBQkAFfoIrQ0OpQur9phEtQCiLvEs8Pczrh1ypJO0NBjIrdwawxsF3dilkBCVI+yA/hAXiftwDqJiAmwzQZGMashzyvcloU8GiyhMHO1BduABFtAbhYVURaBg9FaBL+PlGO7gUtF1Aq/v9BuCOulzQ+g4QY1krlmVFIQlTu7VNPG012kFrTRTGXB2QOzOiOOSzZjgw5sYxIAesDcwdlCzuLsoDc27j5wpTGmCmaaOl5Zlkniw0yPpKYlZo8gJ49nfqWuHufYL3315oQKz2zPOUq7jp7Yh3uKBKR+WBCTWcjJNysXQKQCieJLUXFIwfQ4XntEoZOIz5jH5EX7KhnbR1Tush9GtOXUNh4FEYBKU5NmOy3EXga6EYZTDQeFhjkupJDN9aDyOVnJbLwDLrU26jKBc0WlcHiKrOu9CJzpKKrLeOqtFVWmeAm78jj9e2bclQRfrT+4blcgHVgr03NIjhSrlcQFTEs7izAOm+rpRSNgNQSLNoCL0tKI55FPOisWc1FE3vTbzkFKAERNCWMd0V2GOgCxBKdUEpi8wPWCMZyDrbWlJi6Gy43lOVMbbuLW3BUiQVlH/nYLKcJ6016TPD9xZYlTQovk5BRY2nxGiruDq6OCjKTCgsdK/oeG1q0IO0zlUNkZArBVlZRpYp9hwTieKt6J5hVbz63hRPRkLs+85VAAqGehXZOWDnHWDRbwCgElSpvzjocWt37HzHtb7gslasuv8ua8Gy/LAgBMOMZmTTLQ6FkYJfcU9X47czipNBM/ts9TNMHRygYDyT7x7bdQQECZ0YI5yj35DuDaeZPLzH1fXEYtbEZmAbBjT2RhpaNbeB090jAGrg3afPn7B+uuNnv/NTUN3BrYHU6ELSbmx4/fyK++0V+y4GfKVqSjjlQ7jIvu6AHiLyJjGcts/6XlcodYzt1dXutFmMTy3N2hhFzgxroGvVFCQabS/xWwIkVlWcTDNBsXp6Y79k7WNdUaMRivGhuU9jlXKf8VexksQwprjnX+/GMyGUtL1hV36z5NRwSnJAAffKcW3e3Ui8n3oGmoIGHAoVQI0OOyzFgeoxnV+tdQWhgnvRY93OfelcnKHZKIj9Gilv3pXfZCpinOPKIt23akAqEVrCMKjUgloquDM+v35GqYx1XaUPRSxLuLMYn+joLnVxGg9VgFkkSaNpRlF9vvTMzytQJiP4uNhdynt0TcugdHrvKRKB8u2ujHT+S95p1IopUktlzq8wCZXW6G5+7neb/ApRcpmcI3KXtcci8BhvCu5YCCAKw7dPn77WVEyb8GNEABY0bqjlAoIYy/q66LZ2x0hx3l/K42pGMyN/qow9EvMKdAI30uAH5BuHNWoaSqQiNP6zLC8gknSN923H0hf89a++xtefCMCKb1OOVPl4x6PT6+zZM8URpvvO61MqQ6b4ITEIHag7vHbjteY67dwTjoGFN1DeEACYGioXmCkOTc8CAHPHp0/f4PLjr0SmasI1iEEC9DyVHEZEBJSQFTo3TaEFDTIRJ2yWRdf14vJzmO+METCNYroBhO9DU+6Ma4vU4ig9BWZRRkMVWKWuMEMzgkRR6HyXPbzv4iRCYjRtBnyUaEXrXaLUUAHXMICwdmcjFDvjvH1EJ+fdtyuzQmc0/vS75LwjAMRoDX4eG7deKsGMp5jVq17PjD2dF115x5VWNRQRHrzWIsayLgsDXT3Ml7oqt1/ESLJ3FKr4cF3F+aeoiRKLcq6S4juQ1Fj7vmPfdjTWdI+lYFlXXC5XSYnVdAh5ccO5ZVlhUS/3tovcWITn3vdNz73F2GdpU63JYUUNhhS/6e0YgXQe6zwXbuBSI6JwluWyfGlGVpZq2uTa2dhlNrTJ+IT9ztfy348Uf+z70c7oiJJg653VOaZWiXp1v99QF6hsI/t7WRePSubKRgK478pPNJEvCqk8CLWDDdlC+BZGR/BqFuGuaLThLO+Lg5WOt8+DjFEtmpbLxhBQvlGiJAhNVb5C620s64BbQyEbN5GZq2I25PxLB3c7t+UMBhil2hlIzkeejnvvIDDEh4YwGJDrc41ZU/zCaZYpd8nbJ32W6IqA8TGyRhqg0bEY3Z2c9lZUvpYIttv2ilqBolE3C3Xc9w1rWVCWBWtdUZlQuaKUzwD20z79fZbERZzKb7+pd/6m6v6hy9s8zXjfl/r0iHcZ/45P55Lm+Mx3GUc+/DvXE9yW4cfBI7DjAnbFZGoCNHWk7If77TO4veC6XvFy6fjbtqOuK+7bTRdeFaNaIgkgrFyXpSS1NKjLsgIQA1DSdO7cVd+AHtFeujiaLCVh4H1OPz7SfaP3di2wUSDvDovgT0SoS1EZGsLUgx2Ld55e698b476LjC8R/lWHoxHbGKIP2XeL5m7GhMC2NTW2X9Sxz+RawTIITSIpluo8fdsb9u2OUhfBS82ESYeANP1wZ8ZuqebrAovgz6Q6lWKM8XiGhqyuxrV2lrv+qA7j8CzfvzwNZp7lWZ7lWZ7lWbSorQMkEsLuFsdg846pAIpHBgEEVBNhVvgbEbh3dAWeaiEsCsZ0Io1yIAwYMeH19RMA1rQ6jC6cLxTdGoC0LKD7ZwXNzRvGfbQ9j/PoUZSF9qzrn8FgMjTGwXnADG+WJcBnb6ul5vDn7ccARANoZAxNhWftnsGV3K4RaIBbgZsyIxQGmUM0Bj2r5LqDGdIsmRdxypY2ZkCIADUkMGWBvSelZHJB36zPSTzZIToBVgmGiCwjDCoVcBGAU8BAMbwRQE8YXlaLfVGeKQi1LDEv+t5aF1XOmEJdDJAM+MxjOP9t3liMLkC/XE1AzYmoSubBPAJe81zZVBwBUH/Unz8HxOgAgM0i6wEAtHVLcEDagJkMwplgMtYTfXdQrySv1glcnA2T5mLhwPMzEhwqxPr8rty+bMhla90Unmegchh20fADQAE+UViZoCXg1jTmOm6KS+vyUsHMNJsK4lWqHuWm5XQnGtba6JTJyBYC1QC/GCMxIATDQ8X7GnKDF10HnopI9+oJXTODGcteksezM4MVOF7WVfIUb7sa3xUwdZcwLeqAKSzMcMymjqd5BeV9EJHIRq9jKMDcPc2aDKuEcUcRxan8UFL8Wb+Vutp+MFqVdoSvb0BTy0g9TQHvfd99gvd9R3NlAmS/T0D8ywAAIABJREFU+LqJ377mQHACRtZT8/zmAEvT3gcQkWXYVJCxXvOGlmgNuo/VM9fU+wNg0rtSdFGi5HPAFWceSt1C5/Kwv6z1No7S5obO5MqzZV3w8uGKDx+uqKXi//n3BX/1F6/4q7/84VEIgeQjAgMgejuCZMEKeMTSDkXJKgPBxUeIz84JoXg0rN2o4VhI7/cqENNqMB9NT+d3W7SZgP2mdnm9owFM3HFsFU8tGFsb79j/6iN+/e8u6D8Ffue/27GoggRKA/re0PYdrUUKDnaDj67RWyQKVD6ayNdqd54FSOeQW2lEuzItr1Xfw6GAinMig2KWltL4TBrSLcY5dhiiGCvu09iz85Oj4ai9U0eYxzEe90yKTKOQrZwBY/oke0QM18w4h0BUPRpR8A+x1oydk3PBjG5MycJ2l/NAlsbKjOEkAmNxvjb0vXbuFD/S7LATh8RMz8eUp3ZWOr8HoS9Ce/J9R+Ug+HgW9C6R3OqyuDFhszEiAtWCavPVLLVCKDsPXto2wzomM08U/Up9zP8e6OJJoQBfxztD+U5EIE2lYOMo68Sok3lpynquNXgxGauI6gB1UKCSUpaRnXWS0qT3Ha3vuN9f8fnT196GoudW15RGxDl6jUXHPI7Jgab42omD//FYWfsh0W1UvmC2FG66CHR+euvo1NCIwHsDV40mwAXr9Uf49PoNPr82fMlgZqSjPiMq7xzvfkQ95zrGz0al81+Pn4s7Ytw6VDZma9nEvw71Rx2aVMi/IxivJT7W8rAoaCIx7rRCGdj3jisVdAb21sCoUk96gykcLLy/0a3gueS3nXHGH3kf1MAv+Ca7Po6ZryHbG3wyi0ojeRgUGvYgp88MOZO47yC+g1kijpqMAhbjSYsyZeMC7hpxUox+1jUiM4bhTESrzDQu+vYF2jGVt2jN4+9CPsuONZnu2plqqQ+JgPUinkzcRbnemp27UldrDZd1xYI4wz19YJEzeF1XxTuCxzBcQ+R9M2IAetu8fcwapQtydhWlfZaCudQihv9UPEqM9EnTJ7XmtI+5g1ucS72b/GrjAI8Ca39LakKTM3T8eDRWyfOZFZfWFuO+PR3GiXNIljtFzkrOM2leZ7k1v/dAUzI+8aiwUYTMC5HTCDmz5ay1aJTbdkddCvBZZNZtuwMA1suK19fPwtEwexQpkDkPWLvK0Nch9ZLKyCa/gNmN7OY+Bw4moxxGRNKHDjFuUYFIaZ/sY7AYMtl7xei2gsDY1xXMEknZHHAsBabJYND0gMysDgkVXIJ6ns6D/yN/cDKoNR5pNKiTsztfMwV4Xi/xfJnmWniFzg1IfKalx227RJhoe8M39dfY7neslwsu6wXX6xUv9Qp0weIWVKAXMOeI079dJU6AUTr7TTWXpt/n345v/00PnfEAj1rzVskn6MxDfOmZ99Qdbft+ozBz4Occ1SgPxyfCGG0mmIM8nwSlOQTwXvHLP/19fP7zF/z49wgfvwJ+9FUXPmjfpO5SsKyL98/OWeHdlccq5M5bBHOQNYeADlInCaG12eHN+IxzWj4bcZ4VgkRxM6cS5oi+BpVdzbhFrRzHRUAkRil7xYJFDAZVKHOzeG1nKQv27Y62awRpEGpdcb28oC6riGSKGTRuaJrS2Yxcq6aK3YtgWbUSlqWgtYq9bWBu4qjYGUVlzmLp53pgCoXCIFKCWx9lTF8dHDoAw+nCAfbhsD7LtyxPg5lneZZneZZneRYtBm4z2EGj1huqMyBFosdU+d0MIFHgzRUq+449pb/IikwLa1jqgsLqdawpJQycsrYYCKtXQGSGEOEh75D0IyDXnw3GCxgBknOAggamKwPjYS3OqiOaodgEkMiAeqeC8Yu2mWf1+ZwEQDEz1tHnBAoN112EUKE+4FpmeOh8AiTlDAIIiXcrNMWcwCcDedT6n6oAZPpKVnCWIQpPkCQLmafIAIUApBoIYjxj60+s7cW77XK5gBkKoimgo+29bze9V743oyZ7TwbC7JotD2PEWYEWD018IiDaPjjOwdtlXmM2r2+l3pq90eaxy2sY0L1WDrcO5WwdGTCV2xXvDU/LdwF5U/tyf/yaKmezoUf+MQOZAL3KEKkkp2Syd52Okb27qNGYjz37WhmAzfSsz4s+Y1FLKLVZngkPu0IFZRkNgGKeTFCMqDC9M5Z6VOITyNNImLFK1WgLUjeQsdscXjqPt/0upWDv4l1HGnWl945NU3Ws66ppKEI5A1VmuGewC6vz3McaEQB99Lhz8Nn73JH3gM0l6497PmcEiSLKlxtIkIR9jWAX8oetWTMC2Hf1xG8WgUE8gvZ9j8hXCvIWpdcmeFsb/XNW4OT1nMpRqW/RY3CYn7x++7SGGSm6hLxOogY1m/iSvC7NEIEU5CAf69moKs+FHLFkMTfQGBpSv2BZX/Dh5SNeXq6opeDP/lPBn97v+E0VBmMHNG0QCc9h4BVsdo/7RKAp/ZtPYG89J/LT78VR5vvmz0N9ZyQxr5c3y3ijnqwZKsTZzsvPW88LJE3PwgX7a5f1UhMTw3IwDyAUZF3ldHgCtPHQSVP2Eyl0SKltzOYQ60WWW3HDwVrFk3nbtmF9mvEuqeJCwDLSyHyaMi3tHaetp8Or0KcZpkzouNBrJTC6r42me4h+9ea1KF3mAWw822h8Id55zKGM9KgcMGMZowdGQ8nPFU9DZvyZnxfC94w8aBgDyLVQwhjvFh22uVP+eor4YGuGDZVMfMOozBl525kvmcHMMx410/neO9Z1xbosrlQaFFP+lyrE9cx5q+6RD3i8T85o9SM+4j08jrQ09l6uS+SCSHMUCkaNrEJq/ErGo0OB9cTzUxjMVDOY6RIlYNtu2NuGfb9h3zaVqeKs7Y2H9WDdMa//L/GtBljbvH6J10oPDiC8lLROrH29g3oH7zuAgl7EUGpZX9D2C378k0/4F3/c8PHDB/y7/2vDtr1F/UY6kOck9eaL5YyevDVK760zt8g+Z9OZY3vtyXhDT/cKb2Qx0wqqkpOIzZbarfJKZ4kaslu6ULDWIXIQgzU6a09RnHIv7QQ+rh83TMltT+eGKaGOayifoGk0k/HY8KytYZdnrVlCp9u+o6ANfKbR9NbaMcKotqUWSbNQlDe+K59jz9mZF8/kcfkW5b2Mx1TifaPMN8uQcmaJMp/I5EESy0Y2A/wxCue6SvrTfd81OqXUuSxV5eiKdV0GhR1Q0ufuK7lzE/6R0hohjQJi79VIMGKMJRHXSGUb65elN1o8NW3wsbVoGi1krEg87i1Vl/Vf5KRIjw2OtVdr9bGcDRtsfPa2w9bevGbmv8dzML6bZfT8zIClfMe1kR90STKd8SYn9NawbXeslwWfPt0jVSCLYdSu8niW48gEj/SWM3l9HpPMD4CTsa3yLI4r+XkHpVP6Ob/xwTazObpcLrhcLpIm5UVSsIw81Ch/iqxuv+3ctrVq59P4YhqG2fi4cf2djcG8V2MtzhiLdpWnOrQZVAIXkXSd3WVa+lRxv2+4XC7YLld07rj86CqGq+gAdYCLK7p/W4uR8kcy1g9V3tpmWVTgdCb9poftO2/97/nO9/br3WLsO+t6T735O85XiAcjvLN7CRBeplV88+e/i6/BqJc7fvd3Vvzkpz/Cp0+f8XoD9i6pa5dlcRnK5B3nw4sjTs6zmazqDsIs55Hx8tY+huFaUuHZnvc+nPDVJuNKqmKVzROvOOKyWb4UIup0WCPfdItOU2vQZa2R2aJQ7kpbpJ7r9YJlkbTxZnArvIRFcWONfG3RviporXpsCP1trQB3iWwj49UliA/J2Btvls/lYRxgh8Q8dkYXA6PL5zd9CQx/lneXp8HMszzLszzLszyLFhckDYBSpS1q5NI0AxdLz7Q3CbdrzJwoEDSnM6DIBYG7eiaX7t5govVVho9n5QJUIWOsvVwT0MuE+z4wU+fl3NI4FMCPBF4FEY1RSxFrbLQGUNMVCxPTm8dXmdmDslTiKh6AGGOic/oCa2/UEYYyR4VC3B8XCgiPI3WE19BxzGxdiHImDIKyMsNhVRZvVi7Ji0tn09IXsP2weEN1sISv7B2g6sClKM3YAbFlWXC9vnhKBvGqC4V4NsQ4C5FsihWpO0f8OHqHvafMSgUbqzzGZ9996V1nSpszpVH+ncGeXPfclrz+GYj0FlM7M5iYxzV//57iShIVHnO9uY45zVC8Z66Rht9HEDOUnISI1KN3uEHUPBa2nk2BbG3KY5PBLyBCqAboF/TquNfHjpwp8UxZa/RGwOOaDGMkVOrZc9ngbajbugcSr1qSlEpskXscFMh15vWQFRg2VLHmHEBUvUbu57zu8mdrq+nmrS0UDZb7SNqd9y8RPCXI3N8cRh1ar0UIM6WPKZgE0E9GMfpeAB5tKPs9DfRuOkPmOZnvz2Nic5uNBqPtmLxVE/0CCw5KsxEM/L655HEfooiweHMyJKw58w6ignVdcbm84HJZcKn0d4LqMRhNuoCI7HOu7AwYy9b0vIKntU+xpr4LAHpSa678IQI5X35rGM9BwmO18+fhHQx89Yc3/OxfbliWK1zR6OSNEKm5ONGbFGHG6FqD73epx/g1wNZZrZ6URv5PNIPZorFlL+wKol09njcAuv/MKxk00FMGsO3Nw/pH/3P0g2MhqVjboXtUV0gtFkgabihnysPeOnYQmBsImmbKjGtIeJGIDgKAjGc2XiwMJGutQImoLgyop7yuXKNfAAKoVQB24EWEN+5Gw/TdYqRs3oDyiBsYdbGCKVQ1wofSPVsPFiGISI0UR9qc18fJyB7KI17A6qxVot9wUtJbys6lipXk3iz1gJ59YJ3CI02b+WGj9a6AS/Me4/g2nZ7b/eg7fw7jiXlG42fldtx7fF++N/NapRSJmMZmiCMODWIkvh94Wzk2KvKZkXktMyR4D58b4xo88/vKyJ9lGSTzFARGLTLP3Dt6B2p9wX/5T2/4H/77jt//+RV/8qf7mwYzUtMka+XzerrvredzPSZ7jnWfDcL89ihDG5Ky58xI5liLvj9FKgOTeglD65LvzGhGJLxoP4FQlgtaB5rSEJD8EGvkKpcfRyNxvejtZbbIZGGUEbJGvp2T7GyjytPe1DVBnB6cxkPpFGDrL3hi2ROWts5SdY7nmfHprTVs25baPcpFVY2Os8wYEUrPVsx34SC+T1FDpcRrvsVLl2J7VbAaInFianvIB7Xaj0bKbM3fFee0pYGo2PdNUzjJfPYuUXxKKdgkf60rz+oiKZtRxDteGXswiVE3GGjbBmAd6AEzD0a72cjdaZzSjLyW5Fm4sZAZuNqYmNxlDj/2rvkn01tmiXpsPLjUWwYnjjnNRi6zbHsmM4xn5hETyO06K0RZKWi8wYyjdZftmRltb9japik4u/Mbndn5IIvuSal/zNmm1rlu+a6zR28qVMCFfd11pQdI+4ucX2ZjKdVhAxpBM4ysrd1nuITgQNcwmHFnp4pSzDDFHLkIERnZ+qBf6fq0Sx6lbQxBHedCIfQeGMDZXsxY1BzZOpez+Q2ZUnkA58/yPaR8QKQxBYC6LOidQZpyqmtgHp2F3/ry991GO7Hik5X3Gd1+m/e859r3fcdbsucDkfW0nMvgbz8/jt7Z3+dPn8nAmTubr8C/GWstTIl3YlBhLAuBSlfHnI4OQtW9WWsY19r54TJnFxomqTaVP2eR36h0iWCnPA2VIqnUbc28cV6boYhdG+7j0MU43eDgh+SjGMT52Llsr7Kdy05Ks6mgLgu4janZpO1Vov8vgBv2lwXQ9Ir2kzhLFNJzTrH8UiuWUkDLin2/izNXV4yA2aO/WDGHOpf5T4qdaQWTs6I6X0vVdv6oXH2QZZ/l+5SnwcyzPMuzPMuzPIsWEbRFqS3h1hmlSmg9UxKIdwOj9w23+w337VWYR4Qn7r5vuN9vEnq3CHDbG6Ohg6iDLDN6Z1wuqwh+bZuYx8DtguGDtq2iVsLt9goGoyZg+KycfWfMav483hPGKrOg29oGdsbV3iFh0y01kAPTGi4QwCBEu/KSWcNHR+hVE7it7QNgNCkBBChiBz/CyEb6AKQoCiAQVYQBQVikMwdDLXWK8kJAjx3MDaVIiMVSFg2DWLHvDdu9IRTmFopZ2wcRNnoR4YJJrPpNmURIYJVOsClyLNJL9fym8DyrrTXctzto24NZTpE27ve7e+dGSp+YUwLQsAMpzY/MS/L6elDOmPvMoJ+ttTPF+ttKnHMDnrmeQQmu45DXUW5XBh+tLhfIksLuaHyiwHINo408pm8VG3PzHDBwelfgPXt9ztFI8tit68XbfRolR1qZgNTw4A6Q3vZlS2Mz14BBwAUwrKG5WDSjroL2dpc9U+uC3iyKTaSjGCJ9QKITyHgusJCkZkBn94piuWDfjT7LPR6dhXkw7ok0HtG5riAo9467Rup5eXmR8ejs3ic+b6qEqFSHcT9b59lASD5bWHg6rB9rS37WPUOJhH5U24/jGs5pT/ThgT7P/bW1ZV4s1g4iMbqb536oJwGc0WdKBn7jPplpdPaaydGu7N6ze+azpvcIjW7to0IommDIxrhWPcs0Ulse9/nsIaIEagNrrehN0/OgofOG1oFCK67rFV99uOBHKw2h2d8q823fFmQUoxkWUAqEMkWNyYYygBg9ZWOZUNGNcN5BuZ2gtjP//mOf7N/HwCmfeL8d68Gb98x129vojTbmXjYClusVH18u6L2ioGpo9/GM2rYNr683iGESHGQCYh+UsqT1yL4em0Y5kjVr6Sm7tzXvC0sJZn+33nC/37FtG/ZdU8L1MFqDht7X1Rt7WkNPyfpV5WBvJyOm7ydhQmQvaLSWUlBoAXFBTbyl0aBf/+obmDKs1oJ1fcHHjx/ALN7Z9+3m7yjFzqGu4aZJx6j5mG2bpKiK1DoLaKHB29fXpdEXvdb1r6LXuiuYJf1FIQVmuxkBQr31JUVGhUbogaRoMj5c+pzO8GbK7UyLs/IuwF2jgUazsiIo0798BoWhBWuUOE13Qs0qF6UqEZZ1xbqu0p/ewTnCEY58UtDJoMm9d7RkRDKvx1zPqWEpjka7b8kVNSkj8/02DjMPJ/d18JDCJuqz53I0RLujdzGS+fjxA1pbsO1SX3hlCn9fKoHVq9zOUWvfeA6+QYfSGrC/31Le5ufm33L2qJODR5WS/Xm9LLheLyhU0PcORkHjFxAYv/x0xy/+5pfY9u8G1x5p6Zfvl10cf71VzhVrcYXeuIOGnzhhLJUfIAqXDkLh874wSVQ4u2JnJjRFk1wDlvUjXu8bUDqWS4WJNzNffMbPhxFlR28bttsn3O6vACQyC5HEriolol3Jj61tky81uh/P+1LvGc5EBkNop53j5HgAoxThu6t7J6tBf6JhZvBi7zJeaaZZYWQSiu1lWTSaaU+yvv00bU/Q07m8JRN9FyVOlsVnWdDeJfws+XyVQqAa/eutD5FX922TOe27vmNXuajg5eWK3jteX1/x+vo6jGWO+gKwykYyv83byOhoaHvHrkY6vjZJ+IB9v7vBTh4Xo2e1VuePsxxfqKA1OF2L8Qh+TviUcS7sWTNON1oosuV6kDf9jHvgpT7Td7+uitRRPiBXxh5SChqvznAMw66dyTXvL2YkWSTN4bIADHzzzScsF4n0Z3uylIqPH7+SSDMa2TfLvC47QHkMosGAWeTdFHUOkhIwt39dVpjTncnDcTaEbGjjbtGFM22y+TRHvh//+Mf48OEDLhfBBtq+4fLyAaCC2hqYxeK7dYkU5Ipl4/2Ut7J1YPNvspi9z527lA4sdcQ+8nzZuXoWDdf253yuzvN94Kd0zADBCyOSUgHQlJ8Mvu3z6w3LS0Gpqmi+AHWteLcQ94+0fKn3ZljBhztNBvv28ux3LfN7viz7Bf/ynufy99+1T289d9aOs/tzmzMfFN+T3yffsUZsMSk/sLSR4xrfwWi43b/GL/7613h93VCoYNFo0HaeXa+ry6Zm8BfnxKZyVQVII6WxRZoidxCTrW2cncpiVA+owYwf2bXh8+TAMownyTtJI4iRpoCyqJ1NjRgbia6lqohZCmFdFuxgTy3HDOwbg9BxubxgXa9et9BalUE7o3c7c8PZeVkkSnUti6dSBhiv+45V6VaphAtdJCVTC7p/uVwGjOqsnyZ3Hq/jSDu7GOWgAjkK2LN8v/I0mHmWZ3mWZ3mWZ9FiyjkBUhJT4sAEK9hO6unYguMlhfkVOOGkKDAFpFktO7iLEISRwTNrD0xxGe0zQMaYUveScYEaE/g2gsNHJejUfwSQaEAfs3n7kwI2c5hmGxsDiXN9GUgfQUq/6ICclDMm+ZFyVpjy7oysjYOFLRb+XZjpUjR9BUXbycc3jCdiHDSqEJkCPpQtgAANXSP+MBsIItEKOCl/tBEuTLjhEERZY0AEQxTCni9W2+GRSXROeu+43W643zdRJJpSpxYHDg3wsTHJ4JsZzJytjS8qBBD35nKmnMkKnUf1PnwfW6jP8zrPlD0GbINwAN6szF5xoiAMdWzM/TEC01ttn/+eva/s3bn+DJSdGeFkkMnaOrfLgMtReWbCkikNistb5HTIhxkHUX7Yv1kJwIf2uxHJ+Gh6Vq7ObbYyj0nuZx6T6BurweC4vrOSbwbyUkMEN+xdhP5SwMToZqio/WBmh406d4vF4O9xaCkpa4T+JejjZM3k8cv9LqUEJJXHh6BgoY4V0ZCaJfawkdEI9S/PhJLQFOEWXYNpnHM/USheSKTelvklwDDG83mSoxHNypk8DqbUYRbFUz7DvlQEYO/eP1dQg07XwKGkS2z/UQdzA0NSMC51wa/+80/wy//wcyxUcb+/H2wNEAtvGpg87B88fgiYxFPMkovED7mCcfg8dNH4CVIdZG7J2J+zNtL0N59cx9DX83V1diFRy6HdIwCax24EBI/gKOuZa/MuKVxibRr/EXs5g+yn68T5EuVRGBJi2uhRa+IRTNHyeV9wWqemoNubrntTgmmaBmE+9Y0c6REvlytyxC2pzwYhj4kTbh8tVpri9B9BF7PBIRHh5eVloLvLsuDl5QNal3z3LRnDMEcULYLVb0q8HuMBMwbO5w5FaznRHjBAkGgiE/04rIjEUzv/U8o4jimFlOWat7Yy1Ot+SoMaa8Rf4eMevGJeIudKvvEHMiYk72uaFgbW5qVgWSJlk53fJa3LvK68TxO9NF6mLhdt/9HIMs7QMCr9Eq+T7znjk+z3Gc8+n3cmF61l8XV+pnAb2kLmTb5j2+6o9SNqtT0dlMCU2GIQb8ataY2mdpzxq3N/j/0bOnfgdax+bTIyNbP5cv4u0UH/IfHgbY3AtAKd0ftn/Ot/Dfz8Zx/wb/8t43/9N+EZ+6UTKdPI955BIYUeKez8Thr+Gs+WfA5lA8nEIfm5le+TYVM+jIQmWNKbUTaOtvap1fbl8pNf4/pf/0dwvYI38ncConiVVJcqe2n0Kos+B+icAwBbpC09M8zgyfrj3WPkEZxPqVBFPuJJ0v26KIL+lDDQKbK+xQhBnnM5wdPphaGa8VrZOMa+kz7yIKOFjJVxD6OjyNmA3iwHmf2LK/a8DjaMIO3F2bDRrgNGByTKCzlPaDJWBRFr0DQ7S4UeivMS0DyFqRjAGN9MREqnLTonYFiRne1mmCrzVFEXbZOel6QpvZelqPHFfMZh6E+Wc5kl+XfmAfw54mHe8rkkFRBc5uF879Ho0/GNPkbxzE4J87jHe45yez5S5jUhf5zMd/7+YcmyPSsvxD4/MufVx9kMckCkuA2rI5zMlfETskZCJhO8RHlwjxBgPzEPtldlrAyLICx10fSaNP7omiYiV/QyhUG0z3mPCLc2RpaONp+dltaWSkHRz2KcWVVesj2e5P8ee0A+By04O+szbcnfWTvNeHV2TrJ7z9bbXOZrmcadbBNvvxgLqwHhtqNyQV3F8GzvG/7gX2z4g3/W8LLsuOJv8fOfvuDf/G8f8Bd/Ub/1OfmPocx9jVP88SjkmfmuY/UevuXRtS/N08y1zJzJ30U545EyVzCXaHPirzH2haffYpUYNRLIHVbGd5LIHb2hNUk3BKjTb0r7++HDVc86M7YPHlbO2mw40tG70EeLzhVpLMWgd+zf+QzM2OwsB7DKQplmjiNrNMaSUiv9gqE6Quks5aQ4mnY1NN6GVkmfGLUi+g8azrpMe4hKmmdzrmNPIytRZdgjzwjPpHIzB8ZrjpMebXYaPMMc5WhJb2STVxkWbcuuiw7DonQ/yw9RngYzz/Isz/Isz/IsWi6XFctSJWzrJp5URfNN7/sGIpJ7asG+CYDbuYEVXGlNAN19E2asEKFqfmoJVbOANLyfgHXkYX1LKejc3LsFQFLYjKC2fqleitkoIACIDE5lgdPqMU+WAQzPoD86uI+etPZeA9/qskgoWE7MLxnTpwwuj5bTGQCQvxmtdxAFwHMGZudr2XOlaYj/DAJK/QpocDzj4qArMUKRZmEfSwnBXq4JSGReazaebpDg4IYZohSAiqb7UJnGwUYB/sRAw9rR/b0G5hj4kpnnAAdjvnpvEeKRwvjGFOQ5YhEArOsa487q/U1A690BJNgocRgIkUpPBuoDec2NczMrcqzdZ4Yqb5VQfI6AywyS5uJzhjHaTn5fbluAyuVQz9n73lKy5P2T2zv3YQYrz/ozj2uMXxa56TAXnLQF/h3g6y5AqtymZAyjUZCgYUezl3ee10wTfC2yzFity9TmaFNg3nlOx3RRBmzntZTzB5vB4ll78tjlefD9r3TRhV0dF4Lsf/G4oTCSKeTjErQYPua5EI3vi+vHtTPTXfeONfAVEO8XBpgE6Lap1xkVukMk3vRKpxywBOR8ISiQHp6vNvRd3FRdEDegNa/F3ruvG+n1CPi+VXKUgDPlBhDhaM0g0e/Rc0PmNSJiMRehUxjDp3uUEJzvvzwvw15E5LZufcPebtjbJp5C5YL7/Ypv/mZ9s59nhYbfpPqlb284Y63MNeoJMCgYz4xlZoBuButcpoOiAAAgAElEQVS+LfDJh3+tngz3jXU/et+xV8f7s7EMT089AiTjfK8AF/2t0Za6gIW9d2zb/bAWsjLbaSlHmgbjI8DR294Zt1fjC0jT2I2QbQCP8gyVgoWWIVc51QqQpnD0SFfq/Wve4mRpIswjuyv74cjZMANG42W0qtILUdJVksg5l8tVjb8lpaOknCi656qmJVvBLOmElqVqZBxL7yHvq7WKF7MpLZzQGwBsvE8YC4hxG8ZFo2eT5YHjpIwSnkRXOUFookYKLNWiCNoZCWP95MfOcYum16FeiXZm2lmPibZJDfOZYs/k6zNdzHxGKaKUZo0ItCwFy3oBIPyrgaWg5vQfACpj3KfpfdnwxdrvZ9y02TI/8YhuzzzKfP2MftN073wmZl7HgV/dED3NrZXZGz3zGLUQsC7YtoJf/OIX2PZ7in6RW0QAzJDAPjPMWDBHTJgBe+uvG3kd+Df9fUYwCUPbg1ePucn8vb9bDnuhbERilOYK24qODR+u3wCXBi4LJNXUl8uRdr6/xNkxjQ1iR58NwHxdgnwer9P0V77PzjMAvhcIQKexLxJ9bbrf7jUivXbUf7Kj8QdQWQAQ+r7LXZqayXiA5unQuvMeKJKurpPwxZ27RCtzWRVg9TTu5jyDcf/J+uq+/pCeOaZKlV74+HOWg4J3liU7rlFWXhZJPp7541m+Bow3I1WUy1kTxqQdpRL2XZX/UCMRgq5ZenOBzXtIeNyRpuR77dpIb5XnrwQq4XxhNHBd16ARSj9ut5tcl9g/gPLGpWiEGW5ovaFUKIYi3uV9b5IWjwXfWC8SFeSyLnLuNUnBHRiKRe2J3WKyhPHfTBLZZVHCLPt6QV0qCBVCq0LWMfwijPNjnsyYcl0uACb5p870OykeWVLsWoRPi2AzO2KMzwt+xen9y7IMc2MOOHnuenrnTD9tHQ70z76nbAA5rp+3sAI7twHlg0sYy/iYlqr4ygKqCzo3lCq8odHkMCbTJa3PS1Q+lRfTnGTHKaKKIZUimews8xyR44SrNTkKAGrqY+st0sklg5M5CpFdM7kxZKeCZV3VGJAkGBSRKroJ3AtADb2HhFAAUBf8yfkfZrBGseletzzRW0Nd45ye5yKvVWunte/MOSavt/m6fnvgt4TvC5ySBLgAo2Hf7/j09dcoyx2X6xX4+BFEjNY29PWG6wvhqw8FH6ngJz9lrJfjGafT/4+ufKlPf1d9/j7v+bbP/rbM4yx/z9/Jb/LPJjeNMnH+i2BGM2ey9VxalyihezPnBwaRRlvbd3z48IJvvvka23ZP+H04+HLv4NLQd8Z921U2E71I07OV9HwTA8XqRoijRJzameSXfM2xvd6VF0/8gT+nHJTqV+SM0xd1ow3BF7mx6rLgxz/6Ef62N9z6KwiaklINkE3fo9KnRoEjbNuukfDDMaM3Oeurxjwuyi8WaAp1m0s927piAxbh2PoLYMADjgMFd76OcYrzrWhkG+eni0VQPefUn+Xbl6fBzLM8y7M8y7M8i5ZlqSiFsPXmRiGFRJJsbVeG6iKeXZBrwow1tL5j3zds2x3bLgC4M5ClAlQVuIcLoERQA5lQAlvoZFHqGmA0Mj6cFStJmDRA7S0W2gRd815+VERYbgpwjICx+jk5I+ugIAAM3p2kuU0TMILISWrAH/fu4VJnkGQGBQfwGcGMGlAxGg8Eq04UIoiBkTGeBhaUVA+BSMBEkAF1FtUiwAWxWbJ5FoMZKkU90TnARQ7jmKWu87RI+0qNfMsJeMqfB6DCrhlgx5HmZL4/Ay+t7YIXk8DLliqAWXNwq4JQ6mZUqlr/POdj+3N0lFmRcgawvAWEzV/NfZmVHV4/QYDecvSm+9K7Z5BvHvu5zOvyrE3n71RAMhn0AGNqhRloNiE2vo86Z0+Ceawtt3u82+rLe5HFs5bVS4VHAS23bTYoMu8MKgVFDWbkvlAc2frM+YhzyqEYH4ZFlTEA3wDpPA69R2oFA8rt82ywJevaNQ7xPgOMu9IgrnKLC7E6P5SBfPnscMYw9GG0drpfpzKMJ5lORRQ23d6VQJSAXUxBrDQFXZU5auhjbSJ2YFHOoFCFuUexCfZEboRCts5SO9G7KPJO1lgGSjPdzmDpvK7ntR/KJt3fAGpKseQ+5hx7h0iN/QzIfgMfyIrbWG/wcetmMLPvuF6vWOoFe3mfcvKs2HyFb3xAZl8C8Qwwm7tD+eehscwI+apZgD//fQHEs+cfAWLvr3GikwdV7bEcxqYyfvSHn1GXipefXcFYYEYZm/Jl4mEXaSbkvM8RYPhwhrGvO20rw6ML9N6wdQtfTRpqmWGplEyZlte8NHxUGnVoFDjz3rU9qG0gtvVuCgf2yRzOY44w0c5DUoxWIQHrqtLv63XVdGYdpez4/HmHg7QUBsK1FlC5oBTZ0/d7caMj24fbZuf/DovsZ7SwZ15PeQyfReWlivOMHLtk4uFiRasiVJ83+vVoFZLS786yC4t5Z6bbg27ZMzbHI+2S246K4Pkcy7yq0LPmiuhSCIsaNu7qXciAKvukEXKOjeYJZzzXzCfbmOdn3qS7D8p77gHGM/DsmdOzjy2FWZSs0Le/w4BG5mVZK66XC/7z3/w1iFijzND4Ls6xuOK8e29/cl1H5Z5eO6mKXCF+XA9m9DlHZrCx4M6ApghsvAOlYKeCjgquX+H/+9WvcWs7ynXHP/vjFZdlxZ/8B4KKmb+RckbTYzTH3zi5186otwpN99F0nYd9L5KbKZzVXO5w/gHAh9/7BvW6oXy8AfUjOlaUsqJ3oO2SWgAImayrw8BoYBK0m5vwiiInWdQRW1c2OGZcqaeyN8jOkLxohP4w8vodeT0meVJ44NHwPDF4B5oD5sFQ2XijvP5mucZ4vWyMEo4cBDPG9si2SrP1oDif22kPhMyK4XPmk2fZUb5j3z+2jx/JXUY7zJAmxKKQf5dlQVMDIGH1O0qRiCCSFrtDDESrp18qpaDfRTmY+2fnX2c7Y4SbkDMcYpRBBURVonyAYIaeoAVO3TnmytKnnkVltXtqWQ5jYfFq8725neIUI9/l6JxZZj3I9QSXBQBRNlq02lm+yfzMMTLceA4crpN9/9gZ5rwcnci84TCDIkKtsodqrailYmt3FIQRiq0bZhYHBB0/7up4U0XuyXtRzqdQo0nWrnDAKUWiNyzrisv14im25nPIUoS11kC63xScGXAu403t3ZY2aeYBJPqqrCGhLxpWmQkoXYyFbdFBZUgiACWwp5Ti3A1zdQzQO4BR3p735Cx/v3s2D2vG5jLjQeR7LfogfzN3bPuGz19/jbKsatAGUJX5vO07gAX3vuJSP+Lz1rH3OGPyyvshZKVn+fsp308e/WHLl9bVzD+Nsr9JUWN9uczmKMOn2vHV7/016FLx8uObO/UCRYwn1VHDIpzcbq9gZnesBGRvdZd95dCXSC2y38yRrS5LSlMnRizkMqsYuGV5KJczw1AzmLH+Bf8Qn4UGS/29SQSts9J7B6lz6bpUvHy44Hb7jG27AyqPkUetJkggNelrqSKzd+6uMxG5owjNV2xRnFECgzY5gVXmJJCzbrPMYmNyFl3clkHGEQyHNBqYMVBmiagj58N3x6+eZSxPg5lneZZneZZneRYtEsK0aShaC69HpodQJlCstS33da0FW9vRWxsUM0O4VZgQngBsiAwrIJwoYUxIteLA5AEoT4CVA8qnkGUC+c/LQ4BCwRLPHaxCsHknjYCLttuVHvBnRlBQ2n00YsgA4/H7txTO8n146o0gmoyCM+SJWR34b4xhhiMtk/TfWmIKI4D8HgEZAlyoJfc1vM4MADYFqs1/SEAhIondQp/6Z4qOoyhPpjVKY3cGVFhIZTMCEOHAvAdjnLIXLhFpNBobu5IUVHFPBtDOwD5/71Qeza0M/7mxwaM+ZkWh3XcG1B2UXXh7j5y379i2GUR6BO56/6Z7Z7Apv2cGheXeEWDObcifs9pNns/gVBpLNawh1pDOCXQFLILP6OHpbSzm7RH0wpo1Al9v988AV6nHlIwkoDM97u8ZzZgBeC9Km+frEr0krxvCmMZGUzRx7I9TrVKiZ6OQi2HsTNAFZG9aCHSPGmXjl+ox/aSEnhXlv9FcM7rM4xp/RwPnfWFjwj089hhmQDXSz9mU4QCy57FKRlbzMzYmI9iblDqwVAsRnldSOEnKFjFOZOzTnB/NTPBwHRglZfUcb31D7w21LljqBYW+r8EMXLnHSeE3tA3HJZSVgPF3+n1iLBOnx9i3+e9HbR25jrGuuRxBu+O7aLqfzm727+OOWb049m9+bwCK9dLx+//j13j50RULXcAscydecBL5b4wgk88CXfvpO6+ZJ8OxswHQTWl7MBvM5G0mZ+lRadLajj1FuKGiquDMg/mekZ6XIlF0xKBMvjAFkbSjuOedPcfM6MRgYvVs1n1XCbQDe7tLPwqBWWk5RRo6o1k5epTRBgFiAeaKygyQ5pEfVrwBisXbaYYrw3nKANxwJgz6zGAXfqblVaG8x4Ee+AfnyYNnhp8D71XsSH+zQdRoCDHzRTImGp3CIliAcbvfwCwGMza9JeffS/NvdWRaG+M+rSeCz+vcjkef31Pmc8yLbYmJt8ptnp8XQwB4mor8va2trOTn3rFzRyExBljXimU5gswegcjA6Qe846O5Gvi16d75/sPY6M9oyH80nsntYGZoph+Q7ksGi7EEEZgLUK543Vd8hQX/xT99xR/982/wk5cf4c/+04J9ezyPX6L57ylnih05xYymn3sPE/BFYxm/93BfrP+itZu+ptP43HxOWpt/9s9/icvv/i1e7wWtfwDVFeBFbJF7g1Elk7EsmgpU8TPLt+aEsG3bKENB6KpE6XrjbEjdGnhUfIHuJLpY0jqylKREsUadZ0rniKViul6vA48NjGvZo/X5ek9Um1mj+DVjm7Uv4dF8aPaDdc/Td/P98/iM35tx6/E7c27KGMW6XrA3Ne6ARBcRA5iCtgvdLCTpz0gjrkmExjCEsLVhRpMxRjpu5sVNgt20ztCANdrmqpGNCnq3CHESVaZ12T0mSZghiq0961sejyxbzaTIUgvmOQ45XMavFAz1W51moGPf2ViY4c9cXA6tVdeGya7OKcHP+pNnrW/eR92LMddHefBYdJ368KgsqwYhJtuWIkYypRZPd31dXpTnF/5u3j80XYfKYmYkQwQ3qAII27Y5LyC8WRhTuaFzCZnacJz5nLZ1wyz7Hel8bMmgz+bWrtmctdY8IoykALNICbEuun5nYyZ9jRGd11AebaFDsT7muczXhvP7W/BXIx14+wwJ/lrmuncAvWG7vaKyGPi9FgYtQF1WMRAoCzqt4Fpw21/ReaJPU5/zd8/yD6c8mq95RX2feX3v+jhbV2cytPExJUWNab6+53ryp3MJuSw7fv7f/kd89ZOv0PcLfvU3RrvjfLc3ff3118i0S+gXe+1QuU0MDxcs6wLmorx8R9VoMtaxQmow43TgePaf4aTDPSRYx3DYJfnIZUQ2zCDqqiojAuJURRqtpteCZV2wrhI9rreuPBy0jfajCBSLcRE02t6i6XMl/SJUPqf0W68luc2cckoh7PsRf3uE2cXaCL4jaOmRx9IjbzCofJYfpjwNZp7lWZ7lWZ7lWbTcb3e8vt6w7y3AEBVsl3XB9eUK5oZPn77B7XbT/McAwLjfX3F7/YztfkffdxTSXNWWOqh3TVsSAiqqKTKE4RRr6cWBmmxekaO2ABlImz3rsyJB7pkjyTCPVuRnhQBQIdRKHq5aQIEF1+sVgBiWtC6hW+U7Asi8clX5g4jaIgD3EbRbFot+kAT7E8OBDFodo3GMAIsoEuBAhiuTEMYxDgqla6P3lABR23aDKetbM4MBURKRKq+Y1cobIlgYSKFIg7RDhRyJIqSAqYMMHeCConnpt715X0w5IGBtGHeIkg/OuGeA9eApz5FKy/rG3PH6+uqebbUWdBalhAEj5lVpc1iYIupDmgtbZ/l6nuO3AJMzYI2IUJfF2z4rvc+UQCSdAmPMt57HIN/roPh3yPU6j63VZ3O27/twn69fhMx3NkcHkDnVxwwsdfFx6T3WKqtWIY+31VUPglN4cYTXexEFJ3fN1X4M6W5eclmR4AZ0IPU8aYc+zOlOpH0ZCI85tPuXZXUBUcDcBeYNbEJhfo8pNfIcnO1zK1mYJIjSYN93ByAlZHlT5XGsj9ZS9LEzj3FAU1uNHpyZNuU9sywS7n3bNp+Hsq5Ya5Vcxxr1pyi03rhHyNkOvL5+9pDfOaLLPKaZJhARLssa649NkSlKofBWYdRSPJy4pc/L9WdwPc9JptFnQID1fV6r/pysUuuERwNalqoGRbKIhLY3b88jWmL9P6y11hQ839H7BuaG6+WKy3rF7Tt46GQlPg2/yX9nI4Iz4Mx+B3im5xZGY5nHbUBSa561L95vd8XdJ0oObfWjd+U3nd2V3wEAbEZoB2UpDyox9jztUU+oaqMXDICp4vryB6BS0HkFYQFKGEDntZj7SBSGzJlOEZGyJDHS3kfjYXQf5YhYXY37QuEaEWwAuIFqXu/3bUNn8eIVpZWkZDFlC+v+lPSbunfWi58lpPsjvIqBy+Wi3uo79r2j7bsYeTMDVQyZb/fPsJRMt9sd2/Yq9AcVe+vge8ftJmNgYFxdFgUXQ5kjvGHRCI3ikc3MwL6h8y4DTHaOhCec0B09s3VeGB17kzSnxvcKjxu/ncfKoCIRmGigBYXgUVtM4ePKRDWSoj4qo63KoNGRKkjeU1BKpB2038afPTIS7P2O1u/SLj1ri9LWj199BIjQ2khfSaNb5neNdY7e/mJEONLTHFEm99/6+J4ygrLBr/QmkTnme07Bb8QZzQC4LskwNt4zR8MopeC+bdj3O7ht2NXwrTUzTrN+zeNjuTVC6TvzgDYXZ3074zdHAHrkIUE0hE23/VuKGdibPETgnAK0k+DpRSPFlY5OjFoqWi+43wkvP/4DbLhh2wo+3Tp++Yuv0dpPcUarf1Pl0Xkxt4AAP6POns/38WkN0PilZpIh31eIiPhoxXJqVa8v4IVBvYDaBaBFaag4unAXJYopWoHgs2sBlkoeXVAivVa0nXA3rqQ359WEf532e1JIS+rl/B7rvfQ0RnE8r+W2cY2Zkn5dL6hVUg4Jv33khe3+/DPTpngmjBF77552b2+7pCAqkv7KovERlAZ6NKcHczLTQd0js3yQz8IZr7CUyGAzOuwH+vL/s/cuPbIkS3rYZ+4emVWnHzNXHI5IiQAhYQgtBEICBS20EvTzBW20EgRoIUGAJJIYzu17u8+pygh3Ny3MzM3cM7L6dN++mCGZflCnsiIjPPxpz8/NDOxhMuj3338vMitEd+XuTiTbi701UBa9qhRJu3C5bNi2C5gZ7+/vOA7no4A44O1UPWAHCGSvMwi9ESgTmDJyvqCUC0AZzSLPUUGmDWBGq03sAQnT+olplE3HmudqsISJVx17HZHvpK0O2rDIKg0u40RZ295rdLfWquCLPuSLnPO4bn+nlPC+x0hzBqjwtq1r4UwfiPKZzX3UH871LNIoBy55EimQKPl+fnm5IqUiBwxax2XL+Oa7b1FbQ9WIg1FPa60BVEW+MN1a27ltBWY2izrScVTIgY7AJ6yPlNUWROhsECkZIAbQTPZkk9n1wMS2DV7uOrDvi9473t7eAEDXOnDbD7TOqNJgJJX/Wm0KqPIUtMyMpMsvyj/RxhZlmlgMiGdrwVJDRZuLOaSj3vmorHM75PQY2ZqchtozrELkZCNioOGGBMbtuGE/PqNix/X1O7y8foeX6zeSDjN33BoNoNl4990q89+/3Er0LP/QyrnE8evr+iXXP/7etXr7ZLJUhx50CPrupMPaT5C7hv2AMi6XF1RkADuAhGNvsEjwKSVQyvjhhx/x7bffwGzCOReNfJ9FjzJeywxKhLIVJNqQNU2v7fPWO7h3bBepV6JOy+GmM9vmma1qAp0zUFuw28D2vug+YEkjbMDzzl3bndBBaJ0lGippyuPe8P23r3h9ecWx79hv72KDRwej6bCaXtUBOlTeSXh93VCKRFqth8iJTNnTL7HPRSJgyxsoSWRCUEIuBfXYh/xgYxB1i6h3DHmOm0aBdRubRJxx4LTrgRkvOU0667P86eUJmHmWZ3mWZ3mWZ9EiEUSSgDo6NIQ7i4MyMUrJOI46osjEcM61inGpi3VG6irq3EYWB6r+YzIojPzIiagNzB2327vm5cYA11haDcAAGw5ISdlSBK2nbQhE9wpmPMkEfGw0j8YVc+SklHAcVetU41dyV5aBOGQ8ZSy7gkysX14MuGFGIG/LGcjnrETHhiv90HzbUq+EZp2j0MRnbXysn/H7ehy43XZcLnkAgRJJbup6NF8jw53npuSck0f+H3UGgxcMCGUnHLsYgRBPqloKGj/BlVJwwEMMFRHEYm1fDVT+vcxR6xau2/Kwa8j+LkZ7Gxc7YS5OdemvheKc77mfpyj4PyqrQWb0m9vJ9cVJtjiAeJnXR++IShkmI/avK2Zsi4a+9XsxoAG26CdDz0n/5ucx5gxHHU4ic9YM47/1RfdVb3IyQl7t4bmlTj/tZv2XNcZAng3ZkRacGryhin0XhTqrUuunDinQCqcR4ktlbbL8a63p+hMDbOeOVv0kva31dX2b4c6AL1YMQDe1d+nHCHc+Tg5KKpeU0/QOm8szp+ioH4/34GoAdiOjuIhM0V3XUAQqxfquLy/BOX8f3v5+Hd2f5rHPa7/WdUm0AI3CO1cA09e0I9YR6YdFiTADkRg61NkDGnZUUifIcSgPAHlak3VOyJ3Ho20AEE6X230lF2QFLfySQmeflnQTw60XtjlP33gNdtLMEtDYdVo+z2+4b8+omcnBKtN9VoO35GzWPjIE0nSPn187axnf3e/PWPvG9QCusefSaDPjL/6Ln/C7v6koL/8IKAWMAkEiQ0+PBfBrl9NkBjQcvQ9rP3ZyNe6d0eb7MPvxHnN2tCGfRadgdDLYWhbHlLVbZZDacLlcp1RGKWUxQkLkmq7yjewBQs6bgA6RAK4yfsxglihKDEZrdqJQo9zUim0TpyJ3RuWOelTkvHm4bTawjLTEAUYGMOfhhMglA2wOMR9v8H2agdnxZbOMwd8S+Ur39RNCeQvjX/h8ggGWZhlF9jx3QqY8jLBmiLX2uGzk8o+AQo9xv/1Eumj9itFSahVQHhFwuVyHQ45tDUFJkLHxhT6uxcY9At9lfu/TOsbxjTzsI/ocy3pvnLeVH5x9HrJqAJS0lGGnU42vxLDjUonUI/y/oh47jv0dLy8vkGg9xtNjGqZYzvl1HJ8IKJruDbpCHDOrd34TjVfHdezvBUgjNXVmpEV2GDoBYzjQW28AJ+RtQ06bgHSxIacX1P7loWNvpUS/tZNv8C8Iv/ComXR6n32e+A5bpDVCJx58buYdkqouweIjWqS2udg7Xv/qHf/pf/N7UL6APjUcPaF21cd6F32+d4kwEwB8sb7TdRD0NgBDNrP1dp/VmO8YPA9XeHyPybw59Gpe+6VkiYpgfJQ8iqOI/A4TMjsEs0dCvV5fQESSegAYgHc7TGL9svakJPXs+47WDnRNxVRKESBor+h9AZCe0I8o+006IjmQwPUuf8ZKpCkCkOfh5F/rtD18uVxGHdu24f395rq96rTMrIeSdKtlSaNgoGsOoIJVR5Mob4tcoyAJ1VQUeFPAZFFqSO01GWUTKc51+KQHE8Lf6Tyab1w3vTO2jZRHBB08Of+yNWBjI0BK+W49dW5g35F6SgFTzIxiNiLt9XEcCipbZJcwdzE98Jm+tOoJJrdn5Qdxftd71yKyi33XgZH6Q6601lFrQ04As0TSSylh33dQcCqabnVmwxjzj/lA0OBjreFyuUxga5u7lCWyTQpjy8IM7vQjiwDksgpk/bUmTmgEfc32lr6ftO7bvo/+2P2sBELmP67dwbDuZIBVJ468m5lRex0yrPE556UGCA82oxN5ZC33PHYpFj2O7g89rO/g3sGtg6kDLaG3ilp3pYtFHPmUALKDeo+55AllfpZn+cUlyk3n35uM4P+bVGRptpm8nvnOcx1bPpgNDai1oTcBcFxePiHlpGAOxnfffacpi/2wsOnNrAIqU0e+bENPBRhoK/3viCoYqd42DtAu9DwCO+7sTRC6bbbV1SYmurxHUUuJkKkAYZykfuG7yYDQvSPlhO1yAXNDO+ygnLB9Sb+k0QSJUMo2IrKKTdN4QMaIyLzQ0d55yG9EwO12BL+RHzhZx+SORprcGQ4QyP02R0b/zHblkWW/Rrd7lq8rT8DMszzLszzLszyLlkQFhAICj3Dhko1G8ce966mrQwRN7nJirVX0Vt1Bo6htpA2gDaAC7hphxJDibEZ5Ck7SxSCEYbdxwRWLwQhZxephaZfP5EY9sCvbZ47MM2WWR3hzET0Nja7fwhxY8p0o/DzageH8RnAeyLujUCx3Mrp3EnqqL7ZH/VjmRHIAkTsI4CMmc5nSEKhbb8jaRh+/aNDzqC2zMceNaDLWBO4JTAmEIg6i4XyrIpQnddjp0K3qjHQ5IZGegCYZ69p6yP5CotTr6HM346rPp42xzBU0yg/PEYfCsBAWdD/MsFPc6Mmk89hHGjKbdw9bDgXvnCtAj4T0R8aS1TkfDTmd59ROY93G9RqMxtYvMXDxMOi68hjM8ZouwvJ7m6Etul1sfZK1a+ybAE5bnDBxL93vqaA2swGg5n6b8jd6E5Qh61vrHsXFHKaAT3dYINI3mNKqIZlDyjE3oGlf9dSoGfbujGl2c3Qk2bWUIGmd5FobocyVPoQ17K4KyYdsTjPpZx+nG0GWKi8Y7myiQlcjCIUoaWhq6BrOAM3r9cwYGyO0GL05Awl97ZoHcJciJD5v80HaZjF6x4hIp7Oqxj5Rojczsk/gJ3OEzGtw3f9do5hFp3TOWaLqjHQqDpRz58p9X87GITqhrW2+bbU+JxLsKqAAACAASURBVJKhqFEZDhyaokCFPS1zqe8AlNY55+Ixvr4HuPcBZGRLp8cEsOThzmmTMO6/wEpqqzq+W77gCTQzPjHCDlAeRKGuAZYZMdqm9BWxafo0TgZS7x3U8IO2A9HJ1wl3zzyqff3LQaM82vdRDWvLoxwxKCZ5G+P3l28I3/x1RtkuqDWBOIPY1pykkpDQyh0D4KwpNycRg13mGbKLrREVTSSEv/dj7IthtIsRlrzeMaZd1mHOWSIPhtD9fYyPE/P4bNY0HLaPSi5IpGPBAKEBXVaLgP4u2BQww5zQ+UDqDVCgga99W3SMXFTmBdTBKOMsW2faVd7OwSzjjJuslpS98nCY+54eg363HsiiyMBoSArX0uB7DiDiISdZC2fuNn92sYhHFJp1Lax01GT23uVdCUEeGe1WpxEwHLEGwCQSwAyYkShrygS2WQBPLdXhZv+8DhMpD5TTmwZOtXSeBu5ZwUiPPz8qq1zST6M18cRHKDzX2VIzyrvMaZ6TgRvNLWD7UWRMofeETiSnNbcCcMWxOwDO9pn0f57xkfrxBCAY+7+Owbj2yIAN60uUB2QETN6Uixj80x6ZeKdWq9oFTFtDZ5iOSMzIqagstAH0InIV+f6L//unwB/h6/23KkGKBY21a8AWvYe8DZFek/7Xx2loHnT27j2MsC8+LuUKvP7jBlDD+41RD0LvJkAazVF+wB3iLDWnzMwLYum9TaBIP2Bhbfx6x4TRFXv27JW+3ggCyMhj/zsowtIG82h/lI8NQGZO7uMwGgp4qoFAxwdQxNJPVU0P2r0tcF1j7Lcho973ITqD5JqBusn3ik68OcSGzjHqALiaA154Uu8NJWfnfV1TZwenVaKEeryDctaT8h31cPC+ybHCKxUEoECi3rtENiTAIsU2ZjATBLsj7Re9eBv8Eiz0LOci60qd8qJXGq1QSqfkhRB0o7C+Vv1x6AoaFSmpLjjkEcLUfxtve5etFeNHVt8AGLBHdrH1LSkdwnuVzqZgBxJ+K/1yvdz78kgfuAeLwIjo1K5Vz5rrkrlIYU9AI8z42paoupzk5H0ust6OeuCSLgpGw4gGa+MT208QwGYK369AjXhtHDBLCpQJct7YS+Q8IGrClHQM4JFtOlT/tb0Ux4UIDQDbutV5alXkW2iEUnM+dx03GmuGhN3amOvCTGHcSVB0Q5cSPdCAVyZ32AE8kmiGzeRrk5TO6eNHIBnT2+6Zw8rRgrwEbTsb/2dAD+y1WtFbU5te0YMwGUB72L6pPT97x7P8+1Iea8p//nLK8/V/k5P8CCabJgrA5CH9/EF98XvoARKLQNpqgwEUCYSq++R6veLtTYBwdvDM5BXb8yVvuGybRhJ1HmLR5z3lrLTASfc5YM70pandUWaIdMH0xdDvRDTSl5uOKPKE6hxBB0MyecgiZ5scJqOdk8mCHdHmD3gULnkesAixKWU5/JyS0lSlzUntLRRnS0G/cP+GZTBY7XT3JUaydD4KWDR/obPWv5hS9Fl+m/IEzDzLszzLszzLs1jpJElDOSNpHmsQgxQpfNQD+7GjtiqAmV7R24F63FBv72j1BkYH5YRUNjBtaCgAWwh3BqiqUizC0nyKiINBA5jlndkIMQwwbCFfJUKJGHOCCZZJjT3u+LXTLo8ANFK/nyQysdxTLQWnkhnRiOD+fzdep0QoZTYuu5KrAmC33pkDp6uhUOqw8bCEDdwZHQ3RQDScXfYeyIkw6V8HKCjGqshHQ1YEEBioRwRnOWFXSgGooHcxSEoYxqxtrmF+spsDSX0eQ26OYwAVfm082N+vblIi0tOQ4iwd1dgaCOvCxp0tibfWZEYZe87nORrWQuEU2jtqMRfBeKvN3xko5NGaWsvZs5PChHm9D2c3852iNeq03/HkMwgwA6I6YuxGc7INZcfeycGQ79ZxjHGz+X7Qp0fKCg+t98SANo2tGmfViBjDkQ/ztRp0oWtdJmlWpS10p1zSgNCpyFhwBwbgRkBcyF3GwKz0cWwWA5e9qbM5eQBOCnQg+WyKK8gUfh1vVVDBXaeG0bmp4Vn7QcAAVOheofF5XmNjyer8iv3V5hNKTzyalIFiKBDaXIoY1cY6nI19K+BmLdEQjQfzb4bQO7PfMIIqLbM1Ye0MdMLAkaZoyxoRcCfch+x7m3Xd69oBi5N2DKjNK8K+UbpBJBEiHMBzzjN+zvg5naAanTeaKY4pWyfeJx570cfe67SBlHFLegKrLwYI6WsaIQPUWdTFic98gLlCsAQX5HxFwQVbol8BmPm67yO1lxba+Bstd0prHMHC/X5NOaO6j0Azg+uEd9qO6nerdG7/x9fur/DYkedt9p+5pdYegiyRlDq++6eSiuzT7woSb0DbFCNMQlO4Q6GfYG66Ltrk8LfSO8DdmLUBMpzGOylcaH7grXbBIsIBUIeOORYsShRGtBZb5zmVsTdY920EiVAmbNtlRL4CJDVfKRuOekj0LWgO9uQ52iV1RwGlqttNHCjJxlhpnQ1szgoCtr3NjIzie1v/2Qn8lMQ4mHL2/RwcMD6xNJw0Rn+Mt5zzyQQjd24MJYANNCMSUhx70rkmIqXpGHMoTVPZAYCnCzXAkd9jAMcxH1AZYWxaGjKB0fkopzDUEWWG1MEnCAniPCtpw16b0mgavWGGRp+0J+Jp6rDuBuk2o6jzfgNknZVHzv1pDniWuey3GMb5/rvklM1HQEedHewKBnJOIqokMcqXrQC6L3rXVJC6Xy392JYzXq4XAAW1EFhPt7dmS8jBacabXFdYZa37Pj8y5PNyX7yHgsw2P8sYiV9tTdmaJFkLDEurSKAuodZbYWSGyvg00i8Sy4GK3oCUNjARGgi0Af/sn7/j//u/M96+nMnBM7U/p+J/WjmTYWaudk/Pne8pQJqBDofcxNZHXunXH/VCdNzWCmoD6pHAXekwK23SPd81tQ4N+XeWuQGPCCYylgHMLfKJzycQ99S8h+7GK1wba4bnuZvW0yJzm9wvdTmQZYAPIbQ/06ZOIkmbRErXXZ5S+TK2iTs6H2A9ENT6EYBB1i/RE9IQMJOc+BgglHMwurff0gs6uM1IhwFhnMiGMVHVhiDmmaygfLK+tCbgBNI0zJ0V7A1pW9LoF9lkeRpjaWCL1rqkl2M5jBATZTHErrFXif4qenkeB6KER8u9U3q2kYpa+LKQhDkq65lefsYP43cCyAzyC5l84uvQ5XOo3NGH3BGBlFZ3jB5iEYXG4YWuu5MZxSLNse4DJDsjAe4NHYx8Qo7ObAE/x4viOMS1Ne5DckAP9xEpz6KO0RgXAcflnJCT20eM769pWolopLcd0T85CS0eaTKlHSu4ycYxD6CMrnmVTkBJ1rMycNNlYfRjfGY9fCLr19aw0VOC7HUmSe0o0cgYCRmdNaUXA6Ck6ZhZtitLapca9THTOa3uMDZI0m+bpR50UeY2xticyCnL2my9IuVNarToybJD7tbA2dyPz0GEfFxMJ1SerLtRZFQGGrC/31AbIacf0Q6AX19xoSvKb84Vn+Xfl/L3MfOLlACMv11+7oDI8YxJW/b7ePn0QSFCyVcce8f72w37TVL/buXi+obqEkLLLMqVAzHczCV6xXZRkKimRBqp0EckZuHRQhfcXhNtZqts4M11u1L8PtJdMt+D1cf+7Eg7CeNPGPeSgkmIgH2/Yd9veHv7jON2A3pH0vTbSdPgGpilhWjVWSOxd+WJErnabYWDdurYWWTs2g40VhBhiiAf6/9HMxllQr17iQxuUQfTAOl66uNn+W3KEzDzLM/yLM/yLM+ipR4VrXY1eKpinBhlKyiJsO/vuN1uYuBtB7je0OqOut+wv3/Gsb8jZULZNpTLFUwFtWcQBNSSM9BYwt1yTyAqQ9hhMFLKuF6vYOYRll+MdkBUDAEVdJHQu50sEu1VQsjL6Q7mrg6AOUSffXYkOS8GDEbOhLJdhiHlOCpqVQMCZVH+DdWtdVrYVPG/0GS8N+MEkaf/sXeVkvUkX0z7IvV6CGA36HTLRT8MSQHYowbSIU6ShreFpCGw0P4i2qqQCcn1KgAEcw5r9CB0bFtBzhvAGb0lyAF1DWHNcnLY0OeirIszNpWMDo18oMgZZkkVMWwjGoZX+uHnMOM/E7C7noQaRSwX0yVz/ESlxObY0ygFo92p8rJGubBrqhisofOBEUXI6o3r7AxssRrGxHDZ/B4z8IVT0rGOCfA16lEVc5ymNEOdO9381HUwmKkhOI1x8hNnY4wXY46dJJ+nY3bCnBkJbY4I52MQT6K5wb7jqMcInS3gLXVE0FCzF21c9qPsI0+XAWSkJH1kEJj66I8ozKpFs58q833kaSRWcFPvXc5qqQEOBFBOo0mmQNozSS29xEDK8oDlRd+2DR7+XL5PevIvOm9nw7Clm4vrS0+0soFfdFyIRpofu5eIJOoDEUhP44gC7DQz3hsNzPE6YCdy7kOtTus3rA0OH+Qyq9FhXk+jHa2pE0cQMnHN9NB/cwhIRKimlFndV8yaIo/C2LUR1YmSG4BtXlLKHqZ94RlnqS28W27ch+5Ls50ara09noD1d+pNoy5zNBAga5R9bDvEGdlZorpko1OMEZVJBlnpIDOYK5jV0dIKcnpBpk2dMPiqQg8+n997DxmxWYkRXoax59R16OXMCPc17Tx71t9pX9ppN76r4Qx+M3N1u3JuDBKRRmlU+NvhYOfPEBi4NPyT//Zv8c133wP0PTq/gltWJ1oDuCFRB6hrXxoGaAZqSIc5D+PeDgZ9IgjINjYg9NrWId2PoANj7YSb1LvvtyHDibNPHHUGTGZtk50Sc8Ab4Xq9TmknxLFzAb9BgHIg5GvW95WRDnTLCXmTvhNJ5DgCgXtDRUz9lgbAw0++Ke3rHo2KkUYqR0puyDRQdlMQjkTO0lP56oG0tRx53znoLvBE+8eemGzsCZ+KIdeIM2pZMQqUWd8ne66BE999R0QjN72UpDIJDZrIcHBMtzEavDTIXb2jVQFJlG3DVq7gviNRVxCFOvuY3UE5Biq0KbTb+YnSYRhYxt8LeOqm9cf6eGZUPZNjLE1HCnMeHYb3OgSm6713BQtJ6rHr9aJpaKXuSOuNP6aUUHLC6+sLiBj1KCiF8OXLm+phmvpBxTOT+URONd48G+3P+nl6jeZrq6yG9VmVlXk8a/MCnRfxmlskAAMJlXIgtSyyEoujPVESYALJ2nWgjayHcu34l//qB3z58WUAZu5p+3DHDzr/53IS+Rv0L4rXofTcNRuO90VdzTkhTNUlnjDAU6Hwf2/A+xvjfT+Q0hWARRrT1AGsEVC1EjlgsswpXI5kTQcrB1okGkHrGWm/XzMTYGZEOlpbanqIySSyYO3ZOR0Zzffa1bCubK0f6tDZtg1bKcjAOOBhMlnOktLL7ARrupTWKlq9oXWNLtMiZAQQsIwARWx8LJJpxywDxvSgMWKHzb4Mu6xxSgRK4kSiLifUowTADOQtI7FEuegkADpJf92kvpSwFZHXGsR5V4+KnLKmZhVnXs4WHSWkKaKk0S270tyEo2qKm6ingPB+O1RHKMj5og62AoYAf3Jyhx0pMRq9JqFBtTfUprYCtf303jUiiNwnqaTntL5uN0mTnhzXxxzF152hbvMRPfc4jrGubY3YASp7p6UYGtFLk9CtMiJwKo9GQiYZd0v52HX+jA/Ne2TmKROvGLz8/rkzPUr2UFK71IHtImN5HLvaa4rqLIRSMi7bBkoJx7Hj+vrN4DtRfzObmK1Z+761BmKP8hfbb/faHJVS8PLyIhGLukY10kMrMSVk3NNmYmBOCo4ZnUcqhKy2r5GWBAAxoUPkDqislVNGhrRTSkdLlhZM5KLeBQTl6QyhkW14Wl8jog1m+igO5YT9eAcRdLwSat1xyZLipPeKUq5jXRkAlkjTffI9UCnajlY75T1QctWL7+ltbwxQBzfG/uUdlBuOW8eX6xv2b79F6d/h20/5z8YTn+VZvq5EKcZkJZjVOKQftrtnSe5E+5zu3bYXfPn8BX/8w2fc3m/IKaGUCwDy1NcM7Ps+nrOU5jlvkPRDBaVk8YMUOSRaq8oN7UDvmrY3C50zmiCg3RgBZqbjq81oov1BR0lqmxNaK+D7pEjapkBXKgmUDcziI2PglUQWiZjx9vaOH3/8A97fPwvglhJyKkNuIhgwl/GuPCAeVhG6pvPEQK8V23aB+CiA3qsCiTpq21HroVH7+mjHmf47Cs+zKJHxGjJJ24yvkKZ+TEkOz6Thi/HxfJbfpjwBM8/yLM/yLM/yLFoOzWVJKauynSRaTFLhrEs6Jmh452aRZmCn1boKLyp4pSDAJHUec4huEN6diEBZBC47iQw2pRFwIZmCIingGHuHRSXxsyiAhAT2cL0jdOtS5hQ7fl2ecePa6iCKxoOYbz3W6/XMgqe1W1IBmKA3h7y2Pwx401qT/MRjTNzISDAnk1thLcKGOdKlOnHCjP7izLhjjhczMLozR/qFYdhnay/N7lADQqGNF4MAdHKlRyI/LKHzyQ0Hj5wa8f51Xh6DNWZXpAEw4nMydDO4Kn6fkoMXVidJNPSZQ2V1zoy1EiJ0xHvGu4JhJd5/qmAsZV3D63fRfeBKm4KZdH+chQq13zlntXLNxq+z+9d3m6MewfB3NtbeVj25CAdqWMhNe+bhmEzhjbw++W1KnzmY4oD5vlpBUL+kxPle1yjbHtW5XcEWcU2c9TUaKR304emm1vZaejVzNKyhteO6jWCYGKLb2mPPxrzK0Vkgyfe8X7EvH61fubfruN87cVZjg7RhHjf7bQ4BuX99EU3jakbhcdI/pfFj71vndG33GU+J9Gy9Fvtyt/9tzXQe4DzhD48dnqwRlsZYQVMs6i0CopF84L5mNO2X0QJipW/iyLmzw/6KwgAiMMQcg8G9aL35oBJzfUbKNUdrke8iPzxfZ+u3HFoQjXeRSs4GuyFZBM77+D0f9cvG5iOKvn7LADoxKG1ISSJPANmBekpTWE90iQG/362xlMWovqZ0tPVy6ixQB8BdX81BZknmlzKHqZ4BB713QE++2ViZodGi04ANCD2nnRv8oGQUKgMAbaUNZ2ESECI3tNrR6iF9tyAcjAnUMqLbAQMYAhBiuOecM8omdNCdsfe0+Yyun4E41hDSkYaLbMsQUeWjVbfMSZg3e//KF+LpxTP+a/T+rN57x47zZxunIUf0jjqcmuKkSiypWw1sc7d4Bt07lwvWv6O8uMqPZ31f+7Dy03jPOG0fxqq1hlrr9E57h/GSbdsGH4zjEfnttm0opYgjXIGSM//PuF43pNcXXC4bfvrpswJ4gJJTuHeet5mK3ZdTudPG8he40ljlOVbZmWh5J/t9lhbGxqC1Jilju5/IdTZodMwiBAor6QC+vDUHB5+0aabTfx7QzEqZg4Z69338bO2QgGA89GKTRqPjpxtfX67PXEmcCG/vO257R8kJQEdnOQQB01+7vmesbz7dO1H2zwOoDXUM2SETiYLqzz4aJJ20s6+CjHm2N2PbpL0zQAJw/TbnjJwyuDktXvV9T/3ch1OstYrjOFCPfUSxjLLj+t6h2w0dHHfvO+OdpisxEyhDnWu+v0vJqJXQuQ2e3DR6DCBpkdA7tst10Jyci4JI3W6yHwdAhJfXVzCA49jRueF6EdphY8cw+nWIE3DwJdlt0g+gU0dJRcdawai5KE+Yweqr3sGMwRtzzoM2rHTQbE2RT8VxjOtBTrW36ZrR40ib7yME3YNUjC7v+z7eZ7S4NQE59LbWM+thE29laDqKmX/PKfww1SN1T5c/1DWn9sc2dUZXvmHjJCmy2ce5dtxqxfXlEyyttPXb2lhKGUBOAM7fGOJYVb5u90cdMLadh2wHEFY9yiNV2fXVltO5ju9itJtlNFzHU6qbqUCzHsJTpIyNqrpfHvolK6I56r0fzYXwOnk38zwfNhbAvC58vczPnNmC1vH4ubLSSCI5/CYh2xI6aVqr2nDghg7CVgpq+yT64Ve95Vn+Qy5na+C3lJMevePn7mPIMc90ouvHe+NvuntTwpcvb/jp82cctSPlV5iqPGwBw+7Eo3bTL2tt2DRi6fUiUU47d7TeUOsSrTXIKdEeZgLfHY0Me/ZuHMgiXfnfbk98bHN1mxPNv4Ghe3W4ryfbIS2ewTw5F0ike9PTo61PDvhaijeDdLsOK/UcxzFkP6sj518DvQjjQwQ72ChyUxk6Igf7wqMI7M/y68oTMPMsz/Isz/Isz6Kl24lfVShF+SJwa9jbjve3Nxy3mzhhWsVRd7S6ox03MCpSBnIhDUtrp5tVjOUsAiaSOECCYdnCmRJ5dAsrq1JtDtneKxzQISdLvQ8NlMSYlvS0vhn67Gd1WowoN2QpWvzkp6GZLdqLCX2W83wIs312v8Vi74mno+x6u+2jLzGFgYVyTcToCiqx8O4YQBYV7kdqGavbIw1YtAQ7aUyWHwB+Uk+i8cT8pWKQMYN/ogzmrCfLJCoNdznlBpLczYSOUkQA7/CcpayGCmvbVkxR7+DeRClgxmEnotRgY0a7OWqGj6d+0r/t8+yAdmczRl/tnkcGrFjOBO81qsb6XFSizuqMBsEzwMGo58RY95ExRS730Vd713qiMkYvsvaKI8ONPWZAiut07V9U6GL7/L3nji1rHPsXD+8lAJSSRJ6CG/XNuGv5em2efRzkZFZKovhJCgNf7zknza3uJwuHYRMS4eRsXh8ZMy1yUzeVnW2vzk6dodBbG8mj/qzGSBuHe8fBapBlTcV0r7SO9qUApgNGff59Grnsrd6c83Ai2L3ReHl+el+dQCFaxepMWJ0yP1fi/avDmaj4fJPPsaRoig5XA/3JiVoiiai29s+c7qvhfSsejWadg59zts5rczaSRoeOOWCbtieXTQy7zLBoMm4Q8V9qix37cezN3sH6HnO8EGNaNylpZIgkPDMXRi5A1ihtf0oxLhP/Hm0eV22f8909fovzj9nxOeBu07WvaVcslsoGDIV6hVefPP9zxr+5f19XePltdZi7d3a+JuT0CYQriC4AsqZR0LRLvANdI/m1jlqP4SC0tdpqUyCwr5lIN4gQPnuPbf+frXFzhNjz4pTzvdp7Vfom99Vase87yuUCoqwiUEImkghHSUL7l1zQasOO2wB45JRx9IZEwHXb5ERfKcIPxumzBII5q1iAOLShJEJLDkwwp52k7jDgoTlPZV1EGmxOVeOZ4lQKUaqUFlhUjWmeA/2KY3tGS8Z12NjOcsD6d6YMvrtnfvcqQ0WZeHV4xnbZ50gnYx0RZOhGVgVCg9FbhYHse98woj82EVbEgZXGChI+HNfiXJid58UyA9+d16z0fO0jgEneWeWY6/Ua6Gaf5P6z8Yv03U7qmzM2qTwTIyK01vD+LhE84zzVWnEcO4AG7g1vb19wHBGkY+HfV0C18czHlCju4dh+Yac/Q8EYLtsjAdTB0QlpMicxmDrq0uasKW97bdhvN/SeUAoA6rhcrij5AkIBs4A/zH0CjYZB+S9ElvugicMh8mcEzYThOP18f49R9fvrBil1yXeub+ZLUs93f/P/gL75gr0zfvj9jpSvuPE7QAVEBZLEisczKdRPBAfkQuRsygkp53Fa96hV08DKuDOLM8WAEAPUuLitpt6tgsDZ2Az9TWmZgTPZI1lc1GF1HG28/+XlBebcyomwXTLMJmDrJiWRdWo9At0155ievs4ZxAlEzq+snt5Mj53bu+75KOfOfdN3pqTtY50XGkJbZ0ZvB8CaDkH5ZyK1lXSJYGl0tZSCy+U6xsvm4vXlBd9+9x0ulwt++vxZaCcx9v3Q6CrSvq1swy7Qu+j+IEhUog7dd0qTU8HLy6sCITdJoUhmo/C1vAJDEhEu20Xof+B5Bk6HRnuLDq4aUkCcORiN96662aof2HPOV+U+iypp7RA+nafodTVGsiVgIjS6bMj+KcivkIKKcpp0Sg7rN66H2T5AakaZZQF7Kfe+rD2NOpIsfRQJmK0kbJdPIvcQ8OnTK3rHoOkpSaSC/fauQGJJMWK6K7OA6o/9ht7EIaxNQyKxsTG3ITcJmFGit2yXgpzsIIvY8zYDVUH0bJicMNJ3uNzdVW5jWCqPsI+IwJxAyKOtKZGkViHXawAgMw3Zs3eg1V3aEG0FkHVMidDrjtaOaU0A8PQmZ3YcBq6XV0hUaOHLLy+fcLu9A5xw2a4SUQ8Y7xOZyBZQWF5BpojlawAzpzo0A5brzaIdSQQrBveGdtzQqsgylAr+q3/F+Bf/9Rt++LcV/9v/+s3PvvPXlD8Xz32Wf3jlT5nrKEEY/wPUKsn3koXJSgQCxeju1gZm/PGPn/HDHz/jfa+gpKnmFMgXU6TJ/hPw7rZtUpdGxbpsrxp1jLHfdhz1htoN2Co8pGSxjTMDpVxQclH+rkDlYEuJ+snoyaJ36B+j06T67aa7+mgVRAmpZLGN0L3uI5G9nLcex4HKDb3e0AyYr03bSlZd41A+L9Gw7NnWOvZ9V9BxExlMga7X6xWfPn1CKRckSpBIeXrgOhmomSGB5Eyf/QXrgkQeqbUhJQ6Rzvywp4aOVTsno9b9AcjyWX5NeQJmnuVZnuVZnuVZtBDMsOAOvUQSKrjWA60eApLQsKP1EMDMsb+B0ZFLQikZuYjRbQh/KsxKqp4ZFCLIZSBzByU3YjCLsWh28qqwRWK4c6OCG9a7Kt3U3WlbaxtGtfUEiDy3OicAwJ1Lndkw1K7kwwQ5R4mbo3KtN/4dTx6b0aBqn6PTwVOp0DA4AdGIFE7phJzs5ugyR9g43U+GWNf2Jmu3nd5kDd/YtV/eZhtnIgHO+MnCNt4rToSOnLTfpG2xiELsrhz7Ht3a072PI+cz4Ej6aJhcHf5uTpY23zs8rKy+krOoLaviYvMSjVzz++dxWo2n9t29kQx3da3OrPh8dER9VGQNzBZqG6dHDjExmrbpmfGc2fOWfpkJfq1r7e/Z++IYnN1z5kwUBc6BAFBlFHEJtoKDUQAAIABJREFUmHVvrAUzYPP4TGSnZmlUcT+I92191J+1TN8uc3j+IlnTZ2O3jscjI9oM4DC65jTBv5ufOVtf05pOZMGf7t4Xn59OdLBFuZnTFJ2t70fFjdz+jmhwXu4eDiAe/0P9NDYGBDtZ6IYLOSW0vm82sodTe8lSRJwbPFfjxzSOJ9fWsYwOVox3ntMDr9f5TWcekWwJvm6H835EepjpcDf6yxaWn9XUCuDBSaafLwudFE+MGrWsjfNdZ6uBpu/dgb46PtX0Pj3Dy7PuHovfh/EDw1IwndUR284xTYzx3ken6E/68uie+T4K80tTW0FATi8gbGAWWta5oVNDazuO4w3teNfUmR2fv7yPdJKAOt3azC/vyz0fjMb9uDd87bN5CABSEBNbDw0cKKfSmPWUPzd3AMF4l9oKyRw1AraWuofHakQlFPpjoGVCT+IkTdkBsyUnEGvql1JwpENP2YnTR2QYW1VtjI2ku/Q2RaCrRM6zPcb3BkvMdC/SmI8il8XnZ5nU6bmPK3RsXfZb61pP28+/72nMmSxz1odY1wqujTKxiejMHfshKT+MJjG5M3MMMuAYCWvf6C/BnMzD2RgLn8tz1q4zMOpK78/4opUIcF5p+h3QKdSZUlIn92UyYNv3tVa8vb3BnKsWqcfqkL1cJ7AqGAPAbw65te8/JzOcla8xZzM4yEns07NQbTAr2CCkTBlzysKDVfQU525Xo3dBJl/fXhckmla+AFQBPO7H3J+Fhv69Flm3gw/rX0GTvXMOzZ8Dj7p8Ab/+CN4zwBsSSZocHjpgH/cmyNjJNDmAyORmUh1PIgRiyNfGgzoLAFLmx/QFT0nn8/81K0j7EvS6IasmkT07O9jAIl8YULH3COr3iIhMESQNeAS1e7osKQoSuuq1HR2JLM2wT5WSmyhM38l7Vmf8e+WTkh5HAfHdZY2uIASLrJst6hfCO8cqcHlYwEMSIYYZg8a8vLyMqbC+W9S21hS4pmA6uXaEwxmawpYsRaHQIEkzURQsE8HnBEvx6bxJpbFVZsAMrpe0oXOkyzO950wetxJp7qonTXOkIxfrasHusr7XeCOHh894NS9rgsj23dyXn9cbbf8YzxfQC2vdjwhXXNMS+UcAK/ZuiYIAlEzIZcPL9YpclL9o+qV5/Dvq0QJgWG0kYLQmqUvW8c1ZgM05AGYFiA90S9FGkkbZADNOI5RHdUJX2w+rGDmGjz16nQGHJeWJgp9YbFcqdip9ZB3DFPatgnnI4E7h/Sdz9JHNxm1CLfyNwbd9WUg0hDN2u8pQH/Hkry1GpkQnYCC7bCjRzBjgjlYremN8+o5BnyreP+8AflvAzNdzgWf5D6H82vle5R5g1vGFbjPmVD3zsy4/BdmpA5+/vGPfK8BC70Ak6amDKuENpwGYEXu27V8DjUjK7qMeqBpZH8Rj749idjFye9ychu5neIF9T6SR+ROos9LqDZ27ppAaoxP4vNLzJJuetZNDH0MA5zHQ0SVVUjjoIe9v4+CIgWotEtyqQ5kskhVobTLX5XLBcbyLDKr1ttYHYPJri9k1LY2o8QbTx3MWHZMSycHrBLTa8SgSz7P88vIEzDzLszzLszzLs4RiQmdOlvNcooD0VsG9onMFtwOt7qh1R91v2G83IFm+cw/HDkAcSsnVUxOWTHiSok7WydBAw8i0RhiZFcvFwEKQvNukYd4Vnh4NNWaE+xqhzQ1X2rZ+fwLYhUcbwbmshvjp+URq8F4N+O74tncMh0yCCqbsIzCGgVWoDcZyNkOYOKocQDC3NzpgoW5GmozWs4GGkjsvTEnoLCFumRhJx6ybAQ1uPCMi0JjHYDhgyS+dbNCDkXAZVTWMzg6du/UQxtDGODpaPloDZkwz44gAeiCKyIkhZXV0nZWvcZgt3bhr0yMDixiAzwxA92l91vfaSWXZlwqEsohJ9Dg10Rhhmt8Rf09O1bBHWmuy/i2Gsj0z7IOqDI51YOtjtBoeZYkm497kDiAxILnhSMeIV4O27qnQ7nWMz8bO6ZX3zYzGpM4Ib6/NgV5Jdv3e6P5zBrTpHrI9Ho2f0cbvgJlHwI0zJ8CdQZlIAUv+3bQmNYfyus5s/5ytozOD9xzqe3bgenvUUTNIRDQeAAxRsM3YTcOSonSoMWI+5XU8pnFW98Yj47yPMd3XQf79o3fY98Y74xiKQbjfvcsIoOyZsNeSOapPxhixDrulg9FhJyFBeiox3Y/LLy2+C3/uLm3T8vvn6p05yD3Z/BqwjP3VRz3zGaivGoWTjn6N+ZunT+ubyFw2YADf/u6Gb37XsF0+oZQrCBcw5MTc2+2GyjtaveHYP6PuBphhHNV4vr6JWeWZmWadteycV9zzueE0pfl5lxvknt5lfcEi34nLUNqiIaMTzWuztQM222MLc0ceKZgU7Aun57U1tCoRbVJWQE3JINYDuJBUGOao3HeAyKKiyFtETrE0VB1NQUYpJXH0hz2XEk0RutzBF4yVHzjRVqDGOZ+5nyXrv/6FaS+dzNH6XnGQ37fjaw2as8xKd9e1VgHeJ0I/KmrdUbYLbN4srac7xACzaJPKqIOfLzKj9/l8x0a5+Qw49JBmh37EcYl0P4Jmomy/9t8iy5RSBm97e3sb6ZeM1638UfaLANGJJBXJ7XZb1lkap+FNz7HvXM69XzgfOel+DawkriEVkUOFLHsbQzqR+WgdCUqjmJFSB4jVkVtAySIKJKXOBqxj9JTx/V/dkPKB/Y3w+7+9fGUbg870D6AQAGJJWqKJR8M4AauTiACU647rX/6A42BUuoEqgWjDpbwilQ3iLFXwYFgCQ1WDznsiSLRXeU+HRPPsvU50QCKpVuy3Hft+qE6Ywv5JP4OtvV+Dtp9JhbJIJ2k4VGSPbduG19fXkB6KAphMa1OHkYEg7J0GAgA8mqNFhhgR/YKsaTox6RgFtdpJj+ootsfWk8yrzDvRGe7oXaKoJNV7Wq2ql1flJdt4Tz0qss0fdzDn4aCy91yvF+y7RmYhwnEcuO370K+kTouaYVHVJGVjIrHDtNYASti2rCkSS9B9HRS/6tk0SPIqe+saTpa+ijHLngKWic6zR/zvjD5HuhX5a6x/ptcqTYXn4+f1IMrg4bAtKAIJJVrsVPOcd55BmR+1P7Ztvs8PlAE8osS4/uYjbPyBWcCTg7ZO605rTYTL5YLtsvkeo7jvJAVJPSqa7pEBDGkdxIzbbdf7Xf+LEWlzNj7X0broIClnbNtF6HqSCFDcNaoMG7+Yx890rdg2kw3ie+N4kIiSQ3ZIGqXQ51gGuhSLXgjcuKLv987suCbuZIIB2vPDd727DcAAfAPEPWjHvUz1ER8+K2c65Cx3GZe0SHEAjfkSex63ive3N3zeMl5fEjIDrf3put6zPMsvLV+76mT7qN641GDy0yQ3adn3CmaNIJfKkDPO0kQSORBVdMIdzEDJDTm5ICWA1y68AJD0cwsQxFPdpkCfHh+aeqiDaKcYQncSSUSZlPOwzxo9ZmgkYeVTMNkq0Gowo5MD+4yOVa4TrWXGoJdRziEy+7DJf0EH6oyGhuOoekiZlI9UDODyUONMNoszHP0eyxyrbdP4js20852koGCg1kP1pOOkrmf5NeUJmHmWZ3mWZ3mWZ9HSuYOQUHJBpiS5b7lKrspW0ZtElekKlultx3HcUI8D2zXB0n4M4Y9V0deIMtTltIU49OSGaIDhYNSScH4mlKnBQwWtPvKNiqNlNsgxUjaHR1Nj8xwO10IaryACK/4+UuXfhUcG0GqTiAersnti/ImG9lMHaUrYygWg+YRWvIcAPd2n4WKTpW7RtArjZKmloDEhVwXZJmk2pG4Lp5sBTtpPmwc/jWKRB4aSbSo4mWtRDDCdCWim0MhpOYheA656cj+ktCIAtYvxJZGGn0YCWkLJUENvBwKgydeArp1h3FKDT78/6R7H3AysEo7ZxsF/7B1rWR0qZmCySlbDWDS6xfqi4cXaE1PnxFePdsPvXds0wmgv0ZIkJChphA8HOsie9FMSsR2G3HcDVIyWZAvSIz9N7QnbbnYSzmMfx8MMkAyg9ibp3wiTk38YzyGOyOHI1n1oQ+5Rongy2sU5sf2A4DIntayxehDklEIeUUx6bwHMNc/nbMDz+SUCUi6Swo7FCTjGJih3pjSKQX6u+1Exmhj/jm0wXAOpYddTbAUj/8l7Yp9Grvqlb0PRBu7mNH4/6iKJ7nVm/4upp+5oXGiL0Whbq5bGxZwkfr+DKWXP6/PdlXMe9QPQVExS0nhmGGuX6F/AGoWKR6qC2NazsfW+rX/PBtmz8PMpJXQGaqsecSY4xYlITy/F5/wkpdEHo7e+Hj26zBiFZEA5gLJEiKNE2LbyQVSfuQznyIPv/PPgIg/uWEswjtH9rTxdjl/OV8cPOZTuxFym1+/HSPjMiaELwIicQ+HafEdo00ftXzvIoU1S/tE/+4x//i93ZHwLxhWEDeCMeuz48cc/4P34Au4il3Gr6sQkQFNsAlEuuV+bsY3ulAnfntCPM6dW5L+R7jJYog8OfpVwHJqChiVdSEmaDhTqz+0d+3FgK9dhOBRQbgJKDvKM7QORXY59x3EIYOZy2XC5XJEtvRKAUkQeYJaUOUQYaT5676iVRp73EYGJfaWnntBVfhGQm41b3Kd+7YxOnNFS+3HHL0zMWfiFyQ7RTHwOdJnlqFWmccBMdBKtc7u2c+3LGZ+w0noHgZGzAKbEYSzpeGqXsOAWHUHsojp27DKF003jgx550mm47NOxk4McEiPDrKkMoqx+1s91XJh5hC6XCA3Op1ZHrIUsf3l5Qa0V7+/vI+2IzbM5Jq/X6/QuABoGXdKiHMeBH3/8I263d6SUUcqG8iDVR+zPR/LFytPHOoXvfqvDQXf+7exEJ+e3BnZS4c3AIBGB0HsDKAtF7g0gCbne2obWNhCyCjdKQ0hBQSD0nPBP/+YA1Z/ww79JXwWYkRbOdPYj7vPnKk73PZ4ZQcCD6eQUNeA7nEAo3/yEb//F/4EfvzCAVyT6hFxeQeUyuJdsH9HXgmqs9JPR7d3JaycAN416ZGuwlKKp8254+/KG2/sN20XC9Y95Roalc71vMdxxS75/mLXPYS8O54fu0c4il1vI/948Zcoa4UnawrAIFePdoy+yhmrdcbvtkKi5TU6Kj++nFgOgoRtJXbanvO4znT7updaaRsYhgLtG6pVUoNDIUPXYkUtG1zQLSBmsMj/3Cmj0Dksfaqe5bRyu1xe0JgC8ehz48Tjwfrvh5fUFL9cXgBjHLnSn1jbuA3ikvrJ+pVSQ8oaUC8zZ1zuPvdvh8pHZDOTk90z3xKGYtF9dxjmJLYiZh75FfO5EPOOL9vns/ihHx/tnfubgibN5AzDAUwCQt2C7stRlUfdXGp7Gmu4jUk8sJo/Hd6/6T+Tnts7s/t5Z5PLAA2VeuupJkhJSHJGm+wkgeNsKjPrmlLHlgm0rYxxtb5DqQr1VHMcNxyEpvOTAWsOxV0mfbU7afs8TKRG2suF6vQwQD2XCdrngm2++xSt9GqlQXE+DOoLFsQuWcU0K5jOwkIFNZz1J54J5iAO9S1pvizoo6yxppJ0DzMC2XSS925bQ+44vnx2sGsfl3I4hMlNrhx74k3VladvdxhAdymOmH8w9xlyfXV/X6aorz98lsclRsiUFcNX124FeUfcbvvz0GYk7Mr7F9VLAX58h+avLR3rhR+VE1XuWP2NZ52nWS395PYSP5/6XXo/134Fm2N959rwEzi4qoyRAD/AO3YkIHil91tGE/nVspQGbgFEoe0RMAchY9McGKgXFouEV4Z9y1kLTHS4y9vq+O/up6p4GaB2HelLC5XrF+/sNPEW+DWNJChKiJDy7ZNGNLS1SSijbhnp09NrASBM9V2zNBMztveN223EcO3LesF0u2DQlYWsNYAHf3m6S0u/QtEjCC+SASbY0fRMflDE1vZ/vxsbG3AE6Qt/lewE5WZom4O3tM3766TPeb+8/s6Ke5WvLEzDzLM/yLM/yLM9ipYsQaPkrSyJ0FEm7dOy43d5xe38H+oHeqhhJegdaA1GMLqNgEg7Gu8l1BZhBmxZHlBmZt+2CnAp6N6NHVDxNAMWoT8A2wbGgzjGQOldCWSNhRMflcK5qw6PxYoACNIoCmFUYZM2N2oYwvTonzAEcBdCBQEcdw7IK0w/VFjaF2QRMazBpf+8NNxIRxkImqgJAnv5JjAZmfMQYY1co0nhe5qADqGCNUMDcQNxVWQ+nm05PH7L/Isj9NuAC1QouT48cApbTxm4nMGM6bEFgAE6i4RMCxhnnNxkwsNXPOYOiASUqNXc9+kARMqfK3ZxMRuRgEAIpMOy+2HqKDn4rsqYKzME3G/lkva6nz1Jyg58pI2tf7tpnxvLw/jNjoN3rdfqsrg6p1WEVizj/7wFM8fS4A4Tobv6M3gB28ku/w3l7ORg4Yx8MXDMbHAGP7HO+NmJdZ9cfOR/PxvXutKduVjO2rn0ZPTXPxdKeGG51pVu0ONrXMfma/q19ihG2AJy+e80hf+aQtbU7980dGm68pLvrDJ9HqzOun0fl0Ro/Gw+9io9MQWfPnBlOZe0LYCepsdjiLjB3NTbL/gZ5Cit7vqojLJODaEgdagZUzUlSKSbKmpP7682dHxvX3HzmVPnn614Nb6epkD5oDYdnzNUauYK/h6a/DNjjxr9z89+oh8L7TuqHXqfwXPxsLeA7Zy4PI5kUSUvXe4atK8stvu83ATWjKStMkAxkGW11ZrH16J7/xZZ1Sx5vV072RuSJY44f0AGP5mR0Uk+7o4M4ALeI1FCoTpzO4BEi2tOX7fuOlGXdWsoJBiOxpOyojbEfN+z7O777Hnh5eUECobc23m8RB6xNSY2plncd6LDUHQCGvDqizQ0nyAwIFJ7vjtjTPb38XsdtBjLMf5tzZDiff4VnwqSh1UH0NSCL2Bd7/syZIw7IhkQ8MGe9dxzHTVI2dAznMIiQ1Zhr8sXKd9afIZOP9W3REmYeFenhmZNqBT/H98V+2t8OwJ5lGAM6RQBu5F0CPtjHd3aitZQyvcfku0+fPmHbLuAuKZve3t7x+vo69kVrTYFI94Ba7//5frR23suPhBZT+SzghImej/GZr4dRXO5baK0sbDjQSeaw94aGit7E8TuCEBLk3pyQ8gbu5Vy9OOvv8mkFR37Mw/60cj8q81gRgMQWcQtYZy0+3xrjy1sD0StyfgHRJj3pHR0G2Na9xTjtWEo0fKqAr/VV5tr3fTjPxWmjh0dM7ww6+OPehn7/jNw0ZFtI5NXL5YLr9SrrtLcB6vd3uBzswHR7l/zXFfDYuwA3ajsCMEKIpwGhfY/LjznsYfJXQtgLj2VFkydjn5gbWj0AyN7iVtF6Rz12EDZ0jYiGLKDlDABZnW+J0E6iUHmqqhsAl623bcPryysu1w2tV9SDRgq46ADLetI8Z0m/NOaDNWKcjqvrZ3N0ySFLBJl96KYAMlskEQeH2fPx75Wer5G24ucV3B/165UHjXsQDmKtOk6ow1NjEfJ2Hll11QFcB1THZgS76ver7jLvA7prd/yxw1227uy3RycTkIjbsKRWOSymQFFd3znnwFctLZkDhSxlZmtVQWWSOpN7x1YKmp2OShrNgCGgKE3n3XrFl7eKpmC0jo6UM758+YLvvvse1+sV23aRPpGtFznsU7aClBOOmpTO9KlPs40g6oWE3gQsA26DqlMCchFd34Kv0gm9uouSGtbifTE5gBBBu/adfE/KlzNS4odzf6ZTT29a3r/aCB7dT6SpWJBASdLM2RVKElGsHgeOY0NtHRfKesjwty+/lqc+llqe5c9R1rH+ubF/ND/GmT9eTY/sJL+sDfHZmZvEtiSJtNc58GSLGLzUoryltYbjONB7E18IYdgJzQYJCL2xwxROj5IeXOwDh/tRP87oTuyBRcOzyKemH/szlqZIAXEwAL3Izblk1Ka6M8Rfk1RXhqaj7Jj9H70b6Nh1K+NB9p0fIFFbA0V7qMhU8R45AE0o5SJpQyedE2N+bLBWni+TIHLhsH8NHdhkITnA8NNPu0SlfaZk+s3KEzDzLM/yLM/yLM8SCwO9NjR0XC4bUiYctxt+/PFH7Ld39HogkZzWOI4bat1B+YJte0XRCAu9A4yumdAZjSrEHKonq7qcSjPjlyuSInzaqffOjOOoelJYQDgW8cRO1Hgu9qjgNgjIo4MSwO1eOWX2tExrXk4AEDAIwUOvqiGHEixGMlEaRnNBWLsSvxrm7T1ReR5h2PNs1YzNEBCDGCaGE30YoWB2vek5c16ZcmDOIQJEx9eINOPUlNqszXhubjoGIyVV7ruEYbSkCAJeaaDUkKiP06JIHX7aSXOkU5jj0FBmRteXkzqfLFCCg2LEaWWGirOTWswM6nQ+7iHlykg1xAzLb+0RSJZtoG2M4bZFoCePhoJ7R4pdi7+BmPPaDdNmZLTvJiABWYjle2MdAD0d74YdORXf1ADWYaG3ZY3zUEhszZ6nWJqdGmeOsVWhs/IopLXV01pD67KmSKNHpTLn20XHcDirzVZOR6hjCBydmWIQkj3lTsPhfwlRk3xvO7jFvido1KtoBAeQy6zURUOuOcbiHHZJ2A5QH05IHYh7YxiHiB8hZLT9HvQkjOMa7SMaE4f5ontEHZ/XuHZmGnfmKJuUdzCo+732zqgEr6fqtXt34xbXqq35qGSv6S2iQd4+z45Rd2wIreiTAi7vHS1CdI/ZelyjEZ0ZKKdrbACVe4PnumeiI/GR8eiu/lCP7VehVRiGEqOhElUr0EEAICBlNYynLKH+4Y4VofUsgE82sKpEGutG55jQG+P9XQyqf2oJqwIe+wHDOfqr67XILnfvme/x7ziyylHODG0I7XTXnH2aa3CK4bTL3jU5iE7bSJjXpoNt7Op27fgv//vf4/Ja8PpNRsL3INrQesb7+44v7zd8ub3LE0lBCQzIKS4zMvXBj8d6C3TSl/HcyrG/FvoV93vckwZEFGdCqFcNXkqNJx7Ye0MpEvmt14qjNbRcx9x2ltQtvdZhfCy54OXlBT0Tck7g5ADG1iq6yh2XnJEB3PYbvvz0I/b3N5QAdmTuOGrFse+otUqYa6UNVcNKy76xfhpAL/JDS3VRJ1kh0qI4Vj6u83jG33dOwuHu8O8N2DPTIPvvvNw5/ZRnxOZ8barSte2AR6GzEnlA75LKVd5hJnUCFe2LphayiCJCo1QIgPN1+dFnNfUCG/HT7tuc2ZqPaY+ivDXGYeE5q6xmBmO7PxrVrd8mC1io88tFT7Hrc7fbDe/v72BmXC4XENGkO0j4d8b1etUDA9uIrHEcO/74xx/whz/8oO82x/kc4Sbu46+ZQ5PPI++38fny/qbjSUEuveeF7rwkIUGApD2DinWQr7l1pwPJHHjiECBAHYsIodWdfwtYRrkHiwy5Hwl5+xalbPirf/oT/of/8V/jr/7yBf/L//wt/vW/nmV6Wj7FaG3amcdj9LOj+GvL2ipZ6mNdYuYfAPDtP/+/QJ/+iAMNvb+gXL4H0QUWVRLcFBzp+hOz99qi/DARiDIE/aFRRLSjZbuAGWhNnN5lu4BSBiUBrNTjNmSrOeXAst7skIoJkHBaaGvJHR5+Td7dwL2jXGWf1Cpgsd5JU3TFVC36GtXN8xJNthr4StMvGWgkpjXizhNAPv5IINmTAw1k9Oeerhs9sEgwOWcZz2bprCwyiMvwl4usWYuIlrKk1ynqsJPoMDIn8s6EnEUP/OGHH/D58xet54Jt23C0hv3YsR87ugJ1BGjiY9W5qiNMZW0kiBlDT+MPmkooZXb6m2Ms5ST2g34fpVLsN8eInFWbRBSTyHIHOnXkwLut/2f6rpX1cFME4Uf5JuoYREKbBEDiepw9a7Tc5OTr9So0T2lrba5LJ6LBY1NKQ+kcNhcicM6DqcZIme6MjH2yNWzypewJuyYyR1adytaggeE0wl3ZRgQaiaJivIhQ6wGiDMpy0Ol2e8NrflVRj1W+agMUdyhvI5boQyVnbKXAIuqsc+K6qut6BiZlTQEuOvGOL59/j7cvmg6J5Ofl9RO++fStrC8iSBrdPg4L5SxMpHdGLqLzO9WWaDqsjmuiDmSJIjrsY7BDbR05E6gIf2m9ot2E/3333XeDr7+/v09ReGN/idzRHu14so+PIf88WsMrbfmacmZLsv3yiMcLPacR7ZWSOfQNPNYl6jMnAAUpFfzur2/47/6nv8Px/kf8n//7X+PH33/6qvb9Ocqfj+c+y29VHs3R12kOrlWfXYta6HoXsR9ksRvcVixXP/1n/wbf/Od/B0qv+H//cNO9kEXG6R25SOQVsPAowIA0rgcIEPWKnDeUXEAg5ZXAlhK4QaOJCY8mBtA6mBqQOho3s5IDRKAPAGkrnYkyoB30OVoF0EQ2LgJ6TFmjM6o+xGYnJELZCi7XC7btgrf9hl15fy4F1FlswFSQc8JO72hHn+iW8R2xK4v/5XKRaIM5W8pA1/vFdyCgHdOBiBK2soGR0blqNoI3yOFC6bvYNYM8mNISzFff1aMeqH8n6Jx1BXfKymm94XLdULYnzOO3Ks+RfJZneZZneZZn0ZIUrVCrnAzpJYEoiwGoCiBE8naao1NTBJUNORUQ6WlFc+CZ9dTcSmosYnV8gIMTWB0DljpGTrXICRczDJitgiNoxs4XkryLIGmBBDBjqVosvDDf/ZwpooLa7n6qMZThNmPrU3AgLVqEGaTP3jsZ39zuos8tE8MO2JkagtlBdS6SBwfZqJyD0s1zs0kMytIfMUjIawkMAc3IXFkjugrJgPj0NUc7CEgJyRxGHeC0Kvlu0SWQhGxuMbKM/I7j4UqFOchl7GIaIgCjzf68G6SmYVmMP4+MGt5uxln82rO1FD9HcID9NmfH6elg1RpX59k9YACjPnFs2JjNEZPMeG7G0ckhF/q9jsVZH4bTXiuNBuMzcIO3sQ2gSKa5bzYnYw/A99lX3t6OAAAgAElEQVSYPjanbJreMacKsPeNT8tv37uAjgfNiqIO/N1aMCOrh8Ju4RS5bS2eiIbTCszvDwbVeP3n5tq+W+8H+xiH6pfxWIEts4K+1o+xDKOTYKYytvZ8ffj98Z74s0aYieNgv82ZGNfU2lYxynsaFTdGMyT8etz/8V3n4zD1/UF5ZOxc5yt886EVKRpjfV8SOrvzmWBLSsdPaWa0GhExEtIcllfrT2pIISJ1XPqac8MyjZ/eBaTA/b6fHxcHJc1X9ffJ/o6FHvx1dq/UF+bNHOtrxDptlf3++N0UvuczynHSCkw188n9FD75tI3z8HfvGW1Wz/N3/0nGy7cFia4gvIAgaQ5u+w3vtxtqk/QKpC9iAxFwArNEXQHxHU2+3xsj+d1oxbjzwX45N9zPI2CjyrD97XRgOHcIIyKLnE6fgcXY3RHHSZw/rXZwT+hZ9gp3DuAFH3kCUI8dx35DykkcQNwBBmpwFuWcBkB6OOUSAGuDuEoCyAB6Wo80Gs79GEW+eUZbVlpudGDlBQ4Oo5PnXTb+Gov1tAYCwYjOzo8cOo/knLO/rc1Cv11u6mwAKouKpQZbVrAam+rg42N1+Svm7+TdSZxuQb6LctdHffqI9tuzq8PWPkeZypy19lNrxe12Q60VII/EYONs62/bBKBYigDCvvnmG+z7jh9//BE//vgTjn1HimDt0WfjrTZ/9u3j/p7Jq/Z375JahBZwWNShjH7J9UV2ORtfyOlcic7ZBawxEryEtU0OkhPw/RpdFGAm9JTBjZHKC16+afiU/g7ffvMZubwgmnejJEZ3V31NrXQq3vlLueB93z8o7C1j5Z9d9dhxJkRr6eWPoOvfAXwB4RuArjCwDHNXbSzyLZsrdTro/jBZ0TpN5GNjaUVSykAhXC6XATiDyd1hL2I4TmIvH32OV+/nYNAeYCgs5sjuvSNRARVPFUSD4J2/w/a9PR/3agSKce/ozWnJqltZHyMoe91jcf9EsLuV1htqPVAyg8eBHqHZOUs6OgF0JD/IAnNEaUrA7nRM+iR77jgETGMAnUHzWkdjifyaCCMFIXcDR8/TRHD5jGhu/6qLMATsn+2wh/JTG19/wcxPjcZFcOkKOFo/r9dWHcloT/wcdYa1/Sufje0YgElre+AdOWe3Iiz8QtYR0FMC9R5kncf80vtt6e7mCDjO1x1os65LTz8kEYxc9oGuEQGdGPArpSR2PmK03tEUiGWRpAAI6CclwHgmm13tfvzP+mS6sssTDkwC9yEF7/uBox6ox47vv/9LfPr0jRwgIU0NB4v455GTfN8pCwGhk84XM8CSpj3q2LZfBYxZJGoEi+6T0gbODpoyvT6um2nd0bxWoj0nRhJax+Uj2eNrSly3cZxP9w6CDAXTykzxUuBTlrGTbGoJL582XF4Kfv/vviCX+ie19Vn+/kvkiH+q/PJr3vlRG0xXNu3MJQH/a8gjUa833hTuMclJNEa5Ib0cuP7uXSIQ/gEAZUi8NonaPR2SWWiaXIoHu3y/TQd8FWSbEklaVBaQMSBAk60UDEL8FXrFI37HzCOynKR/ZumJodEHn5BeJT2MmLNErSzbhlwltR4D2l6JWieHYRtqSmjoCy2Z+x3ToQvdk3mINCnSygFIpaSHCbVe8kjhdp+R6rUunxfp6/0QzfyntTqioY0oOs/ym5QnYOZZnuVZnuVZnsVKBiofQK0aorNIHs1eQdxUx9J0MK2KURUZJV9AKEBPw2E1OyzNONTB8EgR/r1baZIazMwJPsIFk5yzFcEKfgBqRE1QMdgMYGzphYLcav0kPwEFdYSIkc7sdKRtkdtFQDRDmijkYkTTEy5mgExJT8DBDVAu5avQZ46o6JAyB1d0sMVw5W50IG0/gDFWaaSfghqYVUEezsNoBKQhtLpzStyDvVnUGVPIKQipNno2XmLgMXDNCEePKu8jAjqhk5yUA9npoQSQg2KGi9U1GDX0RqPbbFQTW46BQkwIHytAA5YEw6uM0mSIGqrWiaISo9jYu88+x3atxozRG45zYP1xJSmejBMlw4za6jQISonXbyfqokOoLUZD7Qt32SrDGN3UMenXKMn7VoXFwjXbmk1ZT2X0AH6J/SXfb3b6ktnWpTr9WpdEuj2Am+K67/F+hLbkcbrU02XIeMY9LvfHSCNpGPzuNHhVwieDn37XNfz8aBdmY7rkXFdjXmvarjwUyxYcdDIvmN6x1hfXy3oCflUizdkxufQ5fN/jXp9BdY8Md2cGA3uHGyNtHKfBHhEdpG+2ANjvY57qkf3tznke7XdaPu8bnuisgcF4jEEE5Djwxg2sGM/qxD80bE5jspiAbM6AsJROnpWxC3R/UFt71k8q0jKWNh4ERiYCk9M1cwSPtWwLyRo39q86MGjuwZ3xF4x6MFoTXp/SBkaSdZ3TcJj+FoWt/7oWf2nNbsL54J4TsEwsNlzDGDdM90Csne6ejTN3X6/dsV63d/k7HVB03xce/zMYr3/Z8Ol3jHIpSJe/AFIBI4NZTBd7PfC+v6O2QxwlBhy2qByxMWPeZ7Cj8yO7f477E5fmMNBPrV16EN+h9d/Djjyks72byE6seYRBv0+e62qcJI0gMEI/q4uYIDKBpX/o1aN+UErg3tF6A5pGTwhgR3OEmjxkxruUSca2Y1wbTC78ZrYZ9dkWtuc5T1ZAQhyzO5AKz9+Z48NPnvssmKwWZuFuXozeTAwtzOuQLQP9iLtk+n33Pmubtc/4DY/T+GPVJ5JoQSwgCJtf4QRpWl+k8zJbSSNYRtbXnIYiiVwQ5KJowLU+nslvsZw5blewLCB8lpAklZ0alQcYlAn1aDiOhnocaFVM+nayNRGJDtXnaINCIiX6zGXb8O/+9m/x0x//iHYcKLkMp5+MrylB8xwa/4yyw1pWmSICeCYAt82I0YrB/wJVi/OWhnQzfpzPBUC3OpU5AwSPoIDKuGFHy0DJjFzE0WlRAb1VCZ1JxMm0IaVP+OnLT2jtDLJ5z2+cCt/T7Uc0/rco9l7nO8Y7KKQN1HuJsW07Xr//A3rPQGpAvyKlK3K+oDcHHbokFCrW2p2gQA+b+N2URG61vZVT1nXTkTPrmvaUdUKL2IQhuI4aXsw8fRa9w+RJ61sAWKu+MkBnupY7s+wbTUNZtk2jwqRBFgZOY8iPCHInASz7TYCOvjeIBCgv45AQfSu+/SNQktG77TNf265/3Uc9MfCmgFeagi8YsKhuJLSDIbYIe6/ptp0tOkZF7xVEXX8YpkOP4dL0mp270ljlhRYJJglNkQg7sispHHLqTdceC7dwp9ZMD3wd05gjm9RqETZMr0SMGMSimOsBnJIzCEtq2bAufC7udRaze9h/ttpS1GP1WQfSA2nIDrK+bc2vPHikT05CSyTSK49oOMJ3FXDTuwPB6bzNMTroOb9xe5fxc1MhVt7u3xnAXiqQgxIefcjsW8K3FMCZM7btos5XiZBQq0TTiymjfUxiVJs5gk9s1xpl1MZdDmPJu6ytrpOJLbAeh6ztxGAI6Ks22S/MkENUKSETQuSxxR5DhE4CxuzN9oXyxaEXyeG/RBrZWvksc0arB/qhKaR6E2oc5AynWi7bxWLtsWhSRJ7eK0YyokW+1qdD3cu6sMUReLrxUldlh4AJ6P41vW84tDV1lPxOYqfUSBSSoq6g9ITeC/YqfPU/hpIz4x//kzdkPRjKyD7WIPCQ36PGaJ9U++hV9kbvaJXx+39b0NvJy/4jK1+/gh7rxAaWEZHRJSeTndwuIrUYFK+UDdfrK5i3oQsPemUHr8ZLRFY/E5MHnRkiCY+57qoUiiwiumXvDbV1MBJyviowUfkFzg8hfCSfy8HfPtLjUcIAAOdcgmyiZCJ1pCJ6SNkkHZNiVpBTQtNojqVsuFyv6L0CxwGGgGy8eU5jzR4JOF80Gk4aGdxApdXS8Cn4U+QK48EQwDOSCSzCF5SXG1hqtcWa7MgDPU4IC0BSV+YMImiEsDdv+4nc8iy/rjwBM8/yLM/yLM/yLFoqVbzzDQTgU7oiZUY/dnC9gdqB3CuYG9pxoN529NqQ8hWlvIBw0RCfgEioIhSJQmFADAHPDBy5phoCzDgOOdmixoutiIGMmTWHuqCsh9mRBBAwUOPsoQLFEEcAMmqrwCSM+emiprWJ7OkGMREKRfCT3wY0cKXJwioDikZXAY6scVDjiYqEchoIMKV7YOzHGEDfnQA9UQZW8AlJCHZKJN/BFGKgUw+OE4/Io12V/sEsiwluKOrjBmYJmZyRwynWNHprYj/gwnBMcVNrR2s7SoHkKc0JnZsYGRGcYiAfG7itNTGJIREs/WNHvFMYm66poaQNYtwooDEWiTwUfHf7vs160JTE0X8ObtH7T4xD1o5osFkBLdFw5PdxaEt02LgxRpQjgEhPE46TTqbQ2XvcICRFQVJmSDETos6xOJLViKb7Ud4thuguB59R8jacPh7BxcZR5luMfx2t216EaZNqKAVAbRjura1mrCYNg0roSNDTseNZdZqZAkuyxlvr/z97b9JkSZKciX1qZu7+IrKW7sI2GLQQ24AYkZkDBJc58sQ/zgPJE29chCNDygBDYARoVFdWZka8525myoOqmqnZ84jKahQaw2FYSVZEvOeLrbp8uiEupHtfwWIHjoteSnqOhcYYUL2k1AA0m7taq54HAdsI0BI3XQFvRqxg86a13NWRRoBUyRB0KJC1rCtikDrsfFisr+zNwblIn9fNHOPemx2pfHQHMJVjom60YGakFAWkRH+fpF8fgb4Z/LQx9r17n37b73vdXC3bSWUBlG3NmYzK6zVGR0n3PJnjjM41+l4hxze8A9iZ04/VXid7L/do4A7QUnuP7VNzvmpHRd87RBfOZX/YQBLHSxywSsBQrk3u6ZimHXt7Vy8Xx8hH7iUZ9KYYjF7puKEONH4vmJMRU0t8xQBKkSxOUJC2jUvnOqihJmcgl4DKCYFWICxS4mZZLGXYZ7W+K5zlYPiWXvn79b8+6/1D+aWOqczPe/3JM6A1G1Pvjasv3ql7x0bKw5XUftLp3cA3v6j4xb8FKCxAeETRWwIYqBnX/Rl7vqrzAYM1uk2Auf5G0khiM6bMTnft7cPvnX/IMxydaMMYiEmbHeEVYzki+7vxACXjYgSPMAOoGAHM0NYNdUEzyrDWaq81I2fJxGF9Z2bkXJq81Q2ZDM6lncHKFTlLJLHVZfc0zc6W8b/j2AGKCCGBQkQl4RWVhH8xzBAUGp0loDszuDn08sGZEdL6UdTgaStiEHE3vDVrSeNpdrlb1iYTEVkkMfc9os8Nmjrb7jCHRZM3+u92Bfohon7O7HNGdUAlQ+qhFjBnlCqOI4yKEJLKtYQYYjPqtTkyOj/UobfJZFkDru3rTuvRgW67i8g5R42GvTMD7QximzFsWZbGIyUaXY2oCEghYV3XXjKpAOXI2NVAvSyrpjIHuBZEAo58oDKwxIR1WV1fBOw99gPvv/0HlJKxLAtiWgAipChZGrrTuDgKjfvgJUrlW3dYEFtzPzetVIotowLQngaQZkJp+gh1fUHra7p1sXm1gAOVh4OeUWgpX66gvSClgmUpWLWURqKk1bp0P3LR0hoFewHS8iX2WwE4tqIdPzQDptOYGfNzZszus8af8blRfHKz077TNVP3oUHnAYD07hO+/uP/C7djBWgF6OdASKgk5Va46YIAyPhNfxNp1iFTyU02A1U1nIojSoxJaRaa7mHGwKJ6P7iAS2mJopiLKgeAZQTzM9vGqA4r5qwJNZqYvD/wZzsDFFAqkLPqzcuCZdmk/EFQ2spmxFH9vYpjRsuMBHHaS0kdCiqjoGhwQV8co99nzWc2HDOWVNXXSstg4/sfQsC+7+1eOR8RCKw9q5LZUmW8UpsEKU5gWlI31IJadpRyE4NYKEhJ5GcKwLIGMEXwtSKXjJB3lOYsroEzzJDSjISSiwQ6UUJKC1J6QFGa1TCJJqej0QfjNX5da6mopdPSlkGrRZeL3hOjGO+kJNYNMQTNdnO/7mc6tz2//wHA0XGhU6p/qD9TKRWsTrOtfF1a2rNsvER9bWf9HVX4eAwWZd8zzxivyWx0TnhV1XJifv/Mzz3DHMwRRPhgp4/WvyZjtL5IOcqiZcZqLghJHTLVMXNZk/DWGBGiZmeKEfttF7mwFJRcmtxkGW+zykvSze6UyxyGdfIG1TOZplZfOkodoQkoZW8yYUwRwIEPH7/Fp6fv8HC5oBRCDIuUbSYSA++6Ykk+02h1JSAZgTMqMo56FTmZdMyIkGzRgs8xGLnkJgMBBYyKXA7ksouTlC+15vcaSRAdV+/g1M+7Oc2afDCur9EsE2ma4qnXyUejgzmBg+mpkh2jlUORtwudd5iotWhYDCKAVfVrkVFTWrFdLohLRK4VR2bEI2A/KphXAOe08J+ijRTlN9vSwvjXf/EJD48JFC5gC/KkiIKIShHsnZKtHBCRsp+KnCXDZy0Ft08ZH/6HiL38eP31v5ZmnPde2x814JfubrKlc5bpurx8H51sA4g8I8dHnryuD3i8FHz4lLWcL8SxIkWEFBpe0lvQIMza6F7HCs1JDSj1aAdVAlLluiMfiGxBoAcYQFo2LAshUDyR+nrzJXA9f5AytQXHoTg3S6BxKeK42xztdXaMZaVV6H1MUbExCWpdUgBlyZwfQsSybLjtDEZEiAsiRZENGvY7Zj83+4vpUUGBdiZIuSiSIB4JopZVLrVqhQBAAquTZoVVXcFhZcF0VUCDxGTSOyYbxHnS9NEASFVRUpoojkX7vuPx8RH7fkMub55rP1V7c5h5a2/trb21t/bWtO31wHN5xpoSlod3YBTcbs849itQDnDNIpTcbiilIsSEbXvAw+VLpLQIAAZxvChshnkDd4IKfV1JYstu4kAzwcjrELViCimghmR0JbRnAxEvZjH8ApKlI6iBxaLt+zsqa/pjddrJWYBny6oRA2NZxPAoIG8veRMsawowGLMNYDCjE0//DNixq2x+QkgytmZk6gZxn+qVEhCpR7nGaMK4GcN6lLY3mpmTjvxTUNtAHmdYS0nmat8LapV+XbaHBt6hqSXeCAYACSlaKvcCDocI1gFSO72IE5Ckw42wUlzeyFM5CogLFzkFA/GpzUnVeqWw3qgBbImL7KtaJUKp9lIjAjQBhA7oGMAPGh0QfKmfUweYvsJt3Q0kOUubbP9SmiPppBdeMTNDnt0fW+khtPelZOm7iyoxRY05CTmL+1dKK5qhskrdeGbZBzEGbNuKpHXJj+MQtFZB3FzEMeTxUWpYW/TZtm14enpq9d1zOdq5rLU0oM87XnhnD3Fg0NJqFUBlHHlHVdDLUiUHdJAQrMZSBcV8CY9mXHRKngFWIWp9X+amvNmcG8DWlHB9jjnIBHXKYaUZDPQMBQ4Y90A616Ip13cc+zNSWnT8AS3ar0p2JVNGDTWIQeoQ+6xGM/g+GLkBjWzvwKunJcdxNAciwayFfgER4G4gG6LIp/d40DoMZ2C8zqcrb1F7JPvIatC382Z7OqYGCJuxIefcygY1Q91hpaXGUhqzg1o+clesKSCEMaq0A79jXyT6kto+g4KpYxTNaEw9Gw9c3wCFdNy5l3M1GmspSqaF7tQj42wcyubY0aBaOwjbU7Dz0NfmKAC0dbI9zvp+YtYSAFFoKRH2Q5wuli0irRsYAaXyPLRXm7M/wc7XMF9gg5m6ge8ULv31wUaefpL72U1on3e/ubn6z4drid04xkZMo6OV/w7GP16Ciu0MPiDEDYwLCktmMKACJaNcn7EfO0AVMZmxL+gaC2+vpLzIZnweTNu+I78aesKdDrT+v2DIYhZDpe3BOYuK0OgE70gjvD6iWjkj5dc550ZTGu0EIFnn+tkqpSBwPwu+LNtLfNhKUxEF5Zdl+N6cEMzBLC2LyGc6xyD0khYk0dt2TmNMACSKjwKh1NIiAXMWhyZz0pnnrxnWWIx9jQ66MVjKb2+kke/a6rj/98/6fPuFQ6OB4x2j0fKOBlJF4dIMd4FIZK6cEVSerFWj1o8Dx3ETeTqJ7EJWAlEj30lDIJlNDjNDIcnzyMbHbe27YUmMxk0uU1bneY93BrX59zKKGQmtDdleYE7xImtZWSVmxrZtWOLqeLkYo7OWR7Fnb+uGbVuxbZfm+JXzgU/v/w4pLggMlMqImkZ93TZs6woC4bvvvsN+e8bD5YJ1WcAUURi6b/v+OXOOkSW7p4DjNffrbh91+bl9+wpp7vTM+BiG60ezh9/TcpQqqI4lrWzPCgh+U9lx0XPC4JzBasAMcQFCxrK9E4flifa+lnmsS4N89/3nsL+XpuQ1LjYblbrBB603xIQAQqkB+3FBxSMImgFOncXMaNN4fp/5/gZCy6Qif3cOZJnJGAyiKA6ItarqHHC9HYhBMiGVvEsmhprFCO/0XZG/jM/cj5xV7+xyt9PDa6e9dmakrEBEYUJowRmk2SGSc0KQUjNN32BxErYzK44sRbKnsDMyU0R34FKnM+cg/hLvGPmE8Y069pt6lhL7O8YICkneA3H0ut1uCCG2gKAvv/wS1+sOTQiDnG9gJizr1rJVMDGyOh8SSWDDftxwO8QZMcYVuVbcbjcsS8AaE2BlpIhQclYHkAWEipQWuSf3srbSf9kmPcMoOR47YjI2VgB4eHxsn4njYGkGr3wcABEu64YYo2S6gcgu7OiQn8sZO7H+1XLvbGr8kkgcC/bbrWEky7IiKj416+pE1Mq/2vNbXwqpDipnkVQmZ67NwQ0sUi0zJKtdziDnJDPzTz9vJhP4LCQ9g0q/3peEWpYFy7Jg33dBfvKBnHeZt7TqWlTEtGBZl8ZjxThZcd13kG6yorp+KaK/Nv5qlEj5bpfVxhJWc/PyQtGsq4QFzRA66DRy9kSnqQCkBDo/Hyg7Y00XANT48bqu7d1W8jAlKTsCAnI5cN0/4cPH78WRNUas6wXbdsGx9/HEuODh8tB09MrCr8WxSzAIVuOr8fE+ZnEIjyENxuQzHdHkDGuCU7gyu4ZvtUCd7uyorwKFKPQejFwFk4uLyi+lqLyNYa+EGBCYQazzTxIYEU3eIkJKF7z78is8PDwgpYRtW3HZAt49JgQcSOpY9ptor2lC/+SNAjj9LkpKAC0AEphJgot03njiZ5ZhRGhHBIV3grOkinAcAD3/c41m7Cf+MZr0ffPPen10owzS73E0cHjK/GSanGWcEw0EvQ4uQ62QKBpkqJBWgBO++/ZXqHmUSZgZbLpx0fMXAOYxOEh4l5bojUUxZ9MLWbMeij5ZS218PJeCut8Q0hVMAesakFxZuWGmJroxlOJVLDImyXRaj2owv/avl4Q3/hQTIS0RhncHzYpDxEgxIsVFS7x+VDod8fDwBS7bI/Ltik8fPyqWKzKL0DjTT2noowVJ5lJQ+QbDZWMSnZAA1CJZdkouip8WBFpAqWdqK0XtREQ9UFK5K5ghGcqCOFa2DHK9jKXQWSBrhjBSOUfe+c9/Dv9raW8OM2/trb21t/bW3pq2QBLtmWJCDAHH7aYOMzcRGA0wqAAhtPTgUMDAwG2uLNXpTWpvRlf9GxZFPL5/NoYaGGOggTlMnIFZTQFlryqMgHCDKskrmWhKZ/+8gtV5wxth9A0oNaOL8gYwqdo3CcFeSJ7TD1tfzRFgNlh7Y4o8S1I0+v4IQNRrkpdqxox7A7hEGVtOHQDUU233PsF5r0sGnV7+oJsRu9FKPrcyP2IQ0JrxKArYipGcmFEPGQM7dYg0igshoNSAUjPIMoiA0LIPsTyrchZAj4LUdy0VlWqb++4A051lxJBTh/k3sNmu9wYqP//j5/17D4b5nx5kOXN48G2+1tf+DujnoGqWAIkuqMPemPvQ39MNjNZCUMeUENo6AxrVXo8GdhnovO/7EGVgiqE3WjKzKi5LO6se9LRnSR8DQux1bKuCZ8EZCA2YFZBc4oXlPQbu0zSmPmfe8YQAiTJr14/ApTUPnso7CdQiKcKwzv5+A1+ZJW19zkdTtOVeA+TN0Of2TiCQnteZns199ICxfGFnmQe0SYZoH5jTnBurJ3yunRvc5B4DDV9s3qhKaAbzuc99Dvue8Y5/MONJzQOoPJ+Pu7nRj16K5PSG5XZujOhP187PvnsX17s1Gsf2ssHFv+sMlLbm++NBWQOIbd4MbG/OlBq96VmeALHqoKDznILSWmgpMa6ApvmPMWBZzIGLXZaLH24zQOfvPAPQPv9Jn/NNfx9PV9IEeDagzRlRjbPZ761gII1g2/hCjeCeAVWLTj3pm+/ZS+42BMIf/SXw238YQEiwDCZSdlAMNaUULTkZBpCt1g7mDvvwhXU843Xz7/5vT3fns8bMVq3x9IzYNbM8JXvUnOPYGVvujU3Ay6Vj7LvZadXe22iSTPJgiLJ2HEej6/Z9yQUcBbS07IHzyORz4WsiqOhYuQ40SIwVaeBRd3MENy9ODrbxtXd6uuvGeUZzzQh5RqfEQDdGFPf+2pq5/YQKpgKuQLGM9VWATyNB4jQhzoAxqROkOm8OjqasWW40+rpyaHIeAJdhr4/N+m8yxawzEEk2knk8vtm6+5+zzmH3zfvJ9oY4hDPQeAIgxhbJxhGC0NJlWbBdVqzL0vZHzISP37GUUq2a7YAk++JGZsAFrlfGw3bRkiCAUY+ZJ97rFOd766U5OTtnL93z8nO7I5ztt7NzOP9uwQzdqR9gHg3xfZ8SUlJnjaC6JoBcC255x4oM4g1xipCXfeu0lykb2TiKH26ecp9d/zm87rX7AeC3//CvsT5+QuGKo0Kctklc/i3jIwfLeDGXLpv6eyKPSR9MP0otK4vJE+prAyL9p72Vwgfhjmb80FhFNL3fP7MORUQqy1ArLWr0yAzlJqf3EnWqH6DTBZOdOs0toleqDNrP+zhHni7Mn4/7uctwL52dRvs1M0itjP3IYI7IuWBZ+tjNkZ7QS8qIbq+O3yHCMq+KPCd0OdOhhqEu98vzRDfJ5iOeQt0AACAASURBVGxjPElZiJWPsTG2Pujcv6RXeh7k9TpzPPTOh3fPd7K4rSFopD0vzaXfv2eS00tOqL1skWAOZqCr1TCjiBjv6edLuovREtuToh9Jr0jLB8333e1vorvzOPN4PwY/75YBVoJlMvbbtTlnyb4V/rGs6z0WxYxQjVZMshh352ob69n8v8QrTsfGULpi2JiNK7RyjTKnundyxs4ZfDDqAgDUePxxHA2LaPzXzw8XMBV1JBcc8zgqbtcDAGFdL4gx4Thu+PjhA1JKWNYFzLnp7bUUCbRBl6PnvSAfjH92+arzvBn/aJmwmTRT7n0psvEFRuNknhLRnfw3r0mnN+ZQoLQOJoMavdeyLc3g3LP+opVK/c21n/JtX/3shj/98w949/il8BCwOORp2UFWZxiQODGuD5qhCwkVEmDZaP+LvbvH/cCE7SHiL/+7By0xzvjV3xf8H//L8ROO7se13+wq9vZ58s/nIgI8XM0QHZsHpxrAnGYA4bEfn2749Omq8t74NnNOs/kxWcbObUrmVNl5npQKVmfdJAGzUvYa7fyMuKzukUn2ekl/Hvlib0ZHBmcaQIPmujsRQ8j6bd+bvmDn3OjGskimrqenp/adf15Qp/0QYpMBgC5aGo2LkRBSQtSMZQBaNrA2Bub2bmLx9ZGxdqd846M2D8wi285yldFAtL87/40xIu837MeuvOKHdZ+39uPbm8PMW3trb+2tvbW3pi2GgMu6Yk0JNWc8ffqI56dPuN2eUQ6NNquW8SQhLQkprU0xaUp3IEREsAqUgdQAwUUdbRLQyuPcC84mGJryaYJdzt0Y4YEty+JgAJhEppriGBSs9wZVHz3Vhbhg5TVBWm47o5SjgyShC3sNRCQ3BkMYMQp7L4ENHVQelfM5stobiPpnoY0jaAaDVtIIwBgZYSWgJqh3Qp6kfwHLIs4UhNA+EyDF7vQAixhILF2jLzEUTJ1pDjgSCbakRfoEBVUU/GRiUIgq9JqgThCjpTliiOONrBeBCiFz1uwUPXrYHBd8lg9TjIhoENZtzvscnGfbmAX+2QA1G/D8vHoj+fhdjy6zeWuAMFu0tWTmsH4a4BfaXMl5WJZF50lXSY04tj9kzwbsewFYnJpK7YC0jUWegwa0Eglw5aO8lpR0r3fAt88h2pxIH3qUqIGOpmgK8NWfY9HFZn0NIaCy7Jbq3mXPPwMk/bwLVnpuRJrvC03p47ZU/twZyOzpkynT0vfUxqBvGN7jX0+2j2pXgn0E3+wUdRfd52hNyyoFW/fSgPXQjCIBzKGd2TOw7n7PA8AYeeOVXTPQu6G2+2OwdR3nvEfhdnrT6KCL+p8Nq+3lfPY8ndF2LkNbE0tjbudIzkDfb/Zce2qYyhCRGzRRaHf5z7WjClqYUa6Dlh1sH+eoz2TPluZBkdnBUpzIeDBEeCBFkov0NVQqAiuhl1LCEiVb0nEcWhLkQEhVIpKi9HVdNiTPVz6zNQDqR911dj+7///Yd5yDJR221/+zA82cAdUbVf138isNz4MD7ez+2YHmtb6yG83j1zf8zp98jxi/wTe/2LA+rpJ1TftAVJVjdpnI9oEZqsyJ6t7Id/7+mc/dg3nj9d7hdDbMG01H4939Zk/TvAzTv39hgoa+8PCcOTrbDOzze8dxjf0Z+e7YuqFWUlyTgpAMb4hzxBCdnhkPD+hgZUqp9X3up33e5uJkPjxdODO0zb+fySUzGGuy5/27LCPczBdksJaZAlnlEwBkJfhY9miI6kTESY1jfaJsXkmB2VqqG3Kn+1WFwDP+dLZ2s5Gxj/He6XLev/ZMW6dZNvDPXpYFX375pQDCaug7DkkHnpqcD1BggCQjROWAsjMOzQhQawVKQcvsofOTkpQ1PA5J8//47hH50MyDBIC6jGXnzKI/+/J7w/7nUGO/4V6SBT6Pqvsz6udt/p6VITMkctaXRyVIqZNaAjLpmnBFLRnrsmJJCak5XQPX9xF/838uiAi4frcgMd0doUoqs4BRjUYTn3KLz4HbX7tm/u61mesSEuPhiyt++xff4sgFy+N3QDiAmlDrBqgxr6ouJ85ltT1llGk8n+p7w+RBmNwVE5a4YElSjsl0NK7mkAnkLOVbGLVFH8sxd+++c565l/vaN4M8U+/2R2vTI03eamUsWWiO3G7lyLou3f9JCbiu7CqXZ0cbXMDKnKHsJTrgdZmZrw0yq1wlGEgEQhEsY1mW5iiYUsLT0zOYxeGC2LJomEM+EMMCEKPWG3IWZ8QmgzfHeNOpAtZ1kfJZWfaAOWpaIInxL+OjzRkp9JLYNhYb/5neNTuqeJzj7F7vnCiGsNFQ6PWqubV55dFpxeMl9s8cAex5FkhUmVtWD9MdfOa2ga80XUH2f2fOWsiNK/ZdygtZpjYp+3PvxDCPw3Rf+d32Sd8vrDqop5ci9wgetR87qvZ7XVdxWNJ+hKBBJoqXQMfMqMhcEHmUQ4jMicN4yDnvnH/aes4O0G2d0Xlhl0MdxdO/+5wrfrcFLGlFrf2sCX6oOFIIkiWHSEoks8xXCBEP6ztX6lbKhh37jrIfCCkihoB1iUiJEKgimw7L3J2dWsmlma72z+5lEBmXz8A0zhdDUuuKfAWyLLHeKG08TTGrFKTPS2zGZ5H1K4i6Q+DgRAhAyl1bKa2IQFH1BQmWenh4xLpesC6blOsKANcDmW/I+RlcH/H/hfb47orf+8WvEJavkNIDKCy4PLzDb/3eBev6CK6KSwcAZI5V0FKgEVb2T3ARzSijchhR1TUa+ZPMs3cGVkKMAAqMdz83eZgQN+DPaUUMwF//+ys+fPdffokYT6l+jAT56+r8/d6XXWhmHMDr5ZdvfoXHb75HiA/YHr6Qs7V9xC9/+T0+Pd10/wdQNKxU8TorL9fwKJPv5U2t5KpiehJQmKVEe4gQf/kKit2xtRh+RQHruqosP+L4s/zTMdBJNzF6yVrWyTAtrVck9yWVxWTuSql4+iTOMNu2tWcafTaMScbZ+WapWi3g8ojVZdojkDhTk2SuksAH0pJ9Ikd63Ly9h6hljAYk52qXrcRxmM2eoIGDzH2du2yg80FoOGMIwqu8I9FxHDh2cUxLKsvO2Nlb+8e1N4eZt/bW3tpbe2tvTVukgCUmRCIctxv22xXHfkPRaBYiBV1KBUWphbssK3pkxVjGpFYR8KT0TUCtkkqPTAB0KfPOlPGhb1GyOJgUX51wCrLSIaqMk4EfBmIYYN+BpRDiYLiQFM08gPsSlWYRApLSNGhko8lig/FCXzE4ZpyMZxTkeFAVzGvag3W+3Rs/tNyQu9RqmMMZkQUN8c8b58RAxODABnOYEYOzGgEM3FGQggBUJoRgKajt6b3ESDHgRyPyl5hg4IiVkGAKEplB0HIGVRUBBdWYABRdo6hrCEgaVXHESUn2lSgiZnQfgeQ+NmqG7UD3xsKzuT8zKtpcvOQsMz3h9JlhiCBGA4S94cOUAwHNZN8aqGr7OMZFge9eWoJbQVhTRIB935GzZOlJGi3hwVCLnDOPfcv+sq4rbrdb609lB7RS32sC9JrxH+28i9IpBjcP9Pip7n+LQ5ghwxQCgmpUg5PAZCS8i6QvvYSbX68ZCLcxydz3bEUeRLfn+8h0m/sQ+vsN3BI60R35bD3JG2pOgNWZFt5luWEA0V9P3QgEqx3faWGD+ajvhTmCdAb57fOY6O4za5Z9ZgYCuuHYgYXtd9L9IECVlemSjFToax09kDivn31GznlkjO5pfjzNUZI7XYYjZFO/Z8ek2dgqZJXG+WTLiKTX9Sf2ueGZttic23qcO375c1lrbvvrzEmgnJjqpIsE1vsALYVVLBX7DkQ1cAehGQ/bBZdVHGj/ads5r5eVnWGys2vO2usgCbX/37+b3aefYzS1J9nT/E/fkx82rjLWdxm/92efsKRvAFrBvKA7q2k5plY+g5phn5lbRjefGWM4y+fDbdfac2b6c9rf6Wy89PtLf8/0uhtU7vv00jv8vvdGsdf+bs+QB4CZm9HSaDlRz25j9DHEiKAO3swC3MUUnbFkPPtw7zU+6n8/jmOgJ92B0Dm24J4GzfMC3Dsw+b/9uC1K28Zl9/Z7cNf8/SNvAphzp7eOx8k2YymTQ4RIEbWOpeLaWMw2VcXZmiG6gQDA9w4uZz97hrfRsHeWIcLaDKTOc+pLMfk18s9IKeHx8RHruqDqml6vV5RyANCSQcxgFIhfjMjQ+37D09MTjrwjsJR9SEvEkiL2LHOaSwZfK479hiMfWNcFh0VPhgSKQbOrEMQR0p+LtmOcnH6/tu2q9uW5U5nty3nuX6IPs87yEh0Yr1PjsBlAzVgQAqruq0CQshos+kYkALS1rCj7p4C///dre48z4aNxEhanGffGf/L2Gica+Zf0ZnnY8fNf/BLPzxlPz0DOCYwFCIs4yIBalhmGcwLmps1Mb/f/9I2alYWCGEBiUPmdZc/HoJntipTJfL7dAC6oNaOUXeQUeHmLXIaOLg+No7uXK/1Z9Z+JUZNbsICVQ5Zn2LWzzKr73Yl09g9wuqo5xg7ll1yGjRdoxg8ZXuz7l3RANr2WTB+VoATTD9Z1w/v377GtF6RF9NkQpGRSCJLRtoaCGEUPl6xMQNORtA9S5k4MSjFGzRohNM90t1LqQANNhm/BAMBAp1/Sd43+zo7esyOj/2zWpZo0dkJfZrrjaUdw93m8xGcd66WAfdlYzbSD2jAEEDcD4BwMERp+ovuj6W3q0tLKKEuZrRDiqbOMnztvvOz8y2UOgaPZuofNwMhcceSqWYMywBUpxS4L5qNhCVLCS+l3O1cVkoi3Oxe1eSRf3vxeXzYa4ufH/ztzmpHfjQb7Z3Z6QRSb7iwBCRJsEWlpWaNsbZZSUGPUfa6lPwyQc3uyibvMKJRx1CtyuQGZsCwJ2/qIJQJARXV4gmVIqBSkx5VVPx+dws5owzwXdzSDJJBPyFU7tPJPs5pIcJ/hKRExJSzbgvWyahAT4/n5qvgNASiwrDF9nzFQiu5xyQaR0oIlLQ2vvVwesaRVgrBCgDjjV4hz7wHG52BZ//xte8j4F//NR1y++ArLuoDCBaANTAuOmsDBnNeV10Aynxt/ElonGJlk+OsykMiz91KC7dPSysL5dQ4ozBDHp4j1XcAv/oywJMIv/zb/F+8wM3O5l7jerE7O13nu/0Nylunjr3FYf82sa29ffcLP/vAfsGzf4PFhw/V64B/+4T3ef/sJx1ER0yoZre1sazAZAARYGT99PlmGlYBar8i5IgQpXS1ZvNCyt5Dy87RI9vTrbRfHW/1OnNNiywTtdVFPfz2/9HKRIUnWpxgSajkalgf0LHKmW4EZ+743/r4syylOIPeOWWtSSi7QT5rXsb2ebPqavdvkgKMULekZmsMMkWQKDGXc+zZOK21FqodS4wVKVzHKhJKdbHSIkYy7jBQDUnNwKqd67Vv79dqbw8xbe2tv7a29tbemTRTVAK4FZd8B7pEKgJQPMUN6CpLKOQQpG2BCDQaFsjvLiIgbhn9ktUQnQNv/NMFSACFC4C5g1lrFQ9k5QhgI1QAZAzy02ffyuwmyCuoRO0lfo4rUkcRqtJvBqpm62CvHPartDFwe32t6M0l9Tr4HI2ZDtgECFsXiVZUOLoWmIJoyQNTfZesymgb7WCTYRiN9wnh9H4pbM1Mup7SWgSJYazanSH28+pPGV0vEvytnYetHtm+I1BBhJW860EQeHZ1aX5sRoGN7P/p+8SDdS0Ch/+k/f8mo5Xrywnf3Th+2b2Vf1zZ3VnM8Z82oEw00D13JDwFR56pWMdiYN39XDu1dASktqNzLu1hfLKW5KUMegLRr9yMjxp55xXv9W5YbP7el7A2sMHDT0nzaT1PoLLpM+lEQtLzU3DxANRvCbAe1vydgdgY0R7pxf7ZmUKx9x+NZ6tcAIXR6YbShVhKjF6AOf+f77AxwtbeQGkzMIUbug0Zf6FqBAcs80wnO68++2+Pjvh72atAcJEQNbLw3iNmrFaRyZ86uF3omRqBGi2zlZnQGujSa7aWD4v4M2o39/XcPsv1h8+TIhEFlnqf5eSdmMJlhTgDP9nh2zzcapoCGzbecD89H+ufzWnjAYtu2BrJ4QwUwTpHNbbDf1RmRmZujDHSvNGDGRY4va8SyAPHHJZh5EfTiV77z1/zYO8/uOdkud9/fXckusvAO3NerXyjt9PJ7ZhDw/qnj3xGBvgDzBqIEUOx94QquRcHd8TwanZ6NdYORn39gTibac8anZsP3/LsA/i/TgNN+wcsOo3Poa/3wPGjuu8++dBfNDluF2Qmul+LxxqyUkmSXoYjKJNnYMGZT4yqZFyprnXaNWA7Oi9nASisr4OnAGQ2e5/Ul462f5zlbg43j89q8O0xuNL5o1ygfqxp9azKFTIQa8W2GCWriR8veoHMcQmi0vrKk4T7jQ9QMludjP5sfz5tfHO3JfNr8zWVE/DX+/VK+S8YHYlBQB24yo7Z8FhMhJok+PvKB5+sTcs54XBIsOx1Dnd2o4uPHj5KlgKU8QmbJgFBqlQhPsj4ZW2LUetZXP97X58Dfe/b557b5/rO1GWRlOL2rfa8/1YHGov47WK9lCo0vMyEkxvZ1BbjgeIrg3DMWSJEbNGfcpniQH6ebv2lMv+5sdG3Da1oqA+lfgRiXdxmlCuDPccfTlXHbGbkmMC0AFjCLId7+AWglvMD2iXsjD4dmoDdCl6DykzvPcLSIWXS3ANRyAKgo6hiwBHG6PafxXSd8aeJe1o+muSNIP5rMXPS8FABRD8Ckp+m/jhVoGZKBHHQnm7YXp3HcZXO0O9mP2z/rfFxDpiv9n2Xt7BlDY8v+EmLCsiyotdPJbVtwoGC/HVqetmdntPGyOkFYhhii8+w9xRwt0I1oXp7ssvSJwR/3GeJaZsiJb89OIcPa0ujodNbOnjk8I9Bwq6cNfi1GWqMlNJSnsP5NLL83bdGV+dKnO/ppmIzP0GIYkWFDoQVqedlj5ld3GALcPjEOKgymGXntvElwl+wd77RkATRWTjW6LDswfsGsfLpjb8LDu8NFo8En/bQxzGs6697tJ3WHWX+t9F/4pHRMjNMxRDATci2tXHGTx5al91eNsk3GqSwJt2ptZT2IJDhrWdJA+q/Pz8hx17klFLZSdLE54jBFZMVFrHyUDKG2QL8zmWX+1/BMfYY4P9n1nk/bvER1ehJHl3XdsC4Lohq+t60L8z0ABE0HJ5LM2Cbzk2ZoM2eZdd2wpAUS5EgqfBVwKAhUEafgu99UO3vlS7z34R2QFsLjlyvS9nMsDz9DiI9gWlA5opSAzKxwrtAKm6MKK/VuJ4217J04xOlRUb7Kd/0yfiR8o2nvfS8QQzRvKfPECMgMrI8Jj19nlINxe/o8h6Qf0mV/yvZjl/x1rfzM1ej8Ga+5ytj3BOHl/ag0LQ4hLli3L7FuX+K6V3z7qw94//1HHEfW8+zoX+P5fW4b7KNnT85KxO22oJRdA4QLCoqMS2kVM0S+jwFAQghHe6iQWeMJ9xj+MMYXZW4JJItRynCnlFomWeP/XRfosl/PNsmDTuN1Zvt+6FeIYM1YJo42izgKZZ8NVcrHllJRhgC17sDI5sg4/bNmup+VLWtYvI4jxNAlZO7r1b532WW83isibfjNHpr/H7U3h5m39tbe2lt7a29N22Xd8LBesN+ecNuvoFKAWpBE/sfz8zNutx0MIKYVMa1gEHLJAvip7ivZIAIoJM0UIIpiXDYQBQEvq6Z/dkCCB1h8qtdaK9ZtRUoJx3FommhSD2u0WueAZcPokVzc0v9REzJfNuiIMGy/mXHE+p9zBtfcIpPvjR3mGNJTpXqD5wgqoPURzsGm1qpg/OjVTdQjuoCqaVm74bQqaGZAXKkGHlk/K0KKfU6mLBpdoDYgq4NnZoA3IMcDjvbT1qOUjBASlpRw7DfNKEStj4FCSzFpKpFE4ZYGnsscEsCmsvr+WTaGjpm3uWMGqjcgyrhljHDjgIKtPbPDa4DWmZIzz9uva/iagabev24I8WkvLWrA78H+fUAtHgRNyFnKLnmgd13XlrKTuYBAqLUM7zJFa11XxBhxHAc+ffqEbdskOhIAQ2qPSz310iO1HMjpyxillCSlKQj7vrdMNwYWRQWM29llgKi2ciOVC0AYxj6Dvmb0tPcvKQlg4owGrbbuCZgpNMk784xZZXxaU/uuKBDLuma+LFm/TjJkGaBKmhmrhpEO3QGpzC1qsv8LkpHJ6FkV0NygOCkfIin7mbUOvNJbPw9zm+kNEYFd5hOuEt047HMH1DMzqoti8XPk9/ocVdOewwaEjCUacAYq2N8vRjaOZ3HIvkFA5apRuDBkESDJbOXn3jvTCPASmj5eufeDSNO9Q0AeqwMdKaBo2nZLJQtAI5lsT0n/On1H29P2c1kWxBjx6dOnYVz7vvda1GGMrJWz1oGTnDOILZo44MhAWi/INSOlRc92ALGUXxQa/SO9Zl5oHpyyvz/n+vm+z2kGH52VRxqv6+iK3dOB9c9/qx8LuX/WNM5Rrz0feQgbtvUBR7mgcJAsHVGdeYueiyop5ntq9tLoqKcRd8D9Z49kbJ42nhkHzm96GQQ943kAxABW0c65l5vsn89mdUa7/XPPeDizP8dy7VkJJ09vt23Dz7/5BkcuuF53HEcBLYuU/LTroTJblkyEXBnVymNpHyt3Q6OVT/BzMdL/DsCPBlq6o5v+3jNeZdcZ//UOrUbnX1oj+f0EsCRgW5dxXlkM7LkU1FKgYZXtO6BJjqgspRNW1Q3MAdH4J3NB0RKeXAr86fJr7p2WWj+ma+zz2Xjs53Z+tn9WG3MIuN1uiDFi2zaEEPD+/XuI8awiRpnjmKJGOwqtf3h4wBdffIFt2/D8/AzgIwBgXRYBfkkMl4fyB+aAfb8hxYBliVjSiudPH/rZDqMc6QHrs3Mv/e/lGvpcjpTYg+923UvHe56v+/17P+8zXfLzKvUvhNwSkaOd3Ymu5B2UErgC5QBuzFjUqTAsCQ+/w/ij//4JnL/H3/zP3+DTf740JxKCliFCly3MiMZ0Pkhy/3+ZYvsrXpyl9n+ejG8MRtgK/tW/+1t8ur7H83NGLcC3vyqQ0jwJFBKACKhRV2iYnSR7MDUDEljc1EycYYZmv0gIITaDKQM4ShZ9QfXaNUkWg/32jFoPECpqztjWhNvtCUDBkiQD7XEcXYYFQQxIPePWPQdU09d0xmyPNPllnh/VHYzmi7MHo1bLsGflCjpNIAJKhf6PEBgIFerAb3u7O3yYXAh0nuD7abyn9WvgF/0+X1ZhznAlxiSR+62s7bpu7drbdQc44LI9YNu2pk+ltGBZVpS8AwgoRRMxIWqJJnXOKwXLsmpGGskmc+QsZWu0D/u+4+PHj6pjyVoZ/7Pocj+22bBmPDel1PiHxykA4Ha7DbqYd6iZ+XmttTmqDPrXJCP4+6xF6vzL5IK5f7auMZqTYdXzbrRN14iE1hJFNBdPtr1xyJnSMaaYYM5bx3HgOHYcx67Okkll6AfkXAbd3csvXsboxsqO/fh91EuR5zvdbNs2cC2AyvV2ZqwUtWVcJtVrhLZ2JzvmrufKNTysNXMPVJP+dKxlpuF+3WxsHsubMTD/bMnWIcZoeZbsm9vR9xLFgFwLEKhlF2Bm5FIQWKl6BaQEZEAvscoo7GSuIDiHZHq74nq7iWNRXLCuC9KyIECyOVAAci0yXySBhBQIzAEcKogiSi1DYNHM82w+2zpa6S9HG6XsCxAQkOKCZdl0zSu2bcO6irxRi4xpXS6IYUFSmb85kMIM14SwBHBz9km6ryXrCVjpZiCAqjp631CPjyjHtyDam8H6p7Y9/xC/PNMazq79N38Z8Lt/EMF0AYef44YEcBJayBWFC/acpUxLlSzkKUSLu9P9X8AoEhLJBcwFIAbFIJglQ1LStUy1slelRI05KoW2r9B0foA5oOo8gyNqYfzRX3yFP6wXfPs3z/jf/8enHzVnP8UavKbN/mOfTye/3T+za/Jn17/WP58n3BxGq57xbfsCD48Jtz3gP/7V3+D9+w8oucBKvholIAh+VbnCSp4FdKdhoUesAYkH9v2mZ1NsDDkXHIdgW1vT4boM0OmXPFHo6tH4Sg8E7KVKZ7n53lFV9lyMCy4XwnEULcdoeGJtJaO6bN354r7vDS823mz98HKOYVXVZMyQEJdVaeuhOpvS3VpRQaj7DUTdWSbGiJqS6H+A0GaXEVCCTwJqVQfFxkMku4wwXcGw2MYDnd8QsKRFHQm7PFBrxfV6xfV6lXGzVD8A/5hgkbf2Oe3NYeatvbW39tbe2lvTFkAiEGVRxEs59F9GzkWAgCKRUKI0qIAYggpX+rsJYOq0wBBjIlSJF9xvdFrxYMqskMcYkWJSL+tukI1RSvWQe645WnSADoqW6TUwIdc7I3jDQI+cBYuwCkAivKuCmTRmyhnbj1c/errBe8DZz40JxZaNQ8oxJdR6OABCQHKweKLLB75vL6smfh5ngFOv0M8nozIzahHDr81Hd3ayCA59ZggNuLY+aVUmucZF+8/mR59KG1UTrHLPgGSOEd3w7MfT91tf6/u5uDc4TEYUpySdgXsvNw/hd+OA7VV/jRmPehaKDryZA5J3QmglnVgjnUXvAEgzMlEf177f1EtfFMVSMpZ1uQN8zTBkPw3wa8AfoP3rDiBENgehgduSrYia0hSjZFOyCH7ZJ9NMNXCu/+3H4pUhA42sZr03JotmfW9c8+s8Ggg7ffCZrfz3ABz96eWA5KvujGLKq/XR3tme6Yw1LxnB/D127tu5hI+EnI19+uxGC3WtcO/I598xz4tEg/iTOu75rnA7xz0SR51aLBJQ97cad1p6fbJD7zN6zLTGfipv0X0hfRTlWKBWaq+w1pzjGuJE/ec859ObffP86LU2O1EFdQxjCAiXSAyqvVwXg6iXYpuNjzMAm3PG9XrF7XZrNG7IcmSA9GREZmZJFWz0ER/zrAAAIABJREFUDD0bT6lVSzOsWNYN27Zhu6yIiUGUQVCD3Wc0A7Pauyc++Bog9lJj7S+7J4+7ce7D/Vt+6L0GmBGLMwD0fa+teHNMm3rB01X96fbda70PAK8gSEp5CYsXeSwfB3LR/X4cOG635qhoGcc8bwNGugGud/Rl/t3/fQbmnf28a9TP4o9q9jj33DNj/Fnf5u89HfN8UuYB6rRGp/daFN9xHA1gjEmiRGsV45qc6+7MbUanBkDCRcVTnytvADsbUx/PKCN4g+Gpo6H7e84U4N9lfGeOzqu19LPKuvuVl0FLlJI6TQYKYFTUXFtUriZhBEAS0SuimTh5aR9iEksFEyMo74+avYdZrnUjaUAsg0/3xJlh1eZxdtCYr5mdhDy/PZPjbJ1TSti2DZfLBQDw9PSEUrJkFSpAjKUZa73T4vV6xXEc+PjxI56fryJTrSuoHgLE1yJnm4GYQnNmBMQZcr/dAHCT8RgVmB09SN0xmtzMtphwh8uPus2z/N7LC4xGgM9rP8QfZ/nG5sYyhAIjnxW5cuyTjUnOMWOnHRQTIhhxY8QloOi1ngvZU9o2hZMoGJocjqZve7OzOI+wS+09Y0yf6f5JO8vOWNS+Z8lwcLtWXG+SOYU5gSiCOYLq2Be/7jYlXYfQeUaFD0aQKGvNEqm/i3x7AKWCUEBMyMiAyQpFnVO4qCynTnCQrJXM3DLS2dh6WZmZ+I/n84xuzY0h+jAF1hT9Ku/VDMmcabQsISxCW6ysLhe/0p3zjroE9HmadYR7mZ82j452GH/tfe6lbOexzDRkzFzVdfieQVMLbJGUFI4xIufS5m3fDxxHbiVARN+K7fsYAjiZzqtysB7iWsVxL6pTQgjBObyMa+PPpA8WsOYDhM50Y6+j3PFdd+2QDfSEhtu75ubnVgI8qpOjSUtc9TkHerBGcwaBBdMAhO6M1XQqUqeSJjfL/jE8IWvZPMHDDuR8IKaoZZHikE1nll9MPzrb731eC8yZRGSU0HT1nI9hrzDLjq1GR5VPN2wi9IysRJbhJEgm32wZa87P392ckGFr3RDp+ehM320/zHuoX995DLNV4zOKKsFpMz8+k0cBR3UH2bPTJgaJ4Tz0edkuF7lrvyGFgMeHDZeHiwSbgUAUJYtCPiAsSjQC1rNRg9K/hhve6/Lz2RC+FIZ933TRCuXhjKoBTAAks0XOKLWfTTu/FkDRs050h0Ewa1YtdaCspLp33x+9vxXHcUOtz1gii9NQPOd5P1Wb9abX3nV2LSiBKYEpohgGS8KDijpWlrJDSocygIhSY8Oc7ZwxJFNGPnaUkkGBsG4raFmFxhSjAYBkYAsIoQcQEiRDMyCBdx6zMue8iu4MEGNCWj7f9PxTzz8Nv43YxxkGcjr3p8/0js73jd01933RU28yjMo4inSJSwv35zecgcWfKYYFQMbT9YoPH59w2w+5JmimdSsJZ3I+m7OTOs6acyGJc7GUVs14enpqzmsgSEBA1qCzpiMBhUsLmJBz7h18q5S1ds6Inqa+JgsZvQXg+Ha84433utCo/4tzsy//1wNSjEbb6vjP930HgIHHhhAQUsJaCnZ1FJ0zixvWZM8jIkR1Nq1ckTODarcLSGYxeW9MASlFMBfFqCoKc8sk1mQPlXFKkfWSMUF1b6F1Qh/f3Dx+qvY2k2/trb21t/bW3pq2WgryviPvO7hkUSSOQ8GBHTnvABFiWhDiAra66rDaneowkyxaSYEZVsUVklraDDitZIS22eDtDYMSuWkphQU4akKopZOGpq1uQAA1BbgDIqLGUBCBrAM53ZBiOHNQsV2yHXTh0ABJEeedgfLkt2F+vYFzmnc4wXcWij1QJWCCOkk4ZyEP4fbfDWA2lBB3z/0hcFwE9xYC2hVCvc/AN6La8Ml8ZJRg6fkVxFIAn0sBBY3m8LBzUKUXHcxB/7YZcbqR2wHokFrsYAzCe7ub+pOk7+a9zqh1dEb6IaMge614mst5fYd1ZnXSUWHfG8WmJ7WffizWxznttL2391deUskiCQ7JNqQHMQQBDksRxSNEAYTFSBWHcTD3KMLb7ebmRudQgZ4exWzvvwdYJVpDgdXa6/f2KEQ505bhqCtp8lyr4c0KYJ4BtH5OPLDn19YisuxeX7vXnAtq7SDUvEbWX39GLYrRp7m2a/2ejQqqSMYXAVH8NvOGUQ9gj3tSDFyMADtyI3hs+8tOiAGvI2TxOVH39mwYaAButLCdSaLm8GbXyWT0ZwJaegoGkDonN/cuhhmwOsgif5AAH0Z/GOAaBFypNkqjT5ODC/f+tI90/1bu6ZjF4W8s+9WTjJBNEuYkzaSfh2ZUNkhFyzlVUfgFWLf62BXHsbf1snUes3H1f3O0LoAWVTrsX7f/edxYrWQWaj8HOReAVlAISOkB2/aAy+WCFDNq/YRaLwBW/JhGJ7/5Nu6ulyA2TFe9HOXP019nTjM/1ExyAHduPieY6dRVo6Lv3nz2+7lEcPnqit/5429B4R1S/BJEF1zeJVSW7FqMjFIzuBQcpeDTpxvyIeeG846ar6005j196PupOf1hPNf+Wv/3/JlFUp59f2YIsc9fu85/3w1cApC1aGd37Rm4ePb8s+ee3Sd7/752vJ07X+KgMuPD9x+ExFBAWlY8PDzC+JPM72QsctnczBngJVliNq42h0gHXr7mJDM/2/Ntf73Nq537MbMOnxxDkx31GUXlDFLefWhWBs0GaHb8gIiQEogZNTpDDsT55c6QpI4irGUKiLqDphh/Yxc03Xhmp5d5jed99BI/tWfNe2429BGRRnuvTRayqMaoBjAmAlHCuixYEiPnA9fnHe/ff0BSxyCR16XkhFjiNDrT5oArSmGIuCYlvpoMREArr3i3B3Qd+yduXasxKXeNGhy4806hs8bfXjN/9Hn+Mc3vyeHeCk0B0hULdroaEYGrxKpmlc84Z8QasF4eVEcLCGlFjI8IMQ1jbXIFGJW6PkJu5PbJ6CZJ7v9oz/KfWcmHdpLIJNTuRPNbv7/j5793w74fqCzZHYGIYy/Y8w1Pzxm3W0AtK0IQg22gCNZgFJkzAM0hxfdx/MzOq/wLmolya84aIqcqXSGTjxnggporciC08kvlAFBQyg2327Nk20BFzlYi1p+PcY17n7o+zThZe9zTtKav6lpTLcglALRj31MbixiNAWaXGYUllYzwk17GxnrQZWNoNkA1mrHj7yf632y893L+zIt8IIOXqSWDqug3KSaAqQUC1coIjxFRfz+OjNttRz4KtssKKIYhfZFgJaGdFcuyYggkQef9JWctjyDXXy4XLIs8T3CE2JxKxvHxQDNtDoY1OvmZtGyMp9Oj00W/vjvtjJLUrDt7nmHNZ9U43T/T/EuQ1QEmK+dGiEno9byuYONTs14pNL22rCLCYx4fLzpuVt2mZxG15/qsp14mGXStpgOY0yKrY47o4N4JKKWk93ae5nVN2+egUX4yrOgoBaXM5dDP97Pvb3suRn3xTMZ7LcJfrneYnel26E5WzeHHyAG4xxY1Aix8l5UvMjQjjB1oMmqM/h6j6ylhvVwQiLGshJSAUnYcR8a6bEhpxeWScLuJ42DWPVdKBSVCQGwyzSxXzNl1tLMIYYE59TB3km57z2gsaem1yhmVEyItqgN2XVD2AhBCQYxjSVZSHiovsSyhU4AfMUKs+H/+w4H3v2Qwr4jxK0R6h0/vtxfX7se0GDN+6w/+Iy4PCcu6IYSEUmVtTHZWpgWwORbJ2alFaEfOGQxGCAtSegCFCx6+WsCB1AlW5y6Xlh0k50N5WGnyRAU1ut3L+0nG3HwcYBanaBwZdTmET+p5EafxiBhX+AAvgmXr6Vn6UrJypRVMFYyMhvkF4N03CX/ylytKzogxYKufcP3VDf/3X301zN3Pvsn4b//1FfkIyDmhgvD994S/+g//WNO1yTUm8wGzFj1ePcuB87Xz9/b8TtfPr3BH2UMVzTlGfw7OMvJ7iAVf/cHfYHm8YP064sPHG77/8BG34waKimNaBiUUhIYLcKOBhuEzG8aloyU0h7RlWRzfUqcToDlOAuIwI05nh5RNjSJTCU3uAxOMtfOTM0xnmGXTJXWmQoh4eHjQko1V8Z9yer/xrlJKy4zp8VgfbGV8ZAhoBiSYiqjJbr50bkwL3r17BwoYggRiCMgxSjZwLfst8pzSSJasgSkCpTKCOswwAyEq1h17cJ/4M/U1inoNGC1YiNkcWrvT9GXbVPZ9c/P4qdrbTL61t/bW3tpbe2vajuPAcdtFgagFrMBALVmiKbmK4rKItzPDnEdqw2QH0a0BA6oXhW40NZ02TEYFb+zxAmXR/pjDTJiMzfpCiNBrIralp45NoTEgj5yAzAxYbUzAAHnWlNisGWqipl5PQ9TBmGHGxMv7xk0hHAEhoIPlMq5RkB4BJ3tHH6uNl1tWHQM6ZF2YGazZHhR5hQcPBWDz8z/2mVElQgUEIm7DbUpjKw3T01YLKIWmDZGWMWlCs98AgCoppjdzS9fYcA+y67wBzEAXid6ppQyluXwtcuYOvI37DLCsG36+XzK49feer+9w1QA0+VIvrxsi/P2mIvb1ZAXssjq3yLU9wsg+47a2uQjIp9qLpMVU8EeUp0XPVIB3QvOAJLNkuDCwToyLDedoaZL9PHhHH6u7W6tkBPEZD8a56tl/2npAs6EAmp1ojCB/ycCVUlIbU19vczbKCqT46Ai/BwYDqOunRXjNoKdFdpXSwXQ/ppZxIAQUTdfNqKCqBsIJ1Jzn0jc5k0Az3LOVaNFI1tQdB82SafXezbDpAT4Dh5cljuMndYSpLICP7VuxYokiK0+Tc0f9MIegyW517cf+21n066jAl12DfubbO3VMjW4HpSMvZAyYbtaf+o72PNZSgjM9opNHzGht76vtf1s7MQZrWnYt0WUgip0lA8HlDJlhQdRSK0E2g9Hz3wPwAgMPnRGj0UA1ElWLEq/N6BDSCsSEGC9YlgvWNQH0hJw/oMwR7j+iGaeZG0NtpO2vH3Zx6cDe/ef3n41OMy/dOzc7NeYQ5ffj/CwDsey3l8Z5NgcMYH284bf/5JdYl4QlfY0QNoDFAZlxgHGg1h1H2XG77Xh6ysg5ysTVA2y11ae970Gw0ZlGzQiTgWbo1ynwhrvr/R48deB4DXw9ud76XYpP039+3WzUmz8/M8gOkdBKqzp/9PSbHPgW2hnJpeDIBbUSlsJS3sRFDHIdDU929gUovHf4mf/2Y2hyK/e/XzJKnc2p8Vh/ve0Fn/XE7x3J4PDKes7zzEDL4AhHVVnkQ8nAow6STGq41rmn6WwqL6PgeBY6Rbgjw47nv9S/Wc6eHY7Osqv5+X/pnznL7PuO5+dnHMchhu9owLtluxQ9Yd8zrtcdz883rOuiZSGS6lSQ0ngk0ZcAUDg7Xlk1myXjklIzPrAtspNr3UoN+6B9NmSj6dSw8woFyhlKOW1VU7v2tXZ2Ds+uuacbTlafdA6o/GEbgGtV0F7PGwUcfEPatvbsECISbehOfp3f8/DfNFvmjHvSZo7fNS9SZxnXbzO+UL+SQfj6txi/+DMp6VYqY9sCcj7w8cMzPnx8xtNTxrEHgCICkspawb3VTD3FdxrjxPUeWrkBcYRIraSqTKkaYqkgxtDmQ5zYRScMqCg1o2qGmdtxxb5fkfMhe0SzStr6iVHFl/OxnRqm38fz1uZ4kqVlWOp01GhVQSlwMpPo4THWplsYjwtcVQYfnWXae9uCstOn7/nG0B/qJZcsQ4k/b7Pzhr9vkLWrOGanbWnPTGlBzgVEGcxAKVlK/ewHOAErA4EiQkiSOTRIiYfSssoGtAyzQc8xm9OQRdALD9i2DTGmpi96+fElp4eXMnLNzdNWzw/PaMKgh7upPOPf9k7/HO+cYPfMpbXs+lolQ1KpGUyjnkztrKoTWHUZWghYkgQaAOJkK/NWYE6IMUUteRGaDGP8DE6H9fz21FDKirO4NbH7zDEa6BlzUkq9TBjNc3xCgxltr8seM4eyxlWm83LfyL3H742Zrt/jVjOf8mukJRk9HWuyQudTbhjD/d0hWfc8oPf1eZWnUssiIecQoJiwXh6AckOpO46DtcyWBA9ZBinJUtKzfYpDS+p6ldtnZ7LE+Fls1LyPrf/rGKuWOOF+Ts1JaqaXtvfaHmMWPVKELsXuIggRLbCJAKIKCsA//G3G3/81AGz676drIVZ88/u/xJdfr1jWCyiuIFogWbHFyaVkyXC476LrpBiRlqRldYKUlgOwLBdsW0BaEi7vKioV5FpQKqFU4MgZx77j2AW/LscuMlQ73z3jNbPwO7DgcvYuWhiUGfl6ACkiJMmECM1kZ1ur0XtIVijbv4ZhhqhZ3qi24ygBgQHbF4R/8a8WcAmIIeCL/B7f/6fnO4eZd18U/OmfP2F/XlBKQAbhb/8Wv5bDzEwRaPr5kq56Lv+9pNm/9OmPb03+d9Ko/z3Eisff/Ts8fv0VKl3w4cOODx8/oqJqFt+e3VdDNdtTAM8fuhwTtOSa0SxxmEl393DtMgkgj6hV9rEEkzna6nXC2nFmTy89X7BrTVbQIwyT69ZVSrSVUvD8/Nxo+cwLzaZiGWaO49CAw06721w3WqLzTgCI2pwx+t+lVqAQKAQ8PD6iZ2qVHZQ06xURIQOoWemXPoOYJEiACAgWrGo2F81Qbg7+qmpi0pVjELp47HsL5pTMiSrvF8a2GR37Yf3lrX1ee3OYeWtv7a29tbf21rRlFa6a9z8US2XuipymniXzWA4+2gItbSmRRIzMSq7IkeSx29ZGwKBq+nwfHaoKD8RYagq3B4FF6KMmdPeXz6PV/vEMVHSwmuLS+2HjY3uYvodm4za37+1aL/b7jlgfQyDUV4yTHfx3TkIKKptDhb1bA1dhKX0NTDJDvwcJW3dhoAO33wEgUAUHAzyH1zbAYBxzB0IkewMLsGwGEctGYtFQei8zKeA39qdd0QzKHrQJcr2CIRUEbuCeOiARJOhQNQ+539LWOnBe25kiMYN4ZjM6MzK9ZBQjmzBm/zr33v4M/73fKeZZX6Pt167sgc3734x3xSl/rCn+e21yD4yJ4kdtb1nqbwDNc79WUVR6NgtzXDCzdx9raPXD0fZmA6z8JNp82MXgBkJy5WZALVUySx35aPRG5mmcyDMgvqdaHbMwEESNNmeTnj5a1xsB1QF+DWSxzFhhPHN+pVgBFf+89g9Bz5POsaTY6iUvtHyROTa8ZiztZ9nTlZmojrTGDFVQkHKyS3Wg1kXQGp0HOWcV6vvFjFl+rCFGqQ9NUEeevq+7U5adFwM2OsgMSMTJYIAgDM+R8xy7SYzReJYBDLbV+tZwRtkJ8DQ6zTDa06evXfMCItQdLIMCcdz6BUD2M7KLbDOAzb17ohctna0Z8JlRNEpJcA3lvc1A6HLfGEjR6ANr0LY6yuSMrEBLjCvSesG2PiAGqXf/6XtGPoDb8/l4z5rnbK/DFNKX2iLHHO949a7z9zmo/dV7+7WOlg/no3/iyFG/mua7HdQ9GVxbeumpb8vjgZgY6yMD2BDjOxBdAF4ARNvJMP5V8qHpwhlcCC3yfgLIAAPlOr/sxhpugG7n/ePvdv/4+TD6ds2Zs8HZNf671+iYOZaM/Zjp2L0jaze4NVTR0douzwyGO/LvwGmfZsOHODpU5CL0//npqQHjQq+qnqesQK3xEG7DEF6k9GiQaY0fsfIABQ8Lt+/v6dQoe3Wabp+dEym/vkZXPI3qMuZ5GYU2vwxQ6iUH5Xm2Bn3tWySu8XgSwy8F4Q8xRICCQtakc2+RwPI8mcMXiO7duPz+dd+rMyc1wQ0DOM6VW9lAIpFzTJexZnwx5wPX6zP2/aZ8zpzFZRRixJTn3LRs2rZtSEloeCm1yZ9BPJVQKyNb1h8EdaAROYGrAPnMpa8woTmUv2S8dqN/5W/Hn2yfkXHiea/1e+ZzPTdvFDj//rw/dunZvaw6n2SfY+lntJIVBZQk1X5FQLgUxHcF4ggvOshxXSQjHYy+Ag+PByhJFqmiwQoyryLrhCBp5ANio09NhoHJU2hGBtN3xGgLlVcYaU1g3sRRHQXHQfj08Yrv3n/C09MNrWQp9CdZiV4vj8zZZRwP0/PP7u8YQ4vGrVxbaSfTwQZ62mgdmtxC+rel5jdDbveJdtyUGaZnjs2tn61Zk/n69z6L2Xg7A2ZQB8GyX3ajsbxb+gY9Uz2LwPkjz/eurePd7GpfbQ49XfT7dW5nWd/8fRYlTs3RumLfD6zrIRhHkUxnko2oZ2pJS5KyMZbhVtfaYwBmDOaG3/T9KVHuQaPJdc6iM9S1YdPU55GP2vdCz5wcb/qUyp89Gy/c/XOAkedjcOPoWE6Tp+1yO3eO33gMp9MPl1WICBRFByOKqo8yRBfzwQLO2QGMUsVJr3KFqODiGBlVQMwlQzItyzkIZM4us/7WecoZe/XnFqBhzn0pxy4X2JkTA6Y90vRsrgyK3WFL08GiFg0+q750GdAdKN0nfN9X0X+7jFCyZbx12Mmgz3Q+Mz5I/+dkpco925nofCOda/P5grR/NobWDzKNwfTVgBQJudywq/G1qq5aa0EuB3Z1oBF5LyAm2TvcMCyl0zoGk1cqOznW6f6m7Vhp4jP+zCznJ6DvYftp5TFtrjDIvkr/IBn9QCb7KAVtjnFBT46M9fIIPHwp5eaJAK4Vx21FLT2k4ce2Zc1Ia8ayMS4PXyMtCypHcE7YLu+Q1gtCkNJz+74jl4xj/4RbIZSQAFrBSeRCWtXJLC2I2wPWZUWuhzgVHhW5ALkwSi44dsGv836gHhIoJlmHetZqky2JCJGsPKGclUoVuWTJKJkC4rZIyeIoNAJep4IFb3Vs0vBphIAgm0x0fJORSR11KCItq6xPWMAnpWNKAZ6ujJojQrygckWpx+l8jxz1/Dv7nk6/66Eir633eL1/6uftk/nU8vS5/0kY3wcAYdmR1gNpY4QUcWTGnm/49PSM5+dnweXUN7fJZtXoT+cvxq/agI2HNbnCXWP3wJ05cjpe66JSJRb+jRbIlttzWGkwmt2BUIrKF46vvoRteh3NHGC6I19jlXf3mnPlGVY9/z3KOON7vWOwZKczmmwlAQOQI8qnhJoZ8aFnCTN+UhFQVJaU4AqZT3HALEqDTX6xzM0RkRJgeushpepyzlhS0uwy6lDPwqvzIdmm3tpP094cZt7aW3trb+2tvTVtlnYUqhRIlVc1LgdC2laktCIqAIxAKMwt1Wmx+svMCuwwrF6HCK/9d2agckFMU0RNOVra+JSS5B2FRJdJmkXSd5GUOIGKo0QAa/kkU9KDCbaj+M0IKLlqthgxHK5JQID9KMjHDgZEqQEhpqTRPgV7lmhdMCO0MkWm9KtwqECGwhmQKC8ByHPxpYMIVl6JqJfW8QLu7HzRnB7ACJQAWDSZZSQQpd7qd1r6SANjAVEIADTDnnxIzVAu75b1J45IUVK6CqgmQr9Fq1iKYgP/TOln8VRpc0KAlhwJyHlXwd4ALPm3xKTriAa+MaOBf2I8hiqq0D1GHRxXJ4tcCji7kjgVIIoAy56U+dYat9pGQIrRjEos0S8t7TEpNKZRQP6euVySNYtMst3X1oAYISR9T23nj7WGt5QBWJrHfM4FaU2IMeDTpycpkwRJ8Z1iwKdPH3G7PoG5YF1XPDxc8O7dO6zr2vbV9Xq9SxecYtTUz1VqaJOk746xK3AxyVhLqQAHXdbSjE0+iq7W0lJ1EgSUbTV0ZYYQY0I2x7oG8lVsl4vM43GgHkIPYozdYYao1dedgUQ/Jok4I0QihCCJSKz0B/R01lqQszgYbdtFo1ZJsoMUbsparQXHoVl6YEC3OKbZPraza/MggLc5zZiBomia5X7O4iKRbNBzC5BGudl5F0UzaHSazWAIqQGIQY2tFrVVA8P5YgAcVKHvBuVSJMVzUzDLgWXRyLkiUcbMASEsAPVsPbXoXmhOkgb8yT4IIUgkLGvEcig4joyci0ZjJhcVQ6AQQUWNTQpMMwPbdlEjY3cyKSW3LFJ2Pi0N/L2Ros+ffGZGAdZ64gG5VhBic4AyesYG5uraekPPvdFH9s/tlhEiNboQghhlay5IIWBdhId8/HjFF1884jjgssj4zGZoe1uoLbdophBD4zeezliWCwNtuBTliZZ+uujZlX2cc4al5E+U8Fs/+x08XB7E8XAP+N/+p59jv/3810JLqW+6UyDP4DUrvRXYrvWuMz/2ffdNlo7vnFf8fc3BdnqO9WgAxJjuHGPkY76fpvk67cPv/5u/w9f/8oZ1/QIPlz8G4WsQXwAOLdMRBUI5gP1acb0W3PYK1KKlJoTXk9uXci66k7IBWL5cUKDO+6U/3TO1GSesn9Rn4zWD+KmzTGXMs/GSkXK4n1yZyfZ6bn0jGKApX4odRo0OCkwb/bFzHCZ+YP0WELOPZe7PkNqehH+8exSA/3bb8f3777U0aGnrYXw/pYSHhwds29acPm2S2/pWwnKRFPsW3VqKGGSlHIOMg9nKZHTAVwwe3MYp6wBIlCscHZHzbdkYmVV+Jp/5TR03Ys8wMNOVbhgtzvAmzupS5kJofwiElMTYx1XoWsUhbCfKvDCCiIO6TqzlTJkZJXe6bxPGLgW68VQva9mazTIygcBBokzFgGFRjtTkDQRGpIAQIipVxCDyTAgB67aK/pFL441EhGVJGs1dnH4SFJCXsyZlK2vL6HO5SEaH6/XJzanuq2XFnjOer1fs+w5Lud7HR5CkNTIXaKqU7Yc+Vy85ON1Tx/vrzMhs88lq8EsR7j22z154jT5bnD/QafkE4JuxyX6HGRSHfjnnfAXNwQUhVFAQR1xoudf9dhPHy/CI7XJB5YTHP/t70L/8DoGveLdk8PGM//y//in2b382zNyf/cXf4evf/h5P1wPX2wEgYt8LGBHLsuHxiy/xzTe/h4oLjhpRqkTY1lLU1iKOX0uSrDBFnebEsE5YY0Qp8uzv3l+YfniHAAAgAElEQVRxu13x9HTF8/OzGAlzAYGwrhsu2wJQQKmMXMxpxWXGYnNsmPkKgMkhIUQgJQkmoCD7/cg7bJ8wy3kOMTQHIUIAMUFsfQQp+8Ooxw3HbQcXRgxiEJEMDuZgYNHRtdF9cyAiqq3kCKmDGtqeUJk2iAxnGS9GuiZrHULCsqxY11XLCfV9S8Q4jlvPyFBZdHeT9bi2bH5GK7ojX9AMDiLHw/pF6qACanrL7ZPiATGBotDN6/OTK5kWmizanevykNnLyjtsG+GLL77C8/NVxxARozifHIfQbRDh3RfvsG0rPn78gOfnT1jW8P+y9249luRImthnJP2ciMjMqq6+aW7SzmUXGGEBAYIe9SAB+tl6FATpaaUn7QoSIOzOzvTMdPWlOjMyjruTND2YGWnk8RMVWV3QAsJhd1ZEnONOp/NiNPvM+Bm+ev8Bzy+fRHdL0jchRZzOp3bYR5y5UtKyIISorEzAmndUUjs6BrCyTOzqiDX9I1CSGcgAk6TYpmmPaE4tL3tCRAgRg6vdAilMEPjrDR+wvVuDSU3HD9p3m6YvlX7uTrZeHcHYAjrGsKv9IvMxRMLpfMaynLDvGSWr7ZsW0Z+ysKzK3Jd2bOuKooEEKQWkJaKy7KkxSB9eLqvqWBFLOuN0SsilIucNtRY9ZBZagHhMobOFBGMQ6Z8TIj59+tTsmXW94P17YZ8wna7W3NZN192AOKQeJ1CFMEXpaEiK2GtmQu3J7tiE4CXNLmqfGgdZP0RRLKVGw8B0vdsc4R48ZIWZW8odCqJDBTJbGZKuWKdGkydMCBzaM0x3Z5ZDWT09edf17PcQAlCh9iq1utvcY8K2Z+y7YXMLUjrhdFoAJnz8+AwiwuPjI07nEz6vK2p2+xg5rMnkDAos2M8OdnBznttasDb2vjJdEGAsNeuclnTOHUcAYCyh7T2gumHVNEbqnKeEGBaEJSCdNSVwAAoztrzjr/5r4Of/8hNenn+Pc6zYXp7xH//tf4FPv/vKZsUXm4E///Nv8Rd//Vss56/x/sNfIKUHVA7IhVA5YlszUjqDKOJ0qljAWJaMn/xE1tqyLDidHgAmvLxcsO0in1JKoEj4h3/4B3z89AyZzozLywbwGKi/pNTmZFW8tK8NQLjUVAdWESVp3SVwplYgwQ6eAQ0HgKbUhKZ2MwxS8c9cMgIzQhC8My7SjqqBd2BC0hRbsuc8INO1Y3+vAR+3M949/QSFF+TtBcWtoe/X7N5auuX9lqAZ/zzb8Ueb7/ju4yC3a4vf2+PUvpXrHn/57/HNX/4dnj78Au+++iX+4Vef8Ktff4uPz89AICynEyIFZRyRwPPChudAx9qwT8BwdHkCNzudKGJZ+nXyoehAiLLPgkjTgcLJP/1ZM0q+AFxQi+LxizDJxRBbUI8ELua2zw39MGM83IOcDRs2TNXSPYmsFR3CsFsAqm/mxlDm9X0L3I2xM1h5xqoYYwvwNZs3xiiBouhtTNqW3/0/wLf/R0R6iPgX/30Ckti4KIptMIP3HUxVMUpJtVSVFc90MyJCCi6NaIWyZDO4VJQ9o+47EKV/jdApRMK6qZ69r4dz8V6+vNwDZu7lXu7lXu7lXrSIASt5WUtzLnP7Xwh6qjIImAsLiFED3StkcgJGMZHDZ/m/TPVW5UuZLGKMwjjBDCrUcnqSRlhLVHI/udOUXtW0+8kSr9L3U8BCm6nGAmtaH9ZTU+jgWjNS4ZwsdOu9RkW39eukEPsTTXIy7vqauXgAQuqVAIfWf+oYm51aXZm+aq2+iPSDOdStN8V3Y7SiPBilXZHvlJI+Kj+AEBY1DrifGoYaxHaax4JlmJ2zz8bAHGckzzZwwPo9Z6NGZYAzmEtjcZCHJQHAotBY1xpUGY/dYKXjXOi+v4/Gc3YyeSfO6Lh3n7UqCCFa0JG6h2IAKXBcSsU5nfH+wzvUUrHnjG1bsV5WMciDGIUxdUaQslcNkHnUlBFVHfSfhpzvDw8PzfgxIFcCGsSBfl7OiJGQyw6j9hbHvjmlUgPM5GQbqSGq6wl9bUuQkRhcfe7WoQ/9/PTOMWDMj2ugt+/f6gDr6zEUmVRKacFpkppN7pmdpkb7zhxQa3ap3wJ8UIqwghgtu83ZnnLKv6MPoLL5kpIALiy3o6KgcgWKMFt1mqV+inRcl9Q72L+t6wc4ZwsZEI1+CnGWXIR+OsPuJ8srT+LY9ME6BDnlSlOwTAO+0ed9d2aM1LPNAWqtJJHrgft68mmjzOnZgXLtk6v1ac69DsaMa9ja1ps+OmKpfzEVCzSU9rprSE/6Bv8Mo2eX+bHv5rxZkfOptedWEIFnnHitWKBMu0/Qbu0HDXAke9l2lTq5F5xPj1jSCSkkRAIiR5nPR5j6m4oB7H08rtrs/lt1rw02vj/oaVYvTz9tnNxoMr0ywuNnNpPr1OquFR2913W9bIE74YwQF6T4ASG8A9fYgDuroZaKsjNyZtRCQoFcAfAugGvtcnKWh7ODwjtT+tQaIVFu39HBS9wAP2/oKeMed7vM+2N/3tWV7cuuc8jIdRB71EesXr/nASN1dQihgYwGEPp3s6ASO8lnTs/zecFXX39oQRjMQuNveyyAFuxszi1L12Z1mGMFENaZSvXqO3OizR1j8snEXn9nCbg1Jj4vn0yP7vLXArShula5mj/z736uETOS0l/LiXjZ0yyFwF735oiVEWRUzgjxjEinluJPYm80YNMxg8FkN/XEbePe1ou9W9c72aXltNOJfo6Ma8avFws0N9Bc6o3NaQ4Ia8zLywtyliDeGEKTAqVY/1sggKXe6AFV0q8yppeSsa4XlFKxLJI2J+eClGKTO0RAtfa39diB8+4sfq3QjWvcBojef1/uHpurpSY7+tbU16h8Nj7nSMdGNxd0nDTNYwjd6VEqyr5jW3fE9QQKhHcfvsGHr75CoowFn7G9/AH/tJzk0EezJQi5JOR6RogP+PAh4cOHr5GLHMQAAihErFtCiAuIzjAmEMROMc9csW0mR06IcUHggj2/4De//xbbLmxE27a3YFXTY1O0oH2glB0SUEat/4bdhfweMXW32zvMYZILIbAE3cVIPeBW9WCxy81Zr7LAbF1oQAKrHlWrMmzIuDWbZdhPru1eC0zjKX1Rl/le13KDrrYFA+pEqRoQWiFpi3qwNIBmx9QqDhibL3awxN7b1sy+78i7HkiBBM3I+vd7DAYHawv+d4HVIfTgZavf9hRLqQkAT09PrX3MgDFNmZ1jwXchBA0mt1PpPSUPoyJQRKlFg6arMjiaXV/c+HcbxDu/vI3UAgttkelaBY2ygt14+oDFcRzR+mEs098HOkPfC+0STfXDvW8YehCFezXxYC8AqAVxygGJCiBLKq+8gakgJoB5U/2oH3LZdzkgQYFAerio1h1F94UYjVHTzWOVlQ8PZ5TMmo5X9ubF0gGzMU8C4KBpmSv6IQOtiyvyXrHvpb2/9I8EURrO1Z7M9n7OvUxQZhLf5X2smEf85lZRDaP9z6aI2UsU+n7q04w0nbvpD2jPs7b453Z2Nve51jO0cVLWB32/1Wf64PV7GY4H/7XpThSwLGcsMSDtGTGIY7nkik8fPyGXitNyxldffZDAM2Zl3Cot0YuM04gF+T5v/QSCpEV6Xae2/ihF0o7EeFGGZjukNcq3Pq59BCuLzLC+KiUg54B9j1iWNOhMMQY5HEXvkViYU8LEePIWq2yU4gGIC07nJ3luFuaIvUCYYXJFjKUFHwYi0RkBSYPDAdu6y5pExFkPm6zrht/99hN+/7tPuFwuaKxjtV71fSkFxWECsmnpBkEzc9v4AtaXlv4856B9pWmXIMEYzqiErGsJJhP4sYIg44VgNpxiO4R2CPAPzxf89rtPAN4N/bluO/7pN9/hF/QeS5Q96PxwLfd8uPG8m05axI1ikuz4u/lp33/Na0+Zbe/XZ9Y4p1gOOqWIEAkvlxW//8NHfL6sYBAihXE4VBbLWGnAFMZgey8Ga+22EzDjSf1CmvCiWZba2sz73tgrKUQwGfs7wRjVa9W6eLRju8zEzWcAaMEsXQ+oqhvzVRs9Vuq/88FePl2tYXemg1zdWxmF9FAcWfCXyjylWVyWBeHE4EWCp2sFUDJCA1+tTzUMMwTMdp75kaCHKfddGA9DJDymB8FTFaExezTnTe3c78fP7uVt5R4wcy/3ci/3ci/3okXAXqBkOdmS866GOiFQREonpOWEEFLLMWzgVjNdVekU5enKddSeQxrdL4eE1fzknmaJNF2JndINISqQKMZ2Sgk9VYoZmtfvA4JL9U4NaCJ7OLip8WaEGhhmSrV3tFhQincmzA771wIp2omZVr+lnhrTMnnFeQa/7H3n6/19ne2jDnWM15tzRZR2A766Y0r+lZqbsdGxDWp90XIjQwMKOCJQlRzTxBqIpH1RGYgwa8ABCxphDgH/okvJQnqKv6VmstmkKA4za353l1aHjY5ZnUToDpEWgEA2Sa770PedZ2TxdPgeMPLjPjvxroAh9JPeWaklU0pIS2oU2TFGXC4XZYNQpxL1OZgURLA8rinJCegQCKgVe94aswcRBMwPdiKmtjGLUeo5nxNOpxOICOv6GcuyIOetsVHocEkdIWlOZguUoav+kJ9ymt8CXswgM4B47h/fz3OfJWV54oP+t/70dRm7Takj64+/3huHdiI0BAFgutPZ6gxtfgk7h8k3P97cTjoArLTBXXZYOqvu0AcKOqVv0QBFYYfy6cGiApVoJwT3uqnjxjucbDykH6lXIKk02rqxp9v0F8Fqc8WYG0Lw0CnpKTdCbHJQGQ88+MBsGLyedLGc5cWNLbdTvVAOMwGYLJCMIIxZHfKROaz9DXtn70Tqc5S0Xr//2Huao6BWY2Uw57IBE66jfO0GssJkXv+OEECSYQQWQCZAc9U9rmIvUv/D40Nz3s+O/uF5OGzGIQDt9xYbF3GIVcUKlaGAswIhsobPD4/48P4dYhQw8JwCAqtj8Ac7TkdgDLgG8mZQD4DoE/xWKO31px/91cJxHOtMb+2t+zG0xX7+7M9XfPNnFzkhBgPBNH1cdewjsNNPC1I84+tfPuHhYUGMZ1QsIChLlNbNXHG5XDTtS5e9unkCLsCg/xz/2Tz2p3o7dH7QV06/+b7eHPrkhw7Qj1y8njWviVvXz8DckTPQ/tlY2ncpRdQ67vGPj4/NQSr7sLL77d1R7es3p7lvZ9+PLLjT3s2uAzxToO3ftneYTyhomsoecGnMaiYrLSDTHF23U5hYaexwLGxFpxha0JDth7XuMAryqv0SqAPDINbgQb8mBca21HRmA/QVQW2eeTk5B1/KbWMqrTaGVpPqSDZmt3R2YdGBOwEszDGfPn1s6Wm8g9wabiwZfm6Vkof5YykuASBQklPWUP0EClp7RgZSSUpVZSM7Y+Z1x6f2mvy7ssPQdAcJjhjTpAzBoD9qmdvb53a33yRQykD0bnewdYnu87KX5cLIl4odGem0YFkiTqcEpASAkR4Jf/a3hJ/+xYqSJfCilorl/QJafobzeZG0FcsHhEiAEWMigDli59SeCwQwzAYrGpyya1pKkcn7vuHl8x+wXj4h51UCNDRtiaXbkfknATOAMiFxlT1Kdbernrsx1mYf2/LY970xm8jBEz0RDWMr1IAO3R/MoQcWPWVVZgw5Jb1r3W4HZNlLofZ9c6y3hpKuG7Xt2fSy6/ab3t10F7WDoTaetwE806BnljT7pyirHtXOhjXIGrbgiH1KUawYAsZAHHtvO1HtbULmqk5ekXEmD1rqJJUzxuYZY2wspQ8PD4DOFT9up9NJAxtFjuw79L0yYggIURjOSBljJJDDn4KfsQdq+q/sGWGcd+0aoK1L0297dUOds656FCjwJWXeb02OQvEfrkX3EtWtSdpaD1V0HoKP2qdNL4Ayd5rtK4xEdjCCQmh2TSnGYBudTWXOwaj4jfVLBAcNxARj2/fGJkxqq5RSAKLGfuN1NekHkSt5K6CgJ/IhrG3Lcm62VQ+g73IELTWT2sQAaLIrjpyuN4uzueZ7j/QrY7qZ7Wu5xvfTqDPN80baXl81O+b5cq23AUcV9LRRNP5DQCCxT2OsOC2PyKVg39a2XjlVxU0IOYvMt1Qiluq79U/vwt5HzTYW+9mv06Hbpz6utWLfNhlfAFwtyFLkTFGdzoLOzHxirljXzwCp85wjcr5gXRPWywOW0wmPj2fE+IgQGGkhLOmMFAiBK0JK+LO/Kfjw82/x6ffAd//481fto3fffIf3P/2EmE54/+4rAAHpIWLbT3j59hnb/glcCYDozfsurDghkgSvKnOH6aESaCxrkysjpTMAakxhOW+4XC7N/h90PTe/mi7psBGT8cDxHPTvyFXwG4bsUcZ6E0KFsWIb66/Ic1KZIbZ2ga0Va0/f42LTLYF0esDXv3yHv4o79rziN3/3gMunhPXTgr//P3+C3/+dMAHHALx8Hi3pPpu6jT2Ole3Ms/X9Nnnt79K3fPXe+fpb17hdZvj9+9oSYkJaHhDiCc+XDZ9fLqi14nRaOp7YzGV2DZLPfdp6+9wfSvJr8Or5bi55nNKwnBmvNJkYSNjoLWjeMHuz2Sz42/Qde35ro5OfvpgN0/WGqniBMcpfy/zWphCGenzdHhf1hxc7M6nqQcwINajuKAwwKUV89ecA4orLywW//reCtz/94oJ3f5JxejiBMiGmUzswUarirmyM7nUYC4AU24+IifD8+YJ9XxGDBOQwDOPqjN/MVYPb7gEzP1a5B8zcy73cy73cy71oCUEU+1x2ZAN7iwCYMZ2Q4oIQFlCQFD1QA6AbDWa0Alcqs4IdUAcrFPTvBrhcZM4ACSDRgBIFsgTelyIAmt1DTWGCpXhQY4wUdGZ0xdD+a04lu781laiBSh4slGcYQwK3FASz43N2vviAl1mxrqU2Tui5DivXTjHpr86kMt475k317etKqDcOOqgxOhE6MLG1z4PxScLSA5ihYkBnbGOL5iAZT0daLnX1EoK5O9Obk/kGyOP7Wq7zDqQeMe9P4FifRwiTjT/FeeS09u8PdCNidlD7Ntl182f2uz/lOI+rGTIGrgIyts/Pzw0UkXRBcTBarusCapEApZwrStG0K8rYFMhO+I4nswNRc/QJ6J8R4tL6xgwRQE4TGPBXMRqKR4ZmKQXruqLWOgS9HL13CKEB2nN/+TXl0/rM62IwAIkaIj2P2dzWHuxj30f0oAvqJ0xBkIACWQMm11itthD1c5jDrLbxj1WpmU1uQADPRjsKAWqaLEOf5x6MM+d8IFI6V/nOTrwbJba89+ysMLDenG8iveU0SWn3GMjAXIFQYOvcqKFN2FN7E4NCAoj7eunOBGrPlbnS9wIiocImdRiJ7K8HY9rltMlfQ4osqI5Iq+0vovdYYIwG3OipP3dxB9joGvhVJLkFxbR5pP/xAFCfkyLLYIxOIJxOJ2zbdhOs+/7S91p/uw0xT39byxge5E44LQ94fHjEu6cHPDwmnCKwhIKy7QAfO+1eb5Gfo+ye+nrhdkevidxseu2++Xt2T7R6+7j0O27d+xoU6N/kq58X/MXfFuxZ5IulPytVnDm7OWbBwogQxVmS0jtQOEPA44hoq8fSouUdnz8/K/NEbvqPgeN9Py7uPlkHles0zr4nRP+5+WaHX/k6jr7zcO1/mnK0nx45bgA0J6Z9d7SH+mJ9bQ7ZYx2MW912zUh7rSf1qO9lMxBp7em6oaWaNP0GaLNZx5XZwMGexqCdgLf70CRdc8hT03kduwCNcsTKHNDa2tpWlqSo6eBsT+8HKBslqdOWNDeT38h6hVI/Ecj6FQywzdm+Mk1PtRu7c8nPVVnxQ3Cte4cjZ+o45l1nr7Vgz7s6anZ0h47uaY75YHYEejDdAqj8+AcSRi9uDHbiKLL9ozdcO8kS5Lbn9Z+3txEBs/ta7X0EGNem69/2uB9KL2bjQNNnY5P8Z5Y6gnUPB+ydLGim6zwyvwhUGYUA1vQIpQasdUfKJ6RTwqkseDgn4JQQl0f85D8XBr+yB+QsGe5S+gA6PSCkBbUyLnUBoCnAIDtHiAn7vqPWHQbES8pgZbPkAuasjCIb9n3Dul5wefmMAJbA66IMgjC7Qw9jqH4lfRDc/nejZ1+RU0APAvOp+HqHc/vZgiyJUPXUL6saK06XXdO4KOMhQ3Vgt5a0f6R60fmGHZK9DiSsVIHGd/AyFRhTww3aKlsavTLKIV1Hu6brsAB5qgVHxVhfZid7Y6lFD5jxbbfnjnsAhF3T6bd2r7dn7GT26XRqByNi7Aw0EjwXmp64752NSIo6q3Q/ESc+I+eKlCxVQsddWMeKyGwQ+RkCi9OaoJ8Hp8OypiymJodt3lwFGNzYB1/TY2/N2/Zstf8bmzF3tlJDe6xZRDqfQLNUaWPZxocsSIgBxOGNCVEcmTCbwrCsIGsU1Y2ntNPsYPvb2JXtIAVzQc4F+/4yMp8xlDG3n+CXtMa699h+bUG4DpMyO7KzywyjdqAb2GXjoakjrOItxfqyV3tsj3t2AvupzYXZbF7HmdtyC+v5suLlnOsl7nultcNYskTYB32HhLgQUhKWFWGBkINee941RbEwr0qAR0BgNwamO5gkb2y0+p6TnnCEA83rqJQCXledM7kF0zb2JdU3fYqVUgvy/gwJmJGgz7wziBJSXJDSgvXyCK7vJU3ZKSIEBpAlPQwx3v98xeNPX3D6p4Tv/vG4l6189TPGn/zLAtCOlJ5RcsXLy4rff8x4eX7BvhVdJ4IZl1wENgkAo4CpIiWRgbKvdv2hVkZKJ4CpsYwZc4R/Z5tb83x6TUZ5mTYX0QEKUIBcMmJYsaUFeS+im2u60JgWLGDEKrotAeAaGt5QiVDy5p4JxeMkxV2ggHh+wIdfEh5/tmHPAc+/I1w+AXld8N2vvsZ3rUVvsaZvlXHUGONqeUvpEuj4rrlto6Y5P9m1jI/DZa7qIwYoonDCZS349ElSL6aYEGNya82e6g/Q0tXP12xFK54N+9bfR0G85OSv7am1epZJC9rsOFllbsxi0kLPADfKWy93bf3bs0rZlcHu2NY90qNCiE3vMT3SbBYvzzv+UAXjqyLvEeWdUgp49wtC+lDw+29f8Jv/9R14DSj0EfHnv0fghJS+xsP5axAllCyBwZdLhrHt2LtYCUFwzUSEUjaUskH25whGUZmg/aVts0N3byBovpc3lnvAzL3cy73cy73ci5aQ5GT6ljdlkCAUpfkTp0AS8IwDEIS2Gg0D70qYpWTytMhyiVmvVUHQ9kUzMkS/7KldiDpd/Z7l9KpE/a9I6YTz+TwqdQ0sdCA6ebjEgCUD+mdDup/Ik8/6qQ4JXrATZd04no19r4x7Jds7kO07ace1ZncEInhQ3v42OmlSBKAr6mGoJ8Y0/N0Vew+WdYCy95/QfIM0R3ZwRqY1rw2rnLoT0LPqSTgDv/u77PveIuOZgZJzMyC9w8IXDzKMoI3mNoULBFCDyZhAoE7B7jZoIzf06xFo0ftZjSMAFK6vmds63+8/98aUpX1gFrpfYEyBYMbLAEQBzeluwOy+7wCf2qluQFKuaIiHUGJSZ3cJ2veWGkscA9KHuWTwJSMlMcaMQpwICmxYyh6Ap3lmv1t77eSDBcsAY1oeWw/22eVyAdDTMdVasSxLO2Fq/THQQbs57dfbnJLB2mfGoR+v2SCliOa0phAaow6gaekIDZhkN7/JMcNUSJASIHMURKi5uPQgBIQFAsjWBu7te0ZKS3OCFlbQvruPAC4ART21xtpnAaUcyCSGBvvUtrYZDrwkQkSncjW5UktR/NgDVbEBgOzQSO0OWYsUXEYNavWKTBLGAYajlCbWHNDU1mic5nufW/pCTcajbT0OBnAyapKh2n82l1EZdZCptbXCf2btJLZwELKuVdmjfQIPpOgcrVXBBWDPBUWDx3r6retCbU8cy9gn80/uqbWo90in6bcAOtk3z+czTkvE1+8fkdeC5++esX7eUOs7G7xXy9w8D5Lxjfea7+vQ9gBzN6fcDND6+2YYkeFlu4Js3OV+OGz12P75eaxuGzfbwFjAdALoCSEkABWgghQZCEDU1I7iH42gkCCp3iIqIogDUIHSnCXCTHC5XPDy8tyA4+60y02v4faG/qfqWU1++f70M/W1N397aU6j42+/qK4/phwFvcxAqN/Xj4D01+6zz209m9Nz3jssGMfvd/N+7ev1ARQzqO/XvMmdWYfs33VdWS4AAG73MfV9EBzaHiQViCMvqGOns6KMDufZwVVqRc17cz6DWffC7lwjIpQq+eqJCMtpQUwLiCIqdcZD0/VgOrHW0XS0yi1VDKBMgSnKKd6p/6i1tTtPvJ7hU3D5f/60qPwTvbHWjJx3bEoBLnbG5GChLqVmxhqva6SUWtCwtKXIXp1llcaQEIOm1YLaJ63TTa73MbZ9t390a82p5Gv2xQiUHzoKbCOfgty/v9gmzG0e9s+99IT73t7D1qetP1sTxrpiDhB1BDAhcxU2xhBQQ0QtAO8VhSNK3QF6xMPDOxRUFBb7gk4L1GRFDBGVAioCwpKw54oQFyCa3iq7UK4r9n3Ttb9h3S5gS4NLFcwZpWZc1hesygyGWrGEJA7OEBEQdQ5rgoDKqgPJAd0QA2Ig2WcmmeHH67iM664z1IjenvOquk5P5QsipGUBsxxeqFQRm2xhYfJjQmn6jN0mYyu6GtRwBljtyKYLAU2XZQYCT2vVyVlvi3qdzU6DV85tPVv6AQuUMYZOqysGTe3o7AlzEpnsBnDlHLL0teaAElvoOtjAniMpViBzamq71RGjpNMB0NL69VPgFet6QUoyVtu2AmCsK2BsnnJAwg4nQMdKgjJKqTifz0hpwcvLRey4KoG0PS0D0Gx7NNrLZg/KwNkYsX7TU68eyYcxaHeUsbfm5635jIZVlKt9TghZaHAGSjvNXjwd1ng6LTreZlvr/ArCDJMWDVbTg1aGUzFrSr3amVflnffCzasAACAASURBVDDM1T492ToXkrZPgkdLUTscC9hsNtJASJI15VmmKKDNv6J2ONjGPiGEiH03BjLTYk3fHwPObO75cZgxlC8t/Z373J6dxkfPHfdAbnuWXefZorxOY/fenjN9Ps06mt49/bR5ZAHI/rBRFR28ksoaathWSmeAhN1pzxv2vDfZZzib6FIWlGaBiPZOYQisNRldyrH+eYRFyB+ih2yrpHgRVtRxLzQsEuiBNBR2gLLWHYCaQBRRQsK2ErbtM/J+QUwBy5JQOWPPK2rd8XA+4eHxhA8fznj34RGPH3LvTfK6huwB73/yFd59/Q7Pn1f8469/g5eXC7ZtR90ruJBghgiqxwkoIKmnGUwFLc1fkAMHft0Qs+618n1UptQjvX8uxjYFXM/P7y2KDVRiQA/3hbBhWzfEIGnel2XBspxEf0ndnVxLn2dmvbJZYyxjGkLEkhKW0xkhBVA6I6Yzwvk9nr7O2C+SlvfyXOdmTVbX6+/kv50PTHyZxTff80Puvi7jam2aA2xuAQyEinR+loNhqWDdKtbnz/j4aUVKC6raJDAbhnv/12F+0LAntL1x0hU6VjIetvRzbj6s5/UYC+by9YTKoGj7BcDFGOISxF4pGpBf29wXtsnxmYaJAqNfwZ5LRNh3Y3Pu+/Mc9GI6iLU5xoRl6Yx1tu+antQYc6vhwL0/amVEe4cCOXh1Ijw8aKpPAHnN+PibP2DdNnx4R/j6q/c4PSWkBWAKCBuDgshhztavimFRlOA6LrhcnkHEiInAXLBtFjQVwYbJE5CSYar/32ER/38v94CZe7mXe7mXe7kXLUGpMUst6iSOQp+pShWz5FknCNMEUz8ZIEpbbME1o7HO7mdX3Cp3esPrMiqp+56x56w5vPtpFX/Cq5+w8+wEGPR7c2zWWtspMXHiStsMICAFAe1UkQEx8tkxjeMcGOG/b281fSdf8/QZX907O/StP2fDuwcOdKe8UfwfOYl6/To63BXWxtgS0H5iSF9iZo5RoMon9k+AIjWANJhlZo4AJLI+tHu74WLXmALvDZGrtldDbPuJJj9/hDZdItkblXgILQXSUR/6tjQDI4ThNIE3nGYwaTaqjhxy9rcEppT2Xt5gmeeApwBnZscOwxLs4tee6wsiwvmcGpVwCAFxidi2HYDQ3m7biloq3r1759a2TwvGACQVieTnHeek9Ym9D4CBOWd+H39CykBrCyKyuk6nEz5//nzlzJuL1e2pik8abHPk6HwN9AMAbkZ8B8f93OhGZEGIllqC1YkYcHKnVQ3oIgqIyeZJAIUFzD1IRfouXs0hSxEhn1VH8TrKopSiUkd3gziEJOvwBs7R39uCWhjggloYHEQO2HNmQLO57RrIpydEA4Eq949J+zgEZT/S/mMBAhAC2FLYHKwfe+83FerNwVSX/tHWz+vleN/ystT2CS8LzDFijtyoQV4e8Bgae+vpN3Gp151nclqHdW3ODg5z4i5IywIiyRv/q/874N/9mzOAM3gUHzcDVsaWaD9/71tdf3/k8O3Ot+OgGT5sm0JulsIPgA/UrOwT0hhMd10vu7raZ+SDVQhAAtODBs4wwEaHLAAekbWPRG8qQIhnhBBRC6PUHZH6vJagx1XBLMe4xpJCpLIFuMn8M+Yqv1/YPYCu6aYm2Nq3t+uBWl3k2Xt9SZlH5T8tQDU7YDxL2Wtp0GYAftSjuhy19Wuy1/YQz0Jg99daUYvW4Rg7fD1+XXqnz6wD2j8faOO/k+KChd3rtb2/msPHf4fhxK6XX7Mu274rBXnvjIOyt6sepXMsWLB9LurkEWruUjuzzgxKzwFGorOJPOvvS01vqRqESLjex5dlaSkVvGN3Tuvo38/AdIBbwBoFoTwvxViD+r6fc1YHK2mgdw9Gvh4bDO0QNgxqTvQ5QNqPMaiflGVR0K/1ePceY6Ebv8vfnuHTXyb724+1ltn9mz93fzEPskgcgtIgCS71d0oQcSlVgvQDg5aIFhTGQC0Fe5ZUBlwJKSRQEAcLl4oaop7YD2AQKkhlRE+Dl1JCLllZhoRBJpdd1w0Aqihlx7pdsK4vWDdJoRogz5O5a/PN9D/9qWyFtUp7bM18efE7MR3osd1+6Q4dYdio6Dph02ODyY/OGuiDIiyIRieJOOJMxsDsa/6ireBK77Y57nQtZh7YN2fdkHTcvQ3g6zJZZY5UbxNVV9dsyx2tY2HeLYihy/LZKQX09HzGQJZzxuXyAmY7HHHWz3c8PT3pZ2I7+ADGmMzeYxfYk0AkjJw+NVNvKoGrME54O8vr+iJj1R62Yb+h8B3tSWaj+muO7jsufDXd/V5jc9WziTbb94ZssoMdQHf6lSIMFzJNQ7Ox/Froac1Ig43qNG8s0CO3+ywgglmCGfZNUpktS8SyGHuNPDMqLiZ1EkIKLRgKBOS8Q/Yd0SuWJTXZ3A+GYBiYW/uz/+xWuT0mfRxmR7Hd5/cs/6xjzEv05Vo6C4MvHsewQIjZvnyt3f7aI73OZOKY3ttsbS+mVCbb7xTkwIpijRIUubeglRArQpCAJsOCZLl2nMrrU33+9nnhZY3v60FHZe59WOUAz7Ik7cfo6nYBZ8SIKarNLgw5MUlbCRE5V2zbCmO1Op0WlCq2R0XFtkuQ8L6veHi44F/9t8+IQXmpSOZxDBGSTha45Ixff7vhsu747uOzBBuWAqqECNm3S8k9SCAQcjF2LR4OOFrwnAWBh2hpPXuAdVJMZQ4in3U6k3mzvvemwjCicmX9qMhZmHBJ+2DZF5zPWW2xpd36cFpAKG1PDBoMxC7ggBmoJ7EbYzgh0gmnZcHnlwv+8r95BCHgt3+349/9T5+1Oe7d2s8v0xVu2fFv7Rmefv6w4mQEgODYZWztNbxNr4lpxTd//T/jw8++Rjp/QC4PuOw71i0jphOWJQDZ2J8mHcuWkD2DOr7Vcakbtgf3vdYXj0Hb312mdDvP71lxWfDw9KQyX1Miqjy3tPX2XJu30sbY6pplmw/w9WVZEiyg+zVb1/8u7E09faQxkvu+8O8q72t6bFS/j+GRmrIy9rF9/g8/x+e/+zmYGc9E+BWAn/6Xz/jFvwbO50c8Pj0gxgXPzy/YNwmElkB5watKyXh5eUEpewsK9gGKGSzyJkaclhNKLcI8FL6MKflebpd7wMy93Mu93Mu93IuWdbug1B0hELaclR64IoYFRCdQCMqmIKdyJF2TKHampDJzO8kFeEo/jRoGxKk6BcSMSq4paf1Uj0T1B2WYqUjp1ECIdrKCeh7MlredTfkCmjLN2ggDGMy11RTq0pxmjVYR3SkliqMCc0eMDrimb/SKuQc2vONWgNgpJ3UdnS1mSqgZrfZ984x1gJYkV659J4EUrg9cmw1oqzwDkTZuQE9DA+0rPS3imHrMsJd0S9yMH8bo+LCTgcZaIlH/9p7jqb35pOCRAcwy0Fq3gNGeDreUDCah0zewRE6wAHndBwDtVmBHc1ZhBGF9mUGZIxDJB5T478wA8tf5NBJ+3sx52lv9MgjD82dGo9mok7Ua2tp5fHwAhQdAU2MZ2CvpneQ0uhhUqc1C/zz/cz596E8nGIBm878B0a4fzDF1uVzaCfEQAi6XS3OImYPMTnFa3VnlV6YdSY1A64uXlxeXkgrt+hijpjhSw10p0xECKMbGeiJzQHJZhxAaMCQAkATiNUAagsqZpBHHYocFLEUYQYxD9c7DHFohzOMmzwioIAbKXrWuABQNAqSAiAAEW0MRBGGLsbRcAWmYn6UUTdslbQ8UQZRdiAAjEIuTv40zHLDLQgJfs3PuKyhpbEQK4kvarSzvwoR9EyCKgrquqHntbEqL8wRorSGSE8XFjmq7NShzoDMT9O+sPdovFixHehpMZaY1XJ5b9TQhdHCKBOdJK2Q/hLqrDRADkHQcKKhDCZL3udYKtr7RWtTT0xxm1GvHXGaQ2D5r7FyVHRiZ2zMFwCHEeMJpOePh4RHvnt7h6w/vUPMztpU11/xYXgPIfGt/yH2Dq+/ACWLzjt2THKx19YxKaPOVh+9HoI5tHqDPp7Fm/amBNxX9aX7dVk6oNWntIg8lv4EykZHoHbVIUGjNgATX9OCXbb1gXS9Y1xXbtvZ1AZP5FdYKS7/Q0mq4PaHn/ta2O6cFDc4p29ePe3v86MtA2e8rRw6Po8+P7pv3Fn//XJ8Vz0Jm38/OCf/5XJftN17vOHJU+b3Y77mkzk8P6s/6sbWzB+H6dHymN6m+orrSOJ+752eeE9f6NYZ9xO+9dv3sCC2l4HQ6tXpE1p9RcnFsg9TSDAJQViUCcwRFsQ8qA0UZVEz/JguUde3qGqbMXJClAexMOPJ6PeUB3J1EY3/6FCumN/m9n4iUFUAc0l4Hr7WgsvVTZ15sTq4QmlMaGMHzDkYXXC6X9n4jc0W3CY50qHadiifZv7pN5OfccdGT2rqnN4l4JSNc4VFyXn99+zubvz1I3mw+DXwAAGcvaBPRPPUENE8VMOjwgKS4kz2KUbDrGEQEBEQW9rey7dh5w3ZZsW87Hs5nLCmBzwkpsWaqIRRUSwYFaIo7QNgokqaEvLw843J5Qc6bOiMLQpAg31wq9m3F8/NH7GVHrVlkN4utWtt6UB1S+13SodkrauCBpuMEj7T8r5WjMTedeZZnV/JJdUBjHjLdk0JErTtKzsj7jrytEnyvKdwqM0Cxndy2J5RaEUMQXczaop+bLnervd7+9XIoxNSYHWdnsrdhzudzr0uM2OGaowMWQA+oCCEg1IBS5Bnrug5yw9pn7TenUqRJ/wo9JY09V+wmOQkt9kXA+/fvkHNprKIWWM1gtYOl92qteoJaAg6M9SbG1A5EdLnm31HTLgBqy3jMoq+nHkDV9xMZP2q6i73bPHae+cUHH4WDsZrtaP+7BKCE4T7bGy0oxWwgk5cmVzw2MDPfHO3vAJBzZ+SNMUgQQsMhLEiJNWDZZJSsX2ZhHjFRBWbkvWLbL7DDSTEGUGAwiq4zsRmJEgxbitH6pugaFHbXdd0A2ME00uAZasGVUNnvVk8b71vjdKu85bpZN/Nz3P72OMhhgJl2ll175ID2e17bV6d5clRmfM1jazZuXtfz943zgpp9YVJFrXHRPRaSNDucEOLSguVQi+r0e7NQvKwKqq81XR2qq0069hFDk72HTwkGFMTAqCWjls760qwStY+JKzgXMKlOAoA4i1xEUZu6imOaAmqRva3UDIqGrax4fg6IwdiyAlK0wx7CjpmLBusEoJCwEudNUsEb6w3XHZmFnVoIbAsqsq4RspcV/asdbFC2MjZZZOmgZVzGdIPTfMM4L0f76HUbYyyCq0qcnQEQ0v5SMzIDJQTs2wv29UUwMtWFy/msYy+2f1D24cqCD5QqaRpD1KDHJSGcTzg/POJ8epL0VBrE61bBoU5mknu26LxqNV/PwxVvL6Pk+XEKa1o7qdO3TDEeqA0QF1B6wMul4rs/vODlkpGz2udswXax4RddLhIk6KTbvxIg2vHqEGjAIYFrO9GK1+9nXLW9E3ecOsaItCxYTicsiwRVCQ6ztzbbvlCK7DPSnqVhv/5AoS/xxkHPGCVVYwjXTF63bVbZo+xd5jSU9n4t2J8E/2AFUqoGnJZcFdsAYnBB7mx6TWciTIlwfqggKkhLQC0Fy5Lw/sMTSi5Yt62ntK+l2b4hJG2f+B+MOb/LnYgUDdu852T6sco9YOZe7uVe7uVe7kVLqRlVo5Mlp6YFw0Q1IPVEHpmRKf/EOaDFlKNmAHljxhkuFGAUtWa4dpBVfACi03VK4qbyc8CSYosgtlNjFh3dFK2WmoLRAjEMmO2tglpjDpS29h47ZJoyWQGmeniN/9ve2YPjQFfszfk83z8Ye2pbNNYXfSvvGBufi+ZEMedcB6T9c47NH/89GUokD0QPQFIHnmnBYFi+ewbApddvQTMA2km/WksDxeQkch/r2Vh53eClhrdDDWtqYLs4GkstCGEE4S1a3RsQR88ZgEBwc6L4vpqBwrkuA0LHvoX7/roNc13+95vzBH6Ojrmej97N5iCRO4Gqc0eMEQuYyg2cDaEiBG7z6/sAjNfKW0ANv34ANCDZn5r0xpwH7yyQxv6emQa80csmeFrfyWnDBoQFDXap2s/UUxBJ/RIMQYq2MClHDfe5L8FkztmQ3TqDDZ+u9zr3o4IAwuvf3qEoEMxK453SqWX7YWZULiAqCthZKg/n7NT1G9p88XPZHPbmeNf5AAOZZcF2mVQbQKivBZjMcvPFDFoiaDAUI0DSyninINs7OKfFAHRezet+cv5oHnbZ64BThTxtFxvBNnN6u7lowQkKrXID+awfqKemCtZzKgPr2NbeTf2EY1vFh0EkbNMDaP3kZKX+3fZRTf8AldlLWnA+P+Dh4REPD49YloBtuyDvBOB89bzXy/HavgXY9c+Og2VelxRznXM4EaN33AwgdgCuf8euz538sp/kUzHZ/9xVxH09oZ8cFaHYeWzkJg1qAAsduSxuMMQRdrlIwEzOm4JBcLK1py4b52Wfv12PgPvby/ZZrt7aS6fPf1AS8LeM4g8v1/rT8XfA9Zr3xe/Xb3U0zc+aHXIj0CrOM782vXPollNP/hghclIVtY1Pe17/qM+N6i6xk4Bju/0KlTaM/TIHzAAjg1GMNLwzM0n4QUv5EkAwYFWZQsj030lHaHKzvTjaWiVZoX5vt33w1hyYdSzv3DVnOODT1BlAHEBUx3RPw7j4fhs/ORxDjPrGPN4mQ0wuwwJFm80C1UV8jbfm6ffM38Yu597BbJ7bN71e583C0+9spp3qQv3xgN/iTM9sKphep/ZEk2l97oeW4lfkIWpFZUZWAD8wAQXgEyOGpc9bs9mYbffWtaQBU5o6MucLStYgRrZgqSIpyUrGuq5YL6sEuRAjwOYOYOk6mMm9s3ZE+2d9ZOv0NRvndiGrz93udzx7p/5ZD6Jq89Dmns7ZXPYWvGA2HgOg6J7XdCICqB+eMJlSK7e0rkey1q9hHoWQ6k/9Wlundr399EETwJg25mjdzWk6SJ8FdZqt69oOCRwFDfR7rg8gGCOKyRX7rge7RJzOJ5T6IvqD7e16OME+E9ajqrYWtN0SuNRSw7LgD4E0ILDa+pGxETneA2auHfL2mdnc3NfDG/bD2d49cjDOz73ej31bzY6zttn8NB2E2/V276jvWLoNudZ+9uegsYoIC5U6321z6r0Dv5B628we1LlYi/wrZocCQEWpOyjUVj9AOC1nfQ9zkFr7jHVC/jbGG/sbQLPHjuXxbfvmjymv4RNvCTy4wpZo1hcO6vDqzxvnn//djhd4+6DhfYNdp2JufixRs626IU6Q4InY7TkqYE13hCoBjpKOy9JsyXWVZA6zHqBQmuamUx8x2s56ZDCdj9XWYDevSYIxwNKGZlfaPoa+HqUatfuZEeweIlQOGgCp9VfZJ0qVlET7LkEFRMLUZP0nJGxV9oMoGIPZo9buChcETdLHZlP1NJHdnkH7pP/iZjhmW/81nOkW3uXLbYZZ1mHi0d4G2h5XirJ4G4aph8mQdwjjhsjf2OQ1WrrkWisoA5ki8ksFJ8Lj03vgA4meEparFs3awYc/ueDxK8bpdMbj4wnMGyJV/OYfAr79+7fZbT9M27huy2vXvf50GoJm5KaOIctVDFDCuhZ8/LzjDx9fwBwR0xlkMpxtztk67y0QfMp0Mt8y0+cwYEty/xiQ6T8DZqaV457wa0/qsr3JsZcBCDBGM/muVh8wNtblg0F9Kl4/10UHsUC767Z7G9TqnkfKDirO9/i29DFSPaZayjnVZSLwi//qGZeXZ3z+1RPWX381POPT30f89onw039lrE2E00mYbbZN0uBJgGtBpzy2/he8RfSEqCxOitmanJUrD8fmXr683ANm7uVe7uVe7uVetBh4w+pgiWlBiiekuIBC7CAg+slFhrDFHNTmwHlv2AAAGVYs+LADeQzIESeBd2gXvTk0YMo+N4UuJTkNsW0ZOcsJxBBDrw8WMMP9b31OgNByN6pBoLVJ2j0qmaxg9i2ny6xMe2W793ePkO/AaQcDfT29L70hbGBydfd2QH4GmYUp4Qb4QiPAOuCXBgTDTvdyu04f0PqgIoBYTyWSOd8hxrQx4rh/vq2z48+XWWn3fWSf9TfrBpcB7rVU1FA0NzgamGWOIW8gzcDfOLbdmX8L2DlyphlYY6fHm+Hirp/BAH8aajbMDo19a48Hztn/PJ6r9uwQCLUKEBBT0L97u2IU2nszMkEYTsT69zgCUI/GbR7DOWhoZHXqdflAGFsj80lVO23hHVftPTAC6o3unRlUK0ByygeW475qsIiNjRrhwbqdCMzBSTuZJ5XN2a7ArAU5kPt9HjRnVGtVrv/kJC1XYQYCRTAXOfEPAelg4HcDxgNABYw8GdcCqFv/xJAmWQKEGMBc1JdSkXNtNMohCt24BYI055YZ0h5pmsBLILa1Goh1/LrzqkuxDuYbiCn1EpiO1kGfs+M8c+ua+75h1ZJb19YWC6kIQUHDYE83h5s6xNRZJYBpaCw9fmStj/qY2p5kA+wDOPpnV8W6AsMuhUH0u0lT3VgDhPP5jKenJzw9PeHhfAaw4+XlI7bthDlgZoK9Xy1HrR0B7LlWHc03spgcXTW3T7Him0id//josmHOwY0beHg3WUcFCKtOrAVAACanJ1dup+BCq6UKE5Gmu1vXF2zbpbEuVa5oOztXDeocc6Z7WTfuC3zz51scHX98kUChH/tJR/vVH+sY8qDoUeCNlflEstfrrvRB114RM9QcF8DIHuj3xlkntNQPc1uOdEyvH3td2H9/1FfNKdPAx3HPtnfyTAvWHtnTrF4RYubIFRknTJS2x6nqAXOmiEw3Jw/DPCrNNhjet9sat97jWkdi935iKxiTg60b0wfG05vj+rKAe9OHhz6wgFWMc8KP4+xQH0B5jMxoh2UIdBn75O2Fj/unBU3AfW/POp4zX1YYlr7V2n0ogpjd6/g9PjQZ6C+1+RaC2GsEiCd830Eo7SR3CBEcC3LdgL0iUpL0BxpUDNOl2q4rbaUKEFUgF9R9A5ddmNo0XUStBXnP2Pcd+7pJ2kruzm4Kpgsk2Lqynd3WjP0ucwqiO36B1Bx0apug+lf7N2xwpvcwoMwJBHMsdLYzQGRPzpukH+Gquox+a7JE5yA7/cV6EmS9yoAGGXiWExnH4wMH00C3a5ttOQVNd7tFA72VbfDInrL77XfPkOLlha9ztjd9W4eAa61vWRZN4VaafBnTrsl8lqEQh12IhAhjo5DgdNJ1I6mxSeZYVR1O9XmxX4VxptZJZ29B710PrdX3qZ8rcD/t4+u1f2SH+nH7PnkxOyTlF8ACSeRzgrCxoK8T7ukrDL+pLXigy60QbN/ygcPyQjGKXWb9ZKkuLB1VSnGYL+O7dFxCgpaMiRcgBCxp0cBY+RcCtA2MXBmBCafF9tkepCbjrWmYGI4BVQI3m73i13TrNKvj9ji9dSze8r1ff0dr69a93CsYvnsdXzl+/mvPaXqUySD73MtCbRA1+7G3UW73ujKaQSPYWcexQgiio9eqB9iUtZXUgmPZ28Uers7+MkZTuWlmfPJyrrENektE94o298jaKgwMtr6JoMEeOpdAErTjurAdToHKI9j6UVlGfj3awUYdB3b7GJEGrVYQy3Vmg4l4s/eT0dAWaiuCst54eaLfs5/zNNQjfXQ1HVr5EjvnSMf2otD0IT+Pg+3XDACSkrGyBF0GIlz2vemqgSzt2iT7dH4RgIwdHBlUMxIiQgUeHz+04FtrkpuSAIBv/pTxkz8lPDxEvHt3Ri2MFBl5Y3z799/fB3+sjebbcuv7txYLmml1ks0zm88Jn192PD9nbDtjSQkxnkTuOx3zWkbS0Mhui9l1sgZyzlNA/tS+gz1vPog4X2OYGohEN41hqk+CaKKeTvR1GMOZ1ePTvJGTHdd2p+39oekeI/PWsey2dd/7cDygZqWz0oV2nxwYEvmAouztEBzsw79Y8Vg28H7C+uuhR/H8LQGpIv3JH5B34Hx6wvn0NDHqqG+jWpAat8BF04UsTRxRDyJqLEJvI2u8lzeUe8DMvdzLvdzLvdyLFkaF0MmKM3RZTpKOCcGBfHJKQJEBUUuvTguYQtZPnNn3g6HLuFLKvBPDO8JrraAQBfBUquFSdqVDZ6QUFPioWNcLShHa44aNooOSYvMoxb2BMyyOaMMDm7LujKo5+MFe80jRvgXu3+z77wMhaPydgpygFAxQwV7qBuVcl6RlGcGXQdmWygfw1Pq+RbOznCwZX0OAcRt35l0a11Jh9YAlaXhFrbn3cwMKjArZnjcCmN65ceSgsDE1wEPucQAP0IOo7DSIpq5hjOM8gxl+jODmxKHBfTCWHmBlltOr1QLFDoySa4PmGmwcTxs4x5gaCrNxdGt+Nece9/GuNaOyGU4F+74BkPy4gRYwa8oCrlf1W/t9eqQRyB3f6RYAO9/jDdXT6dQARrvWO6cG4CkErC8vqLW21E3btg1MM/4ErAQCqTNAx6cyCw3zBHAB7lwUA5XlxNawxpoTTg1je1f922jAR/hB5ouXpzq0baxqozNHgwnZjlACLTijVqVvVcd9VXBNADbNjcwC3tbI+mwzvglLkHVcUVFLRS5F07uxBigqRb/1o3BAA+SDfgR0lOCTBMm/jrYGiBYwl54aYQCt5H3McdvezfrVy8VpbOY1MMyvMgUlTcXPDdZxbsFRU1CRQAQSKGN0zG1eskAKlXveZQPTGmqGvt+w1vYaGuXBjUHWcxv+DgzpZyFIcNPDwxPevXuHx8dHLMuCWl7w/Ok7XC7vQPj6+Hm41Rwb29vX+Sv8T9EbxntvvO3w3WvXAayBr537x2qY22Btu1V0N0MP/+r3ry8VLx93pA/PYOwAPQC8wDOyCPlB1UlujjoGuKBqgNu+XvDy8hnrunYdh+TpNle6s807K17XF+Y3ket+KHr0JdBnZ176oie8ohcdv2/fjgAAIABJREFUAYPAwb78xvr8PUfO1/n7Pi59/zna144CWIfwN9emmdXOt6FyBed69QyvF8/yTNpZNJ0Xrtrq7/f3CJPMcqX7WBuBzgZo95RakDVdBLWgGJOLtt+R6A8UJNAeAEPmvTk2wdEWCWZkU/0UKkvHgBkv2/27+s8l9QMN7DIWMGMMEzMzhMnzYa2p8DyaTzN9u2/TYLNMumK/tp21frX4PcZ04tvXXJeq6aIw7atm99h3/X31aXQLIr29G7TnDI6L+eeo6/hnDvVz1YAY0ZfHOgmVNeCWZY2WXYIXyfbiBFAoKFxQsIE4IuCM0znidEpN7yKIE4xrlv3IgmK2Dfu6opYVtWaUaqyljH3L2FYJKqEadCwjQliQQpLXUSZLyxrmx7Ex0klHw/Q9avbxsZ5+9Le36a4dH9dyThyx/fnterWX9n3Dtq3iRAJAwQLmjGEjtJSSRNTqKEJ3gpaiswAhRVBSu7OOjI5jn+D6s1pbSkSe1uBRCjzoLCl5vwpUs3q9TCPqKQskPUZPqTQ7xXxgfu+v/mwLzD+dTnh8fMS+79i2DSmlFkAjz5f0THaPt1O87WQ2mcldYyGxuiwIx6fm9XuQycymFrq65z6z7+UrnU03ZNo1pjDuJ21OuOfcHGsGxCEfZY2bnjoFm9t1DUsAwGonkOnPLLa/Dwzo/ahOaxB2O/0ONB1Kvo/IObe9YZhTGpgkKZQE/yJIEM6ynEGhYs8rStkBVMQUUMqGUtVhZ/gZ9cAgaH/Xwth32bOXZYEEQtV2Sr7v7b7jum1peEfX8ca+vqUHfZ++NQyTwxvmet9e/3Ug7nxdH6+3Oa2/77lm/9g6st/7Htpt7NncEv1DDO7KoclVIgirTLmAa0Zj8wuEFOLQxp6ST5QjCmrDgg77bw7mEx1JQ0LbOBuOJPiRsDFVeKxA5rWkU2I77KNpXuU9IGYndTtCdKWESHoo0jF3SEbqHmApafJ0PdqeBW5MOqLDstroffzhsQ8A5NO5w+ay7X3uymYjXjNvzOM+64bfV47nmjy/csdSvJXq04Aaxiixz4KLr8Uz12JI09XklW9D3JFOjHJhvFRC3QoiIpb0Hu++FtzFYi0MG6i14ptvnvCTrxfV30+oWABELA8XvP+J4F2XT1eqdavnxyhvsfJmC3/+u7XFsaAy0A7tBiLE9IhPn1+wbhUUEqIxdrEGUARqaVGvWzbqjZaiSUZM2JVKEdvAY4rd7h6DaY/SDgLj/hhCaHs3M6PUir3sqndoGveYWnpH05d6sQN+IkdMX/D2nB0YHttghzKMLTO2Gj3eOWPM84EEj5vNusCYCs8EimJkBQAFQfo4IG8Vj08/w7sPCZ+/3lFKRX5e2ppeLxn//B++w8vzjm/+s6/xzU8DTqdHWOpbInSbrTByLkhJdOzYxsEO/ZHqCsIwyQ3jvJcfo9wDZu7lXu7lXu7lXrR05ZUQU8QpScCM0f8yEwpDKD3bpQbAmRHc7IxeL5uxRrDoce/Im43hGSAzUAmqHHcHgZ3IAgzwtqCIlCJiElB+Bo/A1E8kmSHpwBd96s1+anTuDXR5u4NozndqT2LzEmBk05hzNfu+kr6bld9jZht94vBsG5d+sX+Ov94HRF3XRSTGe/+cFW/o9TucET2XNbeTmzEGBTZCG89bCvxspJAq7uSfF/o8jFGMlLybUynBTsMbQ8oRSOh/PwJ3jhxsY9/eBn6OnF7zdR4QPeqH4zbOfVanOvp49GcryK1WW4xBgWcZm33PyFm+WxIQgjjZAoVm2Hrj0veXN9CO8pfP/XD0TrOh6tNFzKDtbLgGosH4ZWZ8/vwZKaUrppn2bHmyOgj0ZOEw9z0gZ+BbpyvWK+QfC+AKdBkEtoAPAa7agDiHUpOjNK7VNqZR5C6RjBchtBOLS+Jh/gPAclpAQVKf1WJAsKawKjLGNg/6O7pgHkJjZiJAU9EFBdNkb5DTH6zENyqbqs1JDYLTPuNKjbba5LA8u+8Vfq6bk+BqzgS6Gv8jGTu8F7qT4sgRcLT/EOZr7BmhvVO/xwU1wMYMkFNUej0sgNG6WAd7EAPX8mNMr0PDs1o9xOiygLoTMcQ272UPZeR9x7bvzrF6XIatsb3lCEddFw+R9t/evlt+X4ukeNJ+ccBKz1bXnYG9a/F28WDdre9/9X89Yn054W//uw0cCGAJAhta1jb1CkuzwrWg5IycRZ6WUgfmK5m/Nre4zbE+R28HzLyug/xQ4MiD128p4UcDY18r897wlu/mNe1TePj7jq47esZbHFTGFjTfM8uwoT5Gkye+7lvP77LvOLj0So5d6Rt+Ffd3PmJIsHuEtVFSojLb9awBg0p2ztYGuafUqnq/7gVO97UV7IHf5hCF7S/XfTePQQ92QdMZSimSOkfTMRnwbICzvZ8fi3ks/d6LuS3owZMekD4KHPZjZYH+rxXTwUVPCOgMBW8tpltIQLp3IsqvxpTGw7VgY8s6cCYxjtswnPS1evy7jDJsqPNAt+73VPSUiN3p0vZTP41bExg1F2RssLmV1w1b2gBeEBCRUmhpfygAtcjc5MLY9oz1ckFZMzJn7HVF3nfVgQn7XoSBpVTEuCCwzJeAKKfzKaCgDKeCAXWiMiPn2tJodKcGHW2Xh2XUsd0eT+OY2dpstrdWzgwJbnH6A7iiZEkz01JMUdePRc8RpyljXB8AWiCHBW54PV0eN8qdWzYUy2QX/bhy039neWY/R6dT12G8XPX/zPlEzi6QLpPvJXChB0wYW8x8At07Qo+CKC099Pl8Rs4Z27aBiJTxUtID51xVD2eczwugKR77eF0HClnfWrtMjlk7vK1g+oSfVF4ONb0Rzv46mHuv7bGv6d7+2iuZzUBjwWhppaoyldk8Hm2uvk/I+5C7zua1MRYTQp8/auP2dMzmkLu2GYf5GWzdVrV7usMzaBoWwOxrsXdKzchlR61yOCCl1PrUTLwKYX7ccxY2ueDfjQ92ZBx+Mnw76xF/RHlN97DPb+2Vg26h+/itZxzpb39kw7tNBbMtAWbba23vM6c5YGzTfq9tbTddTG02+aynhfNt90F1QE/91rAIZXvxe928lr1sI5WBBOi8PdZJbd1727ga/S3EFjQWrRj7ZtmxBAZrClnBRGPbQ1k2EA3yUbnMFVx0DjDre0EyVzlbHsRyKMXtScZCFlsKQJ3puta6TAKG/dAGZJpL814wj8vrNlHvy6tCo9wxnW3YU2BMYPbcqrq703GaaBLWHiIo7mPMhABRAXFGLRHryyfsOyMtD/jmpwv+9f8QUXnF+/cRKYp+Eijh5dMF6bQgxIjKkqIceMBWgD/5mzP+9G8iXj4943/7Hwv2l6O3Hq35Ud68btEf3eu/oUlOjfXy1eczrkBM0v/2NxEenp7wh5cVgAT4C7tItwu47eHjE69a7vZVw38DKgr6PLB0jDnnbiOqzK8T1m52kl+7x5gSa1rG0vYP5jFAp7fxuh7Dy49sTv+3xwYAKNsxDfUARz6Xa7bJo719eE5/MESeyB5I1tEM1BLANeKbv8l4+vOP+O53H/Hr/+UvUdYEApB//4jyb/5a7nn3EeVrSVFtqUCbj6AURBLdOgZhlDFm1BijS7GnOhMIaPbSvfwY5R4wcy/3ci/3ci/3oqXuhPWzgIen0wecT2eEkFAyoxahD04Qpo5c5ISFBMsUVVj0xENlmNOuO13RFDqC6jPM2PaLGFEhIKaoJ4xYQI5mfshpMwIhhAKQnIRLGkQjp30WnM8nbPuK83mRU7CkTvohaEYsshgTwIycVxAK3j2d8HLZsO0vIAJSXMSQE0sQxBW16MmmIIB/JEJIneq5kjkE6BA48jTw3tCtCh4ZeFyJ1HCAealbNmAKrFHxHawfDG2WfqV28qS1QH8UVaoV6Ff0mYiV2rCnbmJIW/a9aApmMfK84m3/zEEC9FNZMS3dqHEGJNeA0sBzQBgngoIOHYRs/eOcNSNQoCCFBiM0NV7bGVKUVEwasc4EFFRAAcsRINS51pz8vdh7t+fSbMzLe5XqnJ9WMUPnroMNmHvO+XbiWh1spLmrNd2ZOcG7kSKnKhoNOUiAYmah/SRuvg4WCx4VdTB8PCTHYHDJre0GPFOAtJMJFBacz2cx8PRkBAgCsLfTS4RIEsAABaPzvkuqIAJiSqh5V9CklyM2H+9gaqwxmkJL/k8NrGAAFA3UEuMPQe7btg1525BzbmB+jBEfPnxoRqh9vm0bmFlyTgcCo0pqMZCe8CEEWNBPaMBOp6y3tqOB/dxOmenqpg4nCFbEoFAdaNDBlgFY1hMZRu/MHBHjkzoKZJxiFBD3crkAgUFRKKFDqAhRmGZQubW7rVc95ZkSIcYFfUFIW2KjG7c1B7xcLljXFTES0uIDT6rM5xiBIPMhuFR+0LXecqHr/KqlAhQQGIhBHQNF69Q1ytq5BCA4H5O1V30eIJgcEyCOg7J0NCeCzTdxqoF68OSAtbAtPR2T5nCQ/ajq3EjKYlT2oikM+n0mx2IICAZgssnc7ky39Vxt3Nv4m8NZgErPdCFTwf62MVIZq8xutVYQkgaOLTifHlErYd83nB8k2O0ff/W/o2y/RaS/ugKv5nIERfWeOfru+l4CbjLLzM/uEmqG4W7Ui8a1JCFq7L8z8Pu4poaT26l2tyKvrmUFreuLMAoETflXTe73cSVomjNmYWdaC9bLBesmp5LXy0vLF05EKDXrSWl5cjVA0OQ/Q2jewM4nfeAo4b4yGBGYv/++QgDRAZj8fbfZPP/S+6iv4Q40a7Mbi15rmoxRHfeNsTLbK+QOarJXgr8DREeqWVNjBNnTgsoGqb9iiZZmr+slR8+cHbP61EH/qcxav+7xXGG54GtpEDHIAE0mdLrp7oCGq6+/n3zV9M4GDlPfh1jUSQQ9KU8Mcd6OJwk9UGrvm3NGSglLWrDQIoCyppMgqNzW55ZSUDRwRVjHApgKct6xbxVxsT1A5jWZDkmyjriy04t6ENbo7B2Ba+sfYb+T9FQGvuacsSwLnp6eNPVZZxLo+rinOwdKqahaD2BsDx1Q3/cdSYNtBl1e9Qqv40uQRB6YejAA5V3yNpuHVb93urjpFnO57Rii7tAChvG09pVSwEGYaKidmLe0IB2EN5vNTpL3vdRAcog+I9qPpJ1zrFk+TQwNC922cb8nGOOEaarU/mvFeo9YvjFWhpLFLg1cwcioqtOdsSCEHagvyNsKFDlQwUHGOueMl5dPeP74HZ6fP2FdV5zPJ+xlQ67KTpQr1m2DEfmFEBESaeAYy5yvFWmJCHTC+XxGUNaIvO+qmxDiUsFJ9L5aZc4bfZ31l+jVFuDVWUa6jgyktDhHCMncNP3ayaGqqX2kj0SgUi0AxRbIUpSVsuSCQBGn8xmBCC8vK4xdRuaZ6Gl+GlIgnOO56eYB8s4pJm0TXMpOsXOKBl4vywkUxfFELP0jbKgRBWJXSrqjhBgXWEqjGCPSEpFS1L01I5cNtWbVFfvJ8fP5jH3blRlLWCNQgRAJ67YjYUGKZ7Dp97pXEIkuG8hOgyeEoMw0WfpU5LvIGiLgsn5WfVNtzADEFHA+n0R+F+nj7SIHeySlT0AKC1AJxAGRIrgwuHTGoarMdMxF2pwSTqeEbd+BWUNq86gztV4fVjiWHW0/YX+tpoeC2HdB51jDakwmaICisXl5hp0ZD5H0vmpvq65LgSFBfF2rI+pyGigyb4Lu0aYrA5I6TQwySWOl6Z/VXAOjouTs7Hi0vs25Mw8NrKUALtuOWi2QqiLFgLgQUgCETVeDBkJCraSpaEQmLvGElE7IeUNKSsoMQikZz8+fGttQMkZeZkBTUI17njk4LXiyHyDwqXhG+Xq79NRUPYCz97UEFjH3Pc8CLWw9zbrP0UGY9rsyjRhzkKXqYcVArPExJBty2CGfHvzV91f/jMHpq7Kia/vQvgJ6SiUXzNO0Og1S0063rKoVwg5pKdHagSAAzAEUH4T9IgRNvRO17dKmRduYS0HVf9vLJ9kzYmwMCaw4ojATSUA9V923icW2ULkvzC4FlUWv2XNnmrC+C7a3ctGAPDlUuKQoKZfR062cUlL23Iq8Z5RKqHUHA4hxQUwJzMBWMlJcuo7JIm9KzYjIiCRWhjndq87TGDubmowCKQYiG6gdyAoUZM8wrE6AMe0DDRjS96pAs49s+kTJlaxCTQ4LxRCl7/UiYyLxQUsdHz3SqSBrsc23LjPlJ7W1SCAxNm2+cbeJTbcpug4a/qD/hFUqo5SAyjt4+4iXywX//M//EadTxE9/+hPk7QEPDycsywlLYqTTGUQJJVeUCoAWIJ5Qiux5MQaE5QzCRed4f8tuIR/b4O19X/n+te/a/mG/Mw2fz4dRiEe9rt1DHXM6nx7B+E7YzUHYazG0Q+Z8FL/BEMxBAHEQLD3YXDLdyJK3VdQiOmuKCacUcToJZl32DTXvCCEqJkUSFKb7XVG9i2uVg5roc6zJMwZADK4bgA1cjHEzAaUirwDnHYEiUjojhkXtThZm2lhBVJDSCcsi2LytXcO07adMPkatQedtn4HCBD0G8o/BN2h4dO9Y3R+5z3e7VgKqXXAMGJLyXbITIIg9WCpwuRSczxHp/BVOD4IFdku31/38+VuctzPO518ipYTn588tICxzRVzOCEkOa4QYEEgOu+5F/EDJ0qNXAteKy7ai5A338uOUe8DMvdzLvdzLvdyLlrwXlMyI8YSH8zsJKkEAxwpL09So/UmdsABKMyTVIFBcn8zhAW4/B1WbgBDTAFQ3QFiVTdAIlgoYW5RJBkqlLKDnvmfsWwFRRIpBjUEGgsvhy2K4WZ7QGKM6PaVus2WgzmQDjxro1N5Hg4VgNKkMBKFc9WDlUcT2fFoNMPYENOO7lu7kIE2n1MEzDYYh/ww7BYUO9qEDLQCawSh0hToe7YW1c9g75jW6ndBAfN9uCwI6crbI9T0XN3QUxRgXJ2ILMgDUSLK+nYyqyUkyKvzmbAhtTkkftddpcyjoSUQ5RSmOd2NLAWyuhmH8RpOQbAZOn1lf6lsS3NjaT/e+9jwwPHUtqXEHBbF8aiX7XqLrDVyTPvapiGBjhWs2nrFTW7MB6iekvPOpv0933AMSGFRrbcEogIDSp/O5GXMlZ4Dt1FIHoEPPkTYEANjffo6Na2Rsbwcv1MnWgDVqa0VAjg7k2KkR6xcfwGYgb4gBVOUdpR8WCcyDsqvoXGIFjby5L8F13A1lHsODwvQqfaT6u/TP50IOSFWgvnaqZpvjy3JCLjtyEWNR1mIB595nMDlNfiJQO9nRnYc9bZK9f84Fec/qABxTPhioR3r6UmSZBhhqX0kgUoBJKnGSMOxkG5eMPec+Txwwxh5INqDKDslP/cb4f9l7uydJkiRP6Kdm7hGR1VXVPTO337Oyu3B7AocIIMLTCS888ZfzjiDCiXDAA8gBw8rNbM90VVZGuLuZ8qCqpmrmHplVvcPCQ1hLdWZG+Id9qKmp/vTLgHiZHwGBw1qkjJp63tytAQU+GsYvzqASaSqfKlCr8w9yijCHrMrGy+WhzdDtC4+K4r1v52lFDc57Yx93e7qhHWIIt7WUSNcTcp5xuZyQp4o//OMV//h/zPj0+78A4Ve4ffkF/Jw9Msveb69d26+LwNOJuDnNdPfGyDL7jo3nottrLkv0m4pgOX8Y9TVQ0M6a9g7cdZZh/W7/Ijvv9SOlyaTOuc2VjsX4cLtecbtdNTuBZDHYtIREUieGonyojbLxeT8LunXf0cBBO8wW8dY9AMYxf9V7vr0lk3Piu8PPo6e2k3g4H9sjlD/bSkZHpvY9WVp+fRmHS1gNgeZMEWS2Y9BxP1dECGcRawa8O+daHJkClaCe//ju7OclPsvOuiZrUlKRJsiA9nyWOewd8dxAZc3OxzGLRO/gCmy86dlCHs3MtUU4JxLAnNWpZMoZfD1j+c17VCKkX/4edL4iq9GTS8jiNciAUVbwjIVQnUAyPomxxSM6xahNLYuEPc8MtnKuQw058h7LXjHPE0rZ2nunSZwBuFr679rNidFEZ9QL/Jvc5aP7OUi+7fP79IJXtzahP/eKzqkZkqLs2AxABJQqcl1P16LbJZtoWEBBGO9wz1HZlsjHrKxXc6IMcrPJjXoTEOiSq2X2Mf6sxjo7G8HY1CBHlFB4Ra0LmAm1EpYC3D7fcLu9oNQVpWzYtgXbumDdFpS64frpM6ZZjBiWZVH6nAdZPSFPxiPEYJGylEgAiXOc0KQOpRY1FrPoqe0skvWuteo+E2cZk00p8APTBWXK3PBNYR2afqjz53YodcBioHBF5RWlrKJTQ8cFzQpFUGcZDThhdyqxs4crwBRl94Q5T5jyhMTmQtXTWnPEU+e1XidWPTFllbWcf5mB2NjTsng5Qw+s4EbnTbZX/czKL3kGKClVKSWeReaf8gR3UpBSru5IARBlzKdZyp5AStiWuihvBdZ1wbreMM+n5rhnY2YWWkqa5aJWxpwTyiYORuZIsJUNYMK2Fh23lJsu1TLeyDjXdemymMjq2qpH3uPfGxYTthXaicrdh87D7DwyHELPR9lztWnggJe8IqKu1NGYIYjbSgMxW4PrzwG30fH4OMj16fDeXle2LEFb4DejXo7hc7T7weLIkFj25uk0acR+RWEg64Zr+icS5umCnE8i/yWRvcVBtWBZhIeIE6c4PclZZHpUv6+PGlG/lv3Z//ZZYTx3xGsib962PlusZVjt5Su0fsYMTPbMDveCP7v1VdfvqP/3Rh+fO34uz7TmTlfiBGf90k9aFjpxlkmmKyrttz0gjE0N4vqPSErCRIwCoo+CXX9JFlSHDKIK0IoMkYO4bigccMDG+xJy+LwU4cut9FN1Q/k09SVafJ+qXkTWD5NruOn3gGTflBKDei+pvgkETErOOpHlqhvVddeWdQUSI82CQ2zb0nT1pJmjXE+WKZW9IliYlVDj5P1OZC4dNq7aeLmkcuN2nhjpNBwt6A0evOZnYHPaDCQU8ZyBqnwSo0wHk3t6mdyeyZ0iE15F8X6087cWgpU4ZwjOXkrBuhKWG2FdFpxOM86XM56envDu6R1OpzPO5wtSmsAs3gnNcS5LVnVNrtWJhkf68te08Y5XNBcAFqhiGpfxeVcpo5qFdg33z1F5MCHh3bv3mKYZKW0qcyVTrmRXEkm2d7vbPPeJgurLKmERQLWptiklnPR8r7XiquXbJWuPnLuiYxSXrezsU5qlBuzpyIx3NrmFBfOAlu9iFgeqwqhZymolZOR5grnyIAuOlqYk2RBTz6dNR5FzQ51mCCDMXZZr2YNZViFZweoDfZXRyVGjXj3qrH6GGG+VvWnnl2GlpQDLQpjmGZfz9y5XhLWWvfwC8AquHzBPZ5zPsziES7gn5vlJZShxxEtEoJCdXhzu9HxjiN/t/WP00b6xPRxmHu3RHu3RHu3RtG2bGO2macZ8kjqhUkNTgG4zfObMYGRQqzHeG797w54IkQZ6ubFP3hmjegAE0MtxGxfMRBCziAuu7GAjF43QEIArTyIAr5ulRhUlOqkCX2pBIuB8PmOeE7b1iwKVk0bdadaUoGYkjWTox+FguaSs5k5QG0GMcY7MicAVePFO57q1CJyW6tTmRTFqSqYIFtGAYVHMlm3DQDBLLalG6+Tzb/MrQHKfDtpA9GRGX/ZIrGhYMIODAEQ2Z6QOPFK6ZRw/ECICwlzKovfgapznOK8NPGK0PjShntGU91HREPop2ue4A0yh0mciKpntRYMczsPYjoGro8yvcXx7Y7jvq2jEsn8WtRfnRUBIAxOcziJYGMs29HPZr09M9T0+x0sfSERLKQUpZ8zzDBBp+vpNwSpLRQt9bkZSYDiWI7nvBKB9vANw3itZlogEPGDW2uHSb+mrRfExqIhxbitSkoiU5iXrgwKeyr9U2+0Ry1eaYmhvfPf6uI/mgdkNELKmarDcCuZ5wsvLF400yhqJqNC0AhltfloGCWq0Jn2ztPVuhIS+TyL0hU/J3xa1qf0vADa5KZEYH1IWkCMhKY6R0RzcFFg2MKLUqhkBnC/KnKuDD7OmWB/hIO7mWmhLIgSdJ8U5G50WsVuH3fdK/5ait13PjGiobitle4f7vhmQhDCvR+enfWfGlvjOkV4aHzG+HV4Wefp8SqC04fNPC/7P/+UMwl/jqPUz+/MaDz/tNz0pd8BbvD4CKv7TjIrx3iG6um1P6goEdaDd8C4CmkOM8U+Ovx84jjAlMM0Srd4A+2H92AHfVZ3Mai0NWBJDmmY/U14Q0zsDAaB7Zc3fbt8Okuogf/at39reAmGPvv9WuuSBqkbnhnHe2+fJogcTjs4rNxQPsh6cJoCe97zWKh/LEPfoYByL9cX4VDy7AQeoVdTqweqBB5kzigHI9tlRH2Jac3FkZy07tqnzYII5hyfS8iTXd7j+9gcZw7tPSCcxYhMlbK10hmwxybSBtmdM9krBE9X+jvzSHA7M0WUseTpmnDEDoYHUKSWcTjNuNzHQR4eZBFIDx9qV0BzlMvtXNRsDuF/bcR3dief4ujjer2k7OTusWeyfzd9WSr8nVLYdS4RG+WUE2ceSYH1fQj+CBcUB9L1MZ88lMudelwFiNk0idcwy3kpA5YJ1u+lZKrz38+ef8Pz8GZUlMjZnlfMkbQ2uyxVPmj1zXaQk0+l8drkE7rCTUkaeZxAI21a7cp8pyNPMmolG+5lzBjYe5FhGSr6HRjqKNObzHOY6rIsuXT//gBhOWAwuW9lUL6oaFCPv3DYpIWAGIQ6ZvkgfbPIPA+5wMpHuM82Mw70jVeQvtmfMycLGVZvMk1XXcNnU1sgMWzH7Q7Y5Ds81RzmTh8WQU5pjkuizEXOwOWaUImsLRFmMkPOEnMTYKXq3lDtdlg1XzRo3zzNKWTV7JZDTpLxia5lXSil6XdGxcrtmmibRQ5KUyLbr7RrjXV2WibDK91UVPryubcc7Z+Eoc3fOduS8JNJ6dBaKzoux9X20s9T1o3skW8PHAAAgAElEQVQ6cv+MHneyNbQ5c6fK/YTseZo900v31VrUaYk1e5Y6Mdn4VY8R56XeuTOljOW24Ha7qQwo+sI8z5imSefx2MI3yhX7uaPD3++1Uf4Y76+qfwHu+GR83ZxgjUcBfUBOxAnGPh+dPUe0IBfdl3XujbHTQYMGYXzKeKI80x1mWkDLvXcqP8hhPJRnjPsjnmkyj0azwq9yykjzCRbg5HKjB52I3p3aPcVKJ7Ngr5a1NlGSLDU5BwzF+56sn5SQkssi21ZgGbxs/D5IgMgzlnLZULhiyjPSNIMbbmbOQADXDZV0TQl6jmhmqzzByuYQKQAEcRaS6w1Hks/lvB91cqcdBkc/qPY94KUOI32Yk83ROrV1HGh/XPfxPf4bHX63uy1eFfaGyX+WUdbLwss/oQHZi8/Pz/jyRWTly+UFL++uOJ/P+Pjxe5zPT5oJOmFjAqWMSQNPjf6Oe3lf9773/b3P/Luo8/R/R61rDF2IM+shhf55IsLpdEFWJ9ak8ghT8l3ONt4h2K7xJ3WWYbVjsCMJRITceDyr4/TWzosoa8WsV93Y7/Ak17cATXOmnwOVLLNVASGhpg0lrZqJSzI8ynmSOxnFXtVsIFzRSs4RIZEJ0+R4hIJACSwlpEPfYv8Nh4pOrvGaESPux61/E2DBuxZQsK2sOtQJRO60F9d6nitSvoH5BTlnnM8ZOc8ofEEphIQJlBOmbGO0rIrq4AzJOlO4opabZqg+XJZH+xnt4TDzaI/2aI/2aI+mzUAlSTvuZS0qMayGLSBpBTPEk12EPwexXZAi9BqOCHK9LzmaAulCWOqub4IYVMhjA7UyKE2wtMO1WgkKMXLP06SfreDU4pikTAgloDqQmTPh+rJJ2amUJcsEEupBxPSo+IsS5N91ImQQLKNh5QhYfsuQu++HTJF7zWskh6UGbYqozSFMRWjKffe8MOMgE7YBIlPWTcm3NRLQx1MqhwcSwdLu9irTXrmIwvqotkXDjIGENjfmaCVzJ976qgFpFJimgIWnKDaFh8g96QUFTm1OvIYz4FTjcSEGMB6NxWcSbZ79ElX6dUrseSPQ52BTNAbswaaxRWXOwPjX5nv8fEx3HDOxjMrSNE1gVjANFXURsOR6u4FIjS2aNQENK2EFzu/3wZTSI5AjJwfv7s1F/F5o1zIaKfhdqUVVyezLqiSmFh1MLYuURIMKKC0GPq4ET7c0vv0+jR8pp/GzcSyvrbM9w8CrzsgQgDgD7wzgt2sbP9A+M9Ai5D2zTASSwns18j9PE9KUwVy6+RZATMpYSF1pAqiiOW0kgmRsZTdoVQa3Elee9avNg/HrZJmfNHuVfa5gnIHOO/o4wmO5d747mvvIp51f94ZFA7WODAzmpHQEcssLjtd2pItolBhpJ54nNtYWncdh7QhIqcK8mUpdpFTaq24Kf1y0wc8XAXQrRQ7n18jPMAfkvSHgIOnJAGaS3EQNOArnWtvx/pe8wz7v+8D63fjK+cI4fwcwZjAmzY7gs2lyimXaktIwC4jEyLJtFdtWdw6DR7xtBPHv/Xy7vS5PHDXj2/sn0c953CvtNXp77V2+soffxn0pBw/MMPJmj3RfJc2U1UoLDWsznpHdGVVrk8+OQcb77z5qoxPx0bXje45kzkhTKScrZtidy4mS7gCdB5JU2NM0oRRxrBaxj9vUiuNjBKoBoDfoWxaANlepgi43CAS6qnOhZoNIom8kc3okQkqMWs1J9KhEljn1umPFuq5IKUmJHL3+KEsQ2jjcESLSf5MZ7fdSMM0nAOZgS93z7XwABuOgHHaHFH+kX9xb669qxj+PjiDyMyJGsEadYTzvYj/v8alRvhv1nTiecUTjWXrvs+4Z5HqN32NrAABSBud2veKGRR0tburYsCJPpJHEyrNV5st5wraVplvafLZ3xHHbadbGrg60ugApzkWSLDRE0GyiWia36QMWsb81mrMMNaIHGU0RWlmsQTa4J7uz9Zz9vExJNZyqEf4sslmtBVmNw6z6pP0cJ6OnD9uDesYB6ri8dxQ0PW7knU1CbXqZlVTgJtuMMhoALVfszl7RSSO+o2WKylN4/xQCCjwThzssuXPFtq2oKbWskURS6nJZpFwpEamzhjkMaim3ZekyrsT9HgMhbG6iA+24v2JwUWw+h1byb2xH90T9z8cU19ev22MaI2+Iazk6RLW+7yTA/TtfO6tHGh+DJ6Kj5GvPOHJyBADKUlaDEmGaZnekJCnFY32P+8vKC9ra2h6w8oAAYZ6ndq/rDz2PHuf0nk75c86He5jAvb/NeexIxz3CL76mXyO9DF9+k4xJbQ9aH6NcaFpHbTyWNcuCZbSM/+zcY+tj05v9RUfzFeWdfjj6ZOXr2UpTsWaKroKLgFlKkhUGSEpsS9k6wVtTNgyuqHwmBvRtLW2orKWOqdUsRpNjzBnHaVP2svFXgJFQBAexuagVTBu4eOlAkWVlX2RiQAMCnIeOQR1Vz7rjxbTrzEHBzuu4txp9NdwgOif1/MrXIpRaxoGuPDw79udr2yjnvHZ/dwYPPMnP1/0zLDiRWZwPn5+f8fJyBTNwuazI0xl5uoBpQ5pOAGdAy7+9+1iRpgXbLaMsE+jwLNA+2Ltjpq+QedX+Hp8QtW/j5rT7xvaWPzu1O/rWckrOC9K84fxdbiW+YM9gaOlf+4Tkb0LXB5nzQb43uRbCFUxPN9yLaGpn973zrT1rWNN7PI+RgColZ1t2QspIZmMBS0bHTeUcDbyd8gzgJM7YOaMU36tO1zZakyN8zq3fUc547YwYZbAjbGvk9610lvI9ami5BEeEvHPIacLT9xvyacN2JWzX3LgzLyeU54qNK6YPN5ULK6acMU8ZZa04n06YckIpK9Z1AzMwT7M6zGjpvLLhti64rQtK7Z1+Hu3nt4fDzKM92qM92qM9mrand9/h/fuPyHmSDCxpAlPSDIhujE85AySRNFxZUkJqnV+pD2pgAjWBCga0mbBKaPVzGVrfObmzAzcBODWDgyi5IvDmJDXNBXiBKrkF8yylJ+QfUCrhul09+4mCtOfJokQqbrcVL19uYgzOnn6aea/cuHOFg5VmkGdYqZG9MmU/ozE4Cp/ihNAbYMyRxkCzLgUroOVB0OanPY+l/jJzVV3d00mbMbe2PsX5Jl0I0nkWbZRIFZIG8jiwa1GErni7ypISoZW72IEp7i3fvgc3ZcbGfAR8moLdAMMGaki6ZCvFYSYJ88aXoUXlVubIlXQ0ZQWjkhaapY8mOnqezdMAqiRLVar32bwj7C01sNmaJZq7dR8jHJrRK3npF1RPdTwqSqxgcqRHH1NQgobPxih1f2/Gu+8+4MPH3BmmLk/vAhjDWte+YFk3NyxgD/gSEcZI0zjGPRjTg8gR8JS08ZIefWv7xlKFavQcrEZ2wpRmIBgNTy1jiAFc1s84b9HpYqSRY+V5VK57oJq7n2Pze6BjjAYAGfu6bMgKzsvcW8RbH6XMiAY8GaeleTZ+sG2rzBk7zfj8SqpX+dwMH8J7uG5Imo2HzYSq7y21gqiCuIhhSqOYfS8I3Vp6Z3FgnIS/V1bAU2ioApho0vPD+i1DEqCptjT5cY6PaN1o5wjQspaSpO9n5i7t/FEpDsm+9baRfNynsV+jU8/RNd1nbS17ECVn4PI043yekaeKrbxgK+agOPCB8Bt3nx0beF9re7gKahi3FOf3XXaGUSkQgyBPkD5fZZJwJYgP3s27Zx79ZVcxEEo09Vf92b9c8df/OVDxESmdICnb3BXYHNDW24LldpO06ijIiVHKipeXZ7y8vKAUK4F236E2Gve6Pr/xd2xfa0gZm7Cmg3vJ1u3nPXf3ngay3b3g677reLTNn36mcoJ81u8jm/fouA24oS9J7cbdXh6Nnd25VWsrVQryff522zu82M+RH4zXHDlbH/GJCIw2mJsh5UvBksEwaclRZmyrZD84n07Km684zXMz4hcrO6Kp/Gv1KOd5npHoLOWMWLI/zvPcDABbviL/y9+JXEK2k6FymfHYNhqVESSLh5VVBRCiQqlFZVpmiY8fP4KI8PLy0pVXiTJzKfK8KEdY6VNmxlXLqTHXxq8TEeZJdJCYYWZ0+o0gdDOkyiB3q3/v7DkyzoxrfNSMR1rwgsm6Ticuh7j8brpS2tHiFkrGHdHUmC3Urht1mHadORsejO/IYLEPrvDPu/1BdpZLxCzXFyzLhlrRsk4QMeY5I6vz78vLNWRDyiBkXK9Lo+M8TajKE6VcUgaSZUg1/kIaDQ1E/hidLkzmJBIHlZxzy+JStYSUOF9IuT6h50nHWIKBJ4f1O3L+6s+VOD+pBZpIKapSVmxlRc4uT9p1zHYWmBObv0d0KtcvdeW0lIiWOUoZidwxJZ5p8zx3ulyjI5KMChWyp+Z50myJVTVtkkjzYdz29+l00sAfmZ8vX74AELlwnmcAaNldpumERB6AER1aAOB2u2kf5uYw+OM//ohEhKenM86XE1KesW2z6vfiPHO73WD6dUryvmVZdg5Cy7I03cfGYO8TBy7PJjruMcuYdSQbHqRkaHTh16Ktp+muHrS0N5BZ32yefN9nl3+Cjk5EbR0iHyiltCCI2KejfR6feUTjNicxKt4yD1kmMCIvOTu2I13S9MVSC4gJp9MJt+sXoZ/zGZfzCQRxnCKlSxChanCFPWPbNnz+/AnrIk5TRkOmm8l87Ncn/ht1FpvHo3Pma2S9o/0Sn2FZdWw+PSvTevf5cU/Hvh+NK7bRCZhI9UUrHz6cm8dnnQRByXfcY44KhzEECxMdMZSgrKSBcXo2Wvkm/Vd0Xanp2kGm7MbvTg8+fvsuw7Qec1qJc0akDli6L7Zt1exeQJonLW8sTj8o1RRllVGy6+3al6fzRc5zzUjD8NJzLtuwloNlcdgsG5gLKJeW5QIAsImzv45MZIJaUUvFlAgbV2xrRcoZ0zS386OdS9XxA+PzzIyULQuZ8zxmqMOg8aEgU5DhjanJZvb83X4Ba7l101z3gTTj/hpxstfauOfGz45a1O3i9TnPoDQH3uNzEekJMBl1Ra03vLy8YJpOOJ3e4fLuA95/+AXOZ8bGGVwlY8d/9t98wR9+/3/hN//uA/7xf/tz7/NrY9OAJBo+s/tGjT2FT6JDTQw0Mf05ao0EaLnGcI3JpgDO/+I3+P5v/m/88PFXeF6+w7IWPc40azkRLJqGiHf1zuUdQZ8GVIghdQoTTDtm1JL18Iz3y7I0TPPeuQTs5eD4kxkgZJDuPSi2Jv2xs1Ay/Nk+IxEMMfFJA8Nykw3s+6ivcuhHKRIIFbPjtLUKcsfY/+ikGzNXxT3bjQumK1ofjF8TpBwugZCRkjxzSuLI9ff/bcV1/R3+4X8447f/9oe29p//p3+F538HfPfnz/jLf/MPmKePoKSldXnGNq348GHCcn3B86c/4MuXL5imGZcffoGUlM9xwbpd8fn5D1iWFeu24NH+OO3hMPNoj/Zoj/Zoj6ZtPp0wnaT+ctkAJBfemEXxYYhyR5pSMKlAF4HUCLh0QiK7eMwq7E7quGIARZdeMzifOFDk2RWioUJ+F2V4WVYBsBVsOj+dMc2T1ByvFdu6ImVgud3w8rICXBRE41YHU8BhNzJbemj7O8iv2rSO6qAY2fVRYRvBD6B3SjCgPyp0nbc3EaacUdVIR6Y8MpqWJQKrZYCxyEG5nlNqilHrJ5HWh5XnM4CtSIT8PGlZGnMWkpoBsNSxlCQaOXW1sZUOyNPT9nPSK4RJn4HgaDGC4NFIPRqHiIyu3HmgV6T9fSmJswTXKnNnBXAZoFSaua05PwXtlQnNIcXHdKQw9X9b2nOja0p7hauBRYLc7BR3+3uMpLPPunlEb3C3a8dUm6MzjH1m7zsCEGxdqjwQ0LTbXCu2WrEVjVRSGkjTjFMWx4ZMDvjee/Y9oJSoV0iPDJVtHkn4S57m4AhHqKVg3VaJ3kqWpSRBbIW1rUEiB3mN3gVI5G7NfT9T99m91oOze2eZcb3Ge/RbWAac/p7caCcBVq1YSwQkqf2rNc3XdUMLmiYC0Qh4ApSEpxFnd0yYpGQdGngoIESphMICsyXWbFc2T+xxfdu2IacMEASoqwWkRmkKe3qenwTUq0XAMQNXiJoRGpDoPFKwU9bLaGvS+dJ66QPYegTAj4Y9M5y19VBUJ65NzChg141GwzELwhFoYZkXjs6J2L/RCc5Sutv+qwGsFCDZaGDFfEoAZZzOCZen3QHmdISGNfu71WXldSjx65rtHoN6aPf//fXGjR12i1yXg+ua9fTec+S38fv4t5dnsn/cX5cE5AQ9gatmh1PMjjUSUyLrK3ImiXrfCp6ff8L15RnLcpUsHWrwjLQ40sARL7nHX+7znePP3wJ5X/teXvVt1HDX2ALsFp5AjRC58RB0ex1s57pyJ7a+WWa3nofeA7dHmcKut/1vctK4PtGY1c5ek9V0kmg4Xw3wt/vHjCdtzAdrGfc6cFxKYuRH9r6j59m5JTYhL6lZKwNVyoDknLFtRfmglPcTh0wz1suZcprFQdFTwasMvVYwCqzkxLqu3ZxPUwbNEyIwG+dKnmNyC7V09TknTJPI5OLowmB2ZwwDfmO7XC4NIDcHGwDIecLpdNKxrojOvnFdL5dLGxdzMAAQNcP1kTwSf4/y9lEbz4W32kiP471WmpAZOkdOt8e0xE1OPXrHmL1jHFccc5yLuBadrEm9TA847RpNxPKg9rnLg70TtemRXBlMQnPbVlGogrDBshLNs2SUKXXD9XpV52B7HmHbxMnbnS4kgpVDMUHRq8SRmytryQsgpUkz1HgEcbdOEGNeJ2eDRN+WGsNIKeNy6Y0kNp8592s9zv09/hbX7Xw6AcxYlg1bKai8odYNOc+NDqAGUivXCwDTNDqUmMNZ6d5jf59OJ0DLJ4wO8s3xbOBRRCSZr/KMlCbdz9TuMV1v2za8vLyIw7uVVQhZ29Z17Xit7XFzmLI9CxadZVlWfPjwHoA4sWybOE+dTrPyHQCoyAl49+4datmETj4/g3JFrRuW5YYvX56xbRsul4vSjxp5Najgu+++6wxx67o255g4H2awM7fz6EQTnYxe0zesRRrpjWkqiQU95gifGGlr5AGlFEzz1OY88sKjbI7ikHZHHhhk4CP9LrbxGuPH1v8jnXd83zhmc5Sd8tSc7k+nM+ZZshczhNZAwDRPPpZQ/hUQeXC5LZjnU8O6PHtBMKrSflxv6QNH/P5raCHKI6/pnTH7k52Joy5j90T9xWgz8oRRL4rnTrwOUBFooLt7gT6h55CjIGaOk5UgzQpbOchYTZ0jBaNczpdtoPxGHQbN9YwSSXZt7VuUWY70ujYOSJBKreYcLuvPnKQCoDqD5EnkrJRMb9XM3SkhEzDPlmkLmsV3xnQSxxPWeZ9PF9XnWZ0sJISsksxB1bnKc0aqFSUVVEqguoFqQeHqWEiikEULIKrOY1n2B+eMrfTOUsyuT3N1Ws1ZM3iTBsOQBwUC7hBt5WcalszmZNDL3jGQzuY7YoOVK7h42aORhkb6j6V90Cjofnvr7D26pn9flWy8d++xUqS1zam8x0oIyTXzfJEMQESgVDHlio8fgA8ff4Wf3l3wY3B6afMwaPj2fxquG6+MM5Os7JbttdZ/KbEk/sXc3Rvv8zf37/3w4Qf86Z/POM3v8NNPz6KjpKyOreLMbHuYRRXseyyTJQ5vxjtJ8D9OCdloo9YOV273q7wQ+dnR3h556D06sNKNI3nYc0vdYMGbIv9MoJyxbivS7YZSKub5jGlyZ98WUFtFv2KGOK/RXvexvTQ63ox9jfsnnp/RsdHHGM/nJGuCrDq64Wf6b0qYJyDPM5hULurmRxZy2xY8f/kNSvkReXqPaXqP8/mCjx8Trrff4B9//C3WdcP5ckZOG5aVQfQOXIGX2w1frlfk04anE2E+fb0e9Wivt4fDzKM92qM92qM9mjVTHkEu5KoAxyCANHomASiaeSGIu00hanXHo5ktgh6qDMGdYLxFpcKEMQNyUgMXLAJiVOBrZfE4ZgMZBGRKVg9ehdJSCyoX1LoBzMh5UgW2tihCU/xEKPQMF7GvrNaeUVC2n/eiikega4y0idcdAyXJTYxspj04EK+1j21Km2Jhc62GGbud4joDbf5Yfz9Ut8jj+mHZFKCRNt26HSuNOyAMBCGuXrm9BwJFgNaABdWPdiBYnAcbPINb6Rhb50QydePcyaN00qJmRwbw2Hu4TX+cMck4wfpeEoXxQLmWMSH0+9jZyv7efScb6xDEMfByVPCOAMf4/HsgUPydjYhYMkdRM9j1AB2lBOJ9PoHXjEwyf+r4NYCwkQbi320fNvBEjIHGE/wdQKkM7pxlXP1XvRsWce20KbQQ97sZpN5qrmj7dv2WZjwn0omAr85nx303PCH03Z7DOrbU7u9/UHc3Gh9P7TnxvVIRx5w4YrYhywo1OGnlpJHZ8pycM4pGE3MpkPJPqZ0mlr2FJR3CboRubCUFy3rAIxqgfA572uuNcGj0fcSP7bojwGRcg7dA7dcMA0d9t/FWaBYrCnsStfFGMTJnpCmrw2cAiIY+HIFZX0Hau/bafXz3r32/vB+ssgjvUbJ2LXf3Hr/v4O/gKGM/7Vl5Zvzlf3LDdJ7w8U9OACT9NTMpIIcg6wT6gZWqlKj7dbth3VaROZKUf4tA6D+l3TcmHLcjI8zwxG/swT9lDHomC3NRHtM/lxttR8g23h16crBPI781YPBo3uPeNz7NscTXwbzFc7CdsWyZHNB9t79vD1iOz23jPJCHjs5zl4ePs9IYz25iDpuTcQRaSUHWqZ25RIR5Pu1lN6ImP/fvAcCuJYzAczSkRYcjuQ6IhOBr18xXcNbs8nbMLBGdrm0MBgBXBctL2VCKZJY0AxMwUn+f/t/fuT/E49giXXSyL5xej2Tie+01WTh+337W2takiWiNb7qQyq4Z2NG+ky/HMRz1azz34voeGc7tHlu3CNKP8utxH/r90+bh6B1ELciAubbyPW7kNxmv71c0AEL1AI66BJPoVtUcVPt5GHmT6b3irMHNyZ3h2W+YQwAC+X6NRorGK+/IC+OcREd1EKR8Jm+qm1RYvER/n9Fw0C+UT1euyt8C72M3UN2TX+z3e/9sbpJiCeYkI7yxf6YZ6m1820Cv0QnFso1EurT7DQ/48uWLOIpXLb+jGatkHipKMRkhGpC8HGh89ki3ld0R0KLa7XtzMhl1NZHrfP+Oes7bzaUZoxf/N17zdjvS06D6Q3RCjH0cdU7DiZSsDscxnmPj+8ffX7vuSK4fx2Lviw7yRHGeuTmQppS6Pe24h8l83JwqKmtGpNRnyN23+5Ly0VwcrsOd8b/1vCMd/+gZUc85ambAPToDxmfc6/M9/f+1z8KXytttPeOZx41/t7FymHE9F+VjXU/9PO6dXsbv50iwx73e7e+1TCmWicH1DTl91eE3Eyix8hvDjewcEF5EKnekPEn2LkqoKYG4wHV4z55sW1+cij0ohk2PSlqenKujY3bItSNWfmmyospEFe4waaKr/J6ljBn1c8GVQfmIhrwcNOvkv0bHRxnwTGZte/eAXMZ9FOV8v8jG/PZeG58d+3RP5onX39kNQfb14KRIz7LXCrayYluX9h3A2FLF+ZTwdDnjF38JUP49Xp5f8OP//qeoWx7f1KS/e7PN3bVAy0Oj9ENoEjkIlk/pmKud3i/4/td/AKUs2esTgbLQS2UGMeG7XyWcz+9RCvDyskiAGxnuHcrhdT08WuxwHkGxSWaBDu6cpfE8GGXOe+dPN5+DfiNrh0G2lP52eqY6vbhzLposLHStez/wyf5sVadt4h2Nu6Pxcb/v8fqjuTDZSK6LsqmtjWTEMoeZlJPu6yKllCr32YjaT8b66Qk//o9/i1oTKEm1gGmaMc2EdUl4fp5k2X7YcP7rH3G5AIkKbtuGZf2Cdb0iT0JL0/Q1GV0f7Wvaw2Hm0R7t0R7t0R5NmysNlgYzIaa0J0oSraGyvFQEkv/2XtomLkdhbA+mmDIQRXIXwABTIv0ZLhib0ueKVkzhSkjIYH1+Thl5SiDMqGXDp08/ofLWJHpLA2o1QQmQ6PDq0YAjYCAKtvc7kY379Tl+rY2gzeH1ClxSQwRCQQpTbE2RIQxrEoBeilGyItAbKGcC/pTjOo5ApxmcohOBSfoGru6F8QjcjsooEeuaObg4OkeMQNebIKABI9x0JAdFVJuxOWkgARhhaWWeXCsEDOJmNCDUnhVuai9nBc7s7ZYJo58fU6II1JwX+jFHQGoE345Aw6O5f83wMT5nNFqEh2sFhYhKAb1B0/4fQCVmUIgWew0AHQ02cU33Clw/5qawhudWpeuUc/ucgVZKwoE0dRxjoDmCkTnqyFMpjBNAWNv/95v1MXyCCGb5NaqkE8BcUAqjtvG4ogto2TLYXtbPiRoZM5S0WWuuwwCr1KGOskqplZyodl/Ld4NWDsjSRaNWoBQ4LkjtWQ1UZDNMQMuj2Ff9PDgo4FMjUdupgXlxHkf6G9NldwYQg4QGvnZkyDvmU/7duP/uPWN83rifY/QTFJhtfWx0KyAGWygW944Cr51YPeB1BH/901vcSbbmdNCrEbQDsddZv3dN+PvoWe3vwVnG2rvvF7z7fsN0OeHP/55xumSkNAOYJGSTxQFvqFShoKYb/vOUGphOxK2Ddt4CPZ3c489fa2wYvr3z+R+7/Xz6kCPXeDpgKfSJoKU34oVhf7f3hi+7zw7edTDHR4YgZi1BA+V1d5yf7doxS8p4bnuWhqndYw6EZij41pX6Gj4CjHKb8SV5I5H/tLMu9m+a5iGzSNY04p7Fxs4SycLou7AZMZr14Vgusef0fXVZhUACrGu0OCtxNMktocm7Nt/jfhqdZ2L68VqlrNK2bd3ZGB3gRoC7WpmHAFofrf1dw9+re/bg+je+H+Un2UA2Fpdr3TkmXl/7TXWHru4FAFi7Z/S0M3Q0PliU+bhPesqRYYwAACAASURBVD2rn9v9Xg0yD+wYJMl82cqkGs+VLEhVUom2yPNRdyUiTNnLXNjx2r6Hyol2eLHSphoOpGSlX9+c85jVmCDPrDoWroxSNiyLOFMarzGRuunITTeOe3hPb0dnSZs3ZpRtlTJM26KlAavyWZ1/MKLhUfa4GEJqsnNP3l1rRcpBdyLd7WQOowTC6Pzj9DL+tBIcI11ZCVJ7Z+XS6DGrTB/3ns35uq4tu4xdb6XZiKiVviLlJ4nM6U4yIFWuwZFOxrguWyvjxIDSkWc3aU4/KTjhMXtZqWEfbNvWzoW4Vs3RQo1h0eHQxnf/7G/EGf6Wnzx+dihPHzzxQMYVbVXGM2aSsmviWG2tk9JD7PpR9lRrY+bT2J/X7rs3P2P/nM6VTkOGM+EHWrYrS4YC5IStrBAVprZyauZwZaWI52l+lW8edPnNNmJR98b2Nc+w3+Oc7nlvr3OPz4ifHWUeG/syvnvoGWwvHdHbPVpntmAneQbbs1lRSnL5omFc7X32FDTdqeuL/sqAZgR5a9FcJm3jM128w4bUsQeazRUAkMCwwD3lwUAbX9u7DEgZeNHtZFq8NHHLtmpTAufZhmcRAGS5ghH0KWZYyXLJ4hpkIN3raJnoUrve8BGTrZhZS326DCZrIGMscNqJDqu2xF3Jpo4+PRDKacWwsVG+TY4mjGdhXLGBFxH2tPk1++rb2tc8iw5+Gg3KnC63K9K26bwwcgKenxNKmTA/Ab/82xuWlxumtII3OY+2smBbV3UsYNx+esLt05OM805P4omiqJmWQ+51dpP4PZ8S8N2/eMH5HePdD4xf/B1AWeSfyisq1OGKk4o5GdcXwvPzC3766VkwI80GzUTeEeBe3AwAD5xqDnCsJc1qL3ccyZzjGX3vbHnr93H2jr6SPUVqa8hDWfWig11b5kLLBuo6SW37i1XGsoCAKC8cyVtHY7K5sGfEgF4i0oDQODdJ5HhIqXZKhGlKyBOQE4FSReUVzCtu1yu2VfH3potI216eUP79r+FPj/+/APgeAJDKj3j/63/A+ZRwu224Xl/kuVsBpRnmnPhof5z2cJh5tEd7tEd7tEfTJgqZKFVJI4BYP9cYUJiw7sClRILN80nKIBWLVjNDXYz2cCEtKr+9UrwX6mCiN3sUQJSFiLTMDpEaIIKAS4SyFczv3+HDh/c4zRnXl2f8+ONvUTWNqJREtbGlBgKBKlLqy74A0Aw6Nib2/hB1ikYTYA8AiDhGZt5FxTbgEL2xpb2MCNUM2wlN0yNyZXi04nXKNoJSY/OVkoL/UGVaUmPXId1q/Cfjs/eYsrpXSkdANP7tc+vAdmeYGMa/N3jVYY0CMGjYghqLra8Ei4ax+vAK9KTS0an/pDa8BhiEtYn9a5GCwUjUQHsfxSHY6fRt3vq9UnNkEOv2kzy5i2jzlLf7Zx21ewa34aJGh34RBNwHmhHEAEYdMriUlm3nqC7vvTEijDEaXmx8Rwqtg1+2ZuK2kVSJTDpfjb4TqfZNALuxxGrSM5tjnewzfw8b9vXP1rrsTg1k8ggkNKMKK1/cUHhTXkeSNQARgHQQvRkomUBZwbga14Scplu9cQ47X/ab8McMKIiTuAJUJJo3RKkwKkpZuvl+enKenpIZlMRAMqUEygllKwK6G+xpqCYAqWkPNBsT4nceJTca9Gz8x3RFPuUHQJoDf0eRb/1+i/v+3vcjADOemRHUYAU1bc0BRk4SoS0ZIhLWpWBdKqYwT2M7+rQ/Rb69fc39B+aMBlXT7roAgA0hhHffc4CqcbeHj/rD+OHPX/BX//qKPP8Ayk8AXQCcQMiGSkumGBgfiLxc10HLyJCex4KbmzG3Ny7cM+zc49Wx3TeevHnrvSd+4/U/70UmY9rdxcar9J0otUGwnqvE4XyN6Omr/d+fK3Huo1N0PNcZIg/nYT+Pzxj5ibEm413R2VV4clEHDS8XIuz1+D1tVINMdcQ/bDyjw/GYkdHATpGhU+uDz8GG8/ms47OsPMC6FpSyaeYGKXHj0cG1nz82+RLKj48dFaNRsZcvU7hOswHCx05JygDK32iZDmwOTM4YjaJxjpiha8QtMpEHa+5IO7VWcJCNRz3htVbqKLPe37/x/V/T9vMbn4EwpmM6Hp8VnznKaEfvPJJX4/oaPeacMYcU87fbbVfyaTRo2DM9g1zrQXcWpiR8d9ti+RoraxBoklKXpSQ+K+cJRbOvmBEWlJrcZE4zrjOaU4lE1hr/Nx7muqDIj1XloFKl9O2yLFiXVTKhqOzjZ73pF5aRZs8jjI5NP7fW8yWAObW9vW0rSl3VgUccAEopAJvzGylvMGcBKafgjxeno1mNFLYGhgO0058g5T3C3rtHRyZncRWnNJmvHBwNK0rZsC4bSik4nU6YpgmbOrxdLpdmVGIWh5mYXcZ0j/P5LMbGZYGUdSO8e/fU6RfbtmFZPAuRycZcgHkmpDQJxrAuOwdrd5hhLWMCnE6nzsnZrjHsJNKwGatyzmDyrEs2T/cypNm6oMmC+nc0PoXI+zD5GHnC2KKTpDkd2Vltn9m51pyQeB904diA6QnsXez4VTynaEc7kYaO+Of4mdFFdMyL50OccxCJvEGeAStped/TJCW+r1cE3IsxnWTfruuqpd4KTudzK+1j49Xe9et1px2N663Al9fOkv1+29NTXKcoPxzx/DGD0Jghb1z7e33s8JsD/WrMCOqYCzWezjWce/p/SpI9jtjOi5DFLgUHn7guhkMqDzf1wc4Pwsi33LnwcI2b6hiy+hlgQvK+qvsILPJBreK81+aTWLLhaqCJYBuSGbsaVpSSBMW0wSSkrGcIRF+X31WDIgsuVIcdqvINV5S6oZZNsyQBUAcaNpSJtQRzknJRhpHYPOScPesa9/uUYevX8wfLOG44QyevkmSIs2b4QHTCMTpqmIbK070W2Z87/Tp2i7VrXyvfje+6d6/Q2J0bDccJa9k0YvLShHXbcP3yDHFUsFI4hFozrtcVp1PG5TLj6f0TPv6XK3LasJUVL18+4fnL7/H0NAO84bf/65/i9unpUJPiV363fxVsVNgPgwUv+tXf/YRf/hVwPn+P+fyXACUsy4JPz5/w8uUTStlwylqasIrz8B9++gmfPj8jpUmywCfSvcgwBzRSvZsOeKHLYRoUZmVjU+octVtWv6AzjWdPG/PwniP+dpRVzdZrxKHkobrK7E4nAKGWCnBRJ28g614+nWYYuzBZTmwfebfXzIF37OeR7hHPa5uP+LPt1SaTmvOaZCKVUvaiC4p8xKBUAFrBvCBnxvXlGberUbXy80BVR7+NkkytFdt2BaHiel3w+fMXvHxZAWRMc0at1J0Fj/ZPaw+HmUd7tEd7tEd7NGvNkEYCFqgzhMj03AxCEk0DAKmBYGAG1r2zB9ALhkeGxnjdW4bCptBgL/BF40BThsBShzoAr8uyOhApXiRap9rSBNuY7ytIo2A5Nnv+KHjH++NzDKgxgC96hvfjJwdy2Dy0yfVywydT0shENfwqwIyhL/cAcf8sgVBfve61FoGsCADHv/t57ednfNZR0yl5tcm0RCBDKbp4ynrJQuEROiahc/iD4am17bsIlEbFP/4tAYZ7UMkB8SEyeQAO4/jHayPwikC3BsRu29bAWAONfe6O91psI1AFnQ22PjZgyZWaogA0w4EoarN+zBNG0DP2ZYxSOgJIR0CWSfZBU+rHfUiEPAL4FWos2Bvv3BDRO8BVLgpq/DOlAOU4V1Gpz5DSRf1+aGCggoWsiycpYKmn78DTagVyrSjVAEbPMCA0mhxY1D6gsiirXJHIo8asPxMTal0lwtv6nqib15QSTmet10ySkeZ6WwAUeV9yXq4k3/rua2yAmdWC73lHdCYbeaFda3Tf6F/Bt3itNdtfr7WvOUu+5lrro50ZNheA+Ej6eJIaugTE2LaCrRTkiuaM1z0b2AOL6MGMf67WgyZvOM1gxyq7HhMADtlo2udMndMMxntASHRCTgk5X0B0AiBAljEVmzOjMQNzerANAImRT2qVM1Im1M3nNp4B3TiGz+4Zhuy7++3//+DReC6x/GIf+He4jzG//Q7s5tPmdCwnYDJYqQa4ugGw9TGs25ghhWvdddTew8yt/Iq9x5xVtmAYHeenNxRh9+635JCex0AdCkp7f6298VHeZ8YLGgzReyOH99GMU/0ZFX92c9Xd65l4orxic9bPzZ4arE8OlLsBOo7LniU81JwkzMhdmkwT57kztFQ/J0aHn+hE/fq+3Os4R+0tXSM+y/oEqONCNb2pp/d7zxifNfbvSGc7um+Ua+27mBnD9sO2bdi2rTk3RGP8kYHiXmv0Q2iyjQVRyPLYWNodYD4qnTu8g8gNVej3EJGeUEd7rDN46RtrxcZbk8urOhgYL2gGe+wdhY7mFGFtxzmKa2bOa8wV67ah1hVF5TBxSMlq/JdMGRKH4RiAy5v7PWc8yOZxWZb2t6gHvBtH7J/Nm/HCqmO31+Tc761SnF7Moc+eafMX+d+YTcr2Zpz3y+XSnD38PSWMw0w8hK05AxnNSTaRUja08q5ksq/z62ma2jPtmlgmKs5LLBd17/j+Wj18bMc6YDRJHevf416W81Fo1Axzxlcjzx15iGAS5ixjHbnfvyN+dag3hzaeM3ZdNIjG8zOePSm7YmH8Qq5F079sbYwOiQgzncDMuN1uuN1uuo6nzj9plPe/5nw40l+6IKpvaKNjjJ/hx+91fei+TnJEhz+XNkHOX0b+cCQv6E0w3m4L52PLeq1mNlW5pAXJvdZPPzjlByRDWORlgMuK98be9IIDyTVeW4rLhiQHS+ifYBBxf3bZuHTskVTaPtRSeS7/SoBQO5+IgeSYI1fRakR12WTt2fZNUdwRmPKEPM0opeo8+5hEH9LgmzTuRXPCOTrfbayDo8I36zD3NYV7e4+6uX57b9577vj3a3vhLXnm6DonC9bzfEGiCSaHi6z+HSgxlmVTOki4nDLO5xNyOuFyFmzs3dMZ6/oFiebmxDByAw6UGzEBhiRrsRI7PQqo1ysWM00XzKeMaX6HTBcNjKhYrhWffrqBuWDNFdDz/bbc8PLlilo40Dl1/Uhv0YRBW9QoaieTHeneI8+lYc+P586YFT6eL0SSYVYnQ3pBrgtGmmOWhMtbEcc1ygRUKxd6h9eyyyo5zRj5X+RN93h1nIv4M+6T7hnKHYwOcxYsNcpKlKqUeiMpWQkSJ+oW0BCWqF8wwLmPU1S8LueEy+WijtJXrEsFc0bOJ6Am1JoOfYIf7ee1h8PMoz3aoz3aoz2aNqmFa2WMDOxIEL1cjY8tyqCCNJ123RjrKmkDT6czUpJML4AbkwDAS/jINwY+uCDmABs4CkgiZIow1vfZUxFuzYPcgD1Ww9a6Lfj80x/w/OkPWrddwK5pmlURJmSaACYtWyK5WwykG6MjLVvHKFxGxdUETBNWR0OHCJoKmGnU2baJYiNGCR3DoK8xc1ByCYkBK4Mjd0g2iTknABm1bli3gmkmVRpi+SZVG4IQLc5PPucERsqTGgddbLUMEaZ8v9Ui8HEP2IWuGh9kkzlSRAkSbcBcVcGw54driGAldjpFHKLIlEY3DKKi6cm1j0qDijUAYFRiMb6SldggzLMaURsJmHIDNPWS+4gDcz4wUKADDtEet8NyjgDCqKBVrg3AjGDYmM1lXBczrIA8O4zpK25wsM1HgEbSIjhDGKBo0U9C40mj6wywkvIlthQR4GIGyraFNPkSqUvoS67Zv3tOZY2OQMiqUpuhgCuQpqw6tBv6LN08k4A7E0mEoe1TS5Hs7/I1SbCo/H6tvhYQ/dYmxvnS9q1nWWGUIoYyBwB0/6SMTEAtBZUZBRUt8gs9/2CLUEuAZIOVaOtp8lIDknXGxhboOAkNcWVUIskqYJuBpMwB0TnQg/HwogZm6W/ZBHSvALatYFlWTDkDJBFVIMJpnoVvd3ThkdgNKWHPZgNI3zbxVnD6Y9mTy20BoM4yOToHtUX1PW7POwB07XO5Zb+/XwP3rY2AeDxDmjFfje6tjw1L1U2WgDQlnC9nnOYJHz+8x3TaQH/6Cf/q3/x7cPkP+M3//B/h+fc/eF92PTkGwo5am5ODz791FzgsbPDs+PwDS8srz4lOM3/xtz/iL/7uRz1vgMIE0EmyyOQzpvkdGAn58g7TKYHSBYQM5iTnSSUkNtBZ+V4VR0Gu4jBAgCZ/qtjWFbfbFcsi9JXzJOOqPYjNPuhmmAFGHrKfSebxGms9r/q29q03/kw+F3gQYOdMf562HpHsvBT3ZHv32N9jSrazHOjn17IiCh9xw6oEJCakHMDDKNeiB0lrVbCTnEuYLBid8KZpwuVyATO3iHSAkELpkCgfuRGddZ724xsNiZFnjAZPgJDz3ORck1FMXjC593Sa9b1VDc5iQDmdpmZAKcXlmSgvG08WR049c2z9oCnZNdOGZVlklswOnz59wjRNmkFC+rAsKwDunAoabN72DXXPMQN47FfOuWX1uV6vWNelrQvgEegpm+zEchbCnE+4yar2HuPDnVyNyJL9bLA5HdfoLUD7yHBs+k6cb6GRCnBtjiKSnYc6fiP36Hi682lvQGUTcgaZPKXUxmkGAtff1HijQRXzPON0PoNIytBcXxbVHQGijHkmTFNu69BoFuqOvJsbRiyN62UdGNtasKpOJWvvmWTceD6p8dkPT8ssJBH/+uaI7tv5n0izFab2fMvEwkVoJyXJbBCzwIm8LY48XKXsz2SyRsoaFQ2hLbheLI4Ipem5k75b5GhuDlwmVzOzytPB6K16kxlfEiVQnprTmJCFlspKJNkAi+hGtSakJKWjuK0/a/TzttO7bF9QkvOOmdRROmYCkgymlBJySppRJoETYT7NGlmeMc8TTqcZ27bh5WXBy8sVRAlPl6eW4SOnhMvlqWWiscjnbds6B4ZpEn12WZaW4SulhOv1ipxzc4ComgXqrPRqdFM0Q2atBcsqeIg5iTQHEWTNgMMatFBkOzYekXx+KGaVkf1lWTmv1xu2urY1HR0gU6J2Hoz7oj8gnYA5OA6bLB9146Nm+9EIzPocaUHk9CA/D7zM+IydZULje14yZuCJc290PEbwm3PRuL/jswG08yDea+tmZzKg+gcRkp5Jsl+vyCnreTUhq/zNZvQktHP8drsBkNJfcs7Knq7VM2vENfD5ebuNesa3NnGIUH6QZd8xo9H1TocJolXUsSO+cLRGdo2pIuNYj9aHTFEa3nO09qVEDMqek9p7DCOzObdSSilnlb8lQaqVQuLWP2r8F/BzzbKsVjbemTV7pNBxK+0MqJNAcEaBZrvAgW5k8oT2w2gxp9z6b81VZOEhiXKbX5c9TC512pbgOnlPRzskfJLBqEVVZTKMl8CUQGnCfDqBEtS5cwWznm8kZ6c5zDRMBsFhnHqsywjKZTaVBTUbTU/XrukZvmRBbVUdga1sU59xyOeUmRv+588+0qvimoyyEiFrefr7eA7r3CnttP2ha2YL3C5/e/8e4Qnh29YfLitAFSmc5Z8+f8L5fMJ8mrEWxvVaAAbmacLlcsLlacY8/1LLHc34q//0jL/51wVAxXK94fPzZ3x5+YJ1XQFKOM0X/PDDn2GanlArgUh4IdKCihs+/wPhH/77d01XHyl9mt8jTzMqn3HbgJwmMBdsGwGc8e7yhNuXZ3CtuN5ueLm+oDAwn86QTG5ajolUX9TsTIT7vNNkf5vHeZ51TdQZNeAnke6OA+b877aEQacagxbkWtvfIQsSedlz41mGWzMztpVBZcN0FhtF3y+R9dZ1heB8WuqcRR82p+iIE5mM4baIvRg9noevYZZEBGLhfzZXRFn4appAMCfpAtQCphWgG8pyw7//755w/fw32F5ypxuNb4t4QPd5K52dULcTnn8qWK4A8QlzzjjNZwAmR893x/Bo39YeDjOP9miP9miP9mjamAkcwUFEBTd6VaemEC3bJqnq2dM26x3+DAzmDFKIm6BRDfYuTb8PABSENlXaOUn2AuuXg/EBJEmikrLdByDTLMBhkciIeZ7xy1/8Csttwe12w7ZuWKrUolbdCJnE4cRan2LeBeII3KTBkxsDaEMxsrLNr0VbyD+ocbBWqYueU9I0m6YsMxhFYF12UDnOeKLgNJIy8tQwiOZwxO1/qtRbFCGyJ8rQ+UgmpHIFUNq8i8LiyrkI8F6egkyhIYGhoWtWthUg0lI3MZWt9qcDUnQOWZw22JB4RgOC7V39LMjvnY+HGQ/190QELubVLwDouu5LcNk9ruRHQd7pcRTwO+AohTXHeK0pxFHxi+Blr8wc/e6f7RW62I6M+gbAmAOQfyf3iK+KO2lZ/5LSpted7o0/sQ8tqpOr7CoyI6NGt6esIDG15zVnBhCYjw1KR6Cb0AQUBKq6L4GEBK+kwqikQJIiZhxLmKlSG9cNcEXa+WJ00Pg5LdA4emXb/o5jbQapFGjbRsu6D5rC63wxQQz98p+hbsHRw0bJYf4KFBjpeQc6hdrmPxiiCWBN/bLBWAQLu0gkfaGg/HIFcQaR0AcYWEsFq/MUKx+cJs/4UAujbhV5lnfv18DphiPdsvAsc8DqdqHxMluLyqhU0IzoSg+Nb5Lv0CNgi8jKfumhwsa/IsjbHhBmU3jbuP6HYHS4JqmBiJJep84yaUpgYgX/MzIIT5cT0p98wcvn3yPn1U6BFinmLzmKiXy7HYEgP7fJ7B0DKOMajvfFvsTrzu/P+Pin3wsIpw6VFRNqOgE0I+UTGJZtLCNhFtImlY/I9pKcnbVWKe1W1DmgbBDj5oZtW3C7PmNbvCRa2SokE5PtV+mxOfDEQTAi0Lp3ogVo+Gw8W94GZl+fwT9OuxsR3bJUDWdV+BmdU/xUVKckEtmVaORL/fPiWQcARDncQ1iWTfex94Aow/xSuLJGykpUfZMngGZ0IBByMnnYeIKA7f1e7qcgadkA4xWjwc8MlDYOmc/jdY3RjbHEjbwnCET2W5O/7PyVvhu/tTNH3qsOGGpQKIsYTcWhJTpZxHPZPjejq84LMTJzA3tH3nY+X5qBv5ba1jvKrO3MI1K/8d6IF3nm6Mhj17Xfc2qOPEQqs+nfy7I2Z2pz6q+lSEkCm9vJYUWyscdzxx4MP2PjeKMec9RIZV+/U4xj5uzRDFVgcdJAFVqEGfVjV45oMT4XQK2obY9JaU0K8rnzZd2bLA8zykp2ZorgD3MYmXQN1lpRCkPKRlhZI4ZFpLI6Hcoz1Qmj6vjTOIa4F0weEmcUSqprhChosvO4asbINsNubmS2GFrYgoazX4wEmTKmPKsxQp3MlOYTJZV1zH3bZGiVpwhAVr5IFYmqRvL7ojSHOyidURKH8speIZkBSaeojnwm2wFazq6ghCyaYJG3JRuKfSalg3I6IZ/cKCmG/iIyo+lzCW09xJmHYUYa1jNyylKqSCLDTcezuXOnJtlPWR30DD9Qx3Utl2UlDTctWyUZWiQjjvEQnVZM8yznMTMsBtr6w7AyYOJkvZVNja2ut5jjBZGXMgAOZK1Mes772sq0S4nqKU+ND8/zCTlVlE3OjClnxC0npVeyPCfpCUDC36ZpAkpF1bLDng1LbjajcdzTTUcIJ2VsUfb0cspObaY92TX+vl4/tCAl0wHFUVTXWv/jJrooX9YMkSIDlcbLRr3nyCHkSPY9+m68P/LW+K4xK1hsteE0SempShkKqzmsPGNTHSVpFMi6Gn0a7apjRnCSiViH9ynoAkMbx3rPeHt035jtcCcTKA80xxiTr1jBCD/H9vNqZ6wFkB32W+mUmb20Mfy8gvJl41eNN7f5CU4oWoqoo1aV16y/jh9C95Y44BFSkw1yshJcQCtm9Bo9BWAmYlIpOT7QysSEsyQFntfGQXHV7Raff4AV8xO+ZRlvbUyZACt8k6DjCjKvdHUIEGk6ho+hwxh0fah5dti6SMiR3KQ8i4S/WVltpoRELBghS3lr0vlMyc6hoCtbSU11mIsl3kb6lDaFvholRBndx9TvZTtH5Sz2U91p0vWRUe5itDLXOhaRze3RjnHamvlrufvJdvZHmSnQhF706j4eW5Mrg8zMEHmP64rKIqdO8wTmqqUKV9ExII6NW61Y1g3TnJF0Tzy9m3D5bkKeMk4fLjh9f8G72zPWsmCaJyQ64Xz6Djm/A2EGUUblio0/o1LGdrOsIYH2uo5/B+ZZsG0UmcZUMV8mnLYLLCtwrStq2cAQh5GUJtQwf8azcqpoqzJgI/JRtFkcOfK3jjX6M+evnldTJ1/G7F5Rx4h7zN+rq2P8tmFVHqgHSAAOWOTUlDLSlDDNs5wfbM8oqvOJc7Y4H+vYVY4lrioLWtkicRDtM2AZphf/diczH7f33aUCBsjK2uduXrPqsJJ5GpjyjK1uWJcr1vJ7rNdnfPndr1Fennrdp8kdTi/c/WX7qO1UVM6o5R1etoSySrnkpIHGzBtygvKfR/tjtIfDzKM92qM92qM9mjUVvEagPgpNEWTeasF6W/B0PrVrG7DvcqHoHwbqkDkdaP3bbKifgm3YCznNmGRgKUUQZFAEU1BATcQKji4CaCacTxeUrYL51jJyWH+TKqwm5MYU+hb9cQTGNECgKTE+BdZ2Bn6SLCfymdxTu0ifCZMpaxSESDVeOLjqb0vJ+0ApYW5e5h7BIfo5tykysN0FZ++7ARiiWB+BUybg6lUBGTCFwQnA0sNCQVGdzwarmdHG+mH0khqAzehTXgLc2WqcHlizgmg/7F/rJ3eKg0XmpjQosGRgtYA7FeQghuNnSMHhYgTw2/sbIIUOJLO/o/GiAUF32j3Q8Mh4H41Ge4cMblll+vvseSHNpgJe3AGgroTGshUjSGkOM0Qk0XlbiO6YBRyu5LyjmaSJ1LDCg+J3PA+AwxFWjsz6PqbjjvvVo0OFFuS7RsQB6PAxtTXjyCd/fhvB3fFvfTMsRSt2e8Gvic+wPUVk8filjSTpvJTioJLMHYNJalMbLbZtnX2wqwAAIABJREFU3J4dscYAZianI9fDGVQJ3PaqGU7VAAVutZGlfI3UZgaAeRZl2DLcbLVg2yp41oxQjVb9fVWfxepsBwXLLLtUp5Azg1JFnpwXGKCXUkJVfoWqEd2ghn0kckfPRldAc9RqRiyK/fKoOyBSVVjBAwBoNKzG89jnUwHqnJrDDBJAGuUKTpjyGXW64Kdla4bJHYuE8rE/ktPM+Pe3NB76RcNPax9/ecPHX66ofAJjauCyZZYxQ/v7X34Apo8Qw6YZSv1f1dTJcrQktAPGnkMG80DuqZaly/5JqZtSVtyuL3h5/oK6FViya3HeNYccNwPs93E/Cw5qhZEze/92M3MfiP0WkPaP1Y7GFkSheKX/oHhss/8RDtCRL41ztH+vO7OwZhy0SDwHAXVvQXmhyiMmJzO8FFIzdJOclyZr9vt8XxZoPJcZaAaoKFMDbly4Zxx8y4i4NxA6KGpGbDewmWyEBsyKIaNqpK3KcnVD5YKUTgfvjDKyjdnPIxVqPaOGls/zEke57SubNzNA9mOlJocJ33V5RcpMeXSnRPy7A7ytT85e6i+a5UxukUjUGtZU5VSo3J9S+y6WIRnXwn6WYZ8frV9s4UmB0G2POHgv3AiqX7kcbaUebJZMFrj3LtK+Op2jZT8Bou4lixq75OOiphNFo1lVg1hZV4Bt7sR5LZEECnDVjJHtSbLGTXa2tABxXnBE85YVzIyI5gTjEb0VUh6G3fziMn1bGwCwTDRQ2ZeQ1Rkj5wleflLkkaTjF5aljsIAiLJ4y2STk0vba8n2W6cbmEzhe9LPAdaaCL4nmrzB5vhSXdYzp/hkmRfsmoRSVljGHYCxbUWcUhrfMnkvypMmU8v8EMz4JPNgjjOVe37smUxtv04q26vhCgg6iczbsq5YlgXMjGkSWix1w3yaZY5KRVbeW0v1++GR2ins00l5ybatrYSs8Y1pskj9fu86vybN1hj2HgNmnLfsmOaEU1MF0QaqEuUejcLMzldG+p2mCSnLnkDjEdFAd79Uzv7sV+fEoKP6WaR0BXcZ6z5nX3vTBaKOCA6ZScO9RqV+b9PqDnvsuIefHeMa7DAUoDtX7bvx7/G7mP13PJOdFlxGc8euaNzfgOoZgcpm+srsz7eMg1Heb905jvgf21tn+9H1cUzW33YWtrNBM2nR0Ie2vmT+ATA5IT7/SBf3zzj8H+6Aav41jZ8orZDx93h/MKaG/TG+n8FtDzd5iStqYUwT6d6x+0LGWz1GGrbR7cFxbP4L2WFmkoJlRmHXk6PDrTyy7uie9Tzn6nzEnEfBlpdC+Qqxip/Ga3yeGg4BHdcdTcvoGhhkEn0eq1OzO5YEJycGQBkpT2BINmaqkJK1Sb437DI15xuoI05tgX+sToVNngYar7WSeHGdo5O3Bd7ZfU5hA73rKGABDjb33fRHXhWcPZgBqjDCF7rpac9Ahl4zZnXajnQbnSXQCD08olubt7CfPUanDyGAYdlt5H2nNAFcW7beaZ6R8oTKtWVloxthnk7imKmAxvk8Y5pmzPN7pPwelRaczhPKRqjlAsYTgBm1amYiSduM04cNv/z7BbWu2NZFzt08gzGjMjCdZ3CdUFFQqYjclStO54zTmrHdroDSFYOR8wTKE1oQpjMC+Vm59Tkqf3429k6YAIIuYOsv/MAyCYtTitCD8wRfKHtc5Bf2ziPdTvaC0E9HfMzh/I1nU9JszvIvTakFC4Ck/HuCZVSzrOIFlU2e4I7HWL9GJx+T4V22dUm70VT4LeL7AFrpWgseEKd0Wwe5OuUMLhVfflfx+beEsk7grdNkfNz6b+RcDGB6t+K7P3lBzhOutxW1Es4fKogvWFcG19QwOGIGsBmKg0f747SHw8yjPdqjPdqjPdrQmiCFXvCz5mCqRn2mBAplQFr2ERM0TdBtApW+B1BFU/FMeF3LXpFob4Wb9gA3FAawkPweAzq2bQ2AhaTN/fTpkysNRDidTp3QS/C0tVGRHoXwqNAdgRRHQEz8XvTQ/vOYIjKCHGFG0MDSMOag44LVwYBIo5eTOssA6FKBkoNXphz0SltQfO166oXee+BNHPMR4DW2CDgcPWc0OvjPpqP2z7rTH7mvSgTsQfmi1AwDTkOiY6hyxQnc6BEONuwiRZzwmQtcvbdoRA6AZE/HUaHZzRH2gKDPhz1zv0fuzvkb4GW8llQxkb1rgHQAxQLd7voe/n+0pi0LDfbrN5aiuacQd+9jWLDFrh8c+oow91FdZOboh4VIYs0ZY/he6OF1MLPXSfcg+Z4W+s/Hv4/2xn7uIz3oPQbWsZhzPLV4an2jYU8dg6RxYHuaGUGg8ady22Ygs+jjlnGrjU1oVRx8BISodcVIAjYfoyNRSpK+Wva8OVLFfVNbVFy1s0AjZq2cBSKyzMZPHVAY1yIuWaT5e+vkF/s9R3QQ51SM+qzGPQGiBPARgH/KE6Y8Y55nWFlDUrepqjm+jQsohOTr1QCYN2j6Thvv/PlPAuz8v7/jgT/79Rf8x//FZxT+iIIPEj/K6pRr64fcnGC4AWJooJT3NP6UJjQB4X0w2gnlCeomzjIswN+6LLjdrripoc9lKoSoqZ52XjeG3Pm+0VPfZ99/+335/0X7ue99i9e/de8REH0ERh/28ecT7H1+HPjivf4c9e2eTBD5cnTUiWfx0fiOzv94Fo+ym5S/HGipO9OP5yDy5F7ulSfEuWgGCfZsOfa5l6VyB/genE6799pzpYzUCSmlFnlJJMZxA+njmREdX6wE1DiPiWtzCjlasyMaM5nxNWPI7llqsLpHIYe0G+SLqEf05/URPdjvqUVpuqO105qfm+5Q6xn35Mwc5wwgrKuUr1rXDYxJ+6PzDnKBvtG68y+fs/u0Fuey0YDJO66ImvbkU9VJeKaPjOdBv9/MGducZTxS+b4B/4huLTuMlMm00mU+pv5sENmILXK+6S7+/COZPpackfPJM8LIfQjr6PupVstk6uXgxrm29TZnkXbGsTiX3edZmqVS5SrLNFOZW2m6ZDqGOqE6XaDbo6bj29xG53jrbyzBZM50NqLRaaWVZVOeEvUTRs+b4nyMukn7G/7ece97ya1BtwWLHJdSo9h4q5/3vuZ7FhI/iNeN+ETADw7OrSP5tZVWAndZde6dV0dn8Wvt3hk9fvemPK3jamXByXRAmRLRezyzo2RG0syB6oBwPs1aLk4cwGoRPpZIdJO4Z47H7E6K3vWoYx33/XV58PU2ygbiwKVZO3TM3PplvFB5q60hyfkTz+HxHDw662TCja/9ceTNUfeP9DXKKl0J9OGakQbHOYo8+p4++xodj898bQ3HM6vNJ9DOAcPvLBsQQwNfugxRQMMAQbtnH/Wz67NlQ+v4S2/U78ckTq0AacaLerAnraSUZ5KJdO4O53ssFwg81vbUKzJSNwnQs6xxze61ruzCA8DawAmqBzpmh5YRTR5se4TBbQ7aPLWMQC7H9kzZXv51+/qI5430dETPXYnYwUmqZfZRJ/ltK1jXFTkvsDUTJxpoRibCsq6Y8kX4nWZUrQBSFmebp18Qfv1fV5Ryw/X5CxITzvN3yPQOZQUoFRQWWq68gZmQMiNngFCxbgtKtZJfcrZU7TPv9FrYxLZxHdGNl2fs93bOzotjMOA9x9V+ro8+6/nj/UbhX+g3RRwe4oCi/xSmg7FsOcc0cLRU1KLZ82tFyrNiaHs+PcolkR6G0fh3Rsq6T1wHMIcZkVlFHt2UX6XGl2ot+PKbE37/b/8kPN0lcfvEtQP/nCEYyfn7Bb/+r36Hy+U9fvzdM7Y1IeczyjqhlrXNp8ixEvzy1ho+2re1h8PMoz3aoz3aoz2aNgOnDGCMdbkBiXYy0AmQKJrTPGPOSaKtYnkiNcxG4SsCflIWpMKie7mpLceG8BbRSSYYmfIKRJDWgVV/twB2Hp1rEQzbtqHWimmacLlcQEQNSC9b6ZRjA8335XqOo2yOfh+dASIoFj8f05NalFoHUth80QA+ErBtRRVsUbgrr7B0l9zeG+5BrEG9p4uWPpsstakCuzSmTw2rwCLMj3MQgQ77u5QSQEQBXeP1Rz9tngysp+QKUKTBOPduDHEjcSZAUkt6BHbMYhKNDVwZSAlEM4DeAEEaXXlPB6ZkyreDIWag2ZTWDMgiSJmQWl8HqfbrZJFPxwq2KYT7e6kBuiOo3ynd4f2JUtDg2st8XgcnsgI00JvYgegYlX273To6v7cOEVw54hU+Kl+OqJCBKEQOEzgozG3fWYYZWEJf22+qjIEbuAoDZvTzpmRqB3alqlkjKQigg/JV98YU5yKmwY5zNabHbvNU49oRCjNg0TTV+G6cK41oSw4kWYaq+FzAaonTbg6tb+NYRlBN8CmlP1jpJwKRRDfLbGUASVLXgkDIyIlQyhdIiaXAw4yjtoxcLNkDjD+goNSC0zS36GjZywUMifZOZNHYwJQlq5S4pEhqarHncVvPDizRNZS1yLsI4DgfR/WzbRXugdLRcBMjopk31LIBqKgoYE2nLZkBJuQ8Y5onUNo0TfMNHz5+xH84zcOb27AOgYxvbeO93/Ks2Af5nRu8QsP3AMA1o65nVHpCSe/BLKVi5NpYGiYp8Jn0PKhgEhoAhRBYqIwxZKWSTEi67hOj1AXLem2ZEWotWJYrri/PeHl5wXK9SrYkK5lWGbCMP+jlo9eBnqPvA9gLHNCMyz5/LMPFz2n33r3jj+P3YU463vLK9fcMG6/NcTxv3gY+325Hxr4IZMfP4ruOykS8RRvxOVHObOdVuHeUoaIMeTqd2v1WWiIa/8VwwZ0sfLvd8PLyoteZY4nI6xG4NmcXAK3UnukDpRTkKZy/RbIx5ZxbaRQbQ9aMieu64unpSZ0v1vZdzMRjv59OJ8zz3CL/p2nqjOHrukh6+W3bOazH/pveUEqRzzSqMb4ryjT3DBvx4yP5bk8A7X+7dT8qGyPv9xfF68a+jH0AgEy+vnFNbG726e1dFzjK0mH33W43rOuqOhhwfvqgGYb0+VyQsjmoG504oK4i5gC4H49pdBYXOSXceaCXjHNrEoXPEWCcx0oG2Z6zcz6W9Yk6nT0jniM2L+KMW8G1oIZ3xLmNf3vHqTkmTbM7k4ne2OtmRvem41rWmDjeo+h+nxcbz8g/MnI2Wa7f9+tWkCZJly+P0NIoyUoNi86zrgWZgSllTBq80hx5apH1rhssm1JKUvpurYyybk3uAqHxC1uXaDi3fp1OkhHrer2Cuf4/7L3rjy05kh/2CzIzq+re7une8Xq1WhkW/JABCTYEwx8M///wNz9gARb8lgQZ2tVqZnqm+96qczJJhj9EBBlk8pyqbox3Zfmwu+55ZTL5DEb84iUpJ0LA6+trVbIdx6FKxFjpoNW1LkudE7/fZ9FnZ+eA3zt3zxk2wyxUedvquFe/f/6sjPfa2ib0MsgoZ41GCLWeUrp1GgaZysbe6jLcxf8+0qNZ28c23OeVWilckJU2McTUrFTDEChXKQNARKAYkYudBwkhAL/69jOWJUj0y3Sg5Cye9gQIHiDR1pbYeP7ZGWBj7SOp3FsDH+3jeI+dh3Ym5pxlzy2rXSTqRTpjBkzjMyVSgsem+v70Ml+76+w4Nl7z0TIzhvVr2Axh/WevMLdnjmkq/Rof6/R7yV5HIzxf/+06izfd6Prh6+7pLWv6O5GBmTOSnsHMXu5Hl+qMC93ty70yOwN923ykinXdgFJAnCGRyRrN9utEMC5xRlnXCAoB+37AIv7ZtcbDEUkULmbG9XqVdbxEidgaAkCxw6pEfjeEyRpeB1gcExos036qkbjlTOPuMGSNVsEdjtDOfptLJ1uAQDdUy35cx3Vyi86NvPxIi8fr/Hzbd/W5yjel43DrzHg4AvOhdbQoP8uyYnsKWCKQjoTf/fa3+NWvVrw8Pwnvs0REBOTC4KTjRwELBXz37Wcc+wWcCdvTJ+xIuFyvCCUhhIKcvyIgYgsLCAk57bi8viKyGShq+0RT0NZwHUuqQz+u9e6c1vVlZ5PxPcKntoh2I580k5nadWd64efJ1nPdy8RgTmg5NGtPkHNR453g/oS3IQJQ1ChGDZSICFhXYFnBuYjexV4LY4m9HGmRanwZ6cFs/dV+VwNpb9BDkupUecGiDkLCkxVQiCCIATCUV8/dPmFbkvVbnfGGi7uoxiEseNp+hTV+xsvzE8om+M1bvqKUhBhXCHup6bQoVOz8Uf445WEw8yiP8iiP8iiPosWYPGM0YoxitUzmZa+eW16w4KIhtptiXZhLCxXcQs4K2KnAIBTYK83DhgyxIWOqnBGEKk0N0AEMeGleAK1ZTcCxZ3tlSCkF+753yvevX79i2zZsm6aXAgGlIGcBQoQxlmdKmOpRSB5Vd7fLDCTzY24hmz0A34dR9QyvMetzRZoZ0QDNm9cEDlb0WUJ59sB7Y5gLakBvixw0gavrmDn1pmewrc57gqJcc2bgR1BiHEN2ypexXg9A9GAmmkBshkTQlVksjxNq/RJxgjWNmOkhfP96Dw4baysSZb3A1nQLjd0MZQJF2H55j9m//bsK/8OYeQCjA7uc+ppdXywE7ej504G9shmrEVat2/a7Hw83GhQCorbFAC4T7jwYZevf7wP7/C7QbM8y2tKNkIHQsmaZzPtT6QP61e0FPGCydmd7+cb8dN8SdUpEX/fMKGLcO6NAb9fO9lbhAhQFxUPfO6GHAnpZ24VmLihooeCJ1HCoeE/8ooooqLHZAg9sSjdbu2eAa9EzJQD1bGEWoEA8ggET2A3QYZZ1FLDVgRUhuVTvKEtHIFFUGnBkec2vl4IW9BpgDjj2VFN6BAUwSgnICnhWw0v9x8DvcNr/fcj3EdC6VToAr55fjXbaq/WvKKjPXBBiQVwacGU5pQMFbNuTAucZb9ef8MNfXvGX//TvoPD3eHt9nrblvLt6Zdn713/0zvv3+eIolf5eVR16QwDCgqLpmIqBVNx4Csmg7mifnYewGEdzgwWLIgAzUFElqXnF5SwKPQLX6DL7vrfITVAPfaWZcHv3Y+DOx0bQeJ6x/b9ESfFvQ5kpJ94bih7g7M/Le4pE/317XxnUd+eqVxahm2f73dPyGT/U1cHns/zec2/xVeP9Nj62po0+jQbQ52g1BSnviDHi6ekJALCtG7ZVIoe0KA/Cyxhwn6uixz/XvCg16gK8EY2eWbmlqOrnBBoZRn5b1/XEZ3ZGlEqDf/zxx9oWQPjty+UiNDyG6gxgfbd7zcjD6l3XFaUUHLm0+eVGn6xv8EuVuZIOcO74epufj4K8owLGj483DhdjUkKMa5OllJc1Q7q2LsiaiBJcFMRqYCKR5yqfz+rlakNAEcu2VJmDGTiShY2XdEupsHgZLyue1q1GEZHxB7gQSjlQSq48o5yDpRopFgbUQuNE6GZKy1Zsb3CjIV6UdZ/rmKpcQ4TTurW1YAYV9kzjWWb7bjZHshYZko7gQEpH14Zm+DLyfAVMkj6QuCltLCVH49Xbvfu+V6Mli7iWUzFpG+uyKZ8nst9+leisISxiBE8iO1skTmY10mbbdxLJb1nWOp69DCIGM8EZ1K3rim0To9513UAhoqSEGAmLGSRxxr6rMX4kVQQJP5OOAyDUFEuA7Ot933G5XLCua5UzjHciIuz7jpQSQqDKR3kDwRBCjTxr9zUeDjA+QaKLFJSC2i6Tr4Vf1QhMIOwlIxSjMWK0kbgARXdZjRJki0XkE1FcMSQdSy9j36cZBrzABDblpIUPsgg78YQx9DzD6LBjND2lBAoSFcgb0/m17s8Pzxf7MuvDR8/p8Sy9VydDle/UZMnGBmrbicTAJovByfPzJ8QYkNKB4xDDBajTTc4HkjMEAjf6Wk8DXQddyrZKury8PjfiuFVGmjL73WiMnV2fPn8WTMvTEbl4ymtbEwmScmMc486Y1s2XyYo2HveMNc8Nt0b1ZTQ+Gmm9X39+vc3Wpe/HiDOMv894tVttmM2JP4s9jzLWM/IrLbVSWx/eKEVbL/9yAalTTCBJg2ei7S3+rytEIE0RS37wWc6+nAoyEizVXAwriqNjsr5jnQdzgjMjTTvzUsoAWepzxmi8ZG3b9x1EVHnMnLOkFkIGxdylEGcms6PEKDGytY+Gn4wPI91/yrBUjp/NiBV6trk6jR0iw/KcoUoYH2Rtkr8+NQ/Bn9Wed53RtHGdjWt6NNroMao2LyBv/CTOJMuyAaDK5y5LwvPzM+LyjNe/Dvjn/0PGcXyDT//1CnoRIw1QFINXsKwTRIDF2Y8DYwlPYApIx4JAKz69PIGo4KffXPF//XdXhAD8/f8y4+X7BS9Pn3Hdrihpx7pkpGzjGRCj0TGbL7jzi09994aYNgZ2VrXIctyNlRWPMY7javwNK/jjx3c8H7u9DXHMITfv/tn2TIlQa4aXCXQoHq3jsG0bFuXjj0Mi1lq0ZHCj84ble0Nee94t2ZCNWLDx211LXU9sXCM4a6pvilhiAQVZy0VT3ZUMhPCEP/9HT/jT/yjhcvkROb2ilB3gHW+/2/DX//TP9Lnk8wsAAP7iH/8rrN+9guITjvwtLpcdr2+p7vevrxe8XQ/BAbWJhQLWZZUIPbF3BHuUX14eBjOP8iiP8iiP8ihaYghYYqwWzQEEphYKGNx8u52s7xTtBhK0MMyeyazKUmj0DEOTDYysgiB3QKU8muqz3D9Dae1i1ns6hWhvgT8aohiIKWBQUmRWa1bhKOfSAWphBLjcc/y9/tWuqe9dX0aAyT6bt29tq8tTPCpiR2DLnlLtQOrktTn0bWpNU6MCA4IGsGR8lgHpAnBaqNLbgINn4L1yagRlRoBhBEWYSbwcynkcxzZ27YCBPeylYLCmoSqlec4RiZek5TT39dhY9vPe1q6t+Ram0trkcjNTE6pbO0/D3fVpXrgbwxlYP94vRhCKsRTxeAB6D91xLK1PguMU3SvNS8/GlBnVIIXc/SH0RgCzPnnAaVRK+Ha08ZqsT02+Uo1kuvZB21xxk56q+H3ELrqNjXLbTF2bCbJXbkGC9X57xuSasV/Tvk3mtYaZH+lPXQ+1azJb1Aw6YGYEGlGq0l7NjQ0WrysDW71yUwgLAFJDj9LTMGujBx9c42W8iCotFDpshphwRMkARHsf6/OYGaxRaLhIup1SxOMOer5IMwO4ZOSEuhbtkOJiHjISaj4nWbtZ100IXNN82cwxM7KLVtAbLfXKsdn5M46TDon+te/s3PHpQerzNGKbpTi0fhIiLDoPUQCXHdfrK778eMWXH34NpvUd2wOh/0Ruzf4Ryg1M/FQaNZ39QvXfdmQRKAQoZqOesnS6T6AoowVKV+pB6MJv13rtHBX4S8i5zOV1v+JIVzBnVB8pTcnUDF91zSroR0CvtDidg7MiozaeO1bnbKTePy/+7S8zfuHedb7MzpR7Yz273tPPUZk4vo71kHvmLTr+0b5Yve/N6SxCza1neGNr3zdvUGLGedXzEj3In4ukd/Hnes4JzYP+3CaL3tXoY66grT3LlPAzvs9oqqeBZ5635x1TStVQ3r7f912j28QaKWY2tlOwWQ4EOTfg5rpwVRbalfXVzt8hEoV/zs35UsFmxhvYXJ54XjWY6Q2mi54R8fwM6wujZRawc652iJsRPYSSMsTolYJzTOCMXMzQVCM6EIGUl4vLgqDRz0IkEC3gUpAS1dR2XHLlpdr5CRCHOuaz/fdeEQUmGs/nGUA/vnUs9bWmXordmmY2FkLaODpVAOh4AF9I+R6rw0d2bPPZy5iAGZKRGLI43sqfXXb+WBuO46h7wNKTmfEDtx7LvyE2JVOICLFFebXUSdb5wrY/e96EQgDFUA2jmjGqjCND1kwgSR1pUQTEYFmU9IyCdBzYr1cEIsQQEQkAFywxIu27KJqQkTUiy7ZtVUH4/Pzc8V4W3QSw1DvNAMTzcLauRoW7GHI3T325ht19PhWUo/n6kkppCj/dbwznYGRylKPHVbbt2ea6fmbFy6J2cy9tqAHHUN+9Ouf1oxsLG4fx3PN/Y+Sy2bk6tmM8C95ra8dPEzTKpNFF5a9tdEiuYbQ10taqzNBxmCGbRuQsuRqr2xkg9zTnpFtMc/0dfV9n/f0lvJvtUYvExsxY1rV/jg1A/a4+ePjNxqBda+0bHTS6c5J7uuj75DG0Wdtv8Wh3z0fmTnE9kz3HdTqjyZ7P+GiZyeK+ruLOQc+TjJ+HHsEMKvy1PmJp335dT9TPq77D2J3622nfT6StOn5mPBjBKieJoY1FvhJnK6GnRR1ojM8QeZ6CGYr0fbAyGnsQCfbGALKlvHXROIjiDYGSKsvVre+TbEd1oRKz4loEHzXa6POI8bHiEJXng18HftxH+ayX5fzeH2nlbH2Or/7Pz1mlH0UMnnLh0/haNA4zzLUxFR6bcVyAL79hAAtyknRKhRkBC8Cs49LIhmAOhiORGk4Y1p6QrozXH6Sdl68Jn/9kxfP2CQE/giGRB6F8EBMBXfAgbmwaet7vFs3wNLAZ1t+mubPSj78tl97AydPF8Tt1B1MZQXksIsRIdfyIAARWvC2DOHR7nXNGAmTvqKGrGJJpSiZmlFAwRmgfHQ59G9uYeTdB1vVPFeeUfhivIOuDSB2YoWky3bVchBckAsIzY31hrPkJnAHOC4CIwBat2eQLtzuYsHz+ipdfv4JLwH5kXN8yUhJ/1qRRRTMXRJYI0EIbF4kCHwigj8nBj/J+eRjMPMqjPMqjPMqjaAkUsISIzGhe0eQUqiaE2Q0KLgYHFHolqikMIZchxlCZ6EQCcAUTahS4ySXXdC9Nua3CAVtuTA+WWH71xuz1gj5Vgd0LHmOkA4tuYWBiKQWRXMqfKkgaA0oQPtTCX96OGvOekscAnBngb9d4QKL3Dq0jPAGR5u2xcZJnS2hsATfUg63WoQwwQ0E8Be1tnN2zDIAWgQDdb7MygtzvCS0jeNQDbVQF9Vv3jffYWu2jIFk9zVbKmf2gglucOyDCxpK7dXdrzmUJE03lAAAgAElEQVQ9WihU1EvtszcSu71ufH9qX9/5ffq9AxpugZbz+3XheWANbW4kkkL73aK52Do3cMsAaQ9Mj3Nm4N9HQNLx+6Br2/YpoVdI+MLMndGG0T8bpnpNP9EnMEMed1vwruOMfsz9NTMA5PT8G/XXdnT7pV4BcAHDvJYLQGJokXOq0X8kjGxGWITmtihOWocaCwiw4Y0H2V13u+9+vOq+RLuvlIzCCrCRKGUXTmi5xC0UrPfm9eCEhm1GM1ajuufE3wfRQjvXGrEsz+LV7MAx2aulbtEKtvgjZ6AxcOdNA6RKV+c4HrN5Hed/BGaq9xCaUhEyLeIVHjeJYIWAZYnIfOC6f8H1OKqi5mOFqirn59x1v8aP19RDkXYfN1BHv89ccOQsMWRCAdmaIv+0kXaIl7HDmftrSNZL2y8EsBjVpnTgcrngSAl2Wpi3+pF28QQrpQttbOhYRwveofWuMefRaEzAO/f8f6/cBDDBpy7NznorI38xo63vlRHUfq+wIsizNk3PnnfO3dl9szaO13sDEX/NbIw8fzxvY6ur0TeLMhZqtIbi1nvlI6nfwW2+nNKHzu2z12pIg17BPdJEK9440773RofW9nWVFJtjSiFPs30kOD+mLbKYzbemXiiMbOKLyTDu3xl4fXfuSUOW3zg3RjrSopt5Yz3lbJhcW4bndXytA7IHeQyOLzZ+0BTSRpuLkilC83YVOVDB9BCxbhu2dcWyRIkwkwsuF8Z+FKQiqROJTfmi41Cfcd6Tt9Z5P6zSMLbxQONdx2K8XOPHJAVRXSOloFBRu6mz4uoWPbLvWkon1shwllozqREaXD3NiNm+K6WAkJUdP+8vWacAUehSElgUmBAIKeXKozC3fWOGcstiaTOEx5IQ+OLFDQYoigLK+iP8tbQ3hgAKixqIhfoM8QCOOpbiqW7GMkSkBjYAc8Fx7Hj9+hU5HYjbVtMVlJzFoMqiCKryVsazVG/5T58+dbKFj3YVY6zp4e4pz/y8mnG2jyAINONCoEU79HJiIACLGR06+kc9PSC37+TNWZY/c0Tvl17+hdJr62uTpWflFm86/o1j5qPW+uLlrxGLGc/nWb3v9a9ru/yIqEZsxifb2INMNoBzBrC9ZhEcxci+8f7G/yXjvKHETtJCwIzz52dtG2sv5877eutc8P2dvbczEpAIbMuyIKeMEFdUk3Bq7SbDt5SPrU8kQFKoT2TdG/NS6R5u8yAjv9bLq+e5P+M3/fUWWcL/futZRiNmcrat29m422/js708N6P55BkBV9dszbbvWl8topn/zTAN3xZAUw/W0ZfXccuc+2Y46fycMpy1pTqRPRNYZaHEMJ278YG1LTWyTkA0HiG09jFzjexnhhWez7P+xRjEgdPxjbWPLPWSw0HbCgQC9X1VDqDHamxP1lcz8LR7g/IePMw1KV+C0zj7MfSPqnPieOPZOrTxsdd7vPu49kejReH/PJ1V0ZGN9wWIypCSCNg+RfzZf/KMUjKW5wLmAyBJQ5ySRJiMIVa/OaKgKaxJeRo1AkEBkMTAQsvb6yuO6ycEbOAM5JSRcgJIooBZew19aPzamX5a8XswhIDr9VojHvXr/syr3ZQ3J/vw1nyc65QxoYkBh79PDGfMiar1s0UtYo34zkjKDx6HpAwUgzwC5yyGxqHVf2vNNINV1jnp8RGGX4/G+9o5ZSm9bH6BUg6IYxEBJWCJnyDpkTK4EGL4BMITEDICHbispT7Nt8zep5SRcpE+pyvSEcAsKcBSypoGym4gQFOkBpJ9OhvvR/ll5WEw8yiP8iiP8iiPokU8ugSUXdSinyDhaSsz7nNDqoAQKCgQl6qVujCJPZApBjPKFHJAoKUyg8a2iXK9NyYwBk24ezIUE/WCKsCUmvNenmuC4VnIngkcPvR7jBFrtLzlDbCMURjA5pnbQHnLRerLLMxrB3ZXhvg2EHT+jQD4sLMNmGnXuw8MFVasre13ubeB4qNQz85QygTS+gWPgqP2yMb7hjAzE/Lr2JR+fKyY4DymFmrzeU5HY+8NLPWCoI2DzK0oQRXaa9GPgOodY+ATgUFkHhTtekDWLVlfSB/gxqP1tRmOVb2fCfwT0GlWpgA8Ghjox/hePa0+wATIGdDk/8xgjJlb+12R7+fGEbZ3rS4DRswLZMy3a/M2E/x8+0ZaY9+NUXLI75SKdTh4iXXVkgMoSK6gICl+WK8hU9hb/e+OsnWqXcxFvEzH8evTh93yQDuXaQQX+QUt+ksB46g0TbrISCUh8AICYKmQQwggJhTuo/s0QFkE/RhDra8BBGdQwYA++0x65kB91g18LpzAnCAhqAEgI5cdRLHCuaUApRBCDKAQxeuGTXEba9saMNI8RlvYfEvZJCkjlk3CuVZwOKiBFYp47tmfPwuJunVbSqkGp/LXn4eyBKhea2PRv4aanmq2120f1vtr/nqj5QuW5Qnb9ox1edJ0Bysub1dc95+Q8vtrSWdzPBLQf/HhVT8tVtN7tdw6Gcf7UinYc5ZQwQyAuK6p7q6xQobSfJ9n3CDX3oiRmVFywvXyhn2/4sipRlTLzEhpx+V6xeVykdDikP1VWzGcjx0/MJyLj3K7jDTR0/lbHsJeGeLPuvG1vwmww2J2Bt1qFzveb5aSYHY235v/2bVjv0Zlza0zw9OZ2TiM6QGyevRZJJgQqHptMks6FHtUTb2Cnt77+rkqqZvBpSkrK3jvAG1TcBkfNouSMVOWjZ/H+V8WoYv7fsV+3Su/EUKoSnUzqrH6Pd0NZEpY9toQ4QwYGup/GHtI+qdRHrnHqxGoRnscU1T5e8YIGaVYCsM+/VK7hbrr9SKAQq9MoiCRTIbnSn0RwRnLGF9ofK7xUCilKhzMuOD5+RnbtqpsWJDTAb4UTX+yIx+HRBSJ6hkcRQ7MpbV9LGNqGTm/GZzNi/bj9LWUog4hEllS1mqTZXMpsDSNTaHQ9s3Mu7eOvFuL0LS4FMxDX8+MylN5ObJrIXJW5Uc4H2rS1maYbqlZ1nWFpdBgY3jRXuW5vXGMtWGJa02JwTAlJ7v+BN3brEYwEebta7wu1TlVxQtFSKQCL/+IscLl7YLL5Q2rGvC08ZV1wjVlVVADnwW7pkMcDTNsTvd9l74sC1Cg0RDMWCmf+LI2JjYHoRs/IjFIttRExod2WEQQhXExgx0dbTMS4tKSEtRn1fubkt7mxvMk75X+THFKb53HFjmXh/XVnjFiJ3UuJoqp8Qwez2n/2SvFz22FG8P7+3Ym89Y6XYS0PjVgTyus1DOM7awSoa1iP5xRcpbUGSB0qWSLhETwESQ973A+a+dzOcq8430jtuTHx4y2mRnbtun5FXAcqRl52r/+GYVRDRGqkUETWG/vh9nccc/vujkZr/fGK0aDxmfN/myufOS52Xlv34/OaHb/zynj9ePY+3ZY24mAuMTOKHeW/sXXIfdCxyO6SB4e82hR/Xzp5Wyr43apuBXO0V3kvBb+ruGhACEK3eeAQja+UlsMsY5DKt6wOSie3Kd/vzWftoZjDDXy2LmvRdsThrmgKurx0H+G8GaW5hHsMZ02Jq0ehjjdNF61ZMVUFcMQWniey7623jjaolXN+L9bvN2Iddm1s3u67xyt7tac4iultNRpxivkDHz6fsN/+t8sONIO0AEKGSgJb5cvOI4rvv3mWzxtzxpRhEC0oRRCZjEupgUAZzAlECVQTPXsu1xf8fZasAYxar1eL2rUZ0bEN4bTj+xAS3z/fXQZH01Pzu8zXjwrPc3p2Pz63BnNMXrDLOnNZ7hJv9dsTlXmSgcASSEovHeEpKFSY2FI1LOSLXpVQC4JMfYpou45Fci6kHVoWCCqCYvKJXA4nRp0SzRJIMQCipJG6uvb73EcbxC+ccO3nyMCSeq2nFWGQlS+cEWMBwIO/zQ3OgzmiP0qcibKFYRNeL6sERGpgIKOqvKQIQpfGyiAHmYef7TyGMlHeZRHeZRHeRQrBniDBOSCMaEuNy1yB3C0CC96r/O+MODZCwNFkEDEZUVcn3B1IdJDCLC0k42pE7BVwGIRaKpFsTbaG+mMAoMxoa0vcIxsExAul4vmq34GEeHYd5Qi4ZxDCNj3vYbk9d6m7TkCenpGsw4rWxjT5RTZonBBTlm7SZM6vdAa9VUNPcxQYyYMO6aemVEyV2HJz4cJ1iJPna3tS2EEboy8KKDnEToao90/e/Z5fPVgyQww8yDEGMo5ONeOGRgzCjReIN+PA8l5G4Ka4ZQXOMz7UR5a6tjU3zUKhY1TP4YmnIYKNEuuXz7V0/p8mtGuzEAWafRJP9P/PAEdPUjly2zu2nMVXNO1AWqr0BQmqj2RMdHP+hUA1DzV45qbrfvxt1n7fH/sukjq6cLOWIY1uGg4r5OiYHLiDFJjqCpYG7gYtBPab4dyt25PW4YGIDo8cgRKAFQjr/HvvUK6fg2YA8wzn0DQtEtBWhhcnXIPUMoOVoODNS7Y9ytCXDrvHE83/VzYeSCpf1p7rHhw2oO+qWQsUeiaXMIAZVAQBdu2LVjXTdJnlCKCsYZ1XpaoHuuibJF+JOyW41mnSZQZzSvawD8iYIkGKsSqXCy5IJv38sE4cgIF8VINMdbgtKwISi59X2cAhZ2HIZzBmhPdIqppTm6BHf5spSDGMlmN2WJYsK5PWJYnTX0hsOF1/4qUXwFaJKUQemBwMImEzga8d9c9peP7qpt5OUNJ899mn/09FDbEZQGFF5SyAhqB6HT1lHYoXe7O8kbDZVqUPqQdl8sr9n3H+rQCrOkurldcL2+4XkUBXyydg212D765Zs3Ow0e5X2Y0yF5/7vjNeAYPfGZnJOGfNaPNowJgxgve2teM22e7r8enebOxGI2E7Ox8enrq2mXvS5F17K8fPatDCJUHtmgP1/2CZVnALIBtThll3SDKGzsnANt3szMAaMqZarRIbTzlvD4bPdnZBoiye9u2br49b+/5L+vPqmkpLPpEizAj91pUjXFcveGDtbGmHSX1d10iFlrqM2dKd3vfUrmeFSQzviY4/mp2ztyrZ3Z2jHU05TcAIhSExuPIRRLq3J5lf8Pa9ymALHWgfZ+KpC1ctw0vLy/Ytg3P24ZSCt7eXvH6+gVvr1/AyAgESdOEiEgLTMFmZ7rY8fde1F6hNFNggCTNV0vBB0BVZOXGySV9M6PiXk4JoRkc+LG31zLQjHO91jZCYUldkI4ESefXeDhmSYNZFRXdWlcFPWMwmGl9F+Ojo1Ogxxi6+q3YXig6V55PA2TPmdGNGAkTjiP1xylDeTSJTlMCkE0pqAapIUY1GlOjoyB0gFMW9XAgHPsr9usFzIw/+f57hEDiLZ4SYpT1SSClRQUWmYCZq1e554dzztr3iOM46vo0/MCM5Hzx81n/Sp/epe3pUJ9DoJoetVsDrInnQqhzyaVohLrzXmVmSebgvp/Jx++Ve3JT2ye3779HS/w1Ix0aFdx2fymlM2CxsTR6cYsO3jvXx+vr3ISAQixYkz5rWVes61oVqDbvZnC1bRvAVB2jVLwHQ6LyCOljcAoSWULbxhA5Q1LRGC5gkcg85gIwzyOYjH2a9XkcU0/z7C/GWCPLWHl6epKUtU4QbQ4jagBHmubWn6uikj3xGGaYY+3oeQytleb80ni961ylsf4aO1u8POVTNfvztpPpBycSP0YzPsyP36zcm4/xPG7XzvfNLT5S2haEzunnlFj7LKmChC81euUBPwhP8gtkivEaP44eA7CIHVa/j9hn58rT05O2O9Xrl2WpbTd+z/a9H7vL5dIZRJuzj9DVZoTGbDwHK/5S0B256mgZ6Hw2MjdXisJohisBznjRpTkMBYVR003Hpa27UjI4M+IyGkZI6SKIDTxTGD6PNHS8T870VOnrjN85ySOorF1vXF4YUGMok22tfknfmBAXxlLEMJroQOED1/0n/OHLvwGXAzFeALxgWzbEsIGxIa4L1BRI+s4ZXC4o5arRu0Um+f67JyzLjq9f3pDyG677BS2Ki0YpfMfYy/psfImt1RACfvrpJwCo535KqdINYWHPBjMjza38IzTyceHTs/25Zvuglyk9xtrwkxEHAqARY3LjZ3LBkTJSepNzioB1WU/PD4GQU9HoTf1ZPcoI/ncppdq9Umc4Y+tGjZ/UYCYuhBAzmMUB6+vrD/jN7/45Xt9+DwoB337zPb759hmvl4LXrzu4EJ6fP+PTywvEq+sAl4LI0RnLNBmYQFjD90BZcVwZCMASMw49qwsYYZGIMxVrDBEUFjBidb97lD9OeRjMPMqjPMqjPMqjaGHTaKNnGmceGPI7AOLKQN7yvDgJyIB6VUne8hJEOdUzdVyfIfcGEedPAnYvXIyCr7QLHeBqQt22bQBE4DLw5PX1VZnejEiEI+3CnJKNDzewewQVGFXYnwECo/eLjAVXr4VRaPb96JlwEqDDhYOHM1qysbfv7M+YagEwrH7znrJnA51wz7eVo+M8wxSupDxxKae+2Dj4vtk4NUB1/ox1Xbvxbq82G2dhcxQU+qgMoRM6TXgR78vmjWCGUoBG0whNmWbjz5xhxmN+rQnKVhBrWHPpo4HdKfmITD5v+i8rNl23gLb5PUPKtUFYHN9LvxjO6bWBv34RTgBP8UwQtwAbVwMWDdjzQPS4n/2432pjD+ido7X49Xdan0GMDyJ6sGy87kPA343SXUVTc7ebNOC9Z4QQKkB1VvJpWiVYmOSWlxtgbE8Ljl2AkpwzCjNWVZYCDRwdadW4H9nRjBn44MfLaE4g8dYSIK2glAOSFz2ilIQjFfV0NkCBxSjkSc6FwpISJy6MEFE90o022nvmDAtxf/nyiuIULd1+CcASgBgWuSYpDQ1iMGP2DyVrhCC3NoNThhCZx3KLVmDKKK/kvqX8H4s3Vu2AX7ZxjAoyqceNet6IhyDjt//rv4/f/dVnJCVp3dqrjzTwwhuAcX8J+GRY88cqBOD773/EP/gH/wy//5Kwrt/i5eUzvn75Bv/L//ydu6ov/9l/9RP+7D9kgD4h0DMYa82P3RfrlfuGUM9BKaohgdKjGlEgYT+u4gmXM7ZtBUP4hLfLK66XC66XK9JxCK+waNQxHuZUz2f5vwfsHuVjZXbGvTeGMxpqn+388XyKRQIwmtbTOFT+Yfp8pe0zWj7W438bI44BZyWQpR+YnUv+HmZRHo91yPXmidifj74+UybaWBgobedM0QhpPrJJz3uHTvHUeNl2Phmv78OdSxSIoxmFDzTSe5R7JXcIofKJnt769hgf/fz8DADYjx1vF9nPy7LgOI7OK1XGOijf3JR1a4wARTVaMN7exj5qFDPAlIYeMOeSq+LHg+y3vd3Z8eP3FeDjPI9nxYyPqtebCEgY1kVLM+OfS9T2hSgqFkCdKiwSod1LFLCuG56fX1QRFnG5XPD29oq3t6/YjwuWoJE7ikRwyClp8EVPIwMorCf+a+Qt7kV3+WghMiOVs/GWjEcCB4lEGUIzijUjsFEG8e20z8xcldaibMwYZUW3sE58lnj+0inQR84Jl8sFRC2qhuxF4YXMUF8cObgzYpDP3ghalEX7nhCC3HscCbamt23r5MCSfT9tfUokGlTDugiTUTuenSUF4tvlguvba90jfv9Zmo+aIhGNLhr/6w2TNzXMss/Gx4oCSu7zdMraM8qqAMTQmJVfYCBn3TQRKs+JR3mUHGMoOn0SqbEZaPj2zfZ+29cmn0PnbjwfPiLntftNXvb9sz63tXpPudbLUeAiclNlac5yled5bQ/YWWIKTApB+CbXltEI4iRjDuPV1oc83+rN4HpO2W+mdPbRTXyUoVDN4lsfYgzKSxdkLshkkZfauU3UHDwsNZlTWTta0PbxmHLH5sbOoBEn8XzHSEu8cZuXqa1O4tCzwJW2NLYUjEqTxJAmdOkAR1xqbId9bimv25z56CrGY3TzqP/Yfh95Nr8W/NnuMRzr6yxto43faPTm77vHR976beSh7JkhBDB6wzA/X3P5Gcr7aF8hBgQWYVuhxoqXWQRLMONG69DkuvnPJiOf97pcYAaiZqBSI6tx6eTbGT7i+bAQQjU0nq1lv87rXBAkokU4G4zWOmkwBLNxxbnbDDQnLnZfgmsKeiANN1s4C0l/UzTqFMtmAQIh0FM9j/rhpWoIUBms+u/taJMjvzCOp9HV2ZobeV+arDvSFKoyrtz9nlLC29sbclnw6RNh3QRDSvsFP/1rxu/+p78HYsZPSmNffn3Fn/7Dv8bz86+wfvoEBuH3f8n4q/9x0XEiMG9Ie4vic6Q3HPmK/cj48uUHlMJYFuENP3auSRmdKEfDeu+8a32bpUnyfJqNZ88nAz5a41i8HNTG8na7TYYiMroo5+jsvPUYld9brS2kkdRCZ0jonefG+wAdZWJXD/r3hqH4e6kglwv24yd8/fEP+MN//x3S6z9CLAlMhK8x4v/4JytKAUpZ5awLhBD2SonKEYYZJjz9yY/47h/+C8T4LeKnBfvxomZXBxgZOV+RC4MoqhO17UOqy0V8Lwjlzrg/ys8rD4OZR3mUR3mUR3kUV7gKAKQgiIJxBBG0i4R+JlMeUAQoYanAgRVCDEEUTVBgW8KiqLAnXjdhWUEOFLSw7ABrTliV4k2SJ0JAEw5LySgMZcyM6RNlF2te+NZWFf0JCEHa2gQ8USCXIhEKwAUhBlW4N7DBQlkDUGDOmGeo5MXy7Mqsea5NAD5huuU3Imgu98b4egbdCzzeYMa8b0cGf66MUcMjHfdq1MKGjrOArSQAcG01MSgUtFy+xuoKKCQewqXmkSd7SIVYqEn2Viuj5gEmRWiaoRbDhEc/Yl4AHQVLARP0SgfynAQfu4oJwVZQYRCLwVI04YnlO5QCYomuUzlxon4UrG4FTwXLkHoB836RcN8hoIXn15DrAk60fM+dgDgAF6OQM1OStPFyo8f9x2oU4z+zzZhbF7XOXiCrgAREaGKQ9MftYYMIq+0PAWwpgepCPAuFBnZ5QG0EXmZjYd/5+2wMLYNblf0g2ZRRBVkBSLxCrLCXEe97Zvg9Zq+9cme8zq7RFVkUfHdKc6/QGoF73wavBKyREJynpN1XSsFxMADx3jVjxXQ0oCtY9JQAiN6AEVCwkBiIBXLGZWoQwsySdqTuQUAAvgZEeBpjO9Fegi4E6UeWEMdBzyAmlBJ0D2UwJyxR6ihGc1fCcX2VObMw62aEUsS4hlUhY0A+MyMGwrKsCLRDUkERwEE8LwEJf2vtLxlEwEIMJk2XkA+NLiDebkuMmppBUD2mIB76SnU4VPQXenTI/IFQqL3v19XZqNCXUTEg22pFCAuCKpMYWQ2PIiisyKlg/7Ih/RjFQ8etWjtV/FO4/nH9jOH32fez8nHoS6+PGes3O/6DP/sLUHxGYeCSDWgbzgctz98s2F4igBcUDncAk0bXrDAroGd4pipBbA1JKGSJyHEcB1JOYGIUatFm3l6/ShSkQ0CwqACYbvAp+O/h7fO5fev7Sce4v7bd24/UDOT7myq3lRDUjcPp18nar0cZ37/uI22x96PiptWp5500Vb1VG09QuNTVJOuIG9/auth4a9+P4Rp5mc/Re+fQSBPssymCZ+cmTBHj6jyfb1YvAHA1LCEijcji+FK9d4y+cX/dnY0KPKA/A7GtjApfwM2jjYnjTXJK1cCxaKfScSAQYVs3RArIJVc6Yzys0Nc6y/Is9VA2T3B27RiVHSYe2HhKMEM5V+MiCtagkRtNeWV9Gdf6OJazMRiV7f3vzYO/fefrJJET7HvrD5rcYjKZF3NI+fhFz0/bNQSRA0MIeH56wrZuIAb2ywWX61fs+xtykfSLTGJciir3aBtYSbIqBQpzF3XD990r7ex3qvKGT7knfHs/BlT7BgCBg6wCJpClGECojCXVhlE9Q5mTrjP73upFFWOrch1iOJDyjpR2pLyrdztXWsPKo4qXfUvhWaqzQ9DmOoYejBAY6yYphKuzR2SAEnIRGUS8v2OlTaLfV/kZACGiFNmHFAgBeVDuiywayCIEKP8djAex409kC5OdrZhxkQy5jxYkfQmaXmB7XmX/llLHlhA0faZSVZv/nKWvJBhEDC1Vru1FbyQdWCKDiCEBd3vVIA1mmy3Zs+siUQttJWU1gMuFVKa0pUSVByiWQgpc01+Trs8qV7IzrfAyXX03OdPc1q373m9M9I5I5OjLeERW5a/Jqnpi1fVV+SEM+1/pnVsbJo/4c2s0RujOm4HO2+/+dfbbaLgxRrbikgUHcsrRxouhfi/ylqUUozoPKuJqmgfta1X+s0ZaFTlCHLuyRCFyNFQUnguKpsgrWTAiWYcLRCUVlUbJuAciSQXL7Uxp8rkYL8oakraWkmoaSFlfwrf6eTbHs3re1uWiiIxONlUFqvS5ACgl6l5racqlXjF8c0uhfS6NLrZFQLU9kgFKaKs/WtitqZny2svG/pydRfTy8rQvM+Wxf9Zsrd1679c18yQ6jY6VrTH5zogLtTTATl71/JQ8qzcK6XnY9jrjtYx3u1e8b0Ep5lgjeFnlSRiipC6lykrMJMZUhUFR0tIxEY6i+JBGHQQRCoxmBOX6lSc2DMzzwEaDla+gQkDR6Hxk5wkN60BeCxd1IiFIGhg/92KwnLNhna1VBLT9TGogrIdY4WbMUA1fSJtOBCAiIKOG+OgGl9HPSo+ZfCSqpM1L0PMs0DniUz3nlEbVc4SAQAx2KaNIz4WSBcPFsiiuA5S8IyODqIDCgevlFVxe8Py0IuYn4ELIf3gBAcgwjuNHfP3yL5HTn+IpfIdEwOuXgK//5tc6zjLvTpoCF0m9zQEoQde0HIR17AkOl7U5qjOJuvh92lQzmLGoRj4CUjeuREPaJ88f9zPFkFTlKVn6wvP4+3lrdAl1Xbb3M3nGzgrDhOWv8iLurGp8vcdHgziMLYwQCxASWPEoVsP2xtu6NUqQPQ57BqNak0GcAhAWUIzK12RwuIJxQcEr9usr9t//GuX6VCXcDEaqc6RYpC1RilgAACAASURBVFsFNq51HUD3x1KwfHtg2wpSiihlqfuRcwHSAlLje3AAcUCEGF8HEIgNeSsgzPfUo/z88jCYeZRHeZRHeZRHccXYJHLGMgy15FcwhZzQaoXoDNp2Cl+NAEAhCmtGag1t4bGVmSXnSWYMKTtGOaiWj7mgqGeDROMk/YOGLA2QfLI96GoMqYVLHg1NRAgTI58Ym7dVs1aPzoNVADCycLtQKwg0wKgfkyoJw4ArOEHeK9QMOJkrOfxMGdPdfpHx68PQ1rliGxGqAlNT8EtkHQ82h0hOImLDhivQzEU87MxgRqL5jECfa3KdDaoXsAIFBpbAPX8GmBloYOCVFxpOgIcXuuFBFxPOmvFCFci0ryaU2nofhR+ru4pUur6qskHBUxQJG1lToFSBaZxf91oHbw5yzJRHVm4p3Pz4Frfe7S4DH85K+hFQEkBNlkBpq9A1tVeAmmJJDXJKA5VGJWD1Nrwx/8A4Zj3wdVaSUtv6rjQDH+hYsNI6BY7CfD2Nz+mV2FzntmHAnWivdenn6b7u++P7758vdQNeuG+AQEuNYfdFwTrVw1AEzJIlRzUzA9HmP+q1orjaL2+Ica05ycEN7Gcdxxa+2MAZhuXyJjS65kfBQBwrEvmmeenHsIJQ1EtQAVo9G8xrE0hi+sYS+abkrB42ESlEpVMGQNrek3zoeT2Qs6RtChRQ1Osy5wyOElFAxpNrFAbFNBEggJzNX4gBVAHSAEYEcwvBrrkE2+5289XtHXfOYVhffj+OyoOmCKJKg0FFzxcZV4CxHxImx/nNtvN+oBn1dKF+3ur8DZ/fKx4k+0ihsCA+/wqffvV3UbDiehx4+lXGX/zH3rjCaJEYdD59+ozCEYCGnf9ZTxXCXvct2A4m4X9Yomsc+xXHsVdAOaUD1/2Ct7eveHuT6HQBYkgV/D4dwP/6jFvjxXya56Yo6RXe0no63Xe3t1Na+bdTft482T1wnqDzc+JW/8bxmSk97Puq+Ki8WHtvz2BH8Jsy0dG+SVsaTzs/y6Z9HtaEP6dHfsCfF6MHqn9W67OtMeCcZqbADEpDIHBq0ShqukQ1Zpjxo76/vjSeuIWHL/UMUFCUAOJ5BDcDxoE+sg07UNzLDtD+Gm2tqTdBWDR6GTMjhogYYl+f0Xpqilc74cgrwdxzRaHaR5GoKT4gin0OjFXTQF3KBfpzNaLOkzXeK8p6heJZ5vBe4/O5MY7cDVTHMxEAtroDAHeCtBqMXpaattCeH0JTCJWcsF/MiPfANb2i8AHhY4TOohpQuP1QnPyGCO/l6/eBj8xy3kft3GDj1e193XekKfn0WRQ10gQBTGIYAnfWkhhtxCD9FNGigJFBbk/5MfZrlFkiQKWsEfUs9UTlH7U/KLX/zMbrMVqEAVt/tpfFQH1ZCCm1NhBpCmObWQp16mV/GP3SPpN46kaIsTCjaDSdlm6m7X2V7CioHGjz1WRMT4eILFJWrjSn8c+MXMQwZlsCnp4kgo2kce2dR45jR4wLlmUDuwiiPoofm8Cl62JV5aB8p7KwBDms9NpknTHKSSAovyd0X/xzZGwshYqsS5mDECS9Zs4JueROgWcGccGlNzntrXfOczMqNDm37nWbSnLrZZArfKnngO67ujfAqAbk3YMnbRnq9tFb7LMVHyVsPL9G3nZWxj0+nn1G30Wei6Do00MpPQ8Nf2nYgNbFZqwm9NAU1eZkAJJzA1Ejd6rwKGs9u30v0RKKRsYUYxkXTbbuk1BpNdk8uFFv9N2UyQx2EVxyahFbW+qenk8w2dOf8UZjwKyGReRO8sa/CPYTdNm3tSF0uq0MiSKlXZuwYOzONNtjgRoWwBCDhuY81+bmHp/nz4JxTfjPt9barXP0vYi2s7o6fkRlUIn2GRqvXvE3o5LCA41y/i8tU2zIjVH3nHbkadvcOI72H4SW/o8gWAmi0rrW75QtVwqBgqhcCyCOanbs2Jh3YyyOLzBjFfuWSbEjWW9EHmM+48+l5LqnwC0Si/SrgEvSc99oZNF0ewp4qsFZpYGsfVVjYGUbZC+FgKakvyV3oO2ZugYCeH557YufL+mXGML4qCne2J+Li3oLo6HyWuo4yQ63tHBEBZSBQgTxWlIsGAeY3gDeUNI3WPFrxLhhC6EaeVYqdVnx5V9+g7dlQ3whlAB8/SG4K/rCaEuLQ8D6/Iy8H0KnwTr/co5W+406MFwNXQhUcdpAaoCskVssFZM/Z+oZGELfMD03e9roaAnQDLvQ0yQf4Wa8rz3EDFJs7Gc8an+G+fRPvkr5vfH4emgDVFA4IRUCJQaoIC4BgSRVGPtr6xN1znXtGr9pRuY1FVMgNcJJAF1w/d2BL/96weUPL7pVWTlPo+OtMIAQC17+/CcwidFzfltR/vA9GMD6/W8Rth3h2x1pX0G0oCRCziypyRkAAog3RDsvNbKMYJPmoFYar/kwmPmjlYfBzKM8yqM8yqM8ipUKBnuBUsM/mqQCr8yF8F7cGE8CVHgQRtcMbVjrtwgFAsBSi1Rg3nhEjhn0gig0OggBRcA08SAwoapFifGCEXNjoPqu9oKzPUvCGZoFfwNHBPyOFSy0yDIVNGRWsPscKtfKKJjXjrEymiOY5Jhnf18Vcvn8DH/tWN/YliYocx2rUvrw9iEEmKa4r1PDEBcDi2SWgwOGb7Vt2o73CrW14u8d670HrvXjJwKCjyxiIXPH9CyzNppHkPwOAB7k0GuDgCSrguq3u3ZCK+DQslN/3yv3FIV+Dts+DrX9kqLHlmVTMPjGGMjl1P1322L1WN5gcPOu89cws3qst+9NGL3Vv1EhNQqqMYb5/A1ABHOjURSDhFPXdWFr3w9DAxRvF9L6Zu0mOPpGqHt9Vt4LEW3C+uhZDTSB/mlbwchIR4KlqdrWDbxwNTwUBYmAJxJyf0fOO2JYKshv4fuXpc9n7oFCi97Vip4A7ADCCtQZreA6h6aMlXVpIe59pARLq1ewrJvQZlLvtSL2fRaFxsBKMRoxQIQRj4LjsBDZDCOPJRtdFcOcnArKQpJeQw2BljXWdG7S5oy4bobMqzo0yudqSOqMhiaAbTU64gppDFjOnKZ2o+y2awgLtm3D09OGZV1AxOq9HhSap+n65TpbXA387Pvxup9belXF/bJtK379/fe4pIJMAXH5jD/9c+DXf+dA4VQBd1AAkQAsoIiSI3IOysv8PMCZdFPqKqnzwSwAz7Ffse9XSRNSBHA9jgPX6wXX6xXHcYiyQmkYa0h41khmH6XfM76hKUqcwejkfDCFiPEkHxvtfzfLPV7gI8WflQbOTnm4O/e/d91JOULCM8zKyOf4zzNlUuOl54qgWb3WJv8+pVR5IgOJLcqMnenpEL5R6LfJCW2s7oHJnn/053gg+/22UYhXIugXMGWmRHpohmt+PLxCdVkkxYal6JD0MgE5N+Ddzh6fRi9nRlEFCpwyxIBsC40uZ7MZXmqv045LOioftG0bjuNAVcAo8N/2vAfHe55ppiD0vKj1+db8n9aBHstcT4OmRG300S5VPrCygsJTh+DXJFclhqUglbURUELW+TdNWMGi8pfRvLGwrQM/38BpnXTna5UxRUmEWjOhGodox8k9w8ejqcOjc+HXwsj7W6rLasBTzuPPzJL+K4nBUKur0R6fvmfso6xza5e10ubMUpIcuq7IyaoQhaWmahSermgaziJRj5T/kuiYxmMXpJSF91OLGDN+r7ycW3OmlBIzuNzJs4EClqWlLasG2KXI2UqM6/UNKV2xLAEpHdi2JxC1dHTMwqNdrzu2bcG2btive432J+uwpUWr/Dwk0o0pFSXqKlofdDTJlGG77MsWHYIBamdDnadSqvGbfd/NFbc0OTFGHMdReXebg19axrVv39k8jMpCKzOa8NHzsSsTedlk6Vn7Rlps43BKjeraOeurPcsbb5oxHqD0OqqxjN2PPjqD7YuO1lTeyUUOa1wnQBKJMkaJkFy4pUgZeS7Z/0BmSWEmZ9JSI9UJbXX3cIswZXTQ+D2q54y0tjA7Wql7S8+duCxOKFDKYHKeGiXIO91zFrWJgkZhBXJ1TlA6aSSOvVFIUxaf6G7hrg1+TABUxzyWza/7hDVCT8MpfESo2bnnyz3c6d69Mz5odo7468d67NoxpZ4/K2a/j/WPz73Vz3HPz/px7z5ml85oYnQylltYyniPT9856wvduVeuEYMyS/koxFuigRiPabxFUGegtpdt/GStc5H035IG0gw4DIumeraJUaPxJ1Cm30cKEgyjpmJi3QoEUBDcZInn/d/a0xwyhl+nYw2cIwvb+MXRGNT9PjsLbjy4/uT5DeONQwjIBUhFeN0UI5b4hk+fXkTGhUawMZ706/f4+r//Y2QwMnE1nBixDG0pAMEpmBPAAc/Pn5FwRRtneSskdRg7Arg6OxKIgaR8znEc2PcdIQQsLuqMPC9UvgR03me3cMLa6tLOmzES9jgH/ntft58jz9fdnb+hTVPawCyRA/loPEnKWJZNeSGj94AtXhJGX78jmMG2Hj8gYkQSFUCARqQOB0p6xY//LOKHf/ItmL7p5tTecQVM5V1YM/69/+I34Jhwebvi9S+f8faH7wEwnv7u/43lT34A4RlH+ozCB5gDUpJIwRL0xlJW9fy2ZTyAPqny+Q+DmT9aeRjMPMqjPMqjPMqjaKnh+8xCuHoVWTjKUBlX5paGJSwRXRjKKtkH5XYhHps5V8/DwoyUfH7hiHUNFWAxoBowYTOKRbFFGigLODKW9QkpCejYBHcFzGBGELljSKWJnhH1HhdoQF8p2PekbRCh/u3tguNY8OXLFzw/P+Pz52+x7zuu16tGQAiuzaEKILcEdWb1RRwYeu+pYcK1AfyWH/0WUz0V4knB7SmzflaSmKCQc8YSGnPeDIhaygoZG/W0XESQEGVz374Z8ODBfGuLzMhcjOzqsLYOwIa9jqmtqsdZfX4Dg6w9s3DuVmf1qiLnuV3HRdwTazowtnEUcPaeQcQZEHEALs5z8165dc0IMrbrBI1r/ejrGEHW+jud156/ZxRADRizqm8BLyNIMHop3gKZzv0tp3utPq/o6PpIIh0aWN7t3SpZ6qqx5VNfpHP1SQ7dFEBqGKOKiJ7HYBSgZ3niS8mdZ4uBHDPQOZeCQKhKu30/AASsy4olUPNwBlS4XrAsAS8vK4hiVaL4PWVKMMlpboA3IS50HjvXD+/568OnC2iVK+0X+tPynsurek6ShNvflucKpFTQR4Fr89aTmWlrXe4llKeMFnBA6MDLt58BsHqCMvZ916gEJPUiAcQIOhZiHBGR7+xLDw5O9wTUs4tbK4nOBoL3wFtmbvRdDaJenj/jV999hxACUtoBDfVLzTULbuXWcWIIGFXq51+gQLlTPlKbpO/Y8JYAogVMKzKLcqvwAkZBoIhAK0ArEhNQAgiremtLGq+fUyRqjEVKExpcWDzDr9cL0rGDcwJBIiFcLhe8vb3h7fqGlBOWdcUSIqKe+zlnsK7fqcHMjSNhxiP4cTGgqF0wo4Ps1tvPGoZ/Z8rszPK0dCzLcoaFQmjpSkZF33vlI9fM7imcMVscnvbeWyNAoxW3QN2ZosI/Y+TPKu+k45BSagZicUGgqOdDBFyUmDHag+fNjAcrpY+eZr/ZuVJt44g6pdnYVwBNWWr1lXLymme5qUZ1gILGvu6cU5UnTMF94oOIQWwpCc3oXv5yKShZ08oGiU726dMnfPvtN4gx4vr1C377298i54x1XfH582d8+vSp7tXL5YoffvhBDFl1v9s5NfZ9NIa3+ZMxjVWmmcoF43uTf9QURiddVMfD+jM5oPK5EdiWBVGj9Vwur7hcLi2qThAPe1Fw6b05AwHqJQrEAOS0I2U5vy2CCpMEmQEkLD6FgOM4wMyVL3l7e8O6rnUf1whCKv8wQxXDut7UeUPkvWG/eUBeB8H4GzPqJqJONivFr43ixqgZOvrxMwX709OmsmLCvl+QzcPdzc3IT3VNha2LUqMysJ5bwr9kPD1tEvVMjT4oRDDH09oJQYzFZQ61/25vZY22JM/QMbU2QiK9WT4i8UiWvUUapCmSKSxZokhkSDqIuEgfSlbDtaxRaSXd0evrV1jUPzE6WVFKweVylehQkCguRSPNhrjWdqdUEJdFUmemhJQLlmVRbEBD4VAA1EnlRF+Mn7Y/AOsidK7ymzoYWT/bfJv8v64rnl+ekbLwy/u+Sz0ardYrl8fy3jliNKA713TN+3n1ssIciygdv3erPfPCXf1GN7dtQ0oJ1+u1GgZ6XGRsiz8HfP/8e9s3dk8z5O+NHi1FRy4Fyc1JoGZgAwJyEqO9sYTquQ7oitUotBZpSvdc0bXM0LXX2ptzkTSduWDbnvD09NT4jBo5ra0riQjZxtTLNt3+p5bOLKuT0/OnT9U4FCS8q2FZAbIW93RoNDVJVWVjafMRo6S4qPvew3oDLynvqaN7p/VCACZryBsFmyybLXIPGHFZsMVeRrc5H1/9M33UDVsPPj3SSEPHs9S/92txhsH47zyf49s648NmvIvnt2bfz8p4nvj7bpVbzyFCdaSZ4TAz2VXqA+ysGo22Zw5Rbexu1ymlObSZIwppNKUQ/NhK9HKLOuvrM9ytcFsv1i/mjGVdTuMbY8S2bbBo5U7nDzUd1j0la7iUlv4nF8Gab437uBaImsHprTLFqIAqTzacnDssRfrYP7+UjIJmTNqMKJrRjaerpRQEJqUHjJx2bOsV27YAvKg5oeAJ2ioxkjEnVudwQ9UYw4ZT+UuNDgtEMZTexPBFdAuh8f4yAFZZd7YVLkrD1Sg9Bix2zvg1HAhLXCtNNx7Gj/U4DiccLmesS+ObGt1sUWzs+lYvcGuKb9EVw7x6A7Dz2d2tHTPst/2bMxIDx3UHCmNZ1spDhVAUS4tgNMNIUt7aovYShyYLcEGgBOYDP/7417h8/QTgRdpRZ6nNMNd/5dsQCM/br7B+2vC0HeA/AK/6e84blvIJCBuORKJ3oQCiJ2l3WeAjI0okaTGGtVSEFqE6F3M0eBjM/LHKw2DmUR7lUR7lUR7lnUIhIA5Mu2esQ5gz/czeI6cJYRY9xadkGYVK73FVhTo1yik17C0gAlTEEquqD6h+gcIQB1UMdoBO5wGIjrnyoP4sMksp5ZQXlZmxrCuCy8PujX58vVaPfWfpceyzB1PnwhRX5rCBEXa/jbsLe2q5rGvu5FaTCS+V5R3ayMxiyW9XElDDH1ITPs2IxNdrgIqv1wvJo1Km9a691t7Z7yY0+PYB3foc+2GfvbebvDZF/y2BpK+LUFgiBsToAUirr6UAq7fP8hm/V1TY9GM3Azint37gmhPogdIUExCFO0O88CrwOonSNAqc4zPG54zed7Mx9n3183IGanrBdrZux2f435KGQrdSjUwcQHm3zLflqfg1Na55MZgJAwjZr8FbCpf3xuVUTynIVdkmNJOLGQk0mmOe4RKqXNegvQzCvfeArr9RALIYHACs6ZRcFCoWBakZvlhUKxHkBbRjljRvciZE3bst9UANmUsSzYXVUImZwBrNSUJEl6rRoZHoVSNMFuAaGjJ7WSQ6TWDEQHheVqQkijnkDCpNcVSVTwqcCapmYIHGKGEGuqwHZ3DQz2U9UxUMJD7vkdkc66zAEG4K0aWSk5RcFAToszRLI+1nMIpLwcT1v7/5YsrJQIydD3AByMLMFwJIQP12DpCMPWFAp4wn+EDhNl9giS6XU0I6DjEMUwUDSkFOB9KxI6VdznkuEpUK6M7uOoIfoMutGf1+b+uiP+srnWNR1LS1ZWfQB6O3/f+oeOB8LKbEtFKjZRmdNfZpmMtbY3xL4THjTfx7wsd4hjGC4Oht6nl1/9n34b1z1StBADFsWFfhfU3JG2NEDEujga4Y/zwaqMp6BYSPFD6qUqG6/gNicDyGG892XoWunSZHTJUMRKcxq99RM1KW+gjA0jD6G/yF0BtNS8nSfqkDyh9nxEhY1w3Pz6LEjYEQXp7x/PyE4ziwLMIDbNuK4zjw9nbB5fJWjTPamPTrduR1fbtGBZ6f23vFzGR6kL+dL8bzEZmhvMhiREAgBnPGvotRwPV6xb7viDFgXTfHK1v6ogjo+c2qMM3clNrFFFXWFkf+QggaGah5/I5h8cf9J/yW4831u9P+vXNG2z6zZ5uCvuc3ufLL9lna0pxNjGeyCChiKHwg5QSL8jmu51FeqmubAKB0ikFP52JcJBKGjqPUF+uAduvZXup3rHxZcziQs6UZzZhDi9UbqnxIEtmjELib88YLl2IOKfLoorKq0ZIQhEORce7TapQif+u6idFyblE+ZuNmc2vzd4602f/ZGHicor1KdcWlUJl5i3vDcCsz+XJm9PZzy5T+D8+4JR9XLEGxkJ/LN7ASQM9zmMGCnw+/9v04VBoGLyH25Zb8Q0TVuNLG3CswfaSSk5xf+rkYnyPtofZKRke0oUX4awQgmJIffcQZSQEesCyrGqLJYm9GuDb3pmwt3bkj/Wv7W/YFIaeMmmYrmNGmRQtRvAuaYiQAUDopBj1m7GPyW6l7igi1nraHCCWPxtdzWVNK6K45r5f+HB/3YgiT9elex7maycMjDRj/ZmW8f3zm+IyR9s/a6ffdvbpGXuXnlFn9t0qVMZ0yfibl+XG79ZvxBL7emTxr30dNZcfwUWJ841DPFtQUZS0yWuMfDDdhEKKebZK62aJfj30E7BxLStd7QxH/F0jTMmuj5NFFjM+qA6Hs9/oMDjflZbm/RYOq6x1AH8XmPM5+jCpfZ30nOTvreVsv5W4PMQtlokq47Ps2h9M1xHJ258IopGmJ04FcCBZFl4AuSacl9yEmwY4tgpviLCyDBUBoCrOk1SlUUMxIxtIkqtjF0/1QmRXlQ2TOZG0059d++foUWFSvOfXbP8XtgRBChz3P9rDJ5ONBNo6xXwcjb+f595m8OGsr6/WWNsp4Q3OkE4O4WCP0+bbUMxJAYEKAGPlX9pILgAzeC/7qv43Yv/49pLeovxEK+ZU/2QPqbLpfMzIlXK8Z5fmCz//578ElIz5fAWwgtGjBMANsaCQ1cjKenkkS8SfoIjHDfIjx6nQ2H+WXlIfBzKM8yqM8yqM8ipZSWMIgKvPNjgk3MNmEaZTcPHMoVIG7cqMkbHQIqCmaCitAaZ4CaJbUZh3fjFAaWGcMfUBQxllygwsooOqFQLDQ3s1TtCCkgBgzwF7Bm7SJXsGk7xTQKTkjkllao1m4MyEnUY6llJGON+ScQCHg08snEElIyNGDahQgR8WNXeMBz1sgQafwqYxk+8pAWfvQA4D+VgaqwGAgin9Ss6q3qD0W3cGDqbkYmM8VRHc6DgcI9ULDKDwws6Tqckrceh2hhgm25+pSBZ0EwHMZBXcVL2BRNex7W4++rX785M5SU3JVgIrhUhe0XOQSujt3aQGkLQaeo342IBlVkSSvfsxu9XMmvH20yFiKOI26bKqkVK/px6+V0ejIz+cILpHm8b5VboWgHZ97r5898HSuxzpU3HfNg9wJxGi4KIjqqmzrwLWDq8/MuT2ApqArwzgCdREM/b0FuPm+jx5cRkeNhvnS0xRRykp4Y/WanAj+yyIBwiRMt/xmXt1WzNu6rT8GBT+uARaBalyjHsRq7bS9cQ576+83Y5XMBsTY2mX3n66zit02f5fChBglZHnVQ1JAzqieogYuMaKGUzfApClCKq3VMWQuoCBKI4n0QgCnfo7BHc0C2lazVWZ1jkDKDPyt9bICHnHFsjyBC2kKjALGjhjVMGmqkuD6r0Eff1vGMtaeUhJyviBxRqIIpGBkEgzCsm5Ylmcw57pHNV4bhEdo6bD6Mjv3obyMrK+UDjWUOZDTjpKz5IZPCTlLyGdLz0TcDEoLF6BM5ocIPNK290Zgclba97frOZ8T9+79myy3aTY1Qv3RosTZ33XrrLDf7oGcs3Z6Iwx2wOpMQTQ7j28Z5tw6yz1fNbt+nMtb43k+c8/X3QKJR+WPnSu176EZupuxgPDWWUncmc8cFUamEDPevnprlkGRyo0vBSD7bzg/rL2WTpNZI2OVFi3Nuh9CrKm1TL6RFrTGeiOcUhoP76O2tT4EZDvT9bxaV41+kUtNtbOtCz59esbTtoIgqQDTsUPCiwPX6xUpJViUlMvlAgB4enqayCr9PNn4jvPo+Z/x7BhL9zsaz8MjLxdCnbu4+FQ+CTnpH1p0OIBrVBPj2fu1qcqCYjIZIy5iiJWTpC+JcanyhfEhsmx63tzGweZwHCu3a+p6sDPYFBx1fv0YOhmJAhCXoCmJABQgRlLDDfF0ZlVENznlbPzoS9G+m/J6PNOtf955oqdhSi8IHb9g11gKIIlkYoppZ3Tcr4SWYk1lGWVrar3LtlZjXFI+KYiQL8bKRCqji5wfYkRQ5X0gib4m/ZQIQimLcQAvEmHnOHbtSjZTaBTOKLng7e0VT0/PVflTcqnyhBktp6yOIdoe6Bix4g8IURR6DI2yo/hEaNGmetWPyZnUr50oUagyZxSos0wImtJKLhIenIBAEuEkSRTS2Xp4T267d26P66XSbWry3K1ndveCUKiAytxpYVyb1cjHGU91tHFI1WrrGGgyoz/7tKG9XOXafusMJ6I+mhSaAhywIaCa/of0OU353Mttcg2pJrq1o6Y/0m/FoUTHgCzJaa6GLUyEEBdETWEWKEgEqKKytp1NDKCTDf042/oVumL7cd93dfqQKJeRosotGgUDBO9MYKwwBY1AoClwzdBH4Dah8QLaSbOSRq+wOgvLmWobgctc4jVsqe4nrrMgdbPNNWsAEVL6Lvreka8zfsqvl5ksaWehP7d7GWleT9f6YX942dnk0nHP+Uhjtv5n9fuz1tpjr75Pfr3P+M17PKR/nfGnt2jOjCcc2zu21c65sa+32mnnaM59X4LutS7Fn/w6rbetEF3pQaKct31ieHTfN29Yt+97TV/W8/wtwob2WH+3lJp+PkWxHyKDUCSCy0yyPvlVLgAAIABJREFUM5qifShgjaBnhm7v8+jd/Ie6vWp77Jwe14lhFqUUNeqz56nUOuwP/3yxP2KAGIEZKSfsx4FyBDAkTXWLQtJmpHdQMl7ejZxGnMkpAyyRX/brVQ0YdV0RCQYPaARfJ0sb905yfnMk/R7G9MKabvRaSJJbqzifgeM4Dz/I9aUgu7Ed92elfe22m+Prefd78uuI9Xk5xd9TZ9VuZ7WfsbZVWq7fOSdGQ32MDst7cbZaYgFox57esP/2GentpeOSCGam1rCj2fhd3zLKwbjuYqi5fMvCv+Gz9jkgIKIEwd2seyEuNTKcLF2ZWHZrQuaSADVkm8Jcj/KLysNg5lEe5VEe5VEeRYsIMy1dhgkqMw83ygZSFfX+12gqDpAehcV13exJAFpkGu+FZcLospyBj6CeOSUziipgU0oCzFUhSaK/UBDGNsSAhQSgMwAnJQHbGhDT2mzMqDDTEq7SfpNXZby17waKLaEH1KV/5+g0fjzMWj04hdE9oXX0Fm1VjcxpEy64ArcGUowW9yZf2PdmyMFDfdDxbd4/Ihi0dggzbxF7bL1Ed/8ZCLb3pZSWcbSO8Uz05HqN1BHO3cfY/ttlBCj8d+d5FNGL0NaleDREmGeDrd9+vZQqqEidzRimgQ32ufH5pYJRZ/DhXv9uga93x4RN1CE3n+jWQlub6ObcXu+BvxX8UXB/BsT4+jzw6X+7Byz4962t5+u98DlGgLJpMEAPg0Dt5NBBHnNC/KSYwD5uvhGs9f0cx3ScPw/eeYAwpdRdI3Ua6AcVNPU3svlmAX/IhGatX40brV01TQZa+GvvPSsibK5tl33RRqzNVQPYa7+4GWjW9A3UQOtQ29vaJCmb0K3ZEVSrQFUnyrOG72+YHxNE4WLjDW1/XKSqKOdBNvDZaKbSZjKFrHnEoWjEMdL+ekClX6d+3RjN9vtkpP9jsTERpdSCSCtyLjiOHblkhHBFwY7CnzCKvw3eOpkqYu57+P9++fol4P/83zZ8eQs4wMic2lwpLLQshG+/i/j+z1ubSU/UutCn5QZARtr/knF5e8O+X1FyAkoGc64KvXTsOPYr8nFoGkZHyUVroWDtQDeGPfzeGXWLjnvqMwLLNjbvlVuA9t9K+SVNIMyCnt0tI4jsX32kMs/7eh7EdsKMR3u3uR8Y51bfmfez32d89fn+cxtn5+w9PsEDsx195/58YmZkypJ5pVvyfRtn4f2NJvrXri98Ptu9Emnso0RLEzpu51tRxTzQ/Hg9b1ZYFJuNlT4bKY7pUlo7JLqinMMLnp5WvLw8Y9uecLm8Yf/xguPYEQOwRAIXMTDa9x0lJ+zXvRrXA3LmXa9XSATLtSp/2jlNHen62Prr2+zHrEb7dOu/KYya4YBFwFxqVEWhszk1xwDzHT6Ooxsnv3a0G/WsFgUOkA8xQgwxqueo8MshRFCMuqhIDFGDKLJMMen7M1sfdf2wnqc6JkYr67nBurud/BpCAJkxeABIeaPCGcgSPc/4IUmPyXVdhNAr+Mf5aOvHr305g2ZnxKjkbb95OQ+1HpHRNPpS5aF8Or+er7PzSiL1yDwC5rVt8nrE+rxVwykwVWMVsnSPWj9BcQSKCFQQQ8ASxWCGixiVhCiRM4gAcMb1+obL2xteXl4QF8ayRk3rK7hCSgfWda3OCjlZZMwWgaCwpdJR2bCOkDeQ0xQEZrBQ+TVU3t/kNG3ceT1R0r0hCzssKv9n4+0IZqUg1xV1nGjr649ZZrKBly9vFU8XGBoNYHLmzJ5VryMornA26vJ7cb4fPtafe8rE2b7wBjTkDdvlS3nx9Q28mgwfuzVjfJ3SsEo7gltVDDHXJDHMYtsX5kTjDElrFwJQzygbs2ZwSEQIMSjdlN8sDS4DYuBCklpOojo0quaxrdpu42ds3YYFHLimeJE9q9ScNSVuKSBiLEEMGqw/TTErSm4vc1ey66bK1kpdI25fWUNN7qyj7taTp+3APHqIv76NQf/djJ+qa+UDvJUvs/o9D3nv+vHssj+71xsB32rPLVxg9rzZ763C+327VaSq+7RsfJ7xAOO4VaMKt25rRFmY1FOcRGpYpUTDqGcnUcWH7Tl+rFk3gJw9BFrOhlf++f335/Gw9VqIEEBTimtR1c14jEtBCVzzTM742fGzp51sm70b4yY/EIkxbo3oJqOlR1rjAwST7PvsaTcKIxMjEEtAGRu3LePbv5/xtK54+1eM/NXJoa1mbY3nNuwq+T7GFYQD6chIR9IIQUafNWUmADL5QemNcafCEosxpEUKtmI0zO7o1qE1auC1xvPp3nnl58zrKdp83C/jNWM0LPvdUg6aLGJRnU+0C1DjJl9r4w8l+IzQ2pJbmlRJnannhkWjr6m7MsAH9h+A44eC4wJQphZFaMCH7BSkmPHyp79BQQGXAGBBWCNSBhIDpQQEesa2LYiB6voQszPZ0wWSTQAcNOIN1TSK1SiujrmcSREMCgsCF4TwMPP4Y5XHSD7KozzKozzKo2hZtw3Pzy/iQehyATcBzoxSgGVpgB+IkPOh+eGhwKTl1c5IWSK8bNsTBHBkGDrFyuA1wRmd4UFVYlCLNBAjgxFUkC/igVgsoC2pYtXgDFQE3UDiXBrQDTRwqYFsxsA1BaVnTi2UZwND5LfL5VKfIdfFygDPUsdUj0jqn/O+ksONPUQwOjPoHmwwwSGgee2OxQuVTWglAkKUaAkS8lqiFFAN+8jqZUm1HjOsERDTwqS2/vnSnkOVYQZQQwxjFMiJVOAOOs8QISHfSl91q8j4jHMk/T979tTHB0Jg0j4xJEKNpZgRb04LDW6eI75Z45rrx6ShTAyoMDAHRvw949TfFOpvCnHNiKBJkta/mfAn1/w/7L1bjyS5kib2GUn3iMzqy5yeGxYr7QUDDCBAgl70E/TD9aKXBfQoQA+SIK2EmdHOzDmnT1dVRoSTND2YGWlkuEdWVfdIWCDYqM7MCL+QRtJo9tnNr9MZbNoDbYwmc5/8tUcOMoMSf9D8c3rf7p0MjKf597VoDZJ1F0gpvwOG7YJLjjJDU3CmQTwGDioLpEB364xoLB3x3njn+THe3brAjLyJemvrTqpQmEGLdF8DFBhmGDIwzPjHDH7vGXEMCTH4swNO1hdM+yF0mt6tGSDnns7d5sbOGAZjK7ktWWrPd1kRWrfM+N2dmnoErDMSWPk5QjtzQgwAomZEy7je5EzjnCX6Rq+JMaIWQmUSh8zK4LC/XsXI6EGuuyskI8IDQ8HczMnIouOY9WyIGUwb3t7+iFwSvPrbgUh5dlCe36OFOs2+hrv+2vaH3yf8h//xh3ev+4t/nfHTX6dmqJiw18PW16Ota8i6rZJ2+u3zJ9y2K8ASpwuuKGXDdtMyTE3eqW39AXCGlV/naDTv7T739/CjbFMvQ9w/5z/ndjiGrzrv/W3dMeaoZM3Ak7+Rhv7ZjwD3o/7t/T4bV+bnHz3va/vrgeJW6oZEIp4BZXGUt6ws3VHS77FZ/rWMhPIe3Ud3cozIkfN57cs32M9BNgYQk2T5MoBZL+wGOaKW6ZJMpmQAFLVMUs+gMkeY23tLzaAALEvSMlVASgEhMHK+4u3tF1wvV9xub3j7/FGyLtSKrM+fnU8TJSxrcvrWhvW0oJeyHAH6vTbS4pgXPFwT1O8jACFGpRVju11BIaAUyYazbRvOZykvlZaI2218p8mPFkF+158qxiOujBChKdYlg02ICYBGlWq6fdIsDSh+P8zlvnbOTDInSsc7nQyuEq2e/Z03+CtqZdxuV9Vrq5ZRyneykMynZdXhu/7YvfZdbPQFwL2kENDneQgcGfTjqvLaLEOaI5TIUMxF5EKyNPpoBmvfejYgcZo5nXr6/hAC1uWkfYczwEkmmdj4B4EoNmepqOU3U0yoLNk2U4pIi8pLtYCIcb1+xue3TzidExIC1nXBTbX6dVmQlhUWqMIsen8MK4h6VloxAAUtaekcotpcD+bWrmfCjhO3RklLg6nQKjxD6CM0ZZ3noAE66mLmVSjHo0IMQ4lNP1+/RRvOBrEq7cogs37bPgM36hzpFkeNaLzH/vnsDfMafjSOR22Otu96zP3eNwfAZjy1Prp+iiw+ThsAMGorXyrORHYBdXsrlMc5Ay5ZthQInsEsTnYEOxf3ZQ4pWRaQc0EryxaUR+p5WWvG9XrBsq5IQbM97fI/z+NsPGiOOQDD0lQQeMiAS2TBOibL2r4p4iBWgRDsfsGU+v5y/ehvRSs35fri14ll3qkqi3ucYDZkz2vXt0cZaq35deplwFmm8piQv2Yu/Wd983jpXJ5tH/fax0/8v0f637fK9vv76/GeG2UK/15zWtl3LBiwHXMQbdlljL5KP+pnvHJnAFa+rL0OPSWsvd/LwQAQEcVzTPWzuiOLB2ieF5XDOhZQFVe2PXGUue6OemwYhXW0f8uuNHsgqJMamm5ta2am4fx3H2tpNBzGH6ScjpTDK9ozl2lN8SiT0SUDbriTca1Jchk9F4gkKzEYp+8r/vy/3fDjDwv+r/8B+PhpH8+wskxwNGmnMhNOpzOYN7x9+oySWfGw0PgsXH87SSV3cOEKK+EN7iUmdxvd/dIY/t663d23stAH+QLAIM/NutnR/re2t6a8vmNn27IsQxYr+86/q73D+KT+jzVDUAwRyeTG6srQhgCKJHIkC58HpEwWoYLrFR//j4Bf/ucEQgJBgg/MeY1JdlJ1EkRMGT/97f+Ggoy8rQC/IqUfQesrYlwARMQQsaZF9lnVTDiBNCsQ6amhvKLysK+MN3u9koLZfmRcy3LapfmzfX17Osw827M927M927Np++677/G7n34CgDuhbx/0NkVxTBlt9xqgaMLksiz9Ps2VONezLqUCBVrbtNe7LqhqzEX7x8TIfEPRyE179s0rQMzgnBWUleic7baBAiMlEwPGLDpWN514VsbGcft/pCCgRRZ6oNPqeHtQZ1bOrc103FO+5Z1mULifxyPl21KH+0gOcyyahW4zInIFLtcrUAXYTUtSOlV1oOoGdrmv9UJB3Xul3+jslTSrq5qrmj6tgKo+tNr42VJK1laTNxgoP9FzBlr2mgc6bL35tLoGkACArwkcXN1gq5krilMHrDxgmItGM7OPvLvvi/tjdxx2zbIsGJ1BRkBpr3lg8b3m1+AeQNXnb4yMsHvs530kPz+sGz/vt1mJ31unnqbTiNs8zc1HdQ97DFBDuGX0GIFHVhB6fpX9vZ/1oD/Dg9LAvYOQ//ktzYw58rrR6MK2d5RXARZdJO/rkYymqgog4cEAb+jjaY3KLwJGNdCzOc7J17OTSluTLrLaAwb2bIuGt+/bfmigr7zKDCcgVwpEsVwxJFh64ozt1sssBYrgQDidFuUBChwQNJJ8QyRCitTOjS1n1Fqw3eSMWZYTCAGVA0ph1MIgSkDVsj3Ko2jaL3OTKDRqUd7+PN0FSLTVKoD2Gk9IccV5fcH5HBGWKxgbfv7lI0r9s7v3GdRtUFZlAoFRBcfQaKLfzrDz2zYCcQSxOgnB9jGjHqQg8dGfEq1eEYJF1t9weXsDULGmRUpPlg1bvknmplrE6FUlPXXOGYgR5jAAkzns928Z0QNgvP/uQVIxWnRDySPnyP/82uF59hs89y7DGI3ZZmKMjWPPcpsvRXf0fOv7wIMPZD+5YByvP3+9/Ozbe3O9d0YOPFQ/887DNj5/dmOS3doZwGgOa1Kys0fVWxvL9nUnzIZaI0oZNJW/7Lkmm9u9A0C6Q0eRsYRb3TQDCkhKB8YYm7GfoSAsiQwZCXI+q5zudQ8/b/73JS14eT0hpYDL5YL/9E//CS8vL7jdbrhcLiil4Hw+4/XljForbreLZJepFSl9h/P5DCvrZxkKb7cbAG5jXpYFl8tFjR8CYr8nHxytL//Zuq4gkjNm2za8vLzAyqjkvIFIsr2kZWlZ6/7hH/4BzIwPHz7g5eUFL6czuFTk24YbgJQi1vUEK7VkGUSZuZWcijG1tOpcGW+fP4LAOJ/OWJaEW75KqZ1oOk+VUj8QdlpqQQXwcj679Qu3Zg/WvjMSNZ2k0YlUJSL3WSNa4+fe4G9GEr+PRjrfy+x+L1vEsJd1KovcMettXv+2JnI8t7VDBJVbtISK7kEpVQH93QySknmpch3WSu+3jG3bcjM6kDqi5FKwacalFBMCydkHdFMZMyB+JIScM5YYcFoWAIzL9QYwo2ybyEUkDjNS7nADF/n386c3xMhij6+SbeblfEYIEaWIExCYkWJCjCqzhQxCGs53KI9h41+g+zErnxmm3e+lKqagyoy6ZSnFVDfEpI55ulc5MAK8g0jsGYhUHvCGtt9C3u/zhp0x7beeHXXUB83hh5yeO/d1rxmvnh1Q7V3zZ35df0uzZ87OOMavfbZij32gVM3Aov+qOWfIMvGSFUGNdSZDssiTZKVaiWRN6Vlip5g5F5YiTvXm7Gi8J+izpNtClwBCVIMlO+N+qcKLr9crQiApAVoKTueT6DcxgiiBIUZGOxv6eT/yfP95X++EYe23KRHHMApSRpBQwCxnWqWCUO18D4guCxXUKQgI6iBhjj+hy8b2VltbfWE0WnsdmXb2jMdlWo/DfuYx3zy/3ZPF7vn4KAfZWWbrbL5+XpcjZrf/u73jS9oePvK17fCedwRq39c9Q/+M//jfjUfI/PS1aeXLDVcZzj4YfmjPku+LOgD4d/QxGZ6hPJDlHSn5c1r22XatjW+Ys5oEvS3omAX3rHr0vkrHdGxaVupoD5XXojsM7ckRe040ANTx0uhtvEDXsnuWx9clmyJEtgsBIUiGbLDXY/oZwo0p9vJUpUgmGAKBmPA5ZuQSUF2mrR7mZ30lhzGgvwPA7bKh0hUEwncfXnHdrqg1KE7Y6RCJ9Mm9BCqKOCKKKPcY1zR8aPJjahM60/hoP0o5vZG2IYSGX9uz7nWH/X55HrSn2zD3bH8pJazr2tbEnj2BmVuJaOOxSbP7nZYV67rKetBMPiEEhCWAl4rCYn8Rh2bCkiRzJpeMGAixPRXqPhlavqfuMKNkRQCFV5xPCVtcAH7By+tfgtYFnAKCBggkWmRiTBcLwf4EFIMCMQyJ7bKw6p1sGI7JwTbJFqD9bL9FezrMPNuzPduzPduzaZudM468n2eFiOgeEPfX9MwwXcCzqEJTSCpDowvRrgHEiFtbZhtWZUvf0RA6lYOJRsFYFZzrtjUjuBjKu/Ggg/YzgEUDuGVj9W0GQ0Ww7QYS+86E5+6gM47xUJrW5o0t/b2uxMrO9V4h7SUG/KtcVNBQVml6GGnS4RYBiaZ0EDnhFfMzbFLuDQ7doG809Q5BPTOLvVCfcEf/3r4NeCSCRihYaSXS2so2jlnhUXWB+j4QZV8ioaNmmSilNkL2Wu32kY1hzPhhoMEwpANnpnbJTt3zR8a49wxre83P29EzfQmL997T4IwdIG++94gH7fXrvX7u9dsruK08QesfMCx29OicEQ5wTOhg+e2ty3m83woe7wF8R+8VAMQimjSFvfIKiT42IIobP2budeC98v4+wGfngPzeWV0v0WbfSWSwzUffN4/G4scDu8vtBQPFDJCTzzTrgT4rLWLQKFWMIDEuSMkMkqOBTOyrBbkyKKhjXS4oXEEhIi0LFLkRJz4iccqMERTYpY59HJG3N+YvMTAQaXJc403BosoALhVb3XC73BTw0XssFbOnIQgWPxsaaEF3TjPftlp/Xfvpr4H/6r9jXN42hLCAwiKOg6yOMuY0QyTOTgc9PQLar5crLp8/Y9tuSFEiEEu1shsKktXanHGjIJWobY2hg782d79yzPs89Z7X7a+PcU8923heWTPZdU7p3w2K4iA8P2fvd99+C4Oo9WPun733vTNvD4T3ffKgvDfg++cOEdVk52Vppf/auckVzJJhxc6V+/GLM6A3Elj0uUUg92d2B8m5/IIf3/y3OfJa/3zGtcYnW1+ccwGA25aHMft32+fWQhAnn9ut4nJ5AxFwu91wu91ARDidToiaJUXOuIizOnoQSYkZM7AtS8LptGLbrmCGOrSi8Rq/Dr60yfX3fKL9roD5siyDUTAlyZgDiO5yuVxaJpllWVrmnW3r/Y/RyuB6BxZSEJtBtDZ6WikjcyY4LQtO60mcIzZz7hDHq+LWqTcqNa2gfdYNWvt7ggZePFwjlgXY2WxynxlH5D1dzrd1sGcE7TqOPGfPODq3qg4ZeGeO79e6jcXknVk27fSwcTWdNBdUrogptvkUfdwyyTLO53N3OlBjYggJJahTQhLnlP1SGp3PyJqKXcYmgLno3+aAXBB1LUl/SssAFWJASkuT5aq+JMYFaBlnIBlupj3r+SbrIpn1epPZfNs7H4x2tQbtK7V9OkeY2zMGg+ekc/yWbZYRmfld2YOZG4+UOe7G3C/R5dq70YEFzzftHd5pZubjR3R4773z/bMOOWehaWOcdMZH73KnhOhNvJOJxs44ddIvVTJH9DXncA6GO3vkSW1vElqWlfaZ0i4lc6QETqcV67o0xxzDX/bkwSP5oPMDNwB0fcz4qPSvKg+vum+MIhXijGDUIPeMzpOgvLr1pe7r/n2euqF+5tfzuvL3z9/b77PMZN/t4Qd71xytEY95+GC4MajDziS+65e980ieGWnS+7TXl69pvwZnmGXer31WGw+zZrToWdDkoe3pIz/WtchwDrFG3PFG967RET64OZd3KgZNUOwhuGDHAsEpTO43uosssz/uvgfe0/q6fNR5iZ/b/vgjGjsuQujZVEk2DWsXQgpNxmMGuOS2r5ss4OTvfdlpdL7ZyEpu6hx9uuDP/5uA87/9A/709xm3//PfqCMQu1l8gFuYUy8qtpwRKCFEoAYpG2S8oyq+1qbd9lB159WDtLJMhnd0PM/6tSefHctgdZAx9rJNzbLhIz2try+js8iYVlJz5hVmozGdZi9wjQEpM0vqhNlGrL+7IDNQX/PMFYEYSwpYl4gYgFpuuF0/Y8srCl5QXSEmVicZT01/uoV4wvnlFSktKNsJSzqBYwBHHQf17FFEJP3SctpGLq201cKgTKeRfSgTK+tH6CU0sGu/zAnx2d5vT4eZZ3u2Z3u2Z3s2bZa+0pRmMsFIBbIUrda3GYNE8OKq+fQaQGACtdSWJY1yq4V72mJU8ZLnou81wX0CGU1KZgZqBZfSMnWUWnC7XFBKHoTSEAgRKrxyRa25v5dYMynMDjOjMspsLg1onxvQ3x1Y0KMfQS1dc+0oCYgISd8XLcV7LmAwoindNSid0SRO0v6bg880U0rn/dS+/Qn2Xf97kNvVeO71O3nm6LgUlq4ISAYg8waPKuCXBrJ0oIB7ClaLXPPp9RV5Yu1grVWEbyL1zfGKKk9gk6mnpJkFjHb3Ss4IOHh6KB1V5Dc6hGhKFbe9EIIpohY7Qe0fs0Va23pSYIzNYK+KlQNsWaPUBB/SWuANrHeA0Y6O1RUvU8a6g48uuZYJp4/d+syYDX9GTFOe7t9z3AcDy+0/uP+TdYb7PvS03wOo7PN9Y6Q3/nhQr69rDzT0z0bAa29cA8hMBvYBcNGFng8ORhvmcXe6P2YAe/993wZ+7Sn0R8YbAEhLavu3cpFa2wRxllBds4LBVSLZAQFwX84v7Tk55wbcHgPe8jxZggqA2n+MBuDYGWHPGrGv8ZnGTxqnVl4gRgFf703+J9vVsoTVXgdbHQMZUGMYiUPEtgltwoaSt5bWFSw0aFkAWLiF1IEOSGnFqoBPZcZ2y1hXcTyiwAiRQFRcVq8OHxkt7kdrNAzDPtsDbG2OxeG0goOABxQJuWYFBQlcAy6fGR9/Liib7gd2kKSgSa0vZjbRE174M2k5FihAtdvv3679+LuMf/+3F1xuCblGgCK++zHh+58SznkFIJ8xJxQkMMYMMzIYXct3mWbGVOulZFyvV1wvF2z5hloLblwAdY7JueB6vSHnDTVvDVyqVSJ7O3vtskozWOm8WbriAUt9QMA9fmVGF9uw7pvdh1LbSw+AxAeg99fzJnqEWT64qx927xmX+z39/3ttz9AQQujgXBCDeFv15ABFoAHRVbOV3IGSUz/fM7j4zx/Slfr5OY9hBmfn1p1z7zPh7NHHA7BzqSPP330/AomDRSkZW7RIaz2PK0aZSWUcmV9fXtI7/3R537LP6WTsliu0fps8OhuiPJi/pFXlKGr0sRIAtjdCkOwy5gC0bRvWdcHSMikKmDw6rRsYG7BtV1xvV2zbDSEGFDVAL8uKFBdUBm63ghiSqkg6ZstUIlTChix85rLJ8PVYkwydVXSpIGWmbCyNR4f7bEGNFu1cpbau5HgT54Ko5WzsfLY9YI6xRu9FI2i9IdqX7RVdpTPD2YDp08kPmSWXBRSClFbM3EoyMaM53wQr0UCEGIAIb2SzDD2OBdsutqWkPFNOfL/nWdelrjfb9ExgKigMFNYgDVBz1LDfvQ62L9feGz198zyiy5JjFldvELGACzv7e/kkn/GPWnYngozF/jYnnhCALW+gQEgk8xpjBCJpJiPJQGRZbABqGTsqS9Yj23/yHSGGgLSk5kgse7zg0+dfkLeEgA9grti2K2otWJaoTjRylr69fUKtFefzCcyMnBkhJCzLikARtQbkrHSpUqI5xqXNsRhFA5hG3tc+x7Qv7mdj/I1Ul9HMGHIGVNQi8gSzGm9N11MZj1VmtD1skdxEEWBv3No7vVVH0+XJqiDL310ma7KX0/ug1xC6Q5FfY7McsVcypuMJY8mTgUpETb80J2LCvazwnkOC51f7+t749979/jm2hm1+j43aY/8eyj/GFwD0DH46Sx4cMt4BbntMFkxovKOr4vM5Jte30hMs+JTpnNYTy2AQo5TVgOocFhRABNSa78Z4P3/2/naVux6tT8OZHwiSX2BBdM5jlkGmBjlHg5bqphCbnmAyr5XZQWBXUafrRP3MAAIH4dM89nU2gPqMv318vSyc8f1xvHad8Yf+97ymZrnJ83Iva9n9/h8zt7kyqyLNAAAgAElEQVS1e/f2or93T5Z8hFc8unZvbc9YyPDdO9qcjaeP0d6j56Hq0+R0VeFFVflohLlAk64OgpYIDIqZMmlJLin7Hkx2C0Y/y/qkmT1ghv++huxvye4KSLk8IAaSErsq+8XAiEGyaS1JZKHK0o8CAFwQtKxgUEdMNr44qVsdmQhdKyN3wT0xwZpNaj8lcZdhBxy8/auAZnZjmwRzdiwmrxJCXIdHGv2Dyn69az7jtcnk1LpPzODMKFRAKAgkGadAhFILlu8DXv4CoLXg+vL3uFx/weX/+VfA5w+Dnhb+4j/i9aeK8/kDSgkolfAZf0K+ZIBWUFgavxW7AbfzvaKiaPlG5oBaMiIWMAkfJHVkGZjyEV3bJezG7fe3t2PYs9z+9k90+2wvoMF+ElmR6/HeAC1vJ09AqeKYGKJg67WKLGRlay14rc/TlM+HN9SqZ3kQfOSybZINJhbUWJHigpCC7jVCDIJppSilM+vfLXj7uxMAyUS45Rfc/kAokEz/UoJJRlP0n/WCNQsbKOJ8+iuEuIAqiSPUsgIpAqE7zBCr85qt7ebg089a8o4wJm+1D7rON9L96TDzW7anw8yzPduzPduzPZs2D0IbyNTEEHLRUiqfWRpLDmhZYhoYw5IrROtkCJBUrDayCdwVlTMsWwqcIGhgYxOcCAiQtM3b7YZtu2HbNil3xD3FpwBpGvVVK0otAmKTCa4TUHkHLsH9U8VOQSJS8LXU6R75TQFqlvDCZqT1UZuSXp3J6jmLU5Epo60v+hxvuPSKt713EP7Bw3czIFbrqLjbuOb51w4M4wuOXpKBRVMim5d46IrHCByrcSJ4aIQRotIXtZXnMVqZ7MtNGHZd8gBAA0O4L5mp3RurWnjKQDcT1AlWUoBa5pkGXHFX2vs4RTGxsdYawFyk9mtbF30djSmRrE5zR96YHfjfQJQ2WD/waVx9royGfT748L5Op07KfeBnX/kM1NwSoBhxU1rt75EG4+97gOqR4dEDa+PPPoZZcWKGRt/1Z43PHN9j75fH6PqDgBuyDmzfyn9j3WdVAHfB+IlyB+DYXntkbDm6fu8ec1KzfldYaQoz2Vk0Xo8QZQcSALirpTzzTmqgkkUGAQb8tH0KP//yvZwV04KZxtoNU915SaL2R55ggAZrGvxKLgNS9WvaMsdUqG0XBKDkDRxcVi55KYxPWF9SlBIFKa2IMWHLGZfLm6SWDQVS5ido6cEgANc0p4zumNo/t7U+lqDaMxyM6whAJIQlIKSIECWDwdunDZWvKIUR+CzA95AiWdc4k4JqM3Ta4Ao5z7V/7wGsv7adXjb8q3/zJ2T8DhkJIMkok6tkMqgsDnTcHGcM1FSHT3EJQ1t3brt40JqZcb1e8Pb2pqUTJfK+lgyqrIDRhsvlIgZCNfDZ+pMpawu7/T7vzoMj6htaB1PbJw6I92fU+Mb3+dKvbfsj/4I2Af1HWcXu3/X4bXvGCVv4zJItaDiD/AP18zyl+N+LWPbvszEQ0VBr3n+/5wD3aAxHY9rjwXM7Mlp6Q6N3Bpn/+Xd6+dj4tsltKWkZOpfdEHqmdC8qc4jfz9Ah/Dv0PTTJIcYX92g0gtPBGW66IVK+b3cpOCucrJaKkjOIpNzluoqx4XK54Hq9DNkxJcJTDDHbdsPt9gaujHV9BTjjdDrjfHoBUcLbm2RniesCZiBvGQyGVUIh7VspuZUCJAK4ZgCaIl2zrRD6Oej39zAn6PJ/O+topGVfHNAMOGglpMwxouQehBBCANTZDOjGQqPJ4IgUxjVn8zzPt51tieQ0sawmjZVWBqiCaCwTJlG3zvEN87r3srryymCf9fNBdA7jyl7u0dOumuzd13NVZy7Tb20e+ray9Waf3zsx7a3bwVCD+73XdHLHN/wz2c5CXQO9FFM/K0z/sz1s8zfKGAHX2w1EoaX+37aCZUlYlwUUIrZSsKxrc3yyDDHmzCPligoWkiwxt9sFkVaUKqW6apV1vq4Jy5pwu0lAyMePn8Bc8fJ6Rq1azhIrlvQCooCcCypMD5e+hhBQNZFcCN0hauQFo+w0/30sf8skEvVSujbFMcaGY0iZ4+qP/mHuRA8Kmr0RIOc0087wgUe3VdTWcW+22Khf09Zdvx+Mtgb7nI/j3CsnSO1/wY1hXLcj/Uwf6ucAcL/OB6oOZ8n4/r31/ajN/OQYz2gDu2vj+TJ914Q2vfedLnkx0EvXw70D3+7OcsS9XJc5aPZsPYIfmROq8BbnOAV2147n/Tx38vmxDPNYVunlx6SP5qi3CeQVAyICAhU0sdjOYyMDd4ew/twRcwht34wGbT8u6eu9Q8s8F33eJyVgZ9x7mOCcPdd/N2abC3e0v+9Tnycvf+3xqL32iF/NPO/ROHc/NwXYXXf/rk7DO7lZANa+zG1fZZeRI0YEG596nLGeUUGxia7X69uCvU/eZKUEAXHGCTyAi71f2pcQSJ4RbC5qG2tQR68YCEXnppKW/2HBJEw+o2FcI0UAtHF0HjrTzf1OkGeSYYv+BoK5FfUH1eF+YS9RdF/tE1N37i5F6JrU4bVKGhbR/Z3c5uUP+7udWUZGk5FqAYPAgVFDRQkVVApKZbxdCC+niJcfFqTzn8Af/wm3P/7kHGZ0Ln/4PV7+dcEPPwBbDni7FPz+959QtoAlrVouTzPAwQInpS8pMIoGt4h8IE7kKVTkkhWdoNbjvio9VuH4TeOeDI+Nz3QAbG/LM02naFjTIL+Nre9JoAUM8PR9gGYKg22h/rP1iXXcpclrJm93HmR8ltt6IQpgqrjebihMEHcnwukkTolCZwC1Yo0VAQVUC8o/Lrj8L8lQPGx0woaKIqghCupUikn3rjljqtNyXH+HkAiRWIKCQxRchoMGutrqUoc5sJZJ9DKJyDy1BZwxWklVnc85QJTI6HE3Jc/2je3pMPNsz/Zsz/Zsz6bNi+gGMns104OeloYdEI/163ZFzuIssKwrYogIoQNKvZZzR3RE4c5d4FTFpJcL4dEZBox823C9fsLlekHeejphqCBLCMhZMn+UWpFLRaVebmpWGPcE3j2B2dIKH4EQROKNjcodLGh0EyrGaDXkYxPqKndnlj6WLjAL+Cljs/TJcl3ALKNTU5o6eOIB6/fakTJemsLowQ9SLYg0ApDb3PbofYs29nRXRZG71zyzRFXZvJfWDxHYTcEdgAY43YMxKCJ7Y7qfs/EGD97I3/K7GE+9YwQcaGs7pjZgkUgUoDkltIytg4SWBpa5A6vioNNpbM/r1+wrZTNI8miu957hQQ7/TK90zGBUV0p2AJQJLNo11mCMfPd99uvX1q4ZjcZ+NioMz93ryxEdZkOEfdcBmnvgy/4eATZua3Tv3e/1aeY/R9/PoP/edXv8ybI9jYCJB065/d3oC8LlcmnvM4cZiXofU9AbDSuL8bFybQCvAW1j6ZNxvw2Hz9QsBa2Nx55hhgr5XHusSvvcPw/aEo083cquCIA3rgvpM4FZDDsxBKS4dKBPx71q1gXWTFkUGDlXxLBIxCgs/SzLGdEAkhEss7kQkLGXr/JzOa8P42chADERYiK8vJ7AvOHjp8/ItxsWWvES/xxXOsFyCIUGHKGdWRIozZNZWsszUXeaecd28KtbzhWf3m44fThhjd+BaUFlzSzA1o8Adk6QUIOZGKYe99B4T865GbWlLIWuqya3SOaJrAbkEAjEPhXy/pxY2+MbR98dtXne6WijAHe8geg+Ynh+7iOA/etal5mO+vabNn68DmfDqBlqDNibM7bslXEwWbe/8l5WHMpu7Fx3dB7uj+n++lmGmYFd67vxxtnI48/WuZ8+Y5jd53mn3WPf11pxuVxB1LMfJo4a3c8opYPRTe7noIDxmEHSZ7SxMcz0vTtf6jgmk3E9PWOMDTRnNbDYM4wHM2vOp8rIXICqjjAhtrIwORdsm2Sfen19HfqSUgQBAtYzEFPCklac1he8vr5iWVbkrWLbMm434S21cHOi8sHrvv/9nBN+PGZxuS95IlnjumPW/E9F9KHZHAM9a8ntdtPsOqsYZ2NsjvI2jxbduld+pvFD7uvF+ubnKmkZH6/zGeAtDotVyjVAjECwcVTLnCHZLK3fs26zdzY2vaGMjinCrMQhptPVeHoXSEZZuP/edZj5DDd5fnSW6ftJ1uZRf/f2wF6WKHNYEecRtPd6mSeYs0mtMqf6mJQSYoojz6s2r/IMySQDnE4nrOsqsh0Y0elq5jCzLEs7R21spWSkFLGuC9Z1QSkFOW/o+p5kvhFHMXVMQtTsABEpLQghyXsIer3Jcl3/JRKjaABQedRJPN3fO3/26F5rnfRuP/f7Dob2rLt3E4ByfGIdyQNzv/d02rt73PfWl/m+cU16p6D9587Pa/ezvHHgOzu6z96a9meLH9+RDnTH3/SzVlbsC2Wqo3HN7+Pp7/fao2v25tH4UUCnyab6ld0TQ9Jsa4oFoOp+TgiAYFy1lwXyz97TBY/ou9fHHkCn6FrwzlQm7+nf1QIfCsRLU/Vqyy5jLBc2jx5L0KwSBBtk64/96zrfl/Xd+nj0nXze+7/3vEfOzV/DW6wve7Kbn6vdM3V655e0I3n/8P7p42Madx54NI5H5ZplLQVQiKhFdKt7bNbOaJUdh47d9/M9TASAZJNs+pM+SOWPpseROJks6wqwyhyalbedp2GHWIaDsTm6dExlPueJ+nof6aJn/yB76B5xb7T9oiz3fuXq8/sYAWK6mye71pxBLEDQQ4dCz9peKnhBEpcJloDUGAO2TbTxJRFiOOO0/IDbdwGRpeRVrWIXiB8+YF0ZgU4oOePydkPJIj9VLshlQwoJUHy88YVALSu88fxSJNC2FqU4C1bcs0IrSkFeb9Zr9HeTVW2f2TcAt/Via1OCn2on/I5Mvae3NRkcox4uf3d50GRna3JvuMuGbzww54yUUntHjFFlacWMlPcyCFwLatkkQ1+oiFGcb9ZlQbQp/rTilm/guqH8ckIFI5NkPruhYkOR7DIAClygAQCEitMPN/lbt1VYCRxOCMuCJUowRSmMUKUPqH0dczV9DK1MuJDY6EwtK1mXwX0bHcrgciE/22/Tng4zz/Zsz/Zsz/Zs2gKJt31ThuBAg1nhYBV0NNLk9//0z7hcLjifz/j+hx/w4fU7AIwY5Lk5S5pvDzjVWsBFnCbQFIogHv+VwUUiveVzINeMt7dP+Pz2EaVWpCWqM4MaTlWgjElSl8dECEtELjQIxmYk9WDrvSIraaatGVA8gzteYa5VhT5nnDVKXi5XfP78hpSSS3cN5FzAnJsRrAne1MFmUx5yFueiqKkTm1rklFsDqS2rDQAFKvMAnPmf9owjRwvOHeCQiFQRRuUZolAy2IG39rlk9inTY1sNeSKNtBXHFC5s0JEK/h2UBqwEEJw+ahGZTtDeafcABOvzDNy+j4Ddu6//7YGDrth2pcmeb8pobU5Adr0OoCni8lxTmqTcx5EByejS6dPTO4/r7h5E2AcVTP3B0J/xvXM0l147KS92zwya+L3nAbD5PjPGeEVV9sC9w8zemObfmTvYvQdo29zP4HHVfpgBQZ8IAyHkL2qKXeOVwzq5r2O/B5jN9JvBs719e7RX5/E3Wk9GNfvdz4dXyuV7tAh345feWWbuMyBnQik2hnH9BoJGI3uwQCN8XK3lPZoYgDy/0wNRfY6AlJaWLcpqpWMy6MfYzzrjZeYY4d9r6xA6l5Vt7vtByfrF9XZBSgHrKuUGQEHK9rhSQQxu5UbMebAbTY2XyFiY+zrygLifSwFbCCFKyQpQRkrAuiSczy/4+e9X/Mf/cALwvUTkOUpFW7vowFxhmSu3O2X+tHSTxHahRRn9S7RlPeP7H/8K13LGVhKAiAozANtkk+P7CrACKks8AkwsO0zFtkkJJgFySbILESGzppyvDAoBp9NJ1iAXt+aoyQQDMOfWz7xP/O9fYlwZryHDjw6vn/9+D2B/BDR/iYHoa+75UrD/t3zXHb99D1jfmSMvI5pxbs/45d89Gz9GXvWADnqe+PuMT3vHikeRz/OY/Zk898tAVz9Wv3aIaJAdYwxarojVkWzTkmVXtFry1B0szUG8Ftmhy5LaOWLjMj7ro+qtP21/aX+MB+45r9s1KUbtswD5kYLw9tutncMgSDkAFceWJQIV+Pz5M7Yt4/e//0PjuT/88APO55dGH5GxLeoTWJYTzqcTzuczfvjhRzAzfv75T/j55z8hbwXbJjrSspzw4btXxBhxvX52cxt1HGWYC2a0MiPmMFyK0To05xNzNOkOnm4eHX1mHYiZ8fHjR5RScD6f8fr6ilortm0TyNnx2RAiti279dMzMZZihkyht3eQMdlhby/UKunnofdI1tAbvvv+A0KKyLngljMQCRTWnrmRMTzHy0t+zwy8zVmd/Lqx+Y+JMEd2DyVA1UET4CbvEZna2k9Pv2dGHeG+z8N+1aki/5nbg/M4jR/0vS5zZHJXMxhpBHO0Mk06Z7VW1E3u7zwAOJ/PLevQ7bbh9fUVLy+vAIDrtoFrxe3m1x8h5w3LkgBUrGtSWbG2zExEhNvt1hxQay2a0angdtvwy59+QYziVAME3G5XvL5+h+V0BkLSChQMhIAiVkylbUBKASH28mkLjTLSEd39XvAytcl7fv0YD/JyR//Z59E7H+2eqxVgqnfr9EhG8M3L/3tj27mh9bPfu/voNpYmx+zITXvnXRvjdPneeAZZ1X0+G8vnM3KmlX023zPrB1/TdmUF9F099/lb5Zh5nvzflWU/NFk0BMSYEENA1qwK/b0dL2A3x7MD6p48an9/qVzYaA6AWDM3kukvETHaunIlFqvJWvqvSsZNk7HR8IXajN2gnm0E7B0av6z5/s789fFYj9/RA3VG/HCPPsDx3rXms3k90g3s770SL0eZbPw1e7qFv2eXHjR+fuSs0//199t1exl3dvfzzBarw/fkqfpsQBxkPc5GUorJjfW9xswoLjONDbidhyw63rIkUFD8sgAgQrKzxY2V2QUQhrFv9Z3uGO3kmdRKczZvMR9I5M8b5UmNr+ue0zeDOELFCM3MQkia4bay4aQF0NLFnaaqC+ubrLxnnwe3pwGopwxACUQJISRsuUr5wRLw8nLGX/7lj/jpzxlplWCrz58/4bsfvgfRv0Xlio+/fMbPf/wDPn16w+26IaYVaQXOawIXk2+09B9JyUfR03uwYYxBHNE18wqImhOMm3ghl9+zUNIxK54jP+0zcbBnlf01i7pSDcEHOO47y+7rUUpXIynQKizOa97KZQkrFUxjT8fxsr59ZgJkl48BJkZKwHIirKeIZQGIP6PWDduVQSmA/vkH/PI//bmrDkaKpjAyCjIKNlTklhm/ywgVQDpn/M1//38jc8XlLeB2A2pdgeW/kHUSAsA+iA7ydOunw5/bzzrx8MnW4WkZk+pPdr3OM/M+RvpsX9+eDjPP9mzP9mzP9mxTMxCQneR1ZxCAAQuiFFPoKZ4lMlFKXVQyhUiU5lKksDdzRq3ybwY+SyHkUrBtt5ZFBgRw2ZDzBgQBwYlIAvdVuDKAsGObDK6arrmOAMx7jaZrZ6BtD0DqabGdgAeG1BbXGqFB/hGCRp3W3VIuDDhQ1GrFdzDQnAjG9x+Dbb32af/M/36oeDLAkVsfqc3nZIiCXzfyvZSBkSxDXZMxYE4+q13GBaBgLpuTQQeH9/rYlIU9C+LeUNo6MwMYmhK9p5T4d3tDAYCWgcCvext7p48CW6VKJgSnQNn+kiF4IwTaZ7NThAdoZqMEMGZmGsc0gyV+rLJuiQyQ01SZrW/dEPA1bW897YGg85rcMygc1aJ91Cf7bjYszj/99ba+mSWahNDTuTZcmA2s4KFf3qg6K8/y93EEirW99X20r79kPkbAU+Nrdmhh75pBMsmm0fsqkcBltz82llpry8ojUVq1r+NADYQE+voKWmLnPfByr4lT4Dy3mNZyo4h7Lw1ghWUBs3tkHXR6xBjBtYojJ2x3C/hLgcCFFayQdRMVJIhR0s/2s8HPKRtuA2ZuIJEAIWJcMtr6n37++u8K8EQrRVQRKCGtC05r1DNI2G6rZQ4SJxgIP5a7dK0wa7pdKWvFIE1RLe/6l4YiSql4u2Yx2gYpaWVmS3+aAJ2b0YP141sHwHtZJVbQlJgb/45qFGCu2KBGRs0iNAPmXwLcWvtSkNf66j51o/2ycdrPbzXyfE37ChL8f97MCPaICns8ZpaTHkXPzgbQvbMAeK8k072j5NyXI3ntvbNi5iO+L/bM5hzo7r0fUy8j2eWkeCePNh1C+SijtvNjdozx0ePzevV0N+cQe47Jtd6psRZzVujys10DQLJRNDnIgOoIhO7kGTTTjMl25ixicpH0M2BdVqQUEFNCrazOMFdcLhdc3i5tPs2B06J4iWLTfewMHOUuwM4uu4YUsF6WpTnLeHp7w15zrk+SbUec/dAMPEYvy6bjHZdKKUjL4voj709pgedBVoLLlyryJZlm+cLztDZfJSNnca4fHXIIFALWJQCIKMP6CK1k1p78uCdnDnvBbb2ui0zyB8M9qwcnADRd6+VkGyu1PeL3+mxw3WtHbOFOZiRzOheHJQBImhWol++6dyyoVcoomO7inaGZGcuyIISoDmwFp9MZy7Lgdruh6Jpa0jLMk635bdva+ywrW0qWTVUy4Nk6C2p8yrmIo53ykEABgaKUuqQk529wc6VB3vLegGVZdV1aYEK9o9t7563XpZZl2ZmTvXNUdKb++70+fSe34T5rl1+v7/XzoZ7+zj3y03/e5c6m44Uv64d/NiA8xfwbjtb3Hl4y6tX3eu2gu9C9w6nfT4/O5S9tA31t7lx/j/CTL20e4xqe087AMVjE5qwWk124GQqLPced3/dZNe/7+CVr6Fi+8NmQVRqnEU8xPikGYnGCqTo2z/d7MIXoTGDS0iQdOZvpNtDsK/r9re1IH/fvm/fz1z5/1seP5uzwLPv/uc1reo/v2e97WIeXWbz+3rQ8gin0spYctrWX2XG/j5I5tJQiZXYpiDbLFUTilFaYkbcNIEJiqL4s55Gd4yF2Z2Rbn8ya+c7GE96bky4/mSjy/gj0vIenqdNmlClYfhpWfpnzpqWLGKCOU0pmOcvUUhrt+/z4eatgzSRJFLRElXyWtQchCb5RmJAz43ItiEmCXCgELOsLAJEh8pZxuWy4XjOYJet6IMmCwuAmm3eHGcBwpdzKhEr2OpM9ACDXsru+BsrP+1mz59BARqFjiPLsqFhVqVllqvsycHvY2T0+MExVd7gyGbtawCN18rtnHO2ruR/m5G1laaVUV0WtG0oWxydgQwpAzTdcbhXhQrAULhYExSSllzLV5tCiGp2jn70beLtsQIpATFhPC0AnMIfmyFpZna7IBcy6sezxUk9TCUbmwdbTaWq2kHv54Nl+m/Z0mHm2Z3u2Z3u2Z9OW8w3b7boP/jjhowk3TaBjfHh5wWmR9MnXy2csSdO0o4JQQFwBZNQiUaklbxpRuA1KgBmyTJBn5qZA17qBeRMhOhCKAmTNK1mFaSYt69PA53sw5ZESTuTB63tF+EhJYycVe8FyfmfOBaQZZEopLRPMcJ0zrEof5ijK0Wjh7zXwyATGllbXZSyZFdb5OZ0YQCRx8GmBDZpBRu6jJtyiyndkCl6QyQhB55Dsu9bZ/k65QJTIqkpZe06QSEmnK7Iab92td44zd4BlU8hDo6l3VjoCIO6imbkrMbWIKdkUOaFtUaNI18RYQSLBmJzjDXeQvAOw9vm98e09INI+2xuTV76G9zQqjqBHp9v9mt8Dp7ySuAc2+Wfv3eNp7YF+i1yXvgosYECDGQba8xq4YAPz5a06TR71gUjSYBug16bR7Uujl5XnAsbSA775yDJP9xkUnPfxnZFkovVM2/lvb5TcG6e/zqcA90ZUxSx21s29YdPoEkMCyMrJdUDB3jU7HDJXtLTdD/Zgnc6gOdPD3pq/59XmdhFgYT4yFbbWrAsSAWNAdq2khibAfN+qvED4FQEpRSwpSYQXVywpSupgSKkAM04wDDTw69L6rBm7uEc7z1kV5nlo81gEVDotCeuSsK4RS2Ksi+4addyU0VuKZQXtuP9umA0ZtVgdZB5kAfqtGyOA6YS0fkCpCyo7oyVVx+n1HPC80/1/v1Gjry8hIV/JvARdCJzFgbO4snx35yf6Pn13XF8AeB8Zl2xUHjh9ZCR4eK5/QTu6b16D/XoAePyuvWc+6v+39n3vbIJ274hf7vXxS87bPb64axj7sp43vnN0Bhy940v6Pn/mwfL5/J7PDeOFckYIoFy1rKZ8rv2qwtP7emgIcDtn/JlwdEYdZUUEMDiMDJnqakVFjwyXTFhozi8mc2c770JAChEV99kngdG5aZTHNNJes9dstw033vCP//iPuF5vuF5vSEvSMzAgRXOGFgcT6XsazuBxPu95gH1vWTvM4NEzd45lK5ZlkfnB6BjlAWV7v88CE0NoxoNxr88/u7zAyoPFZ+mePxzpUMzcwHpx1kAbl0U+txOLLOtgHJ7hnzk7EfUOuIySbVXo2iRbj+yMIrbmVPdR3WQ+V7rcbx/0aHlPa59BaV5T8xhmud+uG3UQc+DUYIqQWlmaqiUkvDNZjLFl8QHLXrU5t+fHICU3a+3lfz0viDHi9HLC9XaDlSUDLCvTBiJgXU9gLpqFhnA+n7EkcTr1e9eeG0PC+RyR86bZByMoJJxOL2CSqHmwrgOCOAiAWpbVGCMoKP0Dhgx6RzqL39vGh7yOfFT2ZdRh+lrYk41n3m0t0PH5safrHel3sxyxf9Zb1g6ljxuSdZ/UDYNA7cOjM+XxWr3v63zfnl66p48MNFDj7/zMWbzbm1v/2aMz03/n+XBDlh7IWEd02Wt760E/UGcqwNOxVvEOE3lAFTG4oCyiJq8erbe5j3tra+++e34DdGNs11fITKlsjvp6sekWAZIFUt9bSwHXOgRg9Xu462Et0wIP807NqCkAACAASURBVPhIjjrq/3sy956s4z+f18X87+hZ8/v2ePoe79hzGrPvjsY1v+uRnPql8vaeLKhXwssndt1e1j//3dxXCpbxzHQryxympbDVkcr4mO5sAN35w+g1r+WemZBQa0HernoW6j7nnrlRgmEYxFWwRpUBDFuan+0ziYmzl9HPO/x12WAcP/f9asE3JHub21ZTR4qJl7cHg7r2zvoudZhhy+rElsHPOeCJxypE98Wwro/WBKEiUG29Ys4oBag1AFWz6PICRM1ww1lK78QCeruBIWP/9Dmj5A15y3i7vKFsDC7iqJ60VCSrbiEln4JE25LvZ8e821pRXDg0RzsnjDH6/BDafAblWqgSMEl2j8oaBCCq7gDNXs/osr7Jhj3b5FjC1uZ7j5cY/t33Vu/uvN+PzkXAl24dz1PBp1Q/UDoxKkrOIFxxurzi9R/+S3AAtpqRuSBfVzCK4FT6W1WHmeLQFAYjpIyf/uZ/R4kRmRdQWHH+cML59c+AsKCWhMoRhAXMJkeqhMEsZc4Ce7jmjrcbXc0xjYdr78uwl6nMZcvs/sww85u1p8PMsz3bsz3bsz2btrxt2K6XJmwB+0Y6rwSZkHNeF5QUcLvdcLvdcL18dpHyFbVmXG835G1DLlnLLRWU7TYocjkXTXXOqmxYNgIGU2mCL0CaZhNd04CI9dXQIEE73gVX9pRP4NhD+T1l9biJgGwRgQY0ecWcDdkiU85UWXSKtI/Q2QOzPCC512Yl89G1HkD2bgpQ0FmyonQvfXNYAEQhAqgJ8Cbgai8aAORehkgMCtymz6AZ7ywD/7e/ef7kAGyUn3CG61Exme/rCrIpN91RzGqvesGe2ZQ7aERvsCsAVfwDqfG64d89Ukve0EsQzQDsDNb0/SP7pTtxWF/3aMXud/e5KoejknJPXVunPUMQHRoCjowAe0acni2nG8NCSK0fbT+T+zn0LnTFecfA00a6A+rc08iMLH4cqjo6mvufR22M9IU+p8+fn0sDkebvjsBl//cReC++WuO9/h2+j5YlDETq/HFvZDgC/fp8dkBUgKpuyDOno8YJ2CKYIu5XWm8eLJR+St3mTkm35oFh2hsdG88JfT25dTLyuM4rt6yAcYiSLcrvFUg2tSUlYF3BdQNQsaYV1y1L1LPREej7U88vc2Op3GkEHjM+HM3r0CpAHNR4toA543L5jMtbBeE7l3ytO850ijUqIyjA4VunsuvD4Uz9+kaUENIZiCehewPUx16Ncze24/51ELxHrXXH4E5Xnd0qgBOg6x/3jl97oNYjI8uj9sioY31/78y6B7j325fJLV943zuPOnrXI/nj17Q73okO/D2i4ZFh5j1aPQI7/Tn3OPLt3ohytMb2zrD3AFff9mTYma/MdBJnD3TeROK4LvvInE1IIxkLYohdiJvOjfnd8++zg7f/d5QJB2AQSx8BoJKAs43XMQNVeAURaQQxUNRJ2zKu1NrXSAhjtCMRqZN7RS6b6iwC9r+9/dwyzazr2s5TIaBGSWr0suk2rZyRyjJEXq4wWWzMKOjPwWVZWtlVc0ha11XGwdwyiXgaWwYQD1Y3GoagPix+HUD72Gnes+KoIYP7PXv6ov+8zaPqB2YAkwwoWY9glQFZTUiTEWJv7ew12/tdJJa/qzOGmDzbXHSc/Gz/bF6884dcYpHddh6Z405fN+85Yey1PR7lvzP9McWlZTACRH/u8ovqaIGAyqhcwFxAzhG3lNLWPTNLJHjOOJ3O+kwgxIikql3OG5h7Vs2cN5SS8fL6gnW1tbhhWRYsi0azW6JYsqhw0n2SEALr+xfEEBFCwXp6QS6W+Y+bRBKImqOMZWwSvlVBdd8h0PO0Pd7r9eG7Mgc4Wl/35/1Rm+Vjrw8dyfH+3qPP5z123w/bk8ZQ3Dj88vU6uUnS05CP9pitwaPr5/06l6XZ0x88XZozz9wHgjhi0Pi+2al+HvAjXWrmTd5hZn7eI7nra2QZ0YPkgPJZz0qxXI9mvDe+6+dH5NUyZVA7fM/OWvKf+fmYxwkQqDkt+DGrIXTWtf07AKQQG5+VLKRZzqTGVytK1nFQRIzr3dr42nZ0r18DlsVz/s7TxNPhPZzj6H17343ypuijtco5fqT32X1fKrfPMu0hLYc5HO999JmXG/waOrqnyVxNlfOG8iLBdUFKC9cKlLLJfUFKe5IruWey9LyXvWNqrVA9T8oGRgogHnW36ozwrP1oGczdWreSQH3uAZ/ZomHT7RZ1wm3BjjMx+082TKDqITvjcvrCfovuR5U9GsLIXQYxJzwLeiolg4vqH9Tpd6RL2JuDlmFrsk/NqKRldqpkaakpIpaowaCEEAOKZsxalxU5F7muVA2SlR7HQIgUBHOoGdVkeKrg4PvUy0VxW6s2Tsk436ku/xMcRSU6PdosYzLpd5Zptzqa2XlZc250MhlDUTDNmlXv9AJPv3Fdutlszwztb+P7nb/7M/lYLrg/f+RZzB2jThGgUADegE8vOP3dX+OGCqKKioKM2lxjJKOwOs2AUYhb2WsCQKniz/7d74HTB1T6HiER1lNASn8GLgEFks2fmVCyPIVaBhgJpqjTWEY+W12JV55oM9NB9tSebibZRp8OM79VezrMPNuzPduzPduzaasKugJoQuks8JEK3xRCA5sBcdKQ6E1Jh/7x4y9gLioMSQTqlrN8z5BotpQATk1gKqWgqPExxDm6gRFDBCOogsOAgs4N8GQBoy16v4Od1vcvUzLn6z1QD3Tvbn8d67sfPctHJnSBGi0Vr1deJCWkOQ0IXb2waI40e++waEI/Bi/c2+82jhkU8E0EbxNZZ8cpURa9QmgkZmYUi6ZkqzEq68g7IdwTihHDvsFqANXGm+4RPkcTu9dHfwBWT/veiDODDN15g8FNoZW0/URB16oI+1arllsZKk0t6hyfdDRt3XSQzylZtA9w2d9zBF1Xzrqzgj6x6Rvj/I3AaFMy0WC6YS735sLviZlmPnr1aF78GPaiqvrYbB0SwL1fM6Ax/g6Ic9JYPuwxCG7P6EC9zR83o5W90yLru+IugMU4Rk+vmX7Afq1vZm57cwY0/H7eA21nHtO+H7IXcYuKsevM6EaduB1smCn0zrz2CO0RcG3GCPLAjui18shO80fPd1QEzPHDAz7o66d9YucBa4YiXUv9JlknvVSBGUo7yAvSFM1kGY8URII4jsVIWFIUQKhICcIYg6yRCtnTYJiTYalliOT2YwwhQrCo0djzCPhe4orz+oJTOgGFcbl8wsdP/4g//REg/h4EauWYvu4kHCn+L9nOrxlxAc7fnRDSB2xFHJLQotys+bnTH7YfAElFfPAOW5fzeV603AvsjNRsFEb3EAIiRU1zzA2U9UDzo7P0a9qRUUO/Ha5936jwuC/fIhftns/f+J73jDlH7T0a7wL+8sVw//zuGfj073lkvPD3HxlJ3msCcIfGi71xZo5k9O/0DiSeX8xtNijOhpk9o4df07PsZmOt6iAjfD62zxhQp0tNy70jQ890st8t86KXWa3/5hwSUxJQv40DzWFedAJNx1+rlNFsWbt6hppSWDNoBsRIDWf1tM/ZShGKXB6CRNTmrSAXM7ZHhFARo88CY6X1ukMPMzQq0mQJkxs6MDzTxfQo6485OJhjzKdPn/Dx40fUWtvnzIxlSQguI42tgX1Qf5QPR0O1OUtZphwzoFj/hOZzycYjGbaNI5DOnwDd23bDdruJDLmoc2KhFvnNbIa1e+eZWRYe9rHcLb8HGR9Xycpm+leXn8V0EDRbpsmefcx9vP1f60Vbe3c63eA0/XV8YR5b0Aj4YI4mMem6sDGYjihm/1I2bPmGnG+oVZx7U4pqlOwOM29vF1wuV8QY8eHDayt3lCCGxU+fPqpul3G9VpUdE2IK+O7Dd4gx4PPnzwiBsJ5WVC4Iteukoz5le5uxriektCi9xemOQtDKymr4CzKmGKOUlSBCrZLBLzBhT1oVPlQH+o17iluU+OyItqcr2PPkmeP8zO+dG0F0xFlGmPfLzH/vjWL3cv98D4DBoUSusedZb4anovEfuqfjozZoYDs69JfQdB7Dezq56DTQ9XJPv/meQbee+mtr8E7WppF+R3350vZozxPQgmssu5ZgFOqYRrHhJzKBmt1AHQyZGefzedAb3ytJsdefPZ7aeyipnGYdV8zOXneTn5LdgaXESkxN75OAOHXcU55bS0beNpTKWNIKotRkjT2c4Wvpuze+LqcdX7/Hu/fW8B5/mb/b3aNuX3g5B7gvM7Z7rj2QT4/W67foJvM7jz6f+zKPTy+W/TVhlMxS8tjKnFMIuG2bYpULYux6vGEYTQdzNB5pYM+XDGpS/qfz7lor6pZRGLC8pbVWIEZQtMBDP88DVXRs7u8Q3Dovjd/39QstUyj4o8SCdMc4DgSqHYPpNPK6C7WwMOcdou+SDE5gdeKtVbKto2DLm/xOc4aeAsvc1+fTRqRlmNSB2o4OCtAs7wWlEjhXBCoI6roTl4DKRXkUI29F7mVoVu6ozjLqcFeKyO0kfEbOWb/Whb8Ir7OMlpAsPVUyhbc95tffNGlcLXhJ9xiJvBfaulR7RenydowJll2GWZxrBlwIwJytb9wn9/wC6A4zJt/c649Hzp/355z8CwCpzMxyNqYYcToR4u2EctmAS8KGio0YGypuKNioO8sAUMT0nkeIihKQ0k9YXv8Caf0dQlyRt4x8k5KqvcS14nogMNVWarO2mpp9jkyWlkzOXa8QmhCIelndHnRnHYLeZzyTUHlFDBFlcoZ8tm9vT4eZZ3u2Z3u2Z3s2bU3gnoC+8ZpRSAMAroQrrrhc3zQVc8Db22ecTguYK27bDbUWAcRUmci5NIMUs3ie55IbeGfAlEVBAgBTFM9u9iVbTFFwJRNozF7Brr6p/XwPTCDcg1cdNN038BzroZ2G3tBt15vtoIGhISAm+V0iQSXKwqehbw4EbkyzA4KlofdzeS9kPzLukBNsPXChhhMCLDV9CN1pxoTdGJcdQf8BndjqeNe7CGIb3z7wQE2RHB+3b9wyJZoIqNyFal/+xBRemR8z7kg9FkLUsTOYCyrnZuBiNuG9A+dVQSBQaIBIzreuWLAY0VNMkCgaGkpFHWWY8FkORLFzBjOPczWFX9ezm1ejy0iv+4jkfRCogzt762m+92jf2Jr319j3kvp9kRSyFcAE2PRB7v3Nba7nPj5upLTq2ZyMz3SAxNdhr+37Zqhz7zsCqPY+n8F8e459duRYZL/HyTjW97ZFt+/3Zc8Bh+WLtpTmiJrZ0Cr32jvRwAciy6oivGKse//lUSBzRgH5ef9Z60fzpJjBCyvH1NcJ+J6HtIwJYDAF5AJsuYBClch4O0tYopG4EghVwd8Lat6w1YqMOLh62FgEtOrzZv+sBNkvf/qEbbu6z4+N20QBKZ2wpBeEkHC7iePqkiKWZKNuFJEV3iJGe2Oy2K1jUJVxH434W7W/+a//iB//GgjLT0BYAUQw38DIIJsn7TtALR3z17V7B1hmBlKS2uu14tOnT7hdLmKYr6VF3xvPG/apo8e3gNF3vTvgk21FT+DalxkKfnW3hv7tvpPwTati5ld77zvqx6NnvvfO+fc9WdePdTYAeHnt6Lz76sZimPayx6O+enl27t/sQLM3TjtT9s+Mmcd0Q4XJLWa8Biputw3btiElaNaLJIZ8FrnInm2yvX/3TK+9PqeUsCwiU5qxhEKYHP0rar21c4VUXiMVPMUBgICKNo6UEipB5c4okZEG6uq/Ja0Qg05FzgWXyxUmB8s7ZA7Wdb2jLZpzNHppt7KgZf5QGodIg2wmc6hyanPoiTidTu38MNl0WRa8vr5iUwOT/UTu+oCfRztL7DlDthlIhDC1zF7CdgNZqvderpBI+ixLjbszauv/WDbhTgYrGaw0tYCLQGKUuN1uqMxY0rk9yyLMbX/M69W3UV5AC/AQHden0686lyY7md4XG0Pj9tMbjLscY7KmNdFjRl3H67VfyxvmPVJ1DqJ7p+zHLpPWpvf2MsfMjJQiXs4nLOsZ2ya6y+l0wno64eef/4QYI3788ce2lmsVHf6quv3LS//c+pMzg1Fw2zbksmE9LXh5OUm2BDNWhjA6ZQMgSjidEgLFFowQU0LJLEZL3R8gFieZYBlm1DkOAUHPwwoxdM38cjaoHlB4yLLjz+BZF5I1YvM+8s5Zrxn+hmZKcnM589hZt52xh6PzcU8nopZF0c7/e2O6e0r//ivOYP+2L9Gt/P735fnm5jONzvTd0zNnfWnv7Da5b9adjA94fboyI6Q4OA2OpVj2A0beG/tuUxmyFIn679hOz7Iq3Xd4iD/jKbZxHGfYmV95vF79Hm0/IQ6hVmLDdUNpygrDdD3PzkXrhjmjB1Dbyz27GiNGutNv9sbxNTLiXvsyDKA/15+XRzr7ns5/pyfsyDRE3bnWsl0uy9Jwu8Nzc6LDzNuO5MRv1U++lF7zPX7ftMwvmjGJiAAy3LboeijYNjm7LGhQnCUKSpHzgigNz5MygiN+0eWbzqtjiogAsjl/2HqvGSEuOJ9OCGlBKaxBfhYU6nACeYO+537MMl9yiZwnsclvttZ7Zt8iWVRCBMAITbbQB7MEHZqziDIBABWBK6i6fRzU8UQx81pFjmKuzWHtfD6jApLhnU2mjojxpK/zfE15I7NkZFRIMcSIqHoypST9s5KVqgCWUoCqOUoIksWkZvHE0Iw/tRQkc4gjltJIDLCdksM6hwYXbZLpVWX1GIM6PDOWuLa539uLTW6qHcMjDZCSjDfssLOqdojUcJfexEHHO1jeXzO3PUe5vq46D1VMY2dd7e0/zw9MV1jWF8lqXDOoSmYX5oLlf/0bnH//ZwCgzjIFm2aX2WSmUKe07Xs7vgIo+A6n8CNqOeF6ya2qQM5ZSpsREENoAQ8WpMaaWVDwtHveNcrFbg3W2jIjzqWxAagDppyRIRCiyqm32/XBnDzb17Snw8yzPduzPduzPZu26+WCT7/8AjOuAh1oMOi0CZumlFDAtgnwkTVKpNYCLozrRZRryZBScX17a2kagW5YhT1bQSsRuiRtZ+jeJKL41ApwRQW3qDKC1BxlEqVBIvprAxVMcW9Kh+Bv8liocbA6EyCzGg47YAy7DmZX9eBXoxa8cwKZdUu/K+og1J4BMx4ooOvSFZdcxRBbKogSljXBDPci2AdsN4uyDS0aEiDEQOIhXwVjIQRwFRA8hgBwQYVk7LE+iBCLMYuhB5kNUNNxVwgdGdwiM5p1oa0PMTabcmEKXwOtQlcOWEFRxIiAKEoYGYync1Y7rNcE5irvkohD6ys6Uk1QL3e2RdbBg2DzJd/VYfwEDgKYFTUsVxBQK8iM/S3LiMxpWqKSiBHCgmVZYGnmiRklbyhbxpY3wBxkFPBq66hk5ALEqHPOAuB3JVvxYwq6D/taI00w2uaLe/pLW4od/O1KOciy7fRZrJXbXg0U1CgG3ZsEhL5uub1RwT4eI8jtGjOumNFg27ambHpDmu2BDjxJBAQlAdBNKbM608xAcZEexitqreb60tc09xS1xhsYjFyLREE4JZ7BKNyjFxBcXVwjH8n/5D0t7mdo3XAGzKCO/8xf5+81ANPf47/3zYDfTnvpUW1gCxqdPUhgBrPZOBCDKLuyn2zBKV+NRn+WLAJ6X+E+VtZMSX7Pnk6r0DxvAAJisnF0kBhwa7XhVEHACuXhYuCK6M43nV83A1uLiDejo2bECkCt3UhoRrPGCyqpcWbR9SuOlyUXXD5/FhAqBCwxIup7ZBFEIK7gCnHxICDEhDCBL6xlmoxsKSZZb1V4fggBp1PC7VZAVBV4k1TF3viZUtT1UUGpIp7EwSyEhCUuiBRwXTdEXZveaYYngER4nHD6ok4gFVLWxNe2/jbI9csaLz8iviyg+AHXXBu/scg1B6PpGODOH2h6eOV/x/YJPR6CGtAZMS4IVERWqQxyZ1REkPHngsxFSmcxa9IgAfuCK3sy70Hf/N7qjpXzNXCfe6MbOWZqg6G7cZI+pL1KI+M8GNdlkyMjohnBjVbeULwPvDMfrw1hk9T75/7PtsW7ADb8sNwB9lk/3xl79PME6bxVx05dTjLJzUecksoLJjdURx/Zb8mBm9I8b/fn2J5hxl/jgcLGr/T6mKxcAcEiVv1ZD5MXuDaaBIwOv9a8Ezozt3I8KSWRB/W8ZD0bJUukOO2GqOX5jNImC1Vq57Ks/Yh1iSglIy2LGNuZcL1eO+3UgZprxaYZE+XMDeokiMaL5TgwR0+VCRAQ4yJzEyLyxrhcLgB6hhlxADnD1rWVPw0xtCwc0HlvDoPUYHrJMKO8wfrTndZN9wk4nYRvVOUHTCzZpyDfc4WmFo9Y1xNiVD6N0owORQ1kIVppQeH9sveE5tu2IWu2MoLoWNdf3iDnmMjzti7NuY+5gkBY1gW5WJmpc1sLNh+zEW00ys1ukcJPrQSnydGM7jRTa0DJPTOSvE+YLYUocpfKmR3sLuBaJNJXz9HKWnonBD13NasHAyFoyQ4XDc2VxSBjYyGIbqEKhNBVyxHBnGNkf6eQYAYYZsCCUom6DgJ1ThGjV8/MB+LmpA6MmQpCpJaVyPScXLYmb3vVsOk6Tv7bc471fKYUCUAxeazzdomIZq4qqzK2W8aWMwJByywlvJw/SEYkEGoMYrzijLQQXl5OeP2w4u3zJ2xlA4GwlSzZYgKhbll5Ri8nFimgbBtqFYP4up6wxiTPr5J7qjAjxAWk8xp0nrlUhCWBNKMfWAwu5LMsArASuDlXyDLmIeCBmVELNNOTrWVophXqcxEJtVRwYdRcQEF0t6iljEVWlmhtgHumK6gxCCKLyTv7urCSEU3fbX3W/cMiWe2f+fvyvY1rdnB4ZPg2XMUMlv2LLjgcndTkdH7/7i41Yvyb0HRY6FliBxIrfUjl4AqIU3mQaHMOkkWCzMmLhG9ZErOq2REiBdU3xXAWAwHRSmOylp0TvMiCGARrsQwDMt7ARl/DIaSvOcu6lb0T2jy2IarYRSw8WIzIuk+VKRpaFBqmxU0fUoJ3qs9yksmsLLKO8UhqsocUDUEY50xk0dLfpU4rresmvzWBUe433ie6lEj8EgDgM9Mqn9JziQnI2FBgDoZoMpLPXmo6hunEQXkd19oyzJmsDKBl2awt6wwQQtWyPaqLVHuP8A1UmW9qZ5Ttta5zmpBMQbTyqkI/Ewvuo51l1fWEaLJ+K1fNEEySGTgE+WeBM+YUYWN2fzR9e3KWAWmWHea2J2UMhEoyFwWQ6DlmZNN7bD4OZEn76X+fs68dOR+NDjbmmDLKBLD9y6y6KrW/2fgc9f7tBZzZ30TUMt+JI6Scswyg3orQR8swlVxQNsZ6WhDSCaUWbLli225YF4DYjPFV104V5wkdwrqs6qBVEQCcUoIKEFIiPiySvSlGhCqO0jEkze5Cqj+5oEw735sKprJFI6esoZZBzNY9kdLVBwD2uSq8uYBOViapAUcqo/ZbHJ+JQTEMdUKyoA+SszNiQS0Vi8n4uv8DE5I6l7CeSQEdZzOn5SaHkJRMihQQ04JSGXyT/XlazqhBHJaYGUWzPt62jEgLlmUVumVxuLHs0BRj4wtV+SrYnBMlKLGUPKyfyi4jkZwSyJs4FMk6qghtnMKTyNal7QEAVLnpUxXqhL6sTf4spaDkiiKXoXDjJMKLWGbAZ9rc25fjfusl9ZrefRewNeq4Ta5j629fN6P84BzJOeD2dkMtG5ZEOC0RSyzIl3/GVi7YUBq+k1GRqerffIcFWc+Ix7GJvrLicr3itmUU8T5TvGwRMcDkLgq930Sy96DrwNiL4W4sDmOCv9TO+7W8p+Gu1Deg6m+MFNYhi2aH8h45MT3b17Snw8yzPduzPduzPZs2cwsAVGBhAc9z2VBLVsAooKkQJJFjZhuyFLGmSJkHvPceFqATCr6KNCo/VSCyOqXVyp9oYwOcDMM0pVj7roKxCI8G8ui1E7hk3/UPbPyqKKpm5Mu5OCJ1g+1QN9VrTx2cMFm6C7wyLmrG+e6AZK1HCnVnhSVJnfplXVByxuVybVG1lp7b+m76vzzHR6trT5V0Ipfej7EJ+wpJGLGYenYSYgUWMDXqNBAlUxRG0QflxaWWBhCzAjKWahss4IHNEGt/TfnU1wOsUQ+W/jRXLf/rnKQ8qNFuRFN0RYeT6A61lDVg1UA2t+IUhK+idCngxiCQOgahAiEkiUwLoixcL5uAA0X8+MHQPSCgP1SpsEgWe2MtFZfLGyzKhYIARtpF+AgFZmorjjArV23IOue9PEAznlokos27AS7NAYGHPdMU0Sg1og0wmWntQda+PLrTzAzszFHnDUAOiskFBqiIcmfzhSBzaYCRamKmCDZnMEBSy5LhJqGN0xxCmuHW7qDu6NE/9StCrzc68ghCeRAr59yMlh7ImqONDViyrBdmfPeptoH7snAzjWdA3X9moJo9x9N/no9c1B1BUeOgEd5EpGCnRS1346u1XDJO51OLLDYApDI0Skf3i6tNbWuzAX/w7k5S/iy6dWXGCcsEZGMUp5FeUsmcS6R7us7U2a0Wc5QouGk5CLveov1kHxJOy9LZhX5mxhlbh0wRFFfFWyNI00sbAMe6n6DAGgAt82PAUAFVICXCopFuKfWycJKC1gyTgETMEwpncGScXs/gQkiBgbIgUvUxYOPadU0cZFijiLg5yrSf7po7vv+F7Yffbfh3f/sJ20YI8TtQfEFlwlYqKEZ8/1cvCEsCIzWDBjEp4NQB3dY8z94Z016TeTDeE3rq7MrgUhtIIxGf4rQroFLpz9f5Nqp2x6sx89fj9v+y9y5NkuzIetjnQERkZlf3mTtzZ4bUi0aKG5mW2mmjP64foK021EbGBc2uUaKRM3P7dHdVZkQAroU/4EBGVveZc6hVYqZOVWfGA3AADn987t7LMP2g4jXhX2L10zVIRxSRM8nPAT8l/H6ibuk97t1d1zh88wJeFgAAIABJREFUftDvIKPdfaXOF/8bg2z04L6xM48Nh30/j/to66jJZyLekDtb4tllcqjx+FFGO3KUjGCaR3/HMiH9MEPWFTK5Ur7zbFdqmG9nqHvGDoFaFhkdwRLzPBulAHVmgRlJSxzZ/HCtMLO17JfswBMBD6mcmg08Tyhlx/UqWZnOmo0CyvPFSWDlYhooRUol2dkj81O5AlQdnAgA277qGOWwNhliLElVPfpWzi05y26IJYV8TDkLV6uMfa8e6W10FtANB4eSGNpBEv1LtoYM8A4rlZNU/rXPxbDNDEw5oZQWWUu+KRUUUJRWVQE5LM6fuGeZBdyXU8JeNqScsORJwM5Fyt+m1ECaEfBldDpyprlTzEXm5ly2/WA0bOtX9rScu80xJMBQARFUsZn7Gi9ll0hkruKMJFJADgEksrG9jHVfVtWhJjS5BcTuWCy6Z6uNx89qfS43HULiLxREAQHjCjbLZHojtqWB1wys+k4MfN9a3OdWWtiBv01Q9zkwfv6IH8Rmz3ZADaBR+1WcaEQO4AcL4GpZJgWkmRNWsihdtyvmecbL5YKUSTLIEKPWDW9vX7FuO+bUgG6kwrNnWpRdAEoZy7KIjLc1nXS9rdj2HZQmUJ5V7s5Aapk7ZEwNNFEc6E7Iyc44ywDS+JuBkKLuTJD13fghmyovYC3VoQyAlxgo1KR6yziVkjpSKWOaJ3y4CADPSkwwV1wuZ9QioH/J0kOqawMG7In7pu0Hn9luTsdz4z1AzHvftWe2YIlw59HTMEoQrivHr8KtnVxj+4qCfk5N2iRu69+AkSlnTBptTup4rKUAu2acMX3TMlOYfEAZlAmUKhxVo6cVWdlc1VtrLUFvYQiAw+Qt1pJ4Mig5H4vrXS1LU6/rmXxD6LMOmeMZ4ToiA5uYXNG3UcJjHvRlRtM1qfW1e4CtMei6Mz3kcH002Ayh0YLUJkOkLt2jMUMy8RbeXS5xfkphTetN1d7EMncUtoDNd6nCpyVjAEDUsnHIGBRIwyLPJpqQ56nTPy1gSd5fbXADhVnWZZyiYBNgPf/jLhW7RwAFWeYxCs+0Mxv9fjzSAUxGq34QGSgq+TPF3qB2HnALCgLu1s74Lh8xUffzqB3xmyZ3jRcHuRj3YjoFecpsFg6yG2wJdk2RVDFKA5F7Sq2YkoBUPSMgWIPn7KxRPdT2Nkj19yYDEmvQSVWAhQamTNOMWUHFIj4mcfLnCYkku1ymSfdhdV3cMieBlMf4zmFdR2Hd+Hhp+Peoj6hNQ/e8VmwHQrk+4x+jrgrSoJekwTg1gbgiTzMsc0vVc2w+SeaYLYBaKfAiNluCnhWssiZYAlRIgW1Zs7xJ8JiGrhSAKmFOs4CMWPV0BpYsts2kbvZKjCk1fsbMDhvlGsCXbsvp909bU6Zftf2Xk5z3DahlhE1tfTrl2TEUFugogEOVL3XM05SQs8nfKqObfabGDGePeUDbW/1+9DNJf3X6ZVDKXbO380sIZItGxmQqrPULDNSCnCrmTJivF0z/9Cdg/wP47UVAMqjBnsNehglswC7t9QCUefnj3/Dy5y+YLx8wLxnf1g3rWmDAn2jPVUoL7zYexQwuEpRIZq82ewFbJKzoolRbMFmpBXXfW+Cn2fW52WaTBV1CA3lhNqPHPPDZfll7Amae7dme7dme7dmsEbshO6aP3LdNS8gE8IWmIs5pgss9QVGKTlkTJnMSY0TKIvhXi+qr1Y1VpMZtMyDG+0VvYY3iCdJiNwatDftgiN8zNkXF+djAFPpFQTDuLh0sCHC9MBiPmoAZnRy9AtyiZu3jnDJ2ljSIEmXY0pN288P35VseGWTtM4u+OlK23UVqBo3gyLER94a0BlphNcoYORKSGsVaKS1zZABqmHBjk34WxmH0tBeLcvx9I2Lsqz2bmzW9KfBqTomkMoNxSqKY2FxGp48ZBKw/27bh7e0Np9MJmcSxQVNL+26gGlYjozxTVLfKYuz2qGlktRE2Q3FbX03JMoUy9rsbOweDd1D8gHvnSfcOnQ+/xyKE0mgcOFYivadKR1Nw7/oX+invsdS9poSZAUOUXriBwu90RcqNGtye3fVDCUnh3+6QRFtjIx+K/WytAdZGB9R7TpAxG0w0LpuTM37+PQfNUWv9aI5e4xvx2Ud8yGlh14ao51obj3GwTbh/2zdc0sWfbfu8aAkNSaec3Llpa7Pvl6beD2mULZKoKNDF6C/9MgMs+XhLkRrd5iyU+yRtrQF5zEATeab8lndJuvCWDak3kEjq25amt/FuygqKU5oUq8U8lCgRd5YYZ0otIK6YT6cOGGUASIu+snIaxl+FFhXLkrGvFXW/Yd9eJZMBenMoD3+b20gTKaMQUNS4wmiZZxpk7O9r5w8F//2/fcW2T0jTJ1CeUJCxlQrkLMChKvxR6MMhgPVgnXP/8f3J+/1maxmWajmAGVJSecWD3ZRnJMhn1KKK414YecBxxx/LF8f39aOT65pc0V9H4V9mlDy6/73+hWfwuGJ+YQvGQBgPD2fLjz3il7yXHzy20f0hD+Um7/heD/LtEchgfM69M6Ifx/iMUVaO99pnFmXXn9Ea7chi9LbzIoIkgD6ziPGNbdtUbuodHEdneeuQGS3Js+cxV+Q0ufxYrpJFj4jw8iLAnLJLWnYD+1mmDh8jAIJGntp+Kq2cH6AAzn33eSVKWJal66uVnrGsD0afihjx3NaAnLPieCnqsB3LRDX5dNhj6si0szHSS2g8A0h6BlW9MgNqrJfMBhXMU3fej2Cqdt4KPTzVua2BJBniTnpeGF/Yts31s3FdRP3gaB/cc3ntj1rqjd+Na1jKirbzvjmQio5PThKbn1p2mYoseoGwBct6ZI49A4yHOTEHw9Bv53LMHpEsskHLVidZHJQH1Ca3uxfLBUw775qeYuMfHYEjP7DzOWZtSMkyf/S0PcpQ1ea7vecoaxWrIsMJAVRtpcII27ZjWWZMUw7zJWNbbzdM6iBiZlzfXpESUOqO17cdhAlTkPv9hQc8YpkXvG6vAnwAgUvBbd9RmEFZs7RVCQAxO4PzL5XDa5ALU0qgGmU6yRgi8iEhsYKnU/ZjRBxnQR82mtoaANw1FrRAP0Mly0hFzgtympC1TMeHDy8AaalNzYRxPp0cXG3LsNaYhaplGnF+5XSUOXhUsuWXnXOPG9HRs46eHT/r7RnuKMd9ZrSUVK7V+TNNwXgBIYEhQEoBokxd6VFrtVbsIA1EgctfKcl5YDxfnjsBtHf9jWVZfc/qMnf5yL4OpWDHbE7Cs5tNJoV9Jve0c9JAnBYNT+2ipgOGPeOS17B/jdQVUQwaZbL7OZM9Gdb2qMcOOuL9A9j7Tb432jiNcG1Nil6Sp8nPaNj6it0ls71xk6MUNJVJbQrMoayJ6UqWtUF4w7btChYFiCZIkqGkGaeVx7I82+U5W6OD3Bp1fiMvc9sb0Q7nPNjP0QDsuCPh/X6N50GzlSTvl/Nf3K8B66OR31nFd+TtUfb4nj3g0f3jZ++tH/nKbJgia8jnPTDb6BCDoUopgO05vWbXrKoCIFHws71fl5gBRGUtyldyLuYAdAOYi2eNJNK8yzljnhcN8AGIMpgqUpoUoBmysFBCsIT452YLMOe9kkD+42mD6G69iW2vZbE0Ovn1JAA207R9zSkQxTLzdXYg2/maQTzlCSAJ5hMtHkhTxr4XbKUIECFnBcxEmaKE9WqyvT5XwTKeyab0wBWuFdN8Qq07FBcNAnBaFoAyLMVV1liXErLBAW19RfnCzscjPcjoFoOkUmplrK3k5CibkB0CMJumLa2gz6lMRJQk4JFIypqqXyLuQdubvRx2v1eImiwQt1j7e7CmkHzWZFljAjXcGGz8pd1rfcwZmOeEKRfgNYH+3z8jgcWWg4JCVbMHt7eTzpQ/rQvAlHb+3Sv+8G/+huWSgfTia0GCLfuxt3kNem4QgsT+D4D7EmXVAWMe8uP32QmlJGrvVPkXtartSIFyKaFPl/9sv6Y9ATPP9mzP9mzP9mza3LDLLT3jHupDmiLd4pqjUbkJMdFoHJ/tgl5lL3nyqJmxKzpxLY3jaE+ICuqREhuF7XjPo9aMxj/eXIl55yY3JCVRCnuBOxp3e0ABs2SosKjRdd2w7ZvXhY9K+jRNiEbx6FSNES/2bAN42L/fU7bH7x8p2nGsQG8QNiU2WAj0GlaAyARxHx8/d/ybocAsasa9RlM+/Ly7Bs0ha+AAf0/os+nEpVSg7A/HagaDfbfyZAZQ0EwVfp2usSRvIiRPWWy7a5psP2nEjI6FyLJfMwBLpdtG1NPNRvKYlnbNe3unXWsKPt3t33j/o7VEw3PGe8wo4u9WBZnUGRedvKJ0cUd/G+s47qMxxT6MfRl5WeQxj5rr5aFFR9tohBoV+5GW9r5oYI6Gp3E89r5DBZb6ccXvjH4j6K6n6z0tUkqY5/mQv1qJJ3PURSOagVRsHPa86EAwBxYnuycYq5M4TUy5NoOWRw1VxrrKZ2Igq8rnLOWwlA201LzxncuydOO1MkrZ6i/r9TFdcDRQj+sGrA43d5yYA46bcw8CvCtFSn+UUpCpGazNSAR3NPbGNzl79GGVgVpAvOHbP7/i7edXvP38DoAULRuT5pZDITG5FbJYbIPT/LIz8ahVTrhtZxCdUfgMLpNk5CHSCDZ2IzGBvfzdb9lsrfXgKItY0oh9NcQZIPBobnuDaOnW/9Ge+KV9fOfb7vmPjNv9GsTdPd97z3jN9xx6/3XGenzNL31X5LUP9yp62gBww32k86OzJD7vR2TN0Qh+9Hl87wietHsawLzx7KPSHr3RuXrpJSLSDDHZS9n4WJI5pZuzJ9JPQHoNzJGSZOUCCe3MAV6LgIiN9xv/N94qvLZlyxH+TGg8T2RkM5ILn2DkPIHIMo0NEbo+3gpK5Knje1Nw03ssk0zL2uNC6oOzWq85kLEqM6Cl8uJ3AhTI2PZry7gWeLudV/ZeGa9IsInaiSFGaOmCOaEk46QZ6YVOXFmrpQRZnNHJbkcyzdFeP1rf/XoUUASFczXOSa12yjS5xsCcXpaLCdXYFtoZjNT480htCs6LI/mnjVucPCkDaYiglX1mcnnjm0TiIDsCNvtz0fMBInLQh10z7vGxj/GakVfZ88a5MEeEjT+OPT5n11IJEawwTfLDYGzbin3f8fb2ig+fPoJSwq6ltcANqDvyvTi++BNlPNLMNvsuwKhidII49LI6XItmdpNyJ6y8wFaB6WIGcNAfIj+fwVD8Grte4I4agu97B2p5BgJxzkjZigRiLaCQJKvrMp+Q0wQkdqBAZeFxtVYtiZlQivWv6R9x7RufcNhO2F+j3D2uy7/3XP2tmq/tZBlOW8lBIKryBkxLzn+IpFTyNE2uA7cgID4cX9QfI0Dd11wQRO/1vMAj7GOzTR2csVGXaWXkZH1Y6RDrk9NCf1wPM3k1fM7MrawnEUoIKPBnhDVAXYd/dF6SZoSq3br/kRZpfxQEMF7rNLPP9F1+P4C7uwkA95l+uS2Wjock3etN19EzAQKSiqWbowwSz2jnFe/Itnc8mHs7xmi7GHkxbK4G2ozPj6BWp5eN++C5Ud/3d0NtPA+mdDxTfk07Opvivoufx+uJTPfubSfjOTSCcyk83/k0FDRFkl1MMr9KxhEDVQnYNsqfkcfamSf6cc7GbeVMaaA4saVYEI1l6vY+AoBl7X6XVuQ2OX//D84V+35tgEulipSK0nPRSnRG2urp2cpAB7uzfiN0Kpucp5BMjW3fwOesn6tYBrJxVZmeXneotXrmlXbmSZ/meQZ7ABH8ecwa8AYCJe6ZtdOonZuR54/yj/WllB0mzx/pR++dn/HZIyDe+Fqke+xPA2k2ftXmZmTl3Mn0o/4Rx270tku7cyEsrkSEiqq6k2StBAOXDzOWhVDrmwBk0GeTCZzOe2MreCQTJcbp5RUMxnQuSPmCKX/A2w1gzi0r+pFcCnT0s9812HNYsymbbcwCaKOtklVusnfZulXRVM9nKd1o2Q8rV1AhVI7A2mf7Ne0JmHm2Z3u2Z3u2Z9O27RXrZo7OzQ1tRISsBiJSYaaKhQiJgEnLVMSIHTOaRWOQCael7CgcBSUzuJuRhe6EVDEyvN//qERZGxXKI0NwbNEIZGMd7+1TtvcO5k5SDrZXF+ArwlgU5DJnT4/JWuYoUQr3Qt+7YV1vAJGWQOnLtIxGTOvbsizuwCZq2SW8pJMar0bDbjSoRPrEsR/R2n43J7l9n0AkNeiJWGuZ29hWlFKRUytxcvTMOBedsmdq66CoiNZxYDiRh3QO2Tbe3mgOVfQqM+q+oWr0dHSmG41eX1/9WXma8PuPH8W4WgpqqSi79DVr6vAGghHDsmWnSUmyCZkjVpTUzbsktdYzPNqb5G92R0AcM4e5bzWm27h74647KQa6xH9XVWyOlKL3GgNSC/5Aoe0Mimh8oXBFnia1k7YsPuAQvdWtDwIFBWs0UI9/Hxmujsb9rnEqjKGjU8g6YeP1dPrUHCEj3Wxv2jNt/1p7BHKLe7VTXmNpgGHs9qwIanm0BsZ9P5bCMB40TZODT8xpemSgtlT+sR/2vHVdcVtX1KJGFjeEiNNnnidM0wJb6/bsUnZs2zo8jyGZ09SRQ60clc2FnU+Rlimsr7JLfWXJkrML/1KjlaT3DYberFkSuGjGWVu9vQMFLFH3b/sV+75j23aAGcu8YMuTZIAg4Yk5T1iWjHnasW4ryl6w3jYBSeaMKU1IDKzXb5hSwX/+dyd8+Y//LSz6LXU8Ica0GVhGQDI7rAyT9XiExv2KRifQ9BHACUwvYMySGYN3VLoBkMjeyQyt+2/vLDra78ySynrfNtxuN+G/ymds/Y5GYDs34/6zffOeoc7ao68f3xeNar1R+2hs7YH31/1IO5J9fmRcf0/7kWeO/fkRZ8FoQBWA6T2NmO9Tyjca63MG8GM8w/p3fH9ctk6M7xkPBODO7fg8AyfaejSAhAGkIx+z90bDpcnj8l655+XlRc4VGDAIHs1fLfJP6ZJzlujyZBlSmuEyaYaTdRX5NeXW1y9fvuB6vWKeZlzOF0zThHnW1PdOs0YryxBT6u5noL0/pRmWiW/fdu+jZTqLILicM06nGYCUNWpG+JAtJK4RiFxca8X5fIaAP9q1MbON05aakxRAB+gQI670RTKb6btSwjxP+PZacD5fOpCDrUG9EkRWJoaRFVwAMK63q56J6tzPCVOesW8F29rkhloZy/mMZTm5DLprenPm5qQlRF4In9fvNTunXf61edGsb1LOag/7A5jmCfMsfPV2u2KZZ0x58nW87xr1DGiJEXWuW4p9FekS+r2VkoLZEeUi04PE8VR3oyU5WER8R0aPth5JHRKkZaFsDEYnG3Onn/oabvKtrckR8GzXjsA2kzlitHSUQ+wZAtZoeorIPSWAY5p8ZQCmaZpwuUjGv9v1DcwFgGSaul7fcLvdcHl5ERA0Mm63HVM1p5SASKaccH375vxLgBAT3t7ePMtA5FmU9Yey0o0gzksgJwJzwbZJtiX5PuF0OuN0OuF2uyrQRs7nbb0KzVNCVb2n7E1GTZRQM3tQguk90LIKso837GUDs57rRcurqXvU9kamjGVeME/CQySbUStJKuA90cMAxvX6im3bXL8WGjT+IetBvVqhRXl65N/x9/+fjYFuXYvdwkphtXJXKWfhcVVpkzIsC6P8TJJVJmQBaOBIs/NUl7ujLhTf76AKl8Wz04XQMpBZkzOg6S8FBeB6B34xnmNynoO84hyySe5h7DAdmAWQmEzfPJBL9HxwWqbUgmbQMiGBqOvfj8x7TsklcwGllu7dR6BZACDP7nLPu8YW7SuWoXMEP0y52ey6e4ga8KCTqViNDmYTkr3HavvYyoZpmkMpOS2zppk6W9BI20/yqn4ORvnM+4TGQ2NJkSjTP7ILMDMm9PtzfN+RjYyZpfxToHe8Zrw3pQTedy3Zcr8n4r0j3WOZ5cP5f/DdaLs4ujaef8xmG6tOt6NsPZGvOZCIkp+9AliclD9o9iYi7NixbzfUqhm5yUACAsawIEJazt43ydy369+kgEyxV9O6I+UZKbd1TCkDVH3/2LoyuY4VCJeUf/X0oGBiknUUbSbjPB/RsVRfwWr31BLslJHAyLOVJo7zopmtq613lTUVXMW1auCNZeqSZzNvDkIyu0LOUvLKMoAlahkJuWpGXLUQJEpa8rxqOe4d396+Cn10TU7TjOV8QUoZ214ceMuQcpvJ6UADv6/e71qb3G8lsT9//iwZE10XiIGigGSJrJ1N1uT24zWu4IrB/hb3VARX2flgZxzpfMsaLzDwfJvrXjaL+8l1AWrAU6JmQ7Yxub1I/7Z+p0SY5gl5mjDPZ3CF2s4z/vSn32OaGV++ML6SBB1Jdpl2jrUZ6H/zABCblhX/5n/9P1FwA9PvwfwnvF2Bb98KOM8gkhJ605RwxO+69Y923rVMqU0+snPBSrgyZB1X1gyTEL0v6mQw1SuuITZwGJ6Amd+wPQEzz/Zsz/Zsz/Zs1ohQVZDdihqiLSZKrOpymUadMldUEFhBNqMR2pp97lkFVFmGGkwAU+5DJELlpqyYwRAAoFFhdO8oevRZ7EMUXKOQ1/oAF75MkbYWDcTH5OvHfEQDcaSKcaDq+LZNa5NGSZaagMyg5jBRZ4X1LRpnTTHNOePl5cUBS+KI3dy4aQZZG9ORQjfSI9JyBMmMynX7t31mtK9NqDVUO9q9USEdHfJHaH+nMVuUZZxXqEIkyodNhRhn4OpDUqW3CfsFtVjWGjX8qqFr28yomx0UYGth33dcr1d/v9HaoporE0ATHItDUqoFkHIBAhSxCFB1ZtcbKLXUwNGYIwpjQSkriBKmnLGczkC1lOwtiq+UlnrVyhRE52tKUMNUa3FdRcUzAghg89vZBx8b/dw5FvZFNACN1zIbD8h3n8d3xfXYFNVePYzrp9U75s7QA/Sgkfh7bHfrUNeSAX5iBGakm83lyHci3aLz9MhgNX7+6LPeEEDd3NnnldnTmI6OmdGIYO8ww4Qpx1Z+YIw4Nro2x839vNt4Y4uGj3lKwCSGJDNiNzAUAPTOz2lKADKArMssvlPstClbWZJ7nhLXkjilWsauaZ5ApeB6vaHWgsQJzIE/uZHFaEFSa7xWLf8Ua4xXGGCmctF00ox5krIWy3TScinNoc6afYUBKRmwtMhLGQiAUnBeCESbGLhYDTkAqscTycVubAewo0pGGc0uwxgjkn6rlgFcUOqEikn5oLDChF0dB7JvKxeIOfXY8G/tWO64dzjZmjOnYtx/tSYwC3hAeLY53/t66rHMYHN23xuG4zo6OlttLR6194zd3xv7KHc8et4j+STynaPsCY/us7+Pxhr7ccSD2jlVfM/Z847o+EgOORpz3z/A6mjF94+8fHyO9xfjWdNaF3H/A3Qwucz+bXzmET3js82QG2VjZpGZR7rWWrGuaycvMW8O+BMxPCExa2mULACMpBGuzJhUBmEAe2HU/YZpmvVZkpllWRacTgsokQMWTV46n89aWkP+fTqdwlnRl8SzfueUQUvLhOggagP/Jcn45ZkpmDo6Cl9UkAZPYBigxrLb9NnMEllJHnn2vu8dyLzJDzaHKoMnDkdMNEHLj9HfHMm17vj2KkAAc/xI5sh6t4blPfLOyhU7NnWI2HqIRvukpXWaDAEQ3r69oeyM8/mi45hwmqcgg8i5f7vd9G+Rnfay3a3Dcb/0689AGRnX66blYiVjmwEpUm7Ry0areT5hmaVs17apnjIvoJS8TAmzZHmJbggGVP4WXebt7W1wwDRHOrM6ZxNhzpOWGNi9LKKtMSLJaCDyRXLAWNx/0SG47zvmefb1ezqdQET4+eefg6zSMgTG/hnY5Hq93s25yX9R1re9FHmwrXc5U9tam+dZ94c65cqOl5cXBYIR1nWVUrHLjFoLvn69Yt1WpERSSi2Jw25ZTii7AEpyzpjyjHkilFn2ugHM1nX18rEOUjDAj/4wWemHDAJwu70BDGQtG8FccT6d8fLhgvPlrECIE4ATyr7jy5cvAnKqUhpJdLqElFlkoZQ0CrkFQbC5gMwByHJv2TfsCm5JKaEWCRAiJCzLGefTCefTgnkWgNC+bpiXSbPwfMO+7zifJ4DkPlDFh5cLUvqgy0Xovm/KB/dd3s0Al5ht9V5uiO29M+TouqNz+hfJEsoAC1cFVTb+gmTll5QfU3aAOJKUBDktl+58J+V5OWUFQJywLEsAihbcbles69qdq7PygwhgiRl350nKYYnzsGVjMD0iZzsXGo9PaGty1FXsvsjjJMOMlAASYNdQIo1ZsqYlpYlxJ2ogOSKSAKAs2TEs+KOGI4NVH1aN3PtxJGPFeZ5SbsBHBjL1fNh4u72I2iElSSgH4N6ohx/ZW8pewhktNsCUs2d2aqefjQMuNzSuLYMmPTv9Ws0MWqvJ3yZrJeTJynu1R9gfZlMQO8R9gIrRxHiw2TJcH1cWH/dhXBOxOR1qWy/WhzEj9AiwzyS2VQQ5bgx6iXPu/c8JXFvG1rhu7d4xSCb+tvajOsGj76O+E+U0BiPpbTHDR7zWzikHj04TSmmZifZtw+VyCXST8ioJhJxnldkqKIkOXhkoRWQMWxTSp6rnflJZixu/mpOUjkNfSnqr8i4kKQ8ltgdbkyo3UORpVl7Z5Ao5ZcAIISg9Dz7avyabpyTZQZwDqM3CZBhfF16i2ObDguUAsGQ4rbViX3es6w37vmJeJItcztI/K4VqcmvOGefTRftFqBUts5xZ2ytJqRvbf7ZvqGIrN1QULKczaMpaSktBk3nCRBlMmvmQMpKK2DbeRK1sYi0FxAUfP56wrjds24pSCm63G06nEy6XC87nc7c2I2AGaHKW7Qci6kpX295ue8hdGj4/UXcy2vdgfJunXtcTHtTea/MYOH23nyKvMf0mrpEWtBn0QTTZvpQdHz684Pr2CmbCNC2Y5gmXl59AiXGPYy3AAAAgAElEQVQpjHJhSJ4ZRqWq8pD16EDXQLMKybsIX28zXn73CfP8R1T+hNtKQBabrKy/Hlwf17rJrP58IpABFO0dfmiQ26ntecLTSTtmd4R9Qu2stsBSRgW46Plxz8Of7e9rT8DMsz3bsz3bsz1baMwWZQVIdIiIUG50VCeftD6l5ugoGA1B7lyCyD/vKXVEUDBDVCZZ8TL3jo72/Kas9E6CYwda/PvIyXIUpXN0nTkPogDdjLZN2TEaWHACIuY7CopB8RIlT1Lfm3ITjWPjTxTwI9rbjAUmdI+lXsZo1yNDXGzx+6gkHxn67mhKMnYbn4BlACnH1AA9YzTT0TzoGzol0+4ZhXlXdFUxMN2QGJL5pJpiESO+KnKaQNMk6eKZPXtGjEyLABkbZ1O0kqcPr8ySolnLMbkaQPJeUyJSmqSfxGgOnuYMIIppsSW1uqXDNiABUUKeCKlmB6DpDQNdCto6vQef3UVeuZHq2KD3eJ769x79HddhogRO5rw1SmkffR/E/TiOoQYjwz2/MCOPzecImIl9Gw2ZByM6NJTE5x3RRtbkMQjtUXvUj5jVK/Y9tjGSc9zHY8u51Yf2yDI0Q6E9I4Ksjp418mf7zH5i2m1xKGopBm6ArpaiWfmGZXIxPgeJ+rV0wVYjXYycAmahZOvi/ly45+mNPkLbgpSkFEiLkrV9aQA92UtiqFFVU43EiSTiGtDSJApkWy5n76vxd2aNAKvyXE93D0g9cmrrgFlSWK+3N3z5eQPzF2zbn2GqLof/xvrsDIEQVBKjimWbaaa/37YRGMQ7ppSwlk0iiJKbT2B8y4G6GuH/d7/vnTm+O8fVPiPOTVtjvYwgvwdewPdOsJHP3PPG9/jIr2tH/OdHiXh076PP4u/x7/eef3Rtd7agORSYuTOAvve+kWcf8SCb01Hee+/sMoO5yRgjL3+PZkfjHt9rAGbjsUfvMLku9is6JVysHPpkPHp8t5+PFukrt4sDTA2VIi8IcKEG+hhYJvZPAAQi15qh0oAxxofBFbfbin3f/NwoZQ8A3x5gUNxArf1Tg76NWXislv1Qx2xKBEqAAbONTiCh1e0WQDk6Vi9nxMJvat1CvxqQ22T6Tsbvshfe6xOWOZAUAFh2yaYxz7NbixNl0JQNPwnjy+CW8UJeHN/T+IiBhdq6biBxZok+XVcDzM8up6aUsK6rr3GTZdf1CitJFc/nCCoe17rJUnthjww2nr4si9PLzl8zpqfUso+wlSfQCGtizWQYZVUdPhGjlBXb3pxsdn5YNhHUlqUzkQEqmp6WKPlaqbVKNHpqgHvYug/7ykAyEYxmDrp1XV0PMMBMBILZurP1YeDARoee90TH/nhWxf0ndJP9N88zTqcTpikrjStOpzMulwuWZcG6rnh9/Ya9bHiZTwAzbjcBh82LZIotxQDLBIEaCN1KreBNnBrbtnX86nw++xpY1xW32w3LsuByueB0uYBSxvXawBEuo96aHLnvG759+4qvX7/gdrvi48cPOF/OGozwqqAydYRWcdpMM4Ac9h03+YaIff5rtawDUvbJQNmmPRGxlrfZcbu9yr8zkJOs269fv2oJO2CeSdxQtWDbVzBXXC4nzWoo15dSsW5X5TNAKdLnJuP1e+f7usWPtV/zjKh7Vq7g2pz/0zTpfmlBASKXJ0wpS+YGzy4ja0f4wEmBbRPmaRZ5WM9Souq8YtwDpsf09peW/TUC0ox205RcRrdSKwYcA98D/GwdHu09P9e4wvxupl/4NSlJsAGrk5EDWAMClgeRn50+68ac5UV3otmR7nikS5k+H8/gsf+JevuVZ6LBPVAr0mJ8vxYsG+xxMpZHUh8jZFNwdy0kWxMBijQyYur5QEiJA1i1lfCTkn7eKS/bRmpLMgDkuL+ibWsEwxD6LKIj/UZ5SnROO6vbe46A1FEPVguQO73HdxzZBzjotNb/Ixl3fOePyOG/tB3pTMyWuStm0eppOOpAtVYkFj1eMceolbHMk2Qyc1lG9WAkwMqsaFakWGJwnhfspSCne3uzAXoYEvSmIxDgIpMDeGNmIlCF6dUtw4XJ2jhY76LX274A17akv8OL5XqT5eSsTdQCgvppHGQDMl0aEBshkJCAnMHTLN9zBVWT3Rlgkd2hAJ/kWfJsfqraRFXWrezvbqA/yVcCBoo+ttQdqSYBzSQJBCxVggTFTjK5DGvr37K2muzdaNH4aMzi12T+e1nI5BTfa7XeXX+/T6DjOZqjx1nO78pWkQF22OdLLo/PFULFLpiOlB1EPug63OxAbhepRXmc6GWvr99QC7AsZ1wuJ3z69AkpnwAwTud/QP5vKj5MO5h3MO0ACt4+J/zl358PVlX76/Tnz7j8i6+YlwXnT39Gms9YywnbChQWEKll1InzEHnEmGXXfyPSSnenfle5is5ntlCby8KwoClbG1KqTs4PW8MOaNLjlejed/Nsf197Amae7dme7dme7dm0kSLDGRDgQNU0j6o4mAHVBRK70Q26x06Q8W8zCI+OCnM8kisNuPtuFNKsjcJ0fOcjxeXIadN+3zt+H4E3oqDerhH0ukf4h2fE546GidaXVvP07joh4Z1L0wyWI1AGaFlx3FBJx4r6fZTSfdrwqJSM/W7KzEjt1kyRletlRCkZ7ekuUno0Ko4KE9So4MCuoS/2rH5+oxVeFMQENAc94DXIRbZXQX4wksQoZHfOhL75mnBviCH4WdKTdrWS24yKUVIAMzK2lqoS6k6mzJLpCa1EgiD0Kyo151NKCZTbnhrXeRvWvdEjRmrZv6V/dPCsRvd3jTZ8rzjpNMIcPt2a8rmkbs2z3tSvP+2dPgdDlMajPkfnbPz9iEfcKeEhbLA3KrXxfa/FdR4/+yVG8AiGsRbX/2h8iP2N44vvHo2GRLG8R4sojjz40fyPdI28MBqz5X029/B3tnvNUH2kkIfokg4QKEZuArqI/sjXjwx/jW5iHLQsBuY0a30y2lovtExaNeNT0iwOEs0lfEuMfssk0eniqJB1K3uvrWHJRhAjpNjPCWZJ71z5htu6ofIXrNs/APjQ0YUD/xEqAkxSium/NlhGOrAj4QvAJ0x0QcEC5bwaBSXOf1ZDZAqGmb+3jet/BJHeyyFxPXFzEgDdHm9OlVG+acfEEf8wI9gv4Q1tLPfPtP48aqMx7r4v93zmezLTEQ/9nqG+P7ctCq+PdrbvR0fz+M5f4xQ4cjKM8kZ/Xb8f4toZZcT4ffx3fPYok0U+dMR/jpw3RiPvezUg7X2JlwiY8efoeWplIdU/odGkpGU2IE4/bmdzShk5yBEGSrH+11oAEkOw8UnhvQQWtLGWLln8GeJc7aMzWflg1BNkzDauSbN0zFoWI0QBk0Qgy/kkz901Itky7fXZoJRnM5BSk6FND4lzTBSdY2K0vV+Jjc7y/la+IE8ESjPmaXHHXSvhgu6MqyqYiUMm8sFR/+j7aJ/JGpuFl5I5ZeDzbj8pJVwuM2plXK9veHurmOfcydNHYK27tc8tK5sYzGU9GODW1gYqe9YZ47W2nd1ZBOOhsd+R7HIWG9CsP8PN4B72s0X0aup/kylMR5NsTzZWzTRZWcCtZDJym9co5xst1nVF2XectexRpNf471ortm3zbBr2zJhdxgBdMROVvdPOEJs/ic6t+PjxI6ZpUsCXRLALgMYypEjppQ+XEwDdF7UgZ8LptABkzgcBkYgzsZVBA28opWXanKYJ5/MZOWfPNBNLGJZSUPYdoIr1dtUsnIF2RKCcwJWwbyu29YZ13XC7vYGwYd+v2PeC21Uiqed5cecJgQEFKJfKqCR6pOm3khlUFozsNZXvIA5HwelKZgLL87lvG0pZBTS33/CmpT+/ffuKnBPOlxNQGWXb3aGTEmmZMdJSGMXftywTtk3PM64Qe8B9+yUy/o+3R898cHaqsG13OViP4EAykOpgLBmjkjpEBTAzu/4lOr2tjckzDxCibiAOXDujDCRvenXMYmnytQAjCebCadH2F3WkWzmmCfte1Fkr5ZCNz8bz2OT4URYUXgE/LwQoFPpOgWauY5qMKA5m2b8JzclH4fqB7u+IM0d2olL6snUAS9Ykc25rSe+mOysP13Mu2n9G2TiFoAgrtcIQdppTVh1G+xJk5bGxAgnAursi7YZbEhFoksygoIKUbM7J+wtE2VG0A6amexlt7vdSy2Q6ymJ5mP+ow46ZXuVHSuXEN9iz7bo4T93cyWHTnSNH/fX5AoCwdt47U35Z+/W8ptOJ0faM9c2uGfcWAFTXb5s92f5ttuV29ksJs1QlmKPU6qDpZVkwzwu+fX3V+/psO94PsMpAalugBFDV32Y51JaS8kDpiMS0Ub/+fE4bT4z/wyD/j/2Jzcoc9TKcZdDV8lA9s9FnCQjbRkhgMDFyIswKvpasabndlRQ45CYFwraVbv938wsXtkGUQZlgmWzsDCAkAcxwRsYEkIBDjY4RmE7KkGyflVKlBLJmlAEncO0z1ZmsdKQPtj3Q26jiTwQdH83BEW89avIM0uzB1rdAq8CDYmuPbnac2PeUIv8dM1G3uZYnGDBcyPv6+orL5SM+fDjj06cX/PTTJym7Wiu4AukD4cO/viGjIk0SaPbzf2T85d/rc23MAz+4/KHid/+2YJ4IhD+hlIR1Y+yFWxlyG1I3xl5XPVpX8BUb/q0bnhKBKnlmSXArpRmlJtlyyfee61dWfUAD6nKa7+bj2f6+9gTMPNuzPduzPduzaZvmGfPpBGwZhRlcpH64GXusmZ+HoDVJuSIGWo6Ojd4hpdfQ/bWm+I9CazNi9AYAoAlmR06X8dnNmNM3c5JFYRZAZ4QHmjMi1k42grAZTAYBPPZhBFP0gnr7bYpkdJ7ETDUMaPRJ61dUwuO99r1dEyOzLFIj0iGO15SUI6VidHyPTqb3lHl3RmjKfLm2qqG2BoB5e8YjZ5kZQI/AQ52lJfztcvbQxMFhyPiKWNrIDNxWuma9rf7OmBXDDH3RGQNA0ogDzf6TsvwmgNEy7oAU6MHkhmHpXCutIobf6kq9GM3hfdz3DWZIj0aLYyOLKkEaRToa0SJtbKyRxpVbNB0ReRTiGIUcXhfmyua0v2C8j9nWJlA5rG81hfTZWdq17d5+bVtUb9xfFuUSU6X2fMtAcQ8UY5iRYdwDogg/MirKdWYgaU6GOE+jwv/es+J1kdK1FP/X0bxGg4N+031m0UBGq0i7I75h9x2tOXveaIwE+uh1LxtHGSlZppsa9qfUvKakhpmU3SATa1en4KDxsoDh/aMBPfZpNIaM6X299AD1ad6jsbdqdLEZd8SBw+AKTHnB5XyR9O5aEiNpCbLbvjoNj84UK+dh/WVirGVHTiuAFdNlRfrpin0F9us5gGQEIGN/s9WMPl5Kv2krW8HXv76h1BteflexnAoqkvjnSY0lkH3LSr928v14k+P8GLjwCIhhN8b1blF2lj7cL0oxq9G4vpvR9z3D6SMj2/vtO96Vo/YDl48yw+GbD86FI1nmUbOoUDN22fjH7GGNB9g6L4GHqnOdoBng6BcsDuPFjwyvx+O4M/oxPINVNNJ/T1454pdjxHuUrfys1PF2wJdwjhJRy6oxjMt+m0HW7idiTVHfDI/G00wG9+wwSRwMTifmuzmUPtcW1cusZTPEILuBUcvu5aFE1mqglZiNz8ax700+YAUHLMtJHfWLn+PiQNELYUbohJztbN+wrqs68g2QINlqJGuEgntIsnZZeZk2xqYjcEfnNPwbLsfF88PmQNLjK4Bna1lyTDeJ56aBeLrz09d/P88N/BPlabknZ3PvGS0qiHb/t8iHUvogJUZKOj8pIYU+Wbsv5SogACItuQSh0b5bdp7UZbXc9w0M1kwskqGhzxoEBX8dG9qFupJ5J6eWfn/bVgA9vQ2AYtlniKBlFtgdZS2TmGwzK9dQiqylOWcpO8wtG0WM9j+fzqhcsd4kU8+s2XSiA3UsBxJlEKNNDGiIZQXsGnPYNB1V1mfOSeQjSmBkXC4XAMDtdtPSQScF0BR8+/YN374K8OPTp0+4Xl/x9nYFc8HpdNaSv6RYOeVHGk0ugKECoAGLpmnyzDVvb28OliEizzjz9vaG19fXlsUJ8PKcBGCehV5138AmnydCOp9Qy46vP199fxOJsz6lBK9tyySlG0sRB2JqfDRrVDzAYd0SEkFLOCm/q7uWeRK5bJoWrLcdt7evAlDOUlrndF7AfMXtdkNNVnZ3xjxN2LZV5dMdb2+vYGYFiyTcbgok5IriTuHGm+/lxt+m0QN7B/Cd85qg+9/4vWQjAPuJI//PGXmyEhwZy7y43CTOxezZyCgAH5znO2hPMl7ZOm+8Yned1uZ0miYYRFGAcvLQDx9e8OXLF98TLn+r013k9j5LagTQ9HRTPYalhJLNUVeWOPIaXYtGL7Jz3PUEe/C93OQfvyPWGd+I/Mf5SyVIFhYAtYEsoSVXuvpPld1+Yc+957Pwee66xAxYxjWXc+xcus+uwiaXcQO9ugCi5xSoOYaFXg2UCojOZJnhxC5EYGhWGYi+w57Rk73UbmyWkVS62TKG2Lw7EOyu/5bVuZeDiAAclGs6sq94v90IkQ7XWpQ9u74ZHVVuHbv5yBbwno2Axrn7wdbsp21sADQA5XEAjmXn68ZW5T7RgSWzGwAFu7GDtE2OyqoPM3aXEQ2sucwzrjl1fEfmqmUnKUYL5UNibgnZfrit88qWsIy6dUuWXYuktJaPkcyY2HTVSKgjnSDOOVH260d7BLPYCIRnNvuc9E7tf9zbwKrpOPrsaVqCbNHsJiZHbptkSLN912xWykt0/qqNjxIoyTtLLaCakN2uICDLWivmPIuuZwCk1EpXRz1y2zYp98eSBY5SRc5n7NvmoOpRLzJdxkmvq6OUWKZMwG2Pmtllo9x5ZCuI85gcnNg3gmXj7P0Icc6t5JI9y2RCO9vkmtFOS0AoeSS8npxu+y5A0U8/fcLlcsE0ZXx9+4rbuoKryMdznnCeZ5xPZ0jyHwt4BPKHDWk2WUjLejKwvPyEef4I5ox9B/a9ggnIC3SWA4A72GPvaXig/7ocK3RizyoEQPdXqeFsrQQk1lJOYS4C4F/KyjMSte/lmidg5rdqT8DMsz3bsz3bsz2btmk6YZnPIKxaU1SMnxWWrpw0zawBG8Rwqcm7XU4chade+CQXyluj8NOUGDOA2k8SnXMQlCUl9VHmAvvdUlw2IdmMMwZEEcBBBJnIWC0jeFSYp6mBKpohgJDnVgonOjpb9o/qEVTRoGqGLSITMmsQ4psy2Sm7VpqDEkZBf6SFRbyNWRFiymN7XwR7xGc0wb+vlR0jCdv90Zlyr5ib4yxBnM+JCHvZ0UVi4V7YPnovoI6zJEbN+O7+ee0eE+SJyJ078kIzNlRVyMhpU2tFnjJyWpAooewFeUoePetOlpQwzbMaBjRymQiULMJRlUrIb6oS4SjXZDVQi5GvUgZphqIOkRYcIJY6VMa1qZG4ibf7vvq4U0odYMrWlxigGFKXto+ejesYgDuprH60K4lVFXdiUI2ZYMKa9WjsZiSTPvSKVvy72nNZrRGmDGnUS2Mjto+b4m9zOabqjc6LETgh0TNAUUeG9ceU3GRltAJfqrV6mumOXw10PGry/h5gsiyLO1KOGhHAtk6a7hksr82xx2qwtIwrKRgurPkYgrIenZkjiMXKDjAzbrfb0DfyddYZfoafSFdbT3YfAC91wJVR6o55npDS5JHqRITL5Yyya1kFqKOtskd3itFRxpAVoGb3m8HtiMe19dX2v8wn6dy3ubIIcUvFT0TurKoVwJyQ86yZq2z8RZxc2s9aLeuCvTcaX8T4Z2UebK6EX4vDwIwvNGWkiTHPZ3w4/w6/+1dfsV3/E/76H2b85d/9TxhM4MPfUFqx//7tXDet/e0/T/g//vdPAID/5X97xR//u1eIOj6h1AmUJlCaQchgTEAl0JDZ6/vNnKL33zRnWp9xTfh1QQ3l7/wMCXvZHdYc+ZRlagg9YNyt9/adABYeekjeG9mB4dyeaS0aqGFvOaBfNFze9y+eEfcG+HHPxPc9an7up3aWR2CbZReqCszzEoZmjA/nhfxhNBTDon/hac6PmvV3lBHvwc5AAK+oNVyMhPAzyXjX6Pi4N7amw3cYDe6N6XqOBUCQZVyxATAafxNHYT+n97wt/lsIyVSCv4tc/usjHXs6iLxmJXXkzK3VgABVyszVqn3KIpfpuZxSwum8uLPaIvgrq/Pa50VkQuvTMks08el0cTBLlDunSR0oy4xpSvj69Suu1zd8+/YVb9c3EAGXy8X3sQEfcxbHTaKMKU1gBuapyUkG8kgUUoxbqTwCNgWAdMuL+nmNAAhzCgGTZH9hMfSXfce270qj7M5mmauKog79o73Z1lQDhNnne9mRkjj2zfl8u91wuVzw4cMHzLOUaIoy4rwsqicUf988z7hcLvj69asDj97eXhWUcZHyW5RAKbvsUKvQzvSeeT6h1CY/EIlTpu5WLqeqvFzEKRPG6YQNzeSAnAUoErNrCi0KgCpAJYvuR/W1KOMTub7tQfISLKfTGZUlDT6R0OZ6vSr4VXk+Adu6YVs3LKcF58vZQS4y36IbjOVva60ONImly87ns59R5hRpJa0ItUgJtSYPAHvdMU0zfvrpk79vXQ0I84KXlw94/fYF+3pFSsDL5YLTMgN88vk5ny9Yt00zhdj+Aq5vV5Rd1l1OwHLKOJ8lO41llCEi/OUvf9F9OHXrPfKQRdeVrbNWlq0vpcLMoCTlr7ZtxV4Kpjxh3xk5b8hJMk0REchKOIp3Eyk3fsw8KUiiBh6dfW+Ivi08qHJxuUcc7EVAiKi4XmW/XK879n0DwDh9+IDPn/8me2OaUbX01dvbm8qyhNvtqj8rlmXBy+UFOU1opSeOePRv245lheNrY96MqCMImBsgKxmi2VamPGHKIpenPHXzKqXBzj7HzTbU+LuI0w0IM8+z6xpelk/1AuNB8zTh9fWb6wnzPOPt7c357TxPmOcJnz9/VnlcypQlTKj76mMT2tyflb7PqpZbmyVDU84Znz9/xjzPnlHpCOAUAT9mX7FxjPLRj8hMQJ/91PZW1NesGe94pG8dnR/2eZSDgZBZhptDebRdGQ1HkIp+o+egTLroyKabQ2wdRCAtowRqMljKEyYAZReAWak7uBYBy4SyXzln1KTlzjQjXcpkCrKuu6rBIvCFL7I6eek2Rss6ljOhVNkJ59OCGuyayTLfhnVzFKhn44hrgChppq2e9u37no4232KDrF7C0Nb9+E6biyNZ/W5mDtfcezJzdYe/jbuBt1sZnzFTj2RDtbO26hmSsWMHa8AIEbxMpPUr59yArSrTgARgF+0Pp9NJ+Mx5QS0VeykKAGFczhcFx5jO3pzumVo54131O2NRRBIANs8ZpRA2BXjLvCpfpJYBr5XMPKZz1AniZ8220OwZvexvups9uOk6pADZWndsZUPRIL1pXuR8oQymHVQZ89TOXHABpwngXZ/GAuCE2SgVTJQAFNkPKWdQniWDW6mYlxlEkwMa920Vn4HaqQ3IbD1OytvHtW20WJZFbDz7jvVWHLiRUnFZ4u3trfFqzW7DqCJvQrLe7MUCbs3WK+NqIMlm+7VriBrvi3Mz2qhsf/ic1LD3gM7WQGrL73XAvqyh6QcG4o9BWHd+ATJbgb8NpRS8vb0BIM+ytNeCf/78z/j87bMAluYF5+WMKSfJvJdnMAq2vfiTXv7nv+DT/7DhcnnBMn0CeEIphHWbsG4EVAVKEcuaYSnrxChqip1gARdjRnyhb4VkWW60HW2xLUMyUMqOnYO9F2qfnghTysoPZIEmfQ+HMuVcDWBu9spnSabfqj0BM8/2bM/2bM/2bNpOyws+XP4B+3zDkhds2w11u2EGY91YI26KRN8Fw4kEeJhoz254EdlRUcUuCJmQaYr5gAK3Ovb6LHmECY8VTAUFVmKAYOAC1/dYADT+BAaY1a1g6HDSaMjU0qkzM5DMXUjugAVDU74TsiLh2fuVVTdXUEy16DtRbJpw3pz4+2ZuDhu3CKRRwBaATQPSRGFdWgIhuTIYW1SYo1Hd3iVfiXNPUkuacGuKRQOdSH1WwlYs1SE5Pcxdg5QlN0mIYqhcgUqa/tOUZlNGEqapZfupRaIigCwRvqlFE0QgiikUpuD0Y9Nno6UOlheELCEEcErq91L6IHWADDOGyDhtNZuyr31iYNOaqrUy1ioGVElXCs/yIKlQRZiHRtH57DEDAXAGChky2OYRqLz7HvL9EH0zLBGRbZkk5Gm21dutB1sTLQrD3qNrgWYxFhB0/9w7Ec0Q2J5HGtka16AYszsDQWq8Qt7LZk/z9Rudz21NS9QZE7vDKCqNZFHvIB+QBG1HQwVQa++wjJHs8bOWapSboTc0U6yjkcwNXRwNPNxdb06dqJzbNXlqSr4Nr9RdjYqNdwBt34mCzr013OYzMWopKFUylojRKHUGKXv/GBV25CCPQDgz1M4GCAsGvLGNTpD4DnOgRRqbUceiitxwm4U+276BaAclwpQsIn9DlgUrBhI1ktRahZfk5vgpxjNIajDndGxYNJrEklPRmCkl44TgHPYZ2ywygzBh1nnlythh5ScaCMPXHpNmkm0lGCpLNoY0qXEFjL3uqJuUdpNxyPrIU5a9lTPOH36Pl59+j5cTIdcrXuYVlb5h+wD8NYBg9MREheSwsjOZ1XBmxT/i6H6tK6fjEPqw3334Z/zpdzcUzNjKgs/fztjKCZwuAFVU3gBMZh55+OyjefRIMDOGiu3c5Qszcsq53c56OQvF8E4FaPb8BgAl0r1QZAsmKiAkycpnIE0AGdRhN3z/qgEsvTMm4/W+L6nJJffxvMf06OSAg1eNdl6RZayzkBEMxv2Rh9hv482UjA2289QMmLKFFJBojh0UcVjoJDGEh8UzgBL736FzeoaEA9PODlLy+eBSWw+o6gAX+U3OhxJkIeW5LqOz9AwAACAASURBVF8mny/Zc2F3VDHcOj2sZ51TRP9OQT5J5Ou56vXGS4iSgmTJ16P+Er6hwyOyKDt185oMaWcbJHJQXk1SaqlWcLcOSOQWssUgIAMGgYt6M0Coe3E+ULliV7mEwOACbFv1TC1EhCVn5KWdETnnJltnYNtuWE6L8PZE2IsADG63m58p8zw7SFIM51LWwxwMlnFDQAGTGkpvuF6/4XZ9dWcV14rzclJHh8hHSbP11cpINIG0DNOt3NQRJ2nmK1dULXXD7iwDQIy9bnpW99HmRKKTECXNuCL3CPBTzmVZmLufqTkn5LxgOTWHsfRPx2DG6CSmYgdrgWGqkDtcoMDebKU+TSeRkoTLMrnT93SaOwN2rUL7Tx8l+wghackKGcPPP3/Gtq3KB4CPnwy81OSJUgn7XpzGAmSfVBdgEDe+Z+u4ctFxA6fTSVOya14cpbceTSonENZNvpcAZkKthFKgQAoFaelamnIWgHqtSHPyvZTypOVdgCkXCJA1IU8axbt+w3I+gVmccSlNmKcF83xSviHZdfYCLKeLlD3aWLPoAJOCqhIJDWw8iYCUGTnPINwEcJASmItmh9QxmM6j5RxZa6fllHFazr4fCm8AM27bG/761/8CIsKUM87nBVNiXF9/xu3tG7juOE0Z59OMsle8XQtAZ5zOE5iT8u0MLsKPcgbOS8JGVoIpYcpSOsmcT6XIvp2ygUb1lFJHKtsZpo5TKS0r2TugdgSTadtZZM5UQs4nBwLOc/L1Ims+gaFyO1tZWnLgqgCiiv5tIKTGy3PKKLtkrhD9R/rYshjKe6dp0cxMACB7tqwVEwkIbV8lGOK6v6HseraAkJhwmS84q0MxISMy4CPgQu9oQ/fdo3vGz5sui+58ki+jnuU9cY2YCJr1YRauUSpSmvU75RUMzUCzQGwgGe7ISllBK4sD/mz+BWzTgMfkG7yd7KITyP6UOZ99bM4rFXBbmTHPE04nyWbw5z//EQAryOrs9xAItRSspaDWBs4TUIIALW+3GyyjrIyTMc0LQIRtLdiw4/f/8I8CtGBuICKyEi4yFgu6OgLURMCK0cXpY2d90Ent+tHJ2OmqoRlIb3zGvR0Ih+tsdO4f9WVcf0fjMjmZk8naEoCWk2ZuJcgetncya/krOc+xVeGdKQtYXoGNAl4vwqsg5ZuSipissgpVuLxWa0XdCtbrFSBCVt0vJXawJFPbIXJuZkzUwMgE1jNedKyk57nmhgOllgHHMwzZep3npu9DnLux3JUB+UQ3l37b2q+sh5kCR6L9YmyP9PqRH4zz266RzBKSTWsKkrfQtlaWLC8K3KUK5CSisZWN8kw9qoZzFRtnsqw6LsvuSEntZ7beUQAWwLeZuDiA4SkTJsoAVZR687X+9vYm81h34QlEKFCehRWJpCxbrcCynMAsMipXDVqjhEwEwgQmocGUdR3XHYkZk9r1chbFxks9i9DtMpdnweCYiafZsps9VW1UwTZps8Eq49hPy4pVnYamK+0VYE5AOiGdTnLuTpOKSgKWyXMDhYGAgoqcZ+S8AJDyVpkY4FlWqIMkuZU6SxlIEySgtKAWkeFQE1LNqIWRkBTAw9jLhiWJzq6LQ2U0OyPgMqqc38CyiE59Pp2xXl9RduHFpTDWdUMtBcss5Z52zdRGYJgCnlIGJ/bsUaZ/keortvKgdkebPtPNRl7aggPi+WpZYlomk27PWWSt38NipU/Kc/KiZfRYAykbCDLuxeT8RMDeCWHu9adUKY/06eNHrFvF3z5/8XU2TTPmOWPKWXWbjGmZcb3d8Ld//hv++p82AP8SAPDp/Ef8dJbSiVwkoIxLReKKKVXVf4prxbYfGZNwxqroKmbP4uyXAWiWJNOoZZ6DBAQ1yaOWgpwS8mlRvVVthTZok0382eRyRftEzmMJ2GCctOzos/369gTMPNuzPduzPduzaZunCefTGWVKWDKhlBn7OqGWFW9vakBWQxg0w4O6Q4KxS70V/jfcoCsaQXvfo0iIR58TOVRlvMMFKLXKoWWzMFEq3mf9CEJYUHK8v2ipFikoP9IXVdDJwDAaCcMhhSKRK0FtbL1xSxwfDbQh92vWjwcKcnwWcE+r9+8JVCHq/jbDtzVRWkqI0hB7myngDSIF/d6Ui+bI6fvSgEPW/2jwa0YcK7cSos+DQSaOsXNka2fidN6tl7u56FPNtmc3g1JKGRUSMW0poCWSiVGLGrhTc39a9Ck5+IO6WRLFqAc2mUOnX/u2eELGiUh/pZ+qEzC1hAGPZBBbMls3xJjctHhb4Sh1B9gcD0m3AbkxMM6Zrx018oihyCInqvarGUJlCBwM3WZgHFIygOAeIOUjxELXRFmMKOa8ZFaljdW4L4bL6qnXsxuZaq0oLPXKQYTdovPCfMg7ZLzRAHjsjD/YX6okP7p+XOdtb5thCG1PhQU8bJ8W3cLtPvln+9ui0YQOkjJ57LJHc+M+ytEMsiOoJoLVHhn2rWtHe2o04EbDtSvIh4aEx5mtpkAO7w/p+mP29ShRXLqGWIxFR7xz7G8bVDAMqyNsZCaMvhxTc0SOEZkCLowpigFNew+ANOLMIgyddmpsMdqxnqdilEnIU8Yyz7icZ9BegXrDtt2w77bWHQaApCyhUluBkX/qESpGzYGb/tpmT/u//6+P+H/+6YzKCZUzrtuEf/k/Ap/+UQya+3pDtojR7s4fbxzmrb3fzD9t3/l8O8AR4lCtjJ0NxGq8t50dSXkgUZUSJmYY1t+EwLN+MKuMyRbG68157CDVd873Yxo8fmf/XZDdAn+06x45WMJVHe+0rho/SKlF18Vr2932/maic1r0b9bfVtJGPmvnrT2L0CLgrH/2Lpv/+PwGlInyneyzqsbK2qgU9p/zdwQ+qWCC1n32/dXGKcRJBii1iznI1NwMvgYGdroxqw+0jc2PZmr9YeeFYR/o5IS3yopVG6XJFQJWlT4QVyQumumR/BlJx+DZrog8g9u+7xBokZw527aich+NT0S4fPiAnCcxmKYEYklXL474rCWCigPda6lY1xtut5a1o1bJ1mLjiw5XwMqAiGMznmWUErLeY/32cyn1MgEQyiQGmbmXnUOadZhhXp0Ew3VH+8r4jJWXiiAZOwvEYRf3CXzfNaeZLRMDDjC2TdZCrbtmT0iS5UYB6tfrVbLqpLZ3KBE+fvyI6/VN5wtgCHBpngXQtK4VX7+9CbgpJ8kKwFpKLBj9wS1bW9OVhFbTlLHt4liI5TL64ABGzhNsJ1WtWzCpg5LY1v3eTjxu5TgAOdd0Jp1uhOCYZnGUbusKmqRftTKWZfGKHCnlUH5mhmXlAUj3gzr/qZclPcMFdG2H8qnyPIaVeEwpoewtG6g5463Uje0HoOLt+g37vuF8PmmpHJHHv379AqhDN2tWu9ttxe22CoAsTbpeNNtSatddr1cHqJnDyLLK2Jp/BJp2vYGEd1gZBNc1lc7vy5HhbNbWZX/SgIq2d3Lg9fHMDnKU6Q4up6WORzO3kg1xvmK/ahVHIexs0XEkZOfj5iT1h3PTmY/Hy91PR8tA7zs6P5QHHtO1f2bQ5+J4TcZRMGl/FicFzeTGnzXrR9S9OtpR7BOjQecajUwXY1VWJTuZOt6Uf8jaBxIaj5TsdeJcJhJ9ULJcaGauohlapjMSETYtnwxoGZZpBoqU6Cu1eAYnch7IDQTj61j2bA7XyJliYD4FTIaz+pdKsEdnS9Qlj1pcK0fraARUjL/H9x316ejdvSwnQDSDj7u6pDJhPLcqGx9nt1WY/MEmpREJCFQfxKiSVcIHBgUzVRPCUWrBvq/yPmKVWRgaoYBYqs9sCUXB1NIf6avZFAgFoAwBgrSzV/i2BaAFmd3lXx+F8ic7/6QkYc6y4k13AHQstekoBkx14jza8yqTuj30QTv6rrLJl01+jM9lFkC2/V1LbfKv2T5YpUkyW59m3bZ9rUC4TAJytKFs2yr7I9zn9gcLHtRnG7CDmfH2dsU0aXBeZUBLGu/7CuYCK225b9ByZFnAMixZNyiFkkjOs2GCStAM0DThKLTYl0o0s/S5fuDkC3o72u3J9c1G7H4f1rt9LOs1qQ1e+SwFu3GQ2yqXAPZuPN74ec6tLF33XrLyWJoxHKR8jUGoQmckFGQJ0Np3pDwBkCBJrruA9JHBNYGDLMewgKrqa0syUS5IqFjXdu5vG6Fsu2YA1CAwoxvYx0P63hbsec//+rP3mNdF+f6Qz/lejh81/VzuNbu/6EQGpItlKceAsVHGkbOVFWguk15VRpfMTRmXDx+wbjv2Cg0oSMhMWsJ8xjQtWJYz5vmMUna8vPyE6V9V1N+JvPbyhwlZAWR7Ka4T2UErYLSie7nthGZrtgCV9+SPYXyu/9ptpPxE9rwFEdj1Gf3esbnpdLoBUJqrZaZ7XJLr2X5ZewJmnu3Znu3Znu3ZtKVMyJOUdEk0Y2ICcUFlxrreJLqVCJwSKGaC+b4PCMCPK+THTYUqRKF/uMKfSQAp4r8z8th17ZlmtO2cDaGfsazKUa1T+3cT4EbjA8ENu7V233fGYFfgcXD/ITWCm+PHmxkTj9qRUU4cBj3i/ii6KRpd3OhVm6F4dDjc9ysolEFJjHXGH9G/jYkG4foeKBDuUkNMXyohAgTieI4+IwIqqYLITXA3JRhsdLrP+jPSLDrd7J6obNjv7+0bGbZEd5mhqjndG636PaDRmJBMOrsa7Vs/JfsNJTGIJCmGC9V/QKmlDW2Kamdt0XdaFEb8rt+fRp4IWDHjjRvfzagT1hZ8tI22Hl040Kx6VFdvjI8K/ZERIT67e15tiv/Rcntk/Db6jd99f557Q0ykQfw7plU/NrSrYXJQSEc+PX4/7pHhqZ3Bouv18PxYiuQoZW/8u4uE16h/AjRi357Zr7m41sWBbXStahg83pN366GjMd1l2rBrYzr0o2fYs2NK+PEzc/J4VqYD/hOdrGZ4EcBdBZFEm+/7K9br3/D65S94fV00o4xQKInJy50VjLbum5G6gT1r+Kxbe3i/fe90+qf/8HL32R/+BSH/o0Sj1cJIkpLgHaPML2+PeDAli2qV8gwpM1KVZVK2XfhIl4455PKifu/K3m4GI3kJB+Hj++O529Nu8PxtaBGfH3mOGVvNen7kxLuTEfQcNKf0GDk3fjbKBDIPEfRxvw/v+26OPd37HQ+g4WyPcp9Gi7IYNy2V9708pe93t00DrMEN5GI2tExxtkMi7DP2ygGR7fHtGqIWad7tM+5++7O4QX56PjryniOjux206gCRF1iSriBdklKgyVTsGT/aGTmWnJJyKlLuBaT3k8gS4qC3vhGIJAvI5XxpWQl0Pjk4VYgALgUWuVjrjn1ftXQTnK4RiPjoXLHWA2MaaGE8q0aefnRGj3tolC9G2sfzwt4Rz4b+uRUV988fn2s/EbgJ7sFB+y6ZTLZtRSkt0w2zgJlut6tmhBAgQeUKqoSPH19AZIDcgre3FZwkKtsikgVUokAPjfSkKSz0YrS0LHHmtLQMEhl7kbM9Kb9zeqNf504XzVQipaUKuFiJjTZ3BqZKCnI0/bXqmhbekXx/2pm47RuWfEKeM+oqJeW2bfc1ZhkwrWSFAS3s+0dZuWyOAD2BSZyp4rQoMKcqUQJyH5HsUeAsfGLKCaCK2+2KeZ4doFRKQc0V623VbE1JwQdS7kmCIbLT5p4fNxktyidWJsfGMc+zZwY8WufMaA7Vu+++p8/0sqeVAhFa32eKdF55INOO+/foXSOfPOqvOYZNBxKeb1lYgeOzBPiexHT0/qO1M57D78n4P9LIFCzIPElJlAqQ8VGTvQf9iqIcm3z/GmDyiP9G3SEraEAeey8XkfMv02vhW1V4QesLhf5XfU+nX5BE2k+TZsJFyw7GLGVcS60CkkiEpGCZWGbGysFYsyy4fWP/ZY5SMCxJVje+QBhEOSvS673fNvajv3+kHekp4+fjNUc64H2ZDeNNEJmok4v7shx3fSZxMFdz2kJ1IWjGNmp2GrcHgdWGRp5BCLCyWJuDC+WHXU6VDKzWB/bzoJ3PrM5vyzpaUakiJ4A4dTKPjKufQ9M7TXYnzb5FZncE0MqtEKBlpezsq0YazfDW9iiOtovTz4KMjAcd6fX9LXSXsBbtTfqXgGVcBmQJOkmZkEkCyqJs3APldE6rgRr6uSciB2GOvLnNt0CuQarzhtLN83S6e++23dr5ysC63gCwglgZDM32Y/sOIosmtmyUjwJqevDA/RXcyjS14Ue24OOy8k7jHMZ9fpQFWIAFE0BN1ve6qvbcJFkSURmc7nWyI7vKEX/p+k8GkVCdQLMHCmBmE6CkZuLhWlATqcordkW7T/a12giNx+v6tlLZgAGmRd7cN5UlgzxoQK2iykUdZL6RfkZDm4dxufu4Sfr1aL+0rCe4W8v29+g3MFnQynMakD/OK4eNTQQPopB5yth2AcxwZZxOZ5xOZ6xrywBNKsMSTZjmk4JlTlLmmoEPL5/w8pFQ/qw6lAYgS2BsK7V3L5sd0cEFn4dt5PtHsszR32MG+fEsimeIyT/jNeOZ9Gy/rj0BM8/2bM/2bM/2bNpcJ9NIDDESbNh3M66pIYFI0ONsUVU/1h4JSeM1h9+RCOrMo/jWGyphY2jqIkbt0hTk6Khp34UnHwh54xg6oYzuBehmYGgO13sh+0ChVQXlULLHKNDet8fKsRowB6PLKJja2JZF6jhbivvxHVFAjTQR46UoCma4ciXngWEIMGR/e46h8GOf7unbKxvNQGDI9UeC871T40ipjIK/fF5Rq6XoJDeM+HtMBzZ98GA++uf1pXqIeqDLSOtHTUcQXg5Y+ZCkxt1SW/STEKdF6UVDiI+fAUCMp6xGJrYUvfouSUPdov0PbGBdD4/7fU+fNj9ikLa9b9dTvEvn34y4yWhICTn1aydGMYxvfmSwjmvw8b471iDjPPf39hGnv0TBG58Z12osv2TrZjSajWt63NvdPj4wuD2igc3/95Rj4ydxj8f39s/sjaTMrFHZkv1AWmrROBwj+mJmsGayTqlfqEf9HelmrDg6H611WSYO+j/+3WU3GHiB7U+mYwNWfKfV+Za/CVMq2LYbvn35L9j+9g1vX3Zcf17UhcMOnEm69lLIxMbUn5ZSGkNX9fBdPJbe2w2xvWNbiaOCFB5JmPLsyVl+63a/D8jpuXMFc1EDIJBZjam1oiY15LNksuBSAa7i3LElZfPN/Rq5A9A84IcPDZf4URoeP+97rV+n4aWQF5uxXJ7Z32NyhchVzZH2Pd5xvzd6OYwOnI+29uR14oKI996f6zScQRHQGQzJ3AYc1zclg2g0vhLlx8bvGs+JWRfaux+MWwlqskw3Vo47zmSd3gDpy23gnfJnv+ZcNlZykaWGr5pBp9g5rllerPSnMQGQOoUHI6fNs0YgFwcoEKDPklJ4k+8Ro5tk2SCAJdMJQSMz07h2SZycZIC0ipQTElMni1EoKRn7OBpXbR78XFGgzCPnQqR5PIvG7+xM60CeIQNOnL9Rdu7nPDbdB+FsjWf7KBfH78yRZWWaDHBqZQ1MzresCpfLBRKRb1kahN4Gsqi1qPNYPl/XHbVu2EvLglLDmmC2fE9N3olzYLpRR3sW2c3AJNDPoozf1jLByhWB28qM+p31hyDAKHEpVgdyWB/16bI+raTI0GfpTjPYxzkuZUetDZAdQTMR9EJErhdZOUBK6giD6mhVABgtU2LxTAMCUGFfD6zvn/OE9bYCAJZ5xr7v2gctTzXNktK/WsmkptuNMq45UGx9xoCFKC8eZUmKTTjQ8fdH+yd+F2Ww6HSy/o1yWOVejo3PGZ2P4zvGn/HZ/TOjBtKfJ70ubRSw+x6Dzd/XLe6vGfn9I/lzbCYTGz3E+dr2ZspZIuG5Ypq0rFgixCAIP5+pndC23sfMiQ/pyLHUZpRu2orx7KhBFxS92ujQxpwSpBSMRqrHLF9Tnrz8975LFpka9qKUMRTgjJQDnDv+FdfPyOv7+TDJepDdiPrh3dHi+zLae+vR3/EDz2h97f8e9bSja+3f4+9IRwHJtvVgZauO2igLynoadHADpkQQdkqweqmyxVgzwTAsQ7Fl9sxZgYdoum7Mtmemw8jHjS8TZU+EK2tgB7GUzzPZsT+/72nj+xKQc5UYrWRdA3dyZQWqNaCV/60/zAZE6vscm4Bfws56Z134dyTnbZNj2/6S0lXkcpc1FiMYzN5l5/C4N+I5XUrLXhv5VSmlK/UcebB8Vv0cnWfJ5mblR/d9l3IuqQF/bR61p1KGFaqnwM5wIZbxmSqHaLdWfKyu8AwE5LDTmVEUONTzYmo0QFjn7fiAAXW7fwNa8jzIi1DglQatGTjH7R3yUtl7lMDpHrDbaNr384i/kCh+2r+gS5Bq6ilj3UUenFEhOUFEl0AlVGgWvCK0jjqay2xqq2QtgQoQ8jQhJckYbfwb2YDyRYIdTFfjluM+8unxPH2kj8b5ZbZx4u46+449O/H/x96b9kiSJFliT/Qw84jM6mMGyyWHJEBiliAIEOBH/v9/QRDg8gA4g8XO7nR1ZYS7m6mq8IOIqIqpm2dldTe/uRayIsIPMzU9ROV48mTYgcPeYH0t9DXLACINQI8vb360R9zYswL2ug8IqvsUAISLJhcwZB0A6odNETEtSGlFTFkB0VLuztZcY3K+MnQWJuaxXs0WHTLhvNm6ftZmW2fWX+Z5Ojtn/Xdnm8fLbPvOSJb49fPw1X6svQAzr/Zqr/Zqr/Zq1oiFRaJJwKi1iuvtE7UWMWYCCSqfCFUVrR8x9J85rH7EwB8XAdAjUk5xhymTwxvRFSz3Aa94jft7I7e7WR/6d+bUm40yIoJj9+zv1doUUKDOUH5UAvet9r+Ftn1iSvn1If6h5g1X/0yBRumPqM4yc6LGGCUoiGE8mBN2Dj6UUkBE3fGellF6xK6Vc1aa72Ow4dCfEPt1t23r17Ax9Y51c8jI+nq83vPBO0e8233mTDKb51EqirFeslK1A4O2XB1EzhBprSGldAjC2HPYT8usODht27lxOzuw/AQTjCZ7NoDFQIoGwtFt1FpBqaVncwQKSJQO42hjbZT9Vv+biLrBfgzeD7r8qXsHo8x++rmoZRij5tiFBVqcMWTPZRmnNpb9Okp/GkI6OLUAYFmWg9FlfZcM5Ya279jLyLy2+bI1cQjs2N/6fOam8ut7/nnmwDiO01HGPGuzgx/wwZXWM+Xl+ceamOfWPjM7TOd72TPP4K5n/bL7zP++ffvWa7cvy3JwoM338NS127Yd11pK4FrEicHQjHahl4UGaMdakewy85g1ZRHxYzGPqb03WK4A8PEcmOfNn3XekTzLfMvStj1vc/bMceDH249VH8MY8OU94+3ScP/4GT//6/+L2//2P6L9/D/hGKIZgQmaIBjEgwmCYfn2ltmP/h5w3N3nq/Rk///qd4BWCGUDQiK8L+8otYqz9m/Y/Nr3/2JISu0NtLYhECHFgJyWLjMsy/h+v+Pbt2/YIVTGVh6AYrQRA1eh/u5OdJCCoEj0gB/o30Hu9/f/psNxCiKQXxidK4UaGBIk8LLBztxZFnkQnF3zGTNTL5/Jbo103yodwNDumwghHwIHXrb1y7A4/K1MxNxXy4q33w/6X4fJSEk/5goLlFjZxRConxuliM4selSGUf7bAx0duH68HcW0bTZ8/9yw8kdDpgymDpP7Xn54mTTOCiDpuU8u+E6BkLrcHXJJ1H3GXs8DzKbDSJ8isoIw5NBXB387zgWAHtzcdxs7YdqguqPWHQzuZ/H9/tnvYyBBAW5QNw3Eaf8IsvRjaDqul8HVjY/XZ5gZHx8f2Lat67HrumJZllOZ/0x2+79HRuiQ9VJW5Dg2XQ+1ucHj/vG6uF1r3/eup1sAeIDXgaT3t4xV3hpAK97f3/GHP/4et9sV1+u1swTFGPHP//zPvY8pJeS89DEQR34DRWF5ATNSjAg5oVXVcY21Jog91FqBObbtMVkURJhq2ME+Dkhv4zLbk32MIUH/FJOOh41h6MEmO8tBhEDArdyw5gUBjFILGA05r6i9lJWC/2tTnURAKPu+6xgElTOeOWfMj50drbWu83h9khkKEo0AE7ZtQyVGSkDOGcuy4Nu3b7o2Em63TyzLgpwT6r6htoK3dcWf/vQn3G43fHl7x9uyotaKZV1xu93wvq74+vUnfPv2iW0rqKUiRpNdRyYZ2x821/aZWivWde3PYq8vy9LnxesmPuHBBzNsTM9ACGd/M/OBhcD2iwETQzA2yUcWUlsbxZVqm8+C5li45vft3PL/bOmNZ5GVJ+8bSwFgcn+cAwZZft5mWXE8N871l++dFc+aAY5SGiA3hqy3+/0OgDo7h8jkR1+I/bNzdAYQeDvaz3+gCHB05x0DWgZErkG6xvzZL6CYAXCQ8SQy+dnQWNbsH//4R+z7LiC/ImUsDPBn6/xyuQCQtW7niZ0JnWXMrUP/7CMoN0rHEOwsO8omrw+d24SPfohZz7f3/Hw/sxvts2fnHjDA/Wc2z5l96D9zdr9hYypLWSlIKSroNR6Y2/xaBXBYM0cbaNj39swewGffM3281gpwxboKe53XSWT/8sPa9Pva+kYkQMai9j81v8YVaFZb1wXM/hI5ZLJn9N8SD5mF1Y2RwAwthWPPfdQBTHae7TW/Rr7bdO2eyY7z3yHJAQFgVvCOysRaK0KKw/2qAJABUxgga39tmx+agL52oW5m6JjbM9u8DD1I9kgMUZM51R+j43+93vB2WZFTRgwB27YpU52A/hhN/XNa4tOAThEAmS4ClCpAqlILAotPx/sbGU3A2MOxrP4v+Z2ZQVwO8ya6rt/L+r0OqgkPPmGvA3qdbsyt2l1hzGuwtQHxg9RakZcEMDqwqLZ6YM2Ce75Z7zyuGajfY5Ad2RgwS9ke1nsyA5Ri17nMLmktuvnXMn881nOtA8QWTXdrFTdsYl+nLOPYKlA2YUmEfKc2Bjn/qd/Xvh33UzPfsAAAIABJREFU0LmvZ95rNkb93CCM88qtc7O97Hv7fu9yUeyHO2qteH9/P4Cpz+QaEaG2Ir5jK2EWGPtecL9vCEH86Mziy9z2gs/PK1pjfHn/A4gi9r2i1jtSqvjy5QuIIgBGrQLu5UCdVaa22kFZJi/9HjyT/ea3xWSP+LGeXtC99zgfMzPQLOv8mW2vmez1jIO/Rfd5td/WXoCZV3u1V3u1V3s1bRI8v6OWDdt2Q9k3fH58w75v3agTZ2IAa+1qIsnsIDOiToxub7wCzknVplCe+95ps4C0V97IgqGP96RupJ0b/ZaV+nhPH7Dnw8+5r8f+j+/Nz2VjA/bZaHo35wCamQfOFH9voP2Wpjb04ZqzQ8Qcwykl1Fpxu98PpUHOHCl+Hs3wikEMmG3bujO2tYb7/Y7r9dqdDN4wFJCDZE76QPPo/7Ec1NHoGGMoY00wQz6olWeOLKPinUE/3hnvn9HoxkMIWNeEZVnBXLQmNgGQz1twIacFISQQmWFzdEz5/tue8IYDmXHxYHM8rlX/GhGB29HRNhuEfvz0CogxqDGj6xcEywYxWulAAYgEQIEVajgz+GB8mrNpUNMPR8rcb8leVJJXdcSESB2IZ46znolCApyR7DI1xl0UObj+mnFG4VHVZw3g6C3RtM59qSPrdg5y+PG0uXzIWJ0McL+n/OvHAJc5FVz/Jqeqd5oMeTocfH4f+Hv4v6lnoYysS99Hf5/ZmXIW/Dvr49z/+bPWfADPOwzsOrOz2Wfm2Hxs24br9RNBgS/ioI0oTWvoEHqWljwvwYLdOu0Pz2DNn1OHZ5Jl+RT4OTtg7LVZdto9bH358Ts4FXHePxsTT38vlNd3/Pnn/4z/8E//Hu+LBCibATMcVYvdwXa7/WWu+xk4Y+Vlemyj9+zx93EfenzvtPHht5hXUMhojYBWFWByDCrMYwEc16b/Obd5ndq6IpUtzIQlBISUOgU5ESkFuKyBxg3r2zsu71/QWgGXHdv9E7f7FaXsul6BQEnBx/qvVUiAR2QFTbLEn29+vZgT3RxUz/Sm7z2rvybwyCh1rs/Ia8Ka0FQ/OWaMju8Nx7Hvo5dNfv0/3MsOlNPnsDEZn56fyfo0Vuwx85LRBEwaEkJIbl9awAKTTJW/S93BXMCoIChjiu4aAsCNsd0lEGtMEaCAum/9jOzXhLx3eAQGSJkk7MrC3jiyY8d4+58GXPbPP5f5sfNHnd2dhcXebwJIaw1Nnd3QwMceag9ChyDU9aSTEGJQgJNlnureDQpI0AcX571mTLNA784CALO9YIBkUENrOrbuXLper1jXS2dCuVwu/Zq1Ns00H2vEB91EN2mH10spPYt93/cecMk5dx3VADL+fLV+2U8PzjljWbD5AYD7/T6A5QpI8J+bn7kHKHA8T7xT257HzoZt20BEWJbc7xFjQM5JP6tsfMFA7hm1VvzLv/xHbJuA2nPO6uQ/Ah+OZ57s0ZikFGlUWn6wBKoYjKDnvAC9cv/e0PXlK9u2oVTdtTF0QEQtpcM8bZwMpMbckIKwE1lgh8LxTA4xIlMEgoDAKESEmPTcrPj69XfY7ndUbsKiCmGvq8wIkRBYsqllF4iuAbSux1iAyOS0rSUffPCliwzIZEFFWXNJA0fG0sVotaGG2uWvyGJhAcpLRGsFbd9Rtjv27YZAhN//9BO+fv2KnBf88ss3bLsAkz5vd9z3ivsmZQG+Xt76mrRzcOw/6HpJYN673mWgK793ZV/IXPo12dc7Hdf/mc3l2/d8CLa3cs64XC6H5A42/8CT61qbQd/Mwi5ylpnun+Wg27EEoAREaWOB/oxn9gI0wPdMK/qeLv1Mbs59ffAXnJ6p8pl1XRUQlUHKVlC5otWKy7qCQlTGI2XuIsDAnYEcQCaGhzGabRZ//scYJRDIoZfNFlaRBgq169lWPieGrA8ipT0CBVSu2LYd9/sVt9sN9/tdZIiOcYzB3V8HQhXYPvpu4oxVNQSxhX1pnlnmn9tjrGDrJswHFPr1A5EmHTHQBvPWKNnED3N/lnBxmMETXerMbvKf9f326+TX9qJ9xvso5u95mbAoUwipXPfPN69XDxrsvgkFVoodrzoRhP2nMaO0Chj4BoyQIkIkcBG/j+hyhBgT1nU9PAeznXcBMQrAShKAdH0EW3uiKwIkJf8MGtIYhIqYJLGIYKw6Cj5UVgnwUV4xAkrZUIsmR3ADkZTO27c7oOdLTFkA+3tDihnCgKLsaMwKeFAwuppFvVSN6mvM9TDWs+ycARm2R+ysLXtRfU104JQiStnAVfTfpOMdW+hzL/qhsg5DfG3CBCbJlyKHGmrdBQBBFYHkOa7Xawdemu3t17/57JpeZ1kW7NuGbdtwWVfk9Aaw+BZtT+17UZAMup8uqj5RasVed2DfdI/IXJOCWwBC0L16HCdGbcX5Q1m/4+ybKueC+b3Mx+Nl/nHvEshsQqfjD3vKZG882D9MAU1tUZE96mMPArplBY+UbXfy9xEQ021fty8PwDLAgacawBUwe1bXSCsNm4Iv8nJBTAmN9BkawK2gFQfuB7TcsrJOxoQUhFmWrcwUERAJb1++IOWMVjdULSMqbUdtO0CEmEIH81v/H87BSfbIMx39MiaL5rKCQzYJYIYIHYTkAX4DBIWu68p8xw6SBtAZ8uxvA/6GELrOaAybIUTEIEms+1aRYsbl7b3LplokSWzJ4nOujZGXC3LOug5FzxX5PPzNVUucMQzUGN35LnvC9p08A0/rWMf4mdHu1vrhd3cWWZvBkrP+5/egv9YZMMrmcdaVXu2vay/AzKu92qu92qu9mrbaCmrZUMqGUu7Yy4aiWZ6dntaUHvBQolw863tBEWtnwZkzZ+zJN/WnyzzoHTCWB1PIfJCt4axHjIBnt5KshEeF2//0QWlmBQ6RhRctg2tQFDNzBzT464ygjTeY/LPOnRwG/LM2z8Fwbtj3j3PlnR8+UE6QQAjcc37PkQOIgbvtG3YFy8zBAJ+Za697RLtlac/r4GG8uzPMnss+T9N4jmeW+43PngW/j0wv5ig048nul0DBnBARnX6z941B1BBCUwfOGLPZGexfZ/9ADgT2OI9ngQtzAKK/5gNsfhz8s1nAQkdODRvbPwMwY3TTUEANwwxp53ju1x0OAeuHOJsYHdCwV4BCdxjIv+G0gLuuN2D16wAFrYXMriTKZCx3o2o8Yx8mNfgsqNp3HAX1d57TcM9NruPH/NjmzIjj7497af59/jeCTMd1Ma+F2dlu78173ffRX2t2FNt7Z077M1ny7Lm8U2Hu+9y8U8JfqzWh7yU0zWBsKEUDaBDgFanTBjQYLLrsc/c4G0d7zqNT5NxB8EzWzr/P7ey98Zrcjyc5b2Ntmd8pS1ZdjIT77Rvu/3rH/n/897gtEfXziwJfjlfxp8d8fbj3evDR929IgP5t//4MBiW73kltpX/4x294+6mAaUXM72h8wZe/ewMC3N4YPZ3PwV/TM+bPzIGB2SmjOwshMDpLFsMOjP7dCEZKjGW5AGC0sqHsb3jfN+xlR9l3lFr6T3ATR7+CacyJ3LjIE/GRMW3uc99/5lR98pz+TPB7eA5wzM8+j4lfg0OumxwF7Eyxf3ZGME+MOE9kmu+DfC/gZBnapw7ndR8G2F5gt7ZsNbM4dcFjfTPQYDTuQac16Ppm1WdxkBH27ESMQA2ABORjSHL+WbCUDViiTmkDnBntvyim/Ww1h7vpYqYXyl+tl0I7Dgr1c1rOW5NN8hw40Py78eexww/7VP/foT8xgRA081meIyh4hsIoqWDXDP2Z0O851o7JLuplcOQ1O/vsrBBdQZzgNn4e1CVgyJhiD9TXCiz5gpwWtAaUwhocBSTw4YGoJ7LNOVRlLek+UGVoZgK07PUzp+xZ4P97DBoGRLfPt9a6g7zLoOmc6/ed9DO/f88CHgZKtXVSazncX55rA3PD169fFbghJZo+Pn5BShIgqE1K/NUqY9KZcRhiE/JYm3bODlkhTBHQZ21VxnhksaIDRMwB31rTQOuYy1IKmAbwzs5jKw91kAc6SswSZOxMNFEZ56zkUWsaZJFrpc4+R7p2AaYA0j3fuAGtolXT5eSeBnqxfWxMOAZamrO2bX3Z7znnDmwS20cSV0ZZzQHeDspsI3EvkT1138BNgjMEIKSIt7c3JAVMbXsBiHB5e0drwG0rwqQWj0ymtp4MwDP0QtIybUdmCr9ex/cfwdFEAkaorR72hf1ue2sG8s9nyBxksTVwvV57gMvkydzmZ3wMpPBROE7fPdNrxf4Z4I7jc5P713vcZd7fop2d6b7PvRsPA0LdT2LzX2tFyhHrumgZMtmDpVSUIvtLEiCcjO5UA+h2mtfT56Cl6TYhhG5LotHhbAjEEgRFlTJ7MSBFAkFK7TBUxwA/6Oahg/S6UvIgS9kCsez0gj5OcArN+bkxy9mz+bDxDmZz6PiQnsMswqHf6+xuD/3+AT0XOFvX5+3X7LRn35n3qZcFvoUgOgNrnxof9/z8+flvZqCiqQvCJLqcN601LYni9gCgqjoBiNonY52SgHFrAgQTXTuBYMzPCSkmNPJsPEAgRooroibwDBuwoZQNOQdN+CFlnLwJGEVLyQBQ0GbQs2+HIHoUqMroZ6COAkJ0pa7tmd1zw97RNdz3MDGYDNAs/whDPhtA0J9JD3uUh44A1YVNTuScUPa7sjclYRoPopcZUFSuJcx+vXQnUddPWQsB5xxxu90RnJ5lZ6Fn3bN+dSAWDV9NCISUMwBgWRdhNynCJMVEhyQ1KfcJIEiJXz3Y5VpahkZ0dEbEUZcyXdf6FGMcoHCzd8jrYwLEJYh8tPLgDSOxS7Y9YVQjMsBMX8mQc8x8mIzh0xr7g0FSrpHNr+zY0+hYHk3k9QDqe9l/Bjrwe0vk/tDnYMBgjO8U1M4ECSKkLQloutthZmtJ6dXGjLKbbi/seTll0fHiCgoDsLisF2FRuV9xv0H9OwLQEnmu/jqcAVSPz+Lf93Mhz/kIdJ/lvfx95pcwdvPBjmbnpK3B6PR+rzf50oHGXDsYq6oA15QBiShgWRa8v33B5SI20F6anI8kgLf1siLlhJii7N8QhDEpOiarKuxMTZ+FwcrkSCBleROViNATPCDu6HFMhr4Gnp0dv+YXO7N1zuZv9nX6971tNttd58y0r/aXtBdg5tVe7dVe7dVeTVutO0rd9OeOWguEil+yNknpVdEzVSEGxa9c95myMzvgvvcd+Z53RI0wAJkCa05lDSqY/8OyYB/bALdMPR5O0qlPvr9euWN1wligz/Q9y+joLZBk8LtrGPJ/6IhmhB3Hy43EqWPw8IlpXB+ZRR4/P//e+04/5tTxhkAzqvepo+a0nwMMxzJPj6V25r6dO2yPoIHjc3nDx7L8HwEznvHFvuczd/WTGmA1Z8Fw1Jiz6Nh3Oh0r39cz59UcGj3bE3MLzgiEW0+HsXB+QXM5kXHd9jFk/SB0fUrmgQXKZFc1NDTYX2Iwn4XgoU7VBpAEICV7nMGtdmPXBwjUJLcudOfNPBZxHpO+F/uIiOOCzEk5xsUeRWTF2G/edzEHp563Rxkzf3feIyNoenK1Sbb4+1tfz4xOC3j4/T8+h8M15705G69+ffprzf07M3TPxupgXNNY3c8+CwxHhqdl9TIt0nAIGrNRCFEzzQAv3xnc53q+z7N2eC5mYAZkTe0s8PMj+/axLwQJgj9ey2RfjLFn1IUQcL/fcP25Ivyn/wGbPa/uRw3366snz3naoS4FTn/qRw7f909weI0Jf/dvKn73x4LbfQdCwD/84471d+LszZcVe31HCFnZLqrKCrvSj43hwyMQHebA5PjZWh8nhWR3uQ+M+YetCV1LYHBMyHnF2qTMRalSDkXKokgJu1IKtu3e/+ZWBBjRjqAx78Qc/fejCeA7+8XWwpnOdebAms8g/z3JvDVgiDhxx373QExzEBr9+KNcOgukjYBHOH0mu/Y4j+xaMh4hWODLsrZt3JowE5lzUw8QRlAHrrFr6DySZIfHNOrOt1ZRmwRH5Hwa85+SlWCRczPnFdCMZmFkoC6LGANEKs8YQGzOZD0TYX9q9mVnhZp3E5/8rWPDYyzG/LLbrMdzJGhfgOgyukNnFNCR1wsFtzeajq85VK2vnYPGbtd7R/ZkkyzrZ7Uq64miBoxUF9MM5EBJMi2jABhCTAAiWoUA0DUwJce77dFRQnMOJNoZaf3oe05lqgVc/Hc9M4bJkFmWmOyfgS/euWv7xweuZsDMWQtmzOC543nW+eV+I0vU1oR/NmYpdWjlS/Z97xnkkimvJQraALEwjzk2vdv61lgyjQNJRncw+euc1yY/faDJ66hR2eJACmWzORqrq9tZsYPIhm5u16meUZKju48/A3UfEOm60ve5IaUsMhBWlun4DDaPRMJGY6/ZOjDGlrOAjcnClEb2b993FPp6l+CL6DcpBgU0sDAjVGGcqWUHQYKHRAJ8YIaWWg0adFoFPFMbYs4PerM/J496pgdJHhkhrNnemNemrTObm2e64jymz5o/q2wvGXBNXgfYnZ1n9zi/v8hJLx9nveGxL23sA9Ww+uVMzssf4x5/YZv1+9/wxUe16eScMEYMIkKKCQhml9u6BGx9ev1iyHvdTzz25jx2fjwFNIPBMkN2djfs9ys+/1Sxf2SkHPDTv61IeUGKGUQRpTYgHMH8OWcs64Kyb7IuYMlcRxlTq87WUZ0Yj9dD8rbOVBo8Wa84eU9gAU7SOPl+kNFuvP4W7ey8+d5e+jXb79l3PMjBfvo91WUGdFcwH+TmrGOe7VVWgIHME3fd3IB8Xl/v+jETQFKOCRwRQ9LzWeWxqm8y9gQo8CoQIYbQGTpk7Uh4MMUs7BUafJXnbyAwUoqI0WxUkcdgRkQAUepxZrEDlO0kEkJglR3C/Me9XwrMoYYYtNzwGKShC/qf+q/bLu69M9t61ruPvgg9LyjLczEABb6GOGR7CEPvD1EYTEVHk3FkBawxj0QsAQ7JHpdkhL3vDSI6lGX2/TwCfARI3ktpEuFyWZVt5tYZTWo1+W/yR/7JOZpULweIhGkO+k/kkO1cBc/TEYQsgNs4dB3DwfQxtaQytWkAp7YThsQ0n7W+1smobMZDtz+PgBYbe+dzt7PadM8YejqplNpBn5vZjzufc2fnnmcWITsjO0O3sd9YN4RFtZQdzAJikZJJVrJLgUpsTE1QW3lHDBEUEt6/ZvXXUR9zMHUAXmUDezCIYgcvBafv+xJHXpexNuvJ83jYZ/xP+6iAS5raluPZQ5A+RmUpqq05liyhOZrvyexLxg3/YEpJWDy1TJU9U4wR6+UN71++4LK+qUxqGOJVEqfE19mEIS4QSt1BIaE11v3jWO7sedU9yl2pcXJcE1I6SIq8nD8fr/n3eQ7+mvZreuMzG+rV/vL2Asy82qu92qu92qtpa60obaiwg9Ri9NERlVgNA8kkaNCsTsKhsKk485oCCoZjZijLw5MuCtqzvjCGDuQVrfl37q+Zc14u7gOb38u84cOv7H5vzWeWDi/LIcvGjCu7O1s9cw3cOgcDkRpo5B1I9j7Bs3J4xZ1dhoLv7DP988F50u3oR+PZjKHxHeoZMhaU3XfJXhDmjRHUa4pS5zZALTEYOMiM1JHdYo5o4FinV7JU5D0xPkKnVLc4VWtCH0lAD2yYM555jL89y3Cc6xrr9oEYo2ayyms25sPB5cfpEFTpNKtNg3TqLIhJjccGq8/LGIYu+05Mc2jzMiPinxl18zx7Yzc4I0buOwJ2rAE0Kyth8yxbUpwG4uwYa92CYtD9bvtV3QrdMBbZMN7zBlV3S7M4RaHZ+pJdrI4Y3Qd7qWhl1NeyjPfGrDTMcE4JLQGm9Ntgl1FsvSejP9b+eSNPH1O2iGYweqnFGA9sjmYvIObZnJyOwwnijXbb59KfVo3K2l/vsf68ZWuP+Wf30ztI7bPD4WvfZ62JDIZklHS59Qig8Y7QOeB45lTw3z/IrhOj+Syg7+/5rM2OEMlAVdYIHk569bcMh46Of2PqCaj+LmcG+Nl42KI4C4DZ37/luZ45jvv4HS8CC1BKptbIIosxSLbfrWHfth4OZGKYa8Tzbfhw4aNEQv/uNHM4OOr6a2ftZG8A+K/+m4Z//J/v+NMvN1DKaMs7dl7QsKCFd7SqTkz9fKABzji71zz+z9qzsT8L6vhzvL9m4pDHmEiwrgGoCCqjQCROKl6wAuDWUFtB2Qu2fcP1+oF9E8AMWsG+faKWTQBCUEaEUsY9+9gZHbbSJ0/U2t4BPjs+AUdvPssnjUpINuTQ4UQmMmqV8oj23c6Op+PU7PwJBG6EGBkUR312gDtotssGuFIE+nT8FLhs35jn2YR2G7+bHGSCrXrRm0awVhSvpOPE7p8CeSOBEdAao1Zhv9i228hMBiHEiFIYQbNpU8rIWRykMbJmVgpbBwAtH+jKK8B0OoxxxXDIGtPGnKE/nn8EsGNUfTyYDG99yOZTAqqX29wbCJYtvKfO0cYDpIAuOy0gCoBY5aoGl0a37AOHezIYRpljzuVZ96Jg7ErUPyP3iVJiqQExBiw5Ydt2bPcdnIWpMETRS01HlGzu4tY+o7amGZTAsq7IMSGmwaK475sEWphFt1RdIVAUhz2gDmsBMtjfgYKyRHHfT8ySwSmlh2Lfy60JMGXbBMr4/vYFeVnA6sSWUg5Hmdsd0uTGio42Tz+7G3fiTWN1vN/vCCFISaaYDmV1UkpY16Slm+7KRrKBALy/v+F2vw4HfkzoGcJ9TsQhLyWN7MzUEhe19WAnB/SSX1A5UKsApRkGRg9gEMpewBigc5vPEAiN9fxnICaZgxQlk5lbw/1204Ckrlk9rsmUAdI110xvhwZKxQgNUUp0AKT7FUgpojWgGuUTkc6/6VnD5jAZG6Ps25Hlzl1vSynjdruhKWNinztAy/8BtbTO/pJSRkoRtRYQWTZyRa3CEiPlmQSMGQiI8Q3LekEIAiyIMWG9JFzWC0qt4762xwCX1DCX1pX5PgbPBstVbQ3QrGT2utcks2qtoDCYjYZoOA+0e53SM4rK1D0CXS+XS/88zM5hC9B1wTTJUeu304ZO9Aj/TPPrMnfo32fnYxgyc9jYQ28Y1/ltASSzGX79O2OMznQjW98iXylYaVyglYICAawxGDkl5JRQeYAMxsJB74/J7jHm0gx4amevZ9REggbpgmauFxA1bPdv+Jf/m/Cv/z4irQX/7f/6n/G7v/uKePmCEJIO4AK4szvGgGVZcevzX1Xmo/d5lJqQfvMw/Nzw6hjbvPJYG8czzR7D1pzeVw5MGIDA5qIHRKH73M/Or+ivZzZUn8mTdTnvj2fXPNOdz14/s+XmfesB3v2zGEM6dEt3H/ly1xHYQMKA4hfd2afdsTPc1pyM8wDzEgJalRJevt+l2CUc2IckmCygiAEMJAIomS/IQA51nCuRkZMAX4bcR2dIEVYbWdel7Lh+XlFbFVDXsnRZaQHqLj+bJCaKWhYQAwQE0m16GYvQ/YVw6858Gr2u5yj9xXwALc0+o25TUwCx+OHMAjPfY2NJnBzlocQWMRlam7ABGQTd5HDTeWaWsobggH2/Y1lWVGWDjTEgJykZuWm5He93MNBpG7SL2O53AQ8sGQbKgFq5wpxXut8DurYEbE1SdpuhzFWDuZMoIkB9l8SIJOwxjZQBLUrZGntmVvk3mq4V8sDcfrrIvfRlg+V1RwSZRDpez85pNT37Z0hH2mxGAoTBhFXfUV2lqXwjn8QH0U9ZF2D3oerd+7jZWc4KkNd1W1tV1mZbu47NSYGQ3Kqy6tj3jvYLlGkGCGiloew3gIGQEtbLFzC3zpwLlpKx3ER/acocCqKuv8nMm05stqT8PXxN1PvS1B6w84MIHRQG5ok1ibofaezd2q9v9lcw3UjBeVKuSxNAEdCgzIB97QjgrNaKqGyCMo/DvuBW1YcA3LcdeVnx/v4m5RIhpZ3KXmS6Q0JjYNsLYir93iCSssHbNvYGmc0/xuYAxJ2OjVlHO9PzvJ/cf/bxLBl2sI03T7YruGtPXXcf+8kd2boxSNkVTd0TMC68Jfpqf2V7AWZe7dVe7dVe7dW0RWpAu2O7fuDjz7+Ig5WBkBZEJGx7kbqjrEpvCEhLQGkFREJ5WkpBaTve86o2jBrCDeAKBCh9PJmzqjoFTZwyYoQOivuheJnzy/d6vCdKrX7HPs0EotadWE6Xdoq8KrH2t/bNjGnrnxm5IYpxYmARc67LvRNixOivq6ncazpbz/WP1g0QVbTJEOcQxxBcwOXocXs+l3GMm2Rd+VrrhBgWhEAomoXa1LgpRYyBXju1Cq0tkaHnh9PBrl3UIxEQ+hhKIM2c7F7phgaTZI4bCzOEjSu3ilIrogZyYgwIahya0zgEQmsFe6lqSGoNYqe0z84dZvTPSP+lTzmnbhjVWrFt26GGrb+WZKYwgKp9VuCPOv1DZniAirc8Rj1bcwY8ZqQSjXESx8OxFM5sjNg8WBDEmFm4G/WOmQdiTJsDwhwpfR32NW/ddk7ABjQLTvZghBrs+n2jCjZjuwOa3FrhRiiVUXcB2sSYNUMkdqN+zTI5rIGuUgqsjrZkW1idYTGWl2ignKrAGCClMRbbXpQZaxh5tQ5qfAn2VC3rM+oQW6AsENBQUdVQFgPY3IEs/lhmAAEctBxHn/+RWSPrp+EIhGE0lG7Y6bT0tWNOQ2NuOAZo2K0pWxMWVLIyV2PyY4y91I1lrAwnpzrlXF+5UXeQzWxIc+CiryH3+/cc+2dOYFu/9t4IQMUHGmkrV9BaBYWEj89fEBPh8uVtyCNUBfKJbI4xjiyyIBnhIR7lhWcD8/Kt90Wzvs8c2N4ROY/Jmez2QajHa8mceOCafFbvwQJiFSetUGYvi9BN79uOSAMy4FbqIUPfrjo/CdPjs521Y8+cE8P95V2GBOBPV8I/f3sH4t9pxnBSOmWgblKHHVwAsJyxFN23n/RjktE/1HclwdPLAAAgAElEQVQ6zx73QAUB7B73bndQ696OQfpWq1IiZ1uXxlJCCIhIeUGuK2LKuN/vUqppv2PfNqHV7uXtKmJOaE0CoQ1amjBZRp8ygHBy/RkyfASYj/uV6y7ncxgyper5I4eO6CZc+AA8CyzlpGxkI0WkLOwPljnIGiwgIllztIMJCEYpHsZ6RhNQAto47wiEvd4GPfSTeTQmATsra7XsUwFMRuegY5b3jWFj7GGTTaM+u41BoIB1zcfSf0R4X39SB7X9805Zuc+f/vXPqLViWRZ8+fKOZVlQasFeCkJMiDHruUEdcIx+Jjpwinn8WM9EP4c6LD7YEa28DBiVgdqUmU3PXznjNZg1fI5dJgB2dimIUp7I9UvGS+bXzqaGVo5sK2AIs4N/TQVErU0Zo0aWrv+ul+sSSBvg2dvtQ+Y4ZTAUuICC2u5YQsCyEmoFStmVwWlDaxVZSyWkuIAooTZoaREBCFVbfEGCw2ld5MxR520VRU+Al6J9o1bG/X4fwPAYO/NN1hKjt9sVe9lACEg59oAEKZBjCWu/V6mM/b714MZgbxlhEyt/K+qYTZCTXSaEuYo+oGtoWRas64rtvkNwKvodNKxLQF6y6DwEfPnyBX/4w+9xu3/idrvier3h4+MDzAJCogS0pmsqRKS4KDtWQYoZ2yZMWqKbByQKAJo48qlAmPmbZBEruKXUXUBFkRDSm+5HWcPregFA2JX1xvb0siyI0fZOw74VpGXBKgoj9vsVZd8R1wUgUjkmuoJlghMIMQiTkQCrJDs3pYSIhNI2oAmLYogRddukhBNHBUFJcMSCjKabCKDLsuq15BQX7GXrOkxOSXXUXWV0Q+OI7XaDsem0BsSckPOCnCKWZQEAfH5+4MvbilI23O+7AMKo4Xb/FNkSF6SUsaw/ic5s9k5MWCJh2+74/PxEjAnLsoLrhq0Nu83AUICCGTv4wZ7VZKuwp6UYwGxsD0H1qwEOERt26FH2c2ZesnPLsqftHJEgdzkAZmzf2do3RsG3t7d+DRtrYRnAAew2noEP+8cCVcO3cPK5qZl+cDyrPIgVej9Z1x7Ab0F/u47/Od+jjxUddckz3fn42tBpTaf396gGYiFGYNEhUyLECITIqPsNFCPysgrLEgilsLC7NDdGVkoXQQNfR6CSBbKNiQNoaK30sRJCBwKHhtY2pEDIcUckK5tWcf3zP+Hr+o5WL0BIiHlFjX8nwWsqYOwS1G8ZMS5gDth3KS0u4FO1dRspyFV7wgJQ6Aer6l/2twCEWte3oba5qcc9yBwC4ACZILn2nKI15uO4xto0l/bZs5/fa7OuemaD+es8u+bMDuT7Wmt1peLGdea/fald+UX+J+qyO9Mg49nMTtEuRZKyNtwGS5ovLRMoIEKAhKbfCHigIi8rrIxclweloBkcoe8l1TOkLl+3ocdziK5Tygie2xoIFGGpNQQBCWz7hloqUiLkHMAVuH7uuN8Lcs5Y1y9I6QLzyzSqaLX0pLPWClIMWHJAjAWEikAJrOWbGCzAVbEEABYQbqkNBn4Gi7yJFAFSsDgBMQCSyBW67S+6tPfLBcSQUO4bGjekFBAjgCagn4aGyhXb/YYUEy7LF/EzIYI5oFR04DM38YsE1bNFp5ZBDZGQQkTggsIVMURcLu9SwrYMGS5yI2JZxGa6368AAUuKUnqpbbh9XvHxS0FKpKwfjBhsn4YB1CJWW60AXFVni0gpCzCegRgzUszDP0JqC4GQQgbFLGsNwCgbjqE3tiqgDfPZ2HkSNIXTdG/yujd0DKkfH+p6G/a7Jfno6+IXbJ3pZnDiyJlXFbxMKaPdNznLQ0CB6sAhydmsa1lKJYpvlwFUroAmvMqUCQCduHZ9lg0gSTLuKcdxHnIDlw0cggI0GnJeBMiWkvrJGbXULguT+v6ICLePP4GZ8fZ2QaYvyEsGiLGjIIWGyxJEf6tALRJzaDqOtgdiB7oMX1Epur4aUIucfSnKmSf6mKy51oa/pzbxP8cQAeJuZ3gQDkGYi1pj1CJnYKAgex0kJZNCwOXyjhAI+76pT5MRWABcX79+BcDYthtqLbjfb0gpC2gcBHDFve74+z/8Pb68v6PsG37++WeAAkJaEeICIKIUQtmAlgIQExgJ+95QCnSegRTF7292qPh3z8+hgwx3Z4HZl7O/ffZPH30z6o8OMvYq/kVOtaZyWUqM1Srl1WMUxlFh/ArKKqSfI9kHtVaEVrXkqq3ZgsBSrv3V/jbtBZh5tVd7tVd7tVfT9vntF3z7888dtdwaY68VDKn9nkBotSGvC9bLG0AR237H22VFbTs2vqO1glrFQSGc6QzigYo39hUAXXE6M7qlmWNdHB/y8qNiNzsHTEHrAAf/vYdIIU1/Y3zeDC73UcaxjI8ZTmJMUXc8dhrDnhFyDDLPyqWFNrn3W25IZik9KH/fDyJaH81w8I6QECQzdrsP0IcwydQOtBGDWpRiy6YWY7v0fsnnJGBrRrE5TJhHfVb5TIYZJLUKKMZCN0Hrppey9fHYth2AfM+AU4DS33ZnZVBHrTpY3BzOSvxcl1b6L1SvtQ6EvI2Vv44F6uxfSgnLsvQMum1TAyhYVIoPYzTmmw/z4p3Bc7C+NZaAieuHv5Zf8+frfzAhnQWGLQxt97Latf5abFugl68ADhuFSANuGNfTLzKP/vtSBTFmYNG5UmfwcazkKkwMCtBa1aT72EplVGXSYex7wXbf+veTGvM23iAGBdk/VewyxJR1X9kzc/9dgFx1MD2o8zmAwUHu6QZARdjIQDHaGnPOgQ1EhX6v7jTTdShgnBGMD2FQ+wr4Sailpdn6OQZR1TP0XUeoffZ7jli7lrFdkXMMzUGE3wJS+LU2l6Gxsm0WDDBHhS9vZwFj2UfHIIYAggSU15cakZQieNLt+XmIjvXQ/fX9HjR5OX/3cZxMno/PfL/ZfgCs02Nvy/WtjMa3j4bPbx9gEGo/TexEGT/HlfT3CSAzD833ZphOPjM/kbGCAUDKF+RLRsMifepr2kJW0xn3hFnmb9EOFOC9r3Ow4cwZZJ+0RpI9iUd5PM4aOWPXdZUzsVa0+obf//QVt+unMPmpPCplw17u2HdhomlcUetmvUar0AxBk28alO81xS3fVM+Wyt1Bag8QYgJq7A5gdOeZ3MM+G/MC6PnUuAnQoAFoVvZAMi8ba6CFxLnbwKA+ZgRzLTIzEo2gbO9SIAXYHJmn7Gy0gKq9BkCZxwSoSg4kbeeHZB+mcb70a/Zh6M5tK31mWW3Ugzp2xQBY5ihbEEjGP8bW+xajlIfIOSPljL00sAuaMhiBhy4G2Djoyenk+Zy1bU9xFsiycyNGAW9YWQpZIjPji13LlvHMGqV6XRzrQDKKHZCxNrRJ5wAkQB362EEpyoNjFKKHZzPdx16zwDkAlJrRuKqTWeSrlQ8qpeJ2u8OYjKyzcq2KsheUWJHSCgqiQ0jQy5WXIgW8ajZoZA12shs/JwOCOWVV3hMkACABE2EGuaQ31ZsBZgHxcjnKEKjOYOvMxraXl3FzbDPkA/si+xVKGITVcckLSiv9XPjll1+w3XfEuCDnRYJtBnhnYUAQ8Jvo3j///Cd8fHwDAGWUyQrKdcD7VrFtO6x0l5SaaAo+1rCNAz+AK1rd0Zj7PBEJcwvHwRBQW8O+C/DGbAYLnA1g8yiPFWPC+9uCoHZCawUpZ+QlabBW9mRlRiltzEdr2FsdawUDPHf9/BS+JdbSxGh4fxcbd98r9la6ntzLIfagUD0AkEl1DNmTCSnJNVrbRQYmAcWEEHQ8LZtW9rjYFgW//PILAMbbZYWxL5V9Qyk7lhyRYlR7kVEVcHTb9r6WAHQGlhH03jUIrLqvS4KwvU79XDYgsWVZy1qp3ZY82pc9iEQD2CjgoXbQP60//nz0fbbf/d8zSPsMMOqve6ajzp+113xf5nbYt9Prz5pd3wMHemkqPvbN3/d7+uAznX0em1k/PfssMMqllLpj2wmNK1JLyEgIRCj7hvv9DpCAHL+8/w5LzmA2PXj0V9YM0BOMMO4do553aEiRECI6AzGIJFhnTDORkHJSfQpoJeE//e//Dmv4fxD+zX9ETBnc3rC3FSEKsE7sBOpg9hgSCNtBR7I90gw5B9bgfoJPwhC2EscUFIKlqsPgEej/V6yFB1Swgm6+08ZJdT6/vzbfz74z22c/spbm9gxk48/ms+v+2v1M1xifcToqFIRk/YdZuO1Q0jtQ0CQZ9aeV2udLdE+RtaXuXX4xQ8qa6B9sRjmzrtVhYT0b/5npT543dJtebMQVwigjwNXbbQTFv3z5CZfLipQWlKZPHoIGggPadpfrBBkLYYeT4HajHU1BvkRBwRY0Ko1SQGTZc0SAQi86Q9JYaOZ3qCCyxJCA+3aF6RNcxecRQ8CaVtS64X79xF52SVBTZtpIEQGkjDhSwm3JYl90XUHnNRChkQAtW1U51RgtAcuaEVQ27GU7lFyOMWiJw4qPj5vsT2KUvQhgRhPuYgygEMGtyNnZ5QkLk0bTkoYpgFXPsDERQJWVTY0CFjSWFIhOWAqwl118lU6HFZVtrBdZVuoLUmC8vUHOjnCrS/7vSi57YCO7s021PNX1rJSqyib7HQwrAWh+UbCC21iAwahNdERjl4EwnKSYZZ+pHzaHJPdUe4hDQEhRmGB0jYgfNCOl3M9q5pEAaDqcP2uY7ZqybyyhzT83Adjvd+Qlg9BQtjvqrr49bsgK/kGMaNCkQyMmIeo2kNcnLLHRn/GSaKSML2Cn/4gv+Vh2bviPZK/E7hf3Z6ydiaIrxW5nyp6ImsRlegv6d1LKCubZUYrYMzkL6JsV4Clg84y3ty8IZPtW7pVTFD8YRYCC6pURDPGHASxnarNz2eSws0VorKvHNnxWs27VP+F0r9nn7H0psubNO3X8vvexDTZ6PdcUDBbNT9EaKiTBKkZC3Yska9tZXwpaLdi325NnerXf2l6AmVd7tVd7tVd7NW23+x2fH59ad1cptI1KUA0io3O0epqXdhE6SAK4Fdxun/j4+AUR0HIDRZWcqs4ipQmkQdcIHB1XomDTQdn6jt/g0IajAYefZ6G/ofjR4/t0DG4e7zFAD8d+uYAGyH3m0fnhX0spOqUc6jh96O3T5zhrHpgxHmlk0HsD1a7rs6vtNTEoR1aYf/143SP6XOYzKEDG92U4YIz1wwLiUrJHnPE5L91pahmu1t+jwxMQkMOR+cb/7jPTfUDUnBzeaDo4vf3o93XJ2Pf94OS04L7d0wJDj/N9dGiNgJeBgOrRODkE4Qeo5GCsP/TXnNvHMThzhI33bRz5sEbGV45uPr8CaXS4O6aAUW98djhJ/9XpgCOoZxihARRHcG3Me0IEI9YyKHb3DaXtvb+1jbXEmkWYcj48PwUCaWawUeEfxiCwyr7xPCYiGvuxcBu2j+Mc9FfHg1svkpRoTr0gzEwRMNAXqzNsBBmPDn4PnvOO0hm0cdb8/H7PGduf7jcGC/7SNgcxfLBc+jzYXR6DJMNZdHzfKHEl2N0ZmHyZMnetM1l9CEDIB0+dw8/22DNH8vcczI9tjLfJMr/fTebmZcWWGVrgTs4U9/vxSj9611//hn+S+dPHnSJ7eGbOOgtu/f/ZjrLoV/bAtNbOmnGgzZ+fn6vvPUg5kBxXACQZfArGq8ouU7TcBnNFrbvb3wGtmmw+3qO2Jtm0/uwnzWq3dUwaGOqZrQLca7UCUWHNqn8ExZsQs9aIp8P6M7CH9QWBQB1Q4JhEpIMAozMK2TOWbQfvsicJGNThto+5Abr3QRawUqYdmNNV50rPKVIwy3AOmkPWZDpGn/v3Jjcey8yK01vG3cYTbjcxAhCPukljpUoPAkSWQMqgJh/AO9MFjuvtLIBDoCO4jUfQuJlO5dcaj+ezuW/68F4nfrauzWne+2S6XRDHbO/Xmb7EDNDI9PQv+71gc2xAkVYbtm3ra4whQACw+MlFx0xYsrCfBIpYlxVE6KAVWR8V+1a6/pGX3Fnlqo5b07NanK/GoqRAH4qH8wSs4EwagQ1RYCzcJnNo2azybFpClISRzp6zB9ExWD1AYw0/Bufk9wALpowguwXhWwCyUdjT0L3e3i+olQFqoMBIOeJyuYC0rBaoYduuuG93XK+f6piPDixvJausJGtEyMb0J+tosIIoiCKgl2gNAYg5IyGhFmOVNHp9CS6mJWrW8WC/A9BBaPu+I+fc5zIECcbEkBRMKIxkMUXUuvezkEDYW0UIqdtXpZW+/r2t2dd4CAgpgZqAg0qpiFkCEqzMp/7zZkNJvxmmfnmmL7EZ4BgpUy/fAXhmPVlPZkvInhAAQcoBre243z7RFBRV6i7BgQaktCDlBdsu7DUGLhZ2Hflb2CF0LQXIuoDokiM/gLqsEP3z8dyT5x+MKYCBk41N1NaOs/3IlTzA45k6s5aenbkeKD3LEJsHf4058WFus958DJId7cjf2kbwx/sJ+LB3/evWnuoYzIfT6cyPMPd9/unlrQclWh9ba9jahvv9hrJvKn9Jg3AZOV2Q89LPNLNPpSQFAEiQWkohNVgBZQNFUwDKvqPuu5SdaEBOlw7cEVlfEVIcgBkmbJ/v2HfGbb+CygZEIEQB4vT1yqIPcBPVMqUkQDHSsdM1IuA6AcgcAVxeZxs2hoHY5IPyP4Y/F5xtzWbfm27x4+1srT2c/09sjrN5/tF7PmvPfFaPTEajX8+u9+w8A3C6PwkCCPdWRZfVjm36CChWppdAKLv3OQC9tPtwU8DOa+340zGZGU+H7Ty+Nub7GEzuNlnOChpUXYZIyF8UhJyyAEdKEeBng7I4BSuvbUzWClo3NiMSsAPBgt0CHGdAk9GGX26whsl5wahorWLfrsLCxQIMI24gRAG7103ACiwMIdsme0aJZxGyBPuFxcvKsyrDFCA6T2NlGTafRROmmiI6wCifLUAeIU1pevbuCJFw3+4AtHxilOfLywrDTjA3XD9/AXOVNUDk1qmmYDTurBU2T8zozCSH8jVuDYzyhY+Ayoc1zZCEgUN5WeoLpNtBU2OX+GRr0FvuUFVzXlvjFl7fH6zDQESuQcFVIhdSjIACaBhARFA22qp/21riXm63ttKZkOw6854fjKoD6OyfZ/gCx0YUcSnPN7/XasX9vinIxPxAu5NJDXvZO3NcjBGM0Fml/Dh5/+Fh3IfY73q4t3NmP7ElbRobutch/d63ZLfRD9ORJBFv2HxBdeCGUuxclhKcUp6soHTyFcZPXy8gRNxud9yuVxizKmlCIAVhb/r65U1ZtgYISBjZB+Nbt5S9D+l0dep7J29536x/7ex3GWN7A+MXWwOMg5xTQxFWlsDkXU+yobE/iAi13pVRTsA1xk5psuPV/vr2Asy82qu92qu92qtp2+4brp+3bmx0I1UzMwEWxg9FZ6cUkPMFS35TPajh7fKOFBPKdsP1sw7AjDKwDB++GE8WDPZK7giqz5racyP/uYPhL3N8ieP8+bunDjVV5I5obVbnOfd6sf31KSRpinjQIM24hzPAfiCAORsIprx78IJ3VnpH2uwkAMyx4Z18vtd9tPRfmAyJQd8t33eOmG6woCv1w0CJXYnvDiyjpzVnp36XepBsBC/MUBClOnQHrgXKu8Otj/2joTS/Z33xmYPmGLFxmimN/RzIdzxrErS/PohmYJInBvbkyJqBBjYOZuDP7z/fC2OdzUGw7zrhnrznjenj9xmdkvukj/b6o2E+HGbEktkUAqmTRCl/IYHfyrV/h4mxl3v3cA2wiM2ZPretRV0zTCPDTXwIBOZBjyzfGUZpDwaxK3yja81n7JjjZMi5Ywb+6BPctec5s9e4/wcoE8CT5tfL9+bzsD70Mc/W8l8aTPhe8079OXiWtdyN7T35vK6mMDINvYMkpQgggJuW2HHOMpMDc3sWZPHOEx9s8bJ1DoTMjmfvaLXPnbezsR0Oees7kdR/DyEgpgDCT6A/3HD7t/+Csl2xf/t78H75/qA/uSs/vPLXtdlf8luc+99rf9HZPt/X5NzJdWf5+eSCutd/XT+xQJO8RkhpAbQ0HQBkGJClqs4kgSRuWiaGxIkGHiE0O0csOGprOGm5wFLHWh/7ymSGZeLVscZ1MGKCZvQOoEkI1J3Ltu6jZtyRZnyGQAqWUPmoJR9DCOBSFZC9oe0b0MRxO5xkXt8QdoiYjsACsgBBv/4Y5w4W9R5R1TH7xwhKda2vumAK21wxwAbEc+DFaeJF5+tBGaHYLnVD5YaUVoCOID9bA2e/S5BuvOYduHN7kEEAiFn07eacxn6dsFFv9xNsPPiT5uXXAQA1jYPIv1E6wZcQnGWl6VleVyKSwIrpV7U2LZNo+mDStQbEHBWEzcIgQ15HlMzD+30DUUTKGcuSUYpQ8dey9/Kjtt7YAQVAj8DKeZ7c5AEYWffkAU2imTjnrjt7WYC94zJTMOThNrr2eMyD6eCiMwsgAzTG2QJ123YFc0XORlHvyjK2gs/PD3x8fEOtO1KKGnwY8zDmcwBpfGCkn3tEQIME9NRxLVuYdA8pU2UDKjchHwVJuUyKCKEpa9Rg8AGg2eKSTS7vU3+NMco3tFo6UMTmLKWo60ZAPjEEcFC9Tbf9McAi7Fey36WUWEjcZd08X8d1Pc79UkqXd5btXmvDsiydMYcbS+nZIOCZslfdt7K2U0pIiaTcx3bDdv+UshRA14VYDaCgAIbr9dqBIh2811pnOxi6lQGaLPhsyRMS/DR7yj9nl8m9xPAQG/I7uX9jD9h4BToG24nC4X1V32G2C4G7vFdy2m7zSckIA7UNxjUikpIS0z6y333Gu29ePvt5/UvbHDjqf9NxvZ3ZZ2e2548GpZ71ZZZh8/o1YHqtUuKi1iJMLUHYZYR9dgOFgCVKWcaoZcSiZusDUrLift+kVI5mt1u5x9ZLJAKZgWu7omYpwZazsFKU0tA44f2PjL//7wpalWSH99//Dsslgyhgb1FKL0GYNux8sFK4gIDOUvZsrVaGJnYGj1IKioLtjmPzOK6zP+Rsvfj5eqY3/6i+O9v4c5LQ3K+zdfDDNt70+vnzPO6LM734157Pvz8HW/37Q54eWYG9/WOyTb+oevG57fb4vEMfPksxmT8/6ynV6c9ehtmesOC/nJfD3jQXmYF7CZD9wwIwLEXA842lcgkgOpuUMWVIuRsBpREILWm5IwOumQ2wbYAy8hCEzc3Ousa6x1tR5srYz+gAgGvBXoXJjJV5CY0RTQdmCGuPno2k4FkBoU2AitaAYMzUVjIpCGjGZHZgMEtJW1K2u1oLGE3Z8aKWvJWyjALgiwJ0rrvocZ0BmXSYuOuMNuZWljLnBSFKGSmtuSnnZ2dsGTI5KDjQ1kT1IDs9ex8tR/Sza1zrqNdj+vTxjDX57PQ++yQdf/bSNibD+n3ka/sh2QxA20GtIkD2V0ADNWFP1oWueqnaCQy0UlDLsXy8P0/NJ2N7xM6RoGAjfZDjP+0zqz0S1P4jvWZpVcrZBoIBalo1FiH5roGUTQ+ycmA2P152etsj5yx9bBXEaqfYCPIY3G5b6utE4nP0bNH9bRawtUHFbFyGHGlq848zhgh9v5p+LcB6AlGEJE9GrEtGWIHf//4ryr7hert33SvYWHABtQYKhLwk5Gy2sVzP/OBAcOtsktnfcW345s+mZ7rF/LnDnDh7qCeuGbu2swnFQpfxJG66flVnh8kb+ff58Qtq2Xv527LvuN/v2Isx877aX9tegJlXe7VXe7VXezVtQotdtda50Jg3hjg1NbMsLRkhZs2ma4iR8LZepIQAA4gJa14BK71TalfgxVhs6rBmzUwyBcsUSXOoQ1/n/r43ZuY2G/njc6pi/aADbHYYPPsMcDSkLWAAsKh65kCFZB0QQSlIR3axWe2SJen7HsZn7NnVmXiw09UIPws+emrK1lpnfbF7SOZzORhqfhwPirALSHij2BsoRyYQc5wmdapbgEQM8JyzZj0KWl8oyrMESSDZ3LU0KW2gWZLGNGHBFOuPKclHoM7RwTPWlAykGaL+GbwTdR7L+bq+jrdfA88cQGPCoPe1gMx4z+q89/HHMcgkRuKRncb/G9+TdXEWhJmdVP4ztgS8QfyjDr6z5g2no2H1eF0/R+YIs36Yw6L2rLPxjzUjNwYzDhs4RKSozjVqKO2ObbuqcxRgBFDZwBzVkWVrRceDxTJrXPsWNecdLJhgfehGtThr2D3Ps39EFkwUoE8MCehz3WewO9nEIcTuniYMBlBmfOc78tGAQXju/Jz7SeHxWvZdv+b8a39Nm/vk14DJmAOlPEgz18f3j9ndmrlur5NmMjnnq38u4JgVfPhn3ho+AuO8zPNjMT/Xs/Z8zB6dvIBlU2tpKibNfpf9u17esfwXFXH5P7F9/iva//W/oP0GwMz37u//+t4sD3fY2RXNpfe45vxrP9zDHzzTH/p4ch8vg/wZOAe3ngVK/HX8P3+2+vMGzKilIYTkxoxFpmjmnAQtGRFRMiVJpUxoKHvtALkQgoJjINcjB2QJoVPBA1CdzMqqKNtck2AXwbK4RH9JWSnwaTiJe+1z54C0bHUEpUgHAMs0b0KXTGggithqwbYV7EWCyA2EmBfBnTTWmvSqS0J0h5ASWq2qAilFtk/kVIdlVuaGwUzXug/UXMpe39TLqazrUVmZCXVogkjL9lCvxvSwuCl0UM9edpSy6z2iMpnIF0wn82x3x3NhBPJnnWwOUB3WIgadfBMkgvRbnZGgDj1GZ9k5QmZO27z2+83Ygab1MnJe+fM5SDazglM6iMsxaBj40YAXnqGllIoiTPj6vlGly54REEJBKQPgbHT+MUhWtOnNtVUN4jZlbhrn2wDb2tiOgL+wFioYqtsRwLAngs6pfE6c3330dExaXy5W+hSAlPFsQ5YcAk18fF1f7EAHOXPEsZ6SrKnb7QoLoAite8b1esW23ZBSRGsRQMK+3/F5/cS23XUMK67XG5ZFyoxKUFnGyZhlsoKOhOMPyw4AACAASURBVNnJdH505hd52oBKtZd5i1GCWnvR/R80w7mJbddYWXtY5I/pdyKXBghpXUX/l3WDzkZUCyurWkJrBd++fcLKqTAzYojI+QIJPrjgCXHX21oVGeX3kugKElRMOeoeap3e38qxWtmB+/1+OPvFRpGgSkwJ+75ju5deLkb0PbFjyl6VDWewttg13i4rKFRcrx/49vFn3K8fSDH08leShcxa2kNKM35+fmJd177HjK3JdBQAfd/Jng5OzzzaSl429HXMI9giwyXlBog8EF3kuDBCyTpkdx2bBwHnAI0rDMisEte2D4adLHvPMsqhn+zAtm66SUb8zIQRQjiUZ7DXfJv1vh/1AZy1o902ys7Z+DzTlY9+i8MbPeD9TEY8u+asf9hnzfa3c9LAMikJa1dT4JvpnXvZkHIEhQUpkjBJgRECI+WAGEjBeAVEwt4p53kDNwH0tcoKsEkKXPnUzPgFgICCuWX84R8afv9fVtS94P19Bbf/GksSwMzH9YoaMkoVZqRAETFmlR/GficsNKx7WfQosbVMZm37Btruuh+Mwe8IgusGopvX+efRzzBsyXMN+HGd/Gh7Nr+n/ppf+c6P9OnMBzAnA50BeX7kfl43nu0suYbY2/PrR//Nsa+tsZbmebRlZ5/HsdEDaMY+bwBM/51aK7hVWOkV882EEEHBfExWMtQlV6luIvtRweXWTwAxC7ijgGQfkLHrDWAvSTEkBTgwuO1gagBFEBugpYLbBlBEowhoUmIjyDmmulCtpesUosmomG0G0FeGKGbUvSKlDCgYk1VP37c7SOW4MUtRcAlAzKh7kxKaem6/vb1JqSaGgOuj90UMH9eyiM6RUsTtfkOtFcuyoBRROEuToHitUp4whKR9Ev9gTkn6rCU4BXxRhX1D2agqi0YcNLEgxNB1Z2L2JyAAAfuYLisf48N6A4CYqL92XGrsRMLki5nWnp2npnPK6+O7zMKuQ2rYCBNYU6179FdsOrU7GNi3DTDdEUGZhFhsutZQuSpgy5LErNTQo43u9+5sE9datTQvhLU0RXC1AaF+qkB9MRxIygID2Oso92ul1QIBwewG9cuFmBBCU4BNQ0To5/4sE62/nnWvmd2ACO6M3DKeHWAEO0NUp4zmu328fug60/DrEg0ZHKPuXA8o19YTLqv4+wpVtAYs6yIl3dYVX75c8B/++Z/AjbXMpti8DAYrEy0DkLKfyjxDIw4RNNZiwDErnWg6V/vOWTTL27P3vndeyHddGWmo3QsDa8PpIlVLhCmDVJNye0GvIfa1gF3LLkwyH58faK0ixdR19n3bDsl1r/bXtRdg5tVe7dVe7dVeTVsMYmRIoNE5lrpToCnanwAsCDEgEITakwIIDaXtaHXDdr9hL3cwag9cdtBGFeAM0WwIzMCWY6bhWfuR4P4zR9QzQ9qMYCkRNL8OzAaEd5r4ck3i+PXXHtl8wzkpNUpBcEwTYujKV0zJtWuoQ581C4COzjn/bLPDwRyH+y4BnTkQbaWG5lrVZhxZgE2oEyVbRe6l9wOGQx3UWVxGTXvJBrXnRmGMrGRzWEOvI5mh+16Qc8bl8gYA6ugfbBJDKT4q9eP5h+NlXddDf620mDlTzyhFD0FOHGtazw6zAe4YTsjZES0O5eYM4j5jh+ewgI6NvX9WC1Ba33wf7PUzo9Hm3LfuqKbj8/2wM4+PToO5D/41C2idBevmcXpk+uEejJH/WRkKdSoNM7x/nrmBa+trh9VBVPYRaDOHQC3DiBNj8zhG4nC1dUnuHhpE6MGqkYELHMfguCfFKK91ZP/a+hMnrxntsiF8uTT5vHdghg5Kk+mYM5QY1SXfzfPks5G9kRsooNT98D3gsS9+vuc2v/4o46XNAQuTTd6p7+WZBX6uHx+IUdlkaNxTMqt3cJO5yzmj7APASZH677a//X0f1iWG09b31YK9Z+3MwW7fm8fo+JoDVU4tZ6kbvu8F3759aEk5wrouuFxWIDZc7xXv6zvuIaH2UDkOofJ+b6Ze6oVwdsfH146790yGPW8dePQb2m8JLPyl1/OOQPv7TIb5dgzMHQMV559xawHDWWoAYh9EAMlZyWBQzFpOQ9deLQgpwLtam6BpuoO4soAMqXIHKpl7LKWlsxIAEEpnjL0VYhRq8zSBUHEE0RGRgnIEZMP6PMwMDhJMCy2Cg4Gn76LnxICEJGuBCVxbB7UxoAwP6ONUqjAKsGYVppRweVuxbxLwbyzA2cvbG2KMuF6vkg1K4ggOfU8bGJkOS1D6bHNIXRcb64LR+nb0OqOOQUqobeghZCwcuo9NtzDWD9PDpEzEhhijZM8CGqjAgcXO1s0M6vWyG0AHJAMA26/MqKUOvQXUGQzt/DsLqvq/DyBoELga+8rQo6pzAAd1wMvvElSP0WjNR79nAKTppdavlBZIQN6yp1nOpCLfWfKKZVlQi6yBsleUfQdQwEzYNsnIBKGzp7x//Qk5rwCCMtigl+WUMWyOIUHGyY+Ljc08P3JujjEhgu4V6pmT/RwDIaZ8AJ+dBST8WrEAFhHh8/MTMRpwG9j3DSklvL1dEJMA4W+3G1IK+P3vf4/7/YZ93/C73/3Udd2Pjw/c73dlMsli91FCDBHpEvD5sXf5J+uXEUNCKRb8F7lmGbul7CJvtGxigwQJU1jASXQ0mVegcUBjQkCCmXUeeJSzJGvs+45aC9Z1PYCFmIG3t3eAJEBfa9VAvF+71MsagQmlVmx1Q2NLCFlln+ncLMuCSGYbhK4vlX0HUerBFgN1WZmjWV8ATCfIuFwunbVlWRbV+42pZ5TGLcX6tCCmBSkJXX/dbqh1Q4hAyoScJAu5qk5W9oJ1zYghqs4o/bJSIESE+/2u4zn28+VyUcBE7UFo07NiIDQyhrPdJQeQzpMEMbdtlL+S/WtgMBPcGr7r5Vel3wMsY/J1LgM8mpX4sDOUiLvt422vUdqMEXkAg4Y+PWwxb/POuvm8z2f7avSLp34+6gf+Hv78/B5G0d/LbMTWmpZUGdnhs333TD/ytquVYSKSfeXLClsfU8498MeMXgJm33csa0VMEXGLff3JuSf/UpRAedlvMGaH2/2GP//5F0mISYvoHSC0IrKztYLr7Rvum5xJKSW8rW8ghQSkNQGcEZCx3QXAUHgF01XAex20EFz5YlnPQ37bfgRaNX8WVHaMMxiAgg+VrQtAsvPO2W52TT/23n4wu/Nsov1cebaas/Xv7/fMlve22nwNK0Xk9dizIPf8XM/uZW1mKT47u3w//D7wSVx+//r+23iarW7NP998z1qlqKK3xUye1Vq7LDxr3AZziG+zj8fflw2Ars6IbutjzGtOKrOAXvqUiVGV6ayXXNbzNVJAjFnLE6pPruxg3nuyy66lp3PK+twFRZN/YozKBinli5p0RgAJTfpKcuCBSxUd0PYCS9C91L3rFCElBBId/f3LF+x7k7MQDFJ72wD+cm90X5CNdKsVpTWElJAVLLysawfPgYwJoyKnDAYjZ5tzxufnx5BNMUvJWWYQojBzXgi326ew2KjuFWJATAlLlkSRWhVMv16QOSj4PYgs00EhA2MHgNgSH9UmcHYB6Xc7WMWtcfsZjaFYL2D6ipyB6IAjS5qiGHUc0F8b1/XMRkcfWYyyBqRUl4B6Ywgih0NADQE3teOMtYegMkH7tpeKUjYBJjBL+ceUut405AUOvkzbH3b22zlj+3avBbECrYN7iuolqQNpZZ8amFcYy5gZy7r2+1Qr2yWbCKanEIkdSkHXPEPtg+bGJ3Z9yPak6b7+M3J+HP2VBtoa5dcGaH4AZnxJP5MXptfFPnYGpGMIC6KXI/b5YQNJyVRm4PKW8PblK758+QlLjvj8+MC6rpJYyeIjLKUgKijM+ruXDXlJvQRmrVV1b1vHKt9Mbunrwdn1z9psF9rP7+kiD7pTM32sCDCPa/9MrQXbtnUdFpxBALbWEIlRy46ff/4TrrcrzJ4XWSdJ2Nt2B3/ysLtdIvKr/XXtBZh5tVd7tVd7tVfrTbIQuWl5DyIEGnSSQbNwG1fUtmPfb5L5W35BCEAtu2bE/YL7/YbGBVFrUjNIFRhxbkQ1FgX8YAE7VgfbADp4Zcscd6a3PXNkzO2J7f/dZsaNXfMsWOHvT2qY+GbBcP1WN0KGwaBOQWWNELBIEIpUe36Bj8DXeIUi1Gcn/jwe/m9jaLG27/sBGOOD5j4YYOVOiKLUs1VHfsqpG4NgyYax4Ik5ESoMPe4DMoPhRdD+1Y2Jrj2laCzFSjmVA6uMlWix8bPP+lr2w4gbziLJTjkGOA3gQyRObXMue8eWNwQOQU0c15wPPM2ZSd6BN37ODqdRpknWzxEh79lwfGDlzLFz9tNf82j8hJ4tdbamnrUePP3/2HuXJklyJE3sUwBm5hGRWd2zIjvkHEjhyh554pH8/z+CF17IneFyZLq7qjIjwt0MgPKgqoACbp5V3dMrQhE6urMiwt0eeCgU+vhU1b1/3hN+riQ6NkL4zL0yZe+z+8cyNwA0zT8RWpkSIok+MOdbq7cMczdXUPEZfcT5Zk6fGMS4kaKNldud4F7L2aIbjnwM/MkMEEQEkESjAKaQp7ZGPTLXQGJFDSmadYDQ+CszWk1w4w8MTQVbJTpE/hm9MUrxTtUeSWLfB81IMq/PbGj1hhC730fumMHB845HzoRHvz9yQHgnhaeF0Yg6Ahok4nsBBTHAj/cqjbKAEitrNDehOSJCDMM4zs6Q/v3ohDgzdJ+1M0PD72rkzxNx/BlvBIB1Tfj69ScsyybReGvF7bpjWTa8vL3gMy0SsQgxXmGCxPyeY/GvOzr78//j/1TwH/8TENOGmJJkEnmJYDVw/X+xPXI+/Oh6M3q3LEbOEeLplafv5T3cp4whKaKb809kASKxFVqKbIYZChVQw9xPtGE/Cp0wFIjb0GRiLIuhZ3IgAuqSOmjGjLlWVof6ugp4wUr7yFdWapKL45eN31WJgKsFXGpLLV9yxrHfNDW2xczqW0K4czdVZrDJWQD241BQQEJIEeu24vL6gpwPxCWCiQUIUcR3y2SA5KBZxB6vv80Tt3OAGs1Kiah+tpWaUY6jraMAiWWvMcwIPmbLAuQsjDFi27Yh64NlzvL3eHrybZQlNCJWf/cAgxj8ed6debJOfLcdZ2dWO4+t9MVQOpMGedbL57L+2jc9w8yRbf22fu373vi5nWEhJhDEIFrK0UAKgDhsKDCu1492HkUrwYMFS1pw2V5QNVvccew4jh3v378hphtiXBCTZQrxZ7+AAmL0eoOX/+wc6Bkj7LxvTjCYXFon3cnpMLg/e41HWGYOAC0rRkxRUtcD+Pr1K5gFECrzJvP//f07mFkB5hcFx+8K0iB8+/Ydv/76TfZIjPjy9gfNsiP7L+eKfT9gJY+E3s0YL32opZfdylnA9zlnHPkAAmN7WWWuVC8AgMCS4QHMiGvCohksZO7FeRRjwr7v2LYVJhenFMEcFVASh2yTuWTUkiVTBDFeX19hEf21VtEjgzhEwBDQIcVWBpi0iwaCqZZ5CxVEAo4pOQt4L1QE6uWnbK+WXLAf4my/XC4tc+btdsOXLz8JDYeAdZXzmVkAr/u+43q9Np1gWRZs2wUprahV+Ovt9o4YKygA3779jNeXVfRpHc/7+3e8vHxte9nWSbIBCfjudrs1cIQBfhoAi01ersqnguhUbLqZOH66g7xnUZISWXGkeSbBrTcnmcrXUc4PBrd9E09lrq7b2jPs+1JMFlYQaNszdp9lOSJQ6NzMy6+WEehM3j3jrV7/m/WrR/LrmePofn/fyxjzNd6pl3MGBUJEd6yZQ4lIQIEtw9vUn7kvgNCpBcfM54s49S2TmoFL5Z3HsePnv/wZP//c6e2nP/4BP/30FYBkdrh9XvHx/o4YhXeVyrhsm5bPFdqzwhVLSHqsapYLEnH3/fOKECJSXLAkyRSz7ztK7gFCPSeIHux4FHzSHZt2Vpm8Y9/FqCVeVN/yAQz2mB+dwV7fsPZID3/UHukdv7ed6exEY99MFiilDKCzuc3g/zNbktf9fgS29fKvXTvr9l7n63Y0wOSIeQ79fm33aKYFk8GtDwag+dHc2v1+rPPY57/XbUOXoUSON+BhCDK3BoIkgmYoE7BH1ABEOzcFoBIAil3mZwUHxgTwBgtUFNnHwLgB67JADjed71qRFYDZbIahz3WtGhhUoeWN5L7j2CWAKAZkZgSKWLcXLMsFJTNuB8AcQTEiJGgJKBk8E+OokKALNlCJ6huBUKkgLUnsvAxURFxvNwm2rEBhAUZXlgwoRruWGccC5kQ+yEiWOVDnvtQqmUjULhJiVECRZKkmtStmTT4UopRiYpDTJwTIhOKChVhLamLeD0bnJguqnsUVgGT+bKoWUT+h9NxaYkTcxHYq5cNrx+S4zI2sA2QAFhphPIlB2Peb2C/cWuRjx3Hr+3y/XSWrn8wWKEYBh2kVq7Su2F4uCr7Q8yCQ6DDtHOg2W58p7VGQUTW7Swya+ZlAKSISGshHVlfotZYKqhUHJONiSgsYhLQkbMuLymVZs6la1h/Za1ZetkkDp7xkBMl2W3M82d9e5pdF6WttPFTqAnmbmIEqZR4LiKy8cXB6cW59tPebyhFDbJmCb7cdr6+v+PL1K8KScOQrjoPx668/oxw79tsNtRYsywZmQilybgqI7YK3txesaxKbYa0IQSjIZwa8lzvufRe/1WZ7r//cnu1lqNrkzQJYuWntC1fpa8kZJR/Ixw5wwoEqtoLjQM0H9utN6JQ7ODGXotmJSAB+Iai/Sfnns/1d2nMmn+3Znu3Znu3ZtEmZkI6qFgMVIxAjJmopRbkW7PsVJUv0Q953rIukIL0dN+R8ReUDoaXulXS5aIYxMmBzcxID7ocqTaNz1wR03997Bf3vNhe4Nx74954517zAbQb42ZjRUfn9TTH2TBe1SmpFUVJsPbqDX56tznNCmyd5pqRiHOaCLYIdkHT2oRni/HWzkmHNBG1JtQw1dqoD2hkgO/BFBHQo8AfwTgUzMOAuHX5VtLkZvzo4JAJNIemZP7oz3WZRsh01YAEAViNuU1wpqANMVFKbK998NKI37MzGUG/sGeb7pHUDHMmahaDOUEJFdUTTswAw8d1azA4s3x7tgzMn23iv/d3n8qzN7/MmyR/dOEek9bvodBy+j/0eA2JVnZeAquUEDFJm0YJcDTRl95JGWJEadIKLROtGLw5+fWVNKLBg2dTA2mrumqaL4gAyPjJInmV7zH8+K5jCDrQvJHu7ckbl0t4TQ0CIMk5mBZQVm1/LaDPTy0izyqHaZ1FrTHfjY1eiuyJcW1SqGT5nI+SPnA3z34/2yOw8mOfJRy/dO1s1MrpF6/i9K4Y7KYuiaZltroI5cfiHe2eY02bI/X2ACuvn2c/f16wv3sFjfTPnSsG2BaSYEIPQISHg2AtQgchkbAc+D5O5yRkYssz8dY3af3n4jLG9XfDTP25ASFoW6FBe8bc7Bv5bt9+zVp4m+h7oBjUf9QuMGWb8eSIG4V5LXC7okWz6NlkriyJUg6keZoO8JIZBla1a/2xcDLKUyCxnb6SAFDqgA1ovvvFNMoPyyNfI/dSrm0NAACS6d4s5RyoIIjPWkrFfP3Ecu5RBqEVTn+v7dMzdKIpmKG4RcCxlPEouKCgwaM2ed/z67Rfs+w3bdhEAHWeJdtSykDqs01Jz/Y1tsN0Uy12Oqcyoh5YZ0vXrciJr6ntdewoKCAjNYW2OHmtWpqeVkSpFnABmWHb0NDtG/br488nTBCD9odDBVbZ+5PpxRvuznDs4AhxgVPSEHo3q+dXQN4zlKz1/t0hw20MxRtxu1/Y+e05fR5FJu4PM1ipqNgaSci8Bmkpf9BPSzIVe5jH5kBtQiYYx2BnTZE0ng5qML2sl42wAIu1X4C5DNtkEQQAZJ3Nv6+5phhqvFWC3yOBaBuwwoE1sAKZ931u5IDsnAMkUsyTJzJOSzrfRAwkIiaiCqAyyGwDpL6OtfYwddMekgRQOkN1VHFKZl7Ctm6xzKSiFxUhepJRTjAu46loTQJDMRHETYH0+JDI9UGyZAcicF1VKCsj6RZ2pLufJaa/ryrreipohQLJqwfhyRtXqPyFKKRejGc/jQwzYwnanU3358hVEwOfnFQCrM6RnVSo6duNrMQpYsRaFeCvdfnx8x8fHr2BIWZlAAh7jwg3oYxkzKHTAPxGNADy3l3sZNHFo1egyObhgFX+OiMxV297oZ5he36RwpffQ+UOt3EBZMaLRzSg1jPzCVipoNLX0AQriIbcP7b6xhPFZ845xe8+87850PN8eOYnO7h37p9dgfKd37gE9it94Sgc38HAO+OxcZ7Lr/LPr6BXv7z1rg8/40TIIVMnkac7Tlg0pkJRd4arR/UKf+35FiuLSzYeUSdnWTbJlaMZikV8EuUqquAjgV4H50PKSuSKXGwIBS0oovGDhBUfJMndRMhFAgZtoNAd4Guq0da/7Qj8VIJvwwMtFMs/WWnC73QB8iJM25+bU+5Guf68LPf7+793udevH9Gztt2wV8zn06D57rqfDR++c6f5He87O5K7D9/vnrHQm04gI2YEFsz75eMBo9ot5Ds/mVPhdFPmvpR3sQB/Pa+08IASECMkQE1isYzFKeKKWGhQ5X/Yf9Iw1WUfOw4IQTYZS5zd1rY4B+ZsIIS4IiE1mKMVkMDnjlyVJ1jYD9OrpWFFxeXlR3p2Qi2SDC5TcXKgcGEQGg/JrO7NlSnVtK4CwoLDoEiEEFEj2m0gKFGJ2/et2PulbwmVbWqmrUioYWTOhBARExLTgclkF6FYlm+QSE/Ity8yHBAoRpbLcE+XMNLmr0cy87hUNADo2lRth+peXeQP60Tbe5zM7Vw1epCBFtir1JwNdn1SJFOSOSlbZN5KAD+FkeQP4y6sDtnVpNnvRQyKYLMOdvC2zAIQRkgCcABSN4awMEHM7g4moAf3vzjYeM7m1PWP7T8cL9OBBlsGgZVoJStMspfssKx8A7Mcu43I6h0yY2sRr76MPUvH6t51lPZMb2j/pL5zs73mRrQ4BmmHIj5vBCqjuz+x8AAAxYgpDCVbRKaR0rMjuaCVRX19fxbqYD5Sasd9uiBHYrwdAjGVZFTzOKrMnpLhiSRt++eUXrGtEWhYBqsYkJdCq2SpVXms88lwX/j3tR2fKvBZdf7FGIJL5FSDNgWO/Yb/dwFyRueJ2+5SA7JKBo+B2vQrtRQ0q0RKxZkWxIB+QcLQZ7PZsf3t7Amae7dme7dme7dmsKc5BhFZAgAVS95ZzbekdGYyyF2RWlHw+UHNCiKTGFmBJUSRN7sZukSY1A4kK/iZYiSJq6fKd0xamQLIYStANZkAXPkcF3ZSYdtVfPxeTwqzdkF9ZxU5VCOx7MXTZH/dGcFKlXqJ/TYgnRFoRSCMDakXNaPJ5JUYIFhXsxtcMwcDUTRAk8sKUqUCESgxy/dOZbH00f1lbelOUAHG21KoRm3J/UcBCS7GtRn0DgvQ+QkEHrpOi4el8abrkqopr6REbZMoNRiNItbpNuhhN+dRyC/Zlrd351BwhTACN0dg2ZjFGozkypNYyK+ly63uLsIGjUf276VaAOKJZo+47kaDpKSTGFIr6jnaV0bwpGfLTsg+QKeue9rwiOdGdb2fOmYlkvTba+zvoQzZnv/2OewNZNwacZerw/MC/j00tYqljzJoBy2hVbARqyWlz1qOESA09Z8ZL5vFvzz/MCShzGxr/Yy6QWsFw77NpNMekWyKlo1qqlqOTOypy29pmeBLgmCnisqfaXgQJH6ZO91BQm61/lZzRaHzRpob70vJA1zJX3SHQCEFTtBsfQVNWW3/MOGI9dgZIe4b96PvY7mjT3U3cLQ23GYuozRUgmTE8dQYzRLE9M0CMiLLXq3un7bsW2eLGjTZP1FbQxukN7cwOZNBoZ2Rvvs3Xz/R3/7ebFLjyZbPdDpbC9oZ1XbCkqCV0FqT1giN/F8AMgkbmyqgUvoA+441UTo/Ju60/XUYPruO4oqQ3iHPSaPr8HX/31vaunCP3c2vzTp3+m/FTDHhyPgflMcKv5Kfba1Ze0eaRm9jU+U3rkPHMqvug04+0frbbz+aQ8M6EdpPRJLf+1VrPCZELOlwKAFs6bAG7gMKJTAUp5zXxYgOZmrMP6GXKahFQDOvvbd/p+ud9x7HvUoISjEhR5E0mVEg2Q65BQaSdooTnafatNs8VixoDiRnlOPB+u0qWCBLHw77fwAysS1KntIFxRxnSWgix8eA2Vbq5RT6QNTdghJxhhBRt/nT1zcnEYhxPSbI+SDkhiZgNFJpxOcaIFJNEHTNQIUAAMXR3AGDnm6NzqdGB9buRUOdb9zXqzZjroRjys5UGJflU7dqYgU3G773BeZBZ3N9SxrP2a/SwsnF4Z5eBOI6c9Qw0p62k2ycV2CwLJkj5fGUQCkrtpU8tCjelRe5t5WCELwUP5ldjuekUtv7zHu0O6BHQ1H/a/pASOnYeF42sDBSkBMNi8qNmsgCQkkSNV3WcratkbOFatbRTwb5/IgQpyVD5EIAFJCNLCBJZfb1eceSMddFIcuU323oRp0eITWYMdoAp3QSuinWfAFBBNkEIVuJKnDRSKidoBHlVPcAd6kSgkLCkhHW7IMaAz1xw5Aw0/iZOJSlRlvr9GqVbskSoW4r7UjNALGVkQpBIbdYScRQaNSPYRhxL5DTZiZtggpCiRuHr6R+jRMIHy4oScHxmlAZmWhoPlNT/BSlJ2YmP90/VPUKLEA8xSqaBiuZAlMxISpcMRJIo+e/vB64f78j7DS8vm2ZPENBBjAu29QWAlLbiXMHowBvLzMl6pgUtXdD3oMrERIgBon8VAwCanCLz1h1g8hzJmkDNWczMd2X6eglet9dDFClc15TsXHVsqUu4Qq6BOwiQ7FkgdwapM4xYMwZVgLRsawiwel/S007f3AfY2KU93/Ojs9b1hJmf9P6vswAAIABJREFU8sQrfFP5gqRskcmWgeSf9cuCU8yZaednKRW55A7EQ+c7j4J6zpqVpCCiBqwaAAVNBKFhj9ieg14bSPZZyQXXPSuPtXMpoFbTmSRgRcZRQSR7VPhmUBFd5oZrxYGKWjMKqkSa5ytuGuQSY8AaN8R0gVVaMH2iy2SmhWip3nF5hjUUwJBkEtOoGljWz33fpZQLLIjHKMTsBrP8ztO/fgR7qY6nnzbXGO4w+u50Nuiq7vlnuryN79HfZyCQ+fcfAa+AMeuSB8z47/31Z6CeESBzD15zvZ/61WV5IvcZz/Y6N+Z75ak/2ssfyv+aTk892MvPU2mlPrRUJ6zEtpeMJPuB0JllkSXJbsiMACt9qkCHWhUsI3qHyP1dHzXAKUODQoy/k5ZDkpmXzDNbaLYnrmK/bcDFlJBilOx9ZodhIDFQqCItUr66FAMAB6e/UpMXzX4rvFeCKvu0m94iZ00tRTK5hoBj35v9jFTGEBmoOk1GRGjJZL2ANcNgoNh4RckSGHLZXrDEBEIUAD0FxLjiVrNmEUxgBAQIyHSwoZmcArcfHelUA9R6soKBl92eIKhuUfu1Tq8Xnhka32AN/GvZJ+1pzpYSdJLF9tHfBx1NNHrQLC2AZtBUHUZkizcc+w1EAjatJHpUUGABc0U9dO8FzShjvFD7yZD1pUACIg4BFFMrESjHWu2yfLUymKbDBeUPkCxAwvQHvZJCAEVCZKG5oEGZEoiRRQYw2c0C3YxnOFndmDP3qewyAxgULAjW2XwGXtnl/+FIZFtPkeS6z6G260OUdTK5q2WQQecjbWw2BipIq2RRZNVn1kVlvXyg1ox8XPH5+YmUIipnLIsAiRiE43oDOCFRQkyyTz/ff0E9kpQD3S4glvLMjU2Cu7zRyugawORc5vlRm1kutzOS7vZOAzgSQCorVUNnQQIgSpYsU0eV8rq1sgDZa7e+BBuH8cWm96peWMes8M/2729PwMyzPduzPduzPZu2SoyiwgsFVSVY0cm5aMQ+nLFLhOlIQQxuRQSUACkZUJ3QUi0iQw2UZowR5TqKEhcsEs+U1wpAnMeCkYhgpG4Mbc4D3Bnu72WlM2HQKyL335uwJ4qpGcNUsKSePaMpDjJSmT9VjrpzxV/v3yK1i21MuRQcddf3WwrwrAqWZVkJGqHlnBtQRV2FVK4SjRJCkDSkDM3+Ik6tkJIYvNkMGs6wQuoc0ggUFHV02JqTGHblJjECEEuWgyUsogSTCLNWngBGN2pgCdwVYyBgWVfUysicJXq8pau9jxqyCOTRWKjKLaiNJ+cqxmMWJdOXxSFVHoum2PRzKKAAW3tvBFUjZ+xRlhKxOQI+0PqgtFEAUG1rA6qtygNpFgwxmkzGNgYswn+O9vV9Y/SayGauMYemjxDr/bs3qgVzMrB8Z6WquvPQG6C6aWjQiPDYCDe2kSbOjGWNb9iaqcLLLIZfi25u8wBGYHY8R/odGA3UYc+7nwMziHZDXDdUdnBbN6wBgBiqev8nIwqo1RGWaOgi6e/5aAAX4SlZP68ty5QHWAgHFFVRFHFz6GtUX0uDLF0gVcwralsysYfUZpySMZW2DkTOx+uUfILwdUs+QnrBbIBsox/mf/y+/d7+cNewp8t7AyvpHPrnGR9ZXQk1KcVgdBxQqhuQzmZzlMkKQZw/rixg+86AEt2o1kxWDpTXhvAD3Vx49hidfLaX/dkgaxuGubw3ZEsN8n2/yn6NG0La8PaHf8Dts+CIqZn3AkvCL+u5na4CorlbkYftRyYVf5oWAAcpBpdZHLQK1XnU/lYDx6mRPcg5lY8DuextX6UUFMApJSfAjEBJ5RkB2AWQZMxQY6vxaXABUwFxBSGDKauTxRx3Cm5DXycbUWVLGe95TpQNy11esBluvL3JNUYvtaWibo9RI1gHyo3zwg0w0+enFFLnqQDkvPxkDy6OL5tz1zsA/Lko0aIZVDNQBTQDxw9qLdhvO7gCMSzDeVVrBalBjInF2G/nNLjVqW/URwAr2KbJWSxrscSA4/qpDmzGum7Y0oJlWSHGW278sxmE9bkpJAW3VrCb3wpGYdnDIRAiC+00+bAUiEOQXEYykvTTAMISEIOUsyEQopU6gYv0I4AWQtLSIbfbFbWW7rwBVA7stG7ZIsyQ7I3lM6956JRyGZ8YDjDoSYw6D5TrqtJLN7ha1O7gnEMvLyX2Zj3Tpn1uoGZfgpIhxuWic1+5IoJaSQPpnzohANRW7IORDcgdU8uGABubZUmAOESpVkCjNAHSqG1z5HXDa4vqZoZlCzGOJzQ1AwUsiyAkQhJALXptJEQClu2CoOO+7TvAkkacgvCf4zgQ9bStgIBC6oH3758QPmDlUxnrugAM5CPjOLKUXUhrAxuFNJYOMWeanYeDA1P/BwWh2P5PKbbMNzGKY3e/3cCaRSlF1c/I+Ak3PamVOw0Bn7cd397fpSRFiE2HYaWFZe19ZTDePz5BRJoRIqKUjMwFYRGQSAhS8iHYvBNgrjfhI5oVpgq9N3oIBIqWpedo768MhJhEZmMGsWaaACTbRTUQwdKALIyAZZWgkdu+Y88F67Y1+R1ByhEyMTgEiQpeJEtMTKtkEYQWRU4R//b+DbVkfPnyBWkJeL++oxTJDrRsr1jWF1yvRUFUwldCCDhchDdAwuMIQJSzyTSMWoTL+bJ8RBNvALd/ck3Potb5i+jlXbDrso5uOh03ATG290P1nrbnlWfK/50+ygFUK1hLs9ne8vuPnPzYwJ/EFpMBA+ZQe0//3BxncPtibudyyb1eNZ6HNPFW0jWS7BTwc2QyM2uZUBLeGgLh2G9SdmCSic9KzXjwy6B/8lyOIgz32/cMRgwJKRmosM8VqqyLqBWiz6RlaWUbiSKAgDW1GRDwK7F7n6wLIBHlFKs+k4FSIFlsCcwC+ss3oe9lXRAvKwKvCLSgKOgYurdLZSxLErnW6X+WLcDL1CJTUFsjZkZhKLhKsmkEWpBSaJmvAO77zOa/rV1XnAj3OqzpKiYWdPHA6TYs9OGlc3L7qdaiPIs7rQx6p6dBHmhgbmc0c/b5o2d5G8yjveJlDf+emR7n5jOJ2tjtmf050LPHbIRNYlY5+kRDYW6ah33bdTphDF7v7/3FJAMwgIhcsgAHNVhF+G87NbWseBHZkgRICgaSylFU+vNqUM7AHYxlgYRgoBZHt3KwiY6heqtkkdBMLZoJLMbQwDC1VJRDQdcxaL+t9BJJRkgQwrIhUkDJfYZElCFIhjOfKdjYJTe6t/1QWyZLBky+ACPqz8/bVTLMueyMAQSp1uoArZoBNrfzIbR1L7mgckZKEdv6guM4UGvQLCMRSAkMkekoJOW7IiuY3G9nWt9Hdh4oDQcjik40/jr7r9nvlMxEF4Dn1WrzhOM7Bog03mf07fhEs/fpc1VNRGEBLMMFDTIzjuPQzIPU5NG0rvj+/olAhO2yKsAcyLUgsACAQzKeCBhoIsaEkkvLSgnjM1xRKaAEy+Ko52piROWRHJVuatEkYGLXDDGhJ1QNQOhyhwTlqp2JKyIFcCm45aOVJzQ6sz3es63rmhG6rAXLFNNlUDo5Lyd1t/3dZQkl9IH3RdXbJAVRB1PLnq9clJcnpTEpAXbkDGbCmiJCjALeSQvSErAsK67XG67XKygSrvsVy5KQjx3Xj3fs+w2lZry+vSCtG0ICbseOj9t3bASkbUFcGDEWvCyMNVZsoSJxBeeMXKQ0NoNEh1CgW4X6CITipglxU3PGU3XOYDIjQ/SJdo/tkP59YKBwaPp8rQRw1kBsOfdq2eXsP3ZwkXVjzaIYtNRoqRrypZujnTl1LI1dnT75bP++9gTMPNuzPduzPduzaSu1IlcR+EMT1jXtdUpiZHYGCVMmaz2XtLygFYAW9VmriGoUCNt2gQihPW252ofUUBvBLBESpWRVJnpaSEt7aiWL7p2Ko/L9uM3fd02JVJM1I5536JrQb7Xdwd7hbaZuE+6pCdjjm7oymkDgxIPzABDnSI/k6ZktTCgNIWh0pRghw+oi/ABVriOIIqqmwD8rPyQpN82JXMQ4XSSFdwgSmSrXQ2t/m0PYeiNGdmZSPP44X7Ym9l4bp6SZFIV+Y7RxeGOJ9bmtmBkRGq10xcYM7Baha9F1Fg0vaxMbDdu8Rk3Z2tfGG7IAKyvQ0u1SBwEN1OQdE9wN07YWFunnDZfeYE3O0Oefac/1dXlnw5af57mdKT8t6mQay9nfg+GMHu+qM0BAm9GhzNi5wc7mSe6rzbFhRhaAmuPNj7/bHkiNDKUp9r4f9v6zNjiPTgyHvu+d/8m+97WRLU3sWVkN4xshlF6Ow63lcRzal4rb7dYie+15ZgAgImzbinXd2p4hkrrQvu9lok8Do1lf/fttnolYykm49Ql+nfy8+7nFb3PbR+2MDs4dFrZfJOJuTtM9GPz7k1rv5kd6Y65/r6fPAPOBqAVUvmnnwqNWXG10ox2fovmvaXM0p5QtUYfymvD6siJ+/Ql/+Cnh/9kueG+mMDM6WdYPM823b4dZGubmrhd0+jlPf2neEARmN3d/O208andzTwCxGKq/v3/i+7dfsO9XLEvEH//4FYSCpKm7xZksqau5FjHYhQQsCRQqigKwKK5yHpkTxYEFzvj0w77Jp81IeTa78z3eeQJYtpXx+sYXJv5EgBhXa598iR6sCsSTlrXcihmMQQRKqfWvlzBId+U+7P0hEEKKOjW5yUSlZD17u8POn4XiAO28nNyYHs6J/ZeFfmMICMuqJWVk/FKGRlpKq/I8ARvnnLHv+3AO++e2PUbyfNkrDOYi0W5mqGUzzKkTufFZkTlM/pBSD8CyLLher62kChHhOA68vLy0kkT7fsP379+6jMeMZV0GecivObNGLJ+UVbOxzffZLD4whd41f/9ZBJ85r7x8LHJ71TNqw7ZtQ7996vSspXlijE1uy1wl24m+r3LF9XYVGzYCrLyiyKxWNkf0DCtXIxmBFLgUJGOIGd6rnrtpTUpK3NZR5q5ncxhlUdbIV9NFxkx5NucdsGzyqMgGKUYg753/kDh7juMQebjIebzfbvh4f8e+7yJvr4tmkQFAhKBgltIAt7J/U1rw+nLpZVYmXcj2rI3tzvlJQIqLzImTm/b9UKcTo5S9yTohSamUEAUU4jO52Hq+vb1h33d8fn6KY4BIomAhwLKchUe8vLwMpWKYWUAjKjc1OQWypy0bWKCooF9bAwEj29yApQxM0mxT8uxenug45NoYF1wuFzAD379/QykHMjGIdoSQ8Pr61t7V6LJKdh8B8xR8fHxi2S4aMby00gLvHx/Y9x3LsuDt7bXLcMGyWwjQ65dfv+PINymdsS7INYMo4uuXVyzLBYyI/SgIIaFyQVCwnpV28/tw20QunIHixr/9/vN6iv9ngGLRocpQDopIAjJaKS30M8RKP2RG47NW0qHpFYS79905tkyGncs9uO9EJFMotxdA7XfC8FwD0fytzdNn75Mv9XD2fLGZCK8yB3E/s5kZhSWT67quqmMKGC5q+bR5XmqtrWybnxf/TM+T7Ppt29qes7N5AEU6fmABKkar9vxZDhnLXTzW+4kIlSqSOjItOKrJpLU2OhZe9kV4RQhSki32Zxndfv36qiDDrO8WewVAEpAwACH6OBt96zqktODl5RU5Z7wfV0F+T/ed6U1+rGdyi58PP6/yfXCk8nvtVaJX+HH49iP9di7ldafXA40mAAy2i7O9CWCQMZZlueMpRhe2tkaHMUYcx9H64O1Rs/1gpqWzcdwJ466POOEzsxwzf2dj8O8W3Y0HOpVMLGbD7OA0eU4vM9mCTUzYrlBwCO76YX2f7Q9361l62ZMQAvKREZPwWgRCPQDSzGeNPomQle5Dikgg7LsAtOd9LO/2Z8c4r2e0ZHKFrbE9z/iOleWTvoxyqqdBuTa2sjJcuWVli5qxrVbGcWSVBReV+wNutx1LlRI2cxlWv8aerzYeZ7Yt4mb/YAW9GNCSmUHVbD0ifCWKd7rKmQ7o5/bUhsddj7Hsiszc+JFd59fJl3wERN7VCyVbNxNKLQ5sajJu10dFJpEATpFxev+2ywtCWsCt74RasoBl0LRTxNCBi6RMnVkzFqmtLIZFflckMrM8I5GVDyoD7c+yq5Vx9bKmpx37/SzbFWy3EAFBAw/Y80EazmW/jkllF+kPuTOT296RLIBa+ipGUIhYWEpiSRnZAwTC29sbUkrY95t8FqQcO4Hw8XHF7eMTOR/YthVfX79KeVl9/8fHB67XHS+vhLe3F3x5+4IYItZXAmqBZVO18ZQqmWQd9Qz0KBmQfr/tbRSwxjbLHvN52PdzRa1SNi3nHfvths/PK5bhvFD+Zimy+0uAiX/f88/fq90+22+1J2Dm2Z7t2Z7t2Z5NmwnvMWj2Du4ORonerxqhyV1E5lMd9e65s+EgqMBzHAfAFURRhUwz2M2GdW4GKeA+7evcHgls/55mgqA3+HkF3yqBAGiKlQl+PiPJbGABWSYa6WeMsb3Dv8fukzkxJ0FXmLxy7+cegEYfZnDJqFXAHsuyDEYVU1CbMkgBy7IhRm6AppzV4RoWLUUg783laIZV0jrjxdHGbDzzyiBghidNwUhB67mOGVLM0WzzYQ6WGMOgEFv/W4Ya7YQZ3a3Px7E3Y41FzQ5r08wbTmkjAweN77L+2Wdzv2dg0rZtd4qyN8wwuPtkgWGuAAyK4uPsMz8Au/g1AXVntuoZVTc2i6ehRZ6bcaNX7flr9xbrfI6GuzODnAc/BE2fzySAm2a4MUXfAE2kipX9KNXe2J5/pmANPTwxotlQLVsIgKYUd6W+R/2fPX829lkqUvtuXiNPx/Yu22OStpba/Jjz9+z9pujPz54NXWN0nxrZmYZneSfng8mTfw/48qO5J/IK/v38PeLzNn/eIDt9dXe91Uqfnznzm7t3Kk3dX/MDxZzG+uWzwfavbbZGtv+XZZHnE+HYdxyJsKSIn//8C8r+BREvjYcZMIaZNbaIJauc/l5Yss0QMcY8QvfGkbnn87UBFZGLRk5yy/LEf/2Qf7PdGyjRDME//fQFn/+S8O1/l9TU31Js/e/7oTZ5QzhJBWMH4QB0HtIl4H/8X1fQ4ox4ldRJ7YyDENuOOXXJ+sdAC7Fre8T3u/MC44/zc/tlo+OMIPMaU+yfkPWcAI4Akl5nEflejuupqj1ttsIGrEbNWlAOcfixOv8kol8juvIuKZUVwGb/zPnSjGWOZ5LKgSZLijG1Z+2z9bU5NOCXzI+eCbKIMgZdx5i0jntasV1ecHm5aAkVKdmSc0apBbkqbMhAzrY2gJbPQKNfAX3pO6oZmQlxSW0OLBLW1s2y2dgce0OuB92WUnC73VQegYIvuxPGeNPjM6WilC6DzLLIOc+hTpsnza+R59teTjlzQJlDHYBG/1aVt7ysFYc+WnSs9W/fd9zyoZGj/fmSVl/0hK4r+GwJ3ahs2Vd8VgVoZjUvf8aUwETNAWnG+kdzYm3O0uDPlFnuWjU6kpkRokRGv7+/Ix8HYkq4bJtklzx2yWpChGVbsWwrLq8vbQ/GQKBIWNeElAKOY8f7+zcFWwHX6677TdZXMhl1kJzxpEYHdu5P49z33PkhSfmIdbko6EmyHdUqAHmZfwX95GtzDl4uL1i3FVwr/vKnf2vrv8SIbbmAALy/v6OWgm3b8IefvuDz84pNwWH7viugKGK/XXHkQyKfCbhcLpKxBkF4sKVPgzn1JXOEcThxoC8IJKXZGH2NpfwEsC4bmCuO3QACESnpGEENaJNrEfCNAhVsba1MbUoRVCu2ywUhALfPd1yvN1jQwpoiliilbFsm10AgJpR8xbdf/4TLtuDIN3z7/g0vry94e/0JQEA+JAMO0SL7V7PdhAY86PKG7Tvrp+070388rRrtGhDG7rX7UhK+yZDSUoR+ztbjUHCCHGlB/iOOYKWv1QBsTieZ94/fR/a932s2rjmQosumHUTfzgWWMw9A67NJN3JfC3s/bXP/xj6e8WJX8m/4mlSHRhtDiAHrKnsqBML1Kg6yUgqu1ytKKaKjt8w85zrFDIayn2arAISfGm+uVUq2eZ7V57pnzPJzP4N1BJBqtgIB/sdoIAEBSllGNytrZOehlHNLqFUyJMp6yruFPjoAl5lQyoHjEKcvAknpURBAFQwBzfzyy8+Q/Ez6jpjamtt/Z4DFWYsx4uXlBbUWlOMDnzXLmuQM0oCiQdfQ4AXocjNzpz2/Zsp4Rd/WP4NkAqmabrav7T1tnTXLoCNjHun0kX5xZmvweqEP3vA2B/v7DCxLRA3saUFXxkvsOgF99j56UMajwJl5z800ONsxztpsA5GqMvfZJmzcc98M9NFkhRgHkJk9V+TpbuNrwLDhmi5L+XV4HPRETfb39pwGktY+2vsABTdFyb6YuWoghQAgCptTX34vqo+IbffeBjHPs//dxjXLth4IPcuugAXqoGW182s626w8fQAAVQHLLZpV1ts7t21rZ9u+S4buZVmk9JzyKpsrfxZ6udX3QzaoQWT6fhnsXg9kRJsXT+/znM5y5Pn69znx/+x6G7+nNwtsWJalnf02fzlnkWWCZvbU7OA2Hrlf5yL08vY9u5CAEBl67nMVGYYJrKBdSRbG7bA1GbLNN4LsE39uUc+45vmNp4PRzjbqIPOceTr18/2IR9w/Q8bqv7O1OXJutjQDYwe2fWpr2m33BhAKFFFzRikZaYl4fbng5bLin//5v+Dz+olt2/Dy8oqapYxwOSSD0rqsIAKunzeUeohuAoBikiCLtCKQyGYSF2N+GynLRmQAsG7PkfOHZe1tnIEeGmfOdCEe/zPMpf0b7Yk6M5HAnLVsbgZxxX674fr5gcoVaUlglkz7ktWul8VuGdipZ9Y/k8v6+/8bGJv+f9qegJlne7Zne7ZnezZtLWOMRitCHStAzyzjM8x0r1mPOhifdy7MdKFXBW6ClljpBqVWIx0+yj/Yw06VdlKDqf/bHBdzX+SZ0m9/39juhfBuiMdgkAIk1aXYOkw4pQ4+AhTdLykdKWg9c+bTDARewPcRl6KEaxpwRhMMu1Izzr0pAC29fwggSgBrWY5qxh0BI0Br7ZLNN0VQFIM01yrKTRAhNms6UZG7NS0lAWCtsSwFOZoB5b5f489AwQqUDsrwbKwwZbRHVEh9954eupeN8OvtDSXyPPnXlfbRsEZac74bA6BGr04Ls8I/G0TGNe33noFFHjlp/PPnZ87fz8q2v/5MqWQz7nFVR4MM0DtYApHSBjd38qOu/pZSKk66Hysy98Yz3cOosLrOzTD5wzkbac2PeTa+DXc9MDp6o67xAQ9W8sr8/F6/nxtvghr/m8FM+xgIMS4tDTgCemYnBKRE4uRrRpM+t+Y8uTM8ijVXjB2VUUvWfd6V6m4oIq2ecR4tORtz5rl7ZNyfnzN9inMe/JimAHNydie0NybO73xkjH302cP+o9Oe8PGe8eu8/79tEP6tvozP68+wCDyJQNbzLAR8fl5Ri6XbBaBuwn6q6k9mZFQUkuJDGVUM+AOY48Tw/hufWNkiQlRA2287AP5ejcAIkVH5hoADvFeU72pkfXgXn/zObeTLSwWXgLB0A2otVYyDXhby68YdoAQHlGl/D+/TFWGTw3o/uowCDOUu5u4PHzs6g0S92b7uJ76mpICBO7jxJgqSkcGMfpWFZxRGcx7FEBCTyDMw0EwpaAAaB/QdI27HcwlmlCY0R2YDQLKbF+O91bLQQHknANTJ3kdgBORc8fl5xbq8YFklMhUAFlqwvbwgRCkdKunpS3ce2EEPARjZvIQQXYYZmT8CIJGDWoaqmLE3DOM0HmVAZeNJ5gAwYLiBSeaMMsDoRB4cLbpoHoRyxp8HPsQKpPBk5PjkmcHTP/tHTgA7m47jGEBSj3n56HTJzgEwZzUQ2c4720LXDSB0bH2JITQnwHEcSFbGCyqzwvab8Dwp8VE6DZLvm+pFQANeyRl5P/55jcyhIZ8V3DQ7Aqlcu5eMz9u1yxI63hQl/b3wEpMvCyoDuVQcueDj84YlF4CF3s3gX0pF5f5eYxFscg0pJJx79HZVGSBGyy7Vjc/MhOMoOgajpeCuA5YUJaKbAkrN+HiX7Dj5OJDzgSUtUp6MM45csKQIWpJk3UHFskQcx031FQE21HoAqEiBEFeZ9xgkkxUREEDIKhsFMmeHwlzYdCNx1pQi2YGUUmQsYERKymfNKS4yWCAB11RNv59SRC3GyjsoQcojylpbJq6UFJiXDxAKailIUdbvyDeAu4NKkhZkfL7/ilp2of9AWJdFnHYUULKAfWOMSMuG/WY5wnrAhM8GcsYD5kyCfi/PDnEv15YiJRpiEt4lafG5zXfb2wTAOWjY0W3fn/0MmPWVWa/xY/C8zfbTeC8ABb2xnd3qyPLnqeylquw9NCo4k2p8n8f+VHcm+4hqeakFBLknyB7Rs8QcVaUUvL+/4zh2dBmgnwspSZlAD4T363d2nj7SAz3oyMD1g6zMQEVFKy9INKzHGb83vUX6lLv84Eq4WDkUoUvhtxawMgb5CPBA+ioluiWLRMb1KtmImBgI3T4kc21ZHSyoSpyyJVcTKmDlFO91upEOZT/L/V++/oR1lQwAt9vewIxWyk7KM/fSJG0+ZJDdrqK/SyWMLiv2ZZuFtzO99uQ8J2pykh+L/T4DbM9sE490nhmsYPefgXbtO5NrDJxgfGgGB3sHuNG1B+3ZdY/6aN/78ZzZN+br/PPmZ3rnvJdXfD/PnuHf6a/pIMoeKGWADv+MR7xQvncReNN4zsZiZ3rl2oL3qgg6LUMJMyM3mV72qbG9NJ0b83vn9/lr5jW2z+YgNwPmn43J6/DAaPc08DNAvUyPXmNZ2zzNG9BJGU7rj+/7WTAZIPuUlY8TRlqEO4/sO5ETzT7utMcTPuz58+9p1k9PJ/PazMAzC7g0kCQAWe/aZWqARI+ys9sAjae8x2hXlqBnpVEwC5HwtVjbS3q2AAAgAElEQVQ1MEZkA4lnYNENqYBIypiD3Bh0vkgVuuM47oC0XqaZg5VMZjnb+/M8z2tho/Tnm18fr6/6/d6CI9rc++tF1oxBgZWQkkykezCEhG0T295//b//BbfrFce+I8WAomBZQEqlBcShjwz1JZAEs6S0gBnIuWDfde8lWdNAVppc7dmhAAp4HqQSRi8r9oAmz/ivLZ59dcaXhuA6pYNIYj8oRc7/z49v+P7+DdfrJ1j5RVGZkRvIthlX2rvO+nh2lj/b36c9ATPP9mzP9mzP9mzampDBAuIwY7JFpp85vfgHzvOz58s9ACprGtzQ0MImyjUBtQlIJqTbg5qZsBnCRCbzgpI4EUiFc39t6zubgUqBJs0+bkaWUdi2n48ULTGuiqNEIi614AVbaks1JAVSVDjp+49xTp2SZG0EzdQOKGLWyOKqgn9PsYlB4DQjOdDKX0EUQ0OtB3KRbDATn849QcE2odUXNsQ3iDSrDAZlSPo7jsuMEGeGDQQgVDRDqxd8Z2Xasm5Idpvc+sPqO5qVKG/88c8IgYZST8zOKMQV1c2fGLd7Gm1PF3PzilZVOuilusbxeQWtK8ViU31k3Jrff2bkAEZlcG5m7GTJC9x85EYnsOhXIrM7tv3e3jT140dKioy1z8Hct3m97PGyTeWl9vTBvPiAAZlBwxsqHhl8ZqOa/9yaOTfulMEHfXn03WBoKspZveIplmFYaTPxafXa1BZRIuOyqEoASGrE6BEy+mZwYZgjvqI25y6rszygZ8sAGJUIIUjt8Xk+fsuYOdPEw+vGm37jezeauznmYV3mNffXGs99tN5ne6x9TtDof/29CI8wXmvjIAJGSu3fP6TVv9KQ5g2Jx3EgLZKRK6YFRAeWZQWHgNHkqk6JZsqX/RwQULgik9B0AWu0Ur/ux43v/6KKQFresWUpwl+zzH9jY4AYgQqYd/z67d/w8bkA+Po3Pe3yhwMv/1CxvlwQYhUHrBxyAg4xZLE36lhdep4dkwpQsc/A0/e6905KXHLjfWa19N8aAM/kImoykoB33TqavATNIUT9mWpWBpT/gGvvo+N52QzQMYLZsrZV1GKZZHrmvUfOAP+ZZC5w82fdavKRfC7OKgY743QlQqik91cApWUhE75KyKUg19oczwxGSAHLuug+1nEWmx5ufLiqVz5A+GpMCl6oyk+rgY7EQF9LRebDrauAMbwz2mcPNOeROBcIEqUM7fsI7PQRsXMUL5pBdoxWPWteZuj8qbcfnWnzWs5GaKA75X0Zrjmz0FkbDNM6NgQa6KRlEuROseO47p9v81iKlZuVPWLBmLVUM/HrM8dyYyVn4auw0mEdoN40hh/wbZuLtnYFyIeU0gtEOErGfhwotWhmxQgrIwSTtVVel6xHhH0/ULlg3284cgGDEAMhxCQygcrsVkJU+EOnb5CWV2S0UVe3NgYI6nNvUfjeYSFgpKCgJCIDmwlwLmvWgZQiYiAgBSwpIBDjOG4oR8G6LJI1hypQGcsScf28olrpAJayfimQOmB0TUvW7CUy3khO12FGZUkbEzXTCVS+MX5idNQyRZErf0Ai52/rCgoCBDAA3LIsqJFQcm0AVaHzoo6dgG2TqOCSdwEXoiAEYF0CliWAIHMDlij4UjKOPSMfV1w/v4FI+MqSVizrJg6ECpSqjq0QFei/y/q1c+M8+4OXhWxv+iw0cwCCn4sBQMOa9cPt9e6MBZSoYLyr2DWaHdIDJ72TbwZSWmkpLw8RuWxnuHeKmK5p/JPongd0WRFt39rZHVS+PnNyzlkiZI4YXtfu/Tf5r8+//iZnqp29Sq+1VhzHgev1s5UdAsZzwoMJ5jPVt3kO/fpa6Tqf7WF+TlWeE132yjNn5DmvY0gJPpj5ROwCkP0Xa0EoBlCUO8wJPupYRg+stoSK61Ui6yvL2V/RsyFt2wXLtmrmnK7nm40DZEBXggcbz3q3b0YH67YiRiBEcXoys5bRUp2NpNSF6ctsTkc2jqo01N7raM5kNFa+7MjV64Ly92jvGb97fM7Pe9v2v93v6WX+/eynPXNu9vy5TPr8vX+v9f1cPzvXo+d18v1+pDvN9z663ge+zI5ye47nA2djmTNizLLaPK6z/TvbqM7GO+9h32eyvqjdAOiyk8jQVe12XoYRso2h84wz2d3zotl284jWZlvfvL5na+bnwYDjQJdd5ns7EKfPx0BjGNfX7j2Ta4e/9b/2c7YfedVeOZ31cpg3P94zOj2zC83fz+M6s6H6a3yAgvVV+BTBMjNWqoCWUrSsMyIfmF7bx0/UMzqafhUt8zSbXB3ARlPE4AAwArgqSIpFNx/232Ar6aXDre9eZ/K05ef3bC0HXcLNU7uuMV264w3+ufP6hRDUZmd9NBlbMkyFYLzG9Dvrs/hRLtuKQIyPj3d8//UXUIxYU0IMAVwqOEsGoKB9tHNEwNoLliWBQsSeD5hMIWWPZb1zlXWBAmZatjaIPQI0yW8Q218r33VCj6d7BeYNuqfdOfuU8I2Ckg9ESDnXnA98fnzgLz//Gft+Rc4ClApRznE5S9UuwLhbk0d8w/PhMzvKs/1t7QmYebZne7Zne7Zn0xY0QtWMiNbMYeKtHaNx+zx9of/M/x7ulAhzsADm6DXjFsgrSMBgYGkKonwO1ggvb5uAGM+acMdstmR0kzt3haK95zFC2VLNmhHexibXW2kDM3yNyqTcJ4qVpQz0WWoeGRFMgTiOw91jTmJ2RhUzcMn9tYqhKKWoLjJxhjLU4B1J029yM2qakmnjjzG0lOEyWO2cGkrFD6igEFsXjQS27Dk+umNZllNlr4+d7rLS5Jw1IoJayn+LpFhqQuWqioMofD7KaU7zacbYGPt75N1dyK61NqeYKJ8O4IRRgZ2NMGfpQ+U5Y/mkMwNoVwi7we2snSngXsH0Rpsf3WP3mcNE9g+1DEh6g/yw57jP/DPOFMy5meHwTPk5U36bfnvCg35kIOs365rxuUNhvu/MSHh2zRwFaz/PFPdHBkLroge42GutNrcMu6pCq9dR0MwW5jAFhJ/Exkf7e+QZphTL7xEcuvOgD9XmSDO1VIDiaKQ8W7PRiNTNRvdr+Xjd/Nj9tT9qbT9yn9s5w8LcDLz26Kx61EciyUDBzZkK917YiGHnk50h8g7jj7ibt/kdj97v+ct8n2RkyBC+GRFCwZcvX/BrSjAoppnzqB2OtqcJEUCB8ncCCFUysbDZXGfXdOvVD/6qYBxqD4tg1ixVP2g/5hl/RWNx3gAF14/v2K8v+FsBM1//acd//z9npPWiPBKS1aRUoGYpUUloZ2MHmOh1ZjQCO7lK3fLc+VH7XDekH3G38SkPbNHtXQ7y8gvU8dU4gPIRn4JF5ofbnrNnMzs5zjLmoVOL/SB9Tcl65mp6anP2eXArMKYdv+P3TWiTMZEfiwIcKjMCMxDkGaVq+UfW8TM1dk9EKsvGHn1OErVX9AwJOhqRmFTeCVIiAf58rOpEIQG8phS1pFXnlVwKapX055l7SctusBsNsSbDARjKFpiTQeauR4Pa916GvDOiP+CdJhPMvIVZnCdncu4j3mnv8vLq3LzB0mS1M542n6X+HouizFXScktWbg84Vqdzm9fRseUBzZaBrI27Shk6IgJVdYKiIteMwqVF0lr2wZwLcsmgEFW6FRnfHJi9HM6PeZetrY5e0o/HiKIO81IELJPWVZ33VuKLGlCFAZgUf+SCXA6UWrFsG2KISHEBkfS/VIBiVMM2t/OHG2BA97CdY0Sg2J1ucpHBLU1mA1Kay+TYnJj+cOD9o5eT2dZNz8qqEewA1wNcDhAY5aioJFkdlmUFF81MxhU1ZzBXbGFr52/JEoEL3d8MSfMe0yK6je4drhkBjJjEiZGrjD20KF2gloLCBSDLDLOACG09ljUJ+IfNiShRvYSAHAqOIwt9aMQskZXKisj7FeW4KaCugrhi21b5LhcwC5BoWwOu14r3j++4fn4gUEWIhLcvX0WeqywZLVJU3AlJabxyIJcbiCT1vsiR9+XYADTAxKyjeH3BO4vEOZN0/ygfUl2LKCgPJU8aTX41ftqJTAFq+i5fOsKXbiMaAxdsr/isKF7Xnp3nXa8wzj7pN44nExUwh0bfMpTxen9ezY7yWgtiFJCYBMKYYwhNLhxSDXSXq3tH56dGF5JpjJHz0UqsCm+/BzeM4x7nwc+Pra+UJ1kb2Mfm1f4JqE/WxrI1zFk1zs4J/U3PWHRWYHNKMkelHJpNs8uSy6JZZ7iPLYQFIOGPUp4q43a7oZQs57Xqptt2kXKL60VLqZmuJXMbo7qwhzLe+a7vdp75vWJAz5RUVogRaUmIZUF0Z2/liuNTgZDBZaOtHS5Dmn0yNEdy11latmYtYfJI5elnde8z6bx6oXvWXWcAx53M4NoM0JivMXrw+9eaB3bZmW/39HX1wUCPdS7T4eYsSme2gXnc87Pnscz3z7qs3T8HxI38YwzIML5lPMrLMwZS8/LwLP8+GsfZ376Pvt+Dzgvdd7odjXcEBAlQ5A5iM52ECIh0biu63/P3pc38Gs+2Ds/32zkDbnqRp1Wvw9u8+vm075fUMzIaWMYAItZahmllyh6g+dt2COq6FqB60xjsoFfCFK326fTseT5+1M5sF57W/P3ermlz4cuemfxle7Fl+uEKK+VmoIdaK2ISviW8r5drNB4eQsS6blKmVzPTxCi/Q0vzSgaZCkYWe6kBDSH6f7eNazZxGW3LKALAZV3vGeTm/TavldHYaGPvYA2/58Z2v//P6Hq2Ycn5IqB209sNJCgyDQlQmiK2jRAiUItk+wkUcP14x/u3X7GtK3LJWLcVy7ICCKhgpCDZgqHAd5FrTZbVrGuVcWTJrC4lagOWZRNgKSTwAu1cNZtBL8UF04NDEN3GzcPMp07p1slMd3rlNPfMMj+36xWBC/LxieN2w/vHd3x8SDnZZV2aHcsCTKDZr5poccKv/ZpZP3zWsmf7+7QnYObZnu3Znu3Znk1bsUhIeAOSCkM/uO+RQDorJoMAHAMCi+FZDN8CVojRBC19qQl8YEjmlm78nd/FzF1ZnATfZlBzWT660D4Kd2bwijh3DMzG/q7oRbCrhQxA0yaOKdnnaAfLHOEFP28wMMXIDLlyXXUG+N5mBd/uZ160BrhGn0IE7hgthTrh4+MDKS1NGau14na7oSIryEgtYrW/pxQgZ3HgNeFbOqLOhPtoQR+1Nhv4mMXB5yPU7ft1WweF0BxPzIzYDI5jVJ0pkvu+N+XaImKBBV++XNrcitLj0vDmgpx7TW8zrgUXgTcrcr6/Z7TllQofbemv05V8qMzN63uW7WSOzPDGndFoo6XQyGUdsoUwepodQnYdd+fivKYzTfafFgnaQT1mtLV1mI1aYphWM7g5If019pH9xym6FmHt/3ln7lk0mTfSz8ry2Tp4A9JsyPdK973xycqJjPzR06kYhUbDIlfGno9Tnjv32wy2XKqfss4PqdOd7R/5u6dN9zTtx34W5WQGOjPEeKX1x0bP8e953s+iC4GRl8yOonGss/HkPNLwh1GEULAleWVc3iUlLOYx9GwdIxD0t9ujMczjacaN2w2fnx94e9tw+ZKkZILRgHLuYKAYjA4iJskyEwZDq5Znat6PGTTD7r+4+6bUA/txgFCRwoYUrMTH4/YjA/GP2v1cAeCAmhn/9I//A+hfCf/yf/3wEQ/bsr5h3Qh7UQdj0TmvB8AHANY5tXlFzzriADMApI6J8k4DaTDXxqNsLGaknPk7IE4W4hHQSqRONRfZaWnLzWBmUzvuBSdrYZTPiOSc710fDdpRBDXkozuYbO4HunT7Zz4b2vgU/sCODzYKtbHBR+sxcBxgzi0yEuoOFyCQ8fAFMSbUwsil4nq74ciyZpadzhvlS63jvtE1iO6cCoG0zBmDWY3wAPZdeLVkC7gCgJR0CWMKev8+cxqHEPD5+Yn39+8opeByuTTZzstifp5nR3dloGpJjBk029d7BPnWWiVbWbhfHz8Hj9btt5o/U70z3DeTqfzPUgq4lJ5Sn9x71Xra5E13jhm5YKAjUyOUz3sZibmBQ5gLSj1QqoAglmVBigtKkTTxS9q0VJNkX4lxGc5/P1ZmbmAAe6+N/zgOEAFvby8CvtJn7Ps+pKM3jhJTQkxJ5dCqYPBOw2lJABRoxYyaD4jBWejKAOsUpHzIGYiaA2sqfV1vhkakmotfdmhMsr+IBDi2aoamnAvycUOtB5ZIWBYpUbSuCduW8P37d+z7Psgm0reMrOXViAi321UyRk4ZCkrJbR8IaEqAO1JOLKMUyfaVc9/7KQUsa9LySyyJT6K71+RjAlJaZe2IFRRbxcmhwJRSD3Ctyk8iJKtfl2Mlq4mdDxXfv3/DH95e8XJZ8P7+jo+Pm47vE/seNAvNhtfXV9xuN3x8vOPz8wO1FKyXDRQCXl6+givw/f0D+1GwXaI4YhSctx8FjAPgIGAgy17q9qrnAyaLmV7kQW9+z/tMJEazy7IgLaI/HpqNCbotmUaAjDyrZwEBbH/0fWGOvG3b8Pb21vjwvu8AMAQxGF8A0Piq768vzyGfkd/iNkJYNiQiA8kYgC0A8CDHOvBQoyf/vQCeRoeSH2No5RjO+gGsy4IQCEc+dH4TLpcL/vznP+M4dqzrgm3bJHOglmTKZXRC+f3rZWrZm8J3BGjSHcrQM/Q4RD5Y17Vl85FxCgjj4+NDy3nIWqzrMvCygXcYz0Pfxx3Hew+s8OsXQsBxHK1s37Is2I8dlM8DEuR5Eev2ire3N2zbBURSflQyWS1IaYFk21WdhbyN5rF8KWPr/SaS7HIxRbxuKy71BfVnxvV6FfBuDFjjgs/rVXkHJBsYddlOl1z+E0jLVt/PHxODqtnAaqMlo0GRGXgoOW1n4Uzrs65jgUX2rMvlMrzf8wUvM8z9NPnDf+ftWDNd2r481RF/RzvTxWcA19m4H71rHs8jnc+Px8rdzvYDk+Hm0k3NbuTKkJ7tS+vDbOeY+zvLFvZOA0HYc2a5Kg40AqCw+N4VYE6Agr5NnNLzgkc5xtbOeITxEABNVjEQldGZ55VWosvT2HEcuN1uAkhOnR/8yDZgwJiSi/Q0jetmffVz4kuyN770oM16j8hAClKbMzvBSfONZ4z6wryGs/xsfNHPteeVfs3n9fXX2c+cM97f3/H5+QkArSSk6RfyDi3VRBFgzSYG4e8GZGw6RQhIwTK1BQRKWNcLUky4HgeOo2gmGMlqeFkXrGkDcUXeb3j/+AYp99tmBhK4CdXlPDhIrzO5HuP+9LqSn5tZV/Fr7vnmLOeMdGCgynHd5ncM71c5mxXAaPMVQkStRe3IjEBJswBWHHvGvn/D29sr/vVf/xkfH+9gZmzbihgXrMsKooRaCDFELPGCzLkFaMUYmk221orKjNtN7NVvr3Juij4imWxyNRCw8Q0BxmmMrfpcVLcksfzM5eVnQPWdjcW2AM6bzX+/T+jv+PzEn//tX/HLz39GKQWvX15FJlOmREIcCuIJ4CrZHtl0tZPm30NELSD3R4Edz/bXtSdg5tme7dme7dmeTZsZF8gkXRMMzSBg5QgAmMMRYIRIgmyuo7JQNALmDiDSnMRi2CRE9JSzzhEpXqH2PsDbu1k/695yERJF6h4FYDHAipJixnUTxEyQDk14Nvtfbk7pfg/QnUL2uaTSFwMLhSApFmNEyRIVBSJEbwTUd0tEF2T+GAD3lKZJHVKWJt2iTYM6Zk3gBcb0y7Nyb2tRxaMCJnXYUMQaN1AkMYxXYFs2LSsFKeFSWSJP0BVF1nWxVQmk5Vwsk0wbg3xmFwpdqTAeLTONGhWAFvVQi3xmCrinJxuj/W2GIGjUQ9H5DxR1viWFfowLXl9eW1YOM+SWmvGnP/1FoteY2yiJqDnJlmXBy8urKu3i3GzKggJ7xB5G5qmVKIlBmasNGNaMECF20jaadRHpRsfeuTU78+13r1ya0bZ/NxqszIFn9EwkftHm3FcjI7edpXTuFHyj6TRFucyGqLMmqba70Uh8yIRS5DnFZTUQmhCnTwqWYrSDfmyL236UvzvorSlZpgRa1+Jczxqg0B3VMm9njvhzoJKMWRVqAyQYOWgUl/G33j95xrIu47wC6gQGDPgXU0II0fWNsKa1rY7RmLBjcmmXrR+tM63VZgDSZ4bQPrP5IwpIadM+6XUSHyYKcRXnjUVUikNbQHJwf9sk23kxtv5O+5sx07hdd09blqVL1ru2PWOGmfYTZvuyPowZNlpPyCnmauBh5XwEBSvkLGA9M6qEiKKORDLHv86fAE0smrmPx59DYw9o/N0dcXJfbX2T4UipmVoLjv2G79+/IR8BX97+iOt//j/x+cc/g3/+irf/+r+Mxj734M75gAhCASFory0rmW8PjSTu93/7PwJ++Rdg2Qr+8/9WETZ5A59ezWoskbNoeCbP9PHove7JFSAOWOgNNRf8h/8E/OGfjHKFRsQRVfHx8YGYkpy1WRz1gQK2yyu4AvFSsR8AkZQ7q0WcqDUfIlewzRHQyh+xULHn2c34XQ2UKOcVo/ZSKAxxNboMfyIWjKAb4gwBD3dwGjMjqDGUVW4Ay4gpkvwjTZvN4jwiWOY4OwNkDOC+10n3C2u5RkZFYULNUD5OoLAiBgJzkVIoVBFiVOOn0Kg4UD14xMZHyjP1n/JeG1uMUR12iwNV7nh/t3m1kljSF+bYzk6wAJzEkAgcR0apCpalgLQsiCmK474cEtFuPB2QyHcQUGQPV87YDzU2Bi1PCQbXiuMQwIM4fWlwSvuzao6elkwCh6bUFh5/u90QU8LLyws2dWoyM/7tT38SA2fsxluGlBQKgRB1nJFknST6MDR+KrTHWgI1yBrR+X4DOg9+5KT115w5C/y/R83LNwaAtvPIOLVKZf2sMvmt5KkfXlbvcl4T6G3dghl0BehdKiNXoLLMx5JWfVfCti24XL4KmF/3ushxEmFq+kJhKUMkfTdZlZtzgOxMAAHECuTuwFifaWOOHO6OM/k9pQgKBpSRTAykmVNikPeaU1yuVTrU+ellMQVAQNRB+7K+Bax6jQFpLJMOkdDd7XbF+7e/IKaERZ0zAeJQzjkLcOTbd3z79VsDQoQYFWxk87xIlpxSdH0IaQlY1k3762iSWGS0QECtuO5X2EW1smTUASGmiIgILoRyU42FWTK1MCFQAleVvXVOSz5EByuSOp5U7iq5gCggUgIiIYaE43aAkPWMrwAXLCng9eUNIQbUknG7FXx8fsPn53eY01p4WkDVMjSlHLjdPoQOPj8QQHj9+hWX7SKZqg4B+JVS8Pr2JqW78oFcioL2AvJxRQwLQujAvNmJ6+nJnEohhAZSGQHjQFD6sRJTy7I1p9uxa5YPzfhkco6tg+kfRltCOqRrrnMQgvJ4cdL8/PPPjT9lDVqIqesVwWQeAmJS3i6PRSDC5eWCksVRdeQsZxYFWEmvnlGA0DInqry8LEl0zRAQwyLOrkPL/1hgQSAtNahli0PAly8v+O/+8R+xpoT3j3f85S9/wbdv3xuAwyTG5hQFN700EJBLxhLEUXm9fuJ6Q6MLKxG877uuk9hVDIDU7Aemh3v9T9f4+vmJ48gtiMQDDgzIYOD4AaRHQtOSpXBTsF1FKVmuNzZueo0/F5y+5B29j7ImQHk6gMb7jkPsNALG7e9qoFMhIISQkDOj1ps+u2LbNi1nZ1H0BSkmABWVRcYC9cx8XmchtsyB7GhE9Pxa+9q8vrxKloVSe3ecTmhBPOZ8BuRsrqWCqaK4s4oUUGUyYYBlgpF1LQZwIgIP1XWNn1XV7UNTE9o8K/3JPuq2OYbobEYnXU60DYxuq6Cx3JjZbZoGyCzZwEKQDGzo+74Ubjaxed29LHAmL/i/PWDEyxf292xXPHPszsExHhDks42c0StRtzX4DBb+rPZ98+M8s8kJWPZebnrU9zPwxWxjaTqA15PabSZzAFxUv7ASLcEBgZS32B6eg4i8vOrn1ebU2+bM9kAkGaSsT2YLiDGoTNLvmfvfbCPLguv1BslOl/D6+oqsAVWMHkSTi5Rf1Anp4AauqstAjQiTDeQkmOdsvv1azDLtLBeftTM6n3nhHFxkc3vHn/UeC540ujLZ2WTJbduQc8blchEZ4zggGesERBKDyDf52CVDXwgIzZYq4HswI4aEGCUAJ992pGVFSpdmpxX+DLmPgEoBIS6aTMZsiT0jLzVdrTReYhnoCISgJW/VeNNsONxsNxj02OLOaSLSIK+j2ZDPAthkD1mfuIGITQ+xefR83evaFILKnVrItfasw6VUcM1A1PkNBa+vG15ev+Cf//m/YN8PrMsiMq7K4ceR5awiDeKou2gZMSJpJjuzv7aMdgz8wx//A9a0mJKtUx4HMg+BGm/uNkHT75WfMyOXjNv7DTFFXLYNKUmp0FItc6zan4yOrdQp930UU1I9xwCWBwyY/PHxiV9//RPy7QO57li2hIUTUlRwNndQu6j0alMhiJ2i+YUmKxZh+Jtbf87Bd8/2t7UnYObZnu3Znu3Zns2aCr/M5AQUr0+LKi6Cpo/kspre3VHdonmIxEmF0JQXMWOa4GPK6yj0dEFII4ibI83/HBUgghrj2mWjwt+VHBOquD3DnOXe4N4VpvvPbWZEVrR3jIpNGBwmouQly0RAApqwLjTwjhr3mwEEKqQ7R0lTHJzRajaMzsjwYbwUgCigGWq1jrUkl9XqrqLXRIotq0IbO43zFVTxSIHavJPSQFfguTnkTTHTaVAFKDalqSmR7KLW/DxOyqsZ1JiFbIs+NwSLBrbZrMPaBQLWhYCVW7ahXLIa8I1OJEU2lEZDSJIynyu4mPtE5sOMrBKBKcoiBehPm6v+uy68rAqbIm1zi2Ys9Gh/G+9ZtHanUTr9DkpH/do+rxUASCKQqlNgqS+zfGZOYZvFB4aE9lZvJNR5gyqapXYlSL7XZ1YzUoR2T2XTwft1I7/pTsm+Hxu7p2oAACAASURBVOmujFjb7U0hrrq/5D9mOHJWp9M2Gu9kg9QWkQ0EA66okaor+xho2iwJylmNObZxmzPB9pxd59Ng27qyrVG1WUCnL8K4NsMykc2m0H0fRaPVTgcOOKJRRAhWVgoo5cBx3BC0JFu09MncszTZsHsn9OzQ//XZNwCKXes7PdG4WzN1j+j4R5CGXTEaFvV+tpT9DDPW2Dkmj69tzKxgSKIAqlJyIWi5LLk3iIOPSPK0NL+C8XPSM80smjY+11viOzJkY0z+hCBon8U4nzOhLgHrPyQkVBy3A87V5J5Fw3w7H0XjaTR1gB/8Prfjk3B8AusLENTycR8jNC+AfUZ3Vz0IDh7vb7Ru4BDJTJUujOVF7UoKEomRwIhIX1/knGbJUoBcpXyZppuuTJrGXFPS5x2lZOX1dp54oKLxJMBqi4MFSForN0dNBWs5FB4i9O8cS+5cJ6hh0N5ltG1HuzpbxMmLNh+IUcqzEGk5Rk3PrCBhrXmk0+7KsiA34E07Z5WZEOQcCxoJJoa3Auas81Jh0fhFS6uQ1rxvfA42bOcQY7F9i19V03yH1M54ofegtdzVoVX7Olh50H6+yTN6hicDbIf/l7136ZEkSdLEPlFVM3OPzKrqqu6Z5vCxWICzQ/C8vPHE/8wjwTuvCwJcAlyQWGCAWe50V2VmhLs9VFV4EBFVMXPzqGrOzC0UlRUR7vbQh6ioPD4RQVbwkwBmCwpn3Q/GD9XwDjkXS6lY1wVDTKBxApBlbGbsJkKMqYnO3hFtTgPAjLECsslZHDAdkNtBeCkNoCBFeChGY+LtvLH05X63VjUey7HQZVubc/KfkcwnY3+Ot313MPSf/X50Znk54GiwPMoGfo7sWd5hYw64/q4ur9h5VNU5swcg2nXtzv15beejDBwUElJIwiMV3NKda5JNpNaMLpZJiZqSxaEZYsRABB4tsrWDXMhorkXwR+17df3kRheAi6h2EbIGHpaxyv4NJHxsGEbUIo7toiCqaRrVQdIdMQbiIt1npqdJFkw1MoOR8wpNIwnLlFFKQV5ncUaUDHAVHlMqsmY2EkduaRHLFAJIQeelCKAvRQGyl62iEBCHiDRK6KuNu6+V6RuS7bNWEuFU9xS1fSp8tzIDJYrcWPdZ4Ew/q1hQip3tIqdTjKgsjuVGxyDhGwggSsqHgpRfMx5NwJgC0pDani51Qy0biDYBtGgGzxgC1nUT+Tdn1JKxbQtKFrq6TBMu00XoqnQncUwJgTQTx5pV/pOyW0NICDEhhNTOG+9o9jR15ow9Om2FZ3bHDDMjpYCm6zM1maTJzLojanPYCJ9uwHwoiFrLObWyaiT3GM+Td0rwQa1FAQ8RTKRnCjAOk2T2GEYM4wBz+uRtw7wsmOc7tnWVda6dv21bbtHe5vyRzBVWLqeCUMEKAAe4OQFBACUBYoYgGZ2GlDDfXnGvCk5ZVgwpYRpGgMxBGISuil9HKdWwznesa1SeUhBCxLIskvElBC1xbLIo7fhD5ap8H+2sgHPYmcNQSrTtnYDLIgCTfRnigxRHkExUMSDG7kwnlVUYUtaFCQoC6nqUzHvdyfn+97O25/Fd0rf9bx8Ly5IP1nXDlotJ6NKPmIB5QQyyH4dxhMllokcVlSkUQGL6FmLLHMYsmdqsA5WBUO0s05LKFBGHuJPNWgBHrchbRt5ELrAR1dIdjlYydxgSSqmYt1loMgYwZ6zLutODxSErICYQNTBOaDaEvh+ND8p7ScFZpcmfdm5lCxBqAr/x+R5sYdnq7DNT9WIS2pZrFFjk9H7TIc/aUcY48qYzB+d7oIbjc/f6cJdDmvx8sEW818f3+nRm4ziTdd4LcDp7/lH29/3+S4AZxzVg0wVUlrerzOFv63y0r3mw0rM5IILKm9yAyMqZ9vYE21O1NnDD8X1+XL5Mmtk/WHWmRvYmz+pnDB2n7gMye3Pr/+PangFf3pvj4/encrGO2V/z7HnH93s7336eafe7gR/tXpPreibM0K5p554C6kUuDaqHVsQQUHkDuCAQgxWfQAq+iXGA5BwklYWClq/VbOcGSASkHFALjFBpmYLKu2hqXlB/QcCeJkvRgEQy7i7yrtm+JSENQ8CP9mxu3xP1TJXP9rlfJ+CxFNaRLr0+QsHo1vQvkRNZZUfS5weqSEPCOAZw3fDll1dsqwZZIUhZdCJQHGRddF4oqh6tV1VAbfFVgix1Iw1pwGW8YBhGAeDEgBQlSNlTmpqyDnIttefYfhXaIQ38FBtBA+nr/lV1SfeU6ca12TmhGR65+R6EPmtdUPINOd9QygyiipREnxG5OfSy0dZvaIYj9T0IaEbl/PZ8W8S9rtiX/Lnc8dH+svYBmPloH+2jfbSP9tG0OdN0+9mFS6+w2S8ipNjfZqCSazqKW1rtkowKbAHBGd/2Aty+V+R+f+z1o+EPXegmMTDCKaq1moHHgTNqT69pxhAT2o/KnUetm9GQiJoAVzVK3EeYmbPiCDYQIds/3/pwGGUQA3mbI01l6aNk/Bz46OZuiC4yMw4UE0icAh3EoUJ1ACqLEbirLv0d3UACdRgVEA0aWSROZ1Pa/NyYsuEVWUJXEncKuknnh/nazQvthWVvbDdKaIb3HY2QRruMsFTvzAKOMQNg1XFZ/XDJ5KDzB4BCROzWLZkhMoM+N8CPGItNWfEGQe2kKjVHp9YxRa4pxPbzcT688gBHT49KxIMRh3s2I1S0qIYAassg02wlKeR1R4fZcW18a6l52ZzInqa6cmofSx1fF12NszJAjylrbQ6ErvZ96mShDjYOzSALmNONT3jS45jYT0y7tjvuZJjeaPZIu2pa0Q/Qf5oRyOYX3OhB6hw/GnXabYJ6VNCaGCTQwGx27X5t2rOsm0ao3MFo/TwQg0VoketVyd489x0QxZsq0br3g9Zkpjb/5BTyzh2NMxiwcj9/zTr2RCfeg6fOv39GGLWNtU+GbmszALpMYKxnIHEA+71lYASrf25zrHS5G4+96jc1bkYnAFCMKCQSuGLbBMhRS8EwvODTdz9h/rEC63/Cti0YfvkrhPXqTvj9FDhKh4cqHcyJv7Wz+ihdJz6soXvX4zM9sfJvemUfk6x/EXOO8mM0w5yct1piT52NtTKIAygGAQ26FNViEJSIqZyzZFFhNN4EeTSYuyGHmVFyRc49dXPVZH3NpEvqoCf0/bDfpCInBQVZgRFQEV2ZuVp7CSYhOwNYhhZZHFJCHNSBrmBQMTAqfRJJxLIcYJ3vEbVJNQAcdoYpBcw0ZlXBnNu5mUtBqSsEZGdgFmpbV+ZNs0Y0oIuAiqry4loZ65q1VKjJHOLcl0xu/WFmQG0gN+pnpQEf+tSKbGNEb2Jn54uOCUOzaTlnftZyGrVWSYEfAiIRaqgA8s7IajylG3HR1s0MvK08VCDNxCEZv5Z1dRGQmhWmyZ+aA0rLZTYHop1l2n8DQzTnQjvn3tlLT86833Ktdwp5mdnLCb9uzGYd55NzavcZ0GWfx2v835tm1RBHgKUijwia0tycHeZ0sD733+Vd/dindk7XBjqz7zRK39FniF0nonbfobxW3ZdzsCZOUgGE+LkycI2VivFOE1Cf65Ri38Ms2fxKFmcDVwXjMsTRjn6eSzacBet8FycNS1aOMEQFqZQ2z5apwehNHMwJl0uEZbaplbFs4pCdriNCEiBBqQXrViTaWWVmcxbb3LNmVkit1KvQdkrRyYH9/O9zyABn7RvbJzJ/uct53pkS49gA7yGiOYmNWdi8lrxirUX5bQFQsS4zAAHJRaW3t7ebjh+oZZNSO1r2Iw1Jzwzhm5ItI6Jm6bNlrgABXBgFBTEIkIegGTJ0rMesCj7L2cM43d/mBCnFQA8uLb8SLJECCPVelX40Stw5llpmS+W/6mQLtu+1vyFIKTxCBwE0nZUKAvdzRgIfRCeIIWiGGAZzwIVGpEhYUsS6rq1/ksEjS4Y0ZnVsASFFpa2AMUah00goJbXyvaY3G5+otSBvAqy9v91Qc1WnZcD1+kmAZ0IZkEhvAgcGKGgWqwwuBs6Q7LJDShiGiG0zOQCgGJrcXXUvxSAZPYvu+2Y70JuYxdlYFEjSMg3pHNj5Mk3TSdnWc/CMlR72eqe/x7LAeqDC25uUmzCn5dnZ0N/d+alvprLYPrSstSACU0VFRrByiKqPci3YNkbVksmy1kK3IuuhBc4ITVQtc2Vz3Km57aPCzZEp97Uegsj4tdtv3LPPRc3gI87tiqjl8OZ5wbatCETItaIWkRVSDGAtAXfUO3clQYgb6Mw42fm+FnqwPsgnBtze68tW6pJkc4vUrPdK1qxeyq3faHL0I+hALCXGGWxesbvm2M7sOvbzDHhi9/waDXfeRrt7HvT4k5/H/hyd8P66Z8/09/q+2J453nPsr7VjJt/jPD2M+0GT63ZIsNBBqT5zRpfVWnYklUHO9rLte5N/+n7Q9zCbWLBrFfV0rY5jsixo/kywct0eWHzKn7jrFe3fk3nazdk7Mu8zGfi47jrh7+qrZzTq5T8vM/u//ViP82dl9bxM6OfMzu5uc9VdyZKpEVyl3C8UINJAJ3KGSMZuAYkz65wyKxDVdDKAEeSMArVSxZb1y2voJj9Jn01m1J9kmkzfj+wyIBLMJkkmyu6y5TXZ92TO296S46c9Bzhmnd7TZrNjN8FH14L6WhgALQYpS3q5jKhVstjO9zuGNDhdQnRSsb2LnM6qy7GBvRkCVOR+1rBm/7peX1p5tqigdthYjjTu/3T6gI2ZSOz94zTuzhpoKafHh5kOz3o2iLxNRgO1QnTeDHBBLYuCZu7IZQUjtzOVVd+XM78Hk3k6tTLIXlfq8j3aediG6Ojqo/3ztA/AzEf7aB/to320j6atoeJVGPFKnrvoIOBL5hiT2ORSNSqSF1oYgjLvwrIY87qRz9qvGejP2lFA7s9CE/rt2abc9ffsFTgzzoS4z+5hSohPee0d+OKsPHcO2LWm2PjneaOTNxQcFSVvDDFLTkqW+lWcwF4gN9nZsstIesUCcSUWcM4SNUcDInrUmQnVgQmlkAjOJ4Ytr/gf5887q7xwDvQUzF4Z9E4DU3qOhgNPi2eGBqhzcT9ftdHY3ughBslSejSl0ZHUQIU6/TJqFYddzgW5MMCaPUPTjNdaJIK2GRY6Or9WSQ9NJGCBZlRGB4aYYbnHWXSlrdeO3huPfHtmlDyO+aw1gwcAqm4tKiEEFqfu0Vj0xHh0VO79+/saA+LYUiO6KU7miIKUTDCrg/GjYEq0M+jsxuDmYdevX/O009556K8+U56PUXEE5XFtz6B9buV9zEnQI5jZrtj1//ius37YHEoZDlVuHa8Ibl3MaOx69M40HJxGrANrIV36DOUPFlkjRtSqUZqMmAYMw6DG34wtS0ploqC1mKvyQJ9VTI3hCL5DAPpeDZqNS84o66sY6v45mz8Tdn8TmqO6qmM7ptSMBSGmBgTglnFov5f/efvX/2YGci5Y1wwKGWGpIKr43Q8XXK/fI/3NDetP/w/u3/6E8H/+D4jri/TJOQ77b86Ydvgd7prf3hgVGRQqoJFEp0/n/T19gBDDW+MTj0bx3Z1ieUHmAkZR4/1hDOYAtD/V4UyEFsXVwH21qLNpa9kTACs3Zvz44DiBOFssw0ynodDAL2ILIykLpAa+JjegO3VkTwnYg7gqYEYcNsxAKRnLsmBdZ9kjzSBWwcgK6IgYIxAToeqZ1UovMkAIqKwRXCpaAAQKY+ONcpZLabjG42HnvHBuVAGriGwTQAhAkvUTvhLanJrRq/MaAwZSI0gBzogTUJpzKgYzsvW9JVHSPSPC/txycommok5xQAyETAFbXsFNzjFi8qVxpA/jOIIYLe131CwaMcYGXDCZzpzVx7PSR+GbnNPpKrT7LdW6GYMNCGFywIOTQaMtbY6M6iXInHtZPS9HmpDo98//z3bmvHrmhDjOx072/gvedXz2e++077uM1/UbOzezOjD9uW0AVFvPUjp4iolRsqyTlEBKbZ1iEvqJAGr0Y4RmNfJn+t5BYrThx3OUpZkZ67rifr83mkkpNfna+jOkDrAx0L0JLhWsTvw+/ykGAEVK3awbVs3eAbCU4SQpdbJpydqgQAhmoOSu2wl/ktT4l8tVy0cVSVnPhBgHEBJKLpjnovoTYRwuvZxDrSJPQJ1AmrUthQBg03IgmsGDzVHLzaDf98DWsj4Ekow2zAJ+KKZ3me6k613KCqIiZ6rTqczBDAbWNWvppK3RFVDx9naTLD9RsuvESMiZMQwJIQA5V5Rc2zwAhLxlVJZnD2kQ8EzOKk9xByirXmGlkqrjpX3u9zKj3w/HfWrOcE/fQm9+TynhPtmeMXqTuncOo+8lWFlU7uXhAkm0udu/hjsrW0YBkJJkJqoKDF3mGet4x/V6VV4ojrvLZUKKAeuiWTsADeSQx6cQUKA6VclgIozjFdM0YEgEZikF9vPPPzdw7LZtWt6iYNty49sv0yfJTDVIybxhvAjVVTSe4eXTdVuRtxVDiLhcJg3QEF2cmTXLmDlKzTYi+9wD4Px54tdwXVes6wpmKbdkdGG0YGCZcRyFz2lpJm+XMDox56DPcGF9MN5j/MlnghBg3brPZHVoe52qZ9l6fs3hMzCS7kED7Ajfi53vBgHQFFdKwkCSZgvJOWNdN+RcELUshJU48jYJU9UssKiUrFkbih6djHVbNKtWBWtGl+hKzwmdS19DJPDaSziKDKHAEuplpv2Z4IEqtp611iantV13oAnLUOZ5wrEs0DEAxfMQm/fjeeTtVGeAvP58NOjMr63vsQ/HQLDjNb8mp3j548x5fmZH8fYVzyfPxvZb3u3n8ez7s7890Pr4HJtr3//3bDvvtVbKxr3Hj9O/4711OBuXXS8g/kf7018yh/5vvye8DH18x+75Zq/GIxDpaKvyY32vj0e69fP4a9cfP/d0eByv6RP2Hr9Xj/KzlfDzNmbf/Bw1vqT8TcrBosk3MYaWCT3nqsEUoke3TCikQVnRZCnVqQNpoMWjLc7zjbN9CeDpufGM3mUOxU47jmP7/FlmPT8P3NSfRzrw/fT8mMGgqOcxiaxpQGkJwKiaHVRKtr69veF+v+GiYBQBT8pZQCG2LLOm9JqsdaY/mY4xDmMrqWhzI4E8mn3wYfb6mI78vvFIopZ5rs/b4zrs9SyglW/WM5ICtKwSo2wZkmUmo9ZVSpCWrBlyoXuz6FvMFnx4J5mq8mj3eo8Pyc8nE/HR/uL2AZj5aB/to320j/bRtJmgBjiXVhN+Db1/NEj31Mv6FKiXS/7BDPiaapDVGmagmkP7LYLQs++OSmZ3su0jvwE0YyOgETyUds+SaBzeKSxHg5F3kMlzokbCdaeG3X9Ussyw7Z0s3ilydIjs7kdAiNTeIQajR8W3P4MwjhNACbVuUjYlL6hF+rJuQSPIJaqxrSmZszrgKMj7OTcngV0ngjntrrFxmyLo1/hoFPL9t/u8EeWoSJjj1StD/lpbL5+dpaV8BNBShQdxxhdLWaxKjBjnAmIkEAaE0CMFAGDbVqEpknu3UhpIx8ZbS26GuxACYkjaZzPU7RWUo8PE9/89g49cvx/vUUF6UD5UgTkay460143gj0aK47X+770xKMBKcJwp/z5SxO6PsYLz5hTTfbTN0bjXf3/fWOHn7fGzRwOSv/7BQCPWwa5YkzmVgRb+4ZqPEtwroXsjt4w/7mhXLu6/e8Da0YjUDNq/Aiw5M/w419Nh8sgGpX0PiMEcaQVEGWi8Ix2MQj0tfq32jADJAtYmCz0jhEYXh9TXtPWLAeR3x/VktAAejTXSl+PffZ0YagxKUfd37NFryrPRzh4pOcDV1eg+8MH3DYd9js+aOc0aTYi1CiEkKaNQM263DZ8/Dbhev9c1+LY7qZ8/XVZ+9wnLmf4eFR3vovZvReEEkQWCox/lBbt6S0daLWbVOoz/0WjZn8DgING4zAyqug/1mloKuAjTa848tZ5lBbms67zbU6Xuz4QGQiBJy+z3K7NFTXXgRs9qocZKCggpIQypAS2BbhgUgKaAOaWmeEKkgMgM5BW5ZFgpzGWR/g7jC4CMXDZ1TotzJyZCJkbZ9PyoZhylluXLMq0BaFFlcZq0xJcCb2LBOE6Nj4eg5UZM3tEIdx/RLsZB4QEpJSzLgmXZO4Rq0XJNJgcEfy7Iu1IaurOIK2rdkFJAPRg9O20cjapVM0VQc+7WmpsT30pnWPQiDMTHAFc7k9TRUEzmShKpro7V+/2OGAIulwuIqGeNoT2vNieoyCGEbds6f5eUFmBmLMvSHJtVgQPAHhzezko2nuAz9ZlsNTw4Wo8y1IPs/E9o3tGyN1A/f2dfb9o/h/ZnzTP94Myg6n+3v83BCnhZQ+ZOAG6W3aM7Jv3z1nXFsiwP8lWMUUqqKNDpKOfuQeWmV/CD/HI859d1bc83mrrdbrs+Gb3ZfAalQdMvjA497R11EyLCMEiGyLwtUpaJK+bbK759/QoG8Me//iMocKP3LUtWkFq5gdAMOFYrYxyn1ofbbQazAAmlz1eklPDt2zdsZdP5u2IcJpRSsC659VV4cdcTiAhrzYgp4eVyASD8smQpvcPc+2hOAAOoTNPYdL/ADAwy/pRSm2sDU63rCskEtWFdJdNkDKHJc7a/SpH3jmNCrQU///wzYgyYrleAScrHhIKXT5/bejACmAQMOV6uqLViWyWAYRxHsAJpxAck53qX/QkxdpAKW3kF5RGe1o6lLZ7tQ5lbyUom8qbMs/AmkcV+FXx+2H9tfwTS+eL2nF7OxUraWFln401dZiyl4H6/Y11XAAKOmZeAt9srfvrpJ0zTpHtlwdvrrZU38vQeY2zZVdZ1xdevX9tczfMd97pi2ySzzNev33TvdsDIy/UFfDEbCZDSVQMmFBhmZ0RQEJaVx6oVFAMu0wQeBpRta2NiLshlxTzfUErB9frS5t3OsOO5sSxL42GmF9xut132heZYr4w1C4jm06dPmKZpZ28wvlJrbc44D4LxABrjZZ5+TC7wjt2cM3744YedfcW3Pb8/Zgt9dl0HLko5wn6mp5QwDANeXl52OqHxO/lMskVdLhe8vb3hdrtjXTZIFkHWdexlxGy+rTQWADDVFuWuFA4LUoohIYYk4OVNgHlLnRuAbhgGrNsCXmU/fvf9dyilaOmohPl+x5evX6QcFzvA0862tKcDIgHZVt6fi37ebA2ONiF/bh1lAps3u8ZAWAbCfHb+nq8hYBrBUdd/9hyjSys3YzR6pAn7+3jf0d5kc+bfebQNeTnljP6seZ72nl3B1s1f62Urf74TdTui199bhii9z+8xu+9ZH3+t+X3l5RzryxlY6uxd8gy0/djLR/Ygw2Offk3GbPpWy0zd32m86riuXh4+Pr9q5hSmR2DMmdz5W+jb33f87HyOHvV9TxM2d/46G5O3/fh9ehzr58+fd/Tl96xdX0sF5yIVfJWmmvxp50EILRMhMyMFRqmQ0p5lRUoCSjE+sW1SChQooCDnzzgOqHmfNfFsbT1Aw9oZ0OUoa9v723cxYgj0QA+erv0z9nP4uJ5nfMQ+K2y8EZLZk8WWJyWaAkhLey7LjLe3V+HzSrdydqf+PAB5ywgxIoYoclGtTdYFOugsxihBcnpm3u/3HUA/5wyUgphGaMThru9+/Md9SWpeWZblYf5t3A9yAQsUMgSx66BbyCA5CDfksoCIsa4z3t6+YZ5vUs7YyjlVARulRAgxobgyqr7ccA0ArFSgO//8+I77Sv/CR/vnaR+AmY/20T7aR/toH+3Y+EyhQCvF8qgwivOLzG+spXxABtgwYIkJN+Ios892r36iiL4nGD1TwMU1qA4RB0ARQ8Y+UvoYseCfexTej0p8/64Lufa+FgV4EPRMePWRxfbsY8TtUcgngkZi807J9dcejQTcSo2IA3ocIjD0TDe1FFReYCm+QeKsiiEhpY5mPyr6ZwqwOdS8A8CP51hDvSkEzkB0jEbw//xa9OcbXYixPjs/OjVHvCg2RJIyM4YByyJGWHPWSxS80KzcGyEGa3PgxxaNz7ov0jgiDKI4DDwiqOHVG33zekctW+uPkIpGJ2gZqJTGZqyvmobdKzneAXOkiz7/z5Uj75zxTar1PBp2rLNGDzaLDRyFvYHI75ejUaZ/HyAx18+zSj3eS+BQAZLoF6BH2vn3H2mEGcDJeGXm2/A0akadpUBTznw7jsvWIwRJpS21fLuRUH7KnitqWJVowiBZCUi+P+Ke/J4159PDGPVnqT2KFzG0FOREsJHIPWQYhOe89biv+r1m+Ahaq1wiNM9pKaCUDbVmxNCdk2aQN+Or58NBDTRMkoa+AcgcYIQrsJUMA/JpLwE8pgO333/N6PWewc5f4/eVmAM0W1lgUAga3V1b2YQUkwK7xJgvUUh75+3Zex7G4MZx7KsZEuxjM7IULgomIGxrxoaMWgqulwHj+D3+8FcDXvP/jbz9Xxjffg/8h797d46ezFzrYf/t8Vtr2wL8+/81gMKKv/rbir/+N1Kz20qhGdAHbb1JFpzYPfnR8HZ27jR+wBVMVQ258k8eZ/McwCygmVIKypZbHe4KMbIaaJJ1faUME/fxMoNRVVZCL2cHBeAYeDb0DCSRuoGQSACagcSgG0jKcoDN4ZV2QNq3t6+43+5IFPH7H37AOA5Y11kilfMKRsGXLz/DALQCVBPny7bOqHmDRPNL6bBAUrogxYSkGaHutzd1EquTcZ5QasU4jhinCcwZ99sq2Rws4jrnVnJkSAPGaQSYkXPCuq0gruCSkSsDtSASMKYEbtn7pH47gjMSB3GC9SxzQZ1IyqvAyHlBKSvmRQCtpRQtxeH5g2VxU+dnJCQASQEp67IilxWARHnDSvLs5A0ArYxBNxZ6sIFl6EhRZAQzcto6e3AQsDcKH8suyvhjA8sY0Mp+ruvaDKUpJWzb9iCLeicQgAeHk5dB64lTy++nYzuTie3a43dHR8bx9zPQtW4BeQAAIABJREFU785QWyUrjjlk7HMPQvI84VFO3vNdLyObbB5jxDzLPkKV8pm1ZJTc+1uLlMkhkrWtpWAcBlyvFz2HLUOL6Tj9/K9altGG76fYG+abfKEx+ebQ8HQjWRFWXK/XFk17BPDYvHcnXBH5LgZUFtBYzhm3+w0lF3z69IKSZY+XvOG2zLi/fQNhw7LMKKXg5eVTc7jP84x5Fnn183c/aAakiiElpJBQtg0xipM4aRr/YSBs64b7fcY4jpptpkjWGgoY0igZOWrAthW9d2wyE7CXvUJIGC9XxBBRa8GWN3HqFHHsSIu4XEcYIGMYI8ZJsXgkAEmizi1qZSBEKYcWk8qOEUMk1FgQsvAdAeTUJv8ty111PAEtllqRhgEvnz5hXgyAM2IrAJgQ0gAURkVBGkYMw4jCkp0UAKZpepCpvX73cOY5ndwAdZaVyn4/Au2PzzG6sdIxzHtgn9xjPAs74Awr2t7rsSH07CMhyBkTXXYck10YClsmSHkap09K/3r2VKCqKK+0UARMV/KGr/NNzsE1o6wFNRfEaZTghUVormwrXucZaUjIOePrLz/ju8/fYYiE8TIghgu2Tfr8u9/9TkFed/zyy5dW+qqvCyGkUdYSBC5FS9jYoCJSlCALGXRVfr4qzWqJWdUPBSB1LPUsspDXgwHh5XY2Gk/wYBnjaWlIWBWc40sntawmTja388pH6PsMr2f2C9PjjY963tsAO++cH7KSj3Kx//3o6CNzeAYDIAekKFpb3halDeG1Mt7a5LLb7RV/+vM/NsBaCBEp9ixjRUtlGZ3L2VLNDCBzUITyxRYg4DKhU5FVA8n8g2t7j59fK73oARJEhGkaMQ7nWXdLKchavs7mwfRCEKku+aibPtOB7LqjU/m4BgLG6Y5Sb0vwusdxvfwzCd0xfNbOZIKzvp7J+AB2WeKO9jvP6ww44JuXHWy+pIQVP9Cy0fgxQMWuOco93gZ3HN9xrv0Y/T9779HOc9Qbj4Cf45zt7SGPdjR//xHg4wMEfflQf03QkkcGoLD7DLRm13rAr7cHna030MExfs7N3uLfYzzIz8UOJKo6j9dMz2TXs7k9AsuO957JmX7uj7q7B0N52jrSkretHG1b1o6Zpz2g0fOJXV9Z+FTWLFPGO7Z1FZkoRCBEVCYJKAFQWNXxEDDECDOLhRikXBtXAXswQEHkozhcsdznlhnUj+u4Jx7KA4Ie5sPPn5eLDaBeXfDQkReegan6B5aZ/XEPHsHwzKKrJZbSipULahad1rKNjWMCMeP12w05i5xEAQhReND333+vIxSQzzhdMC/rzo5q4/A0yMwNbDONE6ZpwjBMsDK93kbl6c6P9xlvsBYoPJwJD/Ol3/WgApIslHmTs5IzCBUERqkrlvmGr1+/4PX1K7ZtwWV6kcx+bFnddXwVKCio7M4Rfa8ABRmJYjMHHffXcU+enSUf7Z/WPgAzH+2jfbSP9tE+2q81sSSYj/Lka4aUW+rABXN0MEQwgkaWyffOCekEujMByAtHx2u9ouPBBA1JToCAHQjMeyHUDInt2npIA0t7pdYL0l459AqiXesFzqOB8qjMH6MmvKD/TFFmNcrbfMsz/bwrwCnITyJCqaROPkCyOTCYizj14tDm0DcxambU2qOuvSHU99GvVbEIu4Ni7A0JXjnfReZ7IT6EnUJ1NB76uWQ1Hbfxa9lcVmqjAHF6glAqQEUylsQUEGJUo68ZBgBf0iqXopGx6nl1er4oO/JPHFAVwzAiJbme1SF1GcRJ2+lG3lFKQVU62LaC+12ih4M5PUtt7/N75GgoEdp1/fqNSkOb98Ma2fwfjQF+Ldjdf2acO3uXpS7tSql9nnUOj254e2cBuD7QkvXT+rAzQEDKnpzNCYV9f5m7G4CezN2R9pphg6AAG6+46fooXVpGmUi2d42vPO5zMwz1OTsA00idu4d++z4q9bkumcHkvD2CX5RXBBkDc0bWKDcxHlp0bTdW1qrOwyrlZGq1PW7R+91x3PlHaLyCgmb6IsuC4Y1VlpkIysdkbOSAFX+Roszv0Gt7TAe7EKDeTq+s66nGBVwJYl0vYM7CW6HgKKb2zKNyf2rUtuvM0NeAHuIkIgQ9n/oNktq3Ys0zKkdJxw/CusnaASN++OEnLL97w+31K1bMSP9qwTAC+Id/Bbx9/k3T1kWA/vLjCHarUIH7z/LLPyIDzPjj36XGb5oMwGaEVx4LM15zvwb78/VZk1IqUnoIQdfKrSMXpVel5xw2SWese4u57hwblcUoZgeKmpq1T9I/A0l1GSW07CqdR8deho7EkDZNSQAoQcqaSJkTAXXUGLAuK7788ifJjjAMCBTw//7n/4RSNqEzFGzbjHl5UxoNoKpp+CmiFinAyMyICKhUwUzgujmZIYBIIthkHoRVbMtN9mQB6j1jnhdM04RUzVEBADdxPqWEaRgxjgOGJBHX0xQxpAuu10FLaawYUtAyhyr/hIg0TqAQxTfFjOlywTgM+PoPFb/8/QaAEELb5UIXMeLHvxXQgp2HX758aSVhLHpNZKxB+q0ANuaqfRBwX+fHwrckmpLVUatyq3FU5n0CJOZWOkv+rjvD35nz4uhM3MmGgJSZcUZbe9YR0G3P2zSqnYCWbaGDNPrZ6rrc++dkdnvme+2ZMfuZU+Eot/v7n72z0ZaCG+wz//OsT+/12a4xWdP3JwTNkBbF4Xl7e2uZC0IIICejpxgbvysli4zxELHZHbe9bzZu+UuyeezBzHZ/Lhkld1CQgWLM2WTy9zAMGMex99PLw8qbYohgMl1DslF8+/YVRITLZWxZJUqRfUYQJ9hyW5BixGW6qEM84HabseWCEAbJbkID0pAQY+eD03SBlQ4qhcVADmBToI9k8Pjaxj0O406e9jTUM0B43Up+5lyxVkHFC0CeQVr2BDDAB1QPGjAk4a+55A7uUN2wspRNHYaLgN6IUHLGMFyAWhS41eU4e25KhHG0bBBSGq/Uimm8YlkyagWGcUBMA8DAfZ7BtWJdZa6v1yuGQUD7MQ4NcEdNzjAAv5WVtU3RdagQAqoeSiEEzPP8FFDm94nXO73e1qN/XaQzG9c921xwsggdZDt6uFB0MTmYS5XMbT24wM4e7avbQ7yTBwQYlcuK/KelZYYR0UEcK2+vvSxuyZuOqWDLC0ouUnaMKlKKmMYRIUpf5uWO29sdy7KqDAC3Fp03lVIl2lyz8aRR5D/LRiqZ327I24rSMo1puS/luSZfgEhLOLCTMypM3vV7wtbUsscZYNI7oZkZJQufM3DNMdgCwC7z1BkA3tPMESwD7EEHR778Hk9u155ccvacdta0d2nZEJWbWAFJ/lrvnJVSsGilk0hlaA7dkW9Ar773IGBHPGYn9nqvzL3OJ23YNgtu2fSaDrCzOfOgA0DK5MVhENmUO1DGAxVaZiqn51pZD8/3bQ4bbR3acW8eg7Pg+mCfna23yRbHa45r2YMfztfUP9v30QMFzgA9Xpbwnx3Bwd426O/388OOrkyn9e/zeujZO/0zfq09myf/Hj9uP09H+8Z77Uy+8rbFo4xGRLuM154fdDp/dKr73+17WwO/Ht7W5+n/zDH/bK79dbs5qR14bnvZQGrMULvzfg6erbHvq/G8Z6CL49r7a8/ecxasdnbt8R3vraXndUca93u8cgURMNg5oTygNGCblUgPABE656CWzdz2vJ3kJh9U7tm47IyCrn0M+yzZ67ruaMA3A08c19fGcEb3z/bIcQ6etaOOdrxn9yyQZP8sIisQIMDrQHh5uWBIEfP9rrK02HuD2rVaedRhAJEAXQzcLbweYHibeN4BXaWPMvshSAbJHlzpS54/8gjbl2e846gXnc2xyRt+r27bCiKR70stIDBu929Y5hvyumDLC+b7XeTCKnJZ2SSwjEiCAkQWCs2m5I54lfke1+qsb890yd/Ikj/ab2gfgJmP9tE+2kf7aB/tn9TMubVH8XcjkykhVrKi20msbIl8vxeGngmwZ5955fgxqnWf4tKMBdvWox/0skfF/2AoeKbgeSOCF9qPoJkjCOb4bD+2o/C/7xcAVmdHrQjJjHBecRCjXZt/AIyEgNj8zrVu4rgj0nnKMNNoN4go+KSSGqbzTjn2Bpzj/D8zJhyBL2dK6MOY3d/+fe0fukEqmJGGzOfSgU76Rkj9eDFoc1GlrHXTz79Og00axZZivPcdAAkoqzLUMdcV9RAiIiK4ZjV0blhXcdQxSzmKmCRKw2fwOKa1PovY9nNsl1o5KDNYeHo6M0ToA9rYZf5kiDZ/ABzGgHQfP9Kt//1sjVvUdIyS3pUIqJoKmqvMry2cggWIxKFBvDdmvPfu5lpgNEfsTiOTC9vf7VOb18cZehgLkSp9xmf8jTou6D5q8/FEabXP/LiejdF6fLb27qlyL/fu/JrxYH83YACQGM0BWEBUQVSRy6ZjcXTAAAkjFUcDawYldXwMw+TeYA4IM9REAfJpiR5zOIoRWw05bHuQ5d0gCFBzP5e/3rpR/MnAT68TelI+IygpEFeQlhokzUIStFQOkYKHOIqB/h3DzFkfycAy7bLg9qPxQuh2ZFTOmJcMrowUB4zDBCAAG+OOjGliXC+/A3HAHL4hj3+POGzgP/8e/Papj/E3zB4/+ct/cnzW258qxivjj/8d61oG8K40FqFnlqmws+isV88MY0Qyb9HOAb8p7fegZzkL/zXwX9B7K9fm5Kq1olQpqVdZopAtOpzR+1pKQck9Uw0RSWR9FAAYAQjRgDEAESMGRkCBJMPRDAao2FYz8ANlvWO9vyLFQTI4lA1fv/6MdZ0RIyEmgCF1wkMcxHBGkj1NZC45G5kEPCjjs9T73SktZ4WCXVJCCIStLIgBQC3YqpxbQ4ooO0ohcCjgWpDXBfMccJlGTONFWGCtCrTLKMXmR6LQUkyYpgHj9QUhSnQ7M2MY9P3fVnz5j2ai1WhFfetwJfwX//0EpNgMxtsq56qVuzB5pBlnWQF9xRxaG0hBXAxGzpuud5X05RUw0Fo7JYgeADPG03c8EHjY614ePOMFpHRSmR+MnMw9I4o5NUye6Q4loNbywAPtz6M8xmxwzkej8XvtjMeeGfa9PLp/7zmP9rIkSPpnpdKO83kmgz/TJY6yov/coiVTiLIDawEBGIaElKLy24AUg855B/VKaZ2uX5SSG3DOZHAvS7uhNNo8Rq17ZykRNQCEB9j71OghBFyv1zaWDggyUCk3up/vK97e3rAuMy7XK5I50iFlZIhIsulsGdMwYRg6/8q5ImcB28U0IqaEnLVkQJQse0AvA2CZZ8yRUptzoGJZVoQQME2TymrdIQBY1k2LQj1xIgVCXgo2V0IGClAMmiEFCnKMQbJthCan2bkCQLNtyUxVAQGHIEZ9CN8olQEYz26EA6CX4VqWBaVsKIWlH2lAXjeMCjaybBTzvAiwmgKGJKCjXCSTSkgdCC/8zOiGbAndPkKTiSgEKTnh1t/rms8cj8e9ZHPdsyNJJo29DBnw6Mbo3x2dXE1nRumSlM4dVzkzai2SoUUdekQkcx1CkyFNvvb/WLPAbWtGraK3BkoIlMBgzPMselUI4tARb5NkUq1VgIXMWJcZ37CCkDEvC97e3nC/KTiNIqbLFVZ6x+RsBgQsA4BixDAmpEhgLpr1JGBZbrj98g21ZoF6a/CK8Gc0PgE642u1KVsh7MsEyR7q/L9WyQ7ldWI7w0LsZ5857PzaeEDGg/7k+Ld99mt2mLN2lNH2Dsj+//faQxaMUlBB2GrF5vrXs9JBgK/Z7BnCkwxwklJqc2NgQMte2Xm10f2elptmxAxJQGNnXGhR+n1K9jTbdft+NojsKTfEg+3E+L0BAKz/rUyLCzg5nq3PnMdH0MPZGeptUwB2NHK8x1935nw28f3X9LIzGvS/n9lBjoCgI9+xa88Ayv5M8rZBf40HItj7/Bz5veHv+6375JkN8zgGf+2ZTfC49v77M5nrSBv2LgPQGY0dx+PvO7Pt+c/OQZOP7/frcPz+CD45fg90MMix2bNjpLa/js84/n7G457NoX+PH/eRJo4/Dajln3kc/1nWoLN3Hvt9Jmt7mVCyakvgBpHYKgtXCeoIASEmkGWlMZkjGN8Q+y9qty/3c9nZ28gCX3oZYtNTLMOWL5Xp16rLGY+06efwAdiJx/l4du+uqb7l+ZefY7+ebe+rzbZrosLPX65XlJKxrgrKDDI3Nneo+3J6tRbkWbLLSFlkObeEV/b184AZZgHAW5k/kxNFFpX9VnhPpx5I78d2pKdazoFr/jMfUJvzAtaAE+aCygW//PyPeHv9hrytqLWg5ILr5QUxJKDGFoRC1MtaiVxFMl+HNTSdO5gfiZ/zro/2L9s+ADMf7aN9tI/20T6aNpHXnhkwaO8X2/nJzDi7v0MQ06EJPxTEyEBwziZ9DmtElVeU2nO6bNqslmZMFAGqGzMkm0xtzjDoLd2gJ4KaOIE1DasaIE2RsPF1x70Ku6XB30XgQxfcROkhEPVIDJ+JxsblFfmdIMtd8PcRNmfz0dZIp3wnMJp9sTkKbTwEKyvU1oQHcQbWDMn6IdFSDMsEwggkjj8OhG0TZacrAiLki/FIgB9ESY3o6iSGGOG9UiPOKNbrJbLFarhaRFKpls4TWmqGpcZ3W/zuiJAoUct2IWAYQbBbhBMkCkXTeKM5NRnb6qO/EoZhRLPRQugihoAhkaQsJTSgl6yvRWUq+MXWh7gJ+MOQgFJ1TAQwOYeXra8okS/Dpa0xhdT2lTkWjA6Zqxr84s5QDiZVwKDKoBnnTLnY0zUpnRsdEbg5mmu1dTIj2+4mUGUUiKPDsoXYPozxsX63RXyaCcPWSbwqAi4onBt9htCz/xAeDSXHdlScqtykLEZd0qKlNSdNm2vy+wYPvMx2Xp9HVdjUYMMysQo+k2dWSPQTuDuldzwpBHDhHa8SOuzrJXMbW6p8U7DlfZ5Xm3Jv/ETHppmW/Jr3keznjndzyhAndYFExEBrW0s/JLU7K29VA1ckEAJQ5U6u0KwyUEV/1ChvLXljzqPLBEbYl7SqMp8yv4RADJCtotB5CABhQ5tQoM+jzk9fzj2P3P/ijGf+WjvSbK49SIJkbWV/VnUAVXG8mfGqVimbBQahl5fhXR/6+/3Z68tP2eu9Mb4dG9xBS4UzchHQwDRMiCEipgEMwrZV/PzzN/z+p8/48dMnzLfv8PXLn8Dlz6jTHfX6Veq8g0D363tSQDeOHfp/PqP738sG3P5cdN6y+i8DDJhw+Y4QpdJBdzWwGZ86PzPHUp+bPodSeigiwFIpe0O0RIUjNAgkYiR3pgrtpaE2A1etZnQsDUxRawEbiKMWAKv0xe1j248NRFZW1CLnDlBBNaNqJLId15fLBbfbHYCs97osiAqqub+tWNeMGAmXywRQlT4wYRwnSBkmqSseYwIhCj+KpSUrqmDZZxRBQceuGQxCjKCYNGo+YKCs81oRiPFyGcGoyNui52JESkPLALGtC9b7hrKNWNMdtVas24pt3cAAhpQafViWqpQI4zAgpovSQNV53hDGipcf+9kaU8R6B5a3CmICzyMQIzIzECs+ff6ES2bc73fM89pKjBAx7vMbuFSQWC51TYqCoAoYArjpUbPQ/R9goJIudnVwS+Ob3GVgNrGW+tlr8lRzJmimElYLqWTYEjBuaJkVhCgkO2LANF5UXpOMFmZ4jjEipAiuFfM8N9rZZ3tQw6w7I+XcMnCxc8QI8e52uKfRzqk6J/AZbeDP0x23cMBO93iFPvb32DnG0udmOnWZtuwa43+eoUp2LQ9WUQ2lisG5yd5NX2CUmhFYyvr87ofvtQSYZpriiiFF1CopxyMRKAZJRV5ZsgMQkHMvhSMGbeOWOq/Uz/a8MYYxIQSR3yxLxqZlVGIMqABev33FdJnw/XffaymjisvlgloL1mUBc8U0XbBtK+Z50exEEEBGJeEfqov8+U9/BnPFy6dPGEJEzQXjOGBbNwGBM5C3DfN9wd/89R+Qc0EuBkaIGMehOXhrhcqhBlKPTQ+T0lEyjkAiM8eU8Pr2hhAiXl5emuPA5ldolmDAuO70MEe3XtNK0RSVPxghCBgRQUokWqasmCSFPUgyy1St00rB9FLbv6J3VOZWigAholRIeQKKKgMpkBfSz1qBLRdsW8G2VcQ0CsgdhOlybaV21m3FtmzYtoxhEDBhSgO2XLGtKy6XK5grtm1FVPnAy2LmOGcW6SOY/mmOHj3jLNuIl7s96M47kiyLgDhvetlN/07RQwu4QnW9Li/D/TtzPnoQX2HWc1F1mYB2ptois5aAEX1QItNzrVLkjJyTWneTgFAiKrGUI1Vai2HclYJovLjZC2LTTUrJ+PLlK2pdJeMaJLvTOFxwmV6krCJJOaamI5I4FuM4IGmpwmkakGIAaYaZUjbcb+I8G4eIaRwQiFAKY1uMf0uJqWg6pZaq6nPof+d2z9HRb2W4vJ5lIFFzevvSKPaMYwDR0YntnbJNbuWqrMy49YMWgWMz2a2Ppwd0iA3l7DkHXW6n1lRwYWwOzMxVynOkz58RopX6ZMkOxUDhjAqx9RiIeUhSDs1nH+7za0FOCU17pD7Hfqh56xk5wKI7xyRlrFu22hCRbJ2rZa6r+k7RH2qt4LjPxnBWSsuf6dZnm8+jg/gsk8gzsMzxsyMfMV3IZACj0aZytnW1a+VDr9f6dgSKGk16QMbR9nUEGp8Bj608IhsIPMUT+lZwXiDVFx4D2Y5OZttzz8Addu+pYx6dh/uMTn7Oz0ATR9DJcX2fgTmsH7b3vK5ozND0WhEJ5f1Zz0fjjwCr/OXlN7ENWuZMkyktq5zvZwhiu6kuM3A0sIbL8OPH4cfsx7grXY8Osj1zlluG23Y+qux+tjZne6DPb1u9w9zrZ92qZNOjvECziYb9PDZaVyWB+RyYeFzr1otGa9Sey9zLCh3vLVXkyZylBNMwREcLSsvsMlVpiR+Amp2sQuwuIBIwMnF7P4GUZoTvyRyHZtf1Mr3NxRk9e/qPoQcJ+jnw9xn9BLe+T7bdbl/tnnHQ6Y5z74FyRvPVaDkQIknpPSBLKb5IWOYV8/0G1rLYpmMwAynKOb2ukoG4lIp1yyJLpIQUzfbeeUXQNTBpIKUBLy9XXK8vTXY2OrOsPoRuHyQitaO4bGP2zK7M9bmunl/sywV3e4vQ77K8oWx3VJYStVte8eWXP2NdZsmYFhOGOKDkiq2IbWQYhpaRxsrDQmVpYluPvu8DifzdZA7qfT3Sz3GffLR/3vYBmPloH+2jfbSP9tG0EQeEGt0H8sOEqQfVhNqNzizsv/bRuRBhKNp3FSAp0wGyCB1TnnYP1070UgZdHrIUzaxGJ4B5Q6mbOC5DQAwDSknSFyKABSkffeQJmVDcnXJ2XVPeNbpfSpJEcEFTlJoB6qA4m4BuaHpvqDRjiNQfN4OkXpPrLmWlL09ynH8KhGVd23vAAPl6rqpYpkGcVeaUlt8JCAkBCd75wGCJLNDPsipWEs067QwpEpW92XKIgZ0SGAO4BgxpUmN6NwDN89yMejZHWYq+olQTiMXYIs640IxKIZAzoJlAL+sl96ApHSKEMzY1zo7jKE4YInGoEAMUJRuMznvJC1JK6tATMFYIEOc8FaEjZlRUQdjnrMZfST2fUgJvRdL7K+q/rgtKIRAmjOmKaQRSmrEsM3JewZCsHfPyFd0ZRGAWw5vU6hUHTM5iNBxiwDhKP7eNsSxZrcLUHPYAY13emvJnBtauzDtjxcE4EVNy+6yXW2NWAI0anrvSw/Dk2Q0i3YA7pCTcoEo2hjLPTdmRSCGN/iN9B8Q5kHOWCPB3jH32efsephtaJpjOS7zx2fiSV54JLOA+hqOrvaEC6sQtWtJDv23ZB5i5OWjOSrbJ72JgiMRg7oZBoQdzWDgep/wm2hZQIBnUuEPgZpRjoBkuZF/WlvCGCEihg5vszct6b4ZGUpqPQ8K6Zr0iKC8SR5QZ0cWYIM514l5q5Xa/CdhslMwy97cbci2IadA5Sbr3JepEtH0t3VSpAe9ikNntpRnUORITlu2GWnsJq21dW2YmuVcdlOZEgQJY1GmjTFSNLnIOVTvrmFALNyMYIMAuIkL1/JgZVCsSEZBZwBghIFJASgGFBVwhEajS/22TMUoqXVLAoANGEqQMhNtU3Sm9p3lPx5FGvEyj8uYVMTLCOCANI0II+LZtuMQJ0w9/hb/+3R/w9vUf8DP9R8y3/x2BGNf4PfK/+7fANuBZ86fQ45n//vWv/wn4P/5n20MrCOvu2r/9nyb87r+eAAxgjsg1gzGDsTX6trTDErFUlaYNXBjAiEAECrg5VMz4U2vFkMZuiLcDA90wJryMQElO/YCEhAEhQOUCBdHUioiAgSLWecH9dgPrWq/rjC0v2OoGooKcN/zy5c9Y11nGzoS3b6/49OmTZBrQzGPCo8fGh0W2IKQ0YhwnDMMF1+sVIQZs64qsqfrXZZFSRikqfxd6JZKSMqxylYFXQ6TGBysD43RV5xuJozJviEFq21tfSmGkNKBWoGRxGMeYMGkmhbItyMuMvLy18iIxDXi5jnqGJRSGOvMSci643e64vPyIECJykfMiDQkRwB//DvjrvxOn07q+4qeffoe//3eM//C/zcgz49//L3Ojv+//BvjX/+MF4/AJt9sdP//8Ba+v3yTTABW83b6Aa0YkQt02cC0tG4aUXCwtTXkz2EOdQLbNlUaClm0xmvEOyeYsoIDAkl1CmLPwDnlOABDBFOQfq4HdIj0rS7YKVicXArhEfP2yKK8Teo+BdW5WbOuKqmm8LV130axIwzionLA2o6eAGlYM6aqZiah9/iBr2lhh52mXR4+Opp3sqyC2ECQzRWVun+3vPTqDLLsOwFR3PEay0KEZgs3ZbO88OuIohBZ9uQeps5bngs5pxHWacL1ecblcGr1XBtZ5wTzn1m8A0GpALQuNyVhWJqQ5iPTsPxp3r8P+YNatAAAgAElEQVRFQAKblH4p64LLywXr/Q3fvn5BrQWfv/uMP/z4GdNlwmW64Hr5hGm6gCtwu7+hrivmZcGfv/yCeZ7BXJEGkcvWKmnvX7/dcLlc8fnzd/j9Tz9h2zZ8/vy5rXUKERsLoGMYBrxcXzCNEwoCEEXOM9lsHEZYVopSKyIBZdtQaQMCASFgqQKmXdfO1y0FP7NBTVjpoctSQgfdqW9OA7kPkLKwmg+mynkcY1K5XRxCxWhNafCiWa7WdVE9i51sH9pYmAOGJNntevlI1uwREaSZZwBCCkDNG7Z1wbaugJbumcYLXl4uIAp4fX3FMETNflKxbQIgmsZJ+WBArVsDuECdDqUWUAxNbmyAFnT+4x05xD3jp83XmSNyL0OcO6CO/+RaAV8hAIwMrgEURxh4yPbqMbsMEbQsATCOCeCMbevZMYj3JWZ8Xw38H2NRAVkYBLvo7K4fAVybQQEVQXRVEBAH0dOYkVuZXQV+qF7AQcAwqY6WtBAplKYPBEQEivj86TO2TeTby+WCy/WClCLM7hADAxDA021ZsCxCG99dfodcMpabzKPQM0NwLH2tTO8WuZuag1fOfls3WTMPnLASD5YZYttkH3z33XcozjlrwTur2gls7Ty/9LTh/278nOQsM+ChgJtC0xVI9SFbC9vT8vza6MLbGboxp5+xhsjYHz972vRAoZwz5nnGsiySwcnOTI3Ev1yuGKaEcRhwuSYFAwSVj6g5Ng14YushNEgaLKIdKwQrK8vWZ7KScBtKyepATghDAIIEiBhgQDJBWQawAGKZUUnWUFvZvWmaME1T28/LsrS1tc9zzj0ACPvz0ze/3vZ7PvAXoylvj3m4n9Hm1n9ni8Zu7rwMZTayZ2AFLzf4TDZH/mT99fzs6NTOZcM0TaKzcUEtVUvSCqBqSANAoguklARSW/cAMXuW7TGRo3rWvuN+8efVcYz++xCkjIo/d45Zg4wO907qPZDI/21z4Hmo8RBZMOhJa/pht8scs7dQIIzTuNt3IDhbktd3AQrAoDJ8LX38fhx1V+ZFbRcxaZLW/Vx1uUyazbkfX4pJAKXGL8+Mziw6nwFzSJ3/QsPne+SsuVmDAQ96ufD++cPZqmeOCssI2t8G+NkFku3X7mgjsnn07zK5WLL9oa1LCMnRSW3ZDksVHcDKUXJMLZuI8SUDZqAUlampn/HWF9RWQsjWRGQXs1Un+bxUMEVEiqglY9O9IcCd3EqAmo3Gy8kxxqe2br83bQ+1vVi7XuH33FEnAdz+NTs470ug2xwfM3kabQ9h0nUuIMqIJNkoByrgfEPNd0zjgFwJW66gqmtVtxZ8aDbtyhE1a+aWMWKKJEElzGKvqgV1U9mOCZ9fPuHTyydM4wiQ8CbWUuVMQexpgbHNM7a8ggi4xAlDHJDr1rP4BYhNjYRvUyVEHjUgmBGDnOmlSDlqBmPd7rjf37AsC5b1jre3b6h5E3CM6nqRCWOcILKTZIT25wFzxThOyFnkEaYgIHxmkclaZuaoAT4ESyAdFNDvS0f5vfPR/mXbB2Dmo320j/bRPtpH+w3tPaHk+XfP7zGHpERBhXZ9VxBcRgtAUxz2WIf+Tm6KuSkgQZHyrCWECMl8+rsunUXg+N93hm51JFvd0LPrj8YLE7K9kmwGC1McYow7JL716zi/Z++09/i0jaaMHA2pMnxqhkO42TwzlLk/ECJr1IZP99/7mmiAZFqRKZCIU3Eqg9SIAhI0es5giHFYwAbSk+akCgzUbnzrDitTgkx5N2Ot+Tw1ZqBNjyliHZhjQIoYAmKK6jDpWV5sHu3nuq76d2pOFzPeFk0DPgwJtZoSBKzbhgpGzl2YF6DQBcxSCkycqpIVYBxH1JqxLHekOMEi0UWxkVT3t9srqip1l+sFl+kq88uMbZ3F2BUMLCPlbWyZhmFoRhJvqJExC21MlwnDmMBcsa4rMhcB6FBoSmUz6JJE8Mm6iHLNtgcd/kQwZ93QYkYTVmOCzbenOd+/UiUCYZpEQa0UQC36nx9+dudA0HmAliFR44cj6aNCvvsd3YHeqNw59LiVCxIjOdqzJYuIGbqPRslnzeat2aKYH/p3VBBbTw9GFwA7o3jg0EtGkUX8WPRRBTQjUmZxQqUYQak7PaAOI9l7ogaT0kQpjKA0x0zCY6ElWNYFeVlwn2f8/g9/ADPj2+srti3j5eWKGAehbYjBcl3nnaFCUqsnZ/wQJ3HO3KKiQAKgiSlquZdeisDoKDIDasDzEWpQGm52POpLzjW3D62sXYwybyHIOC0LQOuzIer0M3GSbdjyJuVtokRfVe7RoCTWyJbGXZawl/KQLvIDjft/nu4btZI5rAqWZca6zhiGhJeXF7y8fGpZKPK2YRwS1oXx40//JdJf/VfI24zXP88Q89gJrTJphJmnwl9vxI9XPbsvl1+wLIxaR4RwxTBOkExUrI7pIk6iLWtZHUYKCXmdxZhKhFqAWiLSMAgwjATgKKUZKgID0egVFSUXBTgRYgAkxTBrELAcaoaXEuisyCPqmpeMNInw+fMF4viYcb9tmO93rOuMZb1jWWaAKmIUsFgMET/+8AelZ5sQxjwvLQo1ReHJDNlv87xiXSoQVxAkQt7ABTFaKZSMEMoOgGvlPsw4yMq/KxvfZaz3uUUJGjAil1cBc0UD4USUXHXfytwQBS2/UkBcEVJEtMh5AKVWbG933G5yTpECQwBxdm05I9eA7374EZfrFdM0IOc7WqnCILXgp2nC7T7jfvfUw+23GBNeLleUQshbxfVyxWUccZ9vYBSAKtblDs4bEKRU1TIvasgtAAHjYA4D0v+UD1OXRyQThwMzc3cg2loRCBwITEXmuFqGPFK+p05EBBBHmNO5cgFKFZBWAHpGFXs/a/nGoHIWYxjFKXh7+4b5Lo6gWuUcL1XKYBlA2WQ0Sa9esW0F4OjOdmrf298eNP4YOev2s5sPf375CE9/jwFBvSOo7BwsgKE2Dfh5jLgWY7+WXgv9+1prc1Swyo0+K4N3PJUse6hC+OL9fm/PtzPl5eWljWV/DhNqkCwY5hwKUdaUWcDfUbPDUVA5MEnWgrpk3JdVShsCCJHw5csXbOuKT58+YZpGcfheBSg3jZM66Qu+ffuK2/2GnAU48t133+HHH39EKQXzfBfwTGXc5gXXl88YhhG5VuEJoeLb61tzOH/5059RSsHnz58Rk6R5T8OI2+0NUHlK3gt1wiidV80SxwruUjDjMMTm4J0mkW+NP3gQVdVsFbYe9r3pRBbxbnKUP+vUF7U7c72zydb67e2tyQKWxt4cNyYXl1Ilm0kWY709L6aIMcYG8iKlq3Wd1QnVz+Xr9YpxHITWSlandtplGPVR81aWgJk1Iw032aBSl3G9XOfBFX7PHJ2UR4fqUbc7ypVnMsVxz3bdVrKFIjiHuO0l5R0752AIGrVsvAvCS3W85pwTXdj0P5G1ai1Kf/txnDnD2rgCN7lJvhRCCUzWffmwmrdV/za0DDEYUrKvViArKGfLC4gk+9tYI0qRclGVi46vg7lDAFIk3MuGr19/weVyUd1RMvQYcOi4ngDUAdn73x2mAtTwznWffcSXuRiGAfM8I6a0ixB/lun2jDYe9RV/HtTW12m6qC5QGmhdbDFoeollru1rpZaIg46zb17f3GcZsX6v26blTllKu0Hkegvskiwymv1O5yi5882AL2ZLsPfZGLxuCqDxI+/APmu9vxEcFUiTnWM6kAlPsHKg5tw23WfbNizL0vaSL2liazkMA3Lte/XoPDwCEOwazyOMdsz5vAvScvur84nzc//s3f7749p5fuPP/GNmkaMM4f/2Y7Bzd7q84PX1FbVKmbLr9fpo4wNJ4JT1J5Bu/0eQiskSZ6CUZ+P0+8z+GS29vr4+0L2ddXaPD67z83/k9f5d/vvgAHcmwx7nfg8c9n3vJVfOxurPBwNWl1IVMCMZ/Tx4yN9jra9d71cPDHgsT9+JB6LH2dnEe5vOe80/873zcP/FuX10vx9O9Fr3ue3do7y858lQe1o9fbbNi3+e2T3tkaazSPBit9GO44ikMp2su+qE4JbBO6VBdbV2QO7nbP/xTs7yNtM+x3IWDsOASj1g83i/lx2O6/BI03t7uJ9rQDPsuPPH9tHxWXJtbfMu9uI937NrPF0Ow+D2JUn54VxRa0ZMwDTKmfv2+qogaAlKTCEhxIQUR0QaH2Qmm0M7uw1EZPYlIQ0CYMBWVrvOAm4261EBqwBzxm25S+aZGDBOAyJFbMuGmAICy9mTYhR5UzPmc2XkbZasUQBqXdXeTAiBNWvxHa9vX/H29opSMsYhAYGkDHVlAUqx2gkJGuz1sGLy/0CganqAyT/KK8yuWVls+kHOTa77PXikmY/2L9s+ADMf7aN9tI/20T7ar7R/CcFEZHxVwqGCdfXKCTuFwJQ2u899T2KA6U5uUptYd3AfjQH+mUeB2hsVvNHEC+6t/A32ylRIAn7xRjBgb+y02qP+PlM6/Ht2Sv47xqWjEm39831oY4Sm2mwRJwYy2T+bDz9RtdSQRlmSzr8Z81AzEKCGwW5YiUSQ0ldiHG3OYvJOIBlvzitKyR1I0ZT//t5SbI2gCnQXso0wbCg2faxlviiSZhUyZV0AJykOzbjno6y8Am+KSimSJcIAFD1CT+iMyCIEuhHIFCQxmllqd7mHAqScBxOmUZzkRbOv1JoBFmARakXSd5Vtw9u6iWLDrI642IyoFkFp6ypzmQDuadtLy4ojRjtaK9a1okjaJMSQsCxvUtYkSHamWqmlI7c9Zw5CMfEaIMPRjS52IKG7SB1s0gFxZhyFGoETLF17razRvhmhuBS7J0bBPt/OCAoIaIbFIM5Ke6Rf+mwwrdds47FNYO/we9DorBv4mc3Q343hti/f45/M+/cffz/ykjNDmp8TYJ8+un1OkmWilbhozkc09hmo07Q4rgJebzMIkuWFLJpF11p8XiyZUjQCpCpIcc0rKDBut2/K5wVctuUNufWrZx+TzE0ACoE5w7KpMOvbQoBEoKDx/1KzROFoWbS2H81YaIarWg6GZckbwoiwI6QZ+JID4TFrlI2ABWUP7KMfzyIydw6KoKlyQ+dNcl/c7QFHWkJHSgdHg6Wng1MjILOWVrLyYIySC25vN8z3Oz59epEyHESYCZjGF6TpinGIGKaMEGbUf/OPWO4LYhKn/+vXG5b//N+CSzoFv/wl7b27CcD99ifg6wyiTxjH71HzFet6w7LekbcNAOHT508IQWpi55yxbpuAXii2MnxxiBjGsaXoNx4j9xGiOtnNQGXrzXrhkAbERk+aejxAM5OJ4SmvAraouWBb1xZZXmvFss4CTMqSaWEYJgGkuQwbIQxamkyNzIGQkkSs19Ijk+2cNWBW5UdHRQgBKSYgdnoQGqzgzEDLnKAZkup+3mOQTFcgAdlFImR8EgOsmOf0HFCwYwoKnjBDouwR4gKwnm9E+ix1mVbAMveRs/h++fozXu/fkFLC9Trhhx9+gJXWlKjGis+frqiF8d0fGf/Nv4VG6iX8/vd/wDRdUGlFLl9RcsWQkmQzIzQgKLhgDgHbOmOpd4RkexywMpqt7J0ZtJlh9dml7JaLJLbvtSybpbMmz4M0Yk5d/P37OCDEASkNSGkEkDSJm8w/EyEGKdcj6R32ZSPs/LE1JwKm6dKEHuPfiSJKic3Ravy+8/gBKY66hjbuvVOFPFiI0O4/Oh7O5E0PVOnCe79eZD96uF9kOjMWd9meK4NJZU4RDIEIXUhdk1J2a+IN/8yQ68FtrLVKea6tZGTgwQFARHh7exN5Qfeo6QEGmghAyzokgZsuE0PNKEXh3BNL6RbNzJZSRC4r5nnGtkl2qc+fP+l+EuDw22vGOmxYhhUxvqEya9YkavKSzVnOBesq77tMnzAMF4yXC0ACpFuWVQ3rQFEZcpguGAmI4wREydCR5xklWzk2hmBWGPf7rM5bAXpM06S808rJMJZlETlYASnzPO9kIaNhc7h5Z6R3Ulo7A5xwrQI3c/zv7Aw2wIp9Zq2VApJh7Qz2+gRJsz8MyNvWSs7a82pRvkRSGu96vQJgbNuiIKa4o3/vXGqZdqjrpfZOQpfZ7P5jJoCjvGFzdiYr+vueOXnP5NNHedWkfNlEXAuKptSX0gHK71WT9/eVIpnhAskZ0vdWQc+mWZtu18ZFoYHQjk5em5vjeoMranE8mV3feS9/aZUJAAQEKdVn2kuGgrKVpudZMnst6w33+Q0pBsnGIMQjpQmHASVnrNuKdRWA2OU6ShawwOC6IRcFmx544xn92tp12UT+9hmSgK7rj+PYgnlKKV0BPjz/twD4H9tezwghqEPSdHsAJPyP0eeemff2Bv1OwC3vy4I2fv9TO4BcLFObyrhELcACDTCgoG8WLSM0nl+b7GO6ltDPfq4eHdfiIGXugFK5Xm6MkUCUdufZTv+ClUDRrDO1ailHXwpqX3LLz7kEEXQQtNz/qP/5OTvjBR7Q4PmS319nWS3kAY80eka3vj2jtaP+suPvh/3tn/XMsV6zZH38/vvvm7xznEubEw9SsRJZx/UG0MG3IezedZzrox3C5rgDFcLDeM/se359/fPPxnv8197NpkKer7/xi2Ow0tla7el/D7xr99b9vB3n5vgOtv2GzgOPNszj2pPJjoyHuXn2vv7epmac3vvsPhw+PupbflxH2jqjeS8HeNCIHEHndH22p/VpotdC5ZKqsmyxcpZmC1EgzP/H3rs1SbIb6YGfA4iIzOruQ86QkpnMZDa2D/v//4xed82kB2llc8hz6a7MjAgArgd3BzyQUX3IIalZkyUOm1WVlwgELg6/fP45K8NjgXnamx1ha6LrP/1nG0BASvnW2oCao24y9rfWqmCIY9k/n7xn97a1WKuWdsKzPXEYM7fWqiYjnI25X69+fwf1A7MerKPO79elB+mbPiGfyeBaEOOMaZ7xy8+/4vFYEVRWMyUwSXJICAkR6Wn92E8PeDYdU/okPoAQBABKJKD1PQtjnzAwq/2m/dzzDgoBKUQkTXrcy950G+aKLRdYeXMKJMxnED8rWPxqed+x5w3rtmJdJfFn3zdU1eesDLE/xYlImWvEpu7vHdd2l/MA14qQJl1j1kfIXifWtYtuA360X1/tH9pegJlXe7VXe7VXe7X/7U2CWuI0McVc3znovR404z7mlKbQdHtB0FetWy3GvQV1zg35M6N1fN8+48uqjK0p25UPGfhjHWh/rY+M4vH+3qk5GtpjZpA3EEYHsQX+SJ1YZINpH+uR6zYn/S1SAzw0imIxRLsjjDhIGQb1yDNrMhWLs6k7p/qYWcBESg2pscAFoAIgYEqTGFwRGqzrwSJBhbhsBZhhrUZfRwFIIAPSd4IYWOZYMOPQG+k2fob49w72Wrl97yOH/6G8Tlsb4rQNLWAqY1EgXbaMX0IGYtAApVBeJnCbk551ayAooJAybeQCph0MQooJaUpIIen6sG0jgIlcusNwfdyRywopgZVwubyJIymIUUSIYriQuJPZ3OIkLAA6IWowCQiA1blBEOd0CAKMk4UTxOhSRzCYtRyGAK4EqNMZcQSkgRZY9uvbZ8od3zPnSwf2yLIhW9G9ne5BhjkU7Fp9H1adYwuEmvF+NLY/coT7dYHm1OtryMF1jmvoO8bi0RA9CWZa2JZ9n49ybpqn9rtkYgesj62XUCLNnHTBW8vWaZXSzLkPyfrbFQQnVMQRe5YAgJXIY3XQ9HJ8FTnXtp5kTCSz3pfeIFADldgiY8n1l/4EmcNScxvfELwM7WAmk0EAlMlMgQZcwWxZ4sL8AOqAOhuD7oQ5OldbBhZRc2IRhcYMYMwyzKwZOQa+6w6e750B4zxTWysW/DE5zyh7xqoOkbzMDTRItKCiYtu1BMbyhh/+r68oe0WKjFIe4P/5M7Y/Vaso829uvxUgAYD3b7+Ar3csMyFiwvv9Hev2jm27o1YWEAyKZvBLgPZ2u2vg2+SSZLmlSdl93P61LN6k65khTGK5FM1Ylo8vywUppkOg02iKZe1VPG533O+PFgDetg17zodAhoAieja4MSuACCUzSmYFkpr8TKq6SCDfrzXLLKxO5th7lgXnnZHiiGSAhYEJVcA5IQSkENr15FpRaczl9RgjOM7IChSV60n5oJSi04d8gCNI1TIW1gljZZNzF8KmoWwNIURQjKgMlLojP+54MON+jyhlFXBollrny7xogJNAl4ov/1no7VMM+OMfI5Yl4v2d8K//WlBKxTJP7dnnKWLbt3Z+BgVog4JmYCYXVHFrVcdlXVfJQHZxP6KAXLKUFbRSKoBkE+pBy1xReAOzMOqBDThDoJAQw4SYZkzTBSnNiGFGDBUckgrT4/wIIEcBy25HldKZ/XwgSJyu4ZBp2UtY9iB0ZSm/ZeddSsKE4AGLPYAG1BowiJ2ns9juZ/ui6Z4umKhPhVqP5+NBtspm7iK+BeV1PEhAtPJoVa/1HCQD0EBgYFbGHwCBEalTtNt5OAat9n1HDFHOMAesCDYoGhSYJikDs22b6GLGkmj6IQEPm59dzhRhRxOA6DTNrtQIK9ueZLNu294ALCAr/SQdNzm4PnbkXBGDgLGmsKCSnMWwcQ1B2CdUp10ul1a2UIbRgCallTG0zOT7/eZ03D7GEhTperQFQDydvdezvY3i6e59QMXWw6hjN12IwoHJxNtmPtBi1/UlgOyaBA/E8OUtCClZudHnoJgFuihI+TwiUiYJA+8KI5gxVPoAifV1tNuOjBz982dBljHL2z/3qGP6dqaLHvaIe20M6ljUQvQJGzspZwtUAdK22+l1qpX/EAYl0aW63uiDZmaf2HpCSM9zzvy0Fg7PWzsgxa5l+6XZaKqLAQaoA6SYl+pMJMyJ9l2Ru1JmUWxUYQaaHqnpcMZAakwvFli8Xq/KHmLPyxD2z+P57XU9P6/2r5TOjmW6hB8XD6KxNd+YkagDI/z6/a022lmy3x0o3cAyrEFOKzOhzEAIQeW1Cm8N/kHPUpborcrT4729/mKywDL8iwZiJSgn4NLczjzVs8kAl9z8AvLPwAzVrY++5rrd2H0TvdwYt5+A36+s7EhR1/IR8CGsQUlfY90TUsYGh/X77EuwefCgFhuffd81wPj9+bT3noAObg2OoDvfunx5TgQ7W0tntuf42XFfj58/k0nfu4e8JmA5668HCXt5OZ4xti/He42y0P89jmWzSZ3M9Neye3mQ2/g5//0uE8/n9ru+AO5sh/77Hjhgf4/z8dHz+/uO/QCR28PP83vqjyBuZ8PZs49je9a+t+aP3+96/Udr8/R66sP4qI3rwV776Mw929vWQdMpRz3jrF99bHuJaagvrQPfbL0TBCFOAKvfs3bZ5fsGmI/iuAbY9GV6npuP/BAlG7Cw2y/eT2Lr23wmvS98GKOP1oLXBT4CnY59HPemnAUMsDGkPYMUj2AZL7O0rHEISGnCPE/YtLSqMXAiRFCYID7q0HSjs+exe3gguUyZ2AcxVpQizI3btiMrw01KCcsFiLGKXh8ipijg3WmaEBFAVewUzqWtFWq+YzV6uILLLmVBSxZbYn2IP2NfsW0bas165krfc84gpoMvvGVqtmezf4BVETBZa+esncMV3U6yzzJkDABqjDTj/ni1/z3tBZh5tVd7tVd7tVf7G9tHxttHAJOmRB2MElKnhTeW7fNKodgUZvmemBquvIYG6uVzEqQRhgxzpHdl2BswXtkeHZJmeFswdDTAD0Yojo6S8Zo+gHAIfg5K/WiIjPfz4z4a894Y98/X2EcYFq+DOUH6ZFjGw3GeWB1T/b4+sJD070713+YCUGef/y7B6Jt9ZlOKwrxTakYtGUBBjUEcsQRV8oX6NQZxUIkjVJOzNQDfxlwX0JOzAxZyCqBg49UdLbYuzEFna6UFAbJkmIbonSfHLAobD5uDUgpYQR/Oq6yfC5qdRkqPTCAkpKRBS0gtaAtchhgxx6TrWTJdpVZ3BvMua5yC0FSHC2q1ABh0LQndPKg7Ctd1Vce3cIjUkqXeN4BadpS6g0jWTy0yrxXcykM0Yzv2oKsta1ajlEBSO7kq+Ics8GfOTxkDyY7Uvui1QlAglj2zcybZGFuJsyfHHFeLvOk9WR3XOK4VjGvf9p/tYbjm5AkpmCJIgNb200hvPQZBzIEa3HMdM1mO7WAoUjdUxwCUl18HRxQM5dYdSFXp8iVrOiOEC2ot2JQtI2epM2zZK0zhcN+DPFJHOBHJOohSamC5XAAiCSACmOZFnAjUjWKjdPb7zZig5HlYgVoGaos6IbXJHQHaFAVM2nz04EmIyiBRgVolE6bt09DnV66z6/MVLZVQJPgcIwL1bKRD6YFBNhvIIqUEqfgSEYOwM5WyI9Dx8xbMljGRdWdy9qPzdXRwMpszxDKuxSkSyMrkJezbhrzvSEn69vXrV4Q4a18jljnhdz/8HjH8HrVs2Nd3fPndjO2fAjijXVPWrJbWWxPqNp320eb4zL2RrgVppgZk2rYVe9mw78CUCNu24c9//hm1biBizPOEZUooeW/ldLZtx77vChbSwGhVGRKk7r3JOss8//LlC+Zp1gCxUBzXUpsckvWjZz2JU+xyuYACsK5bm+t1XfG4PcAEASemCcuSsK47uDAul6uyD8heW9dNxJ2eYVyK6jDU1ilCgGUykwLDQozgaucII6Qe/LKgwDzPB9liZ34IAbVAs+FkX5pT1Uot1VpRcm2BcVt7QNBrCBBNstxIA0R2XnY69RCkpr0wAxCYgoQhWQCquRRh9iEt1wgCxYRLjAhhRuWCvGf8+ccfFXwo5/CXzz8gb0XLy2lZTCTkUPE//vv/p5JbzgumquwySjvOBXm7Y1eGImJgSjOYe936I9U5NaAJEeHbt3cIyFbkACCMbtu+y15S0EyIAfM0SzlQMCoK9h3YcgXrvKkfFDVnVM7Ytw173DDPFyzTFUgCBENKDfxh2o2UL51UVnXnsiL0EMEAACAASURBVJTgs3lA0yO2bRNgUwqtrI0AnqoCoGS+874JAwpJUDLEC4gd0JS1fI7tYQoI+Xj+en3Wv25yyRzAo9wa9ecx67mxOckLEPe/yTaVRdUAMKx2gD8n0dStAOplmvRaBDRAkUkq++7I2jEGPpqz25UJmKIA9o1tisjkj/Rl3zds6yrz0QJ1EnC1MhHrumpplVkc4djlOdXmSSkgBE/dLiAEkWGMWcsZllIRAKx5UzBPQrpemw4NDaqjallN5hbcj5FQd8a6rai1Yp4mYTAiRkoR0yR7Y90eWs6uO8ZtLZiOZnLJ1pytq5Hpws5Trwed6XjydwDCMZPfZ3D7NSUyDer83w8sLyNYpusdIgdzKQZNBJGwcBGi6hwBZqvebnfUYkw7pqPmdj8D3vs17/XdFvzhqho4nsbG76XRBjzTD8bAzEfBJB9w8j/9+XLoCwT0EQMp6yDLORZjB0GYDuv6bfNupXDk3h2URaqXyrzIH1YWFjiCr8ZnOtjyWhqJwBKYZbTSPeCKSqEBYqqCFwKpHk5HeWS/xyRsXTYeYsfvbR3kvLv1JiXMQiBs29o+b+vWgGZ+bvx8+fvPs+hlOQsQ1AAzB98BOpjE1nAIUuYhUuzyE0fb42w9jLbTuAbJjY8Aw8R+D1HLLCqIzc46gFsJL1ZdsRYpd5lLQQpBcDaDduifw3Rsvx4rLIGk92dKEwzIDxJQLoKW8wvmi5Dz22z25repFVae2O4hMsL2osiJaYrN/uxBVsY0Ler7AAwA2kBxISATVOYHFBTVAf2ePPpqxjXRGRj63sk5N8Nl3Lvj7z6wbLJylK0+YejsesCzr8k+Y9cb/VYftY/klf/+mcwa167vS4iy575+/XoodzfqIt1nY0wnx2f2fr6xRORo9/nx8s8/+ghHgI35kwwc69f4OBe+b+PfXn/qr4kN23Q2PR89s4zIrHzo49l8jM80yt4QwoGhxwBu41p76nflFhy3187Ar+PZRngeCxvPsfX5HJP0nmXueM597zwd96T10YMe/Bj53/18NX1F97BnF/F+Zv+dg75sKjVJkpqwvRn7i5T+yzkL6ypsnXegxEFv/w4wiOHZ2kXn9HMwJn/K9QWsb6Ldy3O/z7zuTUQA4yCbxrGze/Sy8s+6zbjXRxnX55m0rH09lNi2cTkDy/T1XBGIEVPANBvzi/mRI0rh5iuqkCQTA4f69TImuvo9SgQULgLE1jLK67ZpGWUAIWDhC94+EaZZbIxAAddlke8D4KJszqyM4lX8Zcb0vO+brLmSUfMG5op933C73fBYHwiwBEZoqWs522UMgzL6WkKSncfHuZB57faBsc3398V2rTY2/cvtOhVAcEv07Fz4ePW+2t+jvQAzr/Zqr/Zqr/Zqf2M7M2J++z1TdL1Sw92hpJk8h3+WdQvzxZkTrmcPMrM6n6khyGNqealyF3U4jIqxN7xMMffKmDlKfFakGaBWRqjU3hdTxM1pahTmdg3pL6RUAx3BOD4DxDtKvFLvywf5/nale2C3UYVUDC6CJ94hhJ4BbP+poRMpaYagMmG4IArQndJJyyBInzUbXxV5K5VhxpuxOlgQY6OMUndETjDDrpSCfd8OTsaUEjAlpEnqxHKFOO4oojZlXUK0FnC3ZzZwStTgOaEibw8Jxjhj2aitrU3T1NdY1aBX5YMz3DJ6+jwcMyFjFKPWYCK+brMY3wRZQhYMZVCs2PKKrA6hZY5ghma3F8RImIJku+eckWKEpzovZce3b2szxIkI1+tVso+nDlZapiRBviIG2rZtWPeMbcvKNCLG4OVywdvbG4gkozar47MysMxXXC5X5H3DcrkqUIZAWiYlUkBFp6KWObCsYtbyPlXn000ji6EZkwBS7FlsTT8eUvqklILr9dqZHNQAnecZhYtmKqjcATQDvDtMepDGQBQa0A0EASCgrUNmC56WlsXZ+4WDoT06ns15YA6iNM1gluCLlzMfgw274+jZof3sWPOOAytxBgCRBLgmmdbAPC/YtlX3c8D1ehFHCkWd/wquuVG+SuCdQQFaqot07RHSNCMmKQUS0wxmoAYBfSVKIIpO6hPSHBAE0iNBUSZlYRAGEJED9+ZgyWVXpqXS9l+nQu8OF5GnNj/OkRcJpd6xb+p0CXSQvUSEmIBSCPtjB1ARgj6HY7kZnaL2t5e9eS9gRFQA+y7jvT428CyZQXaOMJdGNR+DOCIkY/bZcXRcr84JAykP0B2NbQOpM0LBGbVif2Ts9MCnT0BKQIoLYhBQw59+kvMplx1zivgP//E/44//KWBOrIGPDQgbfv36M95vX/Hz//Mf8P5f/5OtxNP1ysPfAPDP//c3/PFfEq5vF6zbHf/1v/2/oJAAXHB7ZNT6DV9vXxXMRQiPB37+9WtzIImsEHDglCakmBCZkaqVCehAlND2dgAoIVfZs4/HA7fbTb4/RS2fUIAiDiY7NwEJSl/f3gDVH1JKmC8L9j0jhIRlvsj60rJ7y7JgmpbD2ZyVeaLyLrqJApUYXa6E2M/0WisCWelCtDKEl8sFt9ut1T/3gRAACr6U/m/7A6VkTNOEL1++aGCckSsDhRHDhEoZFITLjFlWSkQAOLTSVAKoCO3aRB4sppnfDAHYQvLLO919wHy9SpBHAZMAYZovuM4JpewK3Ix4u1wbi1oIAXmv2NdHW/NrWLGtK2JM+PTpE1KMSFPClx++oBZCKRt++eVX/PrrL9j3DSES5jngsnyR8oUkjn0pmZXbOXC9Xg97uijwBwD2krHnTcuzEJbrFXHK/XsUwFSxPiQjL6LivmpWfixynkMAB2xnBQBiQl431K1gnhdMywLhlKtSuikkCdJLLaFB5luAOcra0BJAy7IghIBtW9sz1lrw6e0NaRKnurCaAJfr5SBLcs7NQW6ycQqxjUcpGbmWgyyy4M+YKdyCKk5v9Q5o+5w1W7+NYSBQYz8ptSLvu5zjbgy87i97jw5AbCvZUUtBzRkxJS1j1YM3FoDwmbfj2erHvsv7nhWaAUxTxLdv3/B4PBqArJS9lwvR8bgsE37+6SfM86yAkiCZowoesHKUMQrV+r7uoAAkBGRmlLJqHwOkfKHsv5hEvxUQbAZxREJFBHAJhOunN1SVeetjQ8276PkUW+Dgsa7IZccPv/uCtzeRMbf7OyoXXC6zMiq50lUoyIUbYKuz0oS2nkzPtYxjC0CbDuRB0LI2y+GMs7G394mEuc7bX/adAwBF52bSjFsP3rGAS2XGer8hhITL5aJApQgG4du3b4eSiilFUJE9PM9SyvWXn/6kMtpkoYzj/b62PSGAJbEhtm07AD+8zG62klt/Hgh01g4BxZNAgg98jn+3ew7jbD/9OAKmTRBCqGAEGOhQAO1BafoJQUvzVu4gvQ5C7rLF5MmyLHg8HgDUhgRhz5vYpPEcMGzX8axBIHMb9MBLO7/N9mqATgX/QADbuRYFH9Rmp5qPwnQp6YYAM43BzLoWQl+jxgDi94EAQHcwk4Kuzte3D6gB0Ov0kjymA3v7cZxfG5PigAxntsG4dkxWn7FPCENqaWAjsycYAMWIOEUsl0WuBdGTswKbUwqgkLBtGx6PXYKANSPGWWwJt7Z9n8xH8/7+jlIKoupbMaWuRJq9peBms9P2vCPUitp8JFXLPheQ+zIzmg0hjHgyryFELMss4EE97ygQkr5ftBQswMglA0XWETMaKBnQUpQ6J7D133xabt8HUjYxA7fGw79WDs6BLzxI1L4znls+ucR8UmOg+uxs/igIefAnoQNMxs+Pa85/x9bYKIP836Mc8tcY++xlYwgBb29vB7l1LPtSsW1b1w9CPPgMDMRiPrSu95TTMbF++kS1EWzrn9nsBm8jGsuhB0zYnPs97vfnmdzv8odbcN765mXKYQ0NYz7u+1Eu2WvW/8ydSc/G3+4xJjb5awU6luexs/Ls2T5ai/4z45npy+x0YfHbze7UZMTwVe8rtrk0+WFJW37uvS7q/bPtXI/hoPMYyAvofqBRvktHrTSw8i6q7DMAf85Wqk/OYJTSwNhp6vJp21ZJ5IHZn+Y/UfC6YymzfTSuI3/GEAnzby1V2YQrFgNx6HN5sIjtN0DOjNE2GMfRv+eBonveDvLA92dckzJGwnZm1/bz5O8xAnimKYF5x7ZnUCHMc8JPP/8kNl9MSJPEHogSQFFYWBTQdPT7933tgWYpiR667StKyXJOhiilnUnK+caUwADmZZJEjTkJa2Rl1LJi36SEcFWWZAGaa4JTybpWd9wfwiJT9h1Vfbw2J5dJAPw5S4nbAFkTot+TlppS0Fg1/7exoipAhju7b0tcCB3E2/dY6OvGyotVYTUKoTM9vtq/X3sBZl7t1V7t1V7t1f7GNjpj/OsfvQe0OBSeg2wjWEZeszIZo3PPHJJAdzARJAPOMrRMcfbKtDeqzaAeDXWvqJtR5GnuzTEGANM8aTC5Zx+MmXHWXx+kqK5++2jMHj7nnKej8WyKt89AO451B3UosbxmN6A5XWpRpyFEpw0kwBJTYjvIqSu74hAq7j7Q8QuSXdu+Q+ojIn2dJWtevzNPF2FE4YxSdtSaxQBJkwb4CiioM2xfkcuqNPkTKEzgIIFQog6NquYs1ecnsMuWEKpwcaB1B5WfV29wHTJgSDyz3rlwHO9jllDPTNjaGJlDliE1iC27ojmiIEGiCg3wMmPfxdlbWBwCQcu9iAE6aVkcMZbQ+mSU+bKG7/c7QpDsZ30bl2UR0BaAQBPe3mbEmCBsI6tmGu9gLrjdf9ZgH4G0Pu+UJixzwpSiMidkMIvBxCgIzPIcFQqiMfputD5Cjf4QuI1RdxBWZS/RfTZNPagWI67X68HxdHDuQOvch3DwfaT4HIBs8wlumbBgAcxY/8zJFpRl1dbSmYPpuPeOgYtm/JOVM3DgPfR1ddZYB+h53X3cRFYA1ZhMQoBVDQZJYDLvu3OuEdKUkOvexoRIjHQZJ5EJcvuqxm5BKTv2bdfyWQHbWlRGAEBCraEFoeS6pCRAEnwjGO0/Q8p/VJUHBev6ACurTAyhMSgYCIu5l7eRsQkoxZ699D0cgzA4TVqmSQPNuYhs6gApAV+GEDClhECdJcyvF3My+GBGC/6ygKJCVLBPzs2hLo5+yXIiZgjdP8CRteb1M1OQd1759WbzKOtU1w7pAsOR+r3LZMbt/Sc8Hj+DogQ1Ylpw/fx7ECRouGbG//zTryAwPr+9YZ4SUpywTDPeLjPm6XfYrxfc20qzeT22My3g8w9/QFoI7/cNX98z1hwAyqjbqsEIYLoEgC8a7JJ1KEOpATDN0CsKzjD2BOLOgiXfpZYdlQsBRdkE4oJPXxZlqbCSgFHOvVL0TFQdA4RcxdkbZwEl7KUixhklA9++3ZWBYUJQEKSB0iToUkFBs6xVRtfiZIeuzT5X3LAltv+YcQi6dnCEnS1GFS3rbV1XxDTh7fNnzPOCUiq2fYeB1ggk2V2IYGVWoKYf+eCtlBKLzG3ca83IedO50mCvZ0ggUtAtI0RqGWkHpxoArgEBM+bUM7iDXr8WYEoRl7criGT/bPuG9683UAC29SF6zxTx/v4L7vebMr6QzsWMUgvu9zvyXiSgCwH8+aAmIGejd7QCkJI/2s8YIuYYkbeCXDIoabAeERQnzMuE6+ffw06afdsQAlDLhk3rwOd9w/32FVx21cEkwMwFqLlipw3Ecr5K6Di07GnRs2zcuo7hadZNhzEZZXJJdARy8ssczjhcS6ats27kXGCltaLKzUCzzkVpwYmU0kEujucS4Vg2pzZ5PQQB3bmWQkWJsTlMTc83PdzuLWMYmxPey18ByKiTdpxb109ZQ4tjDsChrx7obqVXuHZmgkCEX3/+BesmQK55ngXADLSAcK0VNRfUXBScBwkqSHUOnacOIq5FbJmUBOhhoL8YeylEA4E3PQkFUceJCJjjhHVd8evPf8KP//o/9Nzo5UZA6DKIgEgig96/fRNZGxM+f/6kOnFucsnA83JvDcpVA6X3IO8YNBuzjccsd68/GaOMZx6S5yztPB1tLB8cNICMfc5n8Vp2fKm5rStvYwGkoHzTV0SPfLtetG/GImRAHgWJ1ILHo7/ugUM+YOLXYFBlkmt5kj9Nlv4bWu9bD/yO1yTShIK2/48B0rEvzGigHjPPbf2X0kufAmK/EEdND+6Z/maghSigzFqLloKTN0uVhIBMnTXL98vbvB7k3NdltwFJbTUXnrEDVfSByso6Y2/qXAygCu6qsujOpvdDs61DUJlpOijpevCB89AYBQKFg14HdBvU7wljyzB55v0NPjjo5w6Qc6tkXzqiBxfbkzrfgpe7fs/0clCxBeHlGgLgtWz4nDfUu5RtiKrDFC6oyHhsXQeqnBEiS6nKIAFFvyeIeilk6+uXL19a3zMz+mwymIDCotNYgpQxXBoDohgfFb2sEmAaqiw5AxZV5KKsMQRs+wrKG7pOjQYGEnZRGyt/lnELVts1m64eRPcwndCUZFWVWiDZAx1KEd3Fz29P0JK15Offr43nvcvNTvafs/caMG7Y+80mPZENI5Bv7Iu/vv20OT5rPkDt7+XXrP0bQTc2H95PZnvGr+vLRUDCokMI+Mk+7/0Hoy/B70s/tv7Z5GefO9t39l1fnrUzpnWmyPEefj7GfzZe49yPPgQDXvgS42cyfvzd/z3ORWfFefaZjuvP26xtft2yGQEYfh26hQXxl/22v+Oja5ytzfF30YOoq9kfXN/7YO26tqZPrzm07v+hNj++LKVPeBj3kp0lwrfYdeMOutIShwpmDqx+iyLyOcRjclDv5/E+bdwJh3vY+2dAW0D9xiE09mTz19l37d455wamGfXCcQ3auI/7Uf4RQNNhzs/AL/4ZPmrjerFrmH69bQWMLKDpKWLfd3z79iuIoKzcajuVCi4VTAExMODK4/bkmXwoCWx64u12k+QM3WNFweiWtMrK9rrvKx73m8iRIIDlwFlL7PZ5EjCPrOltW3G7vTe5tCRCoYTtMGbim5W5iiCKqKW2ZLF5mgA9DxkmI7rm55aMa3peV8CSobk5N3oShOmAgZp3EpUVsPPhrL3aP7q9ADOv9mqv9mqv9mrW1FAQnZGbEnP4iPvNnAjVFEuy96l91dwb8j8XCNJ7GLOCKKouI4B79pboVUG/J/8kM8lbNYJQ5hKacSWMCgHT1IPj3gj0WSc+U807c80wtM+eIez96FjGaggS6LAui3ORdGx0JKiDU/oYHA1yb5CcgXp+y5nqFf5meADiWBQ/khgh6vjr1xNnlDnpu3PHez0h5W5IZrlWc07q540NCKEpwuoZsgfuV1KnNLFU3ZUyFKKkh0IohVA5Y9uk1mqaIlIMoCABzVIYAjqQMhMULOgtzyCGkvSrsua/V/HllipZZ5ECSDPILLAHMPZsJTKMLSfYKKI2J+mR7vPIogEZI7eejaGn7JZNrNlxVdegOuBhBmQzOBMCpCyE7RcKEXMk1JrBWsfdsthIDWTbchIAtnI44uBbt4IcbP4BZEYIVddoxHJ5Q0wSsMtlR94zSskALDuDwLxhe+wIMemeWxCCAZgs+xQwpyXIQBbOUY+g5Xk6OCXGSY3k2mh8bRzNWRN0PuRZO0CLq5SsYi3JZNl+bX/SR14RJ6dsH2pAWCSaABysxnCtSjv0UQ3ok31tr+V9a2tByMaDmZJtfv2+Y13UluHO9pqNYRCQiY2ZfJxhROayGwGw0efLq7lkbHlvNYMZAcilU8CSLJvu1KODzIwxarmtiBgZlqC05wwwKwuNZIeDjs4MkYOMVhLOzgxzclAEk4BaKrMEIENECAkpEB7qEA1EABeXQdidL8LuJOuhlIp9hwa5NPCmwb7KPfOo/9NzjqzWMlQ+mGONGiW9ZS+xrg+mhDRFAAGl7JopxIhJGKVK1ZIuIaqjQWRYDAlFBZbJajtnyc95VMpfBmqwz8ukdflDypjU+8/qGElxlmBHzggBCCUgl1+xXN4QgmaiRbn+Y92Rc8W8TEjLJ2C6IKSC3/0LYfmBdOwEfhF0bErOKLXg119/wbo+QCHgcrni7e0z3v75M4CKdb0Ly8t0ASCAyb0KECNa9jrrc+gZ0v5u8rjrHm3Nc4NfwQ4wcWZ3QSzUwiTsV02uFDCHBrQTZx4Q4yQ9CF0mUCCAjTlBrlmKAA12BbGYExNkzGoRMU4oKJCSkhawljICbHNnWet6MMpZBiwKWvN7qIM9O9ChlgJwREpawiizBtGCrvF+LseUGjDBmIhgmfAq90rJqMoqYGw4tQKBOjCW9Pn1ONdyDepgJUJqAeguG0vJIl9DZ7kjgoLdKigEPNaHgEVrB4IwKvacse4b6MG434NSWMs+6OxfIiunNCGGhFpEDpjiZfvqWZ8zNSZIuR0d4HlJmNgyI2Xil2nWDMOEeV5wmS+iuxCQ9xXbetOSPA/EkHB7/6YlorT0UBBq6n3NQBFGkah+cWJZ+YyoMlIGN0ZG5QwpHVfAqMIa5OQDQkAAtaxSKhmNRYhCWy92RgYNgJrcI2KUYgBjkfulFpVxvYzXSJMOWHBWA1EsgaknB/twHtp53udB9RKdy6pu1DT14A9DsvyLKztm8q/Wis2CNBAGLWaRChakyKWANtJykoR93wQQRQK6iiGi1E12hKhdsob0YJRrxXbv/vsxMzznjKzgbwFsGPNEdzpLeRebuoApCTiJweKwruR0TRmfnC34BmEwIgm011rx0DIouWQJKitTQyApmbitK6xULbd7JtU17fo2twxf0o25aJBGA+jRMkqrMrpJHw1MYjpzaKU8ofaS22/uj9F2OQRAqpRLCrpWDYBobI0hBCzzDIC1ZOneEieIQqt0ZiU/AwjUbAUJ4FAtiEmZAKBAEaCxFdWckfMuDv9oGfKsAJCEGJKWcCSUnBt7E0FAwpmlPAtH2xPHckxngba/to066FkQr9migy15ZlvaOScAU5XPOyPvnslE5rkUYSUU+7B2W9jZiMRWLsLWdQdelZzBweZezm0Beh370y7m9OXn5vShds77oHA8/xazAhj7aIn+peejfAj7XptMIYrqv+hnWddNqNkdTfaqg8DWbim97I/9TrQLCC/Jmu5+iqCAAM9CqyYeHctljHPqA8t9PLvfo/k+QgTrfzYQMSZMxsjHBVyDgK4BWKnXonsU1tcQEJPYc2KDEFhtDDGhlClSQc523gjYWZIsAlU9ENV202fOyvIXQ1K7oDOFsJbQSJNcV56b1X4EjGrXEjiYGdvOiKV0YCE6wAHoDhFJyNJAfykoldtZaquOuQoOq6pPpQE47XvVAae7DWk2L0OA/BQcsGnwDdnPEaAwthgTDBQGtTR1VHQ41b/W1oMDy7h15NeQXztnv4+vfQRC8f6T8Xvmo5LkArFhSs19rKk/vwfTLsvSwIoerNKAsaw2bUxo5SpVN4zqRzGwuulFRX1eULuSIfKd7Rm1TGNUEKAB9Q28JqX3HPudK59EZPvHz8fzOHpf5hjk95afD/pbO+pXbh7Z36+tAACuT4DuR/uiB7w8Jw/J6102tfnW8rh29hjYzcsYXZX20P35D/32P9n93e099vKCjldoVdz8xcB6BuFpfHt3ns9o76Pt/Tuyz47ft7NB9jqaPDP75WDHN8AfobNOkturdiboM8CYnAP2XRhE7DGrlmE1eWh+9/683UZmtQNCMKBT1XUrQIZni0n8omI7xvbPZFYMEctsYFArJ2vJS8f5s3EaGdOBzm5lzCY57600lTHRm9zy8lZA3WjPDApgANmdxUSW+iFzw0WTadQOvl5mzNOEr19/xfvt1kD7wqidFByjoEagMcoyWHCOIDf2aP0KavOnOCFrKaWAKPKGSRIruIK4Yk6L+pTW5mMIxOAqSaC2Lva8t7Gzse62GmD+2qaTcIUQ7vU1YElvpD7yUrPofrq3NJIBSy7k5ktg7YiUsmIdw2Bzy8KyZOAZMv8Nujzo6/H5TPFr5C99/dX++vYCzLzaq73aq73aq/mmDi/mj9QTHJxrYmg7A0T/n9krLM4Yghkn9rmjcdebMSB4w02cUqQ1x+WdokqeGTlqNMnHxak/yXE/ZqSMBr4ZNx7pbm3Mvjm7Rm1GoCiNBAv8q6JJkmHUnpWNhrIbO3Yvf+1DkN8ZXt4A9ePnjWT72R0TMibNW2TPQ0p/T26cmBtgg3Hy3G2ONagMUb4PBrs6AewnbFYJzfsqK86yRxTVbk5rLt03ViTb2YyW+0PLalEEkwBlwGKoBASgRhDEmDKDRkkbEKCOUCIUZnF+M0ChSoZaCs25Udhl/8mybba1zLmsz9oCMZotafMBiMOYjiwjbVkTt0C9+gchoAwDEnCjfLfvEAkzUQUjmJOUIUYVd0BPNxj1VtQDOeI4qhAmGNJREccfl6JjRgKIKbKGQ1ykrE4RiumeWWvOP1YjOCsDUNKM1NACSWZESqBFAm9W+13kjux9M4Th1ocZl8fWDWgfcKUYpOwO24Jz32BhoPDeqA7XIBjiwxwaYjtaSTIBBqCyZJFUMfooHO/xxHZz4jCU+xvQgVogUuTfeQCgfVOfi3WNsF+Yw2f1qdw/7uPClsVCAkTR/V25A5ek/53VyqSvyYJaqmYYq8MCxhQhd7ZayDaYdnqYeD86ogfnGAUQBCATWDNIg4BQWL3tpP0L6uCtpQLoAbJKJpFt7I4AQcWc6PeO1MvGfCSBagKF2Fgfqjq0mISpozDLKUWEgqoZpZox34IQFUBGqcaUwCBa3HwYoLA2mciwvsBR1IY2ryafC0qX3VbkyhwR+ozsHaYhIKakgDxG3oXpppabMkdMiESYk2QV5ZJRNwAPKW8SU8L1j8DbH2UPEwkARM5nRikCVJx+IawrAyiYpx0//I6R4oZ13bHtN9SyyhquBNSIiEWDI4RO+S2yTbouz0bKamJD0gJHLRDbTyMbJ3EG9fNVdIe+V5mpgSgCRQQtEyFAGpUTLBn0SVlRgq4zYUAz2uVx/wOVfYcH7QAAIABJREFUSNaS0htb2RUCqVw2MIrfuX1LCPNTVAYWHxSR/SPgRQCoEkCKSeIjzCh7bkECZgYpSNKCxNZnO7oEZBbQ9yW7cbBnOoKZWPeWHTox+LKRVfYxNbEjwTLOTWuSfsEFFeVMWrdHY/uZ5xnTPMlr1VgCWedMdJi8dwAFqRNVShxFgDOyAgdaoAYQII+tBXT9KkYJ9lV25fI0KAqIPIhGT21MMUGyOQsgDD/TD6gl43G/yXUp4n67oWQBVYlaI/Kg1B0xAREVAUX0FDbOmc7OZbhd5gqqAAebe24OS2M/AEn/KwVQTFIeAqq/1O7Ul71kwRiJJVZz6mp2oK1ryVruJXEswNnBNl2eMlfZ23C6ruqfI8tj7wu1c9X2qmf6M8BiCEFKZCigJKWj3u7PUF8iCESYU9LsTAFmhkDYsYPQS2gyKlCLQE5JS9hNi8hpjgc9BejnuwFGzEltIJKDNOJjpu6RbUGd4/aNpj9UHd/nwOiRYQ24vd8k41jB1y1oqHoeQugOfJ2XECNi6dez/tscSdCxs2kIIM2xXjrdlpp+69hNtByrfLbbVjZ2R9aQ/px+7RSJbostEQIiGahFddEqOlpztqvcFlBUaDpMUJAzK6uTyV4B4EiWcJoTrARPLRlg2ZOk55zp96WwAsmFut8CWlUBlDZOXg8U8IzTQU90xL/V8e/H1wfVx9d+q/lzzJ+VOR/tU2NVMaCp10Ld1cwFALNTANI4tNmhxqxi9weA2L/fDP2z65/3/8zf8NHzfwQG6L4NZ8ux2ihstjAdusWH6/rr973agCYlK+CtM9wSGVjdzxvQbBL3j4KB+KQ/fa6Omff1oPN0EI5n3jXb34BQbOMVAEZBLarf09FWYK4IJFn441jKmaM+CEQEqm0/enCGjJuVmIHaJgxQbusFEN0dTFiWi4CDSex+sxWZJZA4GTCGxZo0JiBm77EQ4GIPZDbpq5+lNvcyXr2ciQB6GIhoYyisOkXHTu1xnU+z36soH2prugA9RcQAAQClI2OhPN+zfDgDQPnxDxTUR6DPpDaH6IGqHzsmnp50YGfZM6OJ3z9nAI7x834fjj8/AsxQ00OEkZe0FFA/Te05+xlBRE9sKnZeNjnYyvFSA2jbueV1+C6EbK5lTGytstvH5vNre5VZbV7to9qUcLp+B6vbvoUox85GPo6ffPpMdo1y7tzvcHzPRlHkmNw3mO+FP5aVfucYC4d97mxuvezRF0XnPnSLTn774G/ya6h/qslY/RCTGwc8N356VXX7k8/6Zzp7fdwD4/k7nu2eqeYwVjAwip9LXYrszpp2dvS119eofb/rQVwZFd3H7OfM5Br8nVkNAfea2GriG+33odbHWi3hDqoDqD6vZRYB1eWb/i82Mdqe6WPqZcsoz9qZZv+Zn93p4wbMYF0XkrzlElNIAaGVpXy76tdJ9zZxAZBBXLTc1A5mAZXfH4+WNECarBlCaj40QORWZfMJ9HHqc279DJo4yeojAICqSZyqFzEBlRA4gBhYbzfseYWVZpWExb5Wmm9PXwtEoJgUoKkMeTomfv+YfYG2luXcsuQHGbliksJPVvc0kvn0Bbwln69COOgppto6U3na1iE3XwuZ8+qkvYAx//j2Asy82qu92qu92qtpGx2z4++nr5nBeGIkf2RUOFfH0+eOBlk4fEfSbUv7DqtyK+hqNRigCqMqdcwVdd+fdC0zprvjP7XXjNoS6DSbI3X8c1+7YWTG+plRNBqSZox6R+Zo4I7jaM5+1n5aZrYFtMnm5WDEUMvqkIuIMUZBITzirWmGf60dThCdQdeudWKQt+eEOgypB3f0A/Jey/gAurO0fQuAOfGhYBAN+pFkDZVa8P7tK273G2IMmNOEGDUQECO4RqHZJnGeARHMFdOk2QggcYZXcYhVzSQSZ9SOhNkp/gKAsbIGNuY9KK1Gagxg6oGM7nhQ89JYRIb5TCkBpBlK7OpMa1aDOUYOY81yPcu7Y80QNwNHPynj6RwKtrZ8tkYIFZ3aVddd7BT9YMni37YVAEuALEYQEgKMpUjKn1n0QGhF3/X5phakWeYFMUyQoLdlV9eWRVlrxaKZ+T4ga8aajISNKdp4or3DQIGbA6s/38sxkWbsG/vK83UIgDCYdL8BN2edAZgIxhYRQMSSNegYX9oeGvbMKE+lpIEb+4MT3a0fP/8AQL0mNOl6QSU0QnqTJfIld63heZuxHpHSMVAFyNrXS4AZh8yUoMFwKVmxYd8ly11iS50NQoAAejMubq2R+907vY7yzrZaDJ3eWuSZgBaE4QItIHZZorBC1U4bbSwTMQlgDARQtACBnCWlKPPU4DwQh2pUxjCRCy3woLKgMhCDMM1I1i2r7Jw0e662a1Uukl1l5bHUuW9rXfaEOb3c+aAOr8oWnEI756SrChyoLohiACID4SC0DF4AKJWR0oKgc5tzxhQT9m3DxhKwyfuGt7c3LMsifVsfeOwZ1+sV18tFyymQAjSi7F89P0KScfnDdAU4o5Yd+75hnmbcbu+43x/YtgdqzVgfj1aeUAKzMxCEdUHWscgNZh5KGnSQSHfpDeembRvZLWiZUHr+1ioZ0YCW67BjUnWDlBLWdW3rH7CMSrQxb1T76DqAgQhSio2FY1231imTx6HVitcgFmpjqyPywAGGZPhBHEpkskavSAkg2XPzvICIGlDLnIpnzlmfGQobQwVHSPkBATdSCC6ALt/bNysdM7XzvwEd9ZohBC1rkwH0evHU5qq2QGsHhmrAorLK2tQC9rVWPB4PF1D0ZS7F+TqhlyQqpaDkog5RCfKLzmA0/AJaYWbUQXcz57VpBI2dj1U3ULARCrdyIrfbXbP8gbe3K96uC1Aj9vuCVH+P60VAONu6Imcpw6SaCmrZkNcVYNFHSslIqWppHgi7GTG4bqBQ9fwBwKHpvlZ6Muj6yqUgW2mCIJ/rzvsue5rz3pUWEZAy2niEoMwrsYOhSmVMKfUSaGAwR+SS+1rxq0uFuuna/loWgA7pCC6wfUrU2c2maQIFQgrm0utlR/xZYc10H9t31+tVvyUMBlyLgoQ7EDjnFfeyIitrS5oi3t6uiGECQWjYhbVsb8/j7YWnQAj1wKuBDKyPviQHAJSyu+cIupf689iYGNjI2K2myYAxAXvZQFVlqjINbduGXAqWZQGrnDcbaN93QXqhnz1WYkmXV3tOPz+eZdHP5VhawEoEnNkTo340BvEbDT8JqLGUAqq1lery93s8Hh18RUFALGQBCTsQZO+XWkEBOICDgrBcRiIsU8Ked+x7boBzEFSuQ0oIsfTRxtHW9zguf0mA8yPb+a9tZ9f+KPDkP3PWPrL7/Bo/031/q3+2fmOMDXQurx3vZ+Pu7fMzcNVH9/leHz76+8zmtzPKM2RGVyKsqdbD2HZmJjnXena8jYOyKNZjEs00zU0/MD2cuZel863JdOrloMb3xmccwQy2r5tsP5SW6QFVsQklAEecRMU1sA4lhBgxpSRHpRtHCTpWTVoBDITALGDm3g/b892eqcTNNrNkGApS/nm5LLJnm3xSJrmq51FTkjojYK3cmAXR9DUde0L7nJyNXTbb+EhJDbGj7ZwTsyCrPs2oWdmwWkKUgOeM7SxSEDYS9HKusqZiK6Nj/4gEpCpndGm6v+0LL2vOyh7Je23mn36KrO+/930FDeI+y6azJC5/Vj/fn55+WjOQqW9mzwcEYYKsooua3mzPL2c/t/J6pRQ8Hg8sy6LX7kAwO/fsux6oas9jOsah/4MNPZZbt3myM+voS+3JcAaCszKHZOc+Q1ncSO0Rr6eNspWcXOgsPGey7sxPOcpM7i6t4xyw2U1qsZ+cHSYT/LyO9z6u42d5/W8998b+jO+JL3L0KvzGNUGNmfp758PYxvPWXvMsM34d+ut70PHx++PvOlHcE5cEhGU+Hu0DQRjwoCza1EGEfh2ePn9bT/o3Qxmy1D7jrsND957tUxlzXWdMEGXS/DxR15C8xu2hxJY1MDY3AJD00c46zxLlx5eI2r5/XtdHHdz758WaNoZa8aeWqvY3ANJSfiHI6yVvIB1XZkl4WS4LtnWDJVf1ce4+xhADOpjdps/WBDf7S9aHlYQXf7Kw85EytUpSWIwR+7bhdvuGUjZIHqKA8Gwu+uQF9VcaG2hGSwpksd32vMFs6BijJFHp+LUYg46tlICS7howSztqN1TmJn1esIJa1b82rLmWdCYLudk5jclXXR6v9u/XXoCZV3u1V3u1V3s1bV7Z9K+dfc7/7FS1x+s0YIG2VlLIPgN+ql/9sTGmSnwVWnWAEZtj2xg1JGBalFQCpE7PcG6I+ZqiVufYjF0zXHzZEVPe53lu3/NsMMs8tYA5oJmvjVq5NKegH5exZrk5A73hdOZYZzA4iPKaiGDFjxg9i8yC/G1OojHc9PkBKUUwZFxDCKAUEbgDfBrGxinNI3vGwSCJGnzgcMjs8Ia9b09OE3MgMkMorANimoFGu1lx/RSwXD+BAKRIuH37ivv7DQBhni+YpgmF17YmUpxQ69ocK6xGUUwJy0Vo9BnAY93UCWEqvFK0F8a+SZDbBsQ7k8CMwj173z9XAxFxHydzwu177qAOgjpgQgsId2PPj3enLu6G2bOjyc+XN3aa47LWZuQVZYYxJ6BffxMBl+WzBhPUkAGj7hvynlFrdmMie2bbdnV+y7qsVejrGVJei9no6y0TrwdmLDtExg6a3V/as4/ja+W30BxKfe6ktILuHaD5Blu2V9t3pQsNZcmQ7AvNlyBzShZ5jSzwLjLAshx52K9+D49yBJCAmHdg+ffOnEvyuzECWTBXMijNILbnOja9lv51WCtuX5ZSlBVAMlX3fUeM5jhS5iANNJtT2OZN+lvUyaCB1ma0A41vFwpGgl+zfk+dnznmNPFl8sT4Nvp1+3DEPM9dzrACmpgVjCVsBNvt0cbQOjmu/Xle2jmxZ6Fcn+f5UILE0zCbzG8B3QRhkdC1HBGRN3G6xDhpADeAkCDMUBYUYTemx+xfOydsXAysEaLcw96XclpFQJFJaYqbLLBMLAn22XPM84x939v4MQt18p/+9Kc2/pdlxj//8+9x39+xvyfMywXL5YLlctUzRpkslFUq1wImYfQKIWKaJnz9+hU//vgjHo8VpVRs29bAddaEuQVKTW3rX0rASdmDo/PPr3NzwRCR+nMc8OHABGUyUUsqxIR5ntq6trVg4IzL5XIIFocQMC8ztnXF7XZrwb+UEi6XS6OE3/f94NTLOeP3//QDSsmqH2y431bc7/cWJBLnVRKHv85X4Ypt5+Y4NFYUKwPCvCPnHbWIfiRlSGLb4yaXfN34fd8lSA4BmFgfjT7Z5Pe2PRAyqbNQz5AiJVtSmtTB5Uoh6Nx4/dBeN73HQFoxyrpowXwrYaJORdsLdj0rV+FlpelYAA4A6Jzz4XMmk/Z9PziMrU8GErS+llLd+aPnDjoYqu23WrVUxYzrPCHNUqLpcb/hxx//BMoJP/6XP6BsEdMfGOkP75gvASFH5G1HhdS0n8MF3779hHzfUMqEeVZmneUTjIGolIx1fxe2kyRlFmpxmbU2PwCyMlmZjtvY8ixA7cCX67oeziw/lrIXKnLZ9NwVFg0GI+cHSvHy28bKQCoJZ2VPUkqYpsnpIoRlWbp+6p5llIP2vt+LMUQgpibHTSYbcMrr2B5YkXcZn8fjjk+fPmFZ5mZXmIO7yaXCuN8eAHakNAtwhkiDp/UJLGJr2cttk7XexrDvez3Z1qi/po2P7V0D8o12FLMwAC7L0jJX7XPzPGNZliazLpcL9n1vfS2laAmY1OwjIsLj8TjYALZnzabxNpX1xwc4vLyWn/HwvH7dWfPza5/zASfby0UBQCajH48Htm3DNE24XK4gIgU1lWbDddksc23PIx0B0hSw5xWP9b3p2OuqmfQssm/bNtWLAlKaME0Rt9sDBJFpHcx0BBj5+fpHtPEeH9lf9tkWRDp5H+glzNZ1BdDlQs65zXuXmX3+P2rWHwM72X4+04Ht9bPrjmP6b2mjHTve9+CD4B4o9wk142eNBclekzN7OgBd/Hr2IFv7Z+eXgRY9iMUHEf1zi86jtuHQp3GMxmf0csjGeZqmdob6daRfFJ1Ky0XoDYWlihIiTVpeOLQAdIgRKSZwKZIoovfqOrWcq9u2Yd9yk71VBXGKkwLfRc+KyZjOVOZyRSk7QAWcK6qWZDK7snYVAETobATtuQw4EhBDZ/W18ZYxBFhZHrz+TyQBz5QSlgUq/0WfkXNybwleZvPCyXrThRqAjOhwXo3rw5JLxveAIxtbD9a30KT76W0uC3z3f/ZcH+1lW0O2N+08N/voEKDm7huT/vR1Zn4OORP69aWEqrK4krGT9fPA7lUr8Pb21s4v21Nvb29Y17XpuH4+W4A4CNDfZIw/hw9+NycbvA/M++f85z3gzr7jdVl/vSY3WkKWzc1z8/15+vkbx8kIyrD1TL/xxbGf/vXxWUeZ479vffh7nnvfO0eZHPMlLDD//bOJWTx9cHM0Ps9ZG89BAA1w2G2E2EBcI1DLn8/+Gke5TYiBD/mI/lnsYznX5psToJ3YCQZq9/bt+OztfkSN7L0ak2EwVhfAs4qZk5MhpX9rKSCqqvdT62tbL1wRGkuO2ZEEQpdXprNas8QPe+9MHxjn69l/5p8VqFxQuY97jMJQFq18fKnYVrHN97zj85cfwCzg9M+fv2CaEn7OP6NW0SNTnJDSAqAzLjIVYXB3/SvlyKxo/gqJaQg7dy1ZfbMCKCKIj62UDaUWXK8XULiAuWDf18YG2iek7zUrFW73sSTjGCPmtBx0gFFuma+5GohvSIA4jKmbYyvrREDzVQSbC51H871zu39nVjI5SPz3kxWv9te3F2Dm1V7t1V7t1V5NGzmFbsz4PDOKADSHqDcmfDagV8K8UzcN2SHewLTXrNUqGdWSUG/lS1gVyR5cEkM7IJcNOQslcJpYues7nTiAlg3qHUAHQ7dU5JIPzgbvALcxmufZBf1roy08c0z6MfAG9ujsNmeudwz73zvbBoBA2ErPCG1OE/V2tLEd9E3rA5wxWapkZPmxD2o4BjrOpfXfB9vaOFKQkgCtNBAO4zw6T/zfJOksOjfiINMZByBBmoAq/CZsWaUF03xBjJaNBWz7rjnDENp5FBDUo6c+Iw6kZSnE8Cq1G6C1Ch27lIzoAQJh0qWeMafrP8aISYExtZTm3APUceoBGpAxkgBjbDWs21xDHVvU148F52y8esCA7Skhgc1jMKgHP58dFbJWxJi1Uh5nztXRcIKWPiOKmKaIQBf9TkUuYjSaYWUU+Gb4GG25BDd7YMsclesqWcHGhhQC4XK5IMTUAt/BORLtsxbo7AZ0OOwl/9lp6kFdOAOy+wwFTGUzxoxe0xoyBBa0LCU3im24cfOgOBtPn3nX5Wgd9gXUaUgH+ekN2ZILagZiis3nKZ81oJHIr1ILgjlKnLNC7i3gBS+r1m11fa+Y5qSBtp4RZU7tMXvRrtk6pICznLMyokRMU1KjO7c5SmkWsEc4yvsxIOLPGXs/pdQAgOYIsDm1Mj2yR5WBgwUMxcqaFOPc7svc17dko3dgg23KUivYCVIfLPFOawumTAoAIaoKNpPAuwEh5nlS0EAB4J2/Mo7T1ME7/vqHtVA6kKxUYR9oAfHmcw1C66vr2GQLEYE0qOOBA/bsft+Yk49ZSnn88tOfEW3tECGkCdfrJ3z69IbL2ydc3z5hXi4y9rm0Uhnr44bH/Y7H44H393fse0YIUdlr+rkkIEPGvq9SbqUK5f00XcTBUnv2Vh8bqBNRAZ04nrOydY0m2AMKE2rsQV8LGtv82phv29bOaQvWTNOEWjrbha2LGCP2fcftdmt7ats2hBBwuSxYLrMGn03GmHP/2nUklY0S+OUGhpKgS9exrtc3/PDDD9i2Fff7A8wyh6VojXjujk0fvPVBFnPgHoIxdm4RQFXYmYhYPyvPtHPWILNkSFvfrW9+/I9O3647elY/D3B5e3trQcN1XbtuEwPSlBBz18u8fPAOaAANKCLzKDpJy2Rs+x6QMlb2GVtHXab457DzymSOzVdKk1674n6/Yf+6gwi4XBbM4Q1/poAK4HK54tMP/4Scd2zbA3va8HjcRZdihpWikjETx/cvv/yEEGfEOGOaJry9XVGrMDYREqa0IIbUgEhQ+bc+VmEWoSC6ieo2RR3c/qwZHejm7G/nBjqbR61F2J+IsCxz+77NYT+jTTl1+qkL6nnZBuBUR/bnwrj/TP+MUWTctu0HnUcAvNvTuczMCnaoLRjw5cvnzkhUcrMtDDhp8lX2SlRGhB6As3Xj9a23t7eDLA0h4P39HY/Ho33eg058IG2e53Y/b4N5YIsPwoUg5/08T42RY9tXWSNufu0a27YdgJkm/20v2rlv9z8GX7st1IMA5dB/++cBTACwbdKfeVr0TO5z4tejByf6cfjIfvNsGKUUXC4XYVjKGUDGslwwz5/a2Mnc2tqNej+xaT5//tzAgZZ4YKCxWovaSsYCYUFeQs7KlFiPwUz//OPfo/3s2xgQ+mua/663Jc+DR78dRLS59Pp3L9P1zCbkgU3+nv55bd37fvl14NeWfdevFy+vxt/H637Uzux1//mjDXQEunxk2wbqQSVbuwY4s0C9PyvPfC7ShyPIzMbY65/Pz3e0+c/G4Mw/4efMXvO+HHv21hdNXqoFCFnAO9M8i+1NyoDBjJpzL59Wq9TpqN1GtmZMsTJGaj+G0HwKDAKFSeWQXj8QSBnwGFJKjagiJhkDIQ5Uv4Tqr1nZW4Mx1IVw6IqAKEIvS6NZ/3Lqq1+D7XcLQMOxAPbEmKilIGuVIDLYgN9o17ExNnnvx3jUZ5rtSF2u+D032vpHOSNBzw6e72CYrotKotK4n31yl93nTGbYeWxrZfx93LteftdqtsjRPxQas2DR8nZHNsdpmpGSAPFtb5ge/ng8GhDY5JQB4O0sGdv4nKPs9PtgHAO/ZwyYXnJpbHtmG5iNYQAju2/bf3qeeIDA92TUoU9u/EZ7+qypmPlQ5vkz2a45ylqvO350v+/Jn39U02Xd3Glm/9F3bl/VLqh0kqD1nbE0vdfruX5OxwRJvye8/ujX1ahPCWBGbDMbQvlpn5MzIpddfSsRU1L22lJBoLY3/J448+3Dxg5oPCwBEJleKkj9+NyeR8vhFvNzhJ4sGlI/71GxzAsqZxhTa60FMV5g5eZGMJ31Sc4EajqcH6ee9BAOY2fP4s9XezgiYRMS1llZKDEAkQjgjG0reKwbHo8VDMbjvoIImJeeXCLsYztKrgBnpHRxcxVQHcBEzgdh8vLgWWb7uwBUQagq2ybsWwEFRiABI90fd0xTQs7igw7B7B8FnHBb+W2d2HML+NaYxOSRz/Sm5z2uH8ZRNsh50u1r04Pbc3UauaYTSUlG1aOQQSEqY5+y7ZDqL24vnbVRLzvu0RfI5u/VXoCZV3u1V3u1V3s1baOC5I1E+zkai/b6aDR6x5F3crNoblLahjsFud3D/vYOKfsOwqgA2ftm7FewOgPmeUKKQgucncExOl99/70zGBA2AG/c2E+PePet1ApSA8Q+exb0HsfP7nFmjI3OkDY3zC177Ix6l5xxa9eWCIq7zomD5fh57VPta8L3c/zecawsc+D8O/4e/Vmlj+achrF9wDvWJN2BSEwQAdhEpBmwkgmlFKzbA3XfBYxSMrZ9BbGWTVFKyzBNYI7C8sIAIYLiJPSUISKQ1Q0/0mcD3MoaAGdZUs/Gh7ynzySWAlow0kxRB2polJZsQTl00INEQNWecA4ISFCVKB32su+TOZ2P89kvziAYVqfW41yZwWSPFxBAMCOnO9qIEubpCobbx6VAHJrioROwzAQrqUbqXN13KVcSIonBSgxQxbrd1NhLLjP7CI4xg60Fb5txJwCE5/XVx7yPYZ8DQBwD0L2mi0TXdW3/zIHKOjZ+7/Q5OPqGx7kZHU3y+WPgpDsUGRSBKSVUNgd6QSkSrGdI9lFsJRwU7MEK9yBzyAkwqBbW7DrJ4pNSKLIfKxfkfWvgAwokjqY23wJkkMXIbX+UomwwtZe9C+qULko7L2vG0lKfx8W/5oP73iEFM+K9w88Z9t2BiAbCInVMe3ll4EupY11BkEzXnIuWgtL60sCTk8YHGA6GPQGVc1t/DAFZ2XhInTktL1HRnMEGnrC95tfHCLo6gjNl3lOahFlNlywAATDC0SyrcCb1mHtnqA/kHNek9UGyiQ0MxSBgy3jcV/z880+Y5hmfP3/B5y8/YLlesSwLfv36Fffbr9i3hwQscn6a06TjC8Yh8AqgZcX1tRCf+tUd/3L2SP9lXDwQAuifMWcSEZojyZyIx2cOLZBs/TKmIa49IOzBH8Z6YNfpzlJSZpatHQPWh2ma295nRnMgUfPuluZgNMAhEeF2uyvThLE+JNSqc0jHsWnLc9BLfGBAPmeAV26OSoaVHQwCSpsNpKqBKz1fxyCiv8fB+anAhyP4S5oHIvu9yswHliAfXLLxNwYN0ydbxjEJC4mUwbMghaylnhHNba0wi9yoYJA6ZJv8oQbJbX3z6yOXDVIKMgHMyGXFl3/ZQYiY3iriNIFDwCUlIKyoFBHThpoL5vmBXFaUkrHtuwCF40WyD4lQS8G+MVjXQwwaoHT/rATFlJLMHTEKa+asjVmXVk86aQ9i9SCt7SNZnyZTRH6JXmYsWQbwNd3i6Lz2QFm7Zytlg2OQZ9TB/Xd81rjJ+V6m6xi0GO2RxiIVlaWpyPx3BiVurDlpSrBSCVwZ275jSlGzRPveGeXzsZRRP9sul8sTMAjo9Od+rZt+ZM/jZZKXRd6OKEX2qQBr9pY9P56vtv/8urVgo42xvefLHtk1PDCu1tqAMP5s9PM8yhgb53FevazwCRl+XNM0iW52kK1Hfby/LmtTygfKWSvAXbTvWD/k+pLpu65rmxNZM66/CnxN4t7aAAAgAElEQVTn4Bg+WGxbkU9Hu2m0k8f17GXf36uNNtbf4x5+Ti0oPK5xu/cYeB77dLan7fXxXDqzj8d25of4re98r3303dHWG/vu5Uz/XAd1jgAU29cjoM/rM3YdDxD0wXZ/fwBNzxv31Vk73us5QO+f71k2EyiInREiQwDiGftWpISF6m4xRqSQXHa619vUZwFjY9XA3uzOoxBBIYJbSUfVCwkAiR0D3dd73nSPK2Oms1l6KU29j50d7hnN3geogcw784HsbaKuO4DUHm973vrXgd3ysQgp36XpOyb/yGz3jxNWbC21n0DzCZztHX8WHeeRYbZ4uz3186F9FrY2f3v92Jg965DP3/Hr3r8mY97npj0Pul5lNtF4ttda8O3bepD5dt9t29yc9oQv73v8yO486+fZc43JDOMzV+fnMFnpgYfWjuDBzhs9jt33m9k2z/Lw79nOzqzv3esfdcb9Je1wGnP/8VF3RUbVp7UIfPwcZ2etza1fH88AmOd1deZTPMpn8Z2QCgF/a/OH5ZwBNjCfAAAtucOuY2vS9+dpDpmbTA7GTgOVL7UebAgbln6+kQK3Q/N1xoSmw+17BRT8k3O3Mcbx9Dpx5YqIo113TLzD6Zl4ti+bPc4EQ1aFwFqOj4BqMs1YeA00nzBrkqYA9CUJiqvNGbWyUkzC8tnlaJ/DnuRhCbdWRjeh5E0ZdQKkVGMEUxVmnqj+ucptDiRRUdYDGswOrrxVUJtAyyuDBIyKozzz6+/53HCN6HAmUrOHPYiw9q811xyry877rt3iaa8861T91vS0Xp/l77+PrPk/sb0AM6/2aq/2aq/2atpGw3xUULzB/pHhODp1vbOrKb3QYPAHxog3LNo9gK4/cQ8AWaDTAkpcA+b5KlTpSq0Iqi54fm58eqes78dH4+QNn97njmq3ZoY58AxWOFP2gHNqU/+5yhoghgVu6Gj5nRj/EjgLTgX1CvAxMNGvbUptPSizZ46OgyNYgSst62oYSz9mx/FWxViBJGxKuCq/3clG+izmiWJQjA0wg5iRQKghgmsBqmQLc8koLPV8c90ROaM2o5gEJKOBoAAgJCkPFNgCqGJEVwz7REEjgp5np+vrvHAPUrN4exrYqT0SoJSV8jxgbqVxnix9CGPHaO2TOvHYzYnfhx8ZjYA6aQkg1hq35khrWXYdFCLXU4psDHtAgwiUhHmJzTnJHVQVYlKa7oisRqGBBKQucMCUJItEMp0lC7/Uihgi9v2h42rAm3Bc/lVoUCtbqbX6tA79vuqyzY+z7o9GKcroIBFAgq0dNMPKptSD8t5h2J3CjbHAtXNZK3cdQYvyPgNRnNOoYsxXDWwj9P1CBuIBKdtEz96DzSaLLBaZot8LVa+bUWqGhlgh5acUMMF6GwU0yd/F9Z11TuU5hMVJ1xVJ2bagIJQzwMkYOPwoG7vUbC/qljPHR3sZJsWYGKjGotEBEQJKqE3eiSNG9l6tQglOpEEwV97Pzjaf4f/Uv7I3Bilz5sp7hJIrqptno2g3J/y4Z8fsYxuvPk4GjggAhXZNkzmk2boEPUPQnShnAZGzDC/7TkgLahWwiMm3WgvKLvTFeVux3m+Y5wXX6wW32zv2fZXACnkQonNAEgMus9Uy0UBKm082xgKYGYNxPctJ+zgAbH15Qpv3/l0LtIuc9+wN9h0r12HACgteBQJiOJYNAvDEqmDXkbEVkJY9W2OmQxSK6KpnMgXEMCM4MFogCbhIaQMDe1QQIpZ5kWzbmMCNsedZlznTO45jxSBKusllv/QyTlrWjyJSEi8YS+3FA1jGX8vvFb+ebE+MTmJbh+YUHQHOVkZsbB/ppe364HYmEdDrpLd7Qs89bgEjCgGkfTe5NLUSVJbRJ/c6Bo772NdaUbDh+kcRgJUr9iqymUICxYo0ASHM4JBBxFjXb1i3G0rOyLHgOiekOEFY6SBgvhgRY0CkCG616I/jOxvQAQCNlPFOnoxABpsLn/kqo9YdpA1s24ZasxwV1Mss4y0B1SN7jc29vW4BpDNdxdsfvo+llFb2xvZVYwVwctPuYaWFfMkLOYsApNDYmwywZmNg5c9YQWh5F0e2dIdhuviZneTXdhuleJTxfr16W8kzqfSAXx+PEMIhW7jvs4JSlL1SQW7WJ3+u+n74/eb7dWaP+Dn0za7p5Z7N6ziHfc31MfbjcGaP+kxtU/rMxrJ9ZuvVmJGsT3J9xr5vsFJ4dn0phZKaHhljwroqMwGqBkqEoYlCQIrG7sEtKCUr4eioH5/le+N29vpf0j6Sd2fX+63rn9nHo27g3/dr5+z6Z3bIeJ/vPcNHNsuzDfO3tY/8At8br7PxOZNXZ2ft2XOd6/pHwIwHhY5z0fogF0FLmB+e5y8Zu7N5PPuMnQkUWFkPJJEBVRlrXYLSbOUeDdiH3j8pERgQKMJK9dq5IvcWoBsFiB1Rzd6E2jnC4CFlYnds2111+Hrcn6yMtWrzQ89ps0tMjgNQgL3NB0nZyadxGf1Gff+brA5siQ6EeV4auNBYzLhWBNVBR6C4nwuvixMRvkuRoW08Q2XI2d483c9uhhsI2mz7v2bt+LU2gl6t+XXV/X3eN9V/LVUAAqJTpQPoXsCaGdfr9QkIYzqAP4NGUKrvmz/3xj1+9nn/uwe3+s95ncOPtZ234/WbHYPjejvrx2/Nxd9LVv6l9/z/e+uriw/L7OlzJ7L/t87PM7vHtw48P98P/nv+c+P1zcc63P2wrqZpdkAdAXS0MnDuPmd+6Q+brU+oHQ8IMN/LDrUrapObx4Q2mQHx81WOgMppAd5m9RsfWXi8HjEyy9gYnenUH9kTfixBhOZNJvFVmQ8WgCalSVnveZoxzxcsy4x5XpBzxb5ncFVfSiSEoGBze1ZSMKkDzEBBi53NsgKkSWtBxoxrQM4y15UrKmeAoYzNAYzSylUzq1xXO3yUG/Jo3X5o46BfwclaPdMd/TgS+viXUjt7DIvvD34v4OCWa+eJLRcp104KNO/zYmuA61HHHG3UjxhoXu3v016AmVd7tVd7tVd7tdZMyTy+1g3pZ2eWNSLqFMSsgaAg1PRWO7Mbb3wIlo6GpzdSm6IMV+5D1a8QCKWYYSvBJXGOm4NJwsgUgBh6oMCcqnYfczqPGc79Tscm2U6hBeaDOm7GDEdvqI9ORf+c/vUDkr52Wlf/Pfn9WFfZlHu4oC/rPMhNJGghACIbn+Yjat9tJnqbS2ggzNRbamMibBOElmKguq4YC/+LvbfrkhvHsQAvSEqRaVdVd+/M2X+y//+n7L7tw5yd7i7bmRESCewDABJiKOyy29PTMydYx+V0Rkii+AECFxfAIPPM7/Q1ME6d+O7QcgUc3RBwsEcJDPo87QIBollnhAryQlgvF5BlHZLWIFzV+bRvqPuObbsh1arOL0oQVAgqSrmgEIFbQspkUanUiTG+hrkz90cUFtGILOjDl4zK4yAdBO50gr1amDz9BrNleqHDfpQOgI7rR/PST06EwMEJ4fXLD/sNgEi1a93xLfYOCQnZSBjpYGgR1JA0S7GXghBWos8w55VEkrKnz06g7KQLBxfdQaWZA1KyqG8QWr0ZiGggcau43bzEz2ryQbO8kEW8tDbKJd1uN3S5YXtDyTppOHfTkXRGlADLUkMGBndoVr3QOp6i0R7CtTu8fXqlAwYTECkS3psMHKC7qfTsKTrO0q/z50K0BI86gRmJfExrcN2YbKIGZouap6TZgyBIHPaURbiwOQohRo4iwrKos7DWitv7ewf+tKSTyxKdoy4rTMbE9bdtNwDAul6wWMR+TsUiAF0eau+dbBDPGXWEETxTEHPDbqVHfP8lr9HdswmZ8e7zn0bqWAfNiIy8gZCthWy/Uhvngq3LLg+E+7379In0/apRSXp2pZSQU7EofY3yaXZu+T5xxy4RmbOB+2djD48STEcn03Dc171av9lqWuu8l0Wzpuke50EwCu0s+i2n3OX6kO0JGVqyrxPeaNEoNiMpbm9veP/8O/7aGnIpWC6rZhMxJ3uiZNnfPDNFs7PLAMGkhFjvpxMCXd6OdRB0iC7bBL18iqjzxoG9njGDVT9YimWPyLk7RnWtjXF3ooTrGMJazqXWhpITyGSv6xKwc4AtaxF3uRH3eAFECVKlqJO51YZWAYED7OVQGib1zAXxHE4oJWFZR0keEaBKMwDOZdPxGuc6uKzhvq40IjClxWQykDMhJUHjhn27obbW37eTKiewuEshnVDdq/DzUMckIWnJrTgwBLunEiCqpvkY8isBYunAw/ZAyhblZ7/cQ7kYX7NejoFIs5wQvOwS94NY50zHSckIpJHidcf1esOyWHY0oEcU+pj3/hCjlBVCCkY3I3IIaRa1nvEDdtYTAXnRPZVesCw61wzBtr2hVSOfsvQsPsgJudjZxYJmJXYAKylRCorPu4hFE9qJ2xpa7/DQF1UndxBdOklKwWiLHmxGlvFXJU07LlAdnKXaXgOELSW7OYzGXrbTNWk5Bd0Pnv3DZYoTN0a5glzKMANIy6CVZUHJKtdQW89q1moDE3fH575vuF1vAAHrqoB3sTIPOWkk7LIuEFjpVB57QWX2cGz576P4VGIl2d5x26YviB6lSpSwbduBkDcIYUOuuZOtE71g6c+TZhjycrSasUCJIN0BSlAQ2wiSrjdHW8f752TvUZIo6GMq+O19RiatTng0OeTPVfLSKGUnMmeuTMgZ3SbUTDhH0lqUH8DIKuP39DO67nt/H7ctoo1RSukEKT9XvRRGvJ/fv5RjFoJPnz6p/MwZRBVAtujmoecpCThmvvM5vLdt5/eM9t9wkp475B45sc6+f+oUevDdR8+abdRow0aSQCRBAk7mmp91tGEePTM6ufzese9/xGF71InGfb93bL/HMXp/HzqMge8BIurrvl8TMBWVj8f58kxqY07GfX0dezlFfxZcf8LxTP6j7xSzIZwRDObvE4nZ2Ttak26raRnKHaqLGbk3DXK4Zh6A7dXFyuqUrouLKBG5LAtAi52lTgJE0KcY7Nkb7eyodevOYT2rCMwqC7wSFKWMYud214vIdUr9EvW5TD2T71hTR/XZ32XWy70ssTtIe0nLytj2DeCmEloYt9sNt+sNjbkTqXFY99LX1yk4pT3pOutwUg+9OeJcjgkQSBOF9rlWgEgzbjYbh/NsJTOmM/885CK6jSJmXzquyD4JYQ7u1qadpf4eXpYQUILjZb30d/K5EJGebdNl08Dp5HC2HJr4GY/+XcdOju877/VB0PSMpqBRDr6UArZyqv39xclAcwbVozw423vn8jCSeobs+Hr79tkQZeq/moP64VY4+b0QgfoafHCNO+5Pbipd7hyfcXo3CV+46xfZNjsnhfp6iERK/04iYGTZFM0kO53bqle7jjV0v7jmz87Hu/0LP0/8fGjdPk2kWIXLzo5R8SBMtFaR82JZWwJ5nDQbrnADI+FyKbjddnggnPdPn+nknkEYLWa3Uxr2jYoTAgLhffyHPt4u3/okkWNx/v4jGK5ZCTglPK64rBdcLi8oOWPfKlpj1MYQ9v2bwjlt2XPLCic4Ot4mcMyuoXU5PM6VlHMnaer3DJvhIS9zXgBQxzLIspch6Anz3vdMkX3+OeBEvhZsf8cSSnG/sFhfBWjCSpLNTbF4dvzGM0/b8rcJINK1LwyzgwFCNmJmwLUFAxuf9k/s/9EvctRbnu3ntCdh5tme7dme7dmezZpG5mht33VdUUoO0UztoIBF4BLmJK8BIMw5QyxzBQEoOeP15dKBlKjo9HT5IUrb2wAwGdt2BVCtMpOCMBoV6A5MAOJsbr9/AwuhVnN4pXJ4hpgS15pGEUKoG7PrZRnRlj0SUhVZd+53kMXAWH+PlFKPSJ/JLzGi2oHdGNU5R8gMh0wwmA300XE+fo8NhBYa98jJaoALmUERgAwHKnTE++/c6V+KRmY2Hg5itUbsCgOskwNK1keGghWRSBTXUAQHanRugQ4EJ+8cEYZij6BDi4A804d9kkzFUwIGgKxOkJQYJTfQUpH2K4DWa6MzM/b9iuv11mtLr+uKXHSNKaliONbdidwNDQPHqoS02uzZJ6g74QBCFoCsjHs6xTwIOa+d1CE2FtzUAU9w55MNOAlEyMZHRyC58Qg1UHLW/nSvGcywodL3WGsNkAZkfzePSOC+XtwBmXIGwZwsbqBC0NDgGQk6IGYgVm3v4G3vaVprq2jsUfkZhAKNUlcSU84J61qwbTewVCtJkVBbQ90bPv39k2Z5sP328eNH28daYiGZUR6B333fwVWzDDl4MMpCJazrBZfLq6YEN+PRiSHMlmWIGEIJQmMwU9inDsa5kelTnFJCpgEcMsPAmwG4ppwhtXVjcsmdOmYOygQBoXW+koLRKSXsN61tXMx5vFqNZS1LtgEuo3u/FITYtx3ZiCAQc/QDKEtRPhxrto+yjvS6Qs0SuwJICcslQ4yM2Go9gOzuNPCMCArk7JZhSLrccjnw269/6nKBLSX67bZ3h5yOMyFhB+lq78Z9RtZyVczmINPIxFIsS4AoPSxni0BPOgdKFCPkrM7N1iooA3vbsSyl7w8NbrcSTaJZADbe9d3SINPUqoSKl5dLr7ut9206Z0tRR68waqtQYpOCD60RCKPIdMqkAoPsHlWzrCzLpa+1vdYOvHrWgRLAhJLcdSpGsBqR8l5ayPeCO2NyzrhcUpfdCroZucPLEaUMIh3LXBISl14OJtm47vuGL397Q627lfwYmSUcgC0lI5dkhAXWf+fValuzybCEnBdzXmiWHtcfiAhJMnJWwItrQ9srIHI4e1POSi64KfGDsu5ddegA+37Dp09/R84ZLy8vKOXSCTOtNuy7km0v5QLJGE5mOLmndWe7EwOZnWirCJKIoOQV23YzmauOZCBhWVc4C5Uss0wpBZRGavcDuNoGwF656l5ICXmx8VhWc/qSrg8TSD3Djst5B+1SAnIB5YxsThs9tp0cSEho/fxLRqiCl+gBlDQZCGUAa1rqTGACqhENU1LSVJPWwbGce30HoDF4J2zVSBQwx2JZLcNKsvPZndcWcSyaYUxE9B3McbSsxUhdfNBLuDGERikuJ1VL09+VXLTEJ+W+txy8JTpmKHTok0XQTE+TKhCu+PjLK14+JICUzKRyUJA3Qt0BNIBMD0FJSEsCdsF2fceHlx1NEjgJKC+glFGbZRKzSPW8LP2cARH21iC1dpB03/eupwKwiPcRmakAvRITc1bn3u12QymuywKt8oEQoEe8zs8Oz3pVTN8quHx4gZBgb1XLX7LKLgAoeYF80JJ3y2JkDGHUBmz7Bs1mpHOac1a9iY7Zrypv3Y6AKM03GVLrOkqrDfut4uOHX/Dx40es64udDzcsy4LadFyWpWApLyhZ96+TI7dt7yQXQEuneYk2l5fbtnWHaMx04mvDHcI5Z3z+rBHAfr0702ZH/8vLq25x3sG8j0xx+ei4yaUgs5YfdbBe/xhRWqLOnUxfzShZ533bPCvLome+ZW6LpI+YMSsRIadBvPRMV35me9kYJaU5WUBJUCklrMvlYPf5+ozlj1T+UV/P0UlYa8XlcukOoPf3994/H8d91zPZ7bDWmpWtq/08iA4mt9vmKHCCZRYy24QbYzcC8hifWFar9mCQaLvNGUQeEVu+p32L7PE9JBH//nxNtMtSt8v802MZ43HN4V+n9z8jyTzq27eIMo++9486Th5f+3WHsanYGFlnoTaaAgbj/tEhDnQHu2MKbPiJ2+MiQCkrlmVgMD0bS7/10O8Jxyy3Z47Zuc0Zpfy6OBbxnhB14lUeegkhoaSE8rJ0G2vfIllNlOxpGSj9fr/9+hsurx86ea+UrPKEW5edmdRG2KueJ763YtnFkguoWCYXbthbw2YZ2YgSEhWsZcXL6wcj72SIZYJR/CQjERuW5FjXnEFTs2aONTZ0uz6/pHsm4xgYBRIQGrzktNqWFXsFGjbsTTN9JqRe4k1Iul5dUtZgpTCVx7m19YFxVpZSVO7WUerS9aKDzPXAAchBt875XLacZWIZK9rJDOH3FLOU6roqTkSXQfRx7MPfDWwEassu+Pr6sctvMTyqtabgmPejYyImzy2zZw32KeE+24w+Pzzb5R+lrkuDjExwslc6WQZHGcTN5ejYj1TOZUkn2of5vSMz0HG9nZM50mGdnDV1kh9l8Hzf+N0/Io+/dTb9UDu5PuIZp5f8wfucXiXH+Y3n+Fmb8evjGHjwghKhHEfrmFp4RiztG7FS/04K5EqXQ34Pl6Wt7aEP1EsEu451lhU3rtU+V+n+zGYjkpRSeuyekJVLWjIKLRogIGr7izAkZ7UfvDy7ZLPjFcspZUXdTVoc9CbgejU72eySl5fXrtPttUJIkJaCxoqlQBR7hssZO1eNAhnkNRQLd5TOxiMTUEWwbzu2fUcVxkIZqSjOlEBqCyayAKCKvVWgMTI37O0GJ3+UtGAVJbWr8a3ZZFJqKKkoIVGa4jOGx2hwRUFDxXbbUMo6SJxmcyuZXlB3LcurQVn3mVdcp40ZFX09pWS2tq0LmFxzvLnrGNr7cL9dAxKalkAsRcceEMihJHPq+5IgqG0HCYfP9AzLIA0OtUw9vtZcf6FMkHQkOM7rPcqlHiT0bD+lPQkzz/Zsz/Zsz/Zs1qLi4ZF40YgF7iP/S85a6gLnaXujwXC73Q4goxuxl8ulKzsxzWo02kS0/EYmZR2o4pQOCr8z9t3p6qnBEyW0Jt1Y0O8PgNef01p3/3agwd/16Pw9ZgOI7xnHxp8XxyASX2YAyn9/cACGMe2Kb60asZwypDWUsqhxAGjktfeFTPk0UEpAnRzyCFQ9Aoyq3Hv3Z5ILgIMiDsCcayFChkYEJ3OMbJqz6lj2Dhv9DrYYWcN/r9ePNUGkb5YAIy94X9GNLcW3SEsfgJEoI+WCdSmADMBN180YA+aG9/c3gJQIo+D7C8ryguSAlAMN+kCdR6iBAVsDe21IpPXXeyYTK/3k/7xv6sRUpyZ3o6NHJZEBBOMDm3N1yroxfNtuEDOmQOrIHJkK1FhRQ6f1efayJDrHR/KHjzugjjM3aIBRjmKs5daB4+g4ddBR99HI4JMoozEBRnATaUqmICUYZDJSD2tGmWUZjpa4x7Ssgq61y+VyMB7dMeXvEWXRMNJhwNwovaL39zIx+vNwrBAI1UhBYw3GchMzyCKWeSLBItU9khSMVrexxklJVQqwqsGPQEITk4V73Qy8Y2zbTSMzi5YkY2bcbu89pTVBS4JwY8t8AZRCmvLVQMFsDlcWhlSXV0BJqWcC79g8C0SqrlJR2bosRlpiCaCzZqRxAgQ3JRqk7Nl0dJ8xM97e35QIk7wcTMLLywcbPSVNfPjwC263jMa1v4tCH4zb9abzKAItB0bglnvHKaeQwcWcq0kJBYkKUjjniGov5+BR+Z5hYFybjLw5yvnAoqZSVkLBADMThIF9q9ix61qSOva3gUKJkq41EbBU7JX7ucTMoJSxVwdD1eG80GJzdQS43GHZzy3LVNKsrFI8p5Q0tvb7xKh7YMjueU0TKSnQHddkayglwcvrB1xeXqCEVur9GSXZNGNL42PqdAWfvXyjEUC5gZtHI7lTw/aa7dsEUQKKrbXmZ1BrwYFtJZZ2dYannJU0lhJ+/fXXPl973UMmkYxSXHaIORA128MAmJJy/gK4E3UrHTvdUB8+fBzYvhiZKUnfKy5H9n1H2xhk68zJJQTSzHEU9QStV09ddlgkl10kJgO0Brpeo2VTRnQXmdNOh32AmJQyKAtyrzMvYV4AMdIM2U2UGDhK7o2zXvUtZnUiaqmw0Tzri8pXzdhDdi65EzxoCV3fA7ke4bWVAtDdGrg28N66juu6XASqvUVicyQ316qZy3QtLIexdx0URpjJuQCk6bWRgbcv7/i3//M3rCvhdnvH+/s79r2hbhn7rmOYCdjqjrxkfMwfkJPgDV8UCEZBgjrzVLZZNjYrjxT3ZHcI0bHEmL+HjuOl70V/V/9cRHC9XvtY9bUNAos6pvR3SuLNxfcsAFbyHNl8CAQ5Afmywss4icCiCpVgIGDNvNVUV8yJkWmAvDnrOaXjm7rcsoFHghGKmdHEnVYFgoxt3/B+/QyWHft+RbLo2JQT3q8uPwhvbyNLy6zb+5rQ8dxB5FG7Rihv6vz0TDLZs+S1Cs+o4Nm4iEYGspSGMyOWkSNKeHv7AuZmZdoqWtsPYLDLZ812Ve3fg4C+rqs5LWr/XkoZS1lNxjthJPc143JhLkkHANu29b0WbQD/jv9uXde+b6KDJoL3UQbPtp632VHn+3Rd174/49r1fvkadkJNzOgz3zP2we/l/TtzHMb3jHahr0WX1y5XfBxmWXPuZP7ntJ/9zLO9Mn7WM+LM0RrHIY7l/T3OHbBz+yPf+RmNTMb/sSbjrz94SVx3rmefff5wHmlk9TjiHsMZORNjzuYwPm/+jIhQW0Orqn8LH21E31tKOi64Xq/9PDmUpglZdG63Ha19AaCEyZySESdHWTkAFtCldty+V9Q6yqYlC1DxoKmcMoQSCikhhkBYLMOY6/PbppkNUtJMNzkX5KxnluNS27b1vkf8Z8a95jmJYxbPZxFYcAcAMCgnfPx1wXK5dBtWyfEVe9uUdJ3Vjm+sZZzcbjp79jy/rTW8v78f9PxH/T1bF3PmoVmGxXE4YFwnS3TO7BLPgK6vBds89sXXrpMy9bPUMbD5PfwMjOdUxAD87xkPPDt74jXxGfMYPhrTr51t/6z233He/Hf24Yzg8keef7YGvnXtozmeS1/2vonaKbNON6/P+LOIku0oEBP8+1/rn8uuuI5jKUv/Tvzjh8/I1nUk1ER866iDSc+i2bOG2b2ylWN3u8QDoj5/+nIIWHB7Q/X+D+HZTraDZgDPCY137HUf72DnADcHgE3H8L7Ds60aMc8DRfXuENHAwZRIA5v2AhbG9f0K4tTHvpSCS7oAKWFtilequUw9SyoBqO1q+u4vU58AACAASURBVD6bvdTAsmmmSIx31XlxeV2xbTtutx0iZBm1B9EuWbZVWpLhxEc9ysfRcbE+zwIl6dDwccRyuH6dr+WImfbxRQZlzQmckowgtk6QGcB2xxGIkCXbmey2ER/+fa4g3a87HwP/M5cV62Wunu2ntCdh5tme7dme7dmezZor7bOS7iCiK1VRuVaSyWhndUS9xewy8bMZrJ+BRgfdIRLK1wyFydM1auTQEURNOaM2TeEbFf519cgnVTRVQYzPHylbZ5D0awYJcG90zGDwALaPJZx8Dnoa9qC8xigejZR3w8EcQZG0osiSeb3MOKChUJ+9x/y78dn9u54prsCMB6o7KzqcIvAR15n+HYk5mi0F/a4xamY46PTa0LG4bsMP/vOI+Le65gJAyLKuiBE3Sie1xDkhu71mNLj25yRKyGXUpl7IUmjCiCjimUciOWYAySPa4dhsRDCA2ZGF5DEo7BH94/Nkztu+FnsaYh8TspSm7n68X7M+BjrEPqdNzZsAnEVAQH9Gv8ajCr0kjhNS1PhP6ohNVtokrC91kBESmTPWIsaI7sG8aECNskEpGN/DQIzvdQD3MIDmngJVpI9rNNr1frrvWBhcR5kul2FzObW45kUEEE1v6xuHOknNvytGl7J++d72FNE80u0SadkImOzadwUVlSywA+NOSsRIYuQ6nftWN8sukZEpAx6pb3soQQkDPXLOyqR18patVQUTcr+vvi/6Gk6kTn5JAqKmJbIIJn8ZOXuJihH9KKIORs9UJAxstx3vty8QbuG5FgFjoEqiBDLHJXnZGE+x0bddkENWv/ocNFWnqgLZWwc2SllDmSYjMorLOahjNwBAum4w7YnUCYXk5d2SgzcCYgFzHTI9KS2P2YH+DDdrZwD3DIgegL9OU9wnsc0A8qwbzOecr2J/BxFdG5oBaQH6edD6WA2S7gbQkWgqwoM8JFpKRpqSRmHjmSzjkZMkSFlcEHZyjjmHuGFvFbXeOwFKschRI/lohF4z4p70eyh/yc9l6XtPwu+7/AhjGP+4/lSy7xH06zTb1kgZn43YxSz2vnpG0XRf/X4bYB05WZhQud6lfOe+dn1vhOwTPrcxOi+QlYAhf/XdnbwR30bs7LMZMZlAfg76N02Wg+b1qnPJseylnSmqvw0niI4nAwfHuxEZ03g3yRkVVcszhv3gYNsMjvseiUB2zP7n43UEsg34c90IBspaWYZcMt7f3vHlyw37frMzkEB4VedZUsIM84J9t6hKUkdZqw0pMbKPxeit7qFARhCxswAuj1x/ODr4ierhDIwkIX/nI4E9OrkCQQZOtIWth0HAbc3kVfZrAJHW7+GEN5Y2iDhJgKrnm0ZaA0xAM+Jv3RVMrrWC7PpsKczX9QXoZSj0WZQYuQiWhYDUsO8bGjfLjJLCnoskSl+LDUr8GgT6WhsulzUQN1T36iUu+ngBCpKn/h2xNS/i5EvC5bJ0ciizZkK5Wba4oYeM+RZzGLRWUeuIJHadp9baZRjRIEC6k3HoafrMdb3Pahn3QiT/nn1n1hWjXBp75agDxf3n++1RadzYzs4iB/RnWykSieL7+LOdFA2MtR9t1PsAAcFcmiTaiLFF+86fO49V7NPX3vlnt0c27D/Sh9mR4T8/eNSdvH1oV35Hn36k/4/G4tvXAecOnvP+fE/P7t6j28b36+S0/6Z3ndn6j8682TaZ7fRIEHEZs22b2iC4J0w48VpE8PnzZzCzZYjUrDGQBEpFs6hIg3BDZUGtt6EfvixQvc6xGQCkZRddN2vM8Iw0zAxqjB1amjalBOQEJkL1bHHrBev6ouVAxLM5CHLS8ov6JyEnYNjURz0vjs+jOZnXb9Q54noHORIAJBLIomOnRMsGWRakTcdbiZOeAUd68MLZupn18rkfZ98723uP9uX8vQOhJvl5d48Dxvud9Q0YZM14z5mYdMy+Ma6J+tosVyJZIeJw8d3ObJp4j54h+2TcH8mfR2P/VXn1g3Lpa+2w7v6b24/0458l38/s3HktPLourpVH9rR/d9ap5z12dj1gJXGED8+Y9+98DvvfM8Z/9pzjdY/Xbjwj4l51nHF+Z/8+87guJSW7MXEnWg/8TLFJD+Lr72WZSFTWKGnjtt3s52CzJVK8a9Jb3S5zrIrE8aKxr4mAlIpmglx3Lem6bbisL4YRNbBoBtZlXZBaNgIpA4cSxRoEo2UCq+FlDbXdQLDswZb2O1Ek2TOGrj+wI4d42cZAzys9QzhMq4+tj/ucCSyunZkcH2Xt6drwcbesbL1UNTwwt1/dx4FsUPV+YW+YLUMOJ07nqdpV92s8Yjjzfjk7d57tx9uTMPNsz/Zsz/Zsz2bNy+dEo3E2WGejk4XhscHfMiTmKKdIpPA/kQHvQO1Q7hiQ/fB8NzhEEojYHCTDedlq1Zq1plh6hKxgOO0cfFYQn+xeI5XrI3BkVsii0jYb6vMYxnc+OjDpoOieReI4sO7gTQSYZ2WSSB2sXVmmI+hwZtwd5lHOjbwIJJ+DvWpoKZnp6GTTZ6gR4N8b14/58O/53+5gHuONft87fHECpQ7jI0YY6Gm1lUKQU0JOi94vvHs0CDkAZiJa37tZuuh5bmeylTuYvB/z++BAMBDvgPWP0NPr9/ElHMdjOAtH/fJ7sCuuaQDIpASD+/vcj+O4lzqQOKwFb2xZQ+7lwQzammOzA8++jtRQJHJnt5be0DVw7Pu85+YouBgp7PLHMwv43DpJLfbTDXXfe7omDYwjQEldyQw5dajL4PoAQI/qj+MQiUcsbKkmorNpjJOvazecHRxw/7Jm8pA+F+O9bR6MBMg+lwQAmsXCx1bFg5HIWtIUtiRaYqsxMmnpGzd2QdTLwTkZj0hTptpIGAFI5Wx835j5a6QD9iw+Tpgb2Vpi3WoRArdRmoeTrhNudYy/uHNTAMm2LrNmd6Jk+94McLCSDsWzj7iMsowIXaAQEhVQkBW+TiM4G2vcA+jkUiLPeKagfsnF+qAZEQAxbMWfyX3ORXZbA2JRSL4+ABGPyBHrkn5Hs+ncgyWz/Pa+LyEd+FmEqK+juKeijIstnmPxHgfZYJGhXuJRHbF6v2IlWbQ0pJc/EQWxyDJGiPTsXUSamjolLR2ka9zG0+Slzskxu5mCb1E++3vrwpbp/b2fKv/H+Zfz0IfmsybK2PkM6WMhrYtxB8NSUmcNxMsvCWoVjBKK6tz3s3TIYjESJNnnuWd7Eysf4n1jZjvnjhFtQ+6MPvsZ5XpW7fvNzrNkS5BJj1MGnMohnWpjcsPlvD/Pz9JY2z2slwjWRpDN5Uccd80gODLZJUu8JDyI3v4UZu4lF1tr3anuMmk+D3zOXBcdnw/Zf+yzI38mJzWlj67llJTo0W4Q8dJHi5aQTIstw9aJeYfypTz2AAAld3WdQuxepY9TXN8qR1zGSpcxc2apCGL7uGtWkqHbcCfdjnN4JtjcZS8Aqx5oKo2ufbEzxMh/lokGsPesAxzWvZ4s6xbQalW5CkESO5PFn6MkpOOa1zWh5EQjKQa52pqXuRsk12FbDJJfayMLi5bd2zu47VlFfC7GuA7dbWSfGaT4cd7pmNbaUKsC9JfLYnpGc5fqQV5pf0vPfuCZclpjlLJoBjfLQOVzlKw8oLch0/3cqZ28Mut/MdL0DJCedUFfR/77uJ5LKZ3Ac9S/RovyNT7Xnx2dqjFrxp2dOkXMzuQYdVC3g9PVS2UNotDx+fFcnc/GGCkd99MjEP9/A7h/9g4um+b5m23keP3/hrH4r2xn9va8Hufvz/bSI+wiXhPvezZPnhULApQ8Sj8Mvc7JhUqs8Uh1L2eoARDqcASsTA9GEFNZHPsBShlnLsOyX7KgsQbXrFaOQ20GdHsIUKI/QWV2yVrSVTACtdyuy0UJrSkTkmUn9DM72pBR/sw2/2zzznpk/HueS+lZAlzXGefMsmjpxGoESc1OqnZotHXjM+cgl7M2r4tHa2TGec7uN9sJAMZ5Ptns81jEv8+eG8+HWX7EZ8X7+M+RJHqGHcxtlumP2oyRxHE+e8bX1sYppvHwyff3+kfa2Tj8T5XBZzbn2Vh9z/t9z1if7fGzf/fni2Mc91nFH91Lrxv20t1HwcaP43G2d+c1e6dn9b17zAIVrzvL1gQ79+dnRnshPs/1Tf/5Xoc8Zp3q5BFyXDlpdmAMHH0OjrtvUX6oscai9oiwBz8wcso9s6gTXgDD71oFsWYUb2ZPtda0tJINcyJCLglFCNvGWl5VmmWLJEjzDJcAS7Sf9L08YCh5QHCKODB1zMcG+m5dRDk5j+2w6WasOh0+i3On3+O7deTjaWadkkCJDqCo2oKhP90uP19/cb3M5+ujM8T17Zit89n+sfYkzDzbsz3bsz3bs1lzR8BsTJxFBwKjfj0mkNmV4eFsHgp2BOUdsHcAM4L8MVWgPkJrQde99mvO7Ahm0WjxEG27vFwwR09fr2+m2AUSjbiz0iJXcizLMZTIOWIxjgeAO7DUrz0CRs0chwNgchDdwaUY0XUHDgjDCR8z2HwKSAY/DoKCOQMMR2BEwneHY21WWs8AI/13w4jOAoYTYTjCRuf8UcPYG/PuTmmvF673IncCYRg9szE3Az3xkSKaQ8MdaToPIVuA+7m6Y4xQkjvChqHrc+1G1WyEeEp6d1x5ZG/j2kt9UKJRVkvG+Nwb9nOEq4z+IkZ930fhxr15JH+pEePvFb9/1gefj7o3y/YyxjfOW1wnXT7AI2qstEhfq1FO+HsCRGo85rz0vpzN7wwOxv7Mn91ut/4enrZ/NqzdSB8EBZhscJlnPlF7dqIM9Ewm1J8To+BiZI8DtcJbpz6pgZftmd7n495SYLcgl4LrtWkWCPaa7Er0ATspRrNEZCQ0MWPc9x0NB7Qu74SyBsJEJAf4OEO05BtcFgApiTnmx0BFEHqsY4/AV3JjfC91PFabK3X6tcaotRmwDuTk50Dqc1HKgnV5BSVdM60x9l1BjaWMcnweRc8MSDPSWzJnLGCOUCUClMUz6JBlLimWocZLaJCVYYE9U7OQEHwuBCknk/Oe9afamsqWJthSvfv2IJ/fYzk/W2YAqfzMOQ/iEpTQhU6cGe0OeCU6rJ949kL2vofOzoO+HmRkLwBwJ+f8XFyWpZ/jI3uLzl2z9P1jrWaTtzr/uSS7PgB5IgDruPrE+5IlIpAweK8olwWJMhjqdHf5pun6lbDkfSll6f3RuW9KBKGElPV8RgDvEIhfEIakkQ2BKGHbrl23ieMV58PHx//tEcTo+17nv5SRTUeYlHxIGThkXOoLp58VQ78a2cwieOal+ny+1kWJN0rq414W8x6kHY7mxg2Nq2VMGym2+3nV50fJRMxOcBxrsDuFXB9gAhODMcjUpRR1oomvW9dBXYdaDmMd19s4f0I5IBF17tWGtu9oez3Ifd8brn+VUrCUBc0yfcTSfINE5Oep6pt9z7ECha4z+Dwx2/vvOy4vKwot4JvqGMsHgrQC4WzD2PD2NsobAlo+SMtpWrYq1shE1yla1cxLWk7iWApwRMaPLH45e0mxsN8DySPqo76n9R3FZLPY+h2/P9OJde6cvG5lXklTqGt5xYa67ZC6g5bUzzNhRk4rRPRsXZaC1cpbJQBpXbFeXobtkJS2r5nVKqrt7eNaxqFUjhOpdIxHRqqcB5FMnIAIAFIOOgNzszOqYt937PuO9XJx8azJytzmgHRZ4/uhO18h2Pet2wPN3r8sWsqPG3dZ6Oec60ylLJq1Ib0DBKzrBQTNvlBKAbeG3WwmESWPlYwREWpnmMu5sXeCzmbraNu2Xr5oLjcbbZwzB1DU02Z7Ku7haLv474due7zPbHf43oxn1LquRlLb+tzPZaD8+li6xt9hyOpRSivaGWdnZyTcRJvXP5vbfFb8zDY7qmbd4Gc/x9v9exw/j3MGHKOE/5G+/ezx+1pzO+WPtngifPO78T2GGX7+ee/Pvc7hquG35+fx/Wf7ys/ZQ1DGyf1cZhBRL8vke3ZZFtQ9EvdNnyXXX1R/3vYbWhOTyQksjFutRgwFmmWIbYDiNdnnBaCUUXJGzkXLOVIgytUGJt2LWurC5XruertY+eI5iCvqCzGzFTAyNc7j7dc82o/qANcfyAkzlnVAg1IGWTeRklgJ6Jn3DudJkJdxDv/IvooYzhnOE783X+fj0N+xZ3u4J5OfkWvmPoygg0EAjvLzWF7mcR/nABlv3yL2x7GIYxjPjkdjM18b7z/jMnN/H83T2VidtbO9/jV58Ufk7tk4nI3b97T/qjPo7Dyd5+dr++HRHvgjbT5ffb3OJW++1W///uPnAK57P9qvM2HmDNs/kxfxnmdjGfWmORs6oPrkUhZQCECYcYVZD/K96dj30D3VVlHMMGJ9ycO4tC80zqavreveDzjmr3o0QTFYbg3NyvY51gRYWfCU0VKyUstt2HQiqMKohlkxMzKP6LmcEpAXLEtBazvYqkTllMCi9lROBORsNkIgrlDGUjyQpnTMtDW3yz0DjQbYCB3fdX73WQ+ddeCv6eT+fdVvJZz7Sh7KUWUR6boHuUFk83QgzBjeTv26oUpE2T/LmoF33GezdBv+n6kL/m9vT8LMsz3bsz3bsz2btajEenYEBzc8VXbMmtBrOYeyI67oejaBCBi6Ue8GLIAOOkSDIgKNROpo2vcNgKeYH+DuMHrd0Bk1u3tfA4HGo2JrdTDUnp9XAE48sewSk7IZSSxzdG4EUqIBEp0X3qdomCzL0sdp27Z+3XCyjmjno1LoRsS9oeRz2QHdlLCUYvVF6SFo5wqzK50A1MHLx/meQbMYvTkU8mYRwBHoVgJA42bOvNFidDmZt8Gda07KoJh/mPy7Yf75/s0cmInv5M4HsIBIDaFuWIh5wk1xPyrdRxJQBMydCBUdTR5Zp2UVxKLDKrbtdgDnHax7fX01ZyFZilAOJUGOc5NzdJTP7z3WwJxq8wyk0iwk9/XsH4FiIloiY1mWjk7Oaz4aYgdjDAkCfY+cdL/qWDW05lGII7JQIFjIS8FFsokcxiOChdHwe3l5OThTXZ5FUtvtdsPb25u9g9UlNmdcvGfOpTvf4/pXMoNoJhIaEdUvLy+H/QHgIDNADKDaOstGtEgaGV4HIO2R3rC9y9wAFtSmkf8JUJAXQG37ILikMdfMGvGS4AZ2zDagjriS1w7aliWjvCzYrjd4Zg1fZoU05ao+I4M9ewvpV0S0LvP/8ed/R60Nv3/6He9vbz0Vu6AhN8964GvHS8opmQZQsADdUV7CnOmcv729ozbp60W4gZsTIxYjyWgpo8YVXpIpkUap3m5XI/xoLWwvCaXCxQCZQO4hKkp0keHAhBByKn3/dzDYzhAlDpUus9/fVB5Ep79uRR2PQdBSR7E7ln08mLkTfdCBdYu8ZYGg9bUf95/LACdGVCOuRODa+xPPmxglPEfzu1PQz3oA5kgOkVYOGtnZUUo2p4SP1Yjq/+Xlo5VyCVG9bZRk0iwOm82FWDYJnd99G+8NkDpS7D6vr5cDuH69Xg8kiOrlnbLpH8xAO97vOB4Iskfn0s+7OD6+b/0ZR2BHiQhOSAGcOAbLmgTkXKzc1yD0CWmmDraygt0RX5ulZWbUtkGkIWUH2ZI64U2OLctic6ZryN8lpQGS6fj4uW6lZCCWpU/PZ5YG4pCppDUkEMqyIid15mhyHCWD1sZG0HCgTfu3y2YAW8j6RSODngOzvcxUAPV8XtRxdenyGSSWRabgr3/9q+45kyHS9P1ut1sfj3Vd8eXLl571gllJRE4W8bHzOR7EnQw+0Tt8bVHSDFcKOQlyXlBWxpf/54JP//cLaGX8+//1N6wvLyAo+eGyJvz+9//Xzq6EfRPwumJ7t/kiGtmNRDTzVmOAhw7p+qbv+VIKPnz4eCA0OAkg6q1+Ps1lcoZuSgAYpSTUqllVSin485//3M/aKFt0XSkxamkErOr827bNyo8BctH5XdcLACMYCvD68VfoVrQ9ZYRBIkI1O6IyYzfHazbnnNoTbMSlQVoiMjLNbn0DTB7ZPkVDbYLr7b2vK7dPnGSh50/DtusebaxkO0rAx18+9HPA5wAI6c7JCJki+P3T3/Dy8mLk+R37flNyR86ghr7WP3/+3QIECtblgpxKz/iTUgK3htt103dgwfX9hpwzPn74Fft+Q8oZJcidnJWEU+uOkSlo2GExi1KU/du24e3tDa+vr3f6XdyH0Tby5/VzX3ye1z7PcR9HOynq1tGGjGfbrNf6WRT39ChLRf3si8/wtu97/36U4z6Psy7sbT4PvS+RlD3bZP7772k/Cv4/6vePtkf3+1r//Hw7az+LKPPH+/FsP9L8zPMz8O3tDeu69vMR5vT67bff0FrD9XrtBLVoEx8yLpHaIm7j6l5SWyaVpI5DLFhKURsJCbkQLlntFWYGpQZB6ljNIKepHNorY687lpXw8ePHrofGLFMRnxjrh5FL7iRSEenyOuJYkXQRbcXZgTfLkIiV9NIi5LqO6kaSbKw4Y9s3iHj510XxKxGzHY7ybCaCeIuO0Pi7Mwfp97T4rlFmU9Cb43ciKTHu/Wir+HkUyYZn73EY5+aBInToS8yKNj8rzn+c2zg/81k3E2a8LwfcLPTZ+/KoxXvNuMv/ZKfv1/r+6LNvrb3z66KeN773PWMef+eE12/d46xFvSHeY8aKx70DWyB89q0z0W3i+NyBU+WDDuprMq5N1+ucVBzt48NzDSNyXdGfEfGO2+3WSQo92wyOxLeIRUY9cQ6WnQMliQYhRPGRUZZITUgjtmAEM0TcYZZN4290HIWIBokjWSyHULd1pSQsS+4YxLZvSAkQWSFCyKUorpQIy5LRGiFlLbtdq2IT+/Xd3pXw8vIBlDQA9Hbb4DgOMyyLqAZ1OXnf8ZJR5tzPDLUTXM4yCxoGruF/H0vX0elcxLGK1/v8xXFUmWxopAhytu/avHd9t68h6YGS0tTOintM+8gA1M6ZM7F7dYBB7D/ize7n0X2hesb1esW27ad759m+vz0JM8/2bM/2bM/2bNb2fe8M79mp7CDtsix4eXnpio6wRppGYCEaogAOykyM7J2B1wiURoU/pYTL5QKRirqzOT89E4Uqj+6IUUV6GCyu0DtQe7ms3QjXyEsGBGhth8gwZFLKWMpycIzv+97BWH8f7yOADrxHB32Mbonfj0bD7LSM39X3O7L9dbyAaGlFIywaB3YBmrgj+LGh6v0dz5ThrEjDoPR+xmv994Oggl4+xqOYRSQQM+Tuel1rg6ySLHKbLPtJSuoUYBllIuz1ghP5nhhyZhjD56SXWonG7NFQ7YatZQFwYzB+x4kXInKIOvP1KwZu5Zzw+vp6AKZ8fX369GmslZQNHFMH8+hLsqwMRxDH//ayFNFBMjJijLI44/taZsCBpqMxf5yfw7PcYOnlHo6fz04Pf5avW/3dyHAzHAuCfb91w4uMUCNMfV84yWx24EdQNjrxz4DKaJgvy9Lv6etp27b+XS8b42Q7z0g15AwsK4R0cll8ZiTIHeSDaNS9k1fUObngl19+m4h2vm2VBJOXhLKqYzf1Nd0UNCACWXYZfZb9QYF4aSJotpMhp/WdxliaEx2EvBSkjp3YPUVdkcki+1tjXPcNtWoJoXUpuKwL3q9vYG5YCoE+XhQcoKYlYpICADlr9A6g2QQ8q4SWx8hYFo8WH8QKX0OlZCzlBUlZLBDSEkM6znQgi+l8NQNfMigpKSplgciO2rT8jcp47RNZsUHN5EI2B0fgJZ6RvqfdwQoSi471zBHq7PbMJLom+jIxuWZZOVg0Y5HYtcrhCHI/kGWIoBmbBmAR9yyROgvdGRgB4bzkXm/cSRTLciwJOEeeRUBEZJRR9HuOckpjz3WABp6Niw9nXa0Vv3/6HSIKvK3rCgjA1MDVSCyIMllBGx9zz1qjBN4EQrYST3omXW9bz6ZCFMpPgrDmFbkU3RMgixTzLCRL3ys+YUQ+xke5F1NTz4BsjDxO2XUfBmREiul9BcuiffF1qOOrZWdYGLXtgXQ89nkpxdarkjPRbM6yZmyh4HzQsfeMQQNE8+xl+u4RmNJoMEAMjNqgpWia9UGBRkqlnw2t6Xg7Kfl6fUMpqlcSRsnLpSwoKXXSbCnF5ABM5rqsHuvJAVonfhwBM0Jru/VT176fzQQlUYoMB5HLel/XDgZ7Vgq/79H5r8QJve68nIwIIE2gyceUXNiBxi6VNINIrQ0lLx38vLxccL1ewZbVQtgzcwX9mpQkQgSkZUECge2sEANcQQbWM+PL57eu26rDUvD+/nbIFKD7fxBEfHw+fPiADx8+gLnhr3/9T9xuN2zb1vX5v/3tbwfShf/xqH1IA7cKFce63nMTCDSLkjADvIBSsswygsZFS24YqZmSZwMkpCJY0ouenewRn5phTNrNskzqHqtNiZRKWMpYLy8oufT5Z2bkJYFI8Pb2BiL0Pejr+O3ts62NpTuKdT+3LncAxtvbF/QSHznDMwMcHQGE19cXbNsN24YOiG/bzXREL6tUsSwFLy8X5LxoZp42sndGYofLad/fLr9um5LC1nUdMklgcuUYROCkS4CxbfVAZkwp4S9/+csow4LhnI62zJw1M8o9b+NMHlkC/PsRyI/OlBnsj3MX7Z3YJ/8sru/4/difqDvG/nqGjKjLH8H8QZZxAun1ej2SHOW+PEJ8/lFmfD8h5VF7dK8fb8Pmntu3+veoLz+7j987rs/2x5qIHLCM19fXg73v+M+XL196ti1AyZoa8LQf5NO+7zhmCWZ1Via1b0tekC1Dlp7PI3sY0wjw8HMccF1Q7THXbVyH0sxrCzz7ntuR9naHPSnmJPZj+vjZwKqYud8jyvgo3+I18fdHJ6X/0bLi+v0MJ9wTEVZaez9VHhdI3SyY6N7R7s+9f9Y9QeAf3RvRHvL79p+ZsXM7/O6MBBP7Ex20MZPZPH6zPeL2srco66NciD9H2e3PcP13dijHfs6YnN832oP+dD6x7QAAIABJREFUu2+RI30NzKLrR2T+v1L7Vv9/5Aw8v2bIgbP5/ta95vP5R8kyfu1d7yZ9I7ZcCkqwayJmFa+br+fW0OSYlTM+O5KRZ6zWf+fXzHjloe+eLzONwK3WZfKw/z2otgfbIEFITmWM/xz1u/m9xzUjy/PYS2SZVAyrJQ0YWNe1B8JEDHSWS/28SskwniMJQ4n32ewoBiGDyoL1cgG3iuv7WycJiQg+fPyIaraM+kgKGgOABYhIAtemWTLX1QiRApEF7++72Xzaj3VVYnwpBY0r9v0afBBWpsm+r5knh25LhgNpSfvRoh7qurBnXgSAmTwT90PUee8xYLW93G4EGTZqgWlxvsV8MylpkGtc3yklw0Hu51/39cjiPq+huJZc/g5i2P9s+fmv1J6EmWd7tmd7tmd7Nmue8s8VIAeMXZEhK2/h/wagShLuU/1FR5veI0RZW+kKZmUUKxgCQJIB44r4s7jDU0FcBbzdMHDwbji5idwALgYIW8kMtmjQBgANiQSXy4JEAJIbCUeFUL8/lNGzCMeoUEZjfR6LAZ4fU+SOcSpBvySMoT32qYO15O+tDhFVSB12kZ79AdBxPNhAMnTZ2aC4N6z0HpmA7PdjAUiQu8OXkIqCO5r1xEArmNEkGMkjICAhuEnl86cZJWweNWYexvk3R7MDYZp+mewduiEEoN/C/hZjv8t4dH8GhV9WHtmOElEnPkSF3p1YHs3PB3aO3lAj8N0oqX2eyuLgz3k07rwWvOWstdQBQa17T9Pvr9j46Pgl0ghsjToZk6zj0LQMjejY9pUi0p2UkXgy9ykamnHf+/t71iJ31rPA/ohl8QnZTkKERCwRMYy32olWbrgdgDDLrKC1bwWUXE7ASDUAgREJI+mQnYQ7KaOvAonz4Z9xf0UHYh28JIuyH0aljXMgsM3AwzzflAhZMsrlRWUdNy15Ujd8+v0/LU14toWt5Kmc1aEo0rC9v0NqU6PfDFWipBEmNgeNWUEVISwla2pYUoObWUN0soHKAhs/I4doaZEBSpDNc913TRFOw4kksAw3ZOBxIjQRvL2/B/kNCBFAGXtj7I1BVM2BedGUtAZQVK5oojIgsclSX7fJXaYUABk2cgWb4NE1IdCfff/5eiUTSj1jkb4Bumgd/4Og2kX6/qOO0pjXuH98j+z73qNqHHz3KK1SNCsFJeqEM5amfeZBUCBq0Mzzvif9nLJ9YGOgDs+EhKwZfzhk0rLmoMj9fvbSW2Mt11ZBDX19pLwcSHu6F2AA0cgMJ9KwbRVOrB2AiMsHiwAtWoZHREACBX2yZpMBM6RV2OO1z7B/gCDJnp0AJoIkApljpQkgYpFa0pD4mDlDo5iU3NbCvu+leaC1yJGS7ouUVfNw/YB0batw8ncyghruyaoz6NllayJAtyKYde+RZVUCFVBajFyh/QC8ZrmgMuO2VZtzk6Okcl3ngwArdSMsXT8jAQqSlRcbwCNIzz2QZdvLBbnoOVKyA6kN+77h/e2zknWMENVJlnaeMBhNNmzMuN0I+94AJOS0YGdBFWBdlJykJDBlgFH202NKE81jjsZ6ZtPjjEACjVgDsY0BAJMDJATyLIhNs3JpWSp3khek5CRS1nI2qjLZuZOxLDam9o4pLaa3OvnQSylaH3uSQgJJhpASjXIBUtbo8T/99ht+LRkffttwvb0jJQFaA8sNt3bFl9/f0bZNo/EY4EZoAlTsSqK9JOSSAMoANANgLlmzvpBlLANpWSto1CShjDPbxQIJLi8XCLd+PrfqUZ+DSLzvGz59arjdriAi1LajcUVZtFSS7tOK1ipq2w9AeM7ZMgR0xUznMXnJO0/LzUBW3TKZ/BVpnRZIUNJPC/oAt0FwYNOHEgmY0EmUgEfhq5wrlPX+prPtdUciJ887QUQsA6XrStLtIpcVTtxo1Rx5xLZXDdBnoDLjmDVJS3OpTk6W1dJ0phbIlVCyZk4Jt7rpPmDqxD2/nzswZseh21rMDsRbuRMD24cex4glPGFnrJ4Ro7xstF3OdMR41jxyRLkNBISMO+Eenh3G5WQMqPBABXcWt9YsGxHBicx+dqXkpRD9vhxkJfqajP0Q0ayDTggYBHe6e7fh4NH7RVKQkwTUGXF0nMZ31etnMF/wtfbYqU3T39OndPz9/XO/r/2YE9dJ5v/17evvF/TA77hftM3jz/+0Rt9cHfCznPyC8NfpLad5PHOIzSSD+d9DDprjDEZwTaPcLvqaH9n6BAKQZoVJGI5NgzNQuWG/qh3TSxabvQfR86HjGwQ9Q8TWmB4hKDmBWZATYSkF67JglKuM+3o4Zse7uX2qzyN7BkSDBYSlX/t+vZrdEr4byli6HuOz5C9KsHeDY0tOHiJ4IIE/gzsh1AOOtPReIwH3gIsjDvU1J/2Z4/Fra+Pse2ey//QzwPAWX5nkagDGb4/jQsfB6p8lSuG6gSWY0vfwnc8y7sxn2Jlj/2sZGM7e1e8Tz8hIsOxldqdzRX83sJbopI42xdwenQlf++7X5PfjM+bxWf+19rX7nc3Jt675o/2L/54xN/9d3CPz+8yy7nvafK/ZsX/XV4e1fE8YkOk21VjjEWfC3f5wXetsnvr6cdMVbDay2kvMhpUEPJAO54m2M13mgJOGsYzl5mcS0Yxn+z1yyVhFgyJz0swtA8PLZusaBkPk1iIgGoywZA0CYc/mY5jLPJbkB42+lf6Vhtxxa1rEsPRUkKhgTQUpF+xtw+36hlu96nlS0ANrIAxpCZkKMiVIUvuclrUTk9TWqFbK230KRu4kUruDlECaywJiBhmxXbotkfq54/gfACQmsDgO74STKOvGGThki2erGUFAwLwH/Bq3ydn0EjsTDQfRoVTbk+xeug5iadKwznzNkK1HbkhgtQkBtdMAgJLhdm6ThZ7Z+3sgTk4LEolldn22n9GehJlne7Zne7ZnezZruShhxtswKs+d6CKW9FzOGfoz6OiRfK54ORigkTUjGsiBAkcaVLFXQCZTBuUMQCzCmTq4q4+X3mdVLIs6Luz5e2tQBsfoo/b5PjrHlbrZYI2GyNnPsUWD4Sxi5aiEDrLMeFZ8vv9BJydQcscA+u/txvZvgjNMOi71AACIhk/sAAl3Y0DLfgi8YOmooZ17hCVEQNBsEYTJ0Ar/dyOQpk886hjeF1tnJOr403/TUJv9HmE+3THzGFTwNVn7ezPIIrmDkStH497LU8Txi4asiGgNXKK7ub9bX1PfYrRa32tyXvoKsGh6YbSqQEyR0g1jQO7mMf6ul5XppIgZSIyXDqN4dnQIvJ9HA4hSAjHMccvI0Ew5nfwiY20raKl3U8DVn+slj8icUbasJZRbEAasjAuLwOvPkyhpJvUoRn8n6WDovDSGQTlk3jwGIm6Ae/pYUbIfkdVsv09tG0Gwvg4EoERY06JGJxOoCqpU3G5XiDQA6vwnFCxLRcmWOjcBTSoyqeHsBCXNKJCt9JoSSARJnaE5dVltm8iwZpM/zGrw6pdsbmBzoWukrz3ru7dESloY4IeXyvExNlmRMlDSMVOMOSfV0WyOUGEkL/3igLYTZTqI46QYMbKB7cHkiyRAtFHe+pxwtf75DZM5mf27vjeaCxcIEiDnjp+jM0ym/c5wsl1rjJQ7/t7HqvEgh5LN2SivNNarZ0yRvpb9XBE4sSb2aV6LkcQZzz6EjEN+f3UMJGDHIYKNiECi2Q7E1xR0LPWMV/Kkl9Lzs1VrbMMc5A5oNQOPKrKtJYiAjXSoJ7/vR5tfAcxrAkJGyRmVrMwKDUJEC9mefL2pfLSsKuJkkWTnpO7s5M58jHWVvERXP0TRz111AjwGc33M+jlip4VmfUEnqRESyMq6ORkDBIitG3YijABEJtds+Xo2EYR1iBQAqcZgNJi/XjOSJIJ7NHIClpKwLtky9BCKOb2qMK5tw/vbJy3lIioriLwcp5+PjMp6HrUm4AaUckFKhMqCvK5IpQAmB5m8RIzKOicy+lrvMojcge3kWiPNkBM9gJwJJS0QsRI+zcpMueMsL0iFlPjLDGrU9RVdckYY6WUzCa+vH2xIba2LEzjzIQvO0Fmpk4+EgIQEJE3tXRYluSTSjF7pww3l3z6hXG/Q6DstG3fbN9zeP6PtO8ACMSJFYyCVjLxm5MWyrQiZYz5ZFKYSSF2mdyeb9TkbgCjQe5KNP5WsZOGc0XLre9LP5WXJqK3heqsmCvWcjanfLy+Xg27i2Xc8C9HsjIhR5jquvWdGahIFvpUtB0nD9kDOlp1NycvZIhRdruWloOSMvSppMSVCszOucQMqgLpb/1qPSoxl05ygNvrq5zr1LC86/4TW9Myjxe2YIG8tsw0yGddyEHlzyHKjWTpVZ+YmIXLT/9w7LOYMl/EztyVy1Ee6fhycFKYfjXvrmXuWBSBmloktPn+OsI/9ue/fWC8xwn/OJhN1KAf4/SzU7E7cr4u25yCHOjmbMUc0e589o5SPifdp1tuPQQ/o7zpIW57Nx7JlYoz513RsH/ef2+gHP/uvaP/s590/33Wu77pqWrf/ik2xgPuff/h+csyieIZ/xM+8ZCiFbAUur1xvOzpUaervsPMFx/0EGCmNPCuokvXtNuNcgYxAGBaNwDLyTiJ3EroeNmwe7YOM3SfqJFXVyLGEgTUoLuSBE6oXwDER6wdM1gx7PeItoxStvi8dxjP+6RZMH3sGVw0OyDkDnAFuqLXdyb/oPD+z5x+1R2v8R9f+IO4eW8dYTq6J3Rvz61ao27D+Zb/HOEtmOXtGpvBzfbbV5nPp0Vh9De+b+/DoPvPe8n/PWW++Z+zns+1ftX3PmvyedjbX3mIgyTy/P1u2P7rv2XMkYJU+3/c6lv9wvHboq3wnPyJBq/cHuFvzjlceb4zDHnJdeSblnWGaQ++lTnqeM/tFLMJLw+acsFhJXEqEkjMaM2q1+kvk9jON/U9qD5LJ1ZIJTKmfH8LowQD3c+Bkd8OrKZxL3j+3qZPKsTUTPv7yK0CM2+2KvVV8ef+C3375VW0EcSKkZqYBkeFv4/xzkqlmKFt7v0ZArOLSmmyd7H0TQOPcAQyDkyMpT5CQgj01VP8jSUaxLz6suVFamA5j1BdEGPJkwUSEaKvI+L5hK2y4LgQd02OMwE/Vjwf5RnEFten0rLV92m30sURF7n1ULINsmPKTMPOz2pMw82zP9mzP9mzPZi0q+Wepp4+AOPfyOIm8/IUYGDAcxHpfvb9HDZZSLHsGUPfWFR+PEFLj3xRNNv8YkipnJP2Gen8l3DhAqYaD/lEyR0JJxVLbU48i9TJN3jxac/SdOnDvY+N/5prIc0T/bKwPJbn1iMT4p9ahcM6RJWfjLwDYbIaMaADMczkDMIOYNF8zO1Pj/KP5GABOFhmAuDqyMK2PDmM8ABYef3ZviD1q0bkWQbjYZqNvjMU9uAKMrEKzIRjvl4Nz+diP4/eA+2xDZ3vprK/x2Qdnq10XSyZ4mvxa68GJdZz7+7GIBuzB6DoBFGZQ6dF7zO95aohjGFcOuHbjDaJ7PgCO+16xluU47nadGpZ8mNc4rOo441A3HViXoyF1WOsY0cNz645bDGDawQ6GIAcg7/CZAb0C77fZ4dDMIvoeWtokpYxcsjk1q8nH3FOae/rb5aKOaFslKouBnlUAMKDZiIFw+dgHx5gHIqBkJDCPqDcZzgIkOY/Oi3JqBnd8nLTckjs6h2z26GufKy8DoWOuTrBi5Z4IMNCkhjkZ7010L/8OGYlwv+71lxLKWbmhP086Tb97DKqdA2PuuPZ9o+OhjlJ3aCuRo3VASd+rNUFK4Txllfs6nuaEQHQAjCijGRyK4PC8t2dZPzsIY2aaUWpFibXMO1qrvd8paZksIgJLg0cc6TgcZQQZOOUOklorkBLKFHmYcuoRvb6XItAc3y0C4P7ucS3E8+0MpAZRJ16GIwIgwjG775Az/a3oqCuctbH2oE4YKp47CCBNyZxSshwVDCdqgSpYPKuLAol+Pz+PU7YIL3f0w/cpgavt71rR2LKI4AXJSjiBCXnJKMRIUoGmMnBvmnVj2zfcrl/A7QYCI5Fn1DF5IQwRjQBngc2XZntYyop1eQFIM81kIzv7esmWuYg7iBcBuqMz4ajPKIDmpdJKzljWFcLAXiuanYnCAmoNa9ZnaxI8I3PUhsYuswW327VnuVgva997te09UpGZUKzsm0d7hyWgY27RcbkUI4jpvkiW8fCvf/0r3t80rXdKlsknKci81y3MLex8r2hV8OGXX7AuL4hkTs80AtnR2qbnZ5BrtVaTnUaAkHEuEaiTWJGdJGaZU4ywlkvGxw9KHPLSGrUeSbNEqZN9fS870cH7EQHzmbRwlhI86sxeMiinZGfYyDADApblBZRGGUg/P+N+975p/2uYs7GxI9nCP/PPvfyRnmtZS9yljFEujE7lj79/LFHnbegkR4dy7J9n65rl97d0rlgebn7PqPud3Q84lpebz4SvtdiH2bnicxyzx7i+HbO+eL98Xazr2s8gHw9fg7HF582Z1Fz/8M/iXC7Lchf930H3E3LQWNfoay7qQ06Umcf/UVR9GL1TvfPr1zzb97QzW/l7r5ntwz9+o5/z/Ln9jLUx3yPKB+9D3FdONlXZ4yUctZSflz+c+36mk8+6qsuIY4nc2R6d95adayH6XDOEBeIEm62DEGxD0N+ZPkFBnxO5d0CnlJH9ALWWUHtpSbVflRx/tOGBgTdEO+N4Tvtz/HyM4zLruCklLbVpGSyjnj7b54/m+FF7tN5+ZO2eXRtxh9ivRzbb1743t699Z57PeP7N//7W+j373RFHOMdR4s8zRjJjN/H7Z/vla+/5qP3oZz/Svud+/+izH10fbb+z9fUj/flReXuGw/m/v2kzhnvMcnn+7hkup7JJlIjwDWLu18Yp/vuMBAOYXitHvXvubwwCZLYSe5Bh/3PUow2JCV3peWOoIyHwUqjxbJqfG/f72VhpdusTWWAynCjh4y+/YVkWvL19wdvbF7S6Y98tQM/wTQSSpACdVALouKzr2vvzyDZSHfg+W3DUp+NnUZbMeus89nPw5RlmNOvQfq19q4+/2+YiilM1acgZ8CDa2VYRw4IEuCutSJj2iR2XRARJ0p8bx8KzoQ4bIR+wx2f7x9uTMPNsz/Zsz/Zsz2bNlVg3/Bz4dpLLDP6lpGn3cikW9eOlD5qlzV4PgKmDAiJAqw40Zg0GYkZKQMmrKkrkylwGWNC4IicCt4Zq0aHZHBHLoiBlrQ2amGQoXCknTbueR/STK9Pez5hCvvefGQnc3302TFprvVa3j1dMX65/u4N/pP2eFXF3eMQ+nymv/kw1fEyBZEYVQWOtXRCdn7NTQj8rcCdw74c9x+dvjgx1UDkRoXmGGRmRn9pVRm21vzsRIVEG0Tlg4P+eP3PgagbaZzB7bt4PV7pj/+N7HJX/8a7R4ZAPzsh7sgrInXVy92c2MNzomPse7xv3mpaGkA4YuqMgOp98Lt3hIKIELo1qPTq6o+PKnxfJXr624/1jP2Pq/DE/J8S56bneN3+Gj+m2bcgpYymLRX6nTvrRiHS2rDkNIu58hwKwLGDw9HyxzAutr/fbbQOge63kgr25szD3+fAIcR+TkcFjdnbFNRvWQ1Z5o5HlAl0ejNoYUvd+X80Go852Ec2CcCQ1CFq9drAAliEmyaKR8Cnh8mFBpoxsMqLWiuv2hk9fPpuzmLBeLnh5/WBjZ+8R/M5KbiQkJGQr/7bvm44F+d5ptvcMWLCLPUrUSXZzBPc5kDeMbS0L4etendzHPWrEDcp9bNiiiohGViNuIXIkRlJKHd8JIMCZsT/mfDimfD3odbrmpGPipFFCGAY96B6IiO14Rg6gvWdBgyCnjG2/9uxJLi9VGhsoYAQKbgMIICJQSb1vOnjUnQAmnk6Bs33fe43x+fPoDAaOhKNlWQ5RYtrninURLEvB5bLgen3H9XZFKQUvLy8oJWvpnn23PaqZHihEvzIzXtYV67piWdTZkuysrHauigg+/PIROWmkmcu02P/xTE93vB/0mCh/fH7iGorrxa+jlLCui8l9gmYwkA6kgUbqYj/Dz84yf/bdWQEje0BLrgnQiW1a41uAniGLINKQpGrZrgZwy10OOQCqGUHQM/sokUnBI2kVCVpyUx1LmmWjNeoRWa/rr0iyo26jNvvfPmkJptoqWtvBvAc9ULRsFGdAbE1SBuXFCFWLyZoCESWF5Kzn1Lpq2ScidWzdbm/YayjdNukK4wyedaRkwCQBKEiyoHKDVIAbILZ3IJohCK31jB9sUW3rumBdtRzL58+fkTLhT3/6E15fX3G9XlEog7cGgFHKgnUt+P33zz3jElHS8kSlaBmrosSdXApSKRDSUnu1VmzXHdt2w367IRHh9fVVz8ukGVJSFqyUUSXh/V0JP7f3De/vVwgIH15/Rc5LXztUVrTKaO0GoAKyg7n1fa4OzNVICIOMruQBBTdLXuHlIIYsBF5eXvDysgLEWNaCUjJay9j3jH2THtXu+8n1Ziek+GdOgJgzlsx6k+swUX9elgwtnVchArAkLRfH43xZ1xW13QL4Lth2OpSE0/UUMwpRHyPNJnQeae79jjoQMOwkEcFu8sgdxk52OcgTorBeht7t4+Tv7jLrbHxippV4ft6R20Mfo54W91F8Xydbu602n6OuQwLoOubch3j/eH13hjB30k8cWx+L2+12KGf0+vra1wAz48uXL6rn2HmhsvWYgcbv62Pi+vMgY6GTw1yPcpuslIK///3vfU34+MX14rI8zm9cu8cxaIhZJWaH0izfxrXfdvw924+3R2P7vddGu/o77/LVPnztnj963deuOcMaDjiDHJ2hbpfGjEx+Lhc722+3G97e3gCgOwVnm3G2jyORLsq/KH/jdzQCPxIVKZRvHHLO5epi2fSEW89UBouMF9FMZpqFwIMLVD4vAZeJOA4HR6/LcCf9oxOd45geM+vkrH2O2b9mfCL+uSdLMmp7AckOrqpTvL294cuXL+h4zXQmnOEQc4vPfPT597R5vuN7zucSgFP9IP77zNacf46Ocj9D5j7FP7FvM9bxiCg6Y6H+rPkd55+j3IjvEu2Is/N/tl/j2J61H5Vz/4h8PLvXt2TWozn9Wnv03vN68Xam0/2R5/3sc3iew6ibRpLbvNdnwkH8/dlacPkNoOtPfe8nuiPLxP7MezPiLW5PuL44r+OI0S7Lgn2rvZRmx8Kmc8C/n1ICjCBz26viB7Xitu24XC5anjxneGZYtQUG2YSS71fLDmt7yPGCs732cC/JMau3fzfD+58gUrCsv+AvL7/gz38RXN+/4D/+4z/w//3n78gp4/XyAf/2b/+OnBbDJysIo7Soy2fXraM94n2utYJSRlnW3lfHNuxlDjqorxMKZYhmufa18yWugzPc+J6AIz3IxQOl43xqFtYMzzrspQzJ5ycBEEHba9fP/b6um+tZZuUdFYZBDLxyTHbfLeOc9kBx4ydZ5qe2J2Hm2Z7t2Z7t2Z7NWlSOHOCNDp/ocO9GKWn5nD2kMHcQMgLC2WqQqjLoZZFgILE6WTztLhFZpGxCztCI3rSCIKi7OsRVmdLI9QFYoEd/plR6JpnKFZlzB3schDkQPILSqIaGYK8D8PXv+jP8e9HwiUCTKn37wfiIJXf8b/2TDnMwA0nR6OjKJ3BIOSiApR4+KrfROHPHLxAM1uR1U7VPMdOOA/giSsrxSN/YX+Zmnx2z0/gaif2Iz53HYbRzsCG22YEg4jVkzzNLnEVCxDUdvzOD2jNoIjIiyOLcHOeT7q6N4xINt0iS8b3l199ut8MYxXmdI5YdLIrv6RF/8X3je7qTq0zA4Gy4e//PQNQzUHWeKwC9PEv8nfdB9xdhWdbukPD1yqzOKHcoR8OO2QgHGHtT+xnXR4JY9pIxNz6mAwi1UTTCSGCbHMY4ZsyK+9+/P/7WNTreRfs3gA6xiBVQAehI9GAUdJCVEqgQ2DKs5JLxcfkIeU3gZrIHShS43m4AEVIqWlbFwOyUEjJp6TYRzeilhihZVCYAJOz7ZnvCDWfuztSUjkQ2YJCh7kFQi+EkA5/F95PtGYyyFQAsBXooQ9OzS7hsVvLhWHNWm5qkG8azQR/PqejE0y5p9ImWl3FZ5H+sfIOVAknZai6L0hrG3I35FjmXZT7H3mfvpzrxk41pzJjh0UwuY3N/f+/jvCadYOPPPgMq41l138fjHo8O2DjPEYhureG9vh+Au3VZUJYCSsBtu6HWDU6AyzmBuVk00QCYa21g0hIwt9sNa9ayf/7MrmNkI3sFZ+aZvJ4BIP+9Azoz+ONyyNdKyRlYit67Wekj2DqgZCmQnaQEraeuaN1hrA+zE/rYiUeic1ZyRm3cp5CMtJBIa7inrGmYa73hdrvqZyjqaAG0xIyXCLRySHVXecasJSyZKsAMBlD3vUuorcsK1Us+ffrUx6TVitoatrqbvmHknURA4y6jc1YdpNZds+MsBUQZwqQAVxplNnP2CPQCJUl7ibKKlAkLCmoLZ2bfU3NE8MhbpPOSteweFFBMRLisK9aSUPcNdWcAGcuiREGQWEkwxtvbm72L3vv19eVAwCICtu2G6/XW95iuaTKnl6+jHdumupKWzWIgEdaXRcvn8ci6AlHiUjZS1rIU1H3H9f0L9n1D3Tfc3t6V/N0qGgtSKqCc8fnzG15ePiKnApCgWBkmJU4VaBKh4XhRPVx1Tn0+o2CU/MpZCVs5aWmwVive3huWRfes9nvD9XbVtdmsNBjrvER9wvfWuq64XC59LcXI+Xh2R4A97kcn3eh3KnI+yqqoExMRtm3repLLuWVZT3Wdfd+xrmu3bVwONdvrUV5HgstMNPZ+tqZZLGEl5rZt6+/kenQ8L2N/IpnP9f2o9/v7Rpky2ymxP7OePADn+xJJcWweOanj/MRsM3OfoiM2fhbPkTlrY/zbsyJG2yi+DzNrNh97D18bTrydzyx3OMxjo2tjkGXqcTQtAAAgAElEQVScQCoieH9/P9wnXhvPkqhznzkexph8XxmNMS/A/8/e2/ZIkiNpYo+RdI/IrOre2ZfZxQEL3AdBEO7//xLdD5AOwkHa1c7s9HRXZka4kzR9MDPSnOEemVVd0zd7CmtUZ2aEO52kk0azx94A3v3u1mDR79lRkR60Q3u65Hvk5Yhf047e+c3v6t4z92SOve/21uQ4Lq/TjYY0AE1nHHqAzLnhLQCaTml8bXz+qGfuyaR2/9hPydIYN+2KnE5N3jBnVr1A/o4BAQyuBdUc942nVdONFFsJAZlZMw5IGyV3JxuT40RXkLLD5vBuRunOE2weTRaKqu/cOit5HMU+9+eGYDEiMyd3Np1OJ1yv16b3Gu/ycz2+yyM6+t6/p/F93SO/BvZ0kKN23lu74z2+7fF82mtjb2/7tvbaszNmbMd/789xf9YTUXMMHXWssc9+D4wYy9F8jeOye/dkg/H68bo9PfKIjt7le+vi6Ew7oiP91X+2996O+ndvfB/lt+M4xzHd699Re/7zo2tH3XePRie5o3fs+Y6/DxD9jrHF6sbzYexHzlkCg3TN257xOIPn7b5/DZ9nBrW5k78liEQxIta8MlFKcnoswto0B+cRmx7ny58l3gllxBOMl4eQ1PYAEBghTvjHkLBcrii5QIJgIphIAic4AFg79oPOExmix1s50C6rRlDYYja+n8W9Ix/QzIpNjmvG85JRX/AON9Y/72g48im5x/Cc7VnVHGTqAqJTO4MJEDyS5IS0Muoyt9qPIjoqaaYgCQCsyMtVgnOCBa8ZVir9naYZKSQw90zWpVw3esCDfh09HGYe9KAHPehBD1LyTiF7gLZPnW7f8Say3SKvAQMv5Nqt4itG6YgQzNjYBa4YLXpDyjpYRhMwa1kEuQaoati17BQqMEOccgKp8Mhd2PTj8AKigd0eHA+hG5O90NzG7QAMrzDsKbRHSr39Lp7Y/doxSnNUmkkkdZhpf4zM8YrILXAg76ONx16eu36jQNtziRCbDXx0ItkH6Pz3HwUcJRXy9rM9xXpr2LVx7bV3G6nDBnTx1pC69073lNbxfftIhjGyyz7zjiBe+fEK3J6yP0YH2LhH5dUreP7ZPmOON0b5/WAgp+//UWSLb3sPdPB9GL+X/emdhXoECjQCo0eMDHMtqRE2ih9gTmP9PWwVzoCae0mkEAJiiLp37oFBtrN2viH9joS/ST98BLrwrhAIPbuKGQkzhK06JwkARJM4uECzTZQKmiWDVKmrZIQgMVyXNSMGYI4nV/6GUbkAZMYtaZgrQ2u+oPLaLCvynM5niKBA7gxothIKwOn0viPA1nGNddrM4WPrzAGwWx+u7fZ/u7bfa+xJSgDV9q7ln0SN2meebJ3bs7eASAEoyJyh98cUbnBQvmDgTICZ6bePMaX/eC31abM1RQoyRABBI1uhc9PPTsuc4edqH+wWp9G+po75oPENO+OICC8vLy07gs3PyHOMd7Uzs4iTRgi9/zYGy/4mY5F1GYPMdancDBVyr82zOYQGqTnugKppmgAKsGxl3hBgc+IBIPu5zRTWU/XbGP39KamTDFcNXau6GmU9S+ksKQ8lmZDM2KKlhHRMrba4442j0UmcpczJrkJ8oSyzjOx5aCY3c1hgFkeL03TCNJ3ARUEmXTBy/lwRrVa7vgvYuRcSUpo279gygZRSseSK17cvYojRdyt9R3u36gIHoqDOGQyUIJXa6SRO0dMZNJ1EVggJIUakOGOeTzidzu3d1FrB0PlGRS1Zs9j4NNrkNpvxcD07Q0KaJq3xLmsshIgpBc22xIhTxHmasa4SxbYub1jygrUUVIjD4PPzJ8zzBHOSK6Uq32a8vn7B5fKG02luDhilVNRSEFNssqe8ZysNKnOWUkCIEfMUQYmw5qxrJIFSkoyJJWNZFizqXLYub1jXK5brFcvbVZ1AAmKcpeRQTEjTjBTFCYZCAshARcmAIyXRkp6tkpUlZ5N1oe/WgOWo64qR0bONfP78CeYwuawLStbMUEGz+XBp34/r2rLLeT5kILHtM++oMvI0u7YbmtAMTOaEL7yTNMNNafvcSk7JuLaGRy83eR7nZTFrj24ctLbOPXZ9d8SU9enBeONJo/HziPw56nmY7//ePaNM5mnPCLN3vf/Oj9vzSE/eCDs+xz4fHU/2nHbs2j1jhTdyeDl1q5vcZssZ389opAEYl8sFzL2srkX9msPOKON6o5B/p+P3fkx2/h3R0Rl9JHPeI1Kd+K+Zjsf7bXRPf/yt+vBb0p6e5em9sW1wA7xvDL51OL41bG7aRdfPWsntA771kf7v3bfHz+xzkzMJ3bmdaNKzvMqZer0CdOsUfvs8GUchQiZy+9jLmSpvo5dSNaqobRf3Z/VMplIqopfJHXGfPX3+hn/rfblkcM3t2tPptMnu5mXQI37+NXT0Du7R3pn2l6R7a+7o7Dui8dy590yPi473m2w14i7+zDUaAwHu0Xv76z0Z4Wvo6Fn3Pr+35r6FH4/YlseCjhyjvrbfH6H3+OdvQV+zPrpOKOT1Zf+evBN34x9Q/s5bXHrkTdZuGz8rRk232DmwzV4t+0HPlmFs4lCdwZAMMyEIdtJ1bQBkWXfrpk/Gf00WBLpzjOePI4/tferz2PsYVeYnTHOUTLTEmNMJ61mcNPJaUHLBulpQMSOlrfxKJM40e/2wfxasYvNnvMNkZAtKNp4v32+DH/3PjSPUxgloXzfw9/q+AQAFybrDzYlJr68jRubkBvvbjBcN35JzOyUJJOGS21oLUTBb8a/xjk8a1LyubWnLHHWcygdbPOjX0cNh5kEPetCDHvQgpRgkdb4IKxYJuRWqxGDVBUiGOVRYBoMuAJpRrgnRXuiDGj8rd/iBJFJIDFSSylDg/KJSGAFkJVAMLBWBKwYBzbkG1ApUkqwFUaOJu9FFmupOKpJCW7JBsBrge2S8ZEMwC74IhmtWUIPFaNIBkKp2E2oRRFUj5gMFFDMUMFDNeByClGKpKrSSGG0ZAEIwe7foH0StxiqbLOiE2CMQG3AZGcgcmcwo7e8bFTHWbCrdqO0FXJs/ghqqKOrvosDsCeqtZS98fxCIGZWLDpjv18k1Y+l2fFulb+/5I4gx9mlUFI9+Hw0Q3VjV++/bOwIY/LhMqX3PWDI6vPh7ga3hgw0QDYRauClBlnmFQpCyET6ThV7Ptc8znIJta8vKxUgwvEXfbQENMcCJYVr2Efe7Wf9umjt6G2SGY4CLOE70dRHVIF8QiHVPCo+5dZbZm8f7gIQ5t1DrgAKpxMP7tfE63mizxECt5jwggIDsropAARzFGMuwMgBFnQgJ1cBc1vJLFJCiGrPtveqci2G/Z/UieMdG6BxLtgYzjYcQEFIAuCgPUCVeS3YAQKuvXIVBbOe17zl7z21l8N78kpsr+btf14HrLd+A4dtwDNG9F/mbqDu11GqKdUCttjIJLbWsM34SAmRoxjPl/Y77CpvnuRlo13ng3f4ObZrE2CBnG3RtCE+wedmn/kzvKHF0zdZ4TXpGSbYSm1z5J/ta+sKsDqYuItbAqhbVq92sVRwKmuGSog6QIbG9trrk2VOM3bFM5YrCIhOYs20tDIRey7zWomPxxsxtFLLwudT63ni6nk7daQXqVJcBFkeqWnPnQwoTlFpRckXgqGn0u6Om7I0ADlFOPuPlbONur1TPdC1/CEnNn9SJ0Az10zSDa8G6LrheM0ouuFzeADDKBJQCEKREYitxpTyAlNtCny/R0EAKhJAmzOdnzPMEgHC9ilNGyRmVJcIt51XnVw3ZcHuqVo1sluczMWR0CSEmceBARGDJ+DJNczOezfOE05wkik55WHNG1uhAtjJBuuZHUM32vZXWCyQrSrLwAIQC1tJfOS9ShorkPFrXK758+YK361UMXCFgPs04nWdUjioXifNXqRWXi8wNMxBiQkxBSjmRlDaKKQKsWVtqRYwie5aakSshssjCl7cr0iQ8ddKMQaUUvL294O3tBct61fWWsSyvWJcFNTNQpaSVOcfEmCQ9d5olI6CuwVwqKARwqSicEahqZhg5j9eyYIWUQQzR1i6AKnXkcy2oKvcyW0bBZ4QoDr5cC7yRsZ+5JqOrEzuRZp8pEIcVtNJOgaLsaZZzQtJ4l8aja5UzhbSd9v6JdJ3b2SKyPmkZLtKzPsVpc5LIDrf9FNqxQpCyIVaysDnf6v4T/oGWMrzLsP2s56q8up11twz3CIAejTj3gGovN+7RaAjbu7YD8GhzamO0mbK2tn3cntG+be9UfkTmuOTb7vLy7Xi8w0tP7d4dbom6fO+NOV0X8Xrp1hB+a+i3Z1op0oqq5dSArZOTN5LI8x1vcnxpI0ff0b9u5+lWBr0zrXfm/Fj++C3pPQPe9+rfrzX+fk0/fisj/9fSR+XPxhh5/J7cl/K3LGlrS69ocgQ33EH0qH6tya8mv/gsqXt87aO0Z/Q2naYy+8frucHWaVQwmKSEby1Febc4Io8OM8KvuqNdCEHlnAqLaO/OkWN5F+NR3bG9an86L+3lgDs/HjAW4+ewjKEVpvAaz2HNJKiIDGrN4LygaunNWlmxLp8pwOsHsb1z/xr21vj35CW/dh18dA/ea3M8szz2c9TWXr/HtkaMaMSO/M8xq8PY5vi8vfX/3jjHNvd+Ht2/Jz+8d829z9+b43t0T+7x3/s5+5Znfcs9H1nL97GA70NfI2M0/mm8RrF9kAW7GMpswTyGW7FJF+0741/MXR5q41MeFpxTWPsOfV+NzsztOz2HrEQ2KcBTSlG9GXo4cZfJwaoL9L5ZexYY1MvmdUd5ucbkO9sjfTwm4wE+C3CAoHOmL0mQReYKICCkE6YwIcSCy9sFzEUywAKI0AAe1WstCCHELsvKGHzwmeEUodkLoGdOiAlR8RcLfAFInUQUs6f9fR9j6ucn28pAm2+Cw96YNt/rTEmJ4zZF/bxjCMbWFY/aLrP7WWA0g4badxKQlMA1Yl1WlFpU37K2PB5h+p/gcnLyir6XomJN75RPf9DH6eEw86AHPehBD3qQEqGD8axR5QZWGqAgZJk5VLAcIpKMxkglL0R3AKJ0j3EilJpRuSCXBYwMIjNUoBv0aCvATimiAfVZSwdoGlwQUMrqSgoFtOh+Qov4qbxqbeoVS10RaxADBc0Qb5YowAwCcilSFztVsJaKCAHAKkYMQATiGCPICejiFT417/pAASFNWvlaJEdmcfYB9SwkXvExJbGJjtzL+tic+0hXu96ib4k0Sj7cGhoNHJK/VdAGYGUQtqCDfCtt9lIrgMyt3N+zT7Q15vq0p0j19vcNDv4zH6XgAQsTrEeQwpfqkbnq0Qa+H76P3rmmOSG4/gAS/Wylj47IFLgxyvlexK59PxpEvHONvetpmnC9Xl2kQc+m5OfOImm9AplSQs+gwchFMgDYXIUQEOa5O/i0f+K4xQCKFBWWeVKjNlSpNrtVe79kAKUpd93BbjQGgcWgTlEMdf0NuJ4wA4EQYNHmZjgmNawPwMEAWO7/vk/be8n99KWZunGGhlJSgCnG1lZ3RDHl0oyXRJp+PEiJC4R+DyAGT3Ns8FGL7d24IbVnNWVa+IHxSmh2MAHFIxgBtcjeb8p1FZBga1hjd9+xoe99wOjWCObBvu7oZmlg7VljjXoBlcUxwLKD2DruAHlKCSWLAdycZZoBGLpWzFlLgQhSsKZnuunPtUw9fgzjNVvyQJPP1kQNWBjncQ+E9PN99CjPd+wML6WgUsU8nyRDyVratTEkIGz5p/Gcdu6G0EoLRc0yw5oOl2tBDGKgNmeDRBMCCRyTNENHSgJ2VDBgZZ8UhLLnXK8rQgotWrgbRsmtAZtPRkrioACKwjeYQKwljoIYe3jNUnKJAK6EXIq8Vy4ovEq0MonTjRjOzUghe9QM7E2WsP2gpbQYLI6yDGR1wgKJowzFIH0BYU4zUkyAm9vPnz5hXa+oZQWBMaWEXxZJ57yubwBfcD4/bTKUybrsqbNzzlhzFiMRATNFhFww1YoQE+b5BKKElE7yHqbU3sWar8hZsnosV+j7KFiWBZfLBbkUcKkIQdbSlPp5UmoByopAjJAiUgxIkRGwIK8rlssbGEXP7dIArwJCzqxliLREoEZkG6Br8oGkw47gWhAYeDpJJPnl+oovX/4ECoTL2ysuV3Eyejqf1TlokTlWR2gExpfXL3h5e20OVoSANcsaDCHidJqxZgazOWMGzOdZeDdYyjvYqwcjlxXIFRQqeGFc3y44zTNO04RpiqAUka9v+NMf/x+8vv6Cyhki+RW8vX1BXQtSfMLp/Hf44dPfqnOA7fPYZHNiKYNac9Y9KMAkk2ZyCSIXW/mMWisioZXDag4KzKjU38OEiMtV5sPujRFg7mVuJKuXOLKWLLw22F5RZxrZx9zmVYx4FTnX1paPlrSsV8anja+VUjFNp/bu10X2JTMQ44zZRYs2WTDgpm0vI6aUtCSXZY4hlMKS2QoqG0McecjPPdEmA5I4vnfZwnjqyHdHGs/HfZlk+/nR2Xl01o4GpT3g2Bs89uReOEOwf87obO6dV4Qf9RJTvtveGLHtp8nZXS6xDBXWvpVNE110+2z/Prxszdyz13hHmHk+O2dyKXcG4/Ebg4nwdr9+7HM/J74ty2Rma2LPuDrqPm6Gbt7R+L6OyOTJv2b6ngZDr7Ptffdb9IPvP+aQvvG2nT23HevuuNivOXS5BWqocmuyX8euPWol5+z7G/2Yuzw09nfs695eeG+8m3dtIBCJQcyCiACAUi8tHUJETFEysEDKhodIQO0ld61crmSjguqjEmBljsNEnf8YxjJiBV3XVp3TgobIHKst0KQbIb3Tun+npu91oItbKeMqeeCaLlTqilpW1NIzylimWzEQo5VjbFMnT0LnNV5f3Y7r6J3s0Ufe49fcs3fvUTtjm1u8x+uPxw6NR/rqmOXH/m2CDnYcA8Y2zdHT3pN37txzpLn3DvZ0wr2+3+vPEX0kE97X0Hvr4uiej66No3uOsMOP9uE9em/9fM95+hY6GjvXrcznHQdNRipZcIF2HxEcrKXOFKLrcuW2rpvzAwkGFWKXxUYM0uOX23cl/ZKSTirHa8CrOP2brl8BYqverLzhds7NYQboWLH1xcr2AYaDm65pbfb5u/1nDjMrvny5IGcp79myJYaAME8ScFtjcwgBgEDqyEjQQDdo9k7JKFtNlk0BRLU55+Q1N5wgEOF0PsvvMSGmSd5bk3N9Nnk7UzpvtCz+LZsVIOejXzsm16Pjth2TIgC1Ob0AFgQY9NiSe7mw6qTicBspopiMXVwPFcMJJDgbB8EyqGgwcy0gri1QqxRZx01vJzT3KYJiPPztstaDbunhMPOgBz3oQQ96kFLlnn681cVUIHBUPrscHrQ0SAdVfArSEdS0a7Zpey2SPUuK+rKCOSMmc6QAKooYvig5IVgjV8272HmHt/4RcD5ZLU1tq1Ysy9rK6MQYMM1JjXLm5AGsa5asDXFq/QwEnM8C4pdWviMAxFJnk7uSAGzrtfpoytEgbPMyguleWR8VK1MIohob7bqcs4u+H7JumMOM9t+/FwPJBdQRAVQAGx9tvkdm6O0Rmda/PdBiVG4tlb9cb6UatuCyB9A8MHKULtrTHkDtHUr8/HtDiz3TK11Hz7Jn+JIIppx5A8Deez3qt3+OX09m0PLRcp8+fUKttTnNWPtxMCr5tWF9rVUzOGkfZnWOWZallUmyseyBUuO78e/FnjsaNHx5N5v3plS6tdvWQbXoFWnD9m6bJ6fgynPlb3NQGwGz7wng65OBnV3ix7YH7MR4WwrM8wd7LZ132pyX5tjg6ShLERFEkSdqESTMFjldQLDIbYvWED6Qy4IQblO4jmDvOOa99b23Tnz/5CMP5vZ2PbBo2UVCIC1xtQVEY+zrxUeGmrEt54LL9Q1s2X3UiSbGCYESarX9xsorhS9VzVRmkT0GXls2tj62Hr26Nz8jeZ74EWPCEdk22AOGvRPl+LwxRbjnffbePeAEIkTNIBJjBDE3JzlxppGzPK+LkyMKcpZ1NU8Tns4zQgDWvGikVlaZoadoZlYHP3VIIAo4nc4NaC7qZGbZ4PwaZQX2YgywEksAo9QsE9VAKtayZyx9qStCIpxPTwIKwvagnofmAMsCnMl+JEh2qAAmkYcisxpQNLNXCs5JJOE0T5hjwjxNm5J+y3LFv/7rv+Lnn38GEfD58yf8/vf/hB9//Iw1r1iXFc/Pn9uZYoDl29ubO3tKK41VSsH5+QlPT8/qKGPPf9JSXDJ3v//Hf8CPP37Gy+sv+OMf/w1vb2/gItlNrlfJ0HK9XrGua6u3LtljZpWnFpSyQjL1XHG5vKHyhPB0RmbCL7/8gpeXL8hlQVEjTwgB05Sw5oS1iONaCAF/+7d/i/NZIujM6GTnW+MJXHF9eUUpAFfg8vYFf/zjvyElObdijDifzyAKeHl5xe/+5u/x/OkZlQu+vL5gWVfEMOHpSc66y2VppcmmpwlTmsAMLMui2SiEH8xzwpcvXxBiwPk8IaUnlCprN8SKlKQ0VC0V6dMZKUZc397w88/iwJPLgnW5opQVl8srluWKEAnPz2ecfjgjxTMCnZEm5xBmWQ5hfFLOGnF0VX4bAOaKXNaNgcbkBpNherktQi2EeZpBauDPOeP19VX5hToWQUo22vqslbEuZePcSrrmbW/4EhREkhq71tvoei+XjGcDEWGe5+aIbNdsnHidDGf6hgHufn90flE254HI/ttsfeO5ZZ/5snV2Rt86ZPffff/2yBsRRrnWn/9eLto7E7xs6K/xZ5HpRR8xJPUzdltSZcy+4tvza9LLMb49L3P5Z/i+eJnUZMY9eWOU59oZo/fZ9+18GvrrZSvrczekhM1z9vSDIxnmL0nHz/r/p1ngt5z7r6Vv7dvRfbbvpHRcL4+5p49t2wM6JnL706/nMep/D4fwz7tXhvhoTEe/743X79/G2wMhRCsDsdMWkQQqpYg0JYDQjK8UCFOaGr833dbr9F5vNwzLO536jMmep7RzgCSAJARCil2uXnNGGrIujHPkzyhzzu/YCIG5oHJ3jFnXBcvlguoceSTDI7tz2OR6m1fRV7pTzq0zyr338te854B9RxGbF2DvbOyOAsd66a2Oa+tgr82xP5v7GRu8zvaPBTHZWrP2xoC5exjR+JnX9fbwr4+085ek9/a/XfOR8/89R59v6cP3x4d+O/JYpP1tNM7VR5y/RrnJZNteDnWL93h51OM+9rfJ9lucSwApK6m6OXNAzVnCAqYkgMDOQDnrxqw11rdpmjZ7rusN5uAcbsbejxSPJ0rQ1bIsmKaEaUp4efmC5+fnDd5rc2F7PRCB6nY+rS/z6exwFaizB2NZVzDVhnuYXk9UMakuQkQouUhA0ZNkBf3llz9rQFLHFWNMWNfs3p0LJLBy0kALRrS+2XtIsQcZNFuOZVpuOpA48sAFCErwlARyBBCYCFNKqByQs8noEk3JXKDNtfnIuWCaBKPIqjPL+zLdlDT4Qko5+cBIw4Me9H3o4TDzoAc96EEPepASs5Q/IgUeLHW6GSTlVxVgLZKOrJzFugFbTOEDOrjjI1fXvKrHtJVfCCpIn3AKJ9SaNRp5Qa0ZOTOIK1a+Anxt3sUpWu15dSiIIlDJZ1UjoATMCK1PM84nalkxmBhcM0ox44QMVdKzm3LMKtSR9g2AAsWctwqJjdtAH/vdA/SWCaQJluwdW/p8AbeR/n6eDdgZM6HM8+yMJua8IAJypapCKrvn+Ew1fTwxBPUY94Zs/1Oj7p3BW/o4pr/syume44kZ0CyLxK0C00GlrfF8O0fWpnfW2QP+R8OLd9K4Xq8A0IwupggJKLYHvHcFzwOa47v3fbB+7Sn+HgDzmQQ24By6gphSwk8//QQADXzxc+INPOPzTSGV8Xfjk89IYfeLUbTcrNMRTN20TbeZeoi6E5J///Y+xjlhZpCrR2vXjfO3B1h5QMB//peiPRBm3AdbJbw0QHOcOz8G34Zc83EADdDdan4wDUjv6dUtcr83KVmsIiR7lu+P3zN+jOM68/0ZjWO3ZCDuLZ9hxmbtyO1VjbD1Zr5Krc0IvF1bdp1kxZpPE3I2XiTgfF4zSEv5AaEZ6UPozlA2lFq7I4V9Zn3rc3lsXPNjGtew/+xraHzWHsjYv+/8Ssa1NXx4sNnee4yaDS5odpha5Hzlqlnc5O9AQEzGO6TUUQxSYibnFT/99IpSVwA9khdaQofIojITSq06h9DSQwXQMoy2NqARb5YliaFnuvWfua8uZlBMoCDZh7gWZHXgKExgJNQCvF0LwGXzDkMAYgpIISJNE+b5JGcEghgw1gu4EmI8qZOMnB+VWe6bTggk40ppwssvX/Dzz180Ilgym5xOEz7/8AOenp9RubaU0sta8PT0jOengF9+ecGyfAFRLy9yOs2Y5zOIgC9fvmBZMuZ5wvl8QimMX768IaYV83zC01kAt4qAXKXk1P/x3/4vKWsZRJaSPUOYQECIePr0GU+fPrfMOSz/Q2WJSnx7e8OXn/+E1y9/xuXtpRuqIE4kz58+4el8wturgJFxnlR+YXCpiCSlm2IKWkpKsuvMp1nLXK0iY+gmIwDTXPHLyx/x8uULLpcLUgJSCrguFUQTSmb8+aefkNIT8hrw9lpAoUKrr2NOMwICUIApRuRlBfOC5fKmu4PUYZiRUkDOC/7l//4zzk9PyHnFmlc9o3vZT3kn4pgYKSJq5kMicRQjAk6nE0IMmCcBSylIVPv1reC1vKLWX1B1/NM0SRYiBLy+vbW1yJVRsqxPAmStxaj8jNt1EjWfUEruoC8R0jRjPs1IU9IU6nIepDQ3+Uy2vmThmGcDx4HzGY2nGN+IMUqGxgaar7gub3INA5IZSErfjAa6MQLb2gTQZA6TDz2/8jLy+dwzh5iBtRkOKTSnitHJxjve2pnm+a595880A7y94Ww0SgnAnXd5seh0bMIAACAASURBVP3uZXp/n31/JB+O1DN/bmmU5cc+7F/ff+8lXGkjb43j3cqAW7ndrhkNM16m8W17mdfrBeDt3Ni47XdbF1629A5jvk/9Mzsjtn0Y34sfnx+X13H/0nT/vf0mXfirokM5969kMr61f3v3jTqRBTQYD9tfg6Tn5K3+7de57YU9vuP7PPJE0zvvrcu98Yz76OgeL7e28UP5SNjX54io4UvX67UHrEQpC1jXssELvGEPQCvd4dseZeLRmdzOlJyzZKZLarzVTC/GI4zjjLxkbwzLIhluOt8nWCJDr3tPKYHdeMSRWbMxkHeoAkQe6EEDwG0J6/for33PHZ2new5dXj7wOM0RHmM0rt1xDse94q+pXFHXjj9ZoJhvw+9lr3/Z90fyhCcvR/l7xvPtfyTdW3Mj9jH2d9xDH12/X9MHe/5/NDL5Z5w7z9dHbA64HevefmHe4tnruu4+fz9YM9ysXePXG/zb3W+4QK0FdVkNXFG+S5Jpk7sT4J5uYLKm/0yuC+p4kTaOP34+/PrymMnpdBadfFlwPj9DAnme3NlSsK4m+4v+n9elvRvJPh8wnSRbaa0Vwfi9ndkE5LJKgA8DRZ1mTCe0fk5TQq0Fy3LBuq6Y56npHn1e5Zyyv81pSNaJyo/E6vByq/N4LM3el2T1F2xAMJsAogRwP6t7MJ8EUXEgKQNccwt+nOcJDJbAF2Z1mJE+2zjXtSBQFGcb1Rtyc3YS3Ec+72udGS2L3IN+PT0cZh70oAc96EEPUhJv5gqLuGeukqqcCIFi80AGgBa5yF2RH8EQDz54IJvVsMDwSlx1AqsYKCtDBSnxKCYuzaNZBCJxYImhO9yYsCTjAIJlSdEkNIGCGPNCggaZQ3ILmjBW2s+cM7iuCCEiqAHPanmLM07P1ACgGZZHMMcL4V5J90A90O81oXAvA4dXhLxC7Z/rvemtfRGc1ZhoEVwpNqVkm0VIVgM0dw+xB1nsWZZGXQxFEj3f18+erumVKA9OeFB9BOS9gnd0j//pnzOC+vZzdKbx7e9FpxroEjW6re60aX0e38UWoN8H4UcFxY/brxv7bHS48eCLgTF7oJx/jl9bJWfEQDfgzR5gNBptjowLdq0fwwjcbByR3Ofjexz7cER7AOARePWXoiPgYQTx+u+3oM0ILNz2eX/f3++DlUnrij8pqN75rxlO4T67NY717/nm/Y3gvn/vR/2Te28NP3IbuZ/vA2OeL/p1aOeK/CTJzgNzrrRSYmYEC824K8CH34vYgDw27r62xzHJ845Av3GO9sboeaC/f2xHj+Pd+R2BUgOkPAA2PmvkNf5Zhc2Rxfhs0X9aRg6AZQuTd2FrS/b9siwAZT17LaI4YEoTUpr1nQFEEVYSOwTpY4wRgSX9rrTd097raMF6hluZDJuXnLNGKSuvrxVrUccYFicpQgBD+ivp/KNEWQUSgC1FzNOM8/mEGANOU8Af/u3P+OlP/yKONOe/x/Onz1jWF/z8ywsu1ytimPD5h7/BNJ8RQkKgCW9vC2JMmJOUZaJAeH5+almnbI2VkjFNE56enlBzxvrvPzlDGamBaMH1ugBAc6AV5wlCQUDVdyZlgBY8P08SNQbSTExqRIqOX1BEZXGeDgrYBeYNGwnMAGVMlfH8/BkBFaf5JKWb3Fk0z2fM0xnphydY5FnOGUuVLH5MU8/iURmcM4grJgUXi2ZBq7Xierngly9/RlmvUkarZlCQklBTmPD8/Ayukk3w+fkzns6fUKu81xgI0zQjfgqopYBzr7EOlhJUsm5knc1zwrpecb1k5HUF1wzUAkJFIAYFychFxE1mLnnBdVnBVZxNUkyapcaAygkxTigpo2RxXk7xhBKzZN/hVaLMDThWZ+2o9e6bLDjH5g8hKcYTnp56xhTv2GjO0LUZ/FQmzxnknGDNscTLChLhzs7RuLSIyi4XpcYnQugl02o1mSIikKxXL7N4OcPLuh7o9oC7z0y3JxMTSUSpd9wUmbcD/sbXvNw38tqRz4489b0MDyN/32tjPFfvnQEfOfv27umy/H57R30cH2ef+/N9T84bnb7H5x2dTXt98vqCOerZ56OT+yhL+nbG/uydnV4n8Nf6tbk3jj2D3lEfjsb/ETq+79uMhf/R6S8tx/9a+p7v2fOZ00nKs/qIdrvm5r6ddkedak+23JPZfV98n+71+2vGOD7jSHf1Mu74/FF/tueUomUkcdt3P7d2v+n+lklv1M99n0yWZWaE2DM6+D76oJMj/ujH6GVv+QfUNUNwsX7uTNMEuLGGEFR+EWzGMIG98wzqQn7El+/xyr3rRrzi9nm3dHTO3cMDjto7WlNHfd7Tx4/2nv/ucF0Of98bm8cAR335I/0f+/1b0LfIH/foW/Gcvf7ce2/f2qe/xNwe6fnf8x17WXhv/vbm7R6/P5Kb7OeRPLcXLOmfNway9XNIZTrwcH1p3wGaLcsFm+3JuOM4t7x4Oy5/ZozvaTs3NmbR46RsZ9bfTYa0Et7WdkVUJya4QDM5JwSHj5Qcv6+opUgwzDSDoOd9XgGoHUUd9sOk+FWQYBELFrbSfFZ21q8LK8kk49P+BMPyccOb/PibzG1TTtSyMKOdryoza5ZfKbotgbuGCTUcqZabuZeuCZ5jZbRR7dkVIdi7k2stG357Q02n/OuWEf8j0cNh5kEPetCDHvQgJSsxQGrEks+g0SrOc1iFGcEwJbreK+YGLIyG+5wzJO0gafYWAgeNMq7SLqsTiqUyjMyS9SUAXDKYMtgBF5LlRoxzFt1K0PYpaDSSAfhqQCBL/++dVgiFCsAZCAXigQ5APYKIAAqMlAiLphMkqEGP9wGkEQzfi3j0zg7TNOm89Ew8YRCwrS0T8vcAGK/ItKwAh0qnCdLbiKvenjgcBfeMXmpEDJJVo/RBDCJxRAL16LbxmWM959Gxqtaegcb32xyA3gO0DUC3a+3zvSiHPbIsLd5YbGCXb9u34fu0B4T5zDiitMRNf/ZAE/9MIw+O2d+2z3zmHDOEX69XEPWSAmMf23zVbTSIGaz8ehvHO0Zdj+/Et++v23MIG9/1e3vpaJ73aA8I+d4A0F5/9vp1e837gOLYV6/Y+jZtXezv9TEK1Vm9IQ4JrQ40QY20DMs8YO2P7//oXYxG0LGft3RHuSVq0S83IxjWTQhSjqdlwcA+qCkOoJoC1/KoMbS8oDkSVhDZGjWnQkmTa5FNDcQhPXcU0G9IDrWe3hneNuvC+N24L/b2ifRBM7E4PvMeaDauTc8n/Xmz7ZRKAKQz18rosZsrBthK6MhZC81Iw1w1wwtLtBFblrIE0CTXcZWyNukEsCZHIgFjhLfJOSRrEA5MExDF+tfPGUapkuY31KiDIISUJF0+BYSQEClJ5FlKIqdQkKx1+jNFSfc/TRPmeUIgxhQrQAWXtz+DLwziV+T1bzCfz5gmxvW64Msvv+D56Qnp/KQ1y6UOeUqajSYSpllLAcHWnJx5f/r3f8eas6RVVr4pkXFB50Ay/Fl2EQMemcVBCOmMaTqpo0ZCTDMoJDACNIGPfEYMkDo5gTU7So9QrsyAOvhRc2AT+W+axTl5nhOqZhVhltTS67qCiLCWCnFKIiAAcWJMlBHZnJyBSAHMBev1ijcCiBnTnHC5vGFZrliWBZfrGy5vrwKiqoxG1MsOnU4nSIm5AEICWMutKeDGGnlWi2THkQxDBTElgCuqzmNMAWVdUXLRuQeeTp8xxUmy1NCEEETWBFeEGFByxqW8Ya0ZeSmIqSIGkWtLruBICKSDZeWtDMQQQRNp6uvQasrLPAIgxjydZI0mccIhNZCVos7hwafw74CtOMwkdQbntkZAwTn/Ctia4tQd41nkcmbN7lQlLfi6Lo6H97Jk9lM+JpiTnOxHdUajXvrCziuf2cX+jZH+xp+8wdBknL1sJZ5X2jNHecX/9LzwPcPJeKZ5Z52xrbH/ezL62Pa9530tyTu5/Xwc99i+Ac5758NIXd7byrK+3fFMuifv7Rmm9wwYR/LH3rq5N1bf51EOP7p+XFN78vFvR99fln3Qt9M9A+SvbRfYlkw4kve/pm9Hetu4lr92TEf77N73/tm3+p39T8/Pg3Zu9iKguNMWKznSy+w88Vlo92R0z/tbRrR1UVkjqjx+e1YcZQrr74FUByHFGipqVplY7yciRCKVc6ljCtQNwkB2c0kqI/hgobDLpz6qV3/0mqP19t5a+Ejf9toZ2xrPE/+8e+fHntH/18yFX9cmq9y79z5ucP+aj87n19Bfos332vvIufo9ztz72MT3pffkxPHar+nTnozl5/Brx3nE9+69F/t+xIv8z913xox1lRLNFIa1XVlK+yg2XhkIqksS0cYBxs+Dz9hkc9Fl216OELjNSj7OnVGtDDBaEC0z1GnEMHlgSpZyGAAYnDqeygpQhJgahlSr2i/kYVraLyKGSfFwQkqTYCXMzU5QuaCWohlEK8paNINtz0Rzva7t3BCsIbWgGgkIgraFNme+VO2e3qIuoTL/wTvMhDZHRKr3sbyvWjPYMhKDUApjWVaEQC7bTa84IHaiAGKAUeVcpeqeb2e1BUb1zwA7Ax/0PejhMPOgBz3oQQ96kBFVMEQ4q5UBFVwMj+tAfABrKn+AwSoYmfDpDfhAd6bZB1u1PWIwk0bKWo1KRo0JpWrJggpUsNq6xLgQYwRYorAlukbB6yqRyYEipji3dkOIIATkAhH0ELQ2tCDLrAJfDBHpPENMdYwKE8gqSlnBTEhxQohRjE4tg4NXCLg56tjYl2URr2o1XNTKuFzeMM8nWJrEmKJm4bkFkUejgMzhbakiE3rtWlEozJBo4JEThhkIMbR3Uqu+a8s0w6bcCHADdACo1CJCaw1A1DkwQ8/eMnPAjQcOpL2evcH6D2zrO9u1Nge+LVt3XjkZFTyvrMm/qoBST+e+ZjX0QSK5cslIJCVCfCkC3w6RZKloDj+DMcjTqIiMBh9fb3fcO/as0VDjwTuLsr5cLgCA5+dnzPN8E9UdQlDnsv1a9OMcd8XXjNRQRaf29eEi/bziKeOy+esgo/VHlOHa2rS95Ptx3zhAm3s/apD6GnoPaBhBq3Ect/2519Yt0GfkM4NYpqfRoNjb2duLW15FptjbM9vevE33fmRcsu/8mrEsGLYu5B57/k6fdufDHDOoARAAbcbUxxvUCcbmTp7dzy5R6gkRYIlkMh4HQou+kWiYApCAEyDJilHZHDQULGjOpbTtuzkf7WQQ+ijJe+klAkfj3IbvcB+jd+wbI7nkPvT3sAM2ex7kP+/vm8QJAKOjjPS1lixZyTQbmz3anDJjDAgx4e3t2nmBLrOc11ZCkCggplkcoIY+QqOPfAkQmyNmKacUiJFrQS6ln3/qUBXTjGmepb75JI4qUzphCjNCSK5knOwJy7QRU9Ta5OKES1yBepFSR0+fcHl7wU//9ge8fPmCf/7P/xn/+E//CZ+ervhD+BN+9+Pf4/Pn34FCAiGBKeG6rmAtvTRNCZfLBaxljAy0+unnn3C5XBAo4JQmzGnCNCVx3Cod7OvgYJ/zylKDfD494Xx+kuekuc+VOjyA1PED1NYHKMgztHQlBl4u0yOAX4oTwgmIE4GrlM1iZpS3NyylYC0V18sVay6IIWE+nTBPJ8zTWTLKMMMcrMQpY8WyXPH2+oJpivjzz3/C29sbluWCEAg//PADmAnLdcG6LpimGZ//4UdY6bR5nhDChMvbgte3Cz5/+gExEpbrisvbK5gZ05RQSsHl8oZcVnz+4Qc5P2pRIJLwdrk2Z49IEbM6OOX1AnAVWZWiRvglLPWKSIw5RUQSJ5yUImLjo5Jimk1G0p+VxTgnjmIAr6Xt5RCCzr048wWaEOKEGCKWsqKUqzoOVZSSm7O4gYrt7B6cYsXFT0pGhRDECYcC8rpuSrgZrxEKCJSklJOd3yq3WkahbI45TS6AOtXvZwDxPMz0hxBCy6ZgfGzMOLPHs4SH9LJUPhOJyR9AP4Okb52neLnBrjkybvmz1/adZWjz14zjNXrPYPY+qfH4vat22hzP7lud4radPSd0/3NPNDKHqd6X2+vG/o0AvXf4t/fYyqfoWrc17sdRqhgXvJ5x9Kw942jr8B1qa9f1DQRw+Q3BesJucIL17382urdHvut4783rXZn+1+kYu8/TM3m5Lg3/OMJU3m/rVma3n6O+5ulbnvVd50JYupyFo7ztdApGd46RPogjbgwSqOMz74482HjBsiy7uvuIH4QQcD6fQURYc8H1uiJoXSaTybzx8agdG4Rcp5H1wfCPiu5sLv1b1xVTCFquktu4CB1zMAygj834McFnC972Yavf3cr+++TfczMKt9cyrLf2f+O3/a82Ezdyh/7OPXsP3D33+PtRX9vYWzv623BGtTZJdJLdg86P62ia9PCTM4J0HQ/tqyO/jc33r/fL6+3kLtLZqPvjvhnP7pf+gdi8mMp8s+XoDo/01/nxAMf9u8dz7vJ9lWZ3n/1XcgYejcXkh11i3h03M7t1ISNv+zUEty9gV32zW+2eXORl9qPrWz+HvWy8qWdAkXsqs5bFZS1nbJi18nruwYoUquicoes5N7wCt2vG46ydv96ep3sBXwBEh5K89QDLOZSs1KyaCAJFILpnk1gPEom+mdcVAOE8WyZMVrx5kWy2agMIqpuVUlGzlGuW4B1CilLGd1nesK5Lc4AppWJKM56ennE+n0Ah4nL5EwA4Jxo0h9v+X1+DNj/eNlBKbs48RJ1byjkneqPswKC8QoOjQwAjgCpp0LPpS4xcMpbromUNFcth4bFWupoByYpaCcwWuF0VKxA8J4UAC2YDpPSdlbl+0Pehh8PMgx70oAc96EFK63rFsr5KpGmagWoGr0nS4mnUKGoFVSCReBeveUUBg7R+ZckZxdKOhqCGxh5NypA6n4ULTqczAJLAYzalHjCgWqJ1NDo2RJQcUcuqSobWrSSIAUGNGeL80pWKioRSWCKHWQw2nz7/2NxBQokotSDNE6YwN3BeDPgZzJKCv5SM17cF0zThdDqJMVn7nHNBLgyiKCkWW/SrRYKJEWuaEiJ35xpmwvl8bsCKgcMxRDAdRPg7MsXF0ugTdacln/ZejJwR6lwPYgar8YCcUkxqGEs6j2JkiSq0ZlTeGlFJXpVESJNlHTLAumBrgJDfr9cOYI/OVOZt7pUxA833gD4bq6/bSyRzerlcGqjl75FGnVIEHYT2YV1XrT8uly7r0sCYFCNi6KVcep9IMu1wcd9JFPsRaO/HZ85SsmZ6NK4Zj/y7BrAB/fx33rhjRiebo7e3txvgK+eMdVkxTRMKantmM5pq/8xb33/ex9L3djdMmcGtv6/Rge4oOtKn2DRDvJ9n+9y/U/nno/do+Pnr6SO4y9eDzAfgGxt/2H+GV+zFaWPrQNN0dZ3nMQJnb14MBPAPtffon9sMUq28Bw3zLv/kmVultTc9Pt9Dph6t055VBjigOaK09bHNMmDrwAxpck3YGBnANKxvuw7NWUPmNgIE1MLqKCNtrnlVdkEC7GgJnS1WaiDVWC7IUweMG2Sr7YYY1PlOHdEIveRazgJNqLObPJrBuTg+IOOy8j6l9AgjQM4rZm5826/TsdzUDdgPMb6Le6kzErJkjAGCnIHO2FBKRSDh77L/k5y5VUoDpaRlBEtBLRUBASmFbiTQ0koCUrnye+jvjIhQS0HOC2pdxIm2MkKccDo94XR6ErkmTggpNUeE0/mEp6cnPJ2ekGgCF5bosSDrzfYiII4NrSRXtajeGZ+e/ga///0/OwfPinl6wuU1IdEJ/9v/8p8xTWfktaKsFXEKQCB8Op/UUYWxLFf88Q//gpeXFwC1Gd/P84Tn0w/6TDEG+VTGrW449zXeMn0QgTggZ+H/KUWsacE0CUhly7LxYhYewJXBoYJYy1qCpZSjXstEzUECkD5Nk5Syul6uuCwLcs54eX3Fly8vWNeCT8+f8HQ661qrWOsVMSSkEPHp/IRpmvB2ecOXLwtSirhcFry8/IxcFuR8xek043e/+4xPnz7h7//+97hcrlgVfEzqmLKuKy6XC/79j39EqRXzfEaaEi7LF9SLZEwJMeA8n/H29orr9SrrME2dp8aIslZ8ebng0+dnlAKQgnVrKSjLIll0wFi17NXnz58AJKREeHpKOJ+57b3LckHOWcuNGZ82xw3JVrWuC0qWvSOZh1KTLW2hl6zZklTerEHKbDE0a2OkxhcAIK9Z5RhyMmtQg1tWGSIC6A52Oecmh5jslHSvCNA9I31KmzNXrgVKYZRiIHfQdR2VJ/Vz2ju/GH/xwLnJB5fLBdM0teeLc9NlEy25LIs6sPUya/77ztdI+WF3YrWzEtg6tvrMk3s80foJdZDhJs8bR/KGrX154EgsODZ0bQ2s3pB5m97en23Sj1uD5rbNrSwLWDYgAJs5tfu9k/r2PitNJiD7smydPH2f5Pf9DJl7cpSNlZlBQcqr1VpRuGJKqcmJXRZwJWRtPbg53pvrGwM63bN/irHEG5izOa3H/SwSx0Sie30t3RFz+6m1c9tvaUN0RruRjhxPZHcdyU1yp13ZDd9sn2xuu923vYnmMPqV9J6R+FvI63ftOdQXYAwRuRQQBFcR+c9kT28sxP05d/sopYTz+dycMI6cEt+jI+Pp19KeA8fm+8pAjLJ+B/Zq74TR14Bdx5Wx5KU9w/M2w118BuBpmgaeus2GNn4HAKf5hKfnH8Qh2n2/NyaC00FYSlZIzyXrn+lrwncJtVTk0kuGL8sVNUQEEEqRs1wcGuw99LIa2/dnesaWB/q1588W64O/ZtS9t0bosLm3MGuQG/WiwLo2WbUj9nPFEnom694CJdRJxmcpM8xr6MfNXrAl4s8f93d1hl/VbBpnCUmyBBmOKP0TJ+kN32p9sjcr5wYxNjEeLSuD6ktBddKeG0EmwPC4mzPbfUa6dqrKf54Y3OI0TKP21OZs6COB2mdeBWdCm9fGW+w+e6+uLeufzX8713UchP2MsX6swFYmaO8g6HgYbZ6b3n3QB1VOb55zz9nje/CyD9H4/t0vJtdjs99klYL6PmZYcEp3lKn2uZ1xQNfVW1v7WbZGXnBE9+bIt+H5ByA810oKG981+fI0z4KvWI91QAFor1HGVSUoB9xK145yMTM3/cd/5mXEaQp4enralDg0/cP6u8VDOk4LoOklIxa2ydBSKyqq6F8UUHJByVl1V8skE5CV58UQkWIUTsLAHAPqLBlgc1lVBpDgmpILQAnTLIHDKSblHcDlem1ysM27/KtNHyQQcpEMqrlkZU0y6YLna5Zp1oz6yueYqTm1RAqA6mJQLDgpLhmsUkCcEacoTj7rFeu6AFTwKc2aoVX3OqljDaryNkKBONesb7lVHjC+YudjjEEz3ZCUq5pmRA0MetCvp4fDzIMe9KAHPehBSiFNoJhQKyQKlsUgFgPAQWrIR0pazqKplYhJHTVK1khsMZhBAWkzeokjRFd8LRVhJxGSgZ55xgz1KU2oNYBAqCSGrJyzZGNRoRQUEMIMIknDb17TYQoI5pihn+VaxCkFjIKKUjNyXVtppGmaUAojxlkijquVaZpQ84q8ZKQkpSYCAfMUEFNCZWm/FEt/7zLDxIA0SamAWkurM8qVmtMH0LNHtFk5UFq8cmdgjykCPjuLGSxCkMwAqFo7tM19BxirKToK1JVckELU8lYJgUmir7krEVGNMMSamlKhEYuOksc4h6mmtDByXhXU3h/fBgiBNwTQRkkyhcXAG2+AAbrS443+uWZ9Prd5N8cbiVCXvi7LAiJgWa5N6S9Zo22dlVzWV39/zTDk9Err3zT19q3v1+t1o4Ta93uli3qpka3hyebIxm/OR/b5aLACNLWoKhuW/lPat3EBVq7HfyYYSr+uZYtiS6u5NSJJqRbrh6XttN9r669Rf/fO8GGglP4umUBsrfmMQjZ/t+vqW8me/T3JG+OPn7l3n79/c4fufVv323rNvd1bY8SeocHXG+6fSVtjFI69V2vN9/O9ZzfzziYjS0ftOsh5AKQTbfhmFc+9DvzY+KykjMvcckT2ara8BjjNfU/Z/NpZwobmwZxWnPPCQb9taHZvZXHuTFouyBxOmfua3gDXCnIQ9fXggWMiwpSm/jnQyhVux8u7v/vx93nhxgv9sgmUMM0TSilYVgGr5mlGiAZ6MtaWHSBqlBipMV75pp7nXBmlroCWbLJn5yzzy2oIKUWznBXhO9M04en5d5JBJp0R4wSiKKWQENS5tjuofvp8RoxACBU1v2ApL/j0+XfKD7X97DK4MaOsK3758gXL9arOpAXT/FlKH00TCJJCeZpmxCkhxIRlXZDXBWtesL4WXC4LrtdrdyZWGeFpTg08AleUdUFBd0jjUPsZLTOGyhqhJS8FvY54wLos0s8qkcrTFPDp+Rmn84w0yRqLcRbZqjKoVgSuiCDNeFJQqmRYohDAlumNFPhmRi0Zb68vuFx+QSmrzFsuWK8LAgd8Os9IlED2n0WA14o4RQXIMqYpYFkuEm0XgOfnM2pNoPCMWotmJ4q4Llf89NOfZO9FOTMul4usu2VpMlDWfUREiCEhRin59fL2gpxXIKgDEks2NjF0S/8oiBxcqzlvJ6QpiryL1Ba98YWiztGFi8oM1NYQQSIo7byiIO3FYCW1ACCqbKCGGpWdc+lgbtuTTAiszigRSHPClCKWlVSuXJHXDAoBT0/PzaHIohkvlwvWNYusrAMJQcDj0QFFXlMVp/BccL1eNnyh84cOzsp8dWPdWOJidMoZ5RzrT4ucV3nU+mXXzvPcjL2dX9lzLdvgnjMGaR89r+tn1t65uvf33r3H93j6OsGkyzVBx9XlBpN9/HX2ec9+szUm2GdHzgS+9EdKqTkrmSG592csuVlh8w5IgMCePO7lly5T0kYGtywyI9laE51KzoxSawtOsKn1Rs2q+o6NyTvYmpHjI44BnuycMtmklQFWvnlEh4YmJj45SgAAIABJREFU+hY3jJYf76DJA93xq59zn941MB498OA2Rjeu7j/r1qDn97X83WUqfw01vt3+99UTcndn35mLj64xb7Bsa9rJcfIcwVK8nAu4MtUHJQlM/7Rz0c5Li/z/6Fi+dWz37v1IG8To66Lt9b5S2urwXSdgzEbon+fPB29Y9eeVD1IxnmafCQ/JoFgRopb1VAzGSmdun0WtNHmtKl+5bI1tVIR2hgFQGUZkFs5S3kKcfUNz/vG4zzg2M/CO8z1iBKMx3cbt58h+99lOG77A5ogCwGVw8yp0QN+nRn1Lqn6hFxAApNQMqyaHV/83manXkR+P9pfMKZLUwV4zlZHJs6rTVOvR0L+WucCry16XMh4z4Frdmcna0jyo+kzDj+DnxS3qjX5H2Dj3bIbs+rL7vf/dbyPafua60sbVNpeNjdXpaNC1Wb8kp4uARS8XZ4f9zo1rzuu4FaZD9q552WHsuzjx8P4k/IXoQ/zL83Z799Cx6C8WdKjQ6YYYBLKyroq2YrN2WJftVmdn/cX4gPx5W/708B18I3mZ1NozHiJOFv2zy/UKABs+1pkGwzIpi57FqDUARfhrTOlGXhydPjvvquqYKM47vpS94dTG872c2/Q3xy9vZUdfplW6zqXi8vZmEyJjfbsgpojzKWKeRP+2DDSvLy9IIeA8zyITR5IgZJa2Xq8S2DzPaWNjEQzF+ikZk//u7z4pjmHZ29Hw51oreAHWUpHMiYaBkmVOlrygFEYKhGlKmKcJFAJevrxiXVeRP9KESbPfWqlyEEumWQIQApgjuABippkwzQlTqih5gQTVdafLmJLILpoFiGJQPKhIhh11fBf8IerZ3mW/NMmZND0cZr4bPRxmHvSgBz3oQQ9SSumEeRbhSpwlskQRO8N/DeJoAjPgQVPuETWlSQTOriSLAFc6yBkCKAYnhFqZGMmAwlyRs6T6D82QrwnkY2rXWHQoEUBWgogSCBFk5ZdCBMeu9HrFufjyP+p4U7lqHWpJf29AVVBBWgwUod3HXAW8EPQKzSseASmJgOiBhNYeRUxJfto1Pl0w4MH9Wxq/M6HdhOCj76HKggioXZGotSJvvORlzpdlAcdJQR+Zx0ABAR3oqZaCPwhQHHSemcx4Apgwu3XyEBBrdIqx8Rl5EGek8TMfHeAVmyMQqa0Jp1DZ7wbyb7LgMG+BSP/roHzuOSl45WosozWmf/ZjH+fB3zP21xuxfHTH3vPMUMvgVtLMK9T+nXnnnB4Z7OdvXKt7f4+lxo6VaT8ne9uggzTmGLMty7UH+v1autfe14DL23tu77u39/WKu89n3v/8fttbpb+BLzdtbx3Ptu1KO+/N+/j9/bnz7R23u2mzCqC4D8R/y5oYx+RATfbf3xpzbE4+/iS5yZeg87zjPceW8ffxOt+38f6PreG+N62N2gD00M5lS3kcNIrM5kbGAi2/VmGOAlY2yaJoATOQy61WGsnOG8n805pFCBItfX76hOn0jJhmpHTSDBXiFBjIyh6q3ACJ4AIK8vIC4IIff4yI9IqYJsSQ8Pq24A///v+q44SU86q1Ii8LSi6Y5idM0wkxTLAyllGBnxgF0FlyQdGsemspuK4XlLICKLo+WOUAt84ZELNCamvMoj3vvSaTS/QOMGcEIkyR1GkW4HJFXjJQI2oIuLxKvK8YepKkQy4ScV5LMUYP1G1Ea2XLTFJwvbzhcrliWa+amU/Ww2k+YZ6tDJTIlkHPfuMZOS+4Xgve3l7x+vqCaUqY5hlEwPW6ikOnZp9blxX//Y//HeuaEUJS419s683KqllZg2ZoUCOD1Xz355llPrRMTKzzaJmYZO8VeDB0I9cp+ch820tmmDQZy87YqhmKuPEPLXEoN7d+BEW7izqz2lnrz2rmnu3GMsFMUy+9tSwLcu6yVkxJ1iqiew/UnE+sbQFhp0F+2MpRezyky/DUgGgrETHOl/30/MeD1CMIzo4X+Gs7z+uyiO/r3nn1LWf2/wi6d67yYJi7JWGQ27HuvzcvL5tu1qNxp2ZQ8A76oywwZki0z/bP/G22BiLStSqGCu9YtTFqo++T2zZ1T5Mzluzs1fad+/k1tCdHGZ95r72jdfe1/Xhv9R7qj1/1lHf68BvvoXvGvXHu94dPm+/Y/f/eszx965g/+n7vjXFPrjvSZ4/aJpUvx9K/ozHwo7TPl96/f2//fUx3GObEPe/o7iMZ2H6/p7d7nmYYjfFAIp8BV8u2gkSeQw86sCxX4vRrwUMAijg897LeW/m88T6Vc0nPt6AlT73R1mMIY7aXcdxHmMo49j0ed6SDbO5Txy0iapvt3f1EIgN3zXPos/tHZOFvtoN7jil2u1pk9k6iM0imBJl3mXsJGOlBdYdCtkvPZXKiXStnE/fO27CGM3Lv79054d4Iq/dE79YBz8Lt/nifhg6PbVr/BjXcHJY2/Xdy2EamczJH2FlX94naM480+d323Pz9VvR12Ed/V/482iAxg+xjF2+n3PGynXffcYrj82Sv3+/jUPfp6CzycqYP/rNAB3+v578yPhlQ03OrjI/eke18O8IrxfH6er20gAL7TPQgC5YAWiAvmZ623bsjNtt5YueBfoxEtHEM99ixOaWXdcH1Kk7q8zxLQI3K4BLQW7QdO88z8irBnV63Nj2zlxsvsMzH5mg0MVC0LLCtkxDFgZYgZbbXZQHX2gKfUwoabEku83wf69U5k7bnkuDN4lRpGIWWyY4BMU0IIaIG4c0WKBZTlMy/wd6bBl/SthSbvBPBYN5Rih70FfRwmHnQgx70oAc9SCnQjBieEMhKIESAxUDFpagBUhwhDAjgqiWQKLRa8uK93R1njESIJIgsI4rC6Kwg5WzMmLbtX1OS1Sgnxih/v0RYh+ZoI2UPTHEfwXivzPmsIEL9e9LfKUCjFKkZ9US4tlv6vSbYWRYd5opavMEwgCiCqEcPGY0OLx8BsfYE+Js2K/cUpi6VvlGMpJ7pFaVoCse8opaCKSWESCBzgjGHKOrGua1ieguo2M/uILWNuuqKzDYqwIP243s7AiF8FJUBSqPyZu+1lcFyzjb2TJmXXg6qVo0qJdoFpDYAgf883DoM7d0zRn7cM2j71NDjGP087AGAm38hAFpi5Z6CPCqgvwYoH9sYwT7fT6MjI93Yjv/s1yj7/1HJ76V7IPF96s4vY9v32/gYwLK/dkaYVD/9Tu9wDzT+GrJ7joxud+786mcB2/e4x+fsGvt5BIT5tvzne8D5Xhu3PIFgEUG+/bG90QguTnb2DrQ8IDwfNQe6fi4xE1jBqsLAknNzng0xYY5JM7mIc8s0z5jmE2KaEaYJ5/mkWUMYARVTIgALCBUlr3h7e0U9Sxa5tVwArChlQq3AlGbENGG5ZizXFUBAipItJoWAp9MJT6eA6fyMND+BQlQnHsnMJ0YRQkVFzSsYFcwJiBUhTphOhJgKzBmmFMniIeO2eQaINDuQxh0KIM/eNauBY2YI7/YHlV9AoEqQKE/GNVesV+iZTvJcljmdNDNORWjRwkRAMsfZIHnRc8m4Xq/I66ppnaUOe61FesqMOMVm9O7psXtJysoVq2aGKSVrGcWCyiQRbFxxuVyRrMwlA+uy4pefv+B0fnLnrzm2CpDXl2YHVpnlPKzlNuOIzEE3hNnP8fcRHN2m6+5lCfxesrKK1oadyT5duKfGu4O8K4nmDUhW5mXgywJotnjlG1lmXTOA6mRqqTsfAkDo0e9E1JxlPN/x8zQ6A/n97mWRvTl872we5d0j/jXKAVt+iM01wE6ZnV8ht/ylae/Mts9tLdt4/Hsa9ahO+3LSezzfXzPKqeOaH9vfNxzsy20hbMdsQQO2Z+7Nx55sM2a98/yB3Pj3ztBvoSP5dPzu3Xa+uQffQN32fvvVN87FvbH+ZruNuulkb13ufX60vsb7vq4bx21+pL2Njjq0tSfD3cME9p7t93E90GX/Z9abjs7bIxrPnj1HTcBs8xUEkTUqJFtfNZwBAcyCl0VIWVLTebyuNfLfMYhlI0/zbcBNCwIbMr/4s2OPF+99Pp7J93jbDW817I/QjJdH89yfSQBJVs5R/xSJ0dxiGKDQf0fPIsNNUsYmiyarYmGyNescmvOGzGfnV74UdO83Y0yPMu7BI9ziW8jrAd2nxWT/nblUOeHrT5TtmDC0v81lYyBie63u8fvrxb6z7BCbLFG+F3fmirQNPrhu3Me2HrqT2Vc86xv5395993k0dL1/7Fxoa4uOSwl6uWfzue2Pg73/l6CjM8h/73E/Cy7wMu0oc/p2TbejQICTGY8wDs+/O+ZQEaPppQDQMYh+JkopthCj6ky9Xe9MOY5xr89Go+O5588pJaAWVNVJPf+2jI/+uUSkwUATiDxWZU7r1AKHxDlQz3swQkiIacJ1uSr7ZURKAMRhnStjvVbk0kv8gqA2DoAiI2tpZLN5AOzmToJMq0bKFFYduFTJENP2ZoCUS1enJMUqAMmCzvA8pWc2s/doZ0DUEoZ72Skf9G30cJh50IMe9KAHPUipVkJpRhWAQkKMQdKW0gLUCorUhNMqui2IICnzoAYviIBkyoC0V6U0g2YPZ1X6RgNDB+Yt8lYoRiljBCf4ilGAW+SCpbTt0TsahRv2M3uYYcEDH77us0XISkd8and2jj0SOS6R9F6B5DY31oQJ4CJQWppScULx6euzE5K9ID0C477fXrHYK0dUSkEBEKlHJnhnipQSTqcTgJ4NyMCBnMXAGCqBIY5TUY2Bkn6xqvMJEAxMIPEY944nG4XPjc/32VJFe+OUXbsHdu/Ni3+/fW0PwvMASkaXQWh00DFhHABqkRTsY9ksozHCy9qLwUWZ59yiC47WJfPWoLanBPr7gO7Y4xUv36/R0NLAOIiTmS93MGa3uAcCjQr6e4aIvf6Z4uzX7mh4HNs4UqB9n743fW+gYQQFP/YsBawO6Ai8O1Lk/bXbfu2bVe4DzPezX+xRX8/Yfd5H6SPvRvr+sTaO1vw9sHj7mbXzfp/2bva8YeRxe3084pXANpLLPrfPfFvjs/b4D8DguuWffj/7s8j2tDfgWzmRaZoxlsaydef5E0PkkVwr1iyZZKZ5xvl8xvPzMz49/4B5PjWeyVyl1NApINAVzAVEjBQJ05xAqFiXK15f/4w//PEP+PGHH2COOaUSLv/2M+bpjBQXUIiIIeHp/A/ioDOdME8nEIJk9AgBiAEhJXGYaRnlup0gBUaJCWsmgIJmv0uo+Yrlcm1lEM3J1mfjMWca+b+C/OBhZ3awuwHbxA1YjxTBlbFonXIJySsg6jKQnXOEgEsIkvmOqJfPDAHzfEKModVJX5cFL6+vrXRKqQxmAeZOWionqpOHZI0oGsXHmsZdzsbr2xuqylAStTZhXTNeX683Z9W6SjTe86fPOJ+fdE5kvlctARZIS6+YfKIGBDlfu0VkdNj1Zx6wzYphZ7dP2e33WmxZlLBZ+17GsT1kf3vZzpdOrFX6lnNpMicR4XRyWXoGQFKiqFmz0ECduC0tdwQ4Kvi4sQhpFo4+B2M2GQBY13Vzvpvs0lafA23tb983m0trx8sLRzzNfh7JgOO78z/Htr3c4/v8vehb2vqoaLKdV2zWlUWm2juTdsfzgFQHuc00cGuA7Z2yvSAZEUTW9SWSbA/497M1RGz748+EUTYf14lE+6abdeGvx7A22pg0aGJcY7bo/Tn1MVmR70ha99/9ve9un3drbPkY0ebHR/tAjg185Pr3aJTnh1YP5/B7yOibNgbd6L3rmcWIWL9y3O/1+0gHem9+x71jOMk93epo7u/J/sYX9/bDeO9H+v+t62a87yPrwevjH+2H8cC9Z4x8ce+7cT729FNmljIUIC1f2R0xRK6LYF412CtoWYwIK2W4t1bs2d75xc6AwLzJdutlGJMz/D1Hc7SHQYzj8uPeO68blkASgGPrdrzu6P1aG4EIQACa8Vr7oL8SAGItW9vOAShUVfteUawtRKfjMDeljEAIhG0JH3aO5u3c2tP5ip4x+/M5nnl2zXGWtf35IAz7mhwf2ASk2T0yLukY4aDpA3JzY0eKtrN5CByeCRa8L+zjCqP83PYMM1D299z7PGeLfeztmY1cwMeIwp5MNOrA/fePyWyjTHKkU7f+DmPY40U2bxv+RYYv08199oxRn6EQELhfe4Rn3DtrPkrv8fGxrz7T5B6v8jxsq3tJSbAAQhnmd7z3Ro8gm1ug1ox15VaqOYQgmfQhgSFmzwgB4BbUs5d5e5A7CW3v7M2rD3I0/t1sEyFiOvVAXgsCJZLABtM5Lchhnmc8P537mEsFuIJJUYMqtpsUE4Li0aIiMDiwXqdOVVUCpQGgcBZcXnlpjFGz82cwFaAGlJoRKII5wrzULFOO6Kbi3FgyYykZtRTEQC1TDleZ18wFIQoOQAEIlQFi4dVsgS+SacYch2TNdNw6pQl5yTL+B30XejjMPOhBD3rQgx6ktKwLLtc3AD2Fnxh4GKAIJnEiWVkcVwIFTKcJ8zRpdPHaUtgbeSEyRCAmAegZ4knsgYBSCq7XK6z+M+l1LbU+LAK9l/SJMaKaxzJDBEQwKJAYigjIXG6UN3ueCa0ANKKZG0hMFJuCl3Nutb7PU9J6ulKuwMDr8/SMNInXjAjTXikxcKWXDggaqV05o9a8qZFtwvDlcsGyLM2oEmNsYHLOuRm7RscTP6/QmJuWAlHBhJ5GkbDmBcva68fGKCUQKhdYea1SMnJZQQSUInVTidxcRaBCao3WyggcW7rn1ib1tJg+JbQ9l5mxriuu1+sNsJdSasYBD7Cb0Fw0yt2MCJ68cmLAv3jX97nzipvNi7wPAyAYKem63AGh5PvUAC3r65cvX5Brac5Avh76qASORm2vAPrv/PVjpIEHy7wDjyk7pmh0hympj4th39omI9cXG+sIKPh58D9HokBSxk2/H/e/v2902hnf54Pu0A6oec8ANQI1BkpbhrA949SvMXb4e/sa3VdwrW9jFKytQ21xA/T5dT/uma8HE9ttRzj9dlzk49l03txnbR9J5zbjHOdl5AF2ne2Vcaz++r196Q2dI7/bA/r2aAOOK0AeHaDngR3rm/S1Z6AzvnMLvvuzUtrOOeOyXFFqQZrPOJ/POJ1OOJ3OeH7+hB9//J0CmoR1XcBlxfkUQMj4r//1f8fb5QX//M//Cf/lv/yvmKaEf/ynf8TL2yv+z/+WEX7+Ey45Y56ewTwBYcLzD1LGKQXJtJLSJH2NEZOlNgYBWPDy9oLzeRLjRREDNleglTdSYCoEAkVGREStBZkT3q4FteSWwp95jCYXxxlzbJEILKBUwjZznziChKDrJ7AG92opyxARUgRxApVVzj/WTDgkMth8ekIMqZVjCiEiry/NYWZdV7y+/ITV1Zxv53Ig7VpCqQG5MNa1aN8JkQJiSHj+8ROu1zf9d8W6LvK8QJhPCSGITEMAzucTcpaz9HQ63e51zX6Tc25ZeaQkp52L/x97b9YkSXKkiX1qZu4RmVnVXdWNbpwzwBwAl4OZ3SGXQpF9mzcKhT+FQv6w/QX7xgceIzvC42FlOQeXK4QsMJhGH1VdVZkZ4W5mygdVNVP38Mg6uoABdsNEqjIzwg+7TfXTT1UBqHedzXeLXiSknb6XeOKKzVUDLk1u8fKHyV9+rHLOjRDSQmq7dDR+vYqc3GUeIysbWCx9R9p/HRifpk6gNfBQ7h+UmLQ8Q6VdPoWSGu9i3wM8obmtObcvmLzkP1+HUff7rJexPcjrCclbRoEtw8U6Yp43UG7JGV0+Od1L1+9bj7+//23Lu9xHtKzTQ2erGQaApVeqjcWo5LS1QUD6HughzF20AucYsD5TTTa0eljfX11dNXDevvP3rc9pq4vJw75N3bN2QkoScj7GuFgnW33rz5L12JvOtF6XtVak2CNdWRTNrb7+xytvIFw8eO97qsWvpS/Ot+3B9/Hpunjwng2556F72rOJtqM1PFAe0j/O1WG9J23ea6wAnO6nD60J/9m567bqv77vnP62tT/9OnWyh+t+/p7z9223F9hwpnHfez3Dn1/+fe05zMglY1ZcZi2/+79zLpim4+J+e65PfRdU/u1tl2tSSohggGPDAA6HQ/8u9s89xsXcI88s+3R5Lq/buO47X+wddm0MQfAEI8pRJ2VLn8p4eByhn+2SVt1k4fUe365XucRjSyYPAkujujiyrc9T14/O8DzPc5P1jOi/1jdDMMo6nzzPZA/fH1u61rn143EoAqFWk1vtHYJFGSa3HjNmQJz5uj78ZqW359xecipPqXwalvNnWz/35XzdttaD1Q4wB4rTfl8/o81fKN65sWesZXh7pu9XL4/IHA4P9uta/rC2rElpfi6fI2vaO9fngDgDnEA8i/s8kaPWikAkMlBMmpK2LOQ1a/ubYgCvu2ZLtt06c9Yyqx/79f65xkZb39n6WkWJ9+N7gnOQYQ3WEEblDKqMGC0ai+01QK4FuVRQSeDa8aPlPrk8m1pbsMbW+vowmdSPdeuLYGeFRF7d7XaY5xmlFNzc3GBQu0t7Zq34+usXTUeNIWKRYpnNWclH1pHI8XOdmiNEmSdM01H2VyKMw4jrmxukGHB7e4vD4YBaMwpncK2YWTCbcW+6sUThkUgxhECybioDc87iWKN6bYwafZYZJU+olZHGiBhlH6OoaxJF0jJx6A46JWsKZUmlZXoLYUIpPeXTpXzzciHMXMqlXMqlXMqlaNmNI66vr0EwsoeEek9xQNwNmGcRRLrhT0ycRwXyQ0wAxeZZ3QU0UXHmXDCphzDUoNRALohyY3lEAQYxI2he5zJPSp+RgILMAcSSJ7pUIGcTspXVHQBGVYG6K0Ie8PeRRExJBpSEUApSAuosCngiwrDfy7OaMhIwDKMCKRW5zpiPYlBiaH1IjE/EQjIJob+jE3asn6QwY2FQ2e12C4WbSIhHMY1glnCIJiCKMgZhZ6tyJ8J4kCzNTM0LJWjYxV4UmCcSIk+p4CpGtaDuOFTFazsEwjDsYMAHc8bxOGvahoQQhXUelWBSuaLmIqauFl4RyugPqCzvKiWDKOD6+nrRT4AoPcfjsQEcZjQYhkEY7pGwT3swM+ZpFlAhhFbHaZ5aeyUVReyK1Eo5J4hQz8woubSvQyDE0JW4Nl8cIctY83fqfc/MSENPS7FWTE3Qt7bYM80AZ8UbkLaM5GsCzxYoYwqWn0+VK8QTxxgHpmz6mbEBiJKAu2t1nx9y61l9b8qrbRrEvQ6+iLLsQQJ68B3vXhQI2oqu0vKduzos7nvgqQ+AIu9SzvnstrCyZC1xaVzOFAMO2KIPcL++lFNj6kOGSKvdmTe152BBlugGlXPzdg2idfB6/Xz5Z/UOoQOIRiwAuIcLP1PHxeOcl912P2p97Vqby9Yqi8ZCq5/LCb0E+lbr2YBhT/L01xvY4QEwv3eux24N/Ns7HjKa+HpKmqMOfPZTHhKBjl0/aJjdWu1dAka1s2FFWJT6E4AqUWXA4ETYjXs8vnmE65sb7HfXAgJVwv39LF5JQwBTQUXGnCPmw4Qf/fDHAAriQPjV5y/w7NmXePQffoVx2KHUhI8++gMQRkRNvwTrdw4I0DSTFIAKlDlLGyMjRMawn/DRdcJAFTzfoeQK5oDKAQxCyQFzjnIGkUZCCRLJJgwJN48/xOPHH2pfV5SccTgeWtS6oiGQc57B7NeKeIuFSI4oMSHnGRSg0epkVEJgMJdORdM+zpPIbWIUmLHfVZCC9FZikvM5EEl9GGANSQ1Lc0mhrQjxwmPcXO+w2+0wzRPu7+9x+0raNO52IqsYmZMSAkVt76wApT97ZB4fDnNLt9RC7LN4pRFFjGOPjJazGW+sr2SZiZFISL/TNG3uZRJhr5/npZRGVgagKbOOIDpK/ZhbnnczZoghbG7v9kYIS300jnsMg99XzUOuoJTajDae3ObX47Le8k4jR/i0S/Y+Izb79S2kgW4ksfqW0r34rBggCRjJpur4qKAN72XZppm+zwPVS8OblzHk+qURyIhQvZ/s3GDXRn92nALvNp7Wfw/tfw+VLePW296z+hZEJjvDzfvq+pDansrMsOOZAhB0jVMIqFyad6jcx0AVQyEzq9NBFFKjkr/zPONwdOsgkDooyDOM9NXqwdzI6FsGrUBBUs+VAgoBSQ29pRSkYQDYeQhD9MbdMIBb+txuEPGGEmDboL1ljFsbqxYOESSh4KUD9V7qu12/j5xoeWq0PRnFd5Tfzjztvd+znuPsFtwWSYT0u7crD/eR7UXKEAYvtpztd1k9XleVE1mRVjIVVFZsVW0rCsSit1fekPXb5dvtejiiTl8za5nuJGrE5kv9+9H0sfaMN9iLtq576Hp/3+vuf5PnrJ+3fX+7avVzaXhczJkHnvkm9fHrnJoV/dyYbEcssLLlZGNEB3+O2f0nER+a3O2IFSGo7laRizgezSqvBN2/5XqRt8RBTP7FFNQBSVJjss51kSNsvfOCgOPrsoUteJ3Cf+7r34zXzhGK9OxnMhKNRB5gO+wATccBeOO1yCxGND8lWZr8SkQ4Hg7SR8yoSuq9urpR3QSCaZAaXvWstHOmFImgoCPbcJkWvSeEE7KC9EfH7fQVci5z17sFL4uL+jM02oPiHSZTsYsgCAlW2WSCwqwRhGx+eBmnzbg2H/o89evD1VMrKKqqdvhCvrB9ql/XTsLVkpP2a9TtYtGo7XEy10SNE4fDTlKQPdfW1rniz13bnSkEiTSh36+dzfx9ZOcbC44sQTaW7yMIyW25P9vz+9xpiCDbO85WG7wy0tuzPYnD1lGtkq5tcV65/cbm6po4QiQRrKriEU2MJ2t/1egafXwrGMd8xISjzDl0Zwki18dkKLvefbJHL3vQy/un7WYTt5b9prqpRB7BglCyGHfeJl4tdDdmsNZ/K9LLWt73c8MIKa2tEEeLecqohRFTkrGqtldZRBb3DmvlUnxsqXSlB5b6h08l5LEPou5MQUTgGDAwy7LnAAAgAElEQVTotTc3N7i/v28kwVIK7u/vm93C9iqTtZkZhatEqRllL53mI6Y8AURIQfXuo5wxFEX/HccBmQCuPZpqDBGFITg4BYxX14jjACJZxzmXNq9F/71HKQX7/TWur64wjBG1VNzdHVArIwZoNBpJtyxznBDjACKJjDMdjy3VdkhyP0PqZenATWcMgSG2mNQit3HtZKRL+ebl0pOXcimXcimXcimucPNm8MAEqTF/h2FAAz/Fw5WUmLFSvIha9JXF85kbsSPXLMqbKpsxBkRKiEGMVKRWX7u+MiNoznsR5ki9pIGUqAmphQuoqtAJQHJFL+uwBgB8KERAlF5o1A1mRiUxTpmi6b10zFjCqChl1nCFohDsBgXJiCRPKmrrXyul5FYPAzeMQNOAEvfOWivyMUMMYhLqMEQCcVQd2JQV9S5GFbC8WbbQFNu1QhyUYCJ9EdS7XlSoYRiU+MENeCxlbimcQpC0VMHSkjZv7+7RyQz1jDJlAhImkhwDvilYp2Cv9zLuBKfSrqkW3SYISYeqqYIWLcMDgjKepkjVKnMzWgQg0hywcABTw5s7KGZjY88RBn5deP+uDfQeaDNFz3v22r3WblOwfV+sPaO3SDS+H/v4LhXT4NxVuhGtRzE4S4p4H7aC9TPOPXMFnpsBSb56n0YLAE7J3QJzz//9mzKsbLz+gc8F1HsA5dF7ujEFfX1u7N/ttgfbtH7fA9fqXrQE+pbvW4O12+/v87XPfft7eaad7Y2TR9IDXz78VcNQGgB5CvpsGW29ocWDR2uvMYtO4ftofZ+dGVvfnW3KRl2We4kREV3jBW3r3UCrZ5FFUKGGMpNux8yhhQqm0A39RECkhF2IQCAMY8DNjUR/CST5riszKDL2+xHTfAsKR6Sx4Hg/gWhAHPaIiUCBkcuE65snKCVgAmG3u8H19TXu7jICDYg0KLBfgVrAJaOWCUDBbiB8+NEHAAqmfI+7+5e4vX+BH3z/+/jk6VNcj1fgGnB7f8Tt3RG5EF7eHnF7P4k9hnq7zaiXhohIndAZk5Br5jyrsTkhpbqIwtW2ZxAYpRFA5nkGo/aQ27aICQrU+zNDUkqmKJFzAgUhWlQ31gRwAYo7cyhEId3qwBlw3ecNQFSRywH1fsb9/T3mnAEWInRVUqjVBS1Uc4UZHexcbOudTIbRrajIWgZ7c68nTiw9e2XN9Khy8lM8hyUlgvNEDj2FpK0z8/Y24ofNf6g1htkiEyrYzGIUWEdTYR37bvv3xLS62PvW9fJ7wLax9BTQ9/Lccj37PgN6VCPzThaDlf1t34mtqvY17Na6tLc/d1kvtL6xfdD6oh037mzvxHE1sq92aq+b2J7un2XP2yrf5Ax+/dnzts/z6Rm4ieLNiAjrt9RF6bYO1WgKWxe1yeOsaSmMMM+V1anASGqiI4QYBQTVyWLgv41r46VtnEGnRkRu8v2QEphri4Y0DBJBqlY1bFSpp4RjT6hw+wFO5dP1e7TzW3u9ccl+2n1bqcPWJA1e/WxEaXsvf/Oxfrvy/t/1YP3Xhi73/1u+5KEvVW/e/ub8I9+gL9YWu67i2bYIBKOpUFsrtS6J5Fvv2tpv1+89W8OFLES68W6TlPz7tr946EXba+AbFaJVv9rB8mbvf/PXEISECVgDl4+wfYdO1Ku33eO3+/Z19d5u8Lq9JzoRAT6kxYJkb9uLvr+fcSqzMaNWgsk0gYS0LPu0CEK1shATGeBaume97eNRCSyltr2Z2Yg426RR3yVG+FmXs1Fo9XfBQFb9AZPnZZyryr9Nj9B1YjJllz+p6QKBqJFdrN6WgiStZCyGkBySGruF+JJ0Sgddiv2ekmfkPLcof8wscus8N0N0J0wXld9s3PxxojKxnhdGmOkjzaBQRXYFNSN7lxMrauHFmBB1guvWBrAkV+Ck72UsQ+tPP2Z21lt/otEklmO7df7KvlhdP7jnuIcws+Brfi5ITyg5n0+WWKsrC9HFHtl8lWw/4i7bGkkNQCNfsLs3YIN4afuzyRmuraZrVCWWmPNHd+Q4fz7KHOQmVwWn53cdoMvsfmys/X1cCV7NlvvW5GEnD+vzmLaImSyfsZAjQNIvbWq5MyYQOcyI2shtFtr6psv+ZGO2eYb1ndHrnQ/OdZP92DB8mU/F4eV+nzDyif1tZY2H+BGt1EnsXh6V+5Ibrn5Xi96usiORfGbp9owc7+u3lqX93+M4grgilyxkd0DxAUujq/uY6g4UCFz0+UH2TJDsM/fHe4DFzpBrAYGRTc4PhBSV3KiOwiEQ9ld718cBtVQhYQKgELBLe7HTBHNEq5hmcRTpDskz7u4LwrHvQcMwILFEzioFjWAvTlbq3KMOQ1I/oDtlzC2ikNga1FmAFRNw44oHIjBdytuXC2HmUi7lUi7lUi5FC9e6yIlsQn8ztJhwZwosOnGFNa2ACIpm8COATbFShYSF+YyawcXCCVYFAtS7lwwsEKknMAGBND90F6cDibGFEBADJLexeZOa4aS9ezt3vSc6GCFBQvtL3b2CXQovvE7WQEkDJ6o0hsm8kGoDDWBejtxZ7tmlblobUL0uY78zA6hCiKmqoAWSULiRkgrqCp6rEs1BFbRzmJwDhk1ZADqBxlRJD6SL8le0b6TvGuEjSmhG2Gi4vvIev9bWpvzq/LFIKOtiAINdb0awYUgCCLGlivJKqPTk4jMDxa1/HHLeQQtqV8OAJloCB57EYm3x4L/NF99eu87u88QZ/zxPkFp7z26Fxbe//c/1XPWGxPU9Ngf8XDhfHgYO3nfZMuI/CGi/c+nK/snH7Rdaffi7oJk9DPKcGGI3wKx+/fvuf1tfp+/ZNs75ebvtHboGhRdtpDecu2/YtkUfbN1Cp4DTut9sXZ7bI6x47yRgDWIur11HpPJlbaB8UwMEkUUhsL7U/+xc0DMtnAwmASxheq2Jlf0uQqgAiJVfEgLikDCOjxCHKzHwDoRxBBgCqtRSlZgKIcVkxjDK2X1/dw9iiZIQQ0JMARQT9nvCcZpBiAhxQPMCZYAKQBVAYexHAoeKMUU8erzD06dX+OjjJ5jyEV89+wp//w9HfP31S+xH4OZmQARwd3ePXCeExIgUNBS8gJysaejEK9iDiSoPWC+4yCKyxy+9d+U+IShwNZJlbnKL9uwiKgPV0mQB783mw+T78e1goqbr4f55JEcE0T3CE+uMxMNMEskFhGGQdCsCXsZGTCHYbQYSh9Y+a7cAcMvULwJg9/1pLUf4ebsEq5239eoMBNDCXfuzVUJMG0B5GgUFQJN91u/dKluGO/+sHmHpdA9bt3VLrvCfec9U33+9jp2QYsaFXm9afNeuMfne/gAWY7esw7rdnti0PD94YyzNaOCfYfL4ul6/a4WhHsDWHvJrgNo/i74if/bxs+3cdCdSuVXsKQqiqwevGVX8ebb2yl4a3whcCtZy+3oe2b2A6I4hEEJKYvhDBZhQCyNPBQh9vwFYDYEMOLLYeq5unj2sRIfVvrUl565Ja282LssjfH0m/66VB/ej35DYuhrFNxWr3uIFThbxc6L91yvC7lxhUl33pI7uuVtjv9gjt++TNWse9tx0zV+XyvS6c+fNH7R4aJfv8LBO0A3763qtH+qLRSk0rMP2Q9h/ehnZ9qePOtORtF0Htips1p1aMMTTG8/rCVtGWHb/b79pVT22c8DJQYEQqIARJe0KBNcxnMXkrnmahVBQa3PQMiyupet01V+c7xYVUIEeQj/L133o21SVUO2fqcIhIpkDkhp+tQLkzjJA8B1Ef87rdeSItHpX+5vMuNsxn6W8a6nagWma9Hk9cpmXC5cEYsZMcoZauk3b7y2676kMxnpGe+KCtM2WeSMIIbh1aSlWOm5kZnrDz7ZwnOVzT2VMjxG189rL802eJDfEG7Odl/r3Fo5kP63/LeUKaR9uyaTr+xftwqKqcp3pym2xuHmiBCqJNCRjEVS/a3uTTXTZ6UGE5kTQ9nKTtQAEYo1UqWe96jLsHtfGWMnGNg+2Spe55D0W2cnwcyNnWBvJWfatLxdEK21LW2vWRGrD5oZwGT3lFBMUecswcatPNf2IsMAp2Mbh3LZPfoQ2vkSvM4gQFs/m9ty+B+g7Pa5GkKjTgdoZaj43vR/JjUsvPgLROTx0W4cCgO5A63UyW2N9PPxzpc62l/dInadOD16n93KvrekQJCKfRcCbS1aSiLCdaq2SZpnEaYgtmiJiX1M6vrnk9hxbHxZdiykgxYAUk0Ynyy3FHYBWl4mnlsa5zjPibocQJWolIJFbY6m67xKAilevXqnOD42EM6CWDKWwIcUoIbVwugeK/grRDyo7XKH3sRF8OHg91vq7nsyHS3n3ciHMXMqlXMqlXMqlaCGgKb4AdwGrVjD1FBGkRoygAKhEGEGL/tIAKUi6JEDC/Vt4wVAzGOLJKpeqIQnqCVwqIlWkwJLjkiQPpqQzECDXiig23SAqYWuXISyxAvTXBASvHDbhVftjLVD7e9fCdC0AOCAFAkKSrisMrlmilkQV8JtiRwATooYzb0Sbptw6oAidgR4CIUqoH+ScMecibUxqqFRh0mtT5pFkSvwamF4L8V7Q95FGfJjzGEPLT2oKhikTSRVBGeMlELClpPTUIQJyW9hgPybre319vLJh7TCAfm0sMqUSOpN89AofLrXPsV5Pu8/3k29bjLFFlbG0SrVWUFx6elubPSjjFZUt48TaW9zu9alXfJ3X166/a0qkaaFnrv1tKEtDX//5/uvnAL4HH83uZweBNp/4AIj9TvWnh5/5tu9a9+PWdWuD2jcrp0SQ3u84AT/8Xu1/XwIZy/Lrmrdv3/YlWeZN71/sVe4eH33DAA5PzNsi8Plnro2Rr0st4J/hwc4FXExooDaIWnoPvVRfTgALCESazqdFqalqNrBw6JGQBvH43F3tEMKIEANirCDM4JrlnFRUkxBQZkaKe4wJADKIJE3hbhw0p3cEc8b93Z3WuaLOBxymIwIH7AZgnwJ2SQCkpx8OmOeM3Y7xwYcjHn+QUPklEjHGyBjjgCFcY54IX3zxAs+eP8OXXz1HCAk3Nx+AOSFnJQhppDdU1ohn6nnJRQivtUfsE8KG/LPoMcfjsRlMiEI7J4gsxV/FuBsbcVlye0sEOkAAYdvfz62LLaA7UAAVFoMMi+EihICSxQPMrmMWw00Fo3BBrbkZK0KIYKBFeFmDjIABuEsZw59/fo6+7mza+r4bTAKikphKKf1spm5U4dZ2whJoXYKdW+eyncVrz8Gts9f3na+rj25jYKU99xzIu7V327NNLvDvXYPGrY5ua1rLNYt9a+P95/p9q54eHD6pw+oZ/rv3cf6867nwkDz1Lu9iEisNM5qRiMkMfZLGVf4lMbigorKsddlKTP4kdHdKBklOBwC2XgnRtmJ3nqzT/Z20Se0W58bIy8jyu+wRITIQCIkicimYpiPmeUIaBoxhhxSTejYTcs1gttQVYTEv/Drzxebp1txaz7v1Wjw3H0+e/waftXH8LZCP6TWi6togs57L6/IubXpQjnCPW6/hb9J/2zKkRtJgttNPDKZeDqMgDiSmg5/RI9g/dvUeIwLw4mptmxn3wI3kIX2OTmxbteFN+uGhufnQ3ri5hrb+dmoPBWoyHSuJATAxgnuT7T69zvdVN2ZuzzVWw1mLbaETma3TyD+n37VOe9Lv5UZC2Cxn6mF4z8nnDxCEzj2+IV8b9/mxZsWt+rvkAVHTeVYWPImgEWUcwQIsEWZgkSrY0jQZDqWGTYuGAosCLePhnqR1Wo6Rj61q5Bepn6ZQtyMG3fjPZHOebAlChXwAIgf3PdiTN1ZnChshZSkL+Mi7W0Rg2X6WcpVhQ6Yj2b+ULARyd/jyTkt+n1ykX2Jp7ToKmsiGtX3X6rggzAAUlgZ0Hy10C+Pp0f+2ZWFr64lchw79LXXI3u9rwiz6Ktzco31fn13PK7nYf9bf49YbE7jNIR2/xaZr+472Oweg4bi178HqhGFjYdd3nI/b3sC6JzO79hHa3JVnVFkDgRovn0AW7gJ+5Xbd3jq8LtaUbkv6DnYoR2uV60/TQ+wqT/Rf97XNmaXz4XmMR/VM5iYftq7VC4htDS9adHbf1Cpvf8g6n9gw+FVfsclx/UXMWETibucPuXntyCdVgG5IgNLtc28t9/h1tDWX1/OVyJwmlvpdXUS0sT3Hr5EuXsjn3QnjLLZMHb/2RBNmRnGpucCShC+kJL/rXkIAKCWJtmPyhtppaiUh7oIRJXQ6Ss4ouQAgDPEU0/ZReKxukiI6owwDYhG9366PMSGCQCSR2sdhRE3dfpBzwfF4j0AR47hbEBSFqCP2AiLv2CNzvXJZ9FktFQXLdOO2/sWJ6EKYeZ/lQpi5lEu5lEu5lEvREkNEMo9GKODIFYFCExpN0TMBNmchSuz2++YVnatEB4lpRExdCKXQ00OgErgSUhok4F6pyLlgnrIYaFBRQ0FQ72kR3kR4IkILl5qr3MdgDMOA3W6HOWdMGv4/xohhHHrdcm5exD4FjqW3ANQIVSsiGN6gQtQjqBgTO6XUngtICokQCCkJ4H13e4dcJtQguTUt5HrDnYjEwwH2j5Q0o4Igo3kSmczIgVCDKnalYJcGAJJj9OiIJlas3iIER6QkaQamaToRjD3xos2D0iO2hCApmTpoURHDgDBEMMRTx7yyp7kCKO091l8WJrOPKzmgYmmAWiv2/nprk81Fa7EZFG3M7VoPnEgUoaVCYG3eioDTO2UZEcbmtr3jVLHSCDhhXBjArA98VBnfbqCnaPIGNP/PG859fde/r8fzBEDFb78X7bsaybaMJQ8bDAjiAgechr9tT+0/W8gmUlTk9QSExdvetV1veb3vgze5tr2n1PPfPTBnto0ZHTxcXqfAiIJdtS5Bt1orpmnC9fX14r0edPTt857lm3XhJbD/UL3fdl2sgSuJkgacfaHWd4sg2D3y0fYRDxhvRaOwd9sc99fa2Qdg8eyH6mVlsYagIOCqvn4P3TbgWISZ7glJRAhR6rfb7doZbr/XWsB0DwoMooKSDy00OtGAFK+QcIXIA0opOOZZZJKZsNsF7AfC9V48oV6+uMPdy6+w3+2AAMx6zg8x4cmTT/Dpt67x/e9+hD/6o+/h8aOEv/vbf4u//pt/i//tf/0b/N9//Xd4+eqIYfgAn376I3z88Y8Q4lP8w88y7vkrcJyQhhEh7ZB5wPE4A0gINIIrI0YhlUokPk0ZWCtmHRO/Jx2P9y3CWgjA1dXuBFizPhTwP8KiTxgeKpfb2iKHiy7niZ1b7Ux0RoUx7ZDnCcfjhGmSfww9bxgtB3zJRc7tFBGSyYpGVsWq3stzNQQJM+2NR76tnsy6nmtmfLQzcn2On8oKdiaXhWFjfb76dSWEpN4G8zz2/XUOYN0yIKzX3Hpf7uOaFmNk9QNw0l4vK5mcZTKGySRexvOknK33n6vrQ+VtzoJz73joGb/t8slWsf5efwYACEGMotzB7QBCTCPGcY9hGJHSAKIIroxSM3LJqJwX5DOiboAjUyrIxhYCYGNpzDI5+jStbP9pc9jLsX6t2PpIKWGeZxyPR8x5RsGIFCNKEcL67uYaV+GmRScQAqFEBEMVI42R7m1urg0cW0RxiQ6yOmtdm4wQZ6k5/HW+2Gfrvni9nPhbUrR6r6vnm67rrbXq99T3sQ79Ox4am7XM7j/bkmdZDfTNsKZCZeWNaGqqD0IjeVjqBN9OwSy25WaCGd2X8pbfa5ffmWbBeqb0NWhn2JuSl193hvh3r3XZB6+nBkk0w2V1axBuL/HPNFFje0zU7L1+n0XY1fwgC91U5fPTs0mNYCpPn+wJq7P2Tcu5O8JGe9bltL189olcLUXHch4bv4ZU/yk1L/bCtREXMIxEyCitCi1vDTSVkzdzkZKgAC4zKlbr2h6xWmsUg4654HXS/dSf6eQOa1dMo9bfnzlVjLYkxJ4Yl0QB7whQ2c8t3Z/DMtqul7P6OBCur68XuInJfoZLAUApljakIM/9PL2/v8fhcMDt7S2maWoYo/3s65thRnCTK31fWLpPI6lL3ZQYQtIP5kwFdLnzdF0b2ejhPQZAMz7XWpFLaeft+t9y/vj93OSQpS7ndYQtebbXdZtY6/ErT1IwRzrvgOflU/8MgEQG4oJSphO5lzkv+mIxh21cqGOM/vld1u/kKWZGGkfEEBdtphAX/W73ozFPGDnPfc+1Grg0Or6vpB0SCcnmtq2PdSRL/065jiERQM/ve35MtpxEyZG/Fv3XHnDyyJNydre1bZy6Dgqi0zvdDwskc5K+Ht05F0CPhBKCRJlntMj4676wvz1Jxdq71PE6XrIlC9r5HFRW6C2X9tkz7Nl+Pds+saVr+Qjkfo2anlogcnTU9KKW+mkYh1YvsKbXUvnHor6YPlCKOSiL43KIEbVkdY7WSC/AYk8aBnE0AtCwtydPnuDFixeyH6ojjKX9CyFgHK+QUkQpGff397i5+QCVC7KmmAaqpnGKiFHOAGaJ5nV7e4uUEsZxxDRlZzMISEPEbjdgHPeQCFNK0AkJKQ0opaKUPibH49T691LeT7kQZi7lUi7lUi7lUrQEZfiLMBIQ0+AAEkIKUQwmKodQIFAIqIB6xKgiEhNqKZhzkbB9MYIAzLOF+0tIYWhAUgAhBUaKBSnOyPOkHuQZlSWsPxfxREppwDDsmqApxh1JQ1RrxfF4RBwGjCoE5lJQj4eFEZaIWhQQD0T4UK8UIzjPG54YoviZMGmGzFpr80pmANMhI5cDwJKegUDI84xApSsRqkMwe48aar+yKnsxhDYulSugAHpVL++iwronTgQL60gk4dKJgCAGy3meGyCwRbpYM+AlJHAHskLoXk+lZFUWSstLXPIMECFomMctgN6KB4WaMoiuOJiiYt/Zs8ywavWd84R5zpvKuRm2fBSGkgsKSlNWffHKlB93qa8A8V7B8oqWsfB9PcZxbPU3w4P9bdfYe9bKk486A3QSjVe8fL+s71+DsP+pKRFbEYPezAhCWJJfHBBK7P5mLNbuW5Z3Mcg4mPq9ld/kvFgCGgIiNmidl+vASoxxYbzz62P93DU48psoaxDPSjMObIAlHmzeMgR5kMW31QNpW56R3thpxQh6tme+qXFhXWf9EBRjA/pB1GQBixSwntUGkoLlTOZahRiz32Mcxw5KQ55ZakWdJgxpROABXAoqTwBLWHcKQAgVKWQkTNjvA25vX4HrEUT34PIc84FRJ8J0FxCIUeYZ+1Dw0x//EFf7AZGA73/vu7jaDXj68RM8enSFEBlff/0M//Jf/iv88pd/j5ILmAd86+Pfw5MnEY8efYwPn34Hu/1THOYBw6MrhLBHgUTZAwKmmQDaAer5GAJQc8Xh7g45H5sxr5QipJ0mg0ABKzM21CargA181lRU3L0PdXTaWbuQdbyHpe6D+Qypllkj1lk6xODuQwUNEWAj6XQPyrhrpsMGJnpAmGyOkOypSzCepY/XBhwnl/n10cHEukgvuTYirI2FNv8EyBwW89l+Gvl5mqbFPhOjRfzocp+tyfWetCaxbRm8Hlp39gwvm1rx42Z7gX++yRaegOVlHt+Pb2KcvZRvVs6ONREIo6SZS0bglrDowzAiDWMDpXMpKFnGdTfswLxr8qWtGQGeFWCvGkoeSqCpFVxL8wS1egHYWB99Xk3HQ9Mr7BqTY/16sTl5fX0tOhMFeZemoRWKgJAi53lCrXpmVfkuku8WOpFh7ed6b/Ce/36eG9Bu56C/xhNpvS7n3+XXyO9CYRM/VzKEFb8H2d/rz5bPe/0+9b76Zy0TPXTd+voteQogFJg3t5FxQyc+EHTtWVRXWwNVosKw7ol6ZBKjR6td1kgcRyy9JIlBX9JgdNIHq4Bknt2oFYWXqfKsDd5w9ib98C5FZO3eX5tzXvsIqzkE6wMiceCxB7prFvViIwjYc1d1J9Ov7MxurA+xl1KTXFqRFNwMkIsy3H5wk0W3G9/JF29aGDibwvrcHWSWYl85Lc2sTugUZp1AbYa5vrV5Z+nnFuZmZkgoF79/kRvfB6oZAgJ4Maatjn5sF30pQncbP+1PZiC0kDIs9SFLf9QqK+tCc7BKAGtSXQHNgCryFAOQddJkPyVMeGcBZsbxeHTE5WX6JY/LrI3V/js7M+yZMUY8efJkQbS0qApGUmVbz+1ZncBkESBFZu/G71Izcp5RSm6y4m63W8iRHoNcronTsj6zlwQYl5YLnYhh82RN+jCM0Q+3JxytS8eVZK+1/ljLuUAnAy1kDiKJcgGC+ZMISUTkGJCOteqVADQKZ0EIp3L2NE06xhaBqKd+lNfqPCVxRIyu3UbME9KBKrRkhIfQCINNXojJEbUkjQyY2zkRGQiBO0mGaFOWF3mNESgghqiOqX7/lP7pDjd9Xday2gNxeub7OWLjEKKQHKxeHkNoMkGtGuXJ9gbbt7Y3lK0zixhACEqGloeQPUzuwunc1jlEtPmuyi6GDFEjA+ZawJWR4rBZty3HgnX/bOlC/jpPNmKukt4ZRu7T/mppqO18E2IkL/aJDSxl9bffwyQyrZy9rH3QZHaTzXWfXqxJ9DUjWIOcm7VWcK6oVfqwFNlruTIKMg7398g5y94FNCeZlBIOhwOmaer6ZKkoheUdlTX9dG5pjQFzLgEIEYFk/Qmh7wDJFFCRhoQ0BDz+4JE4GWu66RDFxjAMkipPos8Q5jmLgzQzauhYh+gVRqwZ35iAfClvVi6EmUu5lEu5lEu5FC0hEqIimCkNqmxW5HkGoyCmKAxlAkg9mmspoBC7JwFD0yc4pYwB0qgrACliEEXAJILk+jaFpGIIowh6tYBr7kIpMyoK5jqhWGqhEJAooGpYxhBFASGIAhAQUBsJxYTZgFIB0jowKrjmniqCrM5LEGsJNJtwLMJ/jArOUgfdouRgQmmhySXsYFAPlCElVDayiirzJN+bsEsUtJ9UpeDa1AlaCdLVlB2owdGRUVY+bi4AACAASURBVIIqGaJMShvnedLuIL1H6uEVEwOeK0SZ4mYgEiOXjTsBiOjgJKMbbA18MIDCe3evwT8DJ7oyIwz4GIWsZcbCWouAocZUR23AgxkFvYLkCTtdkULTOdeA/FqBWQIMYvS1/inqOZbi0Kd3UC+REMCVW07hNWC/Vt68QWIdKcM+O1m3G0QZX9aK2hbgSu7/NytrQO0N73oNKPxQ2QYvH64DufGV8bZBXyrQVec2O2XeA2MLY86iHrT497Zg9mZ48dcVevuu74bz02etfll9T+379Tsfaqtl+DoBXQwgbm3gTsaDhSyWkLMCqAmwTsqSGHepgT0GYPb6GFi3AufXdcN2v7+N8Wbr84cMGltr3t/riT8eqNla+1tnUgMtwchFvIoIJOmIhgSwRACTM8IbT4H12G+Bb6sLEJUYari6AGwyy/I8iwE4DW3OCLiUwQDSEDEMO9xcP8Z+t0eKSvDhfl61BzNACKiFMaQRHzzZ4+vnX+D5iy8BLnh0vcf19RWmuxmYj0hUcXj1HD/7f/4WtYpn6X63w3e/8yn+iz//Z/jOtz/F7//e9/DkyQdgrnjx9XPkecYXX/wcX34VsLu6QimEZ18zhvE7ePrRY3z09Ak+fPoIXz17hs+/fI77Q0XJR0QaQFWJQCSR1yyCDoHEHsRCbp3nGVPJAvBxl51KKS3KhBmCFRmF/W9E0Bb+WPu995X9rsPj9q/KVaLbkITqL7Wg1IqoEfC6COOjNuizqu6FDECNG7Z+dRos3idGnhavvzdj4V25BtWVgEPL89HmnieCrEF/OC/aJl9oPdbe2SZLmPemPbfJAQDm2UBoI9d0Y17lCq52fi7XuzRRng0iFDY5Sfe0Bs5T6x8zprZ+JGp7dG1rebHk0DbSbm5zcq1cXw147lKi7sV2b//Mw9dvXBh94N+qvK258tdV3qXuvsk65mYIaFfYmLpWunOaQZKAxOYIjaAQxHkgylwLISCkASEkMcBESW0UYtBBUp0mUA+tT6IzVPPgLwGFCmqWSJ0EBbWLRTaQxtRSJcy7RuQoJYvu1sg7Ql70BO15njW9XVqtH/W+hup1SdMuLeZ4RBpC02vMA77aPGzGhdDOcblP03Rw976mAHBZkkWPx+OCULoVlcbL2v4zL3Mvx/zhufKu5Jp3kYHPv6dt+m2PaG3Vc4H0y6WMX+GTr5he0/dLqFxcdB9zhpyN6j/YD21vW+pZwFLvsb9by9w4eQPp+n0L4lQgMEfdY6V7xJgV3V4pfZUigamCUcCcUbgiBBL8QPWFylXTKYeOVwCIYUCp3UloGIYFOd8iHNm5bi/lSs0QTERKydc1wTYWNrLSb2r2WkQzWBv0tvrWz22TD2xcN68jmRGyCvUstXSS7X36fmAR5cnmWp9fnuRBXV1sqSGtLl125PYFGuZhe4PtDpJWWp7ZTzlJs9LTbnPT9Zwkoumx3Cp4zdJdZYby37h5uv62As0BwIQrf60Yktn6aNFIlnRU/r2yKDeOXBO+tIVtzujHQQzjPQWLjhoRCEFkU7KozdZXJlsyGjmGLY0LxPHLk5Jbvam9OZAQnpgIFnFV2lgFo4GcBYGSnIgsxueg+z6FigDCMLiIUCTP6fKbpTxyUcVInJmgeAt0PsQY23oGRO/LJSNPE+YyI0TC1fU1AgUcp6O0IQgJNSpWNo5JZfMspM+SBYNiVtwRTZ6WdyaEGCRbTBbnLJHDI/za9XuYx8YMj7AuJLDIujZ/7P4QEFPSqA2dlMAcmyZtbfZ7eggmC5OTPeHW8BJnqrWeIV6LvM+oqEwoc217gI/c4nWUNn6kxAiiJlKS9U1sNW/yZjv7iZUgZDK8RK5Iyc8NSxMPldml3Ra5iaL0Vz8TZSVGEjyRWorLvviZuWGK5mRHRBiGBCIjVSgxK7g9TSNKleJ2K2Yop1MdTQhUSdcklDSwdNirlVUHYT3rewoac1KxOtl69PpHW//wZ21F0ZRGwnnrfbzYTUiIgLZXke+X6nRG7clAAFjXth0PC7F4A0sCUKl6FeVs8edaCKFjTauHnpPttmQMf4+dl1sOnqVWIEv9ZBxlDutU7++1PmIbr6VO184whuJVNiZ2puspTBKBfs5ZRm9BGqwLnI0rNFqeP/9U9yVCiLt25nKt4GBZBABwac6da6eLRtDnHhEnhgRUqac4L0l98izRZCiQklyC23cCdvtRUkbXjPtDRpwjmKF70h5xCBpxmJA0Wu0wRAwxijNAEJ2h1IoyTwBX7HZ7AEK2JJV3k+opl/J+yqUnL+VSLuVSLuVStFiYvOZZQALMVgVz5lpARuQIACDGIDICiQFXgIYF7MI0gRqD3sRaViClgxok3i8KljBH1BrANQPqUcy1Ys5HAcdiEsENHSBNaUADNFjV9UhgDW3agWdTiPR3auYKYfuz5X32IKKl7wlNCQOosZ+Ngd5IKkry4JxRam3KkUQpEQXchGbAFHwBx70HaSWVxrkDE0KkCS3KDCDCNKk3SV2F7W9AiJpUapVQiBRIiS7yjgZykShUtSqLX5VrChqaF9wVviJKUggSDpKChJtfpwMwINEr4NIWIeU08g11IMSHtvRKSOWq/deVGlPSfaotm4N+DM1A3Q31Xdls5IkVGN5BSUjUJPc+zhk5qyG66rNaxAXSnOxY1GddPIjilbaTMKrkFd7zz1m32747X16DHm5e//bA/7uWc55+b1LrDtajrQPdYhQo4iWwDW6eTX5u9Lf1HWzxlrftwpNnvE15h5dtvartY+c6+Jt6aXSNXnYNauBB22iIQWq8sVYJnitRqoTgWMBMktavobxYIjH2RvJPWv9u1ziE4z2ULQOOvZs2Pz9/v/9sy/ixeW3w5w8aeFeZxKMItNpPDLzTfmj7vmsH1LOrgWT9GgYU9Oz9TXqY+1USjRypYDETMKQB47DDfn+NFAcFFhkosg67jxRAqAiUwZiRAvDBzWM8uvoY3/30Gnm+x6sXX+GLz/4WJc/44PFjHA73+NUvfoHnX/4cFAJ+8pOf4Aff/x7+4Ie/j3/+5/8E3/3Ot3E8HpCiyDjTfMCHT57ii589w7PnL5DGG1zdPEHcfYL9zRVubh7h8UdP8Pt/+C08ffUM4f/7GT771Ve4e0WIdQDXKEYms65orVn/r5AQ6VPJyCzR+SpDPSa7Uc+kpODCgOsANY+q3qvsZpXAcCffewCV+hoEkYJZ3fNzMS9tLJsQIOcXOfCtV20FNi5S0qm3NTpgbfcYWY218b6O6/p4woy1xww5fY8GGtnI1evcmumpAqythOUZ2ffyJjs5w1c7Q4DFPSLOymBW9qSVVsnNbanNHP2PzavXXcvAsr04HTPfdlujHcXFYs64b96uvNMZt7lN/+OUd6z/+Rv95+zmiVtDULJMiGq4JyCMQpZJCSkZOUsNVSQ7IDNAMYiEqwYnsIDJbMRH9V63fTfovWIDkREXakTfH6xaRm4nyBqXfUTWR4hLwrY3pBFRk9VbNCSYl+cyrajvnxgHIHa51jQuW19+n4ihG2znPMl6Nx1kZSDa+tdGZ3UuvyvJZatsGWO+yX3vUisZO7R+sf2sndVaghm7IYaNUnmx50hxc4TsRCd3JngZ+N3Leny2dJrFOeDHVOeESpK9xkRA6N7ifn8PSpJUqyDMMAg1LlWekQvAtYhjSZSUxVA5itn0D+k/OT8l9XINUgOfHqYqWbJWq50aYgkoyLDFGpS3gCoGoOD6uCEp5jAT9Ow1meFkjGmxn2+NktyyXDet7/RZtn8YMYpNaqdOeuImg0D7Wj6V9bt+59ophpoeZsZ7f05X6p9baXsD0PtF8RDCkigs00N2PZshnUDfe+ZUR9jqr9pk2l7MIYoalrS1fk6jkK5Gx+5tDlYuAuoqJcmmjmPvtL707za8LUAM2q4NQd/Znmh9CBtfwYhsjTAYgTUqiK4xW2vdWGtRnaDvNYe1AOagWIg5GAEBCQEDCBEEIZcMiTAMGpVGI3T4/YZBbS6ZE5lPd8uoEvnanNyq3BtJCDMWCYa5ClbFSuAxojPE8cnmY9v2IKQIO+dSHJDzQdIPliy6bAhI4w5GpiAE5MqouaDmnk7T0sp0zK7PaMG9uqNhKaWtEehepSu0zTkhngQ1NoseF1ReYCaQYmPiKGFRduQMT0Nsa0xSu9cm10Lf69Oa+/14EYHaSRYhSNQuw/wsKmyLbmfPJDuHrP1dXur7hd9PdH+iAEJUchKh1gzmihgluoQ4/lmkHzHEtwg2gUBFdwV1tAN1eSZCHC+bTuTWuZd5fGqqGGOLEiR9JOlnLDKoLVHmglQNg1VnPnTMlHQud2L/Mj3VAr9sY00tRVqbs253EL0KbX7J/mkkHhvnoJF+tI/af2jr2c5Lwwj8G2T7IJkBDuenIBEE246y2L90rNd7L/XHE/U55cvpNkhtThMv+8C/85y852XBLezV69TWx/5c7+eXEcOWz24/CThJ7852TnX9lNnOL9OZQyPAiMyj7Wznh2zwHcLuMryvjyynVV3BsLTJBJHjzcHJzzsjx9tnbT5GNOKnBKKtkPSWMu8F+++4vznupGFELoTpaFEiO6GslKypq2UuNcIX1Pm2CpmZo/YfJELTkBIY4lhUSgZXxjCOK4noUr5JuRBmLuVSLuVSLuVSrJAoy6VklDJrztaoCiqQ5yLgLBghKXDLQM6zhBJXRq8J/Bau25QuwAuvAsXU5gKg/PcQRfhSwEtyb8YWRpZRJT2DKigcjdiiCr4K7k3BAMGcnhvQpIpnvwZoIIcqE6asbrHRY0wLpdFH+KjVDDdWBxEWh2HAOA5gri0lkoVKNZKPRffJOTfjz1qQl/dFCK9maVwyZUvqGBehWi1kKciMSxmMqoQjNA+YdXtzySiQ/otBQ6kqsG2RaUiNnF0B13o2RZdgBq15nhckEBuD3W7XQj5aPmYjy3gvV99GZl6w35vyGyP2+/0ibLs3qHWjm467m5eeVLNWnhrRInQwwXuClFLa5+cAhvVYbpFfvILiy9pw8SaEmDXhZjP86H/EqoUfTyu+z31aAis+ZLN8Z/etn/4w4PqfbiGgERJX3zQQxyI7aD8zQILuNuAuwMCjICRGJcMZNBtCBDi/ebW4A0ni6X8669/FAPa6+wz0W6/Pc/esjfxbBqaNGpj/JkIAUtrJ2aPe9wb6+P2pOkCoo1XtvwbwETSqnDWmvd9AGGuP/JTUHUEBxbHtxzElfUhowKYECVJAyAiMBr4FIIYCwgziA1JMePLBE3z67R/goyePcHf7Nf6v/+Ov8Jf/87/B48eP8a0n/wT384Q8z/jJj3+MuB/x3/23/w3+7E/+BB88foQYCSkEfPXsFe6/vEeIEdc3N/je7/0Iz28nPHtV8OzVjGd3t8h0jZwT5tuMA3+NAx9x/WiHEq4w7D/EkIGSd6hI4OatbxuFnjkq3xSVAeSfEjaqee6Snsm974nYyT8ruUn7ab3nbwF97TughRYXeSNtngOnU8reqU+x6eLnjb/cGa6wIBCdM1TLDWYckGf0+nsD9+J8trc7UHkdPt5kB9vH16DfWpbYOuvh3kMrj8913dZ/r4Hvh87q9T7wvgz6l/KbKKZPrKNO9vkvoLSQZUyfSsOAYdypnK5GwGCGCX0KA9SeowQ0/a4GgIqGhPeyMQEcxMgXY0BgIedP04xSZP9hNZ6EaCR5Sb9rGxEzo+SptcFAb9Hv+ny2szkEDT+v+qKB9V0+Xsq7YuCztWARubouZka9EEiiitYKqBHKjN9e50opYRzHs+sXeHiNveuZ/03K1hp/p1VPZnwSndbIDwABQQzGgKU9SdqHFSVHMIueKs4HXU9oW50acEKTl7ph/H2VLQJHG0Mz+iyOHpMRIEbkposKIQgLHUf6oZFQbN6HgECx7c1FveRZo3KIIT80Y7ro4xVAdwAJ6lWdUjwZSztnSikt1WRKCRQIRR2SyAz3kGiplcVE24yWbGTkAIpqOKtFDL7WHuhO0zCN/qPtGmfOM6tn00VZDKIt/Y86C9Uq8oiP3mJGtZ76Cmhyy2psg4vusZSD7R39jLTrfDTa7bp3ueKcDGL1MSNk/2zZBw+XrWssEk6fk544QzYpGWgyoUs5627ov5OsXamX1s3J4S1N0rpmtT+PrF99uyoQqjecOtJTkyM1xc2iXzWChuoFHLpewRbiR+cpQyIXc4Wk5qCASEkjFJHid6xzuIhuEnaItEOghEADQhCyzDhCIssEbphPLZrqlFneD0Yts3yWhh4xk2QdiJ5ikQbFWaCWghCKVlmesxtHBF2LRSMSj2NCiknwPQbyrDgcD+AqJJ39/grHYwDRhBLVqS1EhGFsR3+pkiK85owAwjjKHpDL7Oa+dySTSCkyfEYGMUJjaOespIGRM9BGvlbF4Ti0qEIAwLXLoaCAUuzcDbAIOh0LNOe8/hmwTCMza+QIm0dNluaiThVdt9jCW7pDY5L3KOxrW3WXD6y9boXovg0E1Ba9HGCWiNmVLf2jqY4EIKocIVGPKAAICdHOByV8WerLRLLrAxJpm0iioTN6OvndbtdS1jJXWJpWOQck0s88H1uKWYt2LumWNNp4zjgcj2CN5m0YrpePrO8aQQFClEnUI3XXkoXWpnuskbCIugqdUoSl9pXxNBKo4qWka7dtmssUncvzczlO/R4j3Hknl6BySS+yNLg9czHAsI9k72QKm4jkOTHN64PL67f15OWz+jpZn1Ndfpe6SRRIbn3t8V+fru0EVyScnI3Sb1v92ntRjgE9f1OXu0UW6Y67zJ1s3qPfL/vNiCmL79pWTho9TL5e49U+HTqAhrnHkNQx+lSnNqzf90cIMlcCJex23lmn95dh9iGElt6pxoo8M0JIAAkZM8UISkaslUlvElGpM9Acki/lfZQLYeZSLuVSLuVSLkXL8XiPw/EWpTByZvWAHBHioMIYMKQdYooAibLEXFGDB1S68OdT4DAzhmFoQBK4IMWEIcWG7zEbWUdS3EgOz+65AiakOCAOoSsulZE5u3fOXQAOCnqpl41cEhoQaBhGhQHAkpu8GQd7kJIF03+e50XkE1MwugeCREmZ5xm5zAghYLfbIaUBz59/tQB4RYkcF17Uh8OhCY4GtnnSkfWHVwY8SGfPNdCpE2YESB92ku/1/v4eQA+7bumQhG0u3q+73Q4IEfNccJyOKHlGABBTwm4cAYi33ZCk7tM0CWipHjWVOysdEAV1v9834ozVc57nxXtzzri7u0POuRlcd7td63dmbsQiUxTsecMwYBgGvHz5UvOoboNjBFrMWyvW3x6wa+9FV0BFeSltrhvZx/fpmsxj//w4Wf2994rVYw0+rAkzngTklTe7z5Ogtkg4di85BfHXWTxZ6DddvHHTk6mApXHWxmsNYnSF9Hz5x2rbb08x8NeFs3XIsvVtCN0jN5fs0r9YhJSKnI/ANCPEiDQOzQumKMj5TbraFPW3atm5fWS1RpcvAjwoY+/2a3JtMFj/bu/YStG2qokDHMXDM6yWdQdsWQio/ty27x245E0T4qkqnkkxpMWetmwX4fr6Go8fP8YwDMg5q6eSeBIRWdqDACNWiROlpNyT85M17/UReX6Bw+EFvv3pd/Av/sVP8dWzz/Gzn/01vvz8M/ziF/8eX335OZ48+QBPnn6IP/6jH+Mv/uIp/vgnf4z76YAf/fAHuL7a4XB3i1evXgDM+LM/+1M8/fhbSOOAwhn/y1/+G3z57A63x4Avvi549vxL3N9mxAjExPjq1QH/4bPP8OjxNV6+fIVaAMIO83HC9dW4AL4WQ+/AIvnpPAYhAGb7Huv9WY2VIbn7JSQ3rcZ/vff3SG0OmF+B9P5d75OgYSHDzSNPSFv9DN0qFs3Qt8f/bucl0EHKGGJLO2ZAfHsWljKRX0/r5/v1t0XKtZRZxNTTaKxkA3+O2zMtit66Hf5a+3tdv7N9+zt8tvxjnvu/tmKhPezMY+6/w2zQBHAA1OuZSNLaphSRkhmlxRhfKznP704YaLJ+7elGZV6LoUiI+Cye3ETNeSEEYBwId7cvMc13OE53OBwOyLkgxQG73a5dW4rUPQT14Kaxgd45y3uOxxlAUPla1pvIURq9M0RNMxUX648ITfcD+lyQc2GAhXNn5k6A0BMnRsLjxztMxyOmacI8CwiehgSKy3XsveFPhsqtsy0P7jciEL7Hcl4n2S7n1g7rfJO0gMEoTvqZEKEsXZDovTL3mDPAGdN0xOFwAFcxQpuzAmAGuz6Plc6A90k0tnNqy2CoFiPH11zJPtWlGwhCAGMmp5t34acUORezpjxMGt1J3oeeaiDGpgsDwDCMGMc9egoQmZdByR5W52EY3HrpeqmkFNA+JSCNVyg5g2tGIpF5ZlSgZNkjYh/LSAGkzjlznsGAeoFbm9S4FJfmDFJww4gWW4bD03HrkQcsenC/ltQ4bP1phrulDrs1D3pUkFPDpJDrlrJjO991PLyRvtdZ6rQ+U5avNjl3UZ32nDc5b3UVnC5K1r5qBGl3BxOo2hphuR9FnyPEAu5UJ7mOIkRfIrPOwqeysJTXJ4WFeEVY7mvSF9wMloYDGCZznCfZIcJyn7Yxt2iVYCVNWLoNzqBoZxiJ7kASJcaaHyhiTHtETSsYYgRFBoUZIRYlre+Qwh6EpM5ijFoPQD2CuYBrxfH+DvPxgJIzQiDs0gAGME8zjtMMhIQPnzwVgkiQiGq5MkLtuJwQ0gtubq4xH48oJSMEBlVJkZ5SxH6XQJQwzQxcWX0SprnittxJhBiW8SGKuNrtUeYJV49uEFNCLhWHwxGcBPs5HA44Hl4BzNiNO4xDRAyEPOc2Hqan9f2jE7y7zCh4awwBAZq+ioSEVEEtFQ4HoOq+blHZUjTi6RK38POj1iLEDmZ1Wght7AE8qCfYZ/MsKa3kPOlp0G3tTtPU1rL/J4Qf64d+1tic87pL15MBCuTwtYxcRA66ubnRZ3DTNbgK/SVQRYgVFCoiSUTyEAcwEXKpGvFGYvEEm/+EhjPMObeoMcMApCTYxjQV5DwhRsGMmSXt1vX1lawrycuukcg64aCUjN14j1wkOk45g9l6PNPjh4ARFrq8tsSGuyOrXC+EsxACduMIZsGlrfR7O4a/3FMtouhy3zTnyH7vkvQEvzcy2rxvE35r/yWS6FILcuHy63OFeDk/1zqWfd6JLP1skrXWcd0+DvbenupLZNKu/3md0d6xfr+QOJbnmGHP4nwrUWRFx+06YYw9fXDYkKsBIUXZOJj8sT5n7Vpbf3199SEKISjxbHmOd7tKbEQYIsLV/gq7YYcYE4CKaZ7w8uVLWCSrnEUOur6+ajLVy5d3SCnh8ePHePToBrUWfPHl57BUUAA3vP/6+lplqYJpyhjCDileSUo8k/uUACY2CFInMcb9/ZqgeinftFwIM5dyKZdyKZdyKa2IoWoYIna7ARLWUpQ08cIiNXoV1Cos+pQi0n5oypdXtAz8WAuyKYpyl0LA3f0tSjbPLbkupQSmKN4hFrZTWdIV4vEW1RPk/v4eOYsCIEJfaSmd5ENgDOLx3oxziAJssCqs0IeKtobCogAkSgvvZQ/qWHt88WkOjK2fakTOGdM0gZlxdXV1YiS5u7tbkDSAnhN9K4rJPGfMkDDsRtLw9xrxZG3ItV99lBcPtPjoLta+UgqO81EVDEmnAe2fXLJoHlUY4C2EK/c0ChIKfKkUm8Lm54YBBT5lkwfAD4cDDodDy7HqDYMAsN/vQUQteo9FmLH3WDGF2xQU2hjHNUjXQCvqhgz7bB3BxYwZvc9pU9Hxbbfr1v+snVuRZryith5nvwZ9WSuQvY3Oy/AtCrX/3q48BFaeBd4bYP9uZU008OvFvvfjvQaYHyYq+Gq+XS3PN/fh55yrybk6PvS0927IJICwnrMAlGzGLCnbIgUM44gnNx9gng64v32Fw72QBXe7HShEVGaUKor04TDJ/qSexA8B9Q+2yWE3J1V/y/F7bdFjxddpax36731d1iDlw6/StVwhaXSsAg5M6hNHSXJE3UEWjhgDTdmhe1Dbk8giw5inlc9XL/LBfr/H1dU1YhxwPM4YhtQMnZHkvbUyatGQugpaHuc7TPMBMUAImMzI0x3m6RXuXnyJ//1f/zv8n3/1P+Hm8TVevnyOMk/49qef4n/4H/97/Mmf/CmGOGJIOwxpD4oRu/0ez549w6sXhBiAqtHxPvvic3z54iXSsMO4f4RffvYcP/v55/j8yzvcHSOAa1zdaL9XRimEWq9xd5sQ6AOEZMYYQqUMLg6cId/J0kdnx85C37V75JD1IDE0Es1i7mBtKDolb3gyk5cLPEHkdfNvaz7az7P7jAvzvj3f12fP8nw+V9b5yOXsXhrM/TPftL6++Hos+gzo62PVb0tD3vJ8WX/mr18/5z86MslGee976zuUh/r57etnBmTxspS1qfHCScld6qkcQkSKo3pJqim1WthyI5gBOU9K3I+NdAZmCJG0AFyBmjVloRiOXr141UH60Nca1wpJW1BQGRjHKwxpp3W36DDyM0Vri7zC6jwMEgHT5qvJz+ZhPY5JCQYFrPfYOSDkjE5KkDVhRi2A1FtUnBQ0XU7bN6TNJRfc39+KUSsMiOOAykXiwK/G1RPUbQ/039sevEXSeNM58du1ZnW8wGCUths23+UQEFMARfVW1qhv4zAIMSqMAK5Rcsb9/T2+/vpr8cp16nNKXT9gVgP/ey5roywzS6STKM40Te8mS3nS7+lh+yVCy9qRxY+ROap08hC1uSm2QrnveBRSmehuSaPEpDZ/SymYs0WsED3wcDgsHCYA4OrqqtUll4xaKgICYooY0ohIDJ5n1JIRhyRTXtdwCBEUo5JhCIM62FRb1yzpZMC1+fYT9dRbQAVnSflMdKrLrs9mI2tYehpL/RJav4gB39ZxjAHjaHuJzRYx/NVa2rjIPXaWWhRdH7lzez51o2FcrFX56dM5W+qRU/liWZw3en9L65+tH/HTCwAAIABJREFU+rDbi/pXva/sRmppciDE2rUcpVeRvksgLQdQQcgn8niTyTtphbnvY6TXEAE0BCWVy885i7OWXBhA405TF9m5IHNjcARF7QHEFNuzmRlsUUeiptnggFSjRH9QIkyICSFJlBiAQAykOOB63GNIIySVrjg+zEUIj+CKGDJimBEoYr+70jEuKDzh7uUrPH/2S3z4aMSQgJvrhO988gn+8A9+iA8fPwJRwP1hwtcvblEo4erRY4Aibu/u8cWXz/Dzn/+DkMoRejSR6Raxzjjcv8Tt7UvMxzs8//oZXr74Gp98/An+7M/+Kf75n/8pXrx8iV/84pd48fIOAQEfXiUcw4TdfgCjAAjYX0WkYYfCEkkmgrG/GsFhQIwDhmGHq6sr5PmAoFGkmGUv+XC3a/ONDc+s3UGkk8urpIULGmUVootJRBzdrEKQ9PQ1QwK2qCMiMa6GAclHQOaga7JjmLJOLRKcRrlD3xNsf12nIbKzVUizknLe9BeT0W1tXl9fn6xCSf1EqEUxF9Wj2OmpQvBHk2dAmr6ICEQFeZ5AtWAMDIqMOr/UegUEJpTCMv9AqCx4nKW+FPkroNQgRC+WtM8pAJHMaVLJl+hRXoCO7xJRi/LR1iWJEwpqhiXE5BowZx1frkgaTTBFUhJBxRhGxDQu+tb26nmecX9/v9j7LIo1QZwGJGocQDSjqvxTK8sa1cjsFv2bKCLnqe2rQQkZDdfUvU5eLyQoou6E48/cTtjuuL1F85K/Y4M+zNHD9Ntge9xal3L/nepNaGvnFLwRDHpLN1vbHvrnRmBf6p72DEu7ZOQjIdzKehiGLpes8dy1k7AfN4/52rUW+cUiFfUIM3YUeMeK3lN2Xc6GK8hOHjX1NTkcoqc3NMymA2A69BpVqdttzA5gmPa6vHr1Esd0xM31Da6u96As5OBaqdkfLMKLrb/Hjz9ASgNiTJiOYj/64PFHYEjatnmelCAzqRzlzl4qAM0YRgIVQskZc54RiDBgB2ZzqmFcX1/h7u4OPfXdpXzTciHMXMqlXMqlXMqlaIkxICUxZpYiQKvkpRxE0QAgBjkGNNQqMyGgC4rnwMcWSrJWiNtaRckzUgiIA7X0EKLgCVBAHCy4qoLMpGAZYCx2AWQBEw4ZFUVz24qQDFBQYFq9RGJQ7xoFg0xAbiCCKgKZeuQab9wxIoZ9bv86gcMUD2rCsCkjMcbmgSbCaWxeo+uoFsBSYVsrVKxCvdXHA2FGqGhgowrrlUV5MUKL9CUWz/HGthgjBg5dxGYRbk2xKaWgzDMItRNuQlDlYlYnXFooClYfK9445dvQPCPRgb5131vxiss0TXj16lUPhe36skdkgUY5WBq8tgybC7DAGyRWwLz3FFnPDd+Gc+QLf53vl7UR0N9/7p5zRr1Nwgwb5PyWYLhbd79rZUEUWrXhnFFkTUx6u3ed++401cc3KWff9WsYpu13kYTtdqQBXwlJvVA0JQ2QD0ccp1twKShzbh4qHexjlFo0ZPYe19fXSIN4fx0OR1Qj7eF0nlt9fN0WH73lUJ7r2zeZE35feJP7tkg1bzY3FNBvG/Y5kMnVzT+bgRCXkWNC7GA6FGxKIYFZZAEiahELxnHEbmfpGQkpJpUdCOACQmmGAEm5AZQiwE+MBbEUzPMBd3cH5PmI633Ai2ef4asvPsPNzYj/8r/6czx5+gGAipQIn37yCX7605/i+voRCAEvX97h5Ytb5Fmitjx6tMOTjz/E06cfYBzFCM0h4u8/+wJ//4u/RwhX+PLZCzx7cYvb2xmlXKnxokgKBAWqiAfUrOeFzu8QCwIVMdU1o0Y/UDvgaOCYAG09ykwEo4Kqj1ymxlx9lPkji+BjqZ/c2J3Z5xff07Zh+MF52zG1tyjuhrfZJ183P9+jYfrcutpan8v6vf17LuW3r7z/cVELKJkh2JtHO4mwVka1CAMMxJEQYjdUlOq9dM1QHRDigFrEm7nkjAgxgFgqiVok+kBUEikAMagXJYcUebYQBDSqTZAUiBIMSuUgAHDyRzQij3m8K7AeYlASoXio16CkxyGikvhpS0j+rvOJzqbri9Q3QftJiPEuEhM0vQCLjolIiHHQvzUaSAAqTsHwE/1ow4CyGLlNeQFnr9l612+qnJO1zA+EicHIIk9SAFEFhYKKLCQkBIBn5BqQywFDUsNdEGPqnA+4P7wSI5ymD7JDSAx+Zlp/FxnInvXmbbWMnqBuQNUv5afpXtTPyyoLzRF8OynMMINGwKhLPdfeG2NQ5x9pqcztnTyjSpj/klltdD1CqumZNudTSpjnuemwV/Fa1g4xGIKBlDwha5olwwLEKKsyU4iCeYSIQPJ+zhmsKVgCLdM/mHy22JPMagnrttMUtTZEBIucQrY5aIomHYoQ1GhtEetOI8alSKgUUUmNt5a2yeZOG1i0/WCrrAk9Xgc3cl0XcfWa+pqok4vX9T96F3HTJZgbDNXnXJNTQts3Wy2a+KzYj/5FzXhpbY4IEMKD9IX+rnN+S9ZRXpTKjI4YqUFpKkSX4ggwdK7DosMs53hBlUhgCNIK149sY4Ju5BbCMIMqIdKAzFVONhqQ0oBxNwqpzFKAg0CFkctRyB2QyAz74QqVA0qZUbOkSaIIxBTAXFDLhGEI+O53v48f/cU/xY9+8AR3L7/CF5/9A8YY8IPvXWGIDK4Z0zXj0fUAHq6RdiMqE16+jKAa8b1P/gCH+wPubu/AXPHo0SOgFjx//gz/77//HF/88t/h1ctnuL19hf1uhz/+4R/hv/5nf4hvffIIh6cJH+4z/vJf/xX+5m/+Dh996xP85D/7z/Hxt27w/MUL/OpXn+PlkZCuP8CcAUYElOxJaVRyDIFSQgo7UK0gqgCiYm6ke7PDamy8iVQnFnyt1IqaZ6CdhQCjYBx3iMMAkGBlIw2opOleLTVsAECGMxmuK6QmIzsMw67tkbJnQc//JQZomOY6lbrUvzTCjGGndr3hbH7d9mWn6Sd1L1gTCTw2SKQrjRgpVFCdcTx+jel4L58NEVf7HcbdDldXO4zDDrlUzFNBKRUSIChivLoChUF0Lk5gJJgZOIaASIxI4jBKJASCUiVqjC2QUhiVHVGfPCbEkGguB9QibWOOQE1tNzDxcBiAb3/7Uzx+fINnz2/x2efPN7G+lBKur69b/3nnzZq5jZ2sV0ZdRfOSCH6dOMVcW4pAI7r0qCJKTmAjwzgcRlN3cttw7YyFRizpjouWukjmROjZ6WDp+6jtSS1ylptTlYWVGQiLOcEKVAfXPtsPgdoce7aw0T5f15FfFq+2GYfg9uKWgdKNddaoV34dd4fK0+hMDCGaJ01/ZSmILYJfewGWcx8s+37th4tlcBZ5AHBnnvWVXrilimtKaMM+qZ2BPXKe9Zs/B6yNizM4CtlommfkFzOOGrErpR0A2weozSVrW56FGAO284ab2ML/P3tv9mPLsaX3/WLIzD3UcKrOzMOZvPeSV3fqtqUeJLRkqS3AkGQYfvAA+MUPhv4tQX61AAP+JwxDje621d135OXldA7JM9S8d2bG4IcVkRm5a1eRPJfdrZYqiGLV2TuHyMgYVnzrW98ik9L00K/arsX1Hb21zJom+QgyeVvsk/XaibJlUlsqla1uyrdTbggzN+Wm3JSbclNuSipZ0i9ERQgpCkuD1dVgPGfDtfRxhJjVREoDVYwl592wec+s4agErc0gEUpyLUMcyBaR0uhVwzUlbVM2tOT80QGSgcGIj6Px7HqXriPEmaAdWrkBUBPLK0WGxmQAEwlKDFsxTsXxpLRKEeVjtSIi2S8OrziAD9kxqPKmMAErCmH/Z/JK3sCUG4FNoIh8PZKjESXAWeH8KTeb5eZhvJYaQfEJT0BqHFIe+6jjCI5pjTE54ikwSPyQwP/gcU4IMxAHiUipQxxyrmfFmG3PVMrFllHwSqlJZLkxRqKUcq3VqN6yqerinJsQbvLnpVqC0qKYUNanvH8u20Cs8vjynY19dnpsvudmOoeybDtv8/Nt/eLrlKucA+PfL+UhvbZsr9235/x8+ZI3jPJ3TMBm3o3KlDMCpxunXXPVb9Z+KoEKY5tIlNIQJSg12F79l3FcvEzTX+lIkjpsfpvbciRfbfRxHZPzJYoDIAaJ5k1XExDIJGeBgDxaG+Yzy3KxZHd3l9m8YbVec3byIpEGx+jREvgdgOrJPDf+2taEXzWmriQlXPFdvs/GyC4vuFGVrzfvbK+bRoisl6XqB8y/7DtKHG3ifBrrM0SApYNMyr+e14yQgF7JgW6o64b5fEbTzKirapLz2morUdUmO47LFHVRnHnB4UMHtFycH3F2esLZ2Sldu+K7776DigKyxFhzeHiX+/fvcu/eHQ4O9tndXbJYzDk5OSGEyHp9wWp9Rt8H+t4xmx8ym884vH3IbFZjrOGTz77g2fNTvvzymBDXPHlywtmZp3dJmDv6Id2kNJ5mTC2QX+gG+FZKV0/AqjCANyGYYS0QZ1JEawgodBxhRcGC8hjKEtWjM+Ybj+Mo9Z2eN+132REzXP5Sny0ud42zeBxql9eV8f9b+vXXeY6ybL/MlmuWQGJ6KKWK0wsg+Orh+x/FqnVTfvtyHQHiG15p7BhXqG7k+UCm01F5JaYvY5JsKEm7I1Ata6P2orLivCc4TyQ7TbKKQ6GqMThVCrtfG3TUgx2eCS2DzZPbI0z3CqmSDE4Olf+V041kR7jIyitjRBWUvG9Qw5xZtm85Z6ahmNox70vytQUQ11oJGcfnuVjuGq54XVeRZSa2Sjn+c72unPCmc8U4n5QHb8ytX8MMvNzfRnt0ah/I9Usn3eQ6urBZGZ0PeT5TOiYhs9wvHN5HYtQEL46pvu85Pz+j61rm8znGZNs0DuvUePNxf1c+w3UqYZcetTRIhkeM+abD3lPSoOghSCE3y8Spr8Y+AYJFxCj9Ruf1WqW98bCGi+pO3t8qlW1P2W8OnyU1DZXaOKqYOA4Kg0XSoKR9rfgIsUmpw6keQ2A2kwCSuqppZg3aGlzv6fuWbq3pgWgtYTbH+0zAESUPH8H5KD5wI2pBU/swq6xmp3q5mmfLQW/tj5f2msObGMftlZZpjELbTSkkJvYOKaJdmeEdT2sGOe0qiXgzXiLtbdN4yk7JrMKVnfnySOV4TjU3ungWph0vFv9UxZwWy2NjmldGm2BzzsiKMPnfIchFZIQKRjQlKKdUOjFXXJRZRmde6otWYaxmdbFmINLk9QOIJu8LEwlHZ1uxSKUTJXhA0sSoQW0oeMeo+BOGvlpYlKL8OASrRaw2oCPeiWqJsRW1qZjltHvWYmyFqUQlrLIpJVAUFYMQOxQapStRr9GaGC1Ga7yC4KSBvZPAvEjP7qLmrbdf4R//4Y+5tYTnX3zK47mm71pmjZagCjzGRJYLg641EUeIoBdQHTQQFX1T0c5mEGG5nNOu15w+O0P3p9y7NeOH7/2Qvuu4dbDPj374Y95+8zbe9ywajTVLVDjikw//nNX5fQ73FN995y53bx9wsCcqM94s8NHgg2G1djx/cc66XxFNTU7NmF79OPdohfJjmhetFMpkIt+I22VsLgRPv/a056cYFTg8PMTHwPHxC9rWgRIyi65kbybDSYgRfd9x3nbEEGlmCw4P76AwqKTOpRBVFaVtWs8zOTASvCMSknqJIRiZY4wqFHmjBLEIYSgOATLepcBDn5S/0pjyIQW1RE8ITtI5Rkmv1bue0Mt80tQ1tZX9I0pJqkCkLYLv6EOLCmv61Ql9u6KqLLcO7nD/3gEHBwfs7OxS1zOc9xwfnXJ2dkEfDD2aNuQ0z9LvrBU1ICFtKIzyMn6jjI+IYNfee1FwIuF2oZwfk9JSDnoKGt+5RBJMa4cxVLZKa0xEa8dipvjJ33uN1157yJfPz/jlrz7j2bMXPH9xRN8HnIMQNZWtqEyFC06UAoGYcVynIZg0l2UllKn91nZdetei4BpjJNgqYSoypzrfT/CmGH1KdxXSWpz7ZhE0aBjmGAX4PhCQdlJG+rWouOs8nRCy+ZLqZ/TYbhNSc8w2TEnqzLjtZWXuAZSIY9Do5tpW4iGZkD5Z1/LxZT0KGzHvxBXX7Hs3MO1pirWINmoIjhXCUUyE+fJZleAIZCtQyLUxhMEOkrUmnZPWnenePhb24NTuHtcwxqv7gIoRoy5j2GV/2lRTH5SWnKcLWRU+pUWOcVCZj2mPkdtSgkrzNlyC62T9kj1SngelP2uUcsTY4fqOFlHMy69JbC/ZV4nqUk4vp7b0k5vy25QbwsxNuSk35abclJuSStf2XFysAENVz9FqatSOBlTaahdAneRonpITYgJ2Y4wioxfcQBzRCZgJIeXbHTaMY+RgduZJ0WI8xjhEtWcnXP7RStjJCoPyLhFeAjpmgkHAxw5HzBitgLKqorJzslRzTEZpNLLxcHFUJYkxEJUYsBExDFWSR9RKYQsCxybRRaVNrtEWrVKudO8G8GQzlc5mOqtBcjzkth+/HxRk0n1Lievphnz8yQBd6fAbgPoomzN8EPnXAoIb7dB46UepDMQjQGcyXjNhZpMssulsLjdK+XnL+m+SRUoCSTbqtdbMZrNLIO5VqjallHtOqTV1OJcb0YgvZN/Le2/Wv5SHL8sm6eUqZ811zvmrvt90ln/VeTEmWdxNoP6rSrGZvbJc8VzXKdlcucmJ25wM1xx/6ftNTwNpswmjEyj3wThI/n/dLdd4l+3vbBs5Kl56ptynM4kmZm/CFXf7JuXrttNG0eP8s+24LT2NTF6UW077Vd7sCzgOYDFaNv6y0YaAJmAyBI3WisV8Rm0qjAKrIjr2dKtTdDVPpEsBFMZ1ii199Bv28a9Rynlsc1xPQZ/89Bs1yO9/ODaOH8fpvJh/b86dY1FkxSI5vgTCxjZRBdmDEAfZ67K+g+8ykoCafP9RQl4bQ9M0LJdL5vO52ArFAqPSBVSe5yA5cFRSnXEpQtwT44qT4894/OlvOD87p297XOuYvf8us/t3qRtFjJ4nn39BM5tz5849mnpJVc1ZrXpWF2vOz8/RwM5yTtv3nJ11uNBysT7n5PSUdVejlOEv/+oDPv3sOW0L5+tzPn9yzro1RCxoRZykVxnfnVIlGKcAk9Z/+X50vgBq6rze/JHiyGtmvr6QevO7HaWVZZ6+1HsmZXOOn/SPLPU81HGzL6pLf103T2+9/wAtXlHNq+biIX3YNyvxqvtMrr3xR2G75g+Umhx4/WW21eOKde7bLn8dAOD1BLzt97sqNdzfZYDyKrspf7fl0/S7HPRxGLf5vOwAN0mls5xfnctOADWZgyHinYDNzvVyzdTmvXe4nNI0RxgrhlQtPgPbIUf0pojNEv7PVVbF/KICQzoCrfDdGHWqtBodRulUndJyWJv2iEoThxQB29KfjG2Zn1HmQk8myMi1AxHZt43rhgPC8IypAqkd49bf03uNa5m8udGWn8x/VwyF8phtPaG047at99vK5T6lip98bjFPFbbB+CBqMo/l95BJBiatz8ZYfHJi5sONFrKqc46u7XFO1AuqqhbCRm6wuP3pN+2e68pYxfEK5RlKqUEdJi1+yXlSp0jmMZq8TFEcVKkmI46jEN0QhU6yHwebUyVnlJqqywiZJjlZ0ljUKRWNpOZIeIM12ErU8pQHayyVEQfkuj3HKJgZg/c90LJYaHb3KiprqW3FrGloZkucj6xXF5weB87piMFCDJyeX4jyjYr4ZD5bLeQKk1IZVLbKL0DwA91DNIPaLCQl1Sh4TFCFg63cOxe4QlmGdlBb3jXFGMv4QPEO8++MERmTiS6lzVOkmIyJtJQJKEPXT2MpBUMpQjE6IkoXg3m4alatTbuGOLUPpDtfxhiyszhjOaFwHmc1ndJGUJRpM+I4FBmVX8ZG0WglxARIWIgx2MpIqjQFSsN8bjk4XLC/v+BXv/yIvoXglDjndSUBWiqCTgqERFDiWI9BnIbaaLp2hXedbL2iBDMB+JTmr6qqdF+N63vaVtIkRaL05aqClJamakSB5Pj8Bd476rrGzhfMFrvYqsZWBmulTt4FYq/wiOO1sYZaG3xU+DQmJRWMl/VIWZTJqcw6jI1UVWA20+zuNlg8j3/zGecnR1Sqpp7NSEJFGBtlZ6hyX5e2mc8q9uwOv/zFr2iaGTu1pD9UMbDqWnzXcefwkJ/86If8k3/6RwTvMVYTcHR9K4R9pbF14M7dXR4+uk0MjmdffsSiCbz9zuto/Raz2ZwXJxdEbVmtPZ9/ecQvP/iUDz9+gbIL0BUDV0TJ+9LDvGVHRQiVd6NxnOpVnqdIpDnH+eo52nheuX2P3f0dfvqzzzk5PUJrhQsO78IwZ1dVw3yx5OJixWl/Ru89OzZyd/8evQu4EFithTAZ1DwhqkZIYiGikOCFYe8KYlP4gCnS90TZxcn414iyUQQbhTirqpQOK/VT73uIDkVP9C3LZU2MDueg6yPr1Yrz83OMN4CBYDDW0J6/oKlrSRl4cUroL1jMDHdvLdC6YbFY8M53XuWVhw+4ffs2zWyGQtIlPX/e8OLFCZ2Dk1Xgw0+fEZ0hhoQjJ1Uggk9zUEAhgX/zpqaeLXHO0Xc9OXXkatWlYM1ENIoKo2VPGVNbiYpSR9RJMayxVHWNRkFwRLfGhAvuH8J3XlvwnTdv8+arB/z61x/xwQeK87OWi3Wkd6Iu2HWO09UZnUtj34i9GLQlZsIMUNXZpR2TilCkqiuCF7tJoTBJ4WQbYUbWBsHrve/pnUufayFWKciKQhqNNplI4dEhpWlLaUeNsYjFKTaj175Q9h7x6G1YLlpN5ue83pT4alnELBqVWtRA7BqM3HGFKBYE+Vvm95KsVuL22ozBp0L+kPMlSHes2yVMLF0np/CSa8hYlQNUGu9J2YkcUJv9IdlOCegYBWvZVK1J69QAFYrZNMwfJZaUcSSxD+XAEHOKKVH7z3bWtO3HdS9D5yGEYb7KqoPGVlhVE2NIaQHFUvAhCtHXZLVohVeX/RLl+wV5RukumqY2WF0T3Brvu+HZYwSvo6SMNULAc32P92LHOjf2uZvy25cbwsxNuSk35abclJuSik6GjQ8SJVI3M5TSAiTk3Klpw5QNsxA81o65XZ1ztG2L1pq6ricEBMmHGyAqVFCoqGWzZ7JyTC9qJUnBxLkO73u0SUojYk+jrB4M4+gysKuS1KxFYansbDAwlRYjzrmW3rUo5fHB4VxLVjBw/gJIRqwyGFNjzRwUKf+oAMPeO6zWONeTDdIcgWdMfckQLHNwZ6lS59zEqeqcG3KIDmmNCoBL6qWG73VSYcj/Xq/X9H0/MXattcNGYJMdvum4K+9Tyhjm+mWgTCUDejTGowCIMUge9qF/ZLKIQiW59fzMuR5ZonIzR3nXdTjnJvUYJUWnIK28Uzc8b3n8fD6n7/vJseXP+CxTMNE5N9k4lO8yxjg4JHIpj88ppfI7yEoLZXqs3N5ZwntT5vbbKFdFe5Ztkf8dYxxSU31Th1fpQNksV11viGy+olznjNt6vWvbTkFM6WAG6Dy/g5L4tZnqRBSVvq2y2Xfl/gqlAj6M88hQYtLaJst2b9YlJjDur79sktu2ETculxxhlOs+uC22HJu+jwGSJLJGpKO1GtO0HR8fE50XoM13oCKzeYM2TYpeHOuSwaC/jnIVaasEXS6BQC9RNsGL/Pc24GjMMX8ZjFDJIXqV885W1cTxJvcYHRri2HVpXaqZzeYslzvs7O4N87lzDud6tNYDYVSphAslBSHve3yU6EWtNBhPZSHGDu9XOHfOl198yNMnH2CMZrHYITZwfv4Fb775Fj/5yfu8/vprvPvuO9y6dYuuWxOcpPAKvcMow85smVJCNaBhtbqgbirW5yt+/atf08wWtL1ndeFZLm5xsTrjP/zFX+D8gqpeSIqwECZOwvJ95Pe7+Z4n6wVj2kPn+uTw9okc2w8E4vLd5Z9tRKtyzVRwlZjFpbr+TZE4Nu97XX//1te5MVT6a5VM2fpbaJr/pMp19sXf5XKdSsbWfh0zSTMrW4SkhsFAPBkcTzErMCa73CYnrXdJISJHSZL2Qg7nxhSFRml0AtptIqWU6RyVIilOaoIKeHLUp5Bmpuswwz1jcjiWewXvQ9pfjKqP2Ya5LDefJOOTsoJK+ynF4JMf2jbb6M45ui6neOiI+PS9HOP6SNdKVKk4NhWr1QWri1VSjqzZ279Nmcpp23u69HfRPTfn2avmramz//rvJmu2usreua5ke2/D2TO8nykha6r8MqYfyn3D2pr5fIm1FTHKO5BgDQXR067XnJ2cEKNld+cQYwxt205SyyoVUMmRJkTSOLEVcrtdN3aI47Ns2o+yP9fiGEp9SqU+WRlRsshtXaYHyPfM9TSJvKVMXairktpB1GBE0TAHhYx4htZItHeEdbtm1syhBufE4TKzM6pKiC/GaoxWWNVDbNGqJ+JYr1d07TrtHHo0awyK1x6+y2uvPmC5lIAcq2q6zvH5kwv+4vknfP7xL2hXK1arFWcXLU2zYLmzjzIVy5097tx/jd39A6Kac75q8SHQdR1d1xODorbzYkcl710BITqxt6Iv2iNewgK29X+18e9NDCL/5D19fhebYyiP+dKG2WY3leSl0o4ubaAhvVvpCNwo2+o8HbvTKPrcn8rAllLtlygqiAOhMREhShK0VGfEZqS/GlFJjmBMxXy+pLYV1moqK2k41+sLrJXzvvfWI/7oH36fv/f+I/73f/t/8sknzzg+XeOjZj5f0DtonSTcUYmUiIHKBKJb47oVIbTEmeP0+ISz4xecnx6xXp0QnOPg1h63D/a5t3+HBw/u03o4Omr5+JPPOX7xmL7v0cZQVZa9vV12b+2zmM1RSvH4w5/y+Wef4lpH3ewyW+6yu3/Iwe277B/eplnuEaLFeVBa6lstFzjnODtd0fbCdNFaUnPEKOrORlUYraispbKS9kUFw9nxBU8ef4ENPVU14mkTYhzTuYe0jnbjw6NaAAAgAElEQVTrlu989x2Wyx1CjDgfsFXNyckp77z3NlVTC7GInqgCXRBSvGeGV/Le7azmn/3zf8UPf/QP+PnPf87v/97vc3h4G0XCNlc9TSWkeq97bu1UfOftRzx5/Ix1d07EEqIFZVNaw6S4ZiRlodb1oPZRBl7FsElgU+i6wSxquv6Yo/aI//KHP+F7P3yDqlIs5hXe9Xz461+ynM+FNGEt9+/dJ/QevCEEcFHRe83pRcvzo1N+/dFnfPrFC5RWGBuJyhKipneBbt0C0m9lzMpcr7QGbYla5halNRiT1h+NCpLey1oJBDRaI1l5BGOtayECNLXh3t177M4VRl3w6qM73Lt3m6OjI37205/xp3/2p3z66Wf0fU9dV5ydnfPOO2+jtebIn0Bt+MkPf4c/+MPf586d20haXiEEjymjko2kKu7evk8XLB8/PuLDT86pbcWyTuOp9VycnBNCSE55j1GeprE8uL3He+89YjlXdOsVzkecV/zVzz7g6dNjfNCEaOQ96wBYIkI63t9VHB2fcb46w2rDXO/Rnvcs6hmEwOmLz/nws1/B6inn/9Ufcv/RK3iteXi34fWH7xGBddtzdr7m9HTF2emKDz/sePbM0fcGE2fgDKd+TRedEFjSGpfT5Ng0LIzRw/xPlDSbWhkG4VQlgSt5fhWbsycEwVRVCh7JSiFCpukIMe9ZHU0zYzZjWOO1tlTVDMMU994MHiyDIUv8NaeD3EzTlY/fxLGlTj6t89nPkBUYL6vNjOfm9WK6Z83+irx+Tdc+mWukTeNkvcr3yiSZruto23a4pgSMjth8uR4P+DJ+IMuJbZt/Rgx/s16b66TUM5LJLtswBcEnFAqxZUj9I/sUyvuVa29W5JPrSRrqIYwnglIm7TWk/Y2pEmlWSDoxMrEHvPeDYvwm3l6+q6pusLMK72RPJEQYqVdVVazXa7rVioj4W7r+DJSidz035dspN4SZm3JTbspNuSk3JZVskFU2seKNGNgaA6o03BJ4ppOho1Vymo0/dV3Tdd0lgGy0TYXl7HxABYkel/ylJMNdyDIheGIfUi7WUVI0y9zGMIKFOSeqMTYBGykPc0oeq5WlsgKQhdiiQORCkdzkEuCm0NoLacildokxAXIWoxRd2w5GaJlf3bl+MN5zKckSm+SIIVpOQa3rgo0eJkZwaSjL5joOBJn8O4PRGezM1ynrWb7jcpNSHjMQQ4rraD0SW/JuazhHaWF4m2zEi8qOrSrAJPLV1Piu67pwtLpLdcuplLY9S9km+bmttROiRQiB09PTCRCX228T5F6v28kYiHEkOZWfbbLVQwjUdT3ZvOS89Zukj03Vmm3X+5sqk1y7SkmU0NUYJDAFTMvPXtY9Jpf7m3KubbmPimNk1+Yx38DH8XUc0+X43Tyv3LRvXPl6p66avouvVVe58dXfb/kukh19UjYVr64scSQc5cuOUZnb76VMmqVjHPJGj2CLjBWT5hWlGgFEop/MYVNg4OWJKt+0bBJkJo6zr7jmlY66EIo2VFdeN4M0UgeJfs3gUgZNZG6fzvVl3UOcOlBMAt7ye8i51BeLJXXdYKyldx153GiTpIej9JfO9ULqVIoQnERL+oDgrKI01nedaAn4Fe36lNXFMy7OT7h995D93V0ePHjI22+9y3e+8z51VbO3t8edO3dYzme0qwv6rpOUUEbSHQQf8NphtERbx+CpjJbIyWgwVERnCF3g5z/7kE8eP6ftIUZL58EoAYGMNgMheBs5ZhthKebw1xQ2OkbqdTjXEWJI610GdcMA7G0SrLapoI0OnJi/uLYfbb7jq8rLEhy+bn/e5lDeWo/i/5e+27jG9F7X13P7eerK865zjF9XXmbOuK78XSeefNNyXfuVbVHO79e10bf9PrZdV8Zjrl+pElWueSkacyDnarxXhFj2waR2GTyd6xKALkoEdSWOSAGKPQSZZ+u6TvufnJ4pE8EyGUxhTIVsCUoluzj5PezHNp8LSZEgGSplfVBJnSQ7CpTW2KZOkaOZjCZS+8M8WbyrEDwukX8AKiOpOVzKJhNjxDlJO9W7PqXqyPOYYjFfMp8tJg6PbeTqS++oKKXZufndNrvmurnnqnvmf7+MdSzOyFE1FaaqFWN9xv1aGKKkRRFl5HtKSsLVqqNpZI3UiTiV+1hdV9R1nfaQDL+n+yT5yWl2dCYOFM/3VeMt6wflVI85xVJ2wkSQNZuIyTwjZfAh4BOGoJQaAknK+5aBEjFKYM+Yilf6jtitmuCnkcyD8y4EAnEgohEjCp3SS2p2Fg1aR+oKbAXRd+wsInvLBbcP97l9eIvFsiF4h06popWOWBNTGkghEltj0YjD6I1H+/z4+2/Qt13aTwdQFhdkftCmIqD4D3/5Sz57/Jzz1SnGO6yxLHcqQjC0bc/F6gznxPZTWggbxlT4KMq3IepLASeZoLv57pRSYzx+YZds7mHy+8hBH9et+SXBLgcL5TqoOB6fVWg35/dttsw2otz4LJt9cVTKKp+33H+X+Ei2f+XU7HyUEor5NavoGi17GyFIGpSyxBQIVlU189mMWd2gtOy3KwMRh4qapqlQBN579z5//3feYm9Z87/+L/+Cv/irD/mzP/8pv/rgI85XT4lIlD26IhLoXYsOcPTiC85Pn3JxfozvOw73d1EEarPi9e8+5J//8f+MVSLGVRlNVVmMsaw7z7pt+fLLV/n000/4/IsvaNdr5vM5773/Xb73ve8ya2agoG3/a/pO0itVuuGjT5/wm08+4/HjL3j+4jNePH/Mg0dvMq9rlDZYvcZ3nuADVgdULanHg18zX9SJ2heJvqdveypqlAvg1qyOAk9+s+bOInK4O6MyOd2UHgLFBrIe4z5PIAxNVUdMSCoHyHzlUcz39un6lpVz9G3Pi+NnnJ2fsVqt2du5xeHBHaqqpq4MVV0zmxkWix1eeeUROzs7VNZCjEJ2ipJOrXeOWkd2F5amqvhn//jv86sPP+XLp8e0rewHuq6n73t8CNI2TY0KinW7Tqmu8hwoam2ZkaXTXKEIHNy6zfrC8vOffsTzp/8Xsxref+8dfvCD99jbWfLe2+9jTVLtVoqqssz3Kvq2pe+dqFNUc+5FzeuvPuDunQN+8cHHfPT4KT52rNpztKnZmS2gWrJadRhj6XpH23VpXTHUtpF9HGl9MRrXynphjMUkNem8/5IgC4/3Lb3riLHl7OyUTz/5GXcPlvzo+++wM9uhUTMOdw758d/7Ce9/5/usViuOj495/Pgx//7f/3vOX5xjbcX+Yp/bt+/wyoOH7C4WVFoIQQpRltAorKmIaX07uHUL7+GsFRLMYmFZtw7vVxA1RgVQEdsojHLsLCz37tzi1UcPePjgkOUCFC3egA+aiOb9dx/w5a05J6crscsCaFMTMfS9J0T40Y+/Sz0zhNBzcXHOi6cvaFctR8+P+fLzL7k4eUJlPe+++wbGgnMrqvksrVSSFmrewKxuONxv8O6AO7cO+eTjZ3zy8Rc8e3qM0bUom6kaH2WewlsIWsK+YkQbqOua9foCrcBYhetbtBEVVQLEqJOSR54zMwasBYtP+IrsiRVGW0mnlVf0AfesRsw7arSuMNoQvB+CFjMxJM+tef7dJEfEjel7cy0pP8tYq1IaNIPNKMdajLmMzWS7IKeo3FwLy/WnJKlsKyWeUmLG+ZlL/Nn7mEgkKYWjkrXEGM1yuQNEetcnn0Qm0kNOsW2tFcWj4tolVj2SUPr0nCQ8iOEnE2lknRrTZiujqcyoKphxfLm3qP1lkHgMNEyfRSRdKvl5ZUcTY0rVOpCMyn42lhxUOtiDhS9gxP4jnZN7hjSviyIcOK/QVU2lkr+AgDYpBdp1JO6b8o3KDWHmptyUm3JTbspNSWUSeYSAWEEl8kj0gwGojQBQpGizTTAlR1FuqodAUhoJARXBGk2IksYhpt2POP9GkoHIhSpiNOT8ngPYFcdoMTHmAl5FjMkSolrSCcXs1JLoB7GvFdRmYKJ77wkqyVm6lBtdC0M5ZgPWC7nD9U4iNIwZN+5RpBMzSJzLNifzmKczyRH2o+NsaOMNskc27Mvvy2vk43K7lSSR8t2W7yqfm0k9So2KJ/nfWmt8jBMwVSMYe2437x3EkO4d8AnkDx6UGftCvl9WINoE03IbhRAGMC4/e/ld2a4CtLtLwN+2dEybEQM5/2l+3k2wPJdM3JE6gWMkFGViT27DzTbPm4Ftjupcj78uB89m2epASH98nTps9mNVXuPrlq8gy1xVj6+jrLD9RM82EHX8M4Oscfx9TVNc5Wi56pGuPD79HaLZcq4igxKiJLOtQn9LfebrOsCzM244dnR0jW09OWPivJsQCWKKjh4IIBrBF5Mzr4iEz3NEma7ub6N83Xt/U+f4Jnlt+lsDIygloEzhGCUMUrz5vBAjQY3z0CBrn+bHWT1jZ2eHum5S5JM4areS6JJjwnuPG5AaaJqanG4ohEDfORQKHyNaQ10ZfGV57dXXef977/LmG29y/94D7ty+y3Kxk9IWSnTuyfEL1ut1UsUSh1tlLSqARss8IUYDKgZUkM9CAO9AUXN6vOLoxTnRzAjUOFElTu2VJIo3wDmYRnltOllyXvJM8MqKMt67ITovfz727fG9boJ12xxFeVz951Redgz/50Y6uSl/8yWW/8Usk56deMX6l+YV5x14L0c4+T7vTXyaH7TSg3NV5RRJCvF6Kp0csmogypRk9HJtTdyEYp6m+C11zESVOJ2I5LdWQzpelT7XWkvaAWSl8eW9kQhmmwIXgvcjcT6m/YsrlNCSCRCTw0eIHmFIWaFI6Z2IqW1SG4fkRN/uM0+PsGXOGH3mX+/dXjEHf9X9ZF1Q+G8sAKgu7R3z9cr3OH4mjmSipEeUOst1RjKKwTuP0x6d7GBxPCtC6CF6fOjo+tXoyCrWqORlIfupVepUkThJAXQt4Q0kzQLJkZKcwiIiEwZ7Q/p5ciZpUX7I9sy2dbEkbcizpzGW6i8OOlPYLCP5QvaiRQdSSLolawlBnJU2pV0wOoJfYa3CaMVyMePRKw949d4usxoqq5k3DcudBTY5vXPaYklxkmwllSLHTZXaoGF/ZympS1JEfVSKgMYHcD6IfWQCb75+NznfPShDVc9QytA5z2rV0faBk7MLjo7POD4+5fT0HO8jSlVoZVBp7y2KVeFSG5bOqoxllGmKc/uW7ztfY3Mfv029psRA8nyV3/MQvb6Be5R78nLfKXtuM/Tzsf6j03ezB47OTz+x4TbvVWIoAK6fpnVQOUV5Io0J5mSK+kv6EpTMe03TUFuLzgTs0MneRTnasCK4jhB6vDsH36GV5vadJT/60Zs8enSLp8/f54svjvn5Lz/kNx9/ycnZiQR91TW/+sXPcesjKuuY6UivOkJ3yvvvf4+7d+9w9/YBb7z+UHAuxB7WWmG1xblI1/Xc2tvl4f27nJ2d4Zyoety7f4+7d+6kVBomtZWQ3VSEw7sHvPX265ycXXB2seb0fM0HH3/G4yef8/z5C1YXK6zW3H/4CrPFHk2zxNY1TVNz9+4BdWUwaCpVUZmK0+NTPvvkY27dmvPaq3eZzSzLRuaocS0VNYRxwRhhhAJpQ6mKEJykREKjtEFj0caiosb1Lc+PX/CrDz8GpZjPZ6iqQtcVVV1T1RXWGIzSGAWLxQylwCpJIU9aY62qmNWWEBUuKHzQHBzM2NubcX7RsVp7Tk9WPHv+nJOTU/pexl3rTlHA0bNPUCh2dnfwfaRP2GdVVZIWywku0FhNiB3r8xOefPoRH3/4C/74j/+IB/fvMZ81kiarEedwpgfKRGPA2CHtvaoMla2p0bxa3Wdnb4fX3zrj9PyC9bpPBN6K6DXtqufo6JgXR8dcaIc2iqq29H5N1/u0ZzOIMkmH95EYDU5pNGl8pPRO0vMc4DAGvO95/PhTnn7u2W00D28fcv/wLrWtqWydAh0j7brllfuv8OrDV8c5W1vqZsbe3i0W8wVWa0JaF3Uk2Vgx9wSsFtWbxdyymFtCXEF0oGuU1ty6teSN115H64hRgb1lxcF+w3JR09SdBO8EhwKaSoLy6nuH3DnYl7k5RIKPWFuBMvS9o3cdD19ZYitFjBV9V9HfW6IwnJ2sOD095+LiAu9bXnl0j529GaqSoJKB7BdJ66CQPqN3HNxayDyiOr74/AOUqtHsQNBEH4UcTYOom0bZv0ZYnx9x794he/s7dN2az54cy3uOCpQmYlAx4oMihETiTmRPgpOApJhTMqW1TZHs0HI9SEptKgXaxMuYd/YJlPNvxoQn6jMTzGjEhjfX/nKelsDYIDTGbLeksSDnJsU8LQo4CsTvkFIvX6XyXa492Q6Dy4GvV52bf8vfmagzzF6yR9AK5ztef/119vZ2+OCDX3NxcT40QwhTolCuU1VJasYxOCqldlVTdfqyzUZSzUgalvRZea+QFJrSe9Z6rPuldZOSiJNUNnMwZtpj5D4zXk/afBuGtQ2/H/Y0USqo0GgdiCrttVQkqqQ0W2m08cmHlPvHDc3j2yo3LXlTbspNuSk35aakorVEOuTcneJgA+c6nJOIQa0kl3ddV4NB0js3pFESQEMiv7NxGcKUKJKN2hAiZtzppc88MeXxFBNJgbYCJKdrmAQQekTmNcSYHHIZdFLEIFF3OrGRIyrlxM4GnMVawyjpKGB3jBKlJmo1yehNudJDDCkiTqK3VHLMDdajlnRQunAI54jM/NwxJAnqgUwUBAzIZJBMFkpyqJnMoHNu1vxvM+YjTbjmxMjMqgEZ2BSVhqmTb1PicrMMRrZ3jKx2kWAfzg0SWZF9BeK4hBgVPkRMMmqHzXyqU0jAIhl7Qp41hkjM7Hst+eN9GDcFg8RtMtp98NL0BcFIoUCrRMJSmARo5ZyrDHW5DHaXkpwliWbz7zJSIm/oNgky03ZVxf+n2P21gPMWx/T263/zMpyv8gjJNdvYuG6cl2XZBQdWW46AaYqj8uR8ztcjX0wqseVxs9Pp6lLcY3iubRHqivG5ZTOmyu/yGE9/l7WNMVck+eqHdp0qgmw+h/wyCewpD4mQCYlby3Vttf2761JMXfVNdpTleX241gAkXFZryJvnPC/pYTeuRiJNccfxWmkeK2qcK6HSugPgY0ANIEA1XGtKRiuiiCcdp6zsV/S3zTJs2q/q7+MdJ32cjCpsueQ1HVeXhB+lcrcd5wNIecPzWp1kchkJlCVhJiRHJDE7eNO6kK6WuzCIE0oAyobFfMlisUjrRQFKjinTURgII3FUmYDv1zjXolWgtorz7pQQJIKq6zpxJPme5aJmPrMYtaC2DW++8Q7vf+973Ltzj6ZpUlRyh/eOdt1ycnICwKyZyXqEQk0Gj0pRavKetIpoICSQxeoKH8GjUboipPEHnhhG8Kx0COb2j4LED70p5vbQWRraDWuA904k15OjN8ScWz6dR7KHEtg7jLU8fxT3GW8o38dhHSt/52ee9q1sG7xMuZIQ91uuO5cv+FX1uCJS7GWrccV56qpx/VWLzMtM09dd69u83n8C5RvZCV95sSs+v8K+KE8bppU0t6RVq6iXHubQ0cYIAxmE6IbxaJNkfd5/+BBQCiGCBIWL4qgVZc2cgtVCVINKw2XiXZ43MvAtn+U65W5cAtXOeblv3psFWbRzIMDErlaKTD8e9nJF22TQPXgJighKSIowJb1P3mfaO8S0v4o+p7XS43iMaQ71o8qD1WqyLg729WBvjWTb4f1t6TvXzWWlzb/tu03bbmIX5TV1o35DbYYpO1kU8hIKe6aYuyPpmnpUdU3X1DqpRKZd5+g6NcmRZQeCSCaPqOS0CDGTOsdgiMFDkdaYISAk2WHZUDA6k1/GR8rPOdqNRTsOe9WYlzcZPz5KOiSkj5uMP8RsX+Y21pO+nts592etNFGbQakhhJi25ooYxImqtcFWNXXVYIxN40iBVZhKYQxUVaRWHhVbVAwYDW17zMHBIbduLTk83OPVV2/zyr09tAq4vifGgCEkkk1WnI3EIPbV0BQpBVrM/U4xkC8UKQ2pVSmNgajtPLx/iwd3diClwUAJkSyqRKxxgc5FTs8uODo+5dnzY549P+L8wvH8aM35OpFkALQn6xbGKGPMmEqIBbpKAU4SRR4G+yUMKblHu4PBplFFkFBJQNkk5WxGkmfiSxkFnu3UkkQD0/Qd8u5zXxmJKgNhZcBaKPpbTCm4u0vKriMJZ8RF5O9I8BrJnZdGljFYUw17/9we1lqqSvCwjDNprTBWYXSA4BMG5fFBgZJ+5foV6/UJP/2r/5fbt3q+/95bzJdzqqrhwYM9Hj484OzNjvkMZnXk2fMTVHKm/+I/fIGOHYumYbFoqOtdHj18yI9+9APu3L0jShDZPlYxEUgUtmqkr1cVzWzG/q39AcchO2KVSYQr6SfWWuqqwmrFfGePe/fvg9KECOerNXd/9guefH6HZ8+fc356BtHz6LXXWSx3qWdz6rqiqTX7B7uSZjfK+me15eRozv1DuH2wzyuv3CMSqKpG5rqiX00IXUPb53lT9rchRNrOpfU2Cg5oDGjNYragDoEuag4PL1gsl+zu7XCwt8vuckllLMZIihJd7BuUkrVG5U4VAzEupZ8jRM8QFR7Dvbt7oDS9i5ycnHN8fMz52XkiWDgu2guU0vzmN3Oc66mqiuPjY/7yL/+K87MzjDU0dQOAqSy3dvcxWuPcMdb2vP3OG/zu7/6Ad959k8V8RmWNUApVSgE5BI4Y7CyN14SVaVsBip29He7eu82bPnBxsaZ3XpS3IkQXODk+5ehozvHJkpOzc1arFlNVnJ5foHTNbL5ApSA6oy0RTd97VquWL754ltLhyPP63iebxxF8x/nxM1Znx7TR8Yuf/5z95Yz5fMabb7xJM5sRfEBpze6uqIm+8867gscB3iUMUGlswpZ9IsGVqYi1FnUeYypCBK/AK8cP3n+U5oma4CM7ix3eeuNNtAatAvNKUVeRGHr6vhN1jzjHGMNsNhNiDAqTFK1ljxgG4mVWz6pqnewvL8EcdYO1Na7zojISIz56uq5F20jbdrRtN85dOZ3OEDDVYyvNwe0Gpe9wfvGI2WzBOqXZWq37FDxihveolMEYRTOrePhwj929BV1fc7DrCdFydrbm6Oic84sVqIaBsCwDSVRRvQMl6Z50wtcVGh9lLSaNS2OM2Hs4ovJilxFo1x1d2xGiopnNicFI+q9MmDRWBlc2cFLgE6gx1WTCKmQtDcneSOSPZNcaI0GwMYhCXFnEvnUTosdAshnUGTORMg5rXbbb0zIu85DWaakOae282jbcVDKXNGEJN4pCTiL5IQxKyFZ9l3DkrMSjiJ34TrRWw3e5ybRO6UtdXxBh05qe1AbzejrMk2QlzGH1yy01KvUny6xEh/J8G9IeJaTgosFGS+pSOe2sSp+N62tOUauTvTaut2XJ5KhLmOkgLBYHbETFTBqX59JB5nqxX6QPXYd53pRvVm4IMzflptyUm3JTbkoqxlpsVSfp5ADKJxulww35ICPaGWJoqOoakFyRg6RoctwpFN1gBIoRU1eVsKCjEePUx7ThSxsg74mFrKKwxkW2MDsrrRYD2XuPVgGtk7GtVZI+tvioknNKwGCTDCs13McNhJ4o1peACXYksXgfcH2KBo1+iBCPalRxcdERXUjAQoo2UpYciRTj6MQcIqy8bLBNTJLaIaYNzwjeBD/mas/GozV2YoSDGKF9n/PNSu7XHOUfs2pOKXeopkBUTuc05nKfAl4xxkERyJhEVEFyu5cKKzklkmyUFdpYrNHkIL4QAq7Y1NZ1UzDWM/Ah5JgM6hpthuNztG6u60RJIqXbGvzrSo/Gui6j9hnalZjUcVIe+03VgBKMKY1351LOYD0SZso2zM+6eb7WIgeeP0svtwAgtxj2eS9ZflTU56ukQq8qJeA0bPpikI1g6a0b0gaMv0uPkhoqaCafl3XYVg+pf9oYb3mGax1iW776Kodw6SCaXD87ni9tICOoIADBcN7obLpMBJLvFJoQ0iY19fUcoV1WsIw8mThoVfHeNjeMl57parLUlU7u4X9bT2J7H4yTQy45u7b2z9HZQ3IKqORNU+QIm/x3MfZjItANawhDl1PpohFSGzOk/BmcE0XdRodSBly2tdF2J/zVY0dAAaWzPO3l78c2GZ12wiT0V46FrXfamHfGz6e3U+JjG+a37NDKc5Dkzs7gTc4Xrov3kpwDaW3UWlPZisViSVVVzGYzqqpB2reogxIiVEChokYHi1JVqlRAE6lnlsrWKNVSVYHT06fEGLFVQ9eecH5+SnQdy/lDbh8+JMYZlY5UpsJ1PV23QiNrrkRXixwxMbJYLKiqaoguzw5kgIwgx5T7WxEw6XlD9Hg0u/t7VC9WrNqAsgqjAir2EHUCfhhAu0wCCkVfFYeTALaRACESghtALSHMxIFgFELG2gWYylLJDKCbGsZnnhPL7jL8nacnivMKJxaMAFUeZ+OJV5frgL/rztk8r+yzmwS7/P3V19v++UCA3XbOSzJmrrrXlc97zSJz7Vz8EoDdlADxTa4Xt09LX/Oek/tct6B+w2t9Vck2yLZ7bhKDN4/ZOqdeZU9dd06aN6+xmhIBYiQ3jIQIxUAUUKXzN/+ES88QI4m8j4z5mCXNy1Sgab+QzA1xiKUVskiTqBRYm+eUrHRT2hkjebTwQwzKHnmPolWO9CWRU8f65n3BpnR6GR08Ptv4rCWZvDxvclx0sjbFgMpqBqmdx2tnGXmdjtmw6RjnnanDfDr3bCO45N9X9cPr+p+8l42UAsPxuughU2KxPNJIrtF63KOI7bMlJWfc7B8y/6nsRFbiiMmOD6IoLjTNjNlsLiRYIxG+8k7ECSmqP6CSZI84AA0phmM69aX6Ga0HG290yuQBJHXJBOeoMllGIabH9MFijEOqqGHMhOTc0QMdTdJKJLXS4dhEQNXZvtQGU9UoItF7CB5NxKKprahHNAModa4AACAASURBVM2cumqIUdGpXggbFqLpUaplVjkWVUelHCZZEXFe88arB7zy8AF7eztUlaFbnU3IZNkGKfu4D5tEeKBIM0wmZkQhgmut0QkXqG0l4yel6FJRiRqNUcTo8InQaytFZWExa7h3Z4Z/8zYXq5bT05Zf/+YJT5+ecLFas+57nDO4EFl3sO5kpFlbg6rQusHYClSgriTYJKsNeSepNXLflPYPI+EoPYrZEglf7o1zX8nziNJmcnzGE/I5Q/rOIs1xTvtgzEgEy3atpOxOuE7um1GwEBO02Kwhp8PMCjohjcFx7s4YgGlGFaJcv2x3iqKNODKttTRNg7XVECAVoiPGXux/A96Jc90lwlRVz1mvW7p2zQe//iWVPQZ1wf1796jqGZWpaZoZTTPnwYN9KvMGF+drQhR1mM8+ekSIAVtV1E3FwcEBv/M7v8PB/i1CCPK+UlARRZARSXmj0tXQDweF5SCEhew0dj7IPmC+YDFfUFcVnevHeVLBYlHzT//o9zBWHODOO9q+Y7FYEKNHKVEbcQmnatdrgvOSrqXtuXd7xg9/8AZ1VQtNIAREoWJUEcrvZEy1NlXvRSmi1gRlWLd9wqEk3bsLER9kz2BsxcHtu7z66E3miwXESG2gSVu65P4VsowCm5QK8j4zq0/mCTGmeTnCRv9UxAf7wCtj/1Hgk6P46OiY45NjTk9P+eLzLzh58QmffXrC559/xifHxxhjaeYzDn7wI+7de4U7d5e8+vpd/tW//Je88dob7CyXA7lRp32ftVbUcVLq+pgJjSmgL6ezmkzlh7upbyfLMgSePXtKCAe4EDk7u+Dp02e0Xcf5xYr9g0Pu3LmLC5627djd3UdhOD9f8+zZC/7kTy84PT9n3QpZIoaAVhGCpw8de43he2++RtNUBNfy4uiIL58+5Tvf/S7L5XJQihby2Ri4VpaMVeY+XhLgcrrKuq4HXM9Hx+7BjHsPdqmrBoIShdWgqE2V1MwixEzuERLkuvUY27BYLJnP5xP7YVPxo/zJuHKuT65vqZIyKgJGjo5P8O5UbACRtSHiUcqBgkZF+r7DWnjw8IDD27/Hzs4+p+enHB8fc3GxSlh1HLBgbTTWau7dP4ToiXiMqXn31dsoLE+ePOeDX3/Eky/XmKoiULFuHeu2Y912+L4jBi84pxZFrOgjKAOhIUQLGKIGZRXg8X6FUj2zuebgYMnJSctpd4GPGqMsXd8RYo1SlpwSSGk14hgKlJI99bBWFOtItmNjJnQMNmUGJEb7bxMnLe2+0vYcFdJHVbpyLhTSXcbySpJMiStv308Maf0Q2zz4vCaJLUTa5+Xq/+Y3H/PRRx8NeLrYazJPKiU+CyGaiG0UghADBd8ZlVuCTwQ6CRMa2zKRXeT8MpjZE9FoVRX2W0z1CxP7Rbp9RPCs3AajvZOJinKfcm+QMYoSO5y2YbkWZdKs2AP53eVU1qF4B8kXkMhew+8ogcqhgIVuym9XbggzN+Wm3JSbclNuSiohyUyGZJAJMGDJzOUMFigU6/Wa46MTAQzqiuXOksVySdM0GKO5OL8YNqAgBmfXdZK7F4T4ogzeRVzs8CFHVNrBMBMnXILMEmAcQsQ7ieqyVmOVwkeJjjHGYqwhuGRopTybEqWRmeZZDrJKajbZ8AIopc4FjJRNUIVBpByNTVFPweH6Tq6bQGbvPT6OOde11jT1jKoa5Si7zuF9j/Md+DGlkLXVYCT2fT+ARdskj3M0g5B8JFKuS7nes6NUntFMo6FUjoQfUwyVuVdzyqcSIJeTR5ApX7+ua3I6ok3ijWx8RUVnmwQ0MIAfIQjw5pykuxLgyQ6b4Xxudo7m+5Wb0XJTtM0QH0FdhuNLgLMs+TnLaKa8kc8b3753k7YtpUVzH968/7hp+HbKyzq1Nh0D5WY0HcHoeBlzy5dEonETdX0dttcxO/eLtGuF0lF+z38T5eo2VBD18Hd2qGmlLvWX8hytp2kOpu9/6lAux1zplIKvdjq+zLsfHXvf8Lx0ToxMxlX5HGW9SwfaAFr5Qh2qiL4ZrpfvU7RvKTUL4zidjnFNljMu57HrVLOG1vimbTiJKrrC6ZquXY516TqXXd2b4NvWW25xLpXvIM+bA+FR5etuk7HXw+/ynQUlUXN13TCbzZjNZszn8+I9lQ7R0UnWd5EEtWBUREUnCiuuR+N45+23+MmP38VYz1/9xZ/xxecdO7t7zGdLfv3Ln7Jerzg83Ofdd1/nd37yY2LoefTKfZaLObO6xlqDcz3Pnh5xcnxG8AJ6379/f6h/uW5M38HQygJOTd5X5Hd/9yecdf8ff/Jnf0k936U29eiIVtO5PLdhOU5LZ/EYkZYdSSrJlGfCTOk8F7BK6hknRJ9N5+0msDc8URSHctk3tjmFp9+PxNRJ62yM5a/qf9vud9V31x2zrbzsenbd9a6q/zd93q+6z7dZvu3rvew9fxv74ts6ZyLVXhx3fd/6+ve/CrQt58dcXqJrXLpH+bMZ+ZrnmE17YCSzFwEB3uCcK0D+wtaYkMen5JDy3/neWdrdpUAFnWw9lJm0t/eetm0Hu790CqzXa7quQyvF3nJnsJOz4ys7lfO1SodRVh8t18JN50Y+r2yrsn2vavfrfm+W8v1vttk2W2fbvabXGVMbpqMmzzE6G0ayTHYI5PWlbKty3R7WdCNpuqKSiFrvAwpRu2iaGbNmwXy+oK4rlB6dEd4H2tWadn3Bet3heo81IUUl5+fIzzXtM9n+GfsyaR84JTKV54syTplyh2EfJX1L8IZMXJAfqBtJ0yF2d6mUM5K9vA+DsoIyFmXrpHoq0dRNpdlfzpnPGlFN8T3etcM4i16i6INrOT15BnHFD/7hT3j/u2+xqBvW5xfcvnWbGAKu71AqYivNR588Jipomob5fM5sNhvGdX6G0vGWnz3vDcsxXq7D+e9BscDWYCp87+jWa/zalR5GIdIN6asDRit2ljP2d3d487VHuC5wenbBi+MTzi9WvDg55+PHX/L4iyN6F0Tp1oCtKolqx2IKLCKEct9fplYSp7lzDkWkMmpIhVCOl4E85D1d1w3qDMPcVQy50uFd7qGbptmY86eqV7n4pHQwOjTBEEXEU1XMdTPcN8+f5bvJ4zPbdkZNyX0ZBzDGUFUVdV1vYAMuKQLopNJs8D7QtR1KGfHrJlNRaUWIgdl8xu/+7o/4+//FexA71itN13pQa2JY4cMzUbBpZuzZJqVU9fyP/9P/QOdGHMR7j9WGECPGWipbEbxHM+ITSil8eq7c3rnuZcqNjEEppZjP5+zs7GCM4eJiRSQODl1rLdqa5GdNRK+6pmkamqYZJpIQPB1dStnXCNEjk3gSCY/0K6tMbc7Dm/1qOgFDVIaYnt/7gAmBqlbolGYtp+yyxrK7nFNVNX3fo2OPYdQiUEqJgilxIO75wn5WSuazTXtA5cChwc7PTl35ViuFTTfZX+wyMzX3b93hh9/5Pv/oH/wBn332Gf/23/wb/o9/9+/ARqrZgv/+v/3v+L0/+AOMkWCE5XJJ9MK+997Trte07Tr1fU+oKuq0j05St2RGQkwqlqFs77GFkRVL88aj1zg9O8X5wL3bd3nr9df58ukzeufTWtLQ9r2oc0do255KzdidP0AFx5MvvuDF0TFGax4+vIdCFHp2FnPu3b3No4cP6Ps1IXrquqKq7DDXLZdLYLRF8rgssbYQwvB3VVWDHVX25fxjjBDo5sZibUPX9qChMoLnqKhETTw1VfCSCs95aDvHTj2naZqJPVPOE5v4hMwV/tLctBkYNp0flaRsQ+aGGDNmrgbMpq4MRsl8WFuD69fMrKU5OIRDsSO8y8oe4/7S2CjklxhwwbFetdSN5d7hHu3FbRbNnDv3Xmdn/5AnXzzjF7/8FU+eHDObGxSWrmsxOmCIrLs13gWaxS0ihq5zuNbRnnvqBkJYY23kYP8+/+K/+UdcnHd89uQZH338Ob/+6HPq2qYAEy/2SnBEJ2Sl4P1A0GkTtqq1Gtaest2usvk330c+Pgdzju092iHZJi3nv77v6ft+WB82UxPmdz3aSdN9eO63ZX+MUeHIdpzMCbmqGWsW4qwoUForijezZs6s0ZydnQ12obUgBJnI06dfDuQwaw3z+Zy2dcQQ6bpOnluRntOTmy6vjTGRc1XM9kfG4Uh2eUFkNZLOL6+Dm+9js42yfbVp92cVXmCCK2/i/BPbn5HwM8VF/HjvMBKZynd8U76dckOYuSk35abclJtyU1KxtqauZ8mAzAaoorI11tRANgqhriX6RSlhtDvXC6DTdURgvVqljbvFVNWgChONFWMzQAyKuq6T0RVw3uP6HpeowTZHS2QjVGtc39G2LSF4rNVomzbJSRUmeIUyVYqC04QAfd8ihB+RqM7yhTE7xROzOsSIigatIkoH+tDjvBd2PQn68wJIKFVhbIWpRvAz9C0xesTQFCC76ztR4NECjqIU2ozS1EYrrG1EGjkZ7hksKhnwJZgGaYOmp5EL20o2HEXlZEyPBdC27SVCThkVOt5L2OdG53MzcSmkDZ4ZDG4BOEU6HHXZ0Q0MAI9ErY3ykvmZ27adEFpKICdvRjY30SUInz/bdMyXYHve0OTfpXMyG/K5lIa9MZoQ7eQ9lHUrNwhTJ8w0ErUEqrbJUAoAfLXzZ7M/5M/Ke1x13uXvrYDMw488pzF2AL1DkGfIgPmQB3kCDo33z6D2V5Wyf15XXsaZma+/2a7l7+3FTAgmKoFOCqapWi7X8tr75D6S+1ke6+Wzl8e8TLkKVIhhy8Ffo5QEkc0+tw00KsFwIJHyRqJZjFk6VxVj0U66Sq5/OXdsAtv5/lrbAZTMTVZKs28r8j639M+IKIZsP2k8aGuJxYElSWPafuXzlESMy/VNhM/U70bnVUxzblbhSZE1KhKVR2uSY2OMApfczxK1GYJHa0PTCDGmni1QpnRmjeMdkhPv0rMoYjQYBZUxxNBD7GhsQFnH3rLhYM/TmDNmjeb7332Fzz/dxdqat99+ix++/w6/+MXP+dM//ROOnj0muu9wePuA/f0lWoHza7rOJzAJbt26hUp5tE9OTkbi7lUAWmZgRUOMIoevAKUlzeJHH3/IxeqUg4N9WiftLMo7SLqmDQdvCa6V60SMkUFqOSudIUpzI6CW+1N2AmTwTvp9SUgq167hUS4h8wnsLcbhtjYoPwthVBgqv3/ZeeYqdbOr7JCvmnOvU0v7bcq2NeW65/1t5tz/mK/3Mvf6m7zWNrulnO83yct5TG4jO8uY/Op7lXPHNofc5WcZVQ7LYySi8TJBcxuQflVdYHS4bCoV7uzsDM7ms7NTgg8pglgIBEZpXEqZKpGhkJXhQhQPjLTVVC1h0y7JxJk8w+uNNjDGSJR+QXIGIQxkx3HfdazX60v2PIwA+tQmVmTyRbaDYhSwfxsov+3f2+bMfNw3JSEPigVM+8Tm/LxtHS+vEyOTtTQ7KOQaOTWA2B+y3wrk6OEY9aR9y2cuf+QLZGWL4sRtaiHK1LWoqFhbpcCQ7EAFpSx1pYne0bctxliquhnsqKquZc8dEBWTROQRYkoQ1ZeYHLGpx0jwSj08Y7lHQ2tRElHjeJV364Z1MsaQ1kK5XrahglfJGVShtUnOUY/WITmeNIvFbCBmGS3qEKEXx5dWkd2F5cHdGe+9913293aYz2qc6/jsyWf82Z//OTHCu2+/y1tvvkHwLTGsuX1rway2BO+pFzWVhpgceOv1OS9Oznj8+ad0nQS6HBwc8MYbbwwkmUyi2JyjsvM3/132z9y/8p44/7ttO/o+JBKuRqk6kWTUOEZTIEz04pBCQWUjOvTURA4WkUUzw/mazu3yvXcf0jlN6yK9g//7//kTnnz+EcYuqGa7dJ1ludwTB2IiwkVAx6z8qnDRsZxZXC9KAJkIVQbBeO8nZI1MhhmxBpnLMsZTOr43x+amMy73k5DS3cl8M+5XypR0ueQhlYkduY2naSuK3xtTRp4jy3l6mp4JtAFRJ02fKYWk0pMUWm3bge+Yz0XV6+j0mC+/fMbx0Zq9vV1CMIKthExSsvS9KAxkJbKMDcx0M8wHlU579RiJzhNBFEdS28aE5emr5hLGecZay/7+fkpFY4e5OTufJ/s/51MfFFUipZSElrU9KNmHGCxNWn+MHZVtUNvX2hg8FPZqOc+WeM64Bqf3HCPz2UzeiRLyWtuu0dWYep0YsdpjlMeqtI9K58r0k+4lDzghoEpdGAkNQ7VVFrgYelxub9LeVJEFpSKNttg6qapGRa0tj+4/5F//b/+a/5+9N2uWJTnOxD6PiMysqrPdfekFvYAABmSTABdQtKFEG5t5GrN5nJFM/0pm+g96lelBpgeZXkQZjSaRImGUAJIA0Vi6b6P79l3PVpWZEa4Hd4+IzFN17rndFxRlOgHcPudkZWXGHu6ff+7+X/7H/woAo21bPHj4EHvLvRwxmSy1F4kB2y87NKGKEqdrMKUeGZOB7r85ZZ/ppkYC4iIvJMbJ2TkSU3YWJCLcunkDaRwh6yrCN6TpaRh7ey38wRKJGYd77+G3v/NOjsYZvBcnQyJ48mi8R+sITdtgiGXcLaWZyQxGtqr1rPo8rNdrvSZ3yXSBJEVTa2mquNJoU8KomFdKDJ8iQkzY2wOaSsecr3N7tl2zfacmQW6Xd6b7mXOAc0lmSB4K0V1BgIPX+Sd9T0jgNMCxRo/S9nhj4iGpfghglJQ/gJf0UAvZC1xD+ODd+3jvHYILS4TW4e7Ne3jv4RIvX74LJEanTitNcEg84PzsDAeHBzhb9+jHEZ8//gJ/9Vd/jefPn+O/+Nd/hg/ffw9t8HCOcdCNaIiweu8uFi3hiy8eoR+SROCCRFiXVMiGO4gtgMFoqezLoiP76u+LewWREIt4JptvmxPz+TGX8eZnFBFhGAacnJzg/PxcxosIKWM803kwL1MMXXEbSvlv5H1EZBlibWti9JuIGM8AMDb9GswiwjVNi8WikX0d+zr8MjfO12cgSKo9Rw4xSlTetmv1PCopqGSeaoQmFhIZJ56kqhKZNLdGnZoZPkgkYrGtTImn9Zrtum4LLh9znxn2bZ/PSW8FJ425PiZXMZfxdM4pqaaWxQnYMS7X5fXLNWHmulyX63Jdrst10dKEFt43Jd2OhmkW+5MKnaCswAEikzgCUpTs9qEVUKUJDQjAOIzYrDdgZrStKEWevIRQZcnB7b0qJc4DAXBs6RQ4C3kOHgmaBoFLRBGJ6qKKLURJboTFosBNVFWRKwHMgAcxInJixCiGVibxMDEzoQ8GRFAJEekaDXFahO8YGSEs4FQRtbzfMcUsWsco4WkZIjgyM5g8LKjGNgOYEQ9qMJIr5rddm4MKxRhdcuymKHli54IpUEgnc8C+AFglZLhWtiLfGFhGmpIKMCC1rp+1cRhKWN/aKF6HL63v36YozT2iimJy0UvVjMdlzhbAYxuQPo+yUwM1MM+PybN2GznLuin/ra/XoOkuxWtbqcf8dcuF97D0j0Rx8mBva4NUIbequwIMOYWaUgVxa9hfTnyhvflVmBoCJp/NDDlXLZf1wTYl+vKHAZrXpR6t6vdd72JY6rC5gaWuZ71mtwHmdb2v0q6rXp9wOF6jbBuj+e9zkEqMHGFiNBJDm6wTCYPsJnvVXEmev3Pb+BlQeLHFNPt5oVEgbCHM0CXfyabEi53I1X/zc+r9Btv7sP5Z9rgKQIFHvVeV6hfPxTLfGOJdaykWAAHK7JwVA+RyuYflcqWRz1rJbW8p7Aw45nlbLTSveUt78VoHAESkcQOHDQ72Fnj48C3cv3OEuzf30J8d45c/+SX+z7/+P3B6eopvffs7uH/7Fm7fvo2H927j3u0b2FutsFp28IBGbBvQb/rsedU2HTxJuPZhGLDZbPLaqcmO84FkDXssRBhNOccMkMPLl8+x2Zyj7RrAO8Te5ZDJcFPvsPm4bTfmZPONANRSA+m/nLu8AGT1d00u2VUmBo0LT7h47/z8B5ANsa96/rzsqtdXPXd2lTf9vK/6rq/SF9fl65ddfVsTGOy+2uPUrk3ls99MmRvpbO3qp7kul5XpmrwYFevi84Hz83NsNpucEsVS68Q4ou83sPDl8zPBCNpqI8x9OZcbaxncmsIaHXIe+SallA1bRtip2xV8QOimURlq41Z9zXQJM8LWER9qYsG8j+Zn5zYDyNZ2bXmWfa+WxbeV+RjNf07fa2QYl/d++598bt8VgibBSSobMiMmQDNL/S6DT0pJibIOITToFkt03Qpts0BoWjWWGxHI5kHEOPaik4OwWq6QuhJJhMiL3OEt3YF59WskIw2Nb1FdYkqI40aaCoka4ciJfKfpM8EsBiNdMsxCFm3UeB5tDlfj4X2AU8/p4D3I1akKzFBCIodoOl/EDdLwEhxHvH3/Dt5+eB/379zEzcMl7ty5ib3VAiE4jNFjf3UPh6vfBQi4cXgLN44OENw+NpsTBJfQbzbYrHsQAsZG5ue67zGkCNc2uHvvLgDBOfY0sq7JvHMDks2tWq6oI9XN52NdhnHAEEcwEZzXZ7haehW8wXuH4FqwD0Kgi4yzocfQ90hgNK2Qiha+QQuPmAinZ2v86Gf/iPXx5wi8gecI9ANScujpTN6j63fRdthsNlgPfd5LRKYnMDw2yWMYkdezRWRYrVYTp5d6//GBSytSmujd2woruaERmypiikhVZCyL7Ac1PhdpiaX/3G7D9VY9jKaS+7Z1OL1fagmYY5LUJXhJRULssWwWIAwAr7E+jxj7NX76k39AcCO+973fw927d9G0jTxjFOVaEoMwjGDinES4EQM7KVHMnL9EGG2bBgeHB0ACRo3Waym2sKV/rU0hBCyXSyyXywkZwdpnqdetZyx9nhFLiEWdoMSAEocAjb/Csgcku59I9y/pJ9M/gCQJc2dn+ja9WmR6gJWwThrBAcxwnBDAcByROIJYoix0LsFjVHyjkiF0liXm3Dow2a6cdWgiaVvBRWkqlDN0Py/zQiJPVkOk30vMAHmExuH+g4d48PDtvA44SYpX0kgRYJZUd0Sadc+B1JnN5oYQQnKNYb1PbGmwFZcjGSyyc4cI7BwiCAhex0FK0zXg4DJmmc8wFucX7yTKddPuIyFlYheYdH44Sd3Lkg7Mo0FoRiTtQzvLLDpXTZrbriNvx3Pm5yMR6XwUAlCiQkQjB42oRnAckFjGKEUhh3rgArls29yb/l0iGW2ru9VxIi+ABZ+e6IcEsMoHuqdknZwh40s2hyDjl3E1m4uq8+U0obpHkKSGCz7Inth4gDQayI0GB3uHQEpofIMmBDSNgNObvodzhNWwBhzj1u0WN28EbDY9vvHuu7h54yYcHOIQhXDjgKZjPLx7gD/+g9/Brx+/wLOXZzg5G3C+SYiWzW9CUFPyTA2lzPp97qCYx2Ymem/T3+fXavx4fk99Fi0WixzZi5mFrFQ5QM5xvXmRunIeyzxOlTafkn6PZXdlZvAwwgdgb28FIoezszMQMQ4PD/Hee9/A3t4efvzjH+Px4y8BOATfICWhSGXSi6tTqspcsebauSw2lljJ5kaKlH3B6l1/1vcbjcBl+Po0CnyNz5d+BYCSqmnuLFqTMfM62SIKlPGaflgiy4gDlN8hz1+X1y/XhJnrcl2uy3W5LtdFiyiADqITmxAzNWYWIaUIiazRJ4gUGiRCEwLGKDk4UxQGf3TqoeRV53PmMToFN4P3qkhFpGjhAVOO7hAaiVAg3x8UwHEK4gFxHDCq4ZATNO93QpHfNBcoF+G8Blgt1QJ5UfDIScQJBsvzcs51Vla2XIcLqp9IbmEgijKixrMYRXEHiwcUJyARa47uOqf9xZCCdT0NlJH6l3yfuT4QQNP5aSonzBSBlFIGOuzZdv9FwV/B7gwmzJVV/dvkfjYS00Uwaq78zpWNbfWYC9UXlVWefMf6r36HGVtqgTtxQsXhmNY1tzlpd3P5xJRZLmBR+Xx3qRU+e9920HQ7aH7xvvlFZADldQqRKYEFLNSXFBVvAiAaUEQKbE2BtQt1JICygsgZcDFQkqtXlh2m+nsHiHrF1l3pHntP8U7c9r1t1+o+szlrYEn5nKiEOpX+mird9vu/vFCipT1WZOiMiDYFnuu1V+ZyISKYl+qc9IZUFORtANWFWhEJ4JLfO63f7oVAs3GefmTA6WwCyj7OtGUqMqot5cpLL58pCnIzGXfFwAKJhEYKuMqZ6S4AeQJQJkTONA0kMDyVCpEjNE2Lvf0DLBcrjeqjZ2Cy/qyaCwFurCvAllM8CVkun/1ypnnHWCwavPP2A9y6sY+zl0/x8U/+Hj/8m7/BD//2b/DB++/j4cMzfPboEZ49e4rNZoMbR0fY31dQf0xII5CSQ9Lob+IfFyZzoPZY3lXKkhNSXwIyWE8eEAdUW4eSfqQ+qyxEcnnt9r1Y1m3dY6QAUwXkzZaOzqJqDlG175bUZdsKWV3M4Kz7DFfPnd2soKvD3Ahb6v/qM+v/i+Wy+XFd/uWVbYCz7HtceSEa6cOicIg8JxE6ajLI5e/KS6OSZQHbMmoJZ7aZE83kkLmkkqWIiRy8TabeNT+zMdqJYXy9XmeyTJYdM3A9i2yTjzuNJOB0f8jRwmZgNDPI+xxBAoCE9HekaXmnALYA0UZWDABKKh7nPJwPCM6Jt7aSbICozgfVnpmNo3KuMSQajnmmg4oBmClvc9aIAqTbGaTfIa50BVf21Vpvtd/yd5x63ts42T1EE11nMs5Zzynvs7/k3RKhBVQMInK2m8xcR8Cs5OpKf67eVmqd26Xntsowznn40KLrlmiaDqFphGRCvrwD9gij7zi0QQkW44hhGOGckXBKOt/ELNFaYal0khi18liOMi+yPiBkIa4oHY4A7ymn9LHjzuahy2moSuTQ4IMYY/P8ZBAljTor57e8cURKI8CMvaXDW7fvoAkebz98gAcP7uHWjQOsWok0F/wAByC4hKP9Dje+/T5iTGLIw6NKcwAAIABJREFUToPIOHHAuh81JTDDB5kHQ4oYOSGSQ2g63HvwEK1vJ+Qx08PNEDWPjFrr3q8ih8iaEh1eskUzyLFEIyBd3zY7EuCh+j4IfgyIzBgiMHBC5CgppUkMSWJ0ZzQB6ALwwbsPQOThfIfIhH5M+OTTRzg/PUfbtNg/2Md77z1EHEdsNhtJ6+OdOEP1I07PI07OIs7BSCx97ANJKhE36L7BiOOIMaYs9ya2+S5r0JEDcRTKMQlmI20sRj2ihHfeuQ8G4eXxKV68GDCMasw0KY4BsM0/lX9N0KXpnoxqXy4imeq0qPbzyQ3Ie5B91zzzOdNBjDSghH4lJ3gHBMW9UtwgpQFN02C5auB8AkjScjDLvE6Jc/BC29MyoTBJStRgxCtmeCfOCovFAgcHB0IAGAbElMqebETIpNgcl71+0UlqVnN4q9srkYQIzlJiaf+Q7q+2z2ZpmBmMmPu07NYVUqIYXL7KmrZqmxZV69UZc9FLzqIhMFIcpa3jCHDS3U5IEs45BItEZWfb5Ajlmche65DaBorVHYSLdZ0I/HqFkCb6JtmBIash6ewlAhNJdC+ds5yU4EGyv9psJaKMlVqlEyeQOUCBAJboMlbPrK/rKrRnMaBkJta9uWo72XKSvci78kLTVcg5eOV9ytHMYm8H5UNcZo7PemzkWKLjoegj5ixRn9u1fr+NLLOt5DXKDHAEI4k2qEQu0oNMKaJgJkQnuDIx5bZcHNu5jFrGfJc+NSdQ1oVyO/Vnjlpa3lk+rWUe+83+6d+1/KByAgDAVQhcVvoLJuodw7USvcNxAlGEOEMGNE2HmEaZb45xsL+Po29/S4ld6l7GGomaLeJSxP5eg2998x3cuHmEF8fnePr8FJ9/+QKfffECib3WRpJSscoaWqHcFpPDi2wk55f9bbrvhPdN0++QKzijyZDkMJljOhh6RijpkYV8CF5KCujYI1Wyd8bWsX3cpS4XEARtYx4N1PYJww8TR1AEXNsiphGcIuLIGIYecRyx6DqJvhJHlUM8CK3MEi52D0v7CVikcGgEccGOxhg1UpsFIiyYEyc757QdSdJnpgg436iTdchr2ua5RQO0fSoTGys82eTvrLfZGWFrJP+0uW/knPIR7LoXkrZMdZWrrjGAN1auCTPX5bpcl+tyXa6LFmEJe1GyWCjgzJzBoHEcMY5RQ/pZJA4R7kLlLSagiAhXznmERQCBMhEFyUJLCrAQo0RfAUzoUqFIBUnmkkc0BIfghfHNKQEsEVycCxqCOmC9llRKRATvGzB7WO5QbSkkR6oIviBhRwfvkThh6BOQUvaeQUogJ4Qc9gSOAgHHpHUAFOAVj6uCHVbgAQTUYnXwITbPGhThkgR4bqiBhatMSZVphioJ6mFGDokF7HCmNFThFF0j9RX7mgaRVDDcFIIxjgUDdqR5iUVxJ1UapbD+z+LuqCehK4C0hUM08KMGk4CpImlh3efXt5Fh7KcZEmrvvctIJOVzU0im3q61sVmUx3JNPGpHNTjIO2KKOeRwISipNxUZIFAAu+ItlRfXRNG/TLGuyy5QYFv/GQklA+T5+xOkr1K29R4Db7TuyP1TbjTig4B5dR1NuSoKOwPimcKcPYdBCpjr+5wjjbiE3HeiOFdGCpubVNdhWrYRr6b9VH6W5T/t01KH8uLamFE/pwaRCDRtN1uEmVR9pyJXYboHzY17cwLYvJ1XKrv19m3oz+7vZXCqXKgJAhmQA6uSrWOrayEbCIvOq9+bpoewZye2qGYu7w/1Oq9/z31RLbH6eiHWYTKHc1PJgTUaki3YCdmNzChXQFEBC6r1vqPvbBaRghaT/kOZjHl4J/POqpMysJCfRuJJCpJQxtUhI2cpGzATNAUCIemYuOCxaFZYrlZYLFZwzud0HcQK0Nl4A1UEOSV26upkwW8ljDUPQtThUc4yRxgicL6OePLsBB//5GP8zV/9ED/76c8Quptw7QE++ewxPvn1r9H3Pc7Oz/DR7/wOvv3t72B//wjet3C+RRsA71rJaw4gxVT6gyVU+atSuOWeJsLISTOVCCDaeI8HD+7hyYseJ2dfYhwSmEMmxQqoTojRzgUzdlUGgQzc707fNTHg2+wnKpmbYOOlnrEGCdEMwKsfqgB6cjYYBUpN1T6kGxoYAlzOqDRyV2Uoqq9dtcz33H9JxJuvQ5Z5k+247Jx/8yVvZhfLP+fQfIWur/f6C/IMKu9aaBRDR1kOMVzUOYL3BgqXjbcQyV5xMFL1084wTGUj21NQ/SQ9+4A0m3c2Horu1vv8ZM+vfiPRBUy+JxYNpOs60Z9YUnNsxh4hNGiaDkROdRDZqwEzJGiENzASTb09zVDM+f0qlzCAJNfHHJbdqQG2Q9M01TnslfxL8C5I9AsnEQhjTHIGuQT4COKEFJV845waiKQOln7XhQDftBLyfkLUQd4/OZVTOtVyqOki1d/knBJKSptFtKUs44Js/HjWJ9YvKf9tMqL9xTpPzEmD7Bpsa2adTiYfASb/6BuRkCpjinjju+CzYaLWhYiEcMMkZ75zpEQWB6IGoenQtAsE35QoJBrC3uRUIgcXHNAGdE1ASiPW63P0g6TxIe8QxwjmqGk/PGKKcOThg6TadUnSFQ4aDQ4E+LaksM3yoStRikJwCK1H0wR45zGmiHEQo7akYtL0C0FJMs7j1s0baLxXo7v0U9c6bZMYPWMcMPTnSDwgeI+3H97CH3//O9jf20MIXr7HEUSMcewBaJoonevBe5UvxKGnHwdEBoYhgSigWzVwPgBB0nok14KinNGrxRJBU9bOyS+Gl5in9baztqz5yyOedW0L9AljGtTwW4gcgi9olA5AsQDAaz/DN3BNpykmZV4ZaYCIsOw6/OCPfh9xiCByIOcwxohhHPEXf3GMX39+jr29Bu+8cwff/963sFgsVA6U9Xt6eooXL0/w5MlLPH95jn4ATtfnIDj4ICm2Nv0gUUmI0A/Stxb1YIxRMBvnEccIkzQb7+GD7H1t4xHHPq+JlCK+++FdnG1G/OrRgPNzYEyMzThkIkeRzdxkzy4EScq/l7OBitxme8hFRTnvFcxCRPQ+2GWwkpPkwbb2GEN/hvPzM6RxxKrzONwL6DpgcXOJxt3G97/3r/Cf/fH34ZU4NMYBiBIZmTnliAYE2W88OXjFyBxkX3AghKZB13U5TV6em22LRvcogqyzxIxxGMT4GqOkHmdJxdI2TcYSal3LZdm32gez4lHO3FTdkfdC+1tmkHVRVWpy4haJlS78Ur9Fx06uxBgRR4mqQwDYmWFdIm4yCJFVZmbrlaqelV4Ims4Tu9PmjO1dWeuoZPvps6a6YC1qyLmdVKaRqNhGHjD5w7qXKgM2nCsvyFUv6XhJb8wyOliXHgkhREC+Si8FgFQRiBQLBGkXF0zI6p3UQY+cYGnkPALJnp445rba05KxUAigNHVqK44Cph/X7QCM9L+NMLMTT0uMaKQtwy+JUIU6KuPChazlMv4l7+UtY5iXBttcnupCu3CpOcm5ckHUH/mBVaFc2SwN5zpR3lPtGdPVJBW3ZZq4RGJKMU3OBGmLECUiM3iMCjc4hKZF5IR+2GDoeznnvOjN3nmYWuq9EiBlANA2CW/fP8S7b93Byek5fvnp5/DUY4wOiT3O1iNOzyX1oKNWdm+n40OKGdnupfuP2AVkHJkMs56dsfpd7ysn0aiyKFXyusmS9X5Phj0wHAiLtkUMAcPoMYwDxjhq1PaoK8RNt6a8JG0P4TKGAAxzIbJUgTz5shHiIxjn5+fo+16mhWM8e/IUp8cnODg8wJePv8QwDiAQBvToFk1OyQ2WdK0WuamOcuMEyIJ3Dsl5BGpgpEiJbKWR+xPnFHBOhFAwPNqmQdsuEUIDOxMlHaVg5+bMUIhFMu9YsRTnRN7ISKDpSDpJ7dyQ79qJQnCaelDOX7EnCam6RLsUNUOJwdfljZRrwsx1uS7X5bpcl+ui5fadIxwcdnj29AXWmx7LxQqLRQMiiehC5LDZnGC9XqNtGyyXDYhYvbRKLkozFHkN0ZcBBgDjGAGMIuCqMGTAUs4tTSKEm+dbjqICUQyYCJwIYwQSezjXoG1adF2n4Ms5HInnQooRrmnQti1ijOj7HuM4wnsJa0ua/1vq60GJMboExIg0WEoiACkJy7tShhxzFupEug9I5LMXoCNC7C1np0SmCZWxy1jwPhBiHCB5lkekVPKYO+fhXZCQosmEb/ECsHYEzVMNBeqcc2KUPD0FAAHcicTzJhXDspGGUkpIQ8I4TqPbkLNwmaLkZm+3XLh8ruGORUkWJdc5P/G0q43f82LXa4DR5oXU1cK0q7F+9qy5t175zMg85TmW61nm7DQU9DiO2Gioe5sjIYgXpoHkplDnXjAwQ1wWCshggn0GVez+AkSZonGxDYQLSdSr78//5mpOGRjlFHCZKO6VsSZ7SLBEU8rEH6JJX1qZ5IhVAL7u57w2HHB4eADnCCcnxzg5OQEnhveNgn7iGQWuvKa5eCaUd1vfuaz87iq7CUTz/lbDwxzENiMKdKxy31/s69I/GbqAkD3kWj3fAWQPj0xIrPreiIJ1XeYpibYBROCL4yO13QW+b79ebth1cdqfUgXzApLf5ziF1S1FroAYVuLelPRmqRccy3yfRqbBZC7OyVGsgGepHwpI7C5GozIlnTMps5C9TLFPPOozCoCX9yTtk3oeCnBVGyPtJ19ooxmuGCUlHzAN158BAgIIqZrPhKhphiTNhvWPEC6ccyAf4HxQYwUrIY3QNi0Ob9xA07QwI4KdUTQhrUmLuGqPeCNrKoGRMMQBIELwhPN1j36zgXcJKRK++OIYT578LVbLBU5PXsIt7+P3/vhD7O/toz8/xscf/xifffYz7O+v8P7772Nv/ybeeucb+PDDD5BSwub8TNMJFJJMiVxXxna658zWBTKUDXJA36cMFEdmxH7EH/z+7wHU4vHjxxj7DU6jkGa8axCo0fPTwoOHav7GPMfEQ8vO2g3GOCB7FVcAvhn3JYJcWUeAzE8wZaDOnj1py2Sv13O4mmNk99h6qM/APD/5wlEy31Pm++E28t6ryB9fh6hy2XcvMyi+6XfN5ZOvS3jZ9q7fGIlmx5nwz1p2NY0mU3OyL9fX6mKpZMq+X6KU1SWE+m9JXZK9DDElYtdEtslZksWui6kSJ82w70DIkw7QiC80WScu32fy4O5nTc+3pCliBSRu207PS1nPwXtExJx+hKhE3SnyhlPnAY9hGCCklyJrMjPIhVzHxEAcYw6RniBRPH0I8F7+OefhnBjBpZ0kYLn+zYmQiOC8B6cRkROYCD40aJRgbuTpGGN+N7GDGQe08pkwa7pDjGkyhvX8AaD7cMjtEwOfGFhk33WSKkLnU50aJ6eHoimxkYhQgiOU8Sme73YO+DyvTK4cxxFjipP5Z/W3s97S99Reua5qOzvRj+17MUZwAmKSaHJEQkrxwaNpOoku00rEk6bx2dmDICSKcdS2OwevpJqUGL7pENoO682ZRFXhDcZB6s8UMQ4JTWgQmga+DQhePIxJ03ZxTEIE2FsgRjH2ginPGVn4HoQGjuS9TQCiG+AdsL+/AjgixQEExmZzjtOTE3zvT38Pjk/w8sWX2GzWuHl0hD/6o++BIAY+QsLZ2TGePP0S3jssFy32V3s4OtjLfTsMSclbAaFpwczY9BKRtmkaxMiSltJFbDY9QITDwyOcnp6CuaQLI4poW4euW4J5kedRXeq9y3SaOvKrzYPz8/OtKc127YOcGMNmxHq9yZFDJHWKyPQiY2jELU46ZSOIRjhyWHYBzH7yTKgc6QB0IYAr2TN4xmq5xL/5s38taVaaBvv7+2BmeD8lzS9u7OPW0R4+eOeekDZ8QIyjEmQc+iHi5PRcEoZEFrKclyg3MUb0wxqAeMw/fvwYxy9f4nD/ADcOD7G/t8Jy0eHunds4PXkOT0DTeJyfnePFccKPPvkUJ0+fgccEIZFD5C+WKBKMlLEiwAPsclqaLPPP9uFsOC0bNCbUjUoltDU9YsjjGXzAEDcARjRtwKJtQDHi2ZdP8Yt//CGOXzzFh++/jQ++/zv45gffwAfvvYvVskPbBYS2MgSGZjK3ageCUjUSgg2zGL094fDwEG3bTtPZOSPuT3UoDwAh7ExbMdVzs303EwzzfknljKvrZue2nRVzGdIMo3oxR9YsXV07DJRn1e24mJLVdMIkhIfsmCW4IZGMZtTIDvl7+bXVoqaqruDJPLD5X+ZS/X3W6xXmkr9X4QKsmgIXfcJwKnu+rGlMvlMqoGQGHSOXnbsMdzJIg2CObtO5DRXI5J8jgidCA1RrvLrfTeUu0znqvwk0icR80TGGkTDmNjDmaRALRnMhygob4VXuq1MfFb2Zt8yz0pd53OxBM3mZwHAqu13AGWwM8jPtPajmelk38/28vjY5EzSl3YVC25wxSl+ZPlz+3qE31qnB7Ck07TsBJEj3O0ttZnKxklNSRN+vM34uTp4pn0nUyHprGpFtxhQRI0lQrzTCuRGUNjhaAh/91j189K13MI4E9g1+/A8/ww//7u/xMkbAdUjUgrNcaBiHEmfIUoupXMgSxZBckbFK25yQgJMRrAFODhJpTfEVaGQyxYITW4THKrWizglPBHYeA0uElTgyUtLoijOdIY8xAbVjTb3nyJnq4ZxgOibLi+wrZMzgvaav7FQnkPFcrwe8fPkZ2rZDEzoMQ8QwJAyDRL+q5WVLe7RYLOC9R785x2Z9lvHtvdUCXdMpqZZwenqKk5NjABJhj1zBwUBBMhAQYRh69H1J0dj3vUbmE1J113VCqEsWuZCURO1n6173jHwmGxlY+0sj5FLSsy7veULSqqP7mWy3Wq2wWC62rKHr8lXKNWHmulyX63Jdrst10fLZZ7/C5198CkeSu/TZ8ycIvsVyuY+m6TCOI0JosL8fsoJgyuE28Gebd1UW0NkAcaeMYyiAKYqlEGgIXbcoebFVSO43owpNXgg2kAg1Z6driDIloKC9z6Lj1MCkgWpmnDZhz+oa1Og4B8Lq9syNuqwgAptxbKZoxTiCFbjlZCmmGG0nQnxKlAFlEwiZR/TDgOzpygApeG312Ww2uS4GxIUQJoCHeK46+FBA2c1mk+tn91u7TAiWv3d40ld9MDdG2PjX/TP/zra/54pvTagwMkX9rF2RBqbgCmDztLRter+1l4jQtu0knLaRuaRsN6TM54qVeZ/My+5oCbuoD+W5898Vwtl6z4W5Ws/jWbMuMxZlxZ9oh5IunndffPEFNps1+l7m2Gq1EkXK+xyGM+fZrd5Xg33TeVHqOAei7d75XiN/bzd+XTCY5eeZMlZSVJXPUXkekf5f5z/ZOlDPxlxhVqONkSdsnSWUNGzTPtyWtutiG3aP0WXra1fZPeYX1ydQ17v0WdkLbM1tXxcXCHQWQYs1K5MDcnhVtnMmI1P5rTwjIZR9Nk7Wb90+VtKOEQKNXZbsPFJjgqVjEMhc93SIF3lMQmixtBGkkZNqwN2OOZqD8JiCvfMiY+909ZunnoGLPoMXUIAyNPU5JRnivWvQtg26TjyADKDI48LI7WuCB7GGlGeWdD9UAL4UR8Q0whFJdLkYpQ7jBsOwgYFBKTEGZowjY7M5QYoOTXMTzi8wjC1c8Hj77e/g5tEtpNjjt7/7u3jrrXfQNgtsNj2YBwzjBv1GyIoOdk6rt+tkXVaGTkzHVz6zNHrSHwI6OQzjiPXZGWJ/hm99822cnX0X/+uf/yVWTYuDw9sIzRLn64QXx6cgJ2GGk4KJFrLYOTsTGEDSfitzbX5+zQ0VVynb1qutu2wU2FK2gfQAMgC8zShX7+lfZ9/Ytu+8qXLVfruszI1N82vzs+M3Wbady9vqd9n3flP1mdflTRUz2Mzfddm6YL4oOxnxzIxyPNlf9Ww2gp+mLyA3lSmYi3cioHuubuD1HrOtTOUuSEq6bDIsROlk61Sjoph3JlUygQHqFlRK9vNiLE0sQL5Eb/EgOCRmtEYcUlB/vV7r85RYQxIhyxwWCNDzjSdtzqljWGvuhHxPzsE3BmqrJ3Ji9H2f5Rrz6rT+ck6ISkb6yOSbivBhZ3KtK5Y5ECZkSCORWzFQ3GSjXokP0hYzCju0bdFjRI8yB4DyLJPnTe+pjQrbZdF6ThR5x+ZfMVZyrsdqtTcjytSyps1F5PvtjMvkqGwY9Eret3SehWAr89bre8VQ4nIAFXVUYIb3Dl1oxBtadU4xZij5hBhd14A44Xx9hqEf4J1H1y1w/PIMTWi0jyXVLzmPZtEgJXFA6eHB0aMNEiEuxYTEUOM9oQuExgOMDRwxgieEjrG/bPDg/gpvv/MQXZBUHyHIGO6tllifMca7QkY43D/AQSdR4syU3u7t4XC1knaTzD8bS5Oj67Otdr6o7wMIja679XqNp0+fYr1e5/m2XC6xv78vDjnZODMlxW+T8epie585r2zTkev7rL4xRrRtq849U1mi1htrPTPfx6qhGeQy15lMh8gbkER4ZAIWi4XImEQ5sqoR3jO1WqP3EWk0ozSgcQRJpT2iAePGnkYMSGqXZdVsg0NqOl0XC9zeW4AABMNmvBDxA0e0zkHYYgCngE8/+Ryff3aM4+OEkVtwCogjCbHLAeABYxyEnANNWaMpb3bJQdtKsgiD0klF32UGOME7Rtc4uMAYhhM8efwIv/j5j7BcEt59923c/eB9fPj++3j3re/j9D/8CTiO6JqAvUWHZddi0cn6MGcwi2VS5k7RT+zdKaV8ObE49bStOIs1TZPnRK3jT+QNACmaUxOKPnWFPqnnX/1zK8Y3e85l/b7trK3XgRVbz/W/XTLrNpzjMgxqXsfL5sUuGabo/K8n15XPceH79bV5ueBgpeWq83t3PcpZVuNw83H9ujL/xbZVuv6Wm039v2weTtuwu1ym62wb3xpfetX62PbMbb9fwCa26GAXnqty4psu29491wttDhi+bDiyyUkmVzEYzjcimowjYr9WYEdld4zgGNGSRLL/zjdu4527P8Amejw9ZTx+fopHjz7H0yfPAJVxb964gW4hMsz5+TlOTk8BRE3+SHDkwR4IPqAfJJXdarmHYRgxpoQxqtwahDg7DkKs9kHSP6JpwJDro8pgIt8mEFlEFsHXg8rMRpScyhJzHEDJ9Bf2dsMqyvlf2xdCCAA7pEhI0ZwGNWK8hPkVWdfIbq1glSn1IuNJd0sbTXZIjMgjgvPY9OLsdMYAUUJKfXaQHQdJ0dS1HdpFh+DEYdrig5tsQrDUTkLMN4dn7z26rsNyucQwDDmtLLMQsIiKA5TJJdVEhAnW8plG+WEgBC96hPap4RpjHGA8PBDAQ8Lm+QZnZ6dvcon8/7pcE2auy3W5LtflulwXLZt1j6GP6DoJ69d1LSS6TNKoJwzvVRJjyxm9WwmtPfmYObPSARMQzWhYQESTJ51GVBnHXgkh4vXovIfzgEUEiDkag4AK3geERkS7AthODbRGlqmj4tQKkYEOdaSHuWFou7KTkPRvie5RhGcT7ogkdLmA9hrGcBAjO5g05QXDBRGGJVyrpLQhAKwRcUSgL16K9RiM45j739pBoqloOo0ScWFe5oqd0zDBrypzsO6y577qOXb/XLnYppDOx+Eqz5bvXrxmf+8ymBiofaUOuWK5FJi5ELpjyz1z8ACY1G9b+y5ezxabnXXcCShU4H65QX7IOpP+NEBaQP+Y5/4ciNkGvMkjBS2ZA2C1Mr+tnlWvbO2Hbb+LAaP2XjNPTq0JlZ8F4FEjPbMo2rq0kqadkzzkxe9XcttPPfPmYN/82ra/r1zI6r29bJ+HU+LchffO+lf6C5P3bHtu7YFLRICTdHWwvikvmPTF3NCg8MSFd83Bhwv1ZlbCon1f/jkQgg9q3K2MXVLZvP4ZrIYjBdErHJ3yxiIXzFFs3vU1+GvtqdvNapgq99jPGbnLSXjc0DRomuK5bKRRCVVbvhc1jYZeQWKJwjbGUb13LKSy9gtJiH9ZBglEXjzpk3iWO4Km5AD6QUCYxEDXLrFcLMC+wQgP4oSmXaFp9vDs+Bhnpxs0TYvFooP3hL5XY5YXwzAnICUCkhNDM5nhtpBwtwF85nlmnzShQROchJ0GYXW0wNFeh5s3WuwtP8I3P3iAEQ5Nu8SvHj3F3/7dz/DsxZcAOnjfwruAlCRVRY52QwTSMNAWHWEOgs6NdGI8ZdTkUwOM5nNj15rPc2wLsH+Vc3eXgeEqRoKrlNcFqf/fKq/T5t90m76u0eGq73jd+990neTI3H3mbq+Hkh1sr7X7GNk4fn52JlEoISkMmnaBxbKD7NPI8omA203e1209AgZ2x3wW2xqvSY1GuK+BcTIDjiNIRBMBqtmMTSCQnxJs7YyT9yHL9LK/jhOyrJlojcjpCGAmUPCgIMZRMUyEqk21AV7fSeIx6+25JE9mAI5FbvFab+tgi55lu5P0m4xJ+WwaHc3GyP6uCTN271zfEh2wGHZtz7R6biP/i2dzI33MRqAyx4syZkR16tcI5y4S/3N/zPSXMv8J5tnNlsZCr9stZamYUU8IlkAJIV/LyKaTyvfUUzZHIjNSh69kmKQGiSKfeh+wXC7hQyNRfNoWbdeITAoxZjgnc8Z7S/vnAMcIHiAMCJ4RKCL6iJQGxGGDuw+WuH3rLdy6eQPLRYfjl8dom0bXE4FcwKNHn+H09BRnZyPWawb2WokgGYC2a7G/t4cbN4+wt7fE3t4KXcvwNGbjh3cE74HgZV0eHTSIsUccBxABrW+AIWK/CwirBUIT0DQtUhyrvpR56B0V9WWLCrPN6FePfXHaEWPPOI7Y39+fpLQxvGB6bsg6qd8zn1dG+jJde5p+ZNd8m55P24jV82fM9Yb8uRrMaPZc+YdKlSU1UBG8XnMatUVEzlonrp4Hyo4CyLpMIQ4QiVc+ALCr3g95JoUWFgV11Qp5hsAWAAesTlJNu0KKjPPzDT7//An+l//5f8Qg4iRtAAAgAElEQVTxmrE4vIvl4T00ISCBQRhtu4Mn5LTKwQfAY7J31329s5BpBqwVYjjIevSOkeIGf/+jvwNoxGIVcPf2Ef7Dv/9T7K9WuHXzJm7cOMTNm0e4c3Mf8WYHIBUDr+k2tc7DXKXBhontEwzGOZdVluXeCq1GlTKZf/dZul32m0cztet2/66596pru+pgz79K2UUe2Pa+XfLcq3Cjq753V9kmx+z6/lXeeZnsv+3dryPbvUqu27UHbavjb1Jmpbzx1G3j2e8XI7bM++4qmMlVx+q18ZbXeOa2ubvzfSqnbZvTb6JsmwPzvrWzrJYBazxD9vgEJo2u7EM++/OJQ4CkA4toOsJh1yEh4OhmwO0jj7duOZyf38hkzcWykzTvEFl8vRZnPNY9kyOj7ZYITSM2AQa65RL9GBFTwhBlnwtNi5cvj/Hpoy9wfLzGMBKGARgGRoqM0Cyw6JZy9jkCEDV9k2FEErHG2um9z7rBdgzAZd1iLjPs2t/y/kvl9mSUGxN3vK4R1vhRSQjTnm39WCfrO1miGhNpdO+mgYOckRKpnwBN8xdaSZMYmlZTZupZoQeiyKkMpIiUnKTarEjwRBIp/Pj4eKI3bTYbdIslnKavqvWNaQTcovvYuyMnDOtNNdesLx1SihP9xwjNwzDguryZck2YuS7X5bpcl+tyXbQ41wHcgqOHDy2ODpcAibFIonuoNx/E4CgSoEAAJuQAMJSlEgjrn/V1Af+m99XKjjCdM4joGeTE6yfFKJ6RCs44BUZ8cEhplDpHYZp7kpRGAiCKYD8MBq6IaDaJhsOoAHqps+XkzIbLSl9hA8pJUywAEjVBwXj5DAAzQuMLwkrQ6DfSj4ZilXDNDHGr0v4lYVUb2J+4RK4wHFeE9JJF2l7lvc+jYN6tJWz8rvL1lcSvWi4DZi4DR+pyuRJpUKF9p/7udnKBEQK+SplSy/R9NL1ji+l0UrfacG7za/bE/Hn+m+ya1qJS2rISbKm3+Kv14bQURdJ7W9tTBT9Z1BDy0itKTgGzEAUw9egh5xA0MkuKpgiRbTPF0KVkBiLkdS7b1KtBqDqCkBjqtkcuokl/muFcfhdl0vYMzTHvVKHnyhO5MrCw9SNDvC+kMqW/uGobzymKu9dJvUZsv6pvvTrAYho65f6dr5X69+k7tjwtg/pyv4C2rPUrpBlWYFlC/4tSLqRDzgr4OKb8jG3vyPWoIP4M5tfAjdXdWXopiThDqMmGQmKx1pMaucqeMDWYZmutK/ts3WNzgJsBTe1hJw5Bk4dr92sdWCrmvZDQFotFBs3NMxdmEAHlNS3nbJrMX2YWoMjIKeRAlATgSXLOeu8QyEvoY3VoZ04Y+h7gqJFYPAAv49SJN1LbNJLikAiJIzZnJ+DxJfr1CcZxg2E4R9cFdIsWzklIcnADTwGRIuLICszI+7ynbNiaGz7qdW15tC3l1rLzGnY+IRGjbT3axmGx1+Lw8B4+/PAtcW0nj+aHP8VPf/YpnHdioNY8744AHzS9nZuuI5tTl5Ew5nJQbYioMLErFIuoxOWL2x5gSNNVnngJSL7r993lKvLC9jPjdXrh65b53Pk6YPObIpfsMlC9ifKq+v0m3nnxJdsu2RlnnxfzLue/7MycGVAUOXbOwwKBOJUTvG80FUdZa0K0131q1s+WDrXIzpgYBWxfmRPoifRksXUPIY04svD8FnkqKRFQ9g4559QAn3UmfbezFpvRUv8lAdDlHHASqUGBex/aTHwpdYHu4YCRSeyspPJKHQfrD9PbouztbEYDQswylBeiPnkQeXgKCC6o8yvrGaN7NQFwted9SbPESc5QCe8uzgPJQvDDiaHdIe/5oIpQQgnOVWf5ZPuoSQkyNkoFQCbQ6LgZeYpAIFYzNoncxnp2E2ws5VmZ0KSWA5E351EiKbeDnKUbgYr8BDgPTk5VRZun0s/eIvxo1LqUJI2F9w0sRWAIAW3bYrXaQ6eEU5s/zhHAUQwoGkFG2s843N/DrZu3cLi/D449jp8/w/HxKVLssdrrsFzs496dG3hw7zZu3jxC2wRs1kdocmplqeNndwgnx6c4PT3HMIwSBScmkCMlzKxwdOMAy0WH1d4STSAQJOWBjWFKEWMcMPYjvBdHk+iCjqCcuV3XoQmNzkFNiZhJ53lKIU94Kqlyt51du4z/FhWSVB/f399DjMvqniLzmj4z16HqZ24zMpqhkUzGJzMIVfW0NAqweYv8vfwsq1PVlvp51VSb7KQTPTBVXZZ1j/kWXdYQQb257Tlcut16x+Ix5rVeze2sa+dqi1zrsp5Vb0i6Izrd5wA4F7Q/eozjgC+f/Ap7R3dwsJfQLTbwbQPfrNA1LZZdB2bG82fPcHxyiiGeI40OTB5ErezRJGuducjuee+r66qYDKeIlEY0nuEoIo5rnJ6/xPGLxzg7fYTlKmB/eQPvvXsDf/KD72FvcYC2VbnWMTiNgEaAsk5LRHPUbNZb5RdJ0WrjK33bdi1Wq1Umdl3QeUx3rueJ6djWWraIY2qgJKpmdumRemZcRj54k2VOBHuTZdfesIu0ctVnftV6vooUs8uw/nXf+zrlzRNkttVZ9ycjEOcFcPH2y3STuk/eFDHq65avQpb656zDts939audScBUTi59Dk2VJIWc0zOnnGFwJM46bATJBMKI/UXAMixw70anz1J5EiyYvCOAE/phQBxH2OHFMaFpOrhgaSCFVB85ISbGGEfAOXTLBU6OV7h7y+PFyzWOjwd88fgFnj49xiaO8BBnqJQAkM/YaNQ0bypRQxzqZJ6OgxJ57cxUonlJEzQiseKaMFlXsHvrMEvnbPIp657MrpwKbIJojQFU+AO4RN/M8gFbRBodTwbIK4kUgpM6l8BuARjpXNMmAchyeWKTFlR+VkKtybqlrdImSc85VtHZ9ZzX87SeWQUb1b6FCSn6GzNiHCGpQAMKgb3MqdyPnAB2V4U/rssVyzVh5rpcl+tyXa7LddHShCUILeIIUOfQth0cEc7jOeK4ETmUqvzKBiSiKPL2gZBSBmU+i+JtoLSgMx7e+SxCiy6vXo8q7Eke9ABT2wFGHGNmFAOVpz5UKGNgfb6R3JqswpojCVXNDokkpK3k2dRQ04kRLfqNKgM+eARltFs0DMtv2jSNtJcNOLV2JxEpGeCknaHpRiIAMCME5LRLJvRmAJ1Y8gi38l4DCF1iVUAs9dUo6Z3UAJpShHPQkOik300q7Arw47SvmcVLiklIR5z7UMChYkrWkbyC4DlXUF/Xk+iq5esRZLbck3E6Mlm+um/nE7br+q9+czYC1XhiMVTM38sA6ugeLo8jESGyzDVRXkzRMhOTz8qb+AWYAlWUspogRpoCJhuXNFT/LsNi8SRJACxXbqm7tFPgQOS8wDrPnAOLWir1ITEguCoPLbMQ8hiiTHvyaNslHAg99+iTpihT5Rna9ry3aB0decBdHMjL55EBv0XnLB9XQLn28MRzZALiGAhvBJwp6Mj6YM5oNRdE2cgRgJBo2NRpqNGi7JFXB1d2G8N3l8o/lTOUXc3j6dy92I92d5nnMg/MCFXILxJRxfZCVZQJABICEUIQr9HV3gLeO2zW53jx8hQptWKgBCZzsB68UtfiyeIIkwhnVuOYoo6tg/OUDTRMpPnkrR3z6C8utzglBlOCXZnYN1j6QM42ykB4ATg479M59zMXb3vry6ZpsFwucXBwACGGJT1jbY3X4yeRYchV6XnAiJExjEAaGT44NEEIXhg3aFuH5aJD17QAMdbrM7Rtg8VS/n7+4gSPh7M8JwDJs71/0MI7YLM+wWbzEg4EjhHPn/wacXiJvRXhG+/dw/37N7C/v0CKA87PEoL3aEMDJsbABGIxwKUcBW4KKNaRFGrAMZNJowBc3KoHEg+IKWIzAENiLCmAyKHfjPAtIfKIzbrHODCCX4Ign1v/Nzn1lUavURCpnnOXgdu1911ZJ5OTNu8503U0f15FlCRUAFp1v8kl+R6bWttJPfW1XaSf+trcEFO1dMu1+vvz3+15u787J/FM3nbJ3vcqI8RVn/N16nFV+Wc+L3Y9b5s3+NctlxF+tl6v97KvWPJz834qpRhQy7Rl6BGPiqwCACTpYdp2ia4rJHZSMkmWN6q5ahEf6tDyRIS21dR3SYz6dXqeeq+p012I3JSAZGnZAJAQHpwPsj8vWuwfrOCIJGonCeScEuPRp09xdtpjTNBUrgmMBB+SkizkHcOGQS7YstaoMiHv9WT10rZnEifMCGFngMp9jEIS0b2G7PwiI7J6xP4cgALtTkirDKcylRAMhTTj4JRskCBODEZWlkikeub7cv4TmSFA0ugAoouI4ilka4lnwmAmTY0i8l4iB0eEIQ1ySWVKc0zQp0JIOBbR0CK9OMQ0AimCPISPKkMoThUKxosTQoIPJE1IehZzUhKvSed6zgRNF0WkZ0KCV71VYsWbsZzk+QgypvqslAbVVQOCb+B9AJRgIhFiCF3biHHDO7Rdi4O9A7RNh9VeC6IRwIhF14lDRooYhw3GcQNKEaCIRRvw1sN9fPD+W3hw/x5SHPDLn/8cnz3qMY4BD+7fw1tvPcRq0aIJErmFEbFquomcy2B868P7otNGTStMpAQoqIEjSXQPAoAN4iDzQCLdiHGr73sMo6QHcL7BYrWXU8oQZI56MlxA9wzSTSML54VsAADErHpF2WcuM0JOz8AiN8m+4GZnYUVWvaRsI8rUn3lt35xYQ6QRmfLeqPqcdoBJ2rUxLO/d9rd9T0uqdMmJXk+lFWzTcvY7qnut1YUkBmQD3OSZ0/Gwa/UF+ysbGMmebHpkSXdqnuQpDWAwmo5w++5N/OEPvo/bd+6h6VboxwQfFjg8uomD/QMc7O8jxohPfpXw7Bnj5PQMZ5sBPTM4LPHy+QnGCMTRIbFH8G1O2ZdYZGg4yNzjJLoXRyD2GOMpxvEMJ8dP8eUXn+Dpl7/G7//Bd/H22w/x8ME9PHxwH413cEgg9eYXYy6EL0OERBqpKesRVMbZ+pl5gisxyp5KkLQj+weHQsrx07RcNs9yH8/mvZ0LsD2Yy7iT0/1OvlzmicqZr5JzX7fsknO2kYeviintWufzZ83luVfJu/Of20gOr69fX3zXtnKZfPlVMLBt378KWeJ167ftfZd/XyaibGlGNobMzbxXAPUmNR+jbbrMrne/juy7bS7W986xsqu8q8hbF7/3Vckzr0uKucpnte46v2Z4Yb3XCA5XWJnl3Mm7vwnxIEpwXKKXISV0weu9nFNB13rxmCxFT5vlXSJJBcmIOTLiOPYie3JC0OheC0rYu3mAW4f7GCPh+PgcP//FIzx69AXO1wP6kTCOCTEBICcRaxgYxhHjmHB+3iMOA8ZBSPZCJBVyudglWIj55OBCJ6mimJCSz2d7JJObkFN2E0dA9Q/o/s8mR7Np/bpvz84H6zqJckl5ecx3fsGFgZgMxyBJw+oDyDey+ohyn47jKDKeLsKy/wmB3SnOLP3PGoHb7hWiq0XfZRa8rY6wa3iN6FjlOSbvZadFFlm+Ca2QkTi7u8l9UKI5eThO8M4jZqLOdXkT5Zowc12uy3W5LtflumhxIE0XlHC+PsXp2UukNAq4NYjwuVgsVUDW/NAsYXlrg6h4XhJ8EO/1cRzQ9xucnZ+BiBB8i7ZdIgSNomICXiVPW6kF5SKIFeA653KHCFniXS4GyWCCfkrwPihgJ/d1neQyjXGUPJubtQBaGgLcsQMnZdJbDlMFzvvNWL27YqHHHoB4+ZGT/ikpMaDgT8zs7Zg0TLUpDiqsmhc9IO/wrVfPeYmY0/dSZ/FkFYBX4GV7VhF2AYIjDV+O0peSq9yAOCENZYH4K8yduXL6uoreP1eZKr4QUGiLYr0bpPg6by+eA/M5DkxDRjOLAuIUWIeGg3fOC5jsxcMhq1JKTPMugOAxjlHvE+VCCGERPli6lho0KqCt9x5N0yDGiGEYskITQsiGoxA8vCeMsZf0X9mDARDSmsvhPMv6ZYxxEIMNi2EhMuCdgwsNWs3Bbu8lNVSnGEE+oOtaMaoMCaEpuYPHMSLGlN8hYbwZ48hwLiEEj4VGsUgp6bqIF8a3EBMsmlMhwsieQ7AoHWXsTGkVrxGgiiIDA1L0PkzDmqeUkJMyKHhgk8H5EnFH0uUUA54LovQi7gZ0tgJpuLiurwKuzQ0HRCV38EWAZ16nUrc5aUCRAgBiEBLDl42hroNEQGL0Y8Kwjgje462H38StW0d4+uQxPv3kJ/DhFpwLeS+uAf4cdoss7YGdFfJu52bAqZ1huLj+GcK9YrH9IBNmdL81I4sp8dZuZx60GRMkkEM2DhXDgwIV6l0ePInnuD7HIsjM01xI5Dc7dxPIVWshG3pqEhyQ51+M8O0Cp+uXoDhiRQ6ti2j9Od5+6z6+/eF7eHD3LvrNGT799Je4c/cI3/zmezg4OsI//NMj/Pf/w/+E5y9OhFgUHDbDGdA7eBfx5ZNf4snjX6H1QOM9Xnz5JfZWC3z7Wx/h3/27f4PVag+OGJ89egQAuHF0hLu3b8N7LyQZx2jbBs61ua193+P58+fouk72CBLiUFAPeBmHoHsbQSwfCT16RET4xqM7OAD8HkZewMMheRndR79+io9//gxffHGKOBrxNJuVENOwFYS1PXs+xy+uo21A/jytmJFmdq0rBdJmoNP0mRfPMvGkngLJl4HJrwK2Lz/bd39G9T6XwfGL+8a2d75umffhqwDtqzxrm6HkTZWr1OmfW6ba/b6v1vYLfWZgsAK9ZHqFAe9bxnC+vkpWPdtzGYQITyJjS6S78sx67yzej5zlDuaY00fODQIAJroGSNPEkpOzJpNJGHfu3MT3v/dd/Nt/+ye4f/cu2tbBUwR4xNOnL/Df/jf/HX76s8+w3iQwHEYjH9MI51iJNx48JDB7kFdCqaNJihirp7XT6mek/OCD6gmFKG17PzPnZ63Xqv8Ej6YJSPAqoySJVONEpnNe0vwQ6TnjgIETeGSQd2iXCzRNCwAYhx792ENISGZIIZCmqSR2SMzw5NEFD6KAFAc0FNF6gnOMYbPGixdP4b1H23UIbQtm4MV4ihBaLJZLwDmcr0WuTkn6CBTA7AHV4SR9D8DwiHEAaITzEnmUE8BRUu9JHUepnyMAAeQ9XAKIRX500POYCH3fIzgnBn5yIAmQj+DlnDfv5qQ6KOBEXnFdPqtSWgtpJklaGQ8gpQ28Y7SdR9M6BMcYhzNs1uegjcfysMfeYoVVF+BowN27N/CDP/4+xqEHIcE7Qoojzk5P0ASPo6MDtBp9zvsX8F3AR7/9Ln77O+8gath82D9dTsTOFPBKRLU5B4RQpSny1bLmosOmlPD0+Qus1z3u3b+PrmvRth3a1QogRsjrKYr+6qDyGjTqj53DUrd6/RcyWNkjohIV5mSUy9LV6LfLlsQVFgHbB6ff3WWYr3/OPxObFuWH52hLfFH3Nnm9fkt+Z32WbW0KW4+VnfrC3lvekz+mHZ9Tfaddr4i7sLGYvYNrbOei7GB3ixztFR8xvc/uMKcOoAkBt2/fxn/6j//1hVRV9XgzM96686/yPUwOx+sNfvbJZ/jzP/8LfPHsGR5//gIptXjv/d+CaxYyX7XfGid6K6cenhiuAXqc4Z/+6e/w60e/wOmLJ0jDGnurJb7x8D4++p2P8M7b7+Lo8BDBUSZF2fhOCYmlY7nuEyqGUOtXS8kcfMhkz6ZtsVwusVwtq16cGqtrOWub3EO6FizS2pz0kdNFzft3kp53LqNeLLvXW5Gtt8nLu8gFVmqy/Da9t3a8eRXJeCqT7rpnOnfrs9fe+3Xlwa8i270JGfRNy7Hbnn1VfE3GPeX7Jt8Dsq5df38bkWNbPbbNsV37x3xPvljH6Xqx1xt+vG2vs9Q0cz3xAs4ww1p245DT9XPZeqnbdxXS/WX6zrZ6z+ssssTuuZXJHipvuOp8JTBiGvM7xmQ6LwAu7w+hctxVAgf5Qs8kIjQuYBxHNK6BU1llOI/wiwadA7omYnUr4PbRW/jeb9/HGBkxOZEDIfiBCwHMhJcnZ/jFLz7BT37yKzweTnDy7AnW5+e4dfMQ927fxvNnT3G6PsEwjkiR0SxWaGgPoVvAtx1caPHixQl804LgwCMLDpoIEsmMwEr0ls5LcIyc0lv6V7ErQB0BDQswh0lItNzZuFiaP9JrgzkHo0qn5RJStIjNIkf3/UbkXZWfDUfwvqTKDb44OQhJul63tk/LX17vFbuP4Dl9v0HXdXlmxFjSKgkJx2W9ZupQKW23s1PqI3PBMLFX7evX5erlmjBzXa7Ldbku1+W6aBEvn4jEEcQM70mU82WLYRCPsBhHjH2Cz55wKrAr0AQVlk0nJgAuOHRhidC1ek2FLLpEoK7/rvM6g/P3EjM4ClgrBAMJWd00IXslOhKPthhHjOOgz5PnFKFKjHNWiKAElXUW2OR7xUhZ8svXChRDA7UoQBbhXJPBEhEEFUdyDsEFBVSmSlat1NS5Oe09XdehbRoFvkd479SDUwBdeY5TQyLl5+d+1B+/SQb2LoXzX1Ixj7kaDCxV3gUkfB0DXgGbipIt7xK5v3j5GsjGnCTKkCopzFE8kJ0HcwEYmQHvfH52mbcprw2JaFFFliEjhJGmK5CyXq8nKQi89xMAQz4fMMYNQOJlESMwDgzAo20XAAQ86LoOi8UCXdfi5PQU681G1iZBw7lbahkhzDx79gx932cjkLQ74eTsWAw1HmhI0jONUfrGk1OAH5LnWIGXlCI49VnxMwJQ13V5TdvYlDUM2LKQvk2wUPTmeQGDhllTsDEDOQbMdnC4ABuApQIwgBR0ERDcBqxMDAUZO+etP63U7QLNr+02AtTfo7xvmAdLZUBh269tQqMAHCiRcKxWJWS+4hwsHpcOCcQSPYwjI6jHCycJxds0Lcahx0/+8adouwbMEc53AAm4ERMjQdeK80JYJAWqnZf3aroFOZ80KgCXfYBBmcyYW2X9auPkkAEeGQefx1UIbpbWQY00IAU6bL3JWms0uhmATNK0fmckgBOYh8m41mvS9u5CnqOCpQjaj/VwrsZBwJEaVEk8ukNwcIhIiDg6WALokcYzrE9f4q137+Ct+3dweLAAeMC4PkfarNGfBKxfHsMxcPryJfaWS5wd9xjGATGeI8YR+6sDJB7w4Xtv4wff+yZu3ThAFzxuHR1hsRSSrBHj+qEX0CUExJRwcnoqKRhQ9hzLQ23tbZoGbdvCe4++F8Je13Ugkoh2zgkgk5jlTHQCEvoQcOPGLRwd3cFf/OWP8KMf/xwvX57Bhw6RGeOQcHLW4/RszJGH6jU3j2hTG+Pma6he/9vAzHp9ZXKYfEPnRMrrZwocC0iUZoSZ2lhSX89rGJRFrauQY7btX7vumT5L3nbZd7YDu282csq2d1xFFtkJ8G7ZL3eN6/y9X6W8vgHq8nLZ9y5rw3xeXcW4Mgf6CyllVg8TvSqDlZx7Igc5JSHAUbWOlFQMidQg+5nlSCtnDlR2YGb0fT8xZNQh5O2f90K8k32kGN2GYcDZ2RnOz88zqFvWfwLgc3QZr5Ff7Jw9PX6Bv/vhX+PJFx/jP//TP8LvfvRtHB4EOD/gzm3g8KjB3l6DkTdgJiyaJcYUQSEBHBHjgM16QBMW8F70pqRk/HovAqZngckOJvPJfnFx/jdNk/uokC4FBGc4JOyBKYIgemDbBICSkDmdR9O0aEKLvh8kkpqeK57knCaS6Ddd6ERoY6dOx4zEA8bUIyj5JniAOCGNI9oQ8Pa923A8YH1+gjZ0uHPnGxiGHouuw8HhAbrFCuxafPH4Szx5+gyfPvocn3/yMVzo0HVLLJcHCEEiEiZNrcdquG7bBcbkMEYCeRmzmAhtt0Dfy7lLkLQr4B6uscgTCs4zI3jxlI0xyTwkn4mxHgQXCBSAMQ4AMXzTwDEBCCBq4KgDKSHJIaFxEQk9mBKWiwWaFrh9+zYaz3j+/DG++PxTfPTd38LBwW3cunmE+3fv4PbtWwhKsGWIPrDgAWg8nMLbiRza1ZEQLwYPRy2a0IDBOaomUZoYgDmlnMrr4n6AvMa2GdW27TP9MOCfPv4Yn33+Of7gD/8QBweHWC2XQpIGAI3iSvn5sjGYjFsbSSdn2mwvts/r+V/vV/U+NP9eXXa942JfXNwbdxlu872oUnyirFe7Z9v3L6uLfbZNjxf95NVn/bb6biuXyQmvKruMwvX1CRFx9t25zFUbzuyzbbpWfh5HLBvgg7ePcOvf/xlOT87x9//wM/zf/9c/4PNf/g2+fPICgEO3WOLGjZu4//A+4jji44//ES9fPlEZLaJpgNs3Fvj2hx/h3Xfexjc//BAffvABbt++g9VqT8hfVcTTbUTLy/rFsJ95H4zjiLZtsVgssFwu0TRN1eaLsp9d29Xvl/XvZffvwosuw5G2v3Nax8tk6PratudeJqNkfGP2vaus76uW+fuuIiNdVrbtq69Th39JZVv/7tJV5tfs3leN1VVk+8uwka+qK9TPq+fzZe+bfqdggfUcfd2x3NaGbWW+D+3GiS62w67PdeL5/XV9XlWnnRiUfGg3qSww+aLYFDIApud+pXfM9XPDTqz0fa8RhkVub90CbQNwAMYYMcZUMCEaMXLCXhPxjQdHOFh6hGahEb+Arg3o2hZxHLBer3F2fo7NpsfN23cRE7AZBvzyk0f43/7yf8fTJy9weOM2Do5uoVut0I+Skp7Z/z/svVuPJEl25/c7ZubuEZHXunZXX6Z7mjMcDi+LlQhQywUorIAFJUiA9kH6CoIAfUg9aPdpCe2SWmjJIZfk9AxneqYv1VWVtwh3NzM9HDNzC8+IrKzsmlYPkKeQFZkR4eZm5nY5l7/9D36I+NEQvRpFRiImbvHlQQFTxskHkPtaMivNFD0pfVs/iwxGqZjuEGVRi8nvkDA4WCcY6wrTm36WYhzjyBBiOlyktVQ/VjoM7D2aTrueI/p7TtUUY1RYmfUAACAASURBVGS5XFaHuWKxyeY6X/6ZH36YGGrCrcfevby53ANm7uVe7uVe7uVeiih1tRWLMbBcdkQC5+dnXF6tSzBQTzM2GKPAlIRxTgHUHEzW8qQ6JyViKzBMVoNvo9xU35Et02SmIEVi9PigTCwmRdgjIaUwmpzh4zjiXHJws+0M1Pv5dMInMPqRHOwUEVyTTkJICqKKUn+r45mEiHYgk5M+O9mnV3XCgrJaqI/lumNwlxNNAArqWkEU6nibTmcoDkLI+Tzj9FDmfrS3Lm/DEfHtSORuwbo7tC9O82BncZEJZ5Z/F4hRgwoZZDEMfWKPUYNEgxw5tcCSxsV0AngyyEUybf+UY7YOHiFSWJLqgHxt1NbjWAPKE9MMIoyDZ7RRgXTGJSPGs9ms2fRXBO/Z9BsQQ9O2NK1jdbAo9/NhQMbIOPYgAWO1bGNNqXOIWq920Sr4xUcwSlddnMcJ7xCjINEQR8s4KvAggxKAwjKTjbN80hpg9CObzSWNc7hGAW96usVMzzACZJYfXSdEdF7fHKAMJX0OkplBth2c80B7NhJrA/gmZ+g1h3GusGwH2LeG4A5HVll3K2M3064r2CTuXUtKv6RhX3xC6QRNIVU1aYyTaGozeCxRr2oeC4PHIq7BE7lMp/Jteww0yehPToASQE2nhNL7ZBBEalDemXJgIcaJ/an0T9oU8mfahwlwRj4t4wq7jHNNSvNXn2bO4KLK2VR3mgjKEOZL0Eh301BYi/JYqIFUWcop2qjppowIjRP6zYCVEbE+zf9IDAPOLbFG51xjhXFzwaoLmiLp4AnPv/wln//iH+hffcmLX7/Le88+4J133uXx03fxYeB8PdCsAo8fHvHDT97nex98wK8+f8XPf/kV4zAwrM9pW3j84AG/8/F7vPv4IavFgq5VAFQ/DGz6jfabTKeHiAqOCaOvAtm2ANuyQySD3ZqmoWmawhjVti1NApEGr2xEVtJp/6bl4PCId56+g22WPP/qFT/79HNenfU0zZJ+VKBVEEkMWJWDMI3hfY7BefC6/rz+3vaensFyHk1LF8v6HwIVgAsmQBfXgMSvu+/0+vrA35t+dlepA1zTWlNm4lu9x9uWmxz6b1O+K/rTrmCw7JgLN12b18JreqyQUtbVP0ACCpPmIprZsJx675atsqZYQwyRTb8p7IjGGmzaaDLQLq+PeZ7WjtUMGMkAHRG9LgN2c127xH5XO2hFdA3SlHEg4jDSpP6BMGy4OLvgeRMhjLQ20pgBP54zDp7f+cEznr88Z4yBTa8d29gGLMQ4YsTiDFhpkUzfIQoC7Id+xqplt9ai/H5OU9S4iZEv90Fe3zLgMj+nbFNIvCSGESEgcSRcbXBm5PTkWJ9WMJwePIQDSWmEGq42I19+/QXIhn68SPtki8gCKysW7RFN4xh94Gq45Iff/x7vvfuAg1WrAQwCRgInBx0meoZ+jZHI8ckRz7/+mouLCyDg+zP+y9//PeMw4kPg4crzJ3/0EauDQ1zT0vcjiOXho6fECC9evGJ9NWCwtE2Hp0Oc4fxqzfMXrzg7X7NojmhtxErkYNXy5PFTvv/xO1yu1/zTLz7jq+fPcU3H2dkABDYbz9VmREyHswKFWdAi0oDRPSWqQZhSMDUQLY1paI1A7DFxzaPTFQfLFV3rODxc8fDBKaenhzStsFl/yNnL7/Ps2RMWi5bVcsFqtaJr2xRDUV1HJ13WbBKASgzWNBA0ELTZeHwwiWlV7UWhCninwFMQSfrubM3bsZXsC54VHRa4WF/xxYuv+fz5V4xEooFF2+KswcRQAmASVWvTVqQgGNs6zz5QiQbNwmyf3V6ba7DKvA03AVJ2ya6Ab7237VwjU//epvw3kZ2BWa7vqLt1/LcjNwW0t+q15951v831qvm42hqSO/aoXfeyYjjoDlg9XjGcjKy6jmdPHvLy5Ssur9aIMfT9wPOvv+aLL37N8ckx/+z3P2DV/Q4HqyXGCEdHRxweHnJ4dMjx0RHHxyesVqsC4BZRVuI8R+Z1v6ntdfvmQAHnHEdHR3Rdt3WAa18/31Z/2Ke/fFv6x7771Dbq/DV/Xr/m3/e15W2P+1js3m099tsO1N7Uf98FuakebzrGdq0jtwHU5M92AdHetuyzEfPvtR9tuub1ZdxFbnvdbfovf753X3uLEr2C5rOukYGzMTtFc33y92fv7NIP8vv13yFC9Gpvm5QCFdH4R0MCsiZd3ong2pb22NBai1jLYrFgsUg6DBCDMsD3/cDoPe3yQNn1g+fhccfTk46rqx5xHVEaPv/yFf/pb35K2x0gBoKxjE4IPvtoky65pXClXT1GJGRff07hlGIJ1cG94keoff9GUylFqvcSw6eRClyYXG/ZJ6b9CViwzmGaVI/kG4sh6OFG9CCzFhWUfTj5vEJk1p7Zs99hX891qjkr3y5gTe3XvZe3I/eAmXu5l3u5l3u5lyRK/GA04A7EYBh9IHgDscGIU7rZlBoGESTlZ6+DH0XtksmRp6+TG6dSZXfU5CZFp1aItw2RrFB5H4uCrUFIZQ7Qk3jqVC9AgVxiHVhOhRujDr+YnexBHaONaxThnZVwAT0VnikT1emfHZOhBNcUzBNDBsukAITZNvxfZ4SXns7BC7EQZVJtJUKmiWc6nbvVzLclUj0tufnJfadkRz7kW10mv4E+jJSxWN6KkANJMaZAakTHoNYEm9gqMkClOJfM3AleOZJFjSwflBLUBM3T2zaatsh7r6eyiQQf8MHjx+n6EPWEgrMOMQ1No4CBwWqO38Y1qb7KVjX6IRmSG2IMuKYhRiH4QDCZWhPGYAhmwIimlbLWaVoCM4Hs8ikSbUQ28OL2uEvGY3ZqibW6HsXJAavO2LRmpKCGFpvWhBQAE6spYZBMly1kIGD9sDSwHiCO2p6t9ylriJ6Oz5dmsIw6WkUqxwDaLyWUuMtZkZPNpxtocCKn+0pvRg1EVKsLmT51t2MmpvEWS73zqJyM7twPcesaLXO6jw7pmNIO2MLaATn12NRHZVKJAYwW5xoFpaDrm2TGAQEflD1IzMS0o83VNRCywWwwVlNb1MwvuseZwk4gqcYKdqJ8T9sdpmcSUwRXdJdTQEdO9SdVW2uH2MTGI6kfQwxpT0l9FdHUY9VzFhFk5hivU4jksvPf1sDTx4c8ebgixIF+09K1JyCaamToe64urzg4PKDrDhBx+DEwroW2CTx9+pDTk0NePWz4u3ih/WOUDaDtGhZ+wavzDa/OLmi7juOjQz587x36IXJ0sOLB8Yqr9YYQR5bLjiePjnl0fMzBYsmy6yCCDx4rQte0uJz60OS0VKHgsnLAZO78qk8fZVYe59wWiwRRnTcSI370YCIiFrBY12Gs4+Jyw+XG43HghTFM8zRUkyrPZV0aTAE+xZjX4mns12mSakdPDayZXvUHmeaQpHVn9ONUTvpfdLmrmJ7szk0oJrAZaZ3X17g1/4uWI0IOiu6VeNOH12V3jHDfZlmH9H5zAbxvw0n+XQlQ1HKbQN2blpfBV1vBuXKPynlbO2jz+mpUd85rYWbkyGM65v2YaZ2O4sqeXMDq1ik7inNF/1Yab5/qo3pRlJSW1TlEFHSrjt38LaMpX6IhpnRBkZHgh6SfS9pzLLZxylhlUlCUDNBpiFiIyu7XWIMfNizbhtPjI548WvLes0c8OT7EX15wOXrG4ZLzi0s2F885+/oXvPjiC7wXmuURbbvkaHlKpGEYNB2n0BC8zltjBOsECCktYuor4/CjJ3pABJvaLDZiRbAWnFNAUd7HNFWsYRg83WHHZnOp5VvBj5d8+M4h43DF0G8Yes/maoNhRIav6PteAcf+OScnpxwsTzk6ahDT8vjkkKY9YhhWbPqezSawXnu+/PwXjOOSp++9z6NHp/Rjy+//+H2evXPKauGwkgHZI1YUOJHBj03bsuhaXr06Y73Z0PcbWgOHh0uWyyUHh4ecnj6kbVouLi958eIFL1685PLFp6yv1rx48YJFt+LJu8945+kjIpF+HBhCy9VmycuXZzTtgkYcTWM5PFjw+OEJ7777kIvLNQfNmi+PPAerFecXLYhjCIaXl55ffbXh1XmvunQCTREdrnFI9CAB4wTXtDRNSxgDToTOGhrbEsPIRx894tnTY44OWladjp22a3BOAdnBjzStK/tPmjDJnM5HUlSPmvYwfR2S3rnZ9Fhj6CTQSkOybDEiW/ZwjOlUc9bP5vqdQPBhKz2LBvUbRq9pgH0MbIaBV69eYZzj8dMneKDrWqyZjtBI+ad7m+Q9rlpU6pXrWvqiao8NQe3sfO1Ou3kWHNy3LtZBmtuAHG4jMbVFdgSFXiffNPDzbeyBk547q+ue9s7BDhNAxswunex0ueHZ7pPyzKOyCXiUFerRgwccHx/iva71iHBxcckvP/uMf/zpTzk5PubdRw948vABhwcHGGNYLBY0TVdSe+ueMNlTIrrP7atdUrm29szUtFLX3D8ZLO6cSwysiwKMrPtxu/zbj5Pa/sqg0e10Gm9H7gLK2QWSge2gaP77pjJvAtl8E8DGLrDcNyn7rtd81+W1IIzbDLW638l2+m5mqfqe+57RbeWbgpHmAK4aLPO2QDE3ya55d9f73AQ82Xevu9wvWwLUOkAp7AYrMftW6i+XuiUzeKvO2Z8IJIbI8nyqNN5q9ytroDW2pNHuhwErAeVijMVH1zir7IOC2ugiCA0ny47vPT4lRKEfA+ve88tfP9e0foeniG2J4hij6uMXl5ecnV1wdTky9EwH7IxR31cMmGiJIvTDwOA9MfllG9foAcsQiUEP0hrJvoeY/KCh6F1Zw4pxSq203e/ba5qIwRpH2yibmh8GhnEo/jPSPmitwdspDWFMTuzif8zp0IsfLPsCKXpEZnKegDApqwCx1Hsae9mPQkrJum+w3Mtd5B4wcy/3ci/3ci/3kkUUyBGiWvYXl+vkDFtw5BYTeASYArIpoL3jpHVWPrORE7O3PEl2wF+rxh5jRQ36uSI+ud+IQgy5TvkeSivY1DnWRXDNlGOdqGk/mBk4hWWjVjgDClQQp7eMuR8MprqJMZIACGNhCgg55cjWfUwVON1Or3AT4jr/8zGk06ZT2pyswMOkmObA7J3kBst2p5PsNxAA+81IHjtvIhG5laU/v+z1Bvg80J5PjhanshiaxtFKdqhJAg3oj7ItBAIRazQY7b0GHULUgJKxgh8j4+jxQQMvKzsxxohENpucF9czDn1K86XmVQgB5xqisWlYGGWlckKMA4VBpHjdBdc4rLOaOiyxNoXQs77YYBIoRqwleENrW0QMRhyCAZ8CYHhs6nc/9BAjTaLyrIPrZa2JCkkzzmJbR/R6AkQA61oyUCNmwEIISoNqDOI6lgdLcgvKbAvbqbNKUBptdiwsQjFb6fq9qMa5r+hQDfkrbpYGKOe9L1ZkoZ+tw5SRSBRlFckfCDoeQkn5NJ3ML0AjqP7OdyWlr8rzeRp1whQoLQH21E4tYraGSyxjgAjONTRNi7F6WkbBMqmPigdZgTAhBsQksJN1iS1AT/Ors1jni63W5ii53+o+ULYXa7VvrbHVPDGJkUnHbWbi0qpkwEzun4gP+eTO5BSqGVDyepwpf3V9r1JqVae/M3CyOFbLA5jtOyUY6spaH6KmqqrL17zSiS2mtXz/4wf8we+9y2Z9gcTA6fESiYGLi3POXr7i1aszDk8ecnj0AGtaNv1AGB9DGJDUruODd/nw/WcAbDYbHYtmwIc1wfdcnPdYAxINrW24ePU1zx4f8Qe/+xF937PZbGjblhiVcc0PI1chllO4zk4Bhuw83OcYDyGw2WzIaducc1unxFU3yWxWVTBNdN3zfiQ6dR7JVc/ZZY/rDK+uNmy8J5hW54rJDpcpYF875yNAmBipptNu+qx8HK85y2tmja2gXrVWGcnPL7NqQAx5XklZP3LqrpjuGXc5FMmn83U2SHmNRa/TMkp0JqtMuyUKpVtuK8KWrjA5sq4VPnt9TbF3dF7fJsjxtu+z67p9etybym0d0HX5t7nmdfWrgxNlF4l5b6zXMZJTNgU0gOi9fsHYxBoGiBAkpatTLyggiHFFH9B0jNM+rXWKaf9QQJx1FueWyl636TXlagw01tEsO7q2g6jp+oyxCtKNQkxAzAzCjNFDHBAijbEsDlaEKPh02jMkgGbTNGWfMFaIQUHp1giHq47Hp0vGzRnLRvjko6f8+Ecf8/6zp7SN4eL5c87RPeL8/IoXv/4F/vLXdOFrXNNyfNqxXHa8++yYEC3nF2silsurnn7wle4B/dUV4+hVbzIO74VhCBixdMsFi6ZTnSKCteDHS+K4oe06Dg80pYc1HcMAZ2eXHB8fc3bmWS4dq1XDsAn8yT//kPXVBWdnZ1xeXnJ5dYUR4auvvuLqSmnVh/4C5444OLA8fNjx6OFDTb23WGg7Ly94+eoVL1++5K/+6v9hHC/5/kcNP/79j2iahpPjYyw5DRIIoRpM+o6muTKcnpxyfHRMCJp29v1n7xGjsgZmBqBhGPj8889pnKXfrPnL//h/c3Z2BsD7H7zP4fGHfPDRI2IMPH/+NScnxzx8+JCrqzUQyx4jogykL168IEbH40ennB4tWS0bNE1TA82SX78cuPpPP+dseIF4h7EdJjh8H2iaJTaOWDvQth5nB5ZLizWGse+REDg+XNE0h3z08Xt8+N5jDhcNLvqyjpc5aC0Srq8XUs3diK7lEQXKhBgZg+eqX9OvN/R9z7Jb0C6cajNRFLyRB1Was0aEuCN10TT3o6Yw9EGxw0b3xOViyfnlJUPwXG16np+95Kuvn/Pk8RM++eR3+P73PlLbwVqaxMpnjcEWnilJuqxsbQv77OH8fp2yWPvq5nV1Vxl3DSS+afC0gJFm98/fuWvQ/KZ6xOo7u9q+S25bj6KHkRiCdlwbq3tnvTnrVCFOn+c0DTkoKTKB+6aStp/XfGxcs2tym6PaSiaC9yN+DCnA2QAjMVoCsFgc8uEHn/Des48Zvefh0YLVolGQ146At9kZPN7vUUgq11bvTHYokx2a+qltW5bLZQHKeO9L/91Gh5j303xPL5UpWO+kNZZhsts/N5eb6nHTuK714106x7yc+c+u8nbdK68N9b3ehrwpKON1eueuet1U7m2f/22ved1zfFO58V7Zl3BLKZZNvF6ffan2arvrLrLvebzumewDy+yr312e8U1jae86uOO6euzNv3ObNWYOlqnLeF0d931Wykr/q7l90/jb9sW9bqxuf6xrXPZx+epgHZJTm+rBRAMcOIvbbPDe48eRGKr0rrYpfpT6wGL0nuA9FkNjIm5h+eTDxzx9csJyeQjWEsQSEPrB8/z51/zqV5/z9VcXXF6MujcC0Th6H9j0gwJr1j0RwxjUQ2WblqZTGyV4jx9G4jgqQ2QCy0Svqc/FFO8eKaxxgzNgejbq+w4kamhGP7Jer7cYgbNfrGb03pUSc7plSp+d9hplxowY16Rrq8NLomCcrLOC+g2Reizn53o3ve5erss9YOZe7uVe7uVe7iWJcQbjoBjylYOiUJnLdSM8U6Lnv3cp4TAZrjcZiDdJDhiJTI4yk9g1tNaxClQl5/3M+ZgdD7460Z/fr42NOpiXnbT5mvV6vcUkUCOgs38hX6OBTVu+VwdZ62trI0WBDn5nH5X+lO02ZZm3Kf947zPs4q05DO7lm8t8jtTvb7OBbH8nBM21O/oRouaC1dhTT7/ZcEXk4OCIy4tLhsHTNh2r1UrBLSZgTJ4DhhgdL19dKmsHUpgznGtxbgnlPU2TMAEH1FD1IeBjJIrgozLTZIBCdo6KMbTdAmvAjwNDCIjEBGxoqrRKhsy6kh2pDoOxFQhHFMwTo76n9pM63rPjNd/fhxF1y0caOxmyGnir+jRGzRuUQS9V4LcEJgpbQ3ZqWmIMjKMnhrF4gDUOYRDM1F9isLbZWmMEPQVPApJonTS9DISyppTTGPU6PFsz8k/bdQzDgNTBeSGxrOx31BhrGXPgXySl9VIHs7Y7r7Gk55PBIFWaqjxWU/BfA14tYjRXc4gRHzU9kjIGJMBAjAksY2idMnNt1gMhqHGswBDS2NBaxKgnp/th0Ha3LW3bFTabDJTR3zNrgUlARlMYC6bnHNFTNnkf0PrndB2TE38aO7ucdtfmcl6n4zTX5/tg7cjNazVQGFiMEcQ0aT4MjOOQ9hcdL845hgGef33Jl1+tOT0+YbloiNEjjKyWDU1zyMkDjx8jIehJJSuOtgMjLaT+zHtU3/fFCeK95/HjxzjnuLq64vz8gi+/eM5qtWKz2XB6eprWH0lBZSnO/byf5XlU56De5dyb91G9Z+Y9vy4jX7NYLJRJx6dxH3wK7Gsap6OjI4x1fPXVGZvNiJ6UsghO836X/TgNcvbnlp9SLOr6tA9Qmvuvfr71ieQQRqzNTiGdq03TXrtnjJQxWbb/2T5/k1M4rTSoXpfGW95PXuOHfDM86W+Hg+rb0n/yWL4eVLtZ/31dYOU28jpH/OvKnY+n8h1JoMw5+MsYjLNEvz3ux3HU+SJC8IIyiOkeETPjl9W9tG0XuLZVoKMI3m8wRtmzQPeIprWadq5Rppez87Nif9hW9wrbatDVtS3jOBL7kWgj0giSudghAXOEMAYMDqLugYv2iM2gDnGJ0DqHi5omUlOpRk3DY0eMjHSt8PGHT/izf/nHrJaWv//bv+bRibLLGOtBPMYlSnKB04dH/K//y//A//g//XfoOuPwMSr4JQjrdc/l1Yaz80v+w3/8S16dXeJ9gCBcXa15/uu/ZRwDrmmJUQE4fgw8efouTx5+yIOHLTF6Xr58gR82XJ49Z7M5w4Rj/vif/SnvPXuPfhP55S+/4Bf+Ar8549Gx5cPvvcfHH73H0WHLgwNHDIHNpufi4pzLy0uePn1K23RFjxBRMLQfM7tPJIy+OMoXreXh8SHu+9/jn//hjxUAm9bARdcxej+xd7Jtg91kH2XGhfn3lsslH374ISEEfvSjH/Fnf/ZnLJdLvPeaVtcITatp/N5//8OyjxwejrRtS9/3rNdr+r4nhIizDT7AwWpFaDvWV5cYVlxdRV5dXPGzX73ii1+c8+DgEU27QID15QUXmxe4sObgcMHpyYK2NZxfvGTRjXz0vY94/uVzvvziC955dMRHH3/As2cnLBcBCRvVrajm2p75uGvuxhgxVtf5GAMksNeQ9AUxqseLMTBja8ll1QG/uU1KCiK5ptEUhgmIltOVAfhx5OrykvXlJadHxxwsl6wWC1y2y/OaUdvbTFvofM2a27b1+3nfKyBaudsOdJf94HWB57ltntvMd8D2vuv+V4+XWpdJH2o6r1lauF1BsnLJFjhDbbdd+mHuw7zfzFkasm64L/g7pa1I+1RjMdbpWB4GdE8y+EBKd6xt6ByaFljejs+k1m3ruYUkZqgwpV3NTK8AXdeV1K91OVtl3LoOkbazdJ2C8fshsUJ5tQ3UXMw2Xf2zPwD5TcAUNditBJ7TmJmDzudtrW342me3q3671pF52W9a97f5Wa7nTX/fVvbpna+Tu97vjcu7w2109O1+Vtt+kK1Y+vb6O5Ob+qe22bavgdsZRds+u+zLiXFKDXiX+Xvbut/0etd7zW31XOYuwMzr6njXOuz4QO+757r5vrDLP77vXjUrbO2DqA/v1D6Ter3SQ4ZTHWLymfnolSnbGU5PD5S9WwISe4wI3cJy/N4p7z9dIeKVTDYIITp8bBlGw8uXl3z6s8/467/+e06WK8bREKLQdkuuxjXD2DMyMkbLEA2bK0+MFu+BaGmbVnWlqEAUoscYX3rxJv9ibo8fRyTFW5qmKf2wK8aTf+bAxfk9cr9dXV0BsFqtii1Rg229Twy9XAfLze99L29H7gEz93Iv93Iv93IvSSIQk+GppxBVAQxxApmEKlhYguGVMlUrKXVwF9gKFtVK69y5NFdoJ+Nl8jdtn06vHGmhzhULMebT59vllXQQ7DYksgJYK3xZYcun2udB7BD9VnvyNbXynKV2DsRw/X67ThJN9VRFNyRg077gxrUgX5gU4t3l3k3mivX8/d82uVnRngzhqXnJ0fTa63bfqx6H246koQrW630mJ6IGhJ1TqvaQACjGCF3XJGBApOtanAuAYfQjcVCQjBGDca4AINq2USaLEBT0IYbAxG4y+Eg/aoNdYovx0eNHr2AHsSndUgDxWGOTEzA5K0Ng9FHTpXkQcTROQRcxRKLJ9NbatlhOemgas0GtPazN6Vhyn4XEFJVPtfuULi2BfBrLhJur+hllCsrrx/QaERNTUGh6ZsYIU3qeLNlog5goWGMwxTmbwTKZWYTcn5FkqGodfErDouAQTSMxjgMxKgsQYdspGBPLhD47DYjncbPejCmo6RIzT8wjFB+y24lSxzKCvdfT/nlNSFGMfGpZUkMNFjEZMGOVCSiBh3SsOqxpsK6p1helkYVI06jTNgdAfQJ8SfpcjKYI6Lpsok2glcxeACBOWCzUUaCpJJymCROTymiYKGa1f9TpnMEyUJhwsjsuZgaX9J7o84npxDZpH6nX/huD3vnZi0xBMNgCUN4UUB+GIVe/AH0yIwkoaM77sQQFfvJ3/8Q//uM/0TrD2F9xtDJ0beTBySE//MEnnJ4cp7IjoE6gxjpMGoN5j8+nW+v6jOPIarVisVgQQmTodcyu1+tUl8DTp085Ozvj4uKiXPvy5Uv6vk+gmo6+DyWIPj9Jm8FudSCsTsMUY2QYBrxXUNncsa7zP53EzfuiEYZh5OsXL/ny63P++m8+5fzsAmsbvFeWCR8yeFaZJ0JKmVSz1sxBOvW+v62jbAd58u8msWFtB3KmdScHoef7xFRO/nu/w2kerKrnX947clkhbM3+ai+r7rUHCCTl/2oNiVGnzM4rtttS13HX+29LbhNkruU3UY99AZybvrcPqHWbgEs9JuZ6965y5t+f369e67K+n8F/hSkNSrA0Ax9imru2jg0aqwAAIABJREFUUUAYQfeOPJ8PDla4xjEBQzNocoMRZXtZtQ4raa0kEoIlioJxTOLhOF4d07ad7o3WEkNkvd5gjSGMsGwXdEctMQb6/oowjjhncVZZ59qm4fPPvySw5uR0yXK54Msv/5HQjzgxLI9WHB+fMvQDgx8JweMay/HxgTJ0+Mg7Tx7xg0/e5dGROr7/4Hffo2sN1nrd34NOjJAZ8kLABksni8L2YVXpojHQLVuOuobHR0uenv5pAlAGhECIns36v80qATGiTDiAtc2Urgpdb0yE6HsiPdYJh4cr2qbFe8tHz5Zsfv9dQow0jdB1lqYxGAYcqgO4heOgOyE+PKnSD+YxACIBY9PeCZjWFkZ9Zy0SlenGuAwEiRAD42aT9ALJSsxOOzC/t7XGz8Z5lvn613VdtS6rbjkOgcwEGHza56Oh70diENpmQdssQODo6BhMQPAQPH44pjVL+h5enWv9/+4ff8L581/z7NlTfviDj/jo/Q9Zto7GLRABIx6xIyLKsrbsVvT9h2w2A23raFtL23qMBDAOSeNdwSgCklgU981574tdh9F9OgiqqxnHwcEBq+WSGDT9Ug5KmBgLEDzvT/vSRWQfgHZsxBkDYjFBmfe8D4y+p7WWhycnLBdLmrZl02/o1xsMsOx0jpLua4xJrCQTa9W+QE1dl7lss5bs3oDme3Mttw2qzIOCu8rZF0zc1559bZp/9y77UlmHZ2W+TnbVMb8/b3f2Wfiktzlri842jqqXahoj3QPGUU/L53k5Dun0fCq3aZoyPmHu47keCJs/k5BYuHIg0ydWUecc3aJDt0FJ6SoSy0xivtQ8FgJ2YiucMGL7bfe5npfrsi8wO/dxlbKSDjgPumo6tU0pb+5batu2MGzV1877K9sISMQ6R9OYokOHGLm8WPPq1TnjEHbOodfJfJzPdY55++vgad22rFcD5eDAvvvtWh9uM1fmdXnT+bXrGd7kS8xyW/3tputvu17dRcf9JnW/Sa6tnZC4Lb651ONFbaDd9923pu1rVz0+59dMttp1G2PbXpOt6+rv3Favv2l/uEn2jaX52jnX/edrbP79pvH0OnvmbciNfcT+Z/26FFiv0y/y5/mw7Hwtn3+ef49xOuiDGLwh+ZMExlHTKvkR1euhEUFiJPTK6r/IvtAxPS88EU1F2h0HHvzoET/83gGkwwhEiBguNx2/+OwLfvWrz3n18hX9AP1hg7EO7wOXlxvOzq8Yx4hrGlzrkm10Tj5QlvfP+X5SS0js5NY6FgtzzXcDlMNT9dia932dZjCnIGzbdqbL60HGGNQHS8xpvCOjj8VX5b36S6UcdtoP1r2XN5N7wMy93Mu93Mu93EsS5zq67hDrLG3TMAUqM8PKyJjSGE3gmUwhPZ1a3hcY2fV3/j0rW1mBmhvRWmaJfO8pR7Bulk4hefjnDoddKRPmDo4chNrlrNjVHoOhdm1mx8F+B09Kx8B2W6+xX1TX3Eb2fk+9ktzJI/Km9+LtG01vO6B1t/olx5pWSF9yf96xevuMkutOtp21mdoRRY2JVMfgTcqBnl3SeoIOIsZkMABoyo40u0TBDRIFKxqgQiip2NQ2E3xE0z1FMCn9k0gCUbgGolJlmkStrbnijQbmB48VBfZss+ik8iOlbjn9lSEFzgKMMYdeIoKm2EGUoURwWKOOcyOGYRwAzZ1rjRS2FpPWqzI/87QQQU8cUhys+gxAGUj0b5tOxZMDeSEPh5QuKQRGr4AiqZh7plslYFz13AuQI5UvAiYaNFVQXiM0pVMUp47eMhR1zUqENbOBpAZ3Dk5qndOanQPworTqOR1QZoDJ6bjyXuCs0/RKIhhRJiJj9X1lIWowpkVEwSu6rnumdEfgfa/jIHpC0JPsJQgrtjDKaJvS+miqeZfHiwiITyenXUq1lNfcDL6K6TWPJT3hUyK/FVgmT+AEdyrzuy5H59fU5/rcbjpFi6brYpcT/XoQoF6TnHNpn/AlzZYGLBV4Vp/q8cHgN7BeewwD47DGuQWnpyc8ePSItuuUocFJSgeWGJ5sU/a6fEoqM0TAFHzQMWkTQE9YLfXzg4NDvB/5+uuvOTs74+DgYKuc4+PjApDJQJbcD3mvH4ah6Bm1iCjIKZ8ymp/0yvVqmiaxAtSsF5rWzUcNiAYfubi6Yr3p2fSjAveSE4aYUy9ed4Tt0mXm+7ixQsxlVN+b/8xBN0Yq3UALmxb5Mma2x5P+PdWzBuHUzqdtMdW16R1Tg2Ried3SqZQI+lppVSu327zjzreR2zh/73Ld26rHvv05y5vWb1dQa/77fIzdVP4uB259n/m99jmMd7WzdoDGanymrU7/E5CcZi9ODDPTXulwboE1XQLhBxadwZnIZnPFq1fPsSbSNcLF+UvOXr0gRk/rqrQcERDVLcRaQogcHB3zyQ9+l6Njx6ef/oyuW/DBB9/j5OgZv/7Vr3j+/Cuct7xz8pTvf/wRbesweJxV5/TQb1gtF1xcPEJkpFs6rHOcn10Ro2BdQ9t1WNcQQ2TwI8PQY6wCTwggQThaHXByfEjnPAZwywUkABARBTBEIZCc20REAmKLdjG9lv1fcM7StYfkrpby2xQkCDGW1CbpKWq/G012Y6JBCIiMIApEjjESjaUzC2J3mPSgiBiPEBLwwKVkOekRS/VM855TWEwUFDTEwBgUUG2MAa8U8NZYbAIjGkn7D0lXNKp76HYuO8fgroBqbZfNx/bcliyNSHpArdOlUZ7AMzAxyglIBzgd1mGglYHGCK2NtI1Ffvg+i8OWEOFg1fHw5JAHxwesupZATqc4gIwYS9JPHMt2SVhl3c0jMhBFQe0h6WQhBsaxCkZJgtym16z/CKL6LhBFg5AGiIn9UXUnW+aQlIAlBQxf99mcNTV/JiZpzLFor3mB0FrHiNL0gzOW44NDhm5BiCEBwaucyFvPhGl+sz0Gblo/d78nxL3Qov1yF7tyvobO1+vbrN/fRXldXevPt/1AkTHCMPRYa6+x64Km+Ly8vCRGPXS06YetPaXrOvq+p+s6Dg4Oru1X9Vyf28YZIJPn/MXFBTHGUp5rnLL5iYbqNfCma4gSmMWUJiaqih8jGTFzm6c3H69vFkiWBKq/Xua8nLoPsn2wr0923SsEWF+ODH3EOa/A0hjpNyPjABFTUqlXNeE2Q3if/rGvLfM21eV8m3ITGOAm2bVGvW2d9C5y1/77Nuue3S1vJGk/2/nR3j3hhuJu+Py2e8/rbIMs+77zmxrqu+bUbftjrlfddN23NVdvtL9uuO4uY3pfX920htUgkwwWzfufFbU3JEJIKexDCESfQcswZgBn02mqQEHZhMOQfG2CDx5nDW1jCa1wcJBgDKmqIfk0TrslHz1+TN+fEo1jGB0+Cv0Q+OrrV/zDzz7j6kr9IFrvQAgTU3TR+SqfxXxv09BFJGPHlOV42Np75rGTXQd66vmTfbE165jGQ2Ll+zPJj5ftKHCuTWV5TPDJVlGf5L28HbnvyXu5l3u5l3u5lyRNs2CxOKwYLXLwUZ1hYizGhkTJNzDIQAiCCV6drEmZLMHsncrqlmtXFaJyknv6JEfns09enZ3pdH3tQCgOPi07VCfDc0Ayp9+YGwH7HFs3gRf2GRDqwDRYtgMUc8DMdSeC5gOt369PTOw2FL6hkZKYFWIB69QnxXfd626G9N3t793GytuUbHjvMsBvvFPlcJ/Kuq3sM5p3Bc+yv2471Zd+X+9aM2gQJUNAIIZE4wkiITGcTGAJY2wCBeiPn0hMCvTNGIuxyYEYE8NKaUUO4mejUCFzIXgiYI06SY2IHgaIsnVaT/IfRqmxp/kRNHRk1IlqJDn7Q+qQHDcjRVhi1FPuObVP7r+YGKWIuahpLhoNA1kbygxAKqp4SencYq632QJE5N8zYEYNPK8pEyqDcxzH0l8mAW12pZIhRBzNVPXUp4LF2JiCVVL6TYPsVk8j55U2xsLgUvqxWts0cGPTupL6NgYNL4R0wjiz21QpjUQknV7WtTfEWFjHstN7Ym3JOYwbRBwx5rYaYkyBT408YV1LjK6qZ0hVT2mTxEwAAvJY1+eS1/ksIQ6Ika06m/zddHoHpvVtCs5MRnf5RlSGGwW4TOMtz8cYNSRTVo28P8XZGjlz7NXOgVyHyXkgW+Oq1JGYAhFpHIu20RoLAZwJ2AbERMaxx8pI21hWiwXHxwecHC85ObQ8fXzIwwdHtE7YbC6xaMoToqhjvOzZkhh69FmX2kfKCfZ6jMaoJ6qsEfrNyNX6CmstR0eHRAyXV5cEH1gdrBARpdkVwaZgqnMKtMrOkX7odZ3J49xM4LAJVFez8yRgn+iz0hPrAZcJLRJjjhjBigEsRiKNFcLQE/2IdV15VoUFaqYT7GI2qD+rT7gX8EpezzPQTKdBChjnwCMKAque+fxU4669SfeCHPgN0+n6yNb4Km1htq/UY1QHehrRsbpBevAE2FWHqo51xcocmlo1e52/n8Ug12+T2rL7/ayf3iQ6Z6/f+00BLq9zNt8UBLqNw3b+nZpGPH++z1Fb169mJdwVSNtVVyn3T/t8BsiW+wkF4iBmYhxLexGSgJaZkpycvrFKQ2oMjXMpHeOaEDZsLteMMjKOV8ThJcenR7z3ziMkdlyerxiGDSGOfPrpp3z1/Cv86OmWS37vxz8mRFhvNjx7b8V//6/+kGEMPD4aca7h/fef8vjBI371WHjxtbJ8PHn8kO9//ITlssNITPqRZxwHlosOY95Bd4sMEJDkdFXQp89pMkJg9AMQ9UBBFGXNSeto8ENhztCZk/ex3NdZkRMwftpb0o8CGupnUzmJ0+d5Pmf9Tao5l0EDRgzGuhQINgn7aQHVczRlnZQ1I+sRelObHNLmugIv+T3dJ03MAWVPCCObwXN2tVaQttP7S4w0VllJrNHkmDoxQ1of8/6437aqx20el/M9dauaM+e+vkcxHfP+ChNAWQGk26ylgqBgSpDoUHVtBANN63j65JTHTx8lZqMAXg+POGvwZNYTR7GIY2IGzHpFwuT6XCdRYHGeojVYJqezSg+tjBuTWJ7IT1C2V935uq7PO1t+WVek6ABZ39vuc5AQS8yiwOur8ao680SV36QxkMdp0cBirMZ92n9iPjhSniDGGpj3w2tEZnrXbeT1Zed+270X1cOv7q/t7+yv010CvbcWqQbDrWXy4eQyavNzC7yBErNgJwicSYByk2zCq/W6AJt90mfHlAp4HFVvvLi44Pz8jEePH7NaLFksWmxOH5sPFelg1bsmeyHrPVqZtG8lWzCvh84arOg6BAlMlpa7EgAVmd6s+468DuQO2H4uk68r/536j+vj6k2BFdfsxKrMzCzTNg1t2+ohhqwT5r2gzO/yX+mrIQSGIYEoUwtCyOvh1tOu1srr7a/7YV7nuc4xDzZ/F4AlWfYFx+9y3Tcpb6fU10Uq1se8d+3Rz/fc8y4gEfaUdVM5twKR3LpESjPvok/fRURu2Eny/p10L+K0POxr03zc3wgAmX22CzCXbpdrcW3T2ZqLO74rs/d32Svq0347Y+K2cmOJ++yfb3kt2QeaqgEh+e+sn1lI+mXyU0pKb48w+pH1ekOIkcOjQ9pFq9tZDBCGBCgXxlHTZIsj6Wnq/7QJ5I0Bg6d7sODRcaPXWYcPlsEHLq42nBzDahW5uhoZxsiXXz7n1188h9go2yNCbFpCUB9m9gAEkm4nRTvUNqbDi6YAY6X4cOJs7SoWUPVZZrSpfbqQD8CpX0bwKVWi+qUzy2Uuo21ziiz1JWZ2RusqkPa9fCO5B8zcy73cy73cy70kca6hbTsA+n6DWgIOYzL7gU0OP8NoNXWJ90obqAwUYSLfICRnh/5VpHgY1KQPIZY0SiZR7xV1VL3DxSCJBWU8KaxGbFJOfXHM1AEEZWq47ujYB46ZG/rza3elz8l/5yDfrnJrqY2TGGPy/0wG1e0MvrsYK5OHM4dCauerOm13XBVvdg7sA/XczaB6+8bP3v6Mu0+P3eg4yM5ibrQl99Xk5k9nBVoXyWl/siMrO+UyGEH7P7dDKZc1EBuJeIZBA0PDMBBCoOsW5CwJIhrgHYOebsVMY8+o97kCDJjKYanOGmtSPaIyqihoJBIlFDrODNZR56rBNmbKS+ucBnaMLQZmyBZaCpYbrp9MyCnRgK15fA0kEiOtbZKhut3Prg4uh8joPYUmRiImxgoEMrFa1GnljLEll7HIqAZljCXAlhk5jJEy1/J6FKMavWKm3Md5adS0QPkeRlMbZNAfGUCgbDWFwSXmoN6Y0vTU6V8CIZqShsU5S8QjAt6PaVx0OKdgClsxBtkUpxmGnn4YdAkRpVe31pT2xZjTvIwp4JbTTCVWnTJGfOqXdusZZiBLjJTAb/4sr4nzFDgA0ds0RbJHjRL43OW0zo70yTm8LXkNrF9z3aQqIzsGdonMys7PESgAkXn7tvM7ByKeceyJQVNtdG2HFQc+IAEaa3HWYl3AtS3OwqqFh8crnr33Dk8ePeDi4gXEgcvzV1wEz/rqgst2QesaunbB0eERPozkoPfUBxUldQhlb8iYtBhjSRc1jiPDMGCNcHR8yGLZcbXZsN6suVpfYVqrlPy2eDwRK7hWmW2sMZiobDnEBICr0zARNWUS9T6jc9QawVqhaQTXqG5ix4AYYbPpGX1PZxtNIYbQmMhq4WhtxEnEWQhGg9tEiB7w0ziog7K7HP55XdDAqA6QEBMTVwKBGFGGCYOAnRxpGVB8pyBCZAokZce5sFWXXJ99YInCLpAn3bV7p/1mTxXmX49Jp5u0C0qotOwiRTdky1srsdbtXi9vAkYpdSmBH7ne1NKGN9dXImwBn7bqecN+fxtgQK0L7gLNzB3pu/bE+l7XdN4YwZpqfiuEdALvJeeny1wjCpgJouwrxtopMOkUbOmsRX2nIQFoNd3e4QIWjefq6pLgNxCvcM7jLLiHx3z/44/44L33WS1W9Jue87NzDg4O+Mu/+kt++dlnjOPI4eEhf/7nf04IgfV6zfvvv8e//tf/ip///DP+69//UWHcMsby4bune/pcafujCK11YCy2aXS986PqNXbq35z6khixArYg8lKK2AQ81XGgQWKf7Zu0fiVcmvZVDmiGbWeu3oMSFJgCGSlNnLqs07iYsVkVfTClFMRgYh43AU8CFyKEKESMBt4kFHtApkUkj66t0SsiBO/LOMvrszGGURJAKKXL894Tg6d1jsYaZS0UZbGJiYMzO/ytKDNcccPvC4rECSizi2a/rmdto20FMdL/WTeq9QAdNxPLn+5zHomj1ixNCZ+CCvlenUtgbQsx6S0eiBLL6V1fGPRAxGu/awUJMaZggNe9cTbny089JtK15ZlXn5XgXXrP1E9xu4CkZ4RszaS9oGKXiAVSDmkcSxSCrwB9IgSZ7NdKDatvtRWwK7t43lNDKAGXrP84UarE2s6er427ZJ4aJX/35rX99Tb3fIu8yaegn+9iHYxlfucy3laQei7Fqn9TGzVtzrU+uAu8kf5QsBgxBfIjYnV9jBH86Lm4vKTve0QMi8WC1eFh0Z0Ww4B/PvL5F+d8/uXndIuWh6cnrBYLRGJKWxtK6i4dPGm05/eSLSWuxRi1v4wRDlYHxOgxslAd0xpMnMZjLD8xoX6u+1/Kmsx1nb7urrJ/Uus8s+/NbZFd/Tl7b9ertapPHx4e0lgFa2agaqyUKkn9E7MfJv+IzPQVrdc8BfFUy1jsxn1DdZc+NrfF96XH/C7Im86zuwJi3hiEExPIKfcj22uH7hc77iPVd95A7rre7LJfapu2lrKW3+lO+5ez1wHU9l0zr3PRM6jWgN0Xl3k17XXCbcyY2+j+u96vr9+arTt8Hfn9rVemtQqyj092zt/63nffhd5cbrzXG47n37TsW/fqw08hqNPEyMRWVvrUGT14KIH1cMV6s2FkBAvL5TKl1WzKPbxPIJZQPUNjEOf0IB1gpE0+uUDS/BEzYOKIkSsOV5Hf/eRd+j4Alv/812uef/kZbnWsaeUxysSGYb3u2QyDsh36Ee+HgpkPPqi/JNk2BE11KpAOOUmZQ6m3CnOZsZYMbCn+tDL31E/sGld8PoKUtLSZ/bH4UGPEOUPburLmFEbkPXb5vby53ANm7uVe7uVe7uVeklhncE1yxg5q5Fqion0TjWDN3hIMxGgwbcvoB/LpMoAQRjw+KeuVGpwYK/CTEa0sBRp8yvmr90ntEM3ivWcYlLowB+prx65PaaRgUjSdc8XBvstwKn2y5cjbPt04N1J2pZSojbAcLL5mmMibmiSpT9/YwN3//V2Bu6n+vxmn3m+jvN75uv+61xnx29/ZNlTLZzE7j+vxWg+F/DlpPliapqXrprmmxtcEMGtcq9T+IRAyM0rQNEpN0+Bcgw8+3cvSuAZrbXL2j4whsU1YV4LdmS46xpyPXui6RQJXhARGcbqOpHmTASolF246kRhC2Foj8vzPbajzC2dQi9bb4X1eByYwm/c+rROaVkqv92luR6w1dItmC9iQ15i8BuY6TCwrlpjSEzSALLYDS7l+TdNUa0A2BK9/rw4ObbFq5JMlMgFLcq77GDUNQd9vGP2UU9gYg2vaco+2dfgwEqOn7/vk0Nb+8aNnjEot2zYtMcTCHLMwLhnjJvW7AqQyqEhBFNvGbL5/bkded8vpm8yKQHbk3szmof0wpWXYRxlbr+n5td6/MnX7PAiXqeTrlH3znNQ11WwNhJkHreuf+t45wFzXt+wd2RMmAo2FqCnPogj9sKFfr2lbi42RTb+hbQJ/+if/kuPjJTFc4ocrxtHzf/3bf8df/eX/y/qq5+johIODQ04fHDMMa4yNPH3nMX/w+7/Huw+PaOx0wr+uu/d6qqhObZHrvlqtAHj16pWmYLK2zJGu61itVvTDwHq9LuvB2Pdcbi7LfMljIP9dA2VyPcZxxIeR4Md0ckiBKK6xKXhg6boWaw2bzQairivLpeX4+FgBKxHW65Fh0/PRh9/jp5+ecX7xK9Z9T7ts2AxjOqAsRJlAO/mZ1eM11zPX0aZ258/zeJmD/Ob6R36dp7yq+3pOUTwfQ/Pg6jxIsUtfmc+ren7MJWJ3Ooy3y5heI5lJKpR3cn71a/erxpvEuXPt+v3ejkyBsTeReL0J26XuDI6SglRvdq96rZo/55t0iDy+6jE0Bxheo8Q2hnwePZIZIgChsHWJmLLmW+sQ6zBth7OtrktBnadKUReIfiDEK2I44+rqJT6sOTpa8P33v8+PPvoAJ0K7aDg+PqBdNIQYGcaBk5MTfvmLz/iLv/gP/Pt//xd88fnn/M//5t/w3/yLf8EPfvADHjx4UCi/m6ZhtVphjOHTT3/JZrNhsVgACuBrmqbMwRB8ccwCRS/QxzPt7TeNsXrtq+dS0Q/EltOQIQTETswyEQVFzJ/xHGyZQ50+6EEDiTOHfJoz1O8lyevnZrNhnRgdFotF2rNcGRMZ3FvrNTe1uf5Ova7U+3Be85wRTg5WnJ4cTzoZmp7HGJMY/ALBhxJEEJE0bMLecb6vnvP1rt6L677J6+vovQJXqrbN7cRaB8vX2sQYVJdX1wGus5CNIdAPA+M40vc9m81mS2/suo7FYqH7l3W4xm21YdvO3t4v3jQIulOipDUtJ1OGGuIy3VM/lLRsGtm9fs7t59+07L/T9fWxtte+LVv12+yLty0lgFVJvXfUYz3r+cYIIXr6BJjLzJzOOh48eJBA+WprZf9O0zScnJ7QLloOj475wQ9/V9d0MQSE0aexHyJYg0kAZIVw7X6Ofd8D0DqbwPwNLgFCQ+TaOvzbIvXetVwuWSwWal/73SAUYbe/oaxrd7j/XebO3AbKZf02z49vU/JzZE9/fZf6Me9d33Vw1P+/crvnddf5dpvydumyr9O17uX1Uttc+W8FtwQa1yBGtj6TqCle+76nbVuWyyVX6zVfffUV5+fnPHnyhOPDQ7quKz6ArutKGfmgUk7/lH+Oj09pm462bVl0et/Liwui7zlaLTg+ahAcX331Nf/wD5/y63/6OX644uDJKcY1+DEwDhtCEI6OHKu4YOhH1hthHJtyQHntrxjjMLEKBmWVg7TPxlh8zcWH4bOPFULytQTAJyvUWFMYrE3yD42jZwwe5xyLxaKy60LxtWSf3TiOxRY0xvzW7vffRbkHzNzLvdzLvdzLvSQJoacfLhH01Lb3mkpFlZMU9EzpVpzrWC7QYFbwSXkb8MGX4KGeHIwlGBeJ+HEk+kCUlE6hCqjuUtjnDtGsJGl9QxUEbtl25Gznup+nvJjT3meZB6Dmga55nbbK2HXaYxb0nb+nfyswYJdo8ddcWNXP7WWq63Zwua7froDajS7K32IHyO6+vc11N58QqT/fZ4y+rgxS1baCJhUIQU8Z5+/nwKoGrerHrCcClKUEgRhimaP5VmFUxgNrhLbrsOmkdMzMHQFs1ICNQRLVvgaYjXWQ0ujkYDJM1O7OtTSuMppCDk6NeL8uIBvQ+dw0toBtMvtUzSgzD3I0iS6nDkjUTl1jUuCBdFpchKYxGKMnehsrtNJgpNvqc2Pk2nM8OTkpQfySVqYA8oZyol6LSSAEI+Ukj4KdPIERwnQqXQOukru6lKF1FoKfTliW8HSI4KU4gwuvRIwoqMkpA0AOWEtInwd1LKdUX03TkPMui6ijOZ+mzKdW8vgS0XzCwVenkqMQfAY3TQwT9TOo19B6zc59adPYnMBg2+vrLieciBQg0dYc2TWPmII68zV47jC6nhppWrfzd+v7Xt8vJnag+ed1u+t26PDIQIk0LkRo07iQCNFHYrA07Sqd1Ikgjsv1Ff/23/0lTWMxeKxEukXLegP/+//xv/Hx995jvd7w1ZdfcHl+xrNn7zCOA69evqRpHNZObZ8H6SQFzqd5PfVjBg8dHx/T970GQoxwcXGBpPHUdW3Zl4d+YOgHJE7AowxuzeVuBaH1TWJI7ElGTwzFqKlMvNex7P3IZtOzXq/XZe9HAAAgAElEQVTpuuwo6micphaJ0TMMI85aVoslUQwmRByCBfwwYpNuoswHCkybp2Gr61o/z3qc5Nca2DcHLcwBDHPg1nzs1tfX/V7Pjfn19fidv7+rHvNrpjY25EUnz2sNoMbqpNwEoI4AOZ1axZqXt9g50LlgPkMql93yTfSL7T6Ne/WsffcpK3H5KM/nrSt3lJXSi0WIfnLw7QrqwzZAJq/JtQ4bw/UOmo/R/DzngK0pjeDEapKfcxBN0KIgGWV1EBFlZRLV99tWdQLdy5T1TcJAHC9pncG2I2P/isPDBeevnhPHKxYLywePDnj//R/w7tOnHB+tWHYNxgh/93d/z1//n/+Zw6Mjnj17xtXVmvPzM95//wN+78c/5g//6I/ouo53332X46Mjuq6j7/sCbMn6/mKx4Pz8vABktE3CZrOpxv10CrsGq8+BEWqnXAc+5XJKf1V2g6n27iAQU79FUba1PP7HBNgwNrPrRdabta6ZcQI5uQIsnfQdQkxpJKc0TPUcdc7RNA3DMOCc4/j4eEtHyYMmhFBYweZrzVxvnQdY6rVmvkYVcHNiuHMEoh9pnGMcPevLS4iR5VL3rX/46U/52c9+zvHxMb/zySccHx0UcJYxcm3c189qV+BnPp92rXX52dsZSPUmsE3dvrCjL2rQ9i7dtO06jHN4IjYfPHETeMmkcbIZFQQmJDanWVvm9ZnrFOlD3kQULCMKZkw6nuKWIq9enbHZbBj6gXH0vPvsGd4rcKhrG6zIFmBhPj92ibB7rwG2dKK6b2PZUNhu67zs+n25vhfPf7+N3BTkv6ket9mn9rESfhPZu2/F6fP53Nlnq+qKeV3qvQNmAHGJCKawnxiTGaMmQzTGyS5dr9f44PX0OhCNI0jg/HLNolvQOGUdVFHW4ZpFSdODqd2L6Gjs+74cmjJEXJNT0G3vm3PdO7/Ox02tW+3r47vKzudV2Sd1XTJI++joqAQCcxk5bdm+tW+btbLSA1/Tll1j/6b279Mx8+9wXfd73f3n7XndGjP//vz9XXV63TO96zN/0/Vmfs+pnty4ttdrZv1ejGwxndx2bbpLveu1pT7s+No9Ybav7Vprb6rjN+njeR3mZUvS23fd53Vr6G3vVf9d6zlZan1+3iciorbxDeXvkvke+zr7sbrwW2WZ+S7I/Nnu2x+yeO9Lnw6DMnrn/dBayziMxX5XQPlIiHogMfvEFl1XQKfPnz9HIjw4OcF7z3q9pmmaMs/yAbVcZtM0dF0LAv14yWaImLWlbVq6tmO5WDB6T98PhDDw5MEBh3/wCb/7yXsMw8iA+npGHxjGwFU/8uLrM/7mJ/+FoYksnKMfLP0QOTo45tWl42qzxvsBHwPjMBRmGVD/pw+++IFFQNJ+FbI9bXMKX7Ol9/oQ8GOys4xgm0bT/iLX+j4ffpgfwsu6zL28HbkHzNzLvdzLvdzLvSQJQdMtmezUszEZbHoaVQOwhnxykpiUIMDmU53eE1KKkBhGYhxzKEpPezpDDIbgwQ+hnAqaGw3Z4M/gmEkRyop+YKKRrR3JVfAmKfoSmZwmsXrJn+f7Sn3SXraO4uxyMGe5rfG236ipU8bUla3/TFZwdhRpdGq7UVsBqrpOcfbrlqlVlMsYYzIUs7Ip6eTsrZo3k7uqq8JuXtOJJvWNZVd5kv97nSNH2H5soZygz/WJORCX2ZOiOumya1nSEJ0bpa9zwsaEvEcSYEKH6LXxZgxYaxILlCLuQ2IzSmzwhZZ60/cM6VSCMZamUdYQH8YEuRAwDmLEx4AfFVjStR0gmm4IZZkwAngtCwmIMSBTwFvXEJPyq0dMmIJzoFTeJtHgx9lwNWKxLs/3bKRmR6HV9qQ2mRykzUYt03MQqdKEbE2D/Mc2u8ZWJbh+wj/XY3rVNpT0WBVgJv2ipaW8LzmNRQiB6APWTUEtchtyZ8Q6kJpTIKhDmKgn53U0psCHCFE8trEYyWu1ptISsyHSk9NjpcQISn9qwJk8jjKwSalTfVBQjE+n9F3TsrnapNRSIAl4k5sqJmJMQETTfA19QFN4ZVBUxFrts9zUGNLnsr22ZuBO8g+VNWrrGYmv5vJ28OTa84zXn/NtHHB75+cOh5YyP1XtEG2bvp2fbSxrQh6dItWYjALeMFFbmDJaTQ6mihBTsPZsM2L6kc55Pnj3lD/+r/4II56jpfDLT3/Cq1df0zhL6ywHS4Nrj2k7x3rdY63ByjS3QghsNpuy32ZHd+3Ai3EKvkJmODB6in8cEWMY1mvWm7WyB6DAlD6xH+Rg6HK53MngthWwymtm2reMWB33QZ+3MQmwFaDvPeOwwZge6yxiUkqkEBh9YIwQ/ZoPP3rKi4tLfvrzX2s6iOaAEAUrYKyC+urg/K41ALbBLPNxkoEwNSCmZrSLUQOooWpnzHt9rPSMxNqXgcoZ0JeHU/qy9tMMzBEjJRWLfjNuOYLL2E9llOLymMzfSXvOtGZOYzaP0Rw0j2m8KlAz6VSp3kZM+k5uW6qTSQ7g7OyP1b5X5vZ030n2zFmprpiWefKqHHM9YwYZpvHPRJmd26dgBc1Bn/f0a3fPKigK8gyJeYucsisNxLpNtRoWo67hpXf9iEmpUZJGm1LoTH0hSEmmUrc7Zie4qQAOdbCq0iU1OU9+U+m4dWEOYCLGeIwJdK3BDyN+M7LeXNGvn7PoGo6OVjw8fcDp6SFNc8rBaoG1D4jBs1lf8vLFC/7p039gc3nG++89wxrhJz/5CT/5yd/yq88+o207Do+OGMcBYyw/+J0f8qMf/pDVaqWOZrcNps1B2sViUZzHMLHmhRAwMiZAZ943ouKxYiREr2Afo3tNfhD6q5kmDszm+wTkC0HXv5BTMlUBo7yHlTUeaNpWbZukkw2JZaFmrHI1aKCM28y6lp5dWsv8qMCbanupwFHbgRDtk9oumuZRjFPdc0rMei+8vLws/W2tpU3tcDueibKHjZydnXG5ueRgdUDbtAyj5+LigqvLSz784EMWiwVPHj2iaxq6bsHRwQFt25XnpM9FmdTGYUxrpGW5WOr9ogLHYoyql+Y5KVJ0TDEm0d+TvgsK6J70NW2kEKu5XCTbhKInXpXFIQUCJK+nGSgFPgGFYkyg4fRQxCogxjaOptIHFJQZ8FHHzzj6Lae/QGEXmtukkuwAYXq/tCjvH+R27reVstVT1r6kP44SGSK83Gy4XK+JQHd5QWMtrbXQR5wBWwXc6uDFPHA7jeOq3+uuzjqTVN+oda1aLSbubFKtx6cb7qzDvH7b729dtgXanet3NwUmbwJCaA3LRvFWZZ/uWsYKupdP7oEpdYhsd3K9xWzr4nueLanvdJplQOIEugdDSLZhZiuzwPnVJdZ7ZbT0nrZtyrzNuoBAAmhGLVEAEQaf2mZV//XjyMXFK7xPYHxa2ibZWaoEzUdJbm5WfK+PjTIm07yqAftZl7hxPF7vt/3vXT+gYYyhbRVw7pyjbduttV3vJWoz7RlTWWcr6wLXwW03gUz2Sfz/2HuzZkmS687v5+6x5Ha32rqru9A70ESTAAEQGBtKMxLHOG+UzDTPnK8goz6CvoE+hWSmlzGTXsY0JqNMojQcUqQ4XMAhBgTQa3V3bXfLNSLcXQ++hEdkZN5b1dUgh3ZPW/XNjIzw8PX4Wf5+Tm+NpftNeLbvaE5/G9K5dq2dfTRkS0mfC3ta/xDEddp/HRpq2756D7W9DxTp6BPuh71Wr/67Yxnhd+gKm1447sq5bg3IgT7sf++PM2xH1u7ft4+ed9yH5tHzPN+W0+X5W2V0/5c8iBefWyXDqW3XS8eU1m/XntLXM3c9f+V7hspNyriO7ePron02lb9rGpITrtNX/ciNIQqMtRaJSzPkZD1BozXzxQJjA6jRPZNJyWKxcKnodcN6vWa9XqOUoizLWL9Qx/l8jtbaHzL089o4nVoAm/UaJRUhDamU7mUylxiTcXRwm6LIWSzm1B6IUzWaxXLFwciQyfssVxsuFprT84az8wqwlOUYqTIa7YCqa4O3ZeBla5Aix/rUitanwQ32vNDDQqQgYidIKOlS0DtgeWIDMK28YK1FSdcndV3TaA3S2T2t8IdDd0V+vaHnphvAzA3d0A3d0A3dkCeLwBgnoITTfuCMyWkqgtRRFHIoK6MgN97Y4RDUq+WlF2ZqGl3R1BuscbkzpcgQIif3xu4hRbZvqHJO4+BgFgiRCrKuBR3jgQj2F+uRzjvIS3BdOXm3ISJ1ar0M6groQQtzL7FR4xW934LZM/we/gZHlEmuubJSe3H7bl+ydx7QEWZFYvgapv198ALGiJ3FvbhhY/g9YcCvU27rOLGJETL5ldYJ0fkhfg9Cf+jLftSKwSqmU7ljTAtRO/ph5V173Nr1ofBxTgaDC5sp4roWZOEERJ4hjHNmOqeAiI4G50OTqLxACBdNRWWZc9xLENKlMXL1wr8vREwyIJR3+gikgpC2wzk52rQPILzjK+RldyeC8ywHYWM4eBue9WU6oFA3Z3DqJJJyOwVaenq57eu+oZPovHWTMgAHwrtTfiX86XySd9MxggbwX3v6QQIaIQJgICjmrrz2M9455+phDEhhPdwIrBUImSFkFhVPZxhtUAKyTFHmGbPpiDwvI0AppCeQwgFftDZtJBFrUVlOMT7g9HzB2fmc+XxJXTcoapSoKPOCo8MDDg9mlGWOA1FUGNsghFN6tRZ88fk5y2XtwU2ZA0cZjbbuzKhAYYxESIuLjhRhW7hoFaLDn+JYBiN9RykWW586hkNvLBha80PGziFDVrhne75sG02td4rFdD8Jc/PD7MsR0fkgEscAwdHpPRlCaqwwfk9wIW3JnDEGazDCsKnXLJaXvP3W62zmX3L27DGr5SW3T46YliXVeu5yUVuDFMZHkGlBbakBPP2utY6RZKSUjMejZJ67Oa383HH7jHVpOLShXjuAVebBI0K48LnhRGIAk6SRpCABi/neE0J4cE7S59afpLXShRO22oMwfEQMH+HJ4lOjCPjGm/d59OyMjz/7lMZKrBl7sHC7F6aR6fqnfqODtBf9Je23fiSlvhHfdZzqlNEv27XL9+uOObjLkBfmnrSiU7f0931/AazR0XkV/wXzcNjXbDpeGmPbdTB4qtgIbyQM6zz0u5/PrtC47l1gMw9E6LaQfckF7NYnkXzz/Ds6F9zVjsQU9lWpkjnd7f8gWxprPO8VyMC/SfZv75AQ4f2hDGz7PtnKcgFwHoWxkKqOULYHFnWEJRHvd0BJxzsc39seB7edekckCoTbe4XC7R1SY6kQNLz7zgM++/hjlpcLsnyDrC84ns7ArkEbpqMRr75yl3JUMp1OkUKwXCx59OgRP/nJT/j00095/OgR6+WSv/mbv+H02TO00RR5gdaa1+7f58E3vsE3Hjzg5Pg47kOG9uRgWBvj8ZiDgwMAlstlZ54FWSLg6FvHk++nwJPaDuj2n5/K/dRw4Xe3pt0ebG3joq2ZbjS1MJdlcEwZNzdyv9aNNUg/jzKVRbCh2wPMVpVctR0fyPOMyWTk+bCOc9fYIFsorCWecHX80hnLAz/abDZorSmKIjHAu/ekoc43mw3z+ZzxeMzhoUuz9OjRI05OTmJo+ACmsdZS1zXL9Yr1pqYoNPP5WUwDVRSli6wiJbdv3eL2yYk36LvIEY0HXWeineNEuTYBMlkRtTKT8D4pHZrIGIuwBo816/CyEKOnswZ6ayLKerZd/wHsJr0RPqQstdbxpkZrqvWa2u9l2hjmiwVaa6YHMxcBUTjAusoyF+FRa5rGRXBBQGELMqkQFs8/+nUUHf2sBaG0slDKk3dR7I/kj/QxI4110Tg0ikZmNJmLqLbyUZCkBWVBZcpjsK92iLZ7Rl+3Tu6JDRXb156Lwrj12tqrz3A9g7g1sEf3nkv3+itr1JMZvi4aLDsImPFzd77vd8Nvt3n3fVFCxWsexBM2MvBYgZKK2hoaYxB5hqgdWHhdbWIKuVwpVHymBfAGcGeQFWK0Gc+vqsodBFAy6INubQZAqfUVjbUJsnrYF3eNTerIE2JrHK87T68aeycetDJaAMqEiIlD8httD+0kG1SI1qBzrTq/qL1n39rog2le1prog2ZSGbr/+9D3F6X++hiKHvpVyrwODQEuAiiir+X2d76+LtoXh3YBWYb6+GXYQV9kXL4a2An2rWAHIoK+lBD0dH9Xe/2F6rCts8V3X/Xsc5QbKOjLu+4ZvDbwrhcFQv1d0FcBHu2SB8K1IWANtIdlgu6itcEISyZyB+zAR51MUglJKSnzAjVzEllZllSbiqZ24PrJZELTNBGwHt5VFEV892KxYDIZY4wlV4pMZazrDXVdMZ+7Q1AhJbqUiuVyQV1XTKcT8iLDWBOje48KSZaVlOUdtDUs1vDFowU//dvPubg8BzFBKYkl8zqQiikCo3QaohcK2wHLRKk22BASPcfiU8hnKv5D4LIXYFx0mvCQdPZBbQXGyggSMjhZ+SWwpRvydAOYuaEbuqEbuqEbCmRToykxnGB6qrCjFFuHDpZCYHzkE3d4U1IZw6Jq2Cw31PWGqlqzXi18CGtJXowZTw6YTCbRmdxXyNJUEMI7JGwEi/gKe4rC63PI6bsE3mA43StwdR61Qxefk/qW0tS4abvXonI75DBq692asZKqJUpTn3addHge49p/epT24ZCJoW9+2FZqdxl/ugaNLvhr2yGz9XSnPsGoFoy7bmwswVBurTutaqx26UuUU3wkAistFuesyUtFXhaxDkopp8yQx7WntVN5VCYovNMipAnopAvw9XTXfG96cEd0+DYCVJu+QICPeiO8shdO0MqoaIY0MCpJByNk6iAOkQgCOKab8if0l6vPtlFpSAHuj6UQmW+H+yewSCVwPE7EeoSyg8HdRVZxFEBL7p5Q1/78SOeVSOrX9q9LvxXa75zNSgmUKnzapAwpHY/OlGU2gjI3ZJlmVAgOpiX3bs+YTkuyzEX9saZNhWeMc3jleebrLSlHY8azQ754/IxPP/ucx080q6UDHjaNZDzKeP21Y77x+n2m0xFGa5brJZv1xs1DLbA2I28aTs9WIBRCuRR9lamoTeMM30KyXjcILCrzoCtrnGHBG/2tkAgR0jaF094CrEBSOD4Xebcfe4E3kodT5kQHvLtx22g7ZGjt/76LguPcVSWZXxaw2p+wxRutBdq2zgY3xs6ZK7AO+JbhUhfaNpJBTNgVnPy+f6QHU1VVzc8/+oyPP/mUf/KbP+L1Vw6YHt5jOjsmVyBVwWZVsT67ZLXaIFTG7Vu3Xal+/oYUEymoLKTsqqqKqqrIsozZbBrvD1HgAqAlGP3DHl7XNXk2YjQaMRIiplCpffjhsG77IIsISjHGRULyckg4kR/kBmO6ckN7qlq41EDCgBBkUmGFZDIbM5uOyBRUmw3WbtDGp7/ya3lX6qN2fdrOXEn/pWCZFADTTyFm6AKTQv1Tx7W1diuVTuyXZP72DfhpXYeAK0NOwa3vdMvZdZI0/BVSoAZksn6d0z4L4+iM9jKu05S6fBLavbkPGB5o49B1V6jbYdM6JvN9C4gR6h3aHNptDLppYjQZKSUyy9z6TBxUQ3UZ4jGOI2yPaahXuJ6mVIz9Y7sAZ89ukvL7fShQInd7nY+ikWcaKQVKOUBdWQi++8E3yOwF8wvFuMwR+pjZdMIXX3xOJgVlrjg+OqLIc/K8QCrJeDTm6PCQTGV8+umnPPzsU86ePePk+Jg7t2970N2YBw8e8L3vfY9vfvObHBwcRJ4CjtvVdU1VVQghmEwmHB0dMR6PWSwWzOdzhBBbkZv6PHwrFdgOZ4G1bPGfQEPAtsZH6mvT7GynyKo3VeSDTh6TFKMi1k8In/pQCJ9mrut0dKdUK7JcMR6XHBzMOD09dSCZRhPkL5eSboQxxqU88REG8zyLfaqUiqlLuukku/JT4BmbzYbJZMJkMmG5XPLs2TMmk0lse57nZFkW0xaV5YjRZEpRFCwWS8qy5M6dO64eKnNrx8/bwKO1dvtKqEOWpC0KFMY/5cNpH8V+lG06p9Celtf29DnbleqDTGFtu769igvWUpsa3TTUTYNMQEKbasNyuXR1lJKqrnny+DG10dy7d4/Z1PXHdDajzCUik1TWsq4b5vM5xhjKsmQ6mTAuRjjQsIz7z5aTPuW3Ce9KdYo+/+/O8fR56UEDGdpYqrqhMQIhC4rSAdeLbORiT1mJxDlhpGSr//ftJS9OfbfvftqrToUSB+tlCdGXrqp3n2fv2n93lXWdOr4IDTu4v553XU1hLSXzQEBdVSyrDdIf1EAbTJZjZUaZ5yipfIRiE/dmoUA4vGDc56z1aRuMwXj5czoa+fS+HjSZWC1afWG3bD/YCq+X7hrPl2X3SPmXUoqp5xn9PeU6dR4qe+hdsGt+7jvA0wWGh/v39cOusva1Y9/7d9V76NlfttP+OvNhaDyu++y+cvq/7Wu5Te4L+mXQW/tl77eRfj10lZ79PM98lXp+HWUOldXf079K+bvG56qVsNMeFurovwcZ6zpr65fRf9eh4b1xdx2GdOGryuzLokDHTlHXDUVRxINC1toYKXO5XKKUiin3jg6PWK/XrFYrtNbRRxLk5NQeM5vNEEKwXCxYrVaMRiMvA7f6TNNolstVjBQZIggH+XO5WnF0fAyoGLk3zzMKoVDSMJ6NMSJnPDnn4vwZi/kpldYYMcL6AzkhzWhr53YAdgChWn2627ftAUjXz4aQDjstT/tUUu6vB3BLiTukt4IQ8dGdrsGpjzamUr2hr043gJkbuqEbuqEbuiFPQRAOglUw2hnThhEHoqFUCOFRxZamqTFaO4efcKclD2eHzCYzjNHUTc1yfkld1c7QAUhvbIVuLvPUAA6pUt53nATyGt8O2mUEuMqwJfvH/frPe6trW86u+rX1GCYfwn/wITv801ZR3Xd3HIfeCxWcPv3UJ/36Pa9h6JelGL1sA0gAHyBCmMjWsBZPf3vfmCQ12JvBORXmbP+EcjRK9NrSNz717kAIFX9rDWfBuSw9IKNdMw4wkWFw+eGjIiOcQ75jCAnRF5REqdy3MxjuMg+kMPGERAS0ERzBoI2mqjZIKaKjI6R5KksZnR5No33ahfYktTuVkMc2hbpmWep8smjdUDfBOdymJuortW1/ps4DSdOY1gky1Mu9cQiOM5fmJXFKC4FunCtT68Yro0EJhLqpnaFXtGOVggnCGPYdz+F0SVqPAB4Icyd93qXO0IBhOimx1tLUNdauKTLJpMz5z/7Rr/H6/ROE3bDZXCBNw2RcukgVwkWdkT5ygpTSnfRcrxiPx67P6pp1VaFXT3j3wRFvvjql2rwBCEajMY+/fOQMu5Mxo7JwIC0MeqbYVJLT01M+/ewhk8kh778zJcuOMEKyWC2xWMYHJ9Sm5nKxZLGs+OTjRygxYVIckKmS9abm8dOnaO3AUzLLkZkC6+rq0kG50LEqc0CVAKwwxkUXyZQDgIX0KNHw7dfz0LoLY9N3WIa+37XmAxmdpGcIjkdrscY5oYXKkSrDStcWsEgsmRRMS8VmtcQ0tUsxJjLW2hlasiwnz1x6LDduwqfLcXzC7dOgipIsLzFNxf/9R3/BbKI4mJRgG85Pn3Ln1jG//mu/ysXFBZ989DEHBwf88DdK8lxQlkVMkdR3oArhwG15noN3PPad1H3nXjAWNY0zFNV17VKp+RNOSilWq9aIk4JyIQHuGtumX/OGlNSZmKaOWq1WMVWUUhl5VoDVaNOAteR5Rq01lxfnrJaX6GbNellRTkfk2RiEBLpGnaFUkf2xD21NefUQX0n5DULQJPOl34/9/k+/OwNcHd+tlIp5zfvO1fSZtH7pHB2ay9YatJVRZgh93ZfJ0n+t+LHtsE2dQv33Pb+ROI2msN+pmvbd9l7apX77Ai+WwoNC6YIKwt8AGgjjF6LNpC26ynHUOhYdgCKdf2GttYZEN9/THPYgfWq7dlz6p56FjyYW9kMHXJ+4NGdNg2k25FmDrecIvebu3RkffPAuzeoJv/nDbzs5QWsyBE+fPOGdN9/i8OiQk5MTxqNxG73Owmaz4fTslNdfvc87b73FyfExx8dHFEXRAdilc6LvkNP+FGYL/sg5ODhgPp9zeXkZgRShrMDf+w6f6zjRWnnP7uw/aPf01Jk5FJGm73wKz4U2BkBhOifTKHRSStbrNaenp5yfn3PvlbsczGY8fPiQqqrQ2ngjsqHISxaLBUrNMcbNx9u3b0eQjjGGPM+ZzWbxRGq6TwUjfJ7nFEUR+/7VV19lOp2SZRllWfLBBx+QZVnkdy6yg2vPdDpF5RkXl3PyPOcbDx64Mv2zutGYxoNzkr5pZUwdT9D2ecFyuYw6Z+jb8Dkd4yFe2kZFtWjbggDjO/x8CbKcscERb0AKtDVUdcXl5SVnp6cIITk+PmaxmPP0yROMNhR5jpQulP5yuaQoCh688QbWWlbLFQJBrjKWHkSkhKTIcqw2fPH55xwdHVFmOaIcuWxoSm61bXDO9toKxHmZ8v50HgrhoguILAMfWQZj0cZQ68YDtBqsgNG4YDoaM5EZufDAXGE6usTQnO/L5vuoP2b939I+SNMzd/lauG+/07e/17V916ZEvopPp3Xu12FIJ/ll0BDYuH+m6Pn22uFxuIqCzUGk77b+0IFtnBPPGFY+UuGkKDmYTMlVRnjo4vLSA/qcXDiZTNzJcYEHcir0fOP0LePSTeZZRpmXnfb7miQtsgnoZrhd27JQeK+M868vy231nN3uv/R9Q3M88NeiKGPqpaE69Z/rf961jvbVd7v+V9i8enLddeh510HKz4bW7hDP2UdDQO+vSvvmzi7ad89wH9luOrFryDJODr/qiFt/P8DZBwee6vP0IR73svnc8+kCL/7MVeW9zDJ3l9W373QpyIXQ7euhvSyl6+obu/S/5IGYlnaoPVfJJn/X9KL12LXOhvhQKmf2ZYPUZxLk7BBBLMjZR0dHsZ5pCufpdArBRhkAACAASURBVBpBNOv1Ov6t65rJZBLLEEIwGo9RXiZO5fMgG9y6dYssy1z6pPWaxWKBtZbJZEKW5zx69ISDw0NGhQPBSJExGueUZY6h4dmzx1yenfP6q4esl3MePdWsaoMqRgihGI/HEaTj+sHZX621WNON6h3ap43GGB37L9jjnf7jdAMHRq+9XQqUzJP+DvZkoh/GWjDB5nrdHGk3dCXdAGZu6IZu6IZu6IY8Oee5igp8cJ4FQS6lEDJeKokVFiVzpFE+9ZEFq0AbhLUI40IAkleABGOQySmiVBFLlYNtJ0cQgIJRJhgGu3lAr0tDRj/fOqw1GNtsP4MDG4D3PIhUgFbRIds3/u8nw3bKgVCV1BHVreNAzcC2qXmIRiPfX8I+fyf9A6YQFj46S3ARNNLpIKXwdgsfAeIFDQRO6WwN+30nS1AoWuO/O/lpvdHR1Q+wBpAu37vFgwrcum10DdZFksjzkhDisj01DHnuosFYLNpYZ3jUG4qidCeERyF1T2t0D86ZkCIkGKYb7Rwc7hSza6cD2skY7tpFMjFkWe7LFCjlZqY7rSqjs0JIQZZJwGCs9nPf4LEdngwhd3scB9sCnKSSvs6NV94UAWTjbh0+PdI1OAtcqqBuFIeQ7skpgiaCKZwDHDKlorPjuor6NrBq26ncdYpYRnnOq3cO+K1/9o+ZHRScnj3mYn7GbFYiMOSioWqeIa1EoMjyEZV2ICCERWmBtRptXBQX60/YbqwGq73xrEAIqNf+5LcskFKhKLh7ci+CmwSGRldkSiKKMUVeolTOaHLIw4df8qd/8qdk+ZjXXnsNBDTNGmmnlOOcg6xGyjUfvHXLc6mGPHfh2//98gs2VY2xMJ0d8cZb38RaqJqG1XrD2dlT5o8e82yjGE9nTMYT8rJw1fc5m7HSp7uQLqqR8fxQWox3TPbHKsuyCDAMY5sal4ZSeaUO1jgPvQHA2hbIg7EIrRF+3mdSoIShFJZvP3jAK7ffpswVWS4ZTaecXlywWK1ZzJc8O7vgi8enrFYLEA4802gwVlHVFiUzEGBMhjESa3Mqk3NZZS4XtpA8WZb827/4EqM11WbGo7nm4b/+P3nw6oxvvvc2b7zxBpPJBN24tEbBQdCnsP6DccfxgBxrbSdtUwTVWutTU4joIFitVtFpDHgwTtunAXhgpefTyRoJjrN0j3UOY3dKy6VlUTR1TV1XjEYFZVlQ1ZUDKCl4/1vvcu+V1zi/rPjj/+8nLFYNOgIhumWHtd+2X8QxBgb7qe/sS+eStTb4kjpyT5hD4d6hPSLIYanjO/RfCq5J52af96VO8n5aqUDGQJ44pXcZWLtG9BRo2gI+Uhmu/0zf8Xg9up7Tpg/AaknEMlJKDZ+hblmWuTg2Yax694f3pOMFOOe8NfH+XfMhUHTGGYMlhMZ2IJcsC0CXtk+llEwmE9cW66O2Cde2tL9DGsVBUJeUWBoaU2FNQ5nDj37wa9w6LijyhvFIcPv2AUL41IFW8vDRY/6v3/99PvzoQ6RwUWK++93v8ru/+7vkReEjiFgm4zHTyST2ocravinLMp6ybAENpjPHgrHU+OfDfK+qisViwXq9HpaxLXvTr/b7P46hdxyl4Iu0v/rA1z6AI1wP3/t7eeB7QVYLazUAgsLamE6n8feydCmunHE8Y7laenByjhDGyyGgZMZ4PCacJg3Ru9w8EbGe6/U61iXULxjd++t6PB7HewOQJfCecG/g2dbLX3mWczCbAS4yUFmWSKXYbCr8xE3mZQB4ZIxGbR/1nQ19J90uftyXydP7rA0p+iTaaLSfH1IIn8rJ3VNtKjaVi5CXZS5E/cVq7oCdmeL1t94gEwoBHB4dcv/+fUyjuby4QAiXOm80GnF0eIS2rsyLy0tWqxWb1Yosz51YYQyZlNw+ucWto2OEFIxGI4q8wEjd4UH72hja149INuRU235OY6gdAB6JESCVYTItEKWL4JEpsLrygbxc2keswdAFuaX9/bzUH9+2rLYN/UM14Xp/nV61hYQ+Tdfyy3b2/l3QUAQt158icSRtg5pfHomoU1oPqA5AW+PHT/uIlqPxGFnX1FWFNcZF4MosWZ5hgYODQ4TwTjOlMNZQNTVSONnc4tKbiczxnpRfi06Nts0mO13WvXXTzqsur3Hy/Iv3Uqrfh72vLEtGo7HjlQOg/OeXjb46DfXFdfXZG/pPgHpybCsO7+YLwzz6Hwb/vKFtIEgcVxHSy96s/X3U173D4ZVwoG7I1tTXXdLoPQ6A4nSg+XweIzuGsgMIHtq0teH3fgReIUTUCQBOTk5iPVerFU+ePuXJ0ydcXJxzdHjCaDQmVwpdrdlslmirOT9dcP70ksWi5tmjU6pqBDLHCtOmMraWEPVV0PqIhAClnC2uO41aADsEec61Z71eU1VrX/+wJ6nEt+HFUSxKKjdPvcyTZYXXm3Nu6OXQDWDmhm7ohm7ohm7Ik5KKPBhGrcX43PJCSp9bOgh8xgMIrBOWghDo/zkB22CNdvdqjdYVFo2xDdqfDpJCbp12Ds6A1JDe0jUMFi8JVSwIUQBiwe0n070m4mfpcTQDJ8rZc4oEGYXG8PburUONHirLOXpbY0+4x2KjB9gX16+LSK75e1pF6UX6NG1P71V7i9vz4y5Q0VchIZBeyHdzWnvbQTAKB0eKc1q5bnJ90m2HQGY+IkzAjPlfrPXTMjhl/DXtT8jhHbwyLxLDn8DE06bCOaKMwfo8rVmRO8CMMXFIlSxdHSMQyEVDAeUdNTKG6Xfp1ty8q+oNeZFRFA69X1VrFAqpFFKAUJDluQcU+RPVwhnQrXGpOIy2GA0qy8hURmfu2RbUhpAI6U7Eh8hKIsxZkcw3C9YKrJUIYX1rjJ/fMoJkbNLJFleP2Oc2ODS7zs3UCJ+CI9ywhy/uJK0x2vWxEPG9CF+mP00fV1fiNA1OsKC0dqdcaoyUoZuIGLxQB98XgtbBKYQDfFws1/zJn/wZzx59xMXZQw4PCr7z3Q944803wZ+8QAiEzHzKLevwcsaBiaSU5DL3gBIX9Sec7raANdoDK2rffy7aROMnd2MM1kcU21QVygMkjJUoVTKdZNy9Y/n+9100m9lsRl7kGN0wnpRkmYuQsDpaMxlPEQK+/PJLPvvsU5bLJe+9/cCPreDo5IR33nkXYyxVXbNarZ1CXb9N1QhUlpP5kO7C7ylZUVKUI5QqWW0M//GnH/PZZ5dczmsaY5GZxErt2xkyI0uEUW4tWoEDZ1VY2/gFbbE6pLfwqcn8PuiGq8FYN2JSSJxun2FQLgVTAxY3jlK5NIaN1VSm5pPPn3BxeYkUmnGpeP21W9x/5QghxmhTUtUHnM+POb9csFpVNFqQ5WOKYsazp2c8eXrOxcWKTWURmaRuHEBns25chChTsKoEy2rjTi36ufBkueZ0vuLLZ2te+/gxD+7f4e03XnX7twAh3ZjmeQbGYuoGYw0qUxjhTvc0TT8tkkSpsBbaNETWujC5um4QQJG5lI8BqBhARkabGIkggP6s9H9RbeqrsG6sMzBZa13IY12jlEULSzEaIZSk0dZH7jAIoZlOFEV5xNGJ5A//+McuAoIV7PG1b53eD3t76qxM1/gQeGWbD4jI/6xf8+FEdTAgxWet4zNS9SPheJCncB0SeVpIgRf3YukdNYKQqg5C2rnu6S8pnQwk6AI1SL6nbXJj2wU9YN1eFEMjB97igbvW884tA364HsY3AlpjZ7pvYhj4EuvjMnFFnmBtm+LM2u3oQamRs3Xaa/+6INe6k+rIcIa95dVWCicPC7c3iIEUO+n7hh1jAqzCWuX5RxuRCGzkVc7RrRJ52IGuReA74NP1OQBiWDBOlpcu3aHUvHLvgLu3jzg8mDAd57z3zn1GpUDQoJRlVORk0hlojYZcSv6L3/ov+cH8N2JkqFu3biGUi5gVwG0S6aKC0c7jOON6Tv0hWTk4V43WqCxjNBpRliXn5+cxVHnqAO7I1iKdLd33CC9buPd5Xh2i9ggZn+uuB0PTOGPzer3GGEOWHcXy+07/obXeT/EWIqqEtgaASaoLAfGaEEG2UXFMhVAe4O0ijwnhwchJ34Y10O/3OGt6azqtb0pXOkwtKCkYBRCNlCjAao3VplUtQvdbv36FjRGZtlQSv06DrEpwxgv8HA+Ssq9Av0oJz3RgHRfxLWpHwp2eRkqQXgZSCqXcvqWNZjqeUBQO+FOWY8cPjUF5EHZTN0wP3VpTSpLJzMX/syCV4uDApR1Wsk2zhMVF1SgcIN/6vnMAttigLjivcyX0leOt69UKYy0nJycdkPe2/tyOldtB3LuDJKykosRitcEITaFySqUQwrgHhHB8JxnLtnbp3pf0P911bePaE/FeF7rfRNlXiLRMMfC+pCF7v/d+TfbttA67n+3OyW492ja7aTas77bvCBrZ89N1n+qA3uJCS3XPPo/c8aKBF4bIMUFOCXyq1Z/awyfW0u75QmD9hiT9c5kUyCIjQ4AxVPWKxaomLwpOjo9RKmsdfUaAavdxa4VL0yTa+rg62SS5std3BlqRVCvpL9GZy+11m4zt9SjwMki62LbfsyxnVLrDKVnm5Q2lUH7t96N8iLBnxbJiLZ1+K1o9N61m+rk/369jRmnrHmFQiT2od29vYfbvuc4z/d86cmRbEruGIsipYT66714339devzb69HUBBPb1xZZ+sGXLFJFHDi/g8I74qb0mkm/Bljvw4C6dZQgss6v+u/quI+8OViDdO8IN/XYm10S7XmxqcOsUGG/slvI1j+9VgKJ4HyEiZZeEF3ScqpGu//AcUScJssxXoVQ27dfb6TzdOqS6WLRZ7pjHz0Nfz6gM04v02FA/i0Q3jHJX00SwqA1jKYKugJfZw7XwLNGupJSkrmokgtlkisqUk9mkAn/40hrjvgufQqkoOD0/x5hwmAmaxjCZjMmynLqufIQazWQy9oc0BNPpjCwrmE6m0ffjDhYpKiFpNjVFNuHkKCPPN7z7zojHpxWnc82qcjuvsy4InDQpejw3HFRL+HoUTto04+AjQeomRp5pD10J94bIIPy8xNuWRcv3hbROZv2lzqZ/2HQDmLmhG7qhG7qhG/KUZxllURLSvDTeaKEEBORwODXvTSMYbZDWCUguNYYPu41F64pGN2jtTnovFxfeEOLSwIS0GdANPZkattLUMIH6hrhgWH15FBTSNg1OR/iKxjHbkbpbA373NNx+ZSa8J7VWXUeU36M0220FMf7kKrS7SIiGGP/lGnV5XtrTvh11u8oo8+L1aCMXCVzan/C++F8aUYh23qV1i45GIWPz4py1ACHqivvRWBmHXAqBFQqXCql1bmWqCxzTWpOJNkKNdV6/rboIbwRyjlF3qjWmNMkUo3IUT/8aYyjqDSqT8VRt0xDbHE7CZZnyERi8socDyFijvTXGqUBN4/rAgW0k4QSBoJtOxfnDdXSFhv4zJhhBWiOjW1NBwUodN62ibr0T3SS/BXL3t+lP/CPh107ftc94EIUIhleLUqK3HPrv2DYs9U+R9H+LLKRvFImGUe9b8o5OEDS64dnZnMdffMrZow+5dSB4cPsBIyEYSYmVOY0VPkWHr7tnMca4vlJCkCnhHVFgrXO0WnzKLDcq0QAuhAeU6XZOW88ftXEAypZDO4Dl8dExt05uxashCkk4bdM0DQdNQ1mWrpzGsF5tGJUL3nvvvTj3x+MxJ0eHMZ2HS0nh0mIIqeP6wrZ7SDkdk5cFBsXlouKLhzVfyjmYCqtxUZOaFUReLbFWgh3F8O7G1JhmzmSS8eortzk+nDEtXbQShEt1ZoxlU9Usl0uWixXrTcVytaGpNWVZUpZj5quK1apivalZrzeOvxrHY41taKo1v/jkGa/fv8utkwMmRQ7CMMqtW5cqQ2Vj7t2dslyvWS7XGG3JspKinHLxSsnp6ZjPPz9jsag5PDqhqhuenV1yuVxT1Za6cSkXVpsaiwMZIcFmMzYWThcS9WTBqCx4cP8EpZwJxOLSXzkHvSU4bAXtaaGQbiSNphCcEOHws7X+ZLdfv0VeRJ7UOrPdjJfOE+IXhkRIUH6uymjsdXNRa0vIld3KChqVKfIyY1yM0XVDU1fkWYYQGi2si2SlFMuqYb5c0WgfGUsMGzv7htBda31ojQ85pYXwEXSirDNkUG7TybX9gzdS+kWY8q9Ydq8NiS05HZtASnUd5w6s5I1yvs791FBDIAFhk7Z6xubmenutNYi39d7qH9H9HMsP7/Zbseu3bvqSeG9ikW9flQKQGHg2PVnu92nj9oJQ/2joS8bbBsO1aKOUxHvY3gfS7y0wx0SArjECKVRSl2R7kCnIJ52vLipU4GWC9OS9QGBQFpR08oYUhtlU8cG7t3nnndc4Pj4kzyVHhyO0rjFGOwOtUGTS8W1rLJPJmHuv3otRVsL8bpoG7fPPR5lededLkFvSa2n/9w32hVJorcnznMlkwmg04smTJ50IU4H6jvC+06gzduHZ4HyyDuAj4rwyW3M8Tb/k5kWQJ0zkP+n49tuYtq8fdSlcG9J10hR5QkicbdjVVSJchsZeH3QjTmw7fcN9QwCalPrPXHW/A/L05GKto3OsfbZ19EThYkDvcW1xURHD93h9oB5bOkGPZ4Lvrs6z7TNSQJFn0TmkjPCneP17rQOoyBCVRRuqukZIhVASY2GjNbU1LiIGLo3YaDSK73d8kggkjWPhebmQYmtdxPtapcz3p/scHFbXcpr5PhHWPWOs58t+3y2EApVhhaRQitxHt0KAkHggcUspIKR9RX+vTHXVIQCh2yfaS93fWh54jTHf2/TtPXwfpbdtPzLsTN5d/lfTV/tPd+bIrneL8Fy3Pjtr4vtaECIzubuDc8/GAr2ulny21s3doIMZ78zC6xR1U1PVlYt8ZQ15lpEXBY2pmS/OWSyWHBwcMhoVjEeTCACUUrVyiOchVgiE3Ja5bOfT9hika8kkyOg0WmgKlu2n2Rsqq999MhzmSOZaiCoWIqWNRqOYaqMfWW27zB1zNZFpOpdtuNad6/EvkJz42tkWenVyGvTzRyfaB7jYVVZ/39lFW/K2j27dHjmit+8MvEt81ZX5cqjfTyLqP2JrrMOWuatrnMjfXQ2pjJpOmY61JJpYtuX755ET+p+7cnkQ6IdWaFsHkbSz+67kWu/zzvrt/uml0z475bAdaLsftvTAXln7wEvPU8++zBz+Duq9vUqL5Pdryx7XoF/WWG1LLf57MlevS0OysduvWvkzrMFWtneHASEcagSlXMprl+be7SOZUshgNxO9/ci4d6T7yrPTM5brlQeZqxhV8tYtl267qmrm8zllWeKisGSMGDOZzBiPRlTVBoFFSRdZcrWuWG8almvDxVxzerFGiBKDizYYQMDSdV7aK+3eFbZja6MoGL62Onnb70G3DKB9N1dbGTJdB2mfhrkbI76qlzMnb+gGMHNDN3RDN3RDNxQpz/N4ojGcqAQnmKT5m52RnmjIsNYBZ+qmpmkqtGmQwjl263rjrumGxXJOphST6ZTxeEImCzabast5EoSgroGjmw5nl2H6l0HRsI6NJzx3KRzXIRuOJafXrmpOIkD2apfaS3qPxHNCA7/1UeGhOBHDKz8fPX8/tM/t+GWPMvPc7/IOM2tTR4pA+egoQninmkycPIlxq++YSB0d6encNr+8A8SEehojojEnRg8JqZYQ3kmcAkzasOTKO5JSRSFENQn3hFP1bQhLV2+nXJW+nWCNRliF1RIrMuc0yMBFV2miM1xYB3BQmaIocpSExtZUdo20LrTn5WKO1oaiKDk4PObg8IiiGNFYqCrtHPTCYo1BG+3rqMAKD7ZrHKhIhDG1+LAocU5Y26akSMe8H6kqjKcL7y2iQhYG3xlkA+9o13RwtoUi0pPh7v3b+Yn7vwfja/gb39o3QlobFc00WkEwNAshUEo5oEjjYrvoRtPUG+pqjTSad95+i3/0vff4/nfeIyslQuVsNNS1RWsLxkWLyGTfEGIAQ9O4qD2OX+uO0z3LM5TorrvUkBy+Z1mqTrV8OZwOCX2UOt/DmIWUEAC3b9/m9u3bW/1prWW9XscUPsHQ3DQ1UlRubYkC3RiX/sGC0YY5l2zqisVqjdmcMhutyU4sRluqzZrlZoUsMorRCJVlVLXlcr5AijVCCGYTyd3bM05OZvz6d97nnTde5d7tQ27dOqKpnUGgMZbFcs3jJ0959uyM+XzFk6ennF/OkVKhVM5Pf/Zzvlg/xlQLNssl4+kBt45u+/QbOfVG8MVnX/LGa2/x/rfe5vbJEWUmEabCGE3TeD6iBKO8pDwsEn5T8crtMa+9csSrdw5YLGvu33+Npm74xUef8Oz0jPWmZlM1VI3lyydnrGsLQlPVDcXBhMl4xKQQjErAA9tGoxyDRVvh+BbOGZDlLjWKFgZDN2VZSikYIJ3zQrhTQ2nY4HA9/O06LQQqEx4wo1Aqa9suBMY6AFVV1T5FDZ5JaISBTECWKRQ+ohaStW7IsoK6ETx+dsq6Nv6Ub4bERr7Qb1c/XWQ/jdIu2mdEHQIN9I3V/TKe1/kQIo6lz6ZAJWj3rNCe4NhNjYFDhqr+7/11u09OS+dEX94b2us7/Z44XlMHF3TBPWmELxlBoBoQW3uA+xf4v+ntJcMOhD5PHGpDmqqpP2YR+ErYt1U8edinsB+EstNIjNZIH+3NnUCUUiGV2/8wmkwK7GaB0BVFrjg6mPLGGyd86717vP7aMVme0zQ1uQJhHYA37EmufsLPI9cXQogYBSCdP0NOxqg7bLXoakeMEIKyLJlMJjECWtpvQzxmiIbk8nSO9sH6aXnp+MUobPG57fWRvrPP30JfBD4Yngspp4b4Zfqv385+f2/XZQDY1luraX37ffM81MoOicPnivHd973PD4d43S5+ubOOybPG663W2njq3sliTlqWUjpgiQeXYC3G6wxYl6pUNy6FpbGtQ1Kp3DkSvFfA2gTsZ0MUBCdwpvUPl/t13TVvA43GI0BQVZW/t5X3h3iv54KEKBzCWr/vuUg7ykeTFMIBrX1wGRftQuzf64bqG97fr0//t+3v23vjrmf6774OT+ivsV20qz27yt61f6XlDa21fXu4sQORtDz100G0e0o7D/rl99eMEMJHsHS2AJdB1Kf7st1oLZEHe55vtIvCibWoLPOAGYPWhlrXGG1YbdasNxtnV7IwGY8R1rBZLTk/P2e5XKFUkAsFs+lBBM3si9KZfr7u+u+PnTGGqqoIKS/zPI9AzRQEvmtPbtdvIvN620FwZhZFQVmWMS2ftTbun1fZLnb9LqK7crs+fd4R/8LelIWBtvpSDPPnq2hor7lqvK67f3T6ztruubOhe3YWFIr4+u2IzzvWQ3sdXD3XRdImINq4rHAmFXbUY0gmep49fF9bwv3tTBwuY59Os0uX2sk7vb3zax7WSLv2n758uHNND7R9aK+8qt3PU9dddd/3vqvG6OteRy+TrjPPAg2tvyH5OtUZhHAgT2ttTEUb+FJd1zHlqbUupfXFxYXbL4oy6nv9yNipvh7eF1Jhh/0y3PPo0SMHjBmNYh3quubw8NC/f0HT1Kw2DqwTMgOs1xVPz86pGnjydMmnn5/x5NklRTmjMRKLSPRepzv73sPZXhUpdtVvkfGWfhdb6w7vWGvJMhOju6Zlp/wp9HnfDhvs5vlNSqaXRjeAmRu6oRu6oRu6oUiiI5BJFYQ0Fz68qipc3mVn3G10TVWvqVYL1qsVm6qKAmFw9FprqWvnOD45vkueZ2SZO5mqG/eu4PxP350aSlKHREfoomuA/irKw3P3lACjLY1unPFbZchs94mkfcq48KkTrksuAkw/2kWnxO1nSJRHYdmyLLiKDJf2osrPC6THuu4QenvzC5OQFikN2qcdCwK+VDlaG6zxIBeRIcmcE0sJtK6omw3WWndylBYsE5xI1joQTiazqOQolYEIp6tbY5dzqgdgjDuF5hSd9qRBWEvBwaKUIi9yn2LExvXTGhW7Rr6g0AjRnmDWjUt1UBYljViSZxqlNNVmxeL8GUXhHHdGN2w2KzabJVIpTm4d8/qrb/Lg1XtIvaZZnjO/vODP//I/8NO//QtW6xWNhfe//au88+BHvPPuq0iV88knn/PFF49YbcBQYlDk2cjPEYkxoHUAIdn4z1qnvEF7eiCcbA99G/gNtLykVSQtWvsVIdITCD4VgJTxOa1r/5wDOgwZtoNRNf3elplGu2qdaeHePg8QWPLMGbVdqg03ZlmSLuv4aMq7773LRx9+xOXlJStdYU2FwDAuC2ZTFxFsvVkxEjmGhnw8oygyFwFIG6QQCGGQSsY5tF6vPa929Q+G3NDPsU2WCMaq6zrO793GtNZIH68MGH/6Bv60j1zKiyxGLgCXmqKqKjabDXVdRwdTbRpULpC2wdYSqxVFnmPqCiFqSqEpxoIf/tpbZPkIKRS20dA0qCKjwWCEgqxgtTH877//b/n5z35BVW349R99l//uv/2XGL3mcDahDKfNbYPNLNpYrITJoeJkdgf57qsoqTDW8vTsjB//zd/wtz/5D/z4//1f+cs//wsWyw2j8QG/8Rs/4p/98+/z/q98m9GopN6s+eM//H949ZUDbo9rCnuJMDmNVf6cjgArQQuEDefbQSjn52t0w3q+YDorOLozQak12iz45nsnSE4QCPK85Oj4Nh9/+iX/8Wcf8rOff8TDL54wPThmuXzMhx99xurilAev3uMHH7wJJsfZ/SW1UIBGolFSx1RTaDrjNuTcDesi5NtOr6VrNazBdE0LIUAopG15WtM0cc0VRe5kCQT37r3Cer1msViwWq24OFtRVRvu3bnLndt3OTo8QOuaTV0hUTTWcnGx4KOPH1KOptRNhjYWKfDOwy7gJ6bToLuXXwWW6a+B1HkQovKk79oFDO5f69NVDrchx4pAOADjEG8S3SgOQyeh+6mo0rEb4ntpf/bBNrsijwQekPa/EAJhJMTiLgAAIABJREFU3Amy1CFgk0hDIdVJ6rBpx0p0IneEiIopX3fPhEgQlhBZMUSbScdjl5E7BcPEPk2iiASHWQoQc5HQsq0oJKkjL66B4OS3AkmGUBKVFy66m5LIzCJk40J324pPP/wx1fKUd95+wI++/1t89zu/xtHhgY9EZxCiwDYSdOZPjYbiW3nRm0IHgTHhWpBnnOxfd9InBad+plTce9P53x97ay2TyYTpdMqTJ0+2+vQ6BtQh3aDvFEr1jz74Kegi23N5u+799druq13HdjrmQ3wlnbO79Yb087aToq3TdlqePi8Zqkuf9tVlH+3TfewVgnxn/Kxf5wk/6/OZnTrgtlji+m/bL9yW3dYyymYpj8MYRlnepmEL80VbLMaBDoSJEdM6vMoCvbkrBBG4E+YX9HkphAhIDjgoYkO29eChSC6uTCEgvs6661b4CDfJQRiffTYcDO5EP9pH+5xxaR/29890zQ2t613rOdBQNLf+mkrfdVV5/bLSNly37ckPnahyKe1bW6lc0Afwp+3qz88Qaay/+4c9NY3UmOc5MqTH9HwLoKoqFosFy+Wyc4DDgapH8SS4bhrm8znHx8cIKdF1w2qzYr5Ycnr6DG0Nk+mU0WgUo5HVTUNVu6iLl5eX5HnB3bt3mYwnnufqDiDx2v28g1I9PX02AFqCThTa/iL2JDeGTjZRSjGZTDg5OUl+G7r/xcjJcNuWnEHZ0f3geYCXadxNvYcHC9y6eN2+2bW2XqTdQ/M+8inYmXppH88K0Qo7siXEiBB/HyjlUa5OYR/YxS+6qetjv8V/Q8/YOBf6us2QbPEyaEiOu4oXPz8NTei/P+TECLPV5t0yn9j63NdV9z2/ux5fP1js7ys9T9t3zc0+X0oBnlIp8rxAG2ffCMCWoii4vLz0B6eUSyfdNGw2zr6cSUU5nlAUBUopnjx5wnw+R0rJ4aGLuKwyp8deXl5SVRXleMzs4CDqjGD5d//uj/jxj3/MaDRiPHaRZh4/fowQgtFoRJZlXMzn5FajdcO///M/48OPPuTdd96nHE1YbSyPTxeczRvIjrBy6vdIjbUNzkbbHjrxgnpQ79z89IdATIzeOdyHLc8xETDblwWHbAwpRVvBL88d9A+exJ/+6Z/aH/zgB3/X9bihG7qhG7qhfyC02Wz4wz/8Q958882oKPfp9PSUjz76iN/8zd+M6Sj+PtB//z/8a/7ozz50LroktPYQcKVpauq6BquxTUNT1zR1HRHT1lpUplBSgXApMKz1IQZDfk3vMAtCUTDkBGNhCHcuvDHSWAdQCYJniLRhrUVIGY1RrXPFOVGyPYLTCykZPrqL9YJhgEsnGXeufFdK+411EBTkfhnPr1j2TyT1gTN2wOpgweru9Q6SPPwd0sKvVi623iWG6hWfTOrdfyyEjHan29qgMc4AYrw0nxcuFYjFosPwhbPUQsbcr/hoM1mWo6RqI61InDPKGx8ELhpT0zRI5YBTVb3xwAp3yqDRDQJFyMHq2u/+KalQWU6eZT4KjYxRYIoijwqCVC4lj3MWeMNf6BJroyMh9GE4C26M+11KQSYs1fqSt954jddeucPhbMx0UvKt999EZU7Buby44G//9qf+WcNoNKKqKv7qr/6S/+Vf/Ss26xXlaERR5GAaZCapPS84ODjgg1/9gDfffItnp6dUVR3TUD14/QGHB0dkqkSgkKrAyjFWFTw7n/PZF4958uyCcjQD66LOCAvSQpaHaBc6nrQMTlFvGozGUGtN4lR0zn0XyjRxTAtBJqW/HoxjbUQBAy5PcDRUhXe1BmmXai44PIXLu9tsKHPJnZMTZuMRH336OevKkJcTrCwwCDAaaQ3SagQWIwXORe+GTgpFORq79EhGIyWUo5zVahHHtjGGjW7AGhSaQmpKacgU5FKRF9Ll8cUymY743ve+y92TI8pCRQ7g+KZ7adeBoXwEEBfNI/OpA9r+bR1sstNHSWoODyKEbpSk8N5+OcGpGMroR08KBvqwBjsG0OioEpHfOIeudxBhY0Sj4EBSUpFJdyK70ToC14SUbDYuvVJd14zKgjt3TpBS8Ppr9zk6PiArJHVd89c//jH/27/5N/z1X/81Z+cXjMdj/qvf+a/57d/+bV577TX+4A/+gN/7vd9DCMU/+c//Ke+99y1OTk44ODjEWjg4PKTIc89zJHVVecO9c0BYY+OpV9cPsnMKHg/IaqxLSaV9KkSLC927qdZMRmMODw45PDhgOpkihOTJ4yc8e/aMxWJJ3TTkoxHVpmK9XsW0RQ9ef93zSLf/1E2DEKA8D1LSOWKapvFALxsYkRtHvx92DfptmP7OmkqM+2Hvd6fY/Zq2xp2A9wag6FiyXaezyjK3PIRAa8N6tUZKF52iris21YZ8lINQPD1b8OOf/IKf/uIhtc65XBVYcox2c8Ut/zS9VNfZFv4ORZi6ivoOwRehXe/a53DbUxitfGGjU7rdQdoyrgIqEHlpy1PiWvdzFP+a6LDBAY+BmAYwgORCHzV1jUx4iCvApwb1e4AxLsKhEKJNBZicpA48whoPDpFdcAzWxpRxJgIMRATTBId2e4KvPQEX0trFee/rGP5agq+i5ZNpvVpgoF8/SjIqC6zvi816w6baUOQFeZEn4ap9BCbfFikUo3JGWYzJ8wIlNLq5ZLV8ymrxjH/8g/f5xv3bHExG3Lt7m9ls5sfMjbclgHy6YIyULC4FnzUmhggP0rBSEiEFKqxtj3211nqZSaJ1Q1Nrx3ctLtWgj3bXJKBRsGhjePONb5BlGaenZ5ydne10hF9XLu476NNnwxzpPt/K3o4fa5TKmE4nfg50/wU+Ffa8oTqmAICOU3OAJ3R5yy7DvuiMlzEBCDTcL/v41Vd1Vu193iZOWn+fDIDQ5yzPrdEXc+JuVWvfe0yrMzne0O4Rfd6X6kAhhagKUaCk9CC05D1JfySzOsqqLX9t+VFwfKd6Tni6vz+Fz/05EH8PTo6kfSIF79mEd4X3ixbI4HvO84wAam/v6/fRPsDAkCMwuSu2PzR/WNEeflf/HcPv2r0ehvjLdaZa34nWv7Zd/W1g63M9n76bqNW2zv/QN4nWu1guWa1WfPLJJ3z2+UOsELzy6iscHB5GoLyUktlsRlmWnagr4cCItZbNes2z01MsDtS8qTYuYmWWUZQlk+mURhuW65UHpSjGRYEwhvViwfnpGfPLS370Gz/k7u07GG/X0V5mTHZMF+loV7v32lK2gTfptfTw1a5y+7wzjRJT5DmT8YRRWUZZNY0Ct4928ennoS3LTaefWgdiNMsk8+06suhQ3+z6nq7/l0lD4xcBHnt3kud5iS97IBKPZadZ6yvRIB8kyFZpxbp8rctjXA2Tpe7L9OUKX6IvxkbQlOcJuxBHvNg47pu/IiiXA+Xvs8nu0puCbboTdTHMb7fxbj33dYKAhvTFITo/O+Pi/Gzn70Oy2nV0xxcBzOyrQ3rPy9Bh/z5QlEVfEvVlnnYuJO80bk5m4UAxLj11ozWbzZr1as0nn3zC7GDGbDZjPJm4vbNpwNvnADbVBq01y8WCsiwZjcbxMFmjGw4PD5lOZywWCy4uzpnNZggh/eETiTE27lFO3TJkuaLRNZ99+SWPnp5hxJhffPglz043LJcCbXNUnjv7nstt6toTxfkuADn4cdIe7xzWTWRX6/lBRwKKsmng7HLnegj9Hh+1lt/9Fz/kX/6LH73gaN5QSjcRZm7ohm7ohm7ohhIaMvKE66ni7yJjGKc9SuUUEiGwUmKldEhiwPjnAujASok35RJO7LaGaotK8k4aI8Kd0TGqRI6wPqenFAjpRaoYbj8RyMA7jrvhfPvtHVTACI6T1kmZukJcN0hiNA9E0AKv1bedd12p/AyX8SIG4lYF7xoh+/3WfagVfJ2SkYI+wsWe4VHscbrscm6I1uBKFKRbB2vrBGgNlqHaQmUoD86Q3llmo9NKgDXOACIVBtDGOZxLH6bSGYBdKGqtDUJIpHJ1kko50IZ/P6J7MlJlBYU34BtjGKmcxC5BDuSZSoABLmWCc5iAEG59FGXpgTsOIFCWpQcguCgrlpBeQ0XneHQ+RsO9QggXLtPZCSzWaoxu0DQUsqEQG47GcP/OmMODEYWeoxBkmSIfK37lzddiiPksU2hjODkouXcypa7qdtitOwVgrIu6MpvNuHv3LsfHx5yfnfOzn/+Mzz77DCkll6dP+Mlf/Tnr5ZIizxmNRtx+5TUW65rHz86YL9fMjm7x3e/9UzaVoa60c242FmNhuVpR1RpjtEvnJAVFWXrAoWS5XHNxsQCh0I1FNxohXeQa4VlUJl0bXZ8YtGlotDsJTJZhRDs3VXTst86PwIekEkgrcFHIHY8oCs13v/8e3//OuxyMR0xHOfPFii+fXPDzD7/gxz/5iMVaAwX4OUaHh3kwDoZq40/6WhcB6XyhwQqkCqAS696tNVZYmmaNHAnuf+M+924fMxkrikKim5qLy3MunnzJwShHymmyCgOwwXNYEcBCksYIrLYYqzHCO4d6Tt4+30xBN+m6tday2Wyi4T38a5X1YYdEKCN1LnZTpAwYk0Qw6Lj/BbcAIkScaOtmrEBIReajPoV6jcuSo4NpBOY0tTOIP378jPPLS4R0kdWWq5rXX3+Ts7MFFxc/4aMPH/I//Y//M//H7/8BB4eHPPzsIb/42cdkecnTXznj298ueeWV+0wmE6y1ncgDQogYNQkhfGrqfqQVYno46/vDjVmYl+5ZayyN0SiVo1RO02jm8yXVxqVYbOqKUVlQ5E4F1saiRyXmoJ0bwqONAgA1z9qTPnGvxjnqQ5SrdEzi92BJSQzz7dgatO4CqnQE0Pq154dUycQBbdr+SE9daw+yCAYgKR2QsRwVFOMJshhRW6gby8eff87PP37Kwy8vyfIJQoXTUnSouzV15aIgD+1yBr7oXn8det4y9tbFxlVC2LSCnJOuzSGj6VC5VrTrtn8SrJRlBFMHMsZgZDC6dSO9hO9DwAPnuLYoBEi3lvPc5X0PzlzHW1MngcBKkLZ1SvflqT7vcQ6xbj86XkGnb7b7wiDC9CcFF+H/tbxKCEnuU50JoVDZiCwvfRsapBpRjrVzWGa5j0CWIUXm2wFKGqQwSCRFliHQnD75lPNnnzAdC37wvV/he995n9vHhyghGI/GzvGNiRM9AEJJZkR/rhk/rka7lGx+1FFCYK1CSghSczhlL4RANw1NmBMmRHfzPMufiA7ytsWlCHzw4D5gOTs7Zz6fd8Zpl2MzjM9Q3YeudfYE03VypIbv/t5lTLsOwj7Wj0wT6pLO4fRz/97ncUimz6Qnytv2bfOj6zhwdvGxF9E1dpY70IbrtTMtY3hsn6dt16XOa13ldtazvd72edjLtuooEjB/fK4baSvwjMiXkgoJIRFyuF2765U4MoTTUNI7hS8/ttMJGEEbi3f15alkqyede1vjtqeeu+vcXc/9d+wqb9e17e+tXaO/nw85svfVdRddZx2Za/bTdch2/+dkuVAW7Z44KkuUlDx4/XWOjo5ACCazKXmRx/1ASklRFg5UTrLvBd3TRzubzWYOZGMNTePSNBncHp+JjDwXFCqAUn3KIyzjsuRgdsiTR48I6ZFUkCu9PcDto77+X8EeMuTU7I/xLn40pKMURUGe523apdxFA5DJeKd7yJB9Ld0L+vKV0/d2R0jptD+5vr3mwjq2nRX/PDxxl8w39Nu+Pfo6zv7+etklZ8f30W3/i1Crt1yjjjuu75SL9/DBXXvz9ha3W8fY5sVtj2zVyQ7Vp+usHpJNnpf28v3+94G5078+9D19V19+79fjZehNV5XRn/dD86Hb99vzYt+zaR2uu69e9fw++WvvfjUQGeer0i75fB/veVHqy3K76tB55jn2mHYuEpeuyETc4xaLBePxmM16E8egLEtu375NlmVobbi4vEQb4w43QIw2Ew4ePXz4EKUUt27dQinFdDaNUbCbpgZsBLuCs+eGNrp3enuPzKiQNOSczjN+9tGK5XrOYmVYbwS1dbKiNRqLQVoPtBHC+162x6g9eNKX3eLFKMtFUSWRlSHYIsIhqqv3n3S/fEnwyRviBjBzQzd0Qzd0QzcUaUjh2OUwAQeaCTYNaTMUFiNAWgNGtMKPsx4ihc/1bnT8J0RwajjhLYRytwAeKOAEKZ8qBR/dw9/jbOOW4OyxVvhnUsP/1aLTttLgy6MVrFvXUvvPIhCWGFr86xDRXp6i0DeNpgpyT5jt3OcjcVgbDW3hNHUQcrfLhwg0uIaiGgVe7+DSRrcnxbFgXYoka2y0JESQkpQI6UOkCJeuxErrwz+GFii00DTGJzkRiixrUyS4U+JBMG+jHoXw58IrBk3TYKzupFFyFggZHWmTiQtZaU0bmlMpg8pCShwHmuk70MqijJ+hPfEW+tBo01uHNo5LHEurwWoPlvHnC4VBCE2mLHcOjzi5NeHgsGA6y8gLw3xxihQOGKSkoija1E8hqsVs9g3efuMBrbOyddKkaYkCnRweUeY5d2/dRinFYrFAWstytaQocooi587dW8wXCyYj1wd37t3ju9+6S6Ohrg1NA5u1y7d7cSF93zdcLi548vQxp1+ec3h8wmuvvcH9e8d89NGcL748ZbWqyVTBZDqhrisaUyOtZDo54O6dIx59+QUPP/+cqtGUkynl9BDLCO3nr0IgTDoHuimI0jz0bm5IRmXOt7/1gH/+Wz8gw1Jm7vqz8wV/+4uHvPb6EedzzV/99ac8fnLp+s74EKU6ib4BCGVQJKHXtfSpwRQCd1LZ6BppLdgaYQ1KCqYTxcnxiJOjMbPZCClhfjlz4dR9xBnHk7vOPesnYcdxAy4yi5tsg4aLYaNa4JjtHA6grxA9aZcBaZexa5+hcdfn/nOddeTbO2SoDPd1opkA6/Wa1XqNsYamqZGy4L133+fo6A4PXn+Lh59/zrOnz6iqmsuLFbPZMb/zO/8NKlO8/fbbHPgwuXVddxyv/fdGI1TSJ0qpCGIJv4VR6s7DNtVM4E9aa5bNkvU6ukk6a1XbFsjUp36KkvAeY1uWPzSWe8c2GZ90TaV1SH+zye+hjDTFydB8MKbBmIrNZokRlsnBCTIfc3F6yS8++pyff/SEiwUgJ2xqSY4D2GwfHd2e57vnYwrivHq/u8q5+zLpeRwUgfoOovT6zu9xjF0fBVmuk+ZTys64OVBNt2/T1EjhbxrFQ2u/h0sHDpUixH4OoAeXBmUotY6/MX7vj236OZweT/spOL6G+iKtsyAAJVyPpCl/goyRro0Q2UUKSSaEk6GFpSgdkHY0KlBKorVzRgLkWY4UOULigeEG09QIGjA1ujqnUGu++fab/PDX3+fe7SPKogAr0I1FKOVFuG2HXF/+j9fTfgv3WWccdZHW3HeHX++u53bcvWxhw29t2c5JKpBZxmQ85unTU87PL2JarrRuQ3SVkyG9L/3NhUJ3Eb2Oj48Rok2vGXhsCowJcl1/Dl313n11GLo+dP8up8KustPvvyye06ed7w1ia8/JFP6G+bfPkXLlO9g/DlfRLgfe/r7spg9Ky+jz2yFe258PQ2Pvrl+v/lfVfd9+tE/+GhqfXXvHvrpd57evWu7udfV8ZUMQwbpzYtf67D734vPw+akLtgoUDmVYrI8mmTEej3nllVdaO0cyrtYfv7A4nSA4wjysFev5eTn6/9l7r2ZJkiwx7zvuEZHiqqou2bp7Zmd2xM7Ozqy0JdYAGGk0LECIR5I/hjT+Bzzggc94hBkeaAY+kDAjSAiuIlbNzqxCT8uq7lJXZoZw54OL8IiMiMx7u7rR2MlTdiszI1yL40f5OTMX6ldnLJe5p3drLi4unKdfrVnO52R5RlVX6ExjrZMD5Uc5i9mMophFT66uB8SwOWMjN7S+d8GJaboN2Q/tmhhah4GWWSwWzGYzN47aGZCngpSx+d7G0+yKp6+t3O2N4zb6fWt5O6TZNi9D6a+z9wMtMnFX7VowvCaS99KXdA3nn4Ldz5Ht0K2ve+YMpe3jbBEv05tYCzehb6bbPDyGU7TUjWFkT+3Sv5tV9/k9r2xrzy483S7vx8Zgah+Pnfnp98/b/377hmiw6+KVXaHf/pvQmN08gN0MDVyWJUopnj17hlLKeyA+4s6dOwBcrZ3M6erqiuVyGfmfqqpYr9cxJGLwUJrneTSMCZ6a+zx3n5e21lI2hrOy4unzK1Yr+On7z3j/o5KytuSzAmM1qBoIHv+dt/TQt/6e7c9d9zN1wx/ox3bM0ss66VgGo+kp2FgX/3lYnb+RsDeY2cMe9rCHPezBw6Zgr33e0oIpo+WF/9aQ55mzNBYwpkGa9nali0Ptb48aF1YDY1D4m/WqFTIo7fM07iaqDUo0VxnOiMXGdlgbCPgQhscLEQMHbUExQGwl9LVIoiwO+l68Ys7aVoDkUqOcP8KY3o+WJ4xvNu43gS9E9maFGLjeQ5h/55kDvP1KVL6S3u+RVtkbhIpDjE7KXHSUtb5gSYxXjHdjqZVGaT/fLrG/qazx5gDRuEmUwlYur1LOyEFMq0wuitxb8dcITpmXBS8GrujoASbLhCxzRhzQGmNpnaG1piwr6qahUBnz+Yyjo2PyvHBMS91gmobaXBE8JyilsMYpx/wmQolzdS4izOczRITz83OyIFS0DcY2WGOYzQq0ciGZlHYhKOq6pMg1RS7kWpFpJxB98eLUhVrJNSdHC775c69z794Jr5wcUswVhhpdOK9PNZba1oiFTDvDHhWEKdZGL06mMRjfbmOdG3e3Z9twO03T8OrDh7z5xhuxz7/1W7/llHRekarEOoOWqsQ0zkOEVhl5UQCKujKsVxVVXXF5Off7tOHJ04wfV5/y7NEnSFnz4NZbvPv1V1nma2x5xllmWS4yDo8L1mVDvV5T5MKrD+a8+/Y9pHzE4w+f0TSGw9mM40PF2WrN+VXpPAwBTVUxmxUcHR2RZRll6UL1lFXFbDbDAnXd4ELqFFijOTu74OnTZ9y7dYIWhWC5e+uA2z/8Ft/7xW9zfmX5Z//rv+D07BSTC2IVpQ8dhXGeDDKlmM0z7+FGYU1GJRZBo3VBlufUFhouyJSmqRqquubF+QV/8VcrPnvyUx7cO+HVh/e4e/cOhycHFMuZ975Qo1DOMEp71lXafeeid1nCTUSn0Bw2EkhD6W0K5G0UroNzP5vpFmeGteJupqqIaQIO7ods2iYsTT/TOqZgLP34bc4gLBKsVVHp8PDBa7z26huIKG8mJHHfN01DXjiDOmudkZkLM2TjGAAunGByBlpr/d7WUTgvSnnvDu24uPBHXSWcWzPOa0QQJKsoiJA2qpOf40Ip59HGtIqRiLMjnqX7nc1jrr9G0hBbob1hDNI5t8Y47zBax5A4TdNEl/z+uOl4KNLJWkoV1yFMjTE4r02q4Wq9wuZrRGuePLvgD//0z3l+1lDbnNn8hNWq9EZozjgzNRLqw7ggPeyDjSxfGZhSIE0J1ofSj/0O9FnfQ026p1JDNGuDW2hNEJ6lhhWpYLZrMNMNnRA+XWx4yLK8YyzT/xtrf7/eFPdMCYnTPsZ14J9F2Z1S8cawW77tmSkCea5ZzGccLGYsZhlaNYgyLBYzjo8PODxY0jQ1V1dXXF6uqGtDnltyLSDaeXe0ILZwoRLR3F68yvHBQ374g2/z+mv3HZ2jBNBcrdfM87nzEjOIKuMO9d/dpyP3HM2R7mFrmkgLB2Nqa4M3tIDPvdDYG9YEw6qWdnQxnLQoFvOC0xfnXJxfUFVVrEuJUIc96mm1OI/h7DK2XYe+6WEelXa4O8ylUuLot6qmKkvquqbIc5/P4WGd6WikJNKORTtw44rY/rPO+knLCGt5RMrbvm1vYwb8qAb2b6yz086hMkdg5Hy8Ca8SaPJB8J3Zptxrm+X646c4zoQE/nDs3J96N9X22K52r+82BgE3tX3pQspj2fbsH60//N5MNMV2RhyZNEb8f8FTp+vT0PAMr+HwruXv2ndhfjYUHENjL9NrMGktgeuXG8xj5An9Z79dUX4QaN6hdkuyM2MbbPu99/66hhJfFLTd7VJvG62I8pJEDhKoL+tpQ3EXWhTOMER5mjTiempW5WU01tYqwypFpjSmMWiBXClmeUGuFFZB0zjZTpFnHNy96+jQxkR5kWvLxq6I/3dm07ZIIdCv6UCMKYGH9lgr82hrcv1SPlRzRp7nHB4eorWKe8FYQ6v26zbZAuECTipbC23v0xzu8fh62WbcMoantqGvm6zRbYrk65wbqeI0KSX5/+XBdeliaPHnWHmjvKorNJad9rGVLu4Ow20P7e7yI10aNuRtz6BgNNMvt8+H79qObeDw+PDz6bUE110FMnHQ9PmIvlHITaEvsxjjpRxO7RrZfV6jITdEu7V9qO9DYzDE+6V80suGsfEba8cXAUNjMwYtHzPUFtkYrzzPKWYzlFacX1yglGJ5eMCiaTCeCMmLwocJX7Ner1ks5tR1RVmWVFVFlmXcvXuHqqrjZbSyXAfWxeGUhFQJ3tPLquHy8orLq5XzdLOqePzigo8+fsLZuaGq51i7RGeeR7UQLl2K9aeuDbxXe06NnVnp83YY2/EMYzPm9TX93D4Hbb69h5mXB3uDmT3sYQ972MMePCh/W9cEwUkwnIiCAw8SCCQXFkZbF0bBiJCJRePCLZRlGRWHTWOwRqFURq5ydJGTeYMD0xhqUztliLE4AwEXfinLcwAaY0CBFTC4ulMlRUvAdftkrfMukjIQQwyFCgpBa+NF88gYB4FRSJvchA8CR3DDJchUKOBBuFlM5OszsC2T7I2XbGAGnPA0Ev2+X4GANaaOcx0UmkDH0wYQPSY4BYlxaykwVEGRFATPXsGCgCi3xuq6pq7XiAjFrKCqK5q6Ji8KsiKnqQ3a1+nWSuOIYoUj6JUi063LfGNBjJDpjPlsxmK5JMvy2GelFEWunCDPG5lga6xxCtvGNICQ5QWz+ZyyaqhNhpU9kRwPAAAgAElEQVQCa2A2nyMilOWadencajovMQ3l+sIJE42hrCuwDVp5waK4W3n4sczyjONbx5yePmU+n/Puu69RzHL+vz/4fY6Oj3nx/BRj1ihnysE7b7zDenWJSMPBomA+y3n65IJ79454842HPHxwj6PDJav1in/9f/4fvP+fPmGRzXn7/lv84Odf9bLRBl0Hr06ZU7h5RRe4JVKXdUfQ0g2no6MirK9UTG/mh3yAM6ip602lABlaO5Lc3d52DRAF82XOnJyj42UM2XLnzl3efefn+Ae//Y9inVprfvUXvslvfP/bcQ2WZUOWacqypCg088UMEcvPf+Mu/+Qf/x2qynBxvuLxo6f86Ed/yZ//+Kc8P33BVXnFi4tnHB4e8OYPfonXX3+DFy8u+A9/9Qf89X96j8XykOXRbWYHR8wWS8pqzvmZ8L/97894/4OP+Qd//7/h2994yDxXKAsihpkWZofCncOS+yc1omeI0qzLhkwLShXed4xQrirW6yuMUVQWVus1Opuj1QxjCu+N5gqdFV5ZaXj27Dl//ZOPWK2e88brr/Drv/rL5L/wi1yel1RrODxWzOeCzhRaO6WtM7oI+9EGzZMzprD4PbybQKyzBgCZEHB0lDjeuMMx5t5AYkJYPK6k3mS0hwRAxjjvE30DngD9sE+d7/4vxf9NU/v12hqJAIiyaHHGo1qcQZxkWczXEegninr/hcZalPcWU9Z1G5s99seZeAQDwLZcEJX58sMct8qrOE9e0aVFXGgvPy4uvnWr4A4dDwoE10/p1bl5YzGdnyzLEje5RMM6keDVSkWjKne7WKH8zee6dnRBVVVcXV1hjOHo6AiAq6srmqZh7vFwqNNiyBdLMiwnx3cxMudqbTm5c5d3v/ZN/vTHP2V1ukKpgsOjhadPGuqypvGeLGIIKNv3jrEpSGvXyLAngDEYFazfUAC5TYFyXZjKM6jgpg1r0zdYAYvWGY1pfNxz11aXrruWoL0hZ627Bb9et26rrbXRa1VQhCkRiqKIZaaGOSIhFJ/qnE+p5yRoja+GzrJwplRVFfsfyq99OLBUeGysC/UXPN0oj0+tsZimJs80SgulMWQaHt6/xXe//XN851vv8ODOjHr9AmUbtFJoEcR6YzOPsy2KxrpPsQ5nu7q0E5oqcTS5qWmaCiWapqlYNyu0VsyXirq+cJ7LJm7vWW9I1iopJeKDAEaI4QzFh79zITSDAjBzoValO7YpPe3G0KKV4vBwyd27d/nkk0eYpiH3BrbhrNDJugq3KEOZxitcwx72jQbwdMAsfq+riuVyyapZUeQZR4d3XJm1m2OtXNg5EUFliZE8CY7zuHRw7AbPL/9pWjweygvr3pqxfdzyKL4Cd65MzV/CjPQVQlNgR/b+NjwiY+VO4bqR9g8preIZk5xp4VyeUhK15+Y1QYJHSvfTJHMzpSxKn1u7aYRrkz0U+LJ2NWxrUyyl1c9MjHuc91RxoVqvoa0Sf7g/6aOhsz7QkN1qk/OyV8ZY2Ztl2E6/OiKI0YzT45CGFo119MrrlCxDddlEONCWb0fauqVlW+E6RhRp/Y6vdmvLJHPraGxv8K7aNRhob5PUGc6Gpmk67W8wsUwRIcedt8u79yLNVNc1ZbmmrtYgQlHMmC1yrK3JMuH8xSlaa5bLZZSbKKV8GCfiud40TRxPEUFsIvdJ5DKB5gV//70vCwL6OKU/tt1wfu48Dc8ODw9ZLBYulFRi9Ns0tltWatyV1INIvPyTGkgE4/uNNdRbd32+ZDcl7iYMraV0HKYU1duUmf28/fxjPF2nXIszDB3o75epAh0bP5Pi3R1BcEGQu/i6iy/64xDkbWNVjcv/TIdfg5avDbIv6eCvcKFjug8vi1+R8G/wrNlCXwzIIybxYUJz7rJ2+/shLX8XvNtt6w60lki8cBbTSWsIPirL3VL30Psh+qK/5sbaO/Rs6FJJSLttrLbRTWP47Vpz/zlgdF2MUGltM4bXdOBJgwzTuBuTNMDrb7/pPFxWFT/95CPKsuT8/Jxbx8fcu3OH2awALM+fPyfPc46Pj7l37x5VVXF2duYuFPizsi7XWCyNaaibCoOlsqCygsrC1dpwfmF5773PeO+nH/L8xSWN0YheAEXoDdaeYyobZT2ODtBJ91pvoen4XHev9GUpY3K76S00ZhzzZZ4Wf7NhbzCzhz3sYQ972IOH6MXCeoFQUF7Y5AYWKnqSEQEapzBw3keCkKRkvb6KzJkjrAXrQ9EA1E1NZRoy413qa1BZcFWvvYLKglinZLDB00ggqIJxTyIcCv2gJ1zDCyg6hF1C3CX50s8x6BjqkAgbjInug2NJKaU3xiTciOa39EMeJfxW8jvcKDFe+EscHO8wxAtrAOtv0RKeWxf2wApOqeUmXavAfCt/y9cJyKrSeBfPBZL58AFlSVCMuvuxoJVCSU5g1I2L+4JSM4rZnCA+Xi4KZ0xV1zQrS57PyCVDK0VjGgyG+WyGERcmCYUXBCusWO7cf5W8mDvL+tqFhjGNct2gRvSKN9+8z9e/9hbHh0tmWjic5xhTeYMeP89K0Jkzwmkkp7EZdVN7wx1XdllWlGXFrJjx8SePeP78BReXl7x4/pyLZ5/y/sefAMKdO3e4e/c+69XaG+QY5vOCVbbk8vQzvv7Od3n3Lc2t4wO+/vCX3P4RV78SqKoV1XrNs+fP+OjDD3j+6KeUizn3bt/ir/7s9/iPv3vG7du3+Lmf+zpvv/0Wv/xL3+X73/0WdeVuTuvCeXIQi/N40TTUSQg1GL+NH34HBXNciVHI4HBDqqhMFed9GBJgpArTUEZQXmdZRlBiZllLwkdjgo7QjxhmCyzrdYm1hsVyRp5nXhkLh0c5s/kd7t475Nd+/Tvx5ntjneehInfrDWv4r37l25RVRZbPUFnBVVnx+LOnPH1+ykePnnK1hvd++gn//J//C9547S7/+L/723zt7ddpmoaqWpNnGX//v/0t/uu//RtkeeFvhRAVi1j49LMn/NN/+s/4y7/4a548O0X0nAevv8N8ccj5RU1jcK5XiznrSwsNPHv8mA9/+p9YX71gORd+8zf+Nj/8wfc5ODxCqYymcfhaFxnFzIX2CMYHQbBWVxW1aVyMZOVCdWilyEWFIewww/1wJ+kcqxHF3JgAqS8YSQUx6XoYKm+IWe/XMyT4Sj2T9OtO06Xvm54xzdj+2Hi/g2A7Hb8oiPeK+KCsX61WANGNflAYV1UV50Tr1ogx3aNp/4YEUemYh+/B6KAsS19+a3yTtncIH6TroixLPw54YW03xFLaVu09zYQ+p2CMYb1ec3R0RFmWrFYrtNacnJywWq3I85zTs1POL85ZHizIMmdk2dDw7NkZf/QnP+aP/vjPqcwM0XMslcPBIigNRaExmfM2EyC0tW8wM7aWvygBXn8cUriRIngHCIrc9EzoQ/eZoMQOPHe0iDGtN5OuMKwNNRj2dMDpKW5P2xUMVwL00/XDiKV7bChUk7U2nilDSp/wF86gAOGcCkYbKRjvNSx4WZHolSUj97fVF8sFB8sZeab5yU9+wpPH7/HrP/gGr947oMhzMq0QjPMSJ6F/ghUSQxcDNDijYcjF1eVuFRpECev1FbPZPLarrp0BU2sovTmv4S/gF/F0SJ5nHqUF2lIwRrwxgTe29ibmjpa0fu93BexpvUVRUNfOQPfy8oqPP/6E9XodPUtB62XKWhtx4e3btyP+cO21NLbriSj0xxjD1dVVrFtEKMuSWTFzuE1vnjvpHPfHx7ovHWXu0Lrp99kpi3ohET2kith+O3ZRRPShqxgbPo+H4CZYTNg8P7fWNXFbIODeTnJfZjMQRuyLgOAtKW3T0PdNGA9zl9K2bT2fs50jbRlaf0P0RiijvybH1mJ/rX9RZ9C1QLrnSoCUF7l2kV+FfsEgntmqnJrYf6PK3KSeMXzT5bNaZZYGaLznU5y3TFUUFNqdmXmRoyyUZcXFakVdVeR53jG+HgpV2l+PfY9a6fobUnhDaqfQ9eSS5knPmcB3FkXBfD5nNptFfNTfEy0dsQWnjrStTxMNpe/vx5QHG6trF5zQ38d9OiooeIfy9vmrqbr6acfoSfeOwQNo2/79yuzVG8AY3ropDNEr28Zn3DTn5cO4knvcaGKIptrWr5v26Sa0VmhPyJ9+9umGFHeO7aObzn843zt7jXasvsq7ZEw29GXw1btA4Ik3j81pHJjOh0vvzrnzywsWi4ULX1jXXF5eUhQFDx48QKzlvffe4/333+e1117jnXfeQSnF48ePef/993nnnXfipaKmaTBKeLHyBjRKo3TO5arh3//OH3J2sXYXPWXG1UqxLg1Vo2k4chdNlUYGeP2h/RV4duf9fXfZrsvrlQ7Ju7Su4MV8cwyD/A/C4RDmQCk1ImP7aqyZvwmwN5jZwx72sIc97MGDsQ3G1PF3SxQGYxkQ6brKNRivMKuwtvHhFEwi6BS0dn9Ybzjjy3a0k8WGMsW6ugS0DjGznQJbSXBpr7A2Ue75OnyDBnplsbTu4q0IWBuF3UmyoBtqbYVGiPRUiLMh2AnN8VlDfUwxKtdmBoKEpcdcS+ctkV30yo3ANCESlSnuslwgQP3YiLsNYxE//sFlqGNylcpClzzBCy7ckFfUxFuzFqWCNwODQZyxjHblNqYN4VP4OODGOsW0UmBYY2zNK3eOeHD/DkeHC5SCan1FnitOjg+5fesWeSYIXmHijbOMhWK+xIrm7OycDz/6hMefPqFqnFeaxbzg4d1X+N633+KVW0cs5wWzTFNoASlaAh2hiQtDAB2VTMFQCMA0M6q64mC55Pig5Pwsp6orjHmANd/k7OKCxlhmszmLxZK6qmkap4TOi5xZkXN5dcb9B/c4OVlQZKDnS+JNQFFYwDSassw5OSy4c3LA5eUlmdYcHB7y4O49VqtL8iLj5OSE44MjZrO5yxtuNNucpglhCRQGDRjCsuhDysx01lrvmfsdnk0Lp8UnHhIihO+pknpI2BsUlEOCT5c/slWIFDhlp/aGWs7Tj6DQKnNC3XzRznEY67qiKktsU1NkmqPDQ3TmDMcahHVVc/fWLS4ur/j6W1eUtaVqDKvVJSeHC37yZ3/F+ekFR0eHrNcrMq25urp0XjyspaorPvrwA/7g936fR5987EOKCPdfOeTeL38PrXNEF1ysKv74T/+Mx48/Y11W8aakqIJMMq7OLlhdvKBcn9OUhj/9kz/m8vIUpTTnF1eA5ld//dd57Y3XoAZtM2fYJx5DiKByTY5GZxmZv1EiNoSZ25Rg9oW/rRImzMXQrepN4ffG2kjmckhpMwZDwrWh7/EZm+tqKO2GcG5LG0a/jygshtKmYZts8r4vyO570ghjnwoxAn4dOrPCOFjrDsfwPigwgiFMus9CWamBTN9gJrQzDcukQ6jFnnFE2pY0fV3XVFUVPUUEIyFrLXnuwulpramqisePH8c2FrOCV27fobGWs/NLfud3/4AX5yVlo3n06XPKUlBZjpCBVQ4PBIGiUoiLVTVobBTa2J+z8Pv6yuzdlJy75JvEtzdUJARcvmuZ7tGwgDPM61A5xtiNNZbWERQ5AcIaSOsZEtBN4ZcxZXa/zL7CPjUICGmDZ5t+HZB6bwC8iqBpahTOoFNphVaGdbkmzwx5McOqDEOGURmN9bQymsYrGRz9q7DiPvFGKuEGczSkCc90t83OWMO3Z2JtBM9KziA+nMkNdR3ohZBXIq3XQvB+EvaMp/19O4YMIJ13OWcAWFUVq9WKpmnizf7VahUNpYKiNbSxX86QAWKKt1LlJzh35XZgz48p2gNuHko/9LuzZoLxflLWUFuHYKj8yf09pn38gqB/bu+QgSkcM6X4/TLADngT2KVfju0bpyW6ab+4/qVndr8Ng9zywPobU7Bfpw036aEEZnygvOF6GFtKo/v4852N4zBYl8t4o/r6nnGm6oEoynjpsKk8889jM/zZCdEwUGdtCFOxlkwU87ygSWi6Lg9BZ71unO3Rg8Zwmm3t7/MYKc2rlKIoCm8g09KdaRjQVAE6ZMw71JRd+JcxGKObtsHU2piC/l65yVrvv9uVZh07rcb27y7wspXtN8KBMDnwYzTGy4aptt8IR0+UN77+xumbIdo/fKZ87K5gk39pmz/Pfvw8EI1WtshBXlY9yYNryS++ajDE343JUL7odgyIc3ZqQ7q2s0yjMu28VQHPnz/n8WefISI8fPjQnT/Wcvv2bee5bbmMchYXeqnkyZMnAJyfn3N+fu5C3SrjLxW7Sw11o5nP7vHZk89YlU630hjBKuf1U7ko1v5SLPGcjhdOXMM7/E7gZe2AXHBovLrfWyJteB7plRnGzMkUU7o6ZBvHM1+OUf3PAuwNZvawhz3sYQ978GBNiB298SYhEHuCXyyiwNat4FppjYpxnYOaQIgGM0JisNJ6QDFBeJoYYlhpPamEmEw2Ct5tj8BKhX3JZzQwSYRW7pW/B4snMlsxUwhL4qhjn3aQ+W+pZyERHHmFRIeUc9ReZ/yiUNDahJlJFC69Me9A8rhLuoZx7DFINiTyz6PhB2EwfHed0UB6077fjpZYJSpPYngXa7AWjK1BWbS0bVEKBBdeSzkKHWsEUeAcDVmKXLGYZzx7+pjFPOfrb5/w3W+/zcnREhFnkLCY59w6OWa5XDArcgRDOwvKx11VNAbOL5bcvyU8fbqg9oKuxWzO3VdOeP3BXUQsWgmZ8m1GYsfEK6lMGDvbYKzFNI3rr3VhWaw1FLkiyw137hxyclwgSpjN5yzmCzDhZqdTxtZVQ2MsWjmhnCgX+iqGRPHli+io1DbGhSxY+DJvndwGXFxaEeHhg4d+KQXvTP7Wtwgq8553rGAN/mKvNzCywffPpjA9ZfAlmfSNFRk3ezsLgzCiaAp1pd+D4iu9nZHuwTGGOTxX4tZVEHY6ZSPYBkwDTdMKYvI884YKtIsahdKZ2wvahcAQqzBeCZopzcnREYfLJffuuE7XTcPVasXl5SX/8fd+nz/4XcPx8TE60xwfHzMrcooi98ZhhqdPnvLpY/fXNDWHBwf80i/8EifHJxwcHCJK8fizJ8wz4cnTp6zXJY8+fczv/cHvU1WGTOeIAdNUwJqyqvnDP/qP/PV7f4UFVldr7t6/z3e+910QoW7c+nXhd1ohsJIsjqmSVrhio1eILu7bWBO9+Y0YbERgms6XC6NDBz/uKky6qdEBvfW0a/5djWz6iqnUICCUMyb4iQYcPcF+aqxhvVGNzjKPRxND1Ik+jbUtGMwgAetbmsbfIBK8l6UkRJE1aKXb80MEY72hrHLlGHx4Hq3bU9j68IrWIpkLdaJ9GD2t2xu+znDXYK04r0/WeaEoiiLeqtJaR8Maa52nuyzPyPOcel1iLaxXKx5//IinLy548uSUi6uKO/ffYrbIPG5UIJp4+rptD97TVDoucZp6ytCbKm/GFHjXXfNfumB97F0iSOw0aZhcSspLktlIeHkawqCUDmY4kRxz4Q1D5pYOjOtfpK3XvwtlxHrSZtnUc2Cv0aF9EoyD0w4EPDo0B95gBhDvXVEQmsqtba0UooS6XmOMC8tX1YYPPviIefaQWyfuvMAITYM7q6W9mevoVRc20p94HVwd0qg4J+nZ6ddqNJrpeuOx0UuL8cehT2OgtvUGXdDxxJHQwIKnIx0xH1+H8FiuXYbV1YrZbOYNYfH7uQEc3WMadw4p7/0s0xlKa5emZTRCpZ6u8WvJpn1I5lTaplprEtp9kxIfg3S/jxkZpCDSVjpoxNDDz518I+VN45uBDTfRvm0whd92UZwOvxx4FngiSXioMF5sn5eh4m4CgYfsNYEW5yR1dPBcy9cNtSX0S5K23bSNUzBFR43VtzG+ni6bWmtT85vSMtfKNzEg247YdE+mdNZ11v22c/xmfbr+LI/hhK35rp3jGmWn9I//z7oDO/L6ApE2deeM2w7OKCV3cxPwtE/fNwyKe6ODu7vzuU2Z2ilPugb+jvfLO0bYeZ57I9h0d+42dzeYXgjytWTChuZ8qJ+Tpd4Yx7s2hc8OGXWNeiT+DZyntpuuh3A2+MCtIBLvdXSMI8DLFTtJB1rafu2/7pFUrQzxOjAh93DF25EBHpWWtGMT25z+f324kQFCn65KX0xl28Kj9nnftFTpnFAt7hjqubsQ1OXNpoy4Agy9CVKyqb5JJ63trX3ZSDPEi2yDDk008r7ftzieDPdtjE64yXkV23gNGUrydvxpZ5umVJNNPulOT7JM+q3poVzftl6mpLZICfb5b2y82NvB4XFt2h4t6wxJUYrZfE5V16zrmrOLSyxwtCqRLCdTQm0NV+s1f/nXf8XV5Qrxa6pqXKjq5cEBopz37eOTE4wS8mKOtZqyhKs1rOsM0QeIMiAZWiuns3Fuxn0YW4DU82pgkAJPPbBGdlgaw+dzcirEV26EN8PReoa/I5/eTDO41L4AucjPKuwNZvawhz3sYQ97SGDqpsMQQyUi5JkCm2FMKgQPFshEhZz1QsRIdHopQVSKm2DJbAkhl0QJVjkBfiCSLU7AHYQeAaIgxCuF8bfFFeLllynhFm7fBwE+ROrNa2WsAozF2JTRsaD6IgA/Fl42nb6zoSwi1dkVAHeUDbZl+GO6MWFEn2lq25ROYVdYaHzZptvQmCHcmmr/wAscTBv/uCtANpGYboVRYVxU4mLZ34QGRLlQTrlulS2LxZzFLGdWaA4PnAeV93+64t6dE773zdf51tcesFzM3Lw1NXleoDPtQuRojekpfDSAbdAi3DlacOfoHfh6d0yA6EHBWucdpMPO+rEQQPk0Bufyv2nqaDxRlmusbZjP51yt12ityOdztNYu/qw4wxWFRvu10NQu3ABaI94SXmuNbayfW0XjldJRga66niJaTw5N9Djh3qXhVXrrRgIDkzAffu2nTFFQEtvku6SFbSgc23xDCqROvmsyMmnf+nX2BSobQlQjXUMDa6nrilQp6May8CFDvNIUQStQouN4rqoK5W+hB9fVri7QvjqdaYqDJadPn/Dk8Sc8evQoho15+PAB9+7dZzaboZRiNpvxxsPXeOu1NzrhQoJL8vD37uEx777zbgwz8ed/8ReYpuL0xYs2RE5T+/XplImCw2/HRyd845vf4JVXblMUuTP28p5g0hv2PmoGYoO7VXG4N/HyM2Qk01Wy2jgeG0LHZN1uCME8HryJomHq+Wh511Bw9vP1jSP6MPjMvdhQ3vSNZlIcquiGlYHW44NJBYpNE/eoTc6EdIwnBaFBiBPkI+HPEnGdEwZ1yxURRCu/PpwASAwu9J6IC19lWhfvdd2AcWd42x9LRnfNg0Up52FOxBnMVVXrqj94obi6uqL04f4ODw+jV4qmbri8PKduamYz+IXvvMvhQc6Pf/yXnD+7YFVfUHAbs6o4O3OGCsuDW2TFDKUzbKa88N2ivSeOIKoJxq1BYG6C4Y/o7l7qCXuHhJcp7TJkMDUFNxNEXj/9jZR7gU4g2YP+XAkGst0MxLTg+0+CIyKd6NsUslnbK8p2n9m+sLpVSozu9eD9KKHjBH9k0Rp2p+DO3673m1B+YxpE+/KsW9d4mlbwa8un1Tqjrio+ffSYq6drHtw+4GC+YJblgHPXnecuLGMwDlaRFksEnIP92sRX7TEc1qz1Xv9Sjy3unfJh3ghjaFSHNhhTUop1dLcLObg5dqEeF25uTZY5rzFaubIKH7bQGsvVlQvBFDwLqeBCLiUnAu2senyGVYMjE8XhiTJhc+g2cWinjwM0Sfo5nKmtbFcFxdRenK7LDnfsc8CUgrTze1cF3EhM2g6ftKWuoTo7ZW053/s0a19JN5xnc33ET7vDuPfo1i8Sdi0/puvRT5bpMr6Id+Pn3MTQbhnzlznOU0rf6+b5vGkH898w3xSNO9imlN4JBhbJOkrxa+rtIXggkyAXkOv3eZuxzBB+DaEXw4WBxWIRjbHT0IpBfpXmHVo/XZotMaymSw+M9oGWthxqc9/LXb/u0XLHzpKJtth4M6iXzk/Q0LqYqieQKJEWa5F6J3/f94Vlk7/fNtfumtCAPKCPp0fO7Ci/6vUjyvBCOq9IvjZMDLy1Y++346u0zY5+HT97RnEW3SxDcpWx1g3SVhv0+XYYkiWkynk3lz2jlfC6I9NK2ueQUX/KY31jEOQhbdkpjTDViaSMZE933qfjChsh5qbaGdboTXxnWBxdMtX8l3k+3qSsSR84tvfV9h4GCX1nfIfpunTPdPGLbMxzxPvWRtmIxXbSGdp1Gtvo2+f4nhoRdxnAWHe2mAbq2oWGny2WHN26zfn5BRerNflsTq3g8Wef8jv/7+/w7//dv+XF0+eU3uumKIXSmtt3X+HV117jrbff5q2332bVCHlxQNMIZxdrnr9YgToGKbAqw/sc7a5vG+i79mK0tba9PEiLV21cPx1p06BccBPCSZdgjXROJ4m6PoZK843htJfM+PwMw95gZg972MMe9rAHD63BwzCTP/QsKAz6buk3DGaApnbWzMY6wwOLoTGNIz79xfQgyA9KM3AC96ZpwBN0QbBiTXpbwN3gDRStSvtjSlrX+G3f3OUmmygIAtNmsBgf1kVQ2GgsICIxxnV/vALB2ZKDSdlRAUQ0dglprWSEMD/GOhf4bRvTmNKecfNjh0lDZXXbE8oQkRjWwioViUgrbj5EnAcAcF43nCJUI8qHpTEG5ZkLpVQUNgVDk6AoDOEzwlxkOifPl6A0ZdVgwhxpxWJRYOvSeZKZ5RwsCr7/Cz/Pm6/f49btgsXSMs8F0/wtbG3QAlrEM5aCzgqsFapKEDJvHFUTblsrcf10zIh17clag5BUwFXXdZwjEYkeDFri35UTfmdZxqLIyXTGxeUFZVkxOyrItHZGNJni6vISsMxmBVmmQVnqqsEaG5W+IhLrhlZ41zcASyGNny7SDXER2hzepWs9ZfhDGf160nd95jKtLy2zr9BPy0rb3y+nb8DSb+uYoGxMebr+RqoAACAASURBVNVXUPfnNyjbg3vts7MzlsslRVF0lHZhnwQIBippuWH+0jTGtCHoQnkPHz7kt3/7tzvzGzxihLlMxyKtN5ST7umQVinFd7/zHf6X/+l/dm0zhizPvVFC3Y5Tytxai9EZRpzARInQ1G24HXBMs/KGbFpc2DSldBRUDc1lum/auQjM9ma4rH4c53T+grxwG4vbn+uhd2MK3Ai99T9VT0cIwLCgeKot4Ma8L7Hru55P11TA2WG+U+ivxzCuwUtPuKBje+Pfn79+W9M6++dHKD9tWzgHnTeY9l3Im6YLeNU2BmtMDKdS1zXGpzfGUBStYr5pGtbr0hsdzgFhvV5TliXL5RIg0hxhX4Y9ZI0hUwYrDXduzbhz6xv88Ps/j0WD1fzbf/e7/Ot//X/zoz/8Y1ZXa773/V/h/oNXyfNjDHMsOadXlxwcHKB1RtU0VLVB6wylQhuFyjY0pokePDbpgWEhUh/XpfNTVdWgcWCaZkpx05/TbfAyBaT98jYUFyOCraF3afu37dUhJc7Q723Qb3ugb1xb1KjuItCD/XYjwnyxoK4qyrJ0HmVsg1IGZZ1xprU1ti5p6hVGag4Pct5+603eeutNMq0dzQs+dIULZRnsq/tne/DaMnSG99emtZbGOqMeazdDtzlc4PevpwUtFjEeT4+MeZ8O7Y/nEA0iIsznc8qy7NC7LixGt90Bt/RDLsXvOL5g6Lwa2pPt7+nTZ5d90j8HbqQwmNi3113PXyV42XhmDG46RttwzBj0+xXP8y8J9w7hrCGYWptj9NJQmikc/rLhizybhuBl7N/J8plen0PnV58+GMIPmzT4Jl3ap8WHeKkxenaIj2zTuj+RYcOObXS6SFdFOkUnpGUOQZ9fSkMJIuI8umpNURQsl0tms9lG39I6Ap0Xfvfp6evgmql1Za2Th6XK/5Q37POCIc9Nx6kfVnSXNT9pIzBCd4p72UkzhGOGcNhQm6b4Onfub6pIh878PozRrGPpbooXPg89eq06EmX4tfNes36L8wA4BOP524t1KQ87tA+n+KD0+3hdtve5I6RrOJRgu/KrIRijI0bnfoc1MUZjXJfS+XIosM8HQ3T754Fta3rsPB1K73ghcbItNuX/bXnucmj7XIPkrdzJGncRtzE8fvQJVVVx69YtvvvNn6NpDHVVk+U5FsPzz3KePXnC6uISMYYiyyHPfdhdy+WLM84OTjl7ccpHH3zM4Z2v8eLcsC4NxmpUfkLTKO8NmFZW6S9C4S/aWfFeQOmeLxvjL+k6CgY2m7Rh/7xq97yAHVmJQyyYpHOym/wgfv8vl136ysHeYGYPe9jDHvawBw+t9wEHY8RkS0j5WwRKDQjRNz0SaG0jk2S8sYyxQcgPeObLWpMQo46ncN5OfEgn45kXpZjnraGAMQ3WgM5aBa0xLlyO0DI6ggsfgfUu/8U9TwUJxhosTXvD2DjFYOM9hfjmYq27LayVoraGxltbhzKrpqR2/vTJvNLeheSpMNaSqQzxoaoEd0O/0HlLVAodohMs1tTRdaFIe1M5KC+DAjGMS13XlGVJWbs6VaaZFQVKa3+Dv4weL4Kg1/p+K61Yl2swIJnG+lv/jXV9zLIcpfz8CGQa8kxxclTw6qu3KDKNyguKxYLDoyOOT05YLgsKLRQZzAvFotBIfcXxMWSZwdgGZZQzVNLOUCaMpw0W+9ZGJQ4WFIHxtlhv/FAUOXXd+LAdhiwr0LpV1kRFl1iqqgSEYlZgvZtKp4B1nnmcIlM7wtEINrPMrGaWO6WWW0C5UwgXC7cHjKW5WFN7hkSkXV9ZlnF4eNhhtFLDLbf+x/dqn6HpCwvTPZx+TxVj/Xzp78h0hPXQU6ilbegLERvvhaUPw4qqrrIuHYN+nn77UmY17VOaPyjggpIuKNytdUZeqXBySKiXGsiE98G4JuITkY7BU1+I0+IiZywQfm8T4k0JEsVah08K58HIGkPmjRCyxCgr4OXSWirjDWREWMxnYD0eNK33rsD/Cg7npU3sC4v6wkgbkDUWpJ3PNG9Yg0P9taH+LxpEdlJope0P+W4ipBoT+qXrJF1Laf1hL6WhyUKa1sOR+93E8FnjAup+/9K9Es6PaICTvHNr1xsA+rRpGaEPSilyb8CVtjv22XuIAXezV5TQNC6s0sXFhXeN75T1RZFzfHyLsqwAZ3RTlqU3rini+GziGwW2SG75+32AAIZf/M43+Prbr1GW/wQR4fDwCCuK2iou1jXvffgJ//Jf/j/8yYefUFaGOw9e57vf/zVQiropqSowVmNFI9qF3lPib04HWsa6s1klwrP0fE7nIDWMquuaoihGlU9hTD+v8P6/JNhVEbcLTOW76Vimxo5xbwocHsx58fwJmYajXHF2+hlVeckPfvFbvP3GQw4PZhS5YEwFtkJHz0qgZAUEoxVFLs6YUawPT+UN0m2s1yCqFSoOnecd2l4ptMUZrVvr1mmUM7p/jWkNgVBuF4lS6BEsveuc9HFMOBdaL1O+yh5OTM+bKeXh31Q56cvcBz+L8DdxnIYUBdMK8Gkqa4im79Pc29rxsuDLrOurBC9LWfizBH2lWeDvw2WJ+XzBfLnseCrs87qbfGVkfwcvh2y2ocu3p/M4tXc+T5+n9shN189omS/pZN0uVxyGyX0hf3PP/TEYGq9NM4/hfBvgjQGulSdmvfm6HqLlBuuPnyPvR9ZOaNq1mxjW2khdYxAuF6a8mqv/5RpZ2Z8Bvu+rCNbCfL5gsVgwmxVYS7ws2pevdvj6pqGpa66uVqzXK5qmRmvL/bv3yLKM2axAibBu1hjTUF1V6DzjrTff4H/8H/57/sk//IfMi4L5fI5SmrqsKKuK2rrw2MZa1pXhd/7oMatSYcicvMMqRDRNYwnes62xiDVOPoILbyw6nG1BB7OLodnwGhySQ4exY8qaz8KYt8mpdvRlv/H7z9yJ8MXB3mBmD3vYwx72sIcExhQxw8xqYHKIiqk2byrYJkkXFKMCSpNJ1mGW+n/OIlowxof1iZ5rXCnOUEPAWowoF74Jp+APhiuii54i0oXYcUIQWgYnUTZa22BsqzAIAhhtrLPW7rkUFBHEVO4WbkepmZH7MBp4fzVaKSTX/r1CSepdwt2UcZ54DJ1K/BC7kEY5QvDoAsY0uAgRjmB3XlHc76quWa1WiHIeXjDiQhlZnBFInqF1htZO0VlVNVXpDEhmswWz2TFZPmO5KJjPNCINTbPGVGvErqjLU67OPuX09Bl/6zd/jW/9/De4+8ptjg4OPNOg0XlGnhfMZjN0pny4G0esZ0qoSyHTbj6UVdGNv2PixXuRaUejsd5wRgQtgoj25UVeN8Ymd0YzFSIuj7GW2jRUdYXOMoxYJHMKo7qpsNYL00wrANPaKT6VOKWWEsAzGVFppRTW+hvZNtTlbhSIUpFrD1b+Q4qspmm4uLggyzLeeutNyrJ0oUZ6nhyGjEVMojyezWYUWUblPUUE5q1JPJykZaXhljp7fWBPdvJtEXwNCvWSMYt1+Od9A4NO3gHclHrF6bvaXq/XHUHlmFAl7W/EfzivRuCFE9ZigwGKUmTeG0sILxYwUvhO8gm06UJZwQjHmEG2rtPvAaGYKO08VXkDw+BhRCzON7VnTK3Hxdrjy8x7StDBi4U3WHRzEHBgmI9xNjVVXnbPhkSBk+Lcbuc2nw31GzrraCjdkOGLDMzxRvu3phgXSG/k9WtjtJyRsoYEhen+GRMkpkL9UI61tjsW/S0XbwGmyjRAdT0bBUiV2EqpiHtSzzPp+7GxSg0TizynyDIskGlN7o1dtQ6CJaekKMva47uGy6uVPwtc2bVxXmpMIpB0ZEWCM2xYwdIbB5fn6OiAo6MDb+ji2t5YQ20ajuqaw4MHZP/o73B5fomxivniiMXBK/zJn/4ZH3zyCS+en1HVFp3N0FmO0pq6qambBq0zZrMFi+UBi8UhqlggfowzrbE6wxnqOhqjrlsjGhHZ8BQW5jf93BCSD+2Bkf3yRcNNjVimYNSbSC/fLnVvU/oO0r8Bl48Ub2P7nO8/AWosZ6fn1LUF09CUa6rVGVrV3H9lzusPDpnPMkQMShVx70Y6M+BnY7Hi1rwVZ+AY8IkKe9c6msSde8N4ZGOMvDZQKUEFwxtrYx8CfZ3S77FsoR0LwXtM9C68Rdq/tlY3KiIxvRIJLh69eU77PpTb0nue9lPtSxsUZIEujExG92fb1dCPviHy5noaWgO7rq1dwU6EIRpenmFeNh5vEWmL5wO6/NukstUlnCh1GG4inr4pVtqGz4ZwQ0qrX6e8MXqi//Rl4NjrltHqNSzdm7thvtMLMGFfO6+b/mmSNqwNfJq2rDY8zXD7Pm/fX5aRyOQ8DtBaNylnW97RMqGDPLt8CYlZr4RGEGiYiG6lU9rgs6Gm7UIzjNHa/Tx9un8Ktq6LiT05XqZfu5HOAyWK2jRgLXlRsFguosdM8UYyOs9H6fB+W13/0jRh/4Tfnr7c7FAvX9ej6ijccNnvuoan5n9sLXTWJ3TOn6k1Et/F5OM8d5onLbNvWL4N7Nh0bAG3w0YyjjzepVVD473rfIyl2Wje6N6authhxwiMG9U1RRePg93AUdIpaIzQ9j2zbbin4OnD2rbXNu2iTdq52fLpVt4Av5kkT5/23pSV0DGu2aX8tOzr0jI3QTHbaMHYR2l30dZxS9OGR/F/22lo/8zu76FtZ9Z0Oxh2duLPFfH8SJCPZVnOcrFkPl9Q+Muldd2gxKJUxosXz3n+7DlZlvHw4QNmxRxR4kLAr0vnxRlLphTzYsHR0TFVVfpQtN5Te1lRViVVVdLYBmMNh8sFp6en/Jv/69/wwU/fx1rL4eERP/jhD7l3/z5aa54+e8r77/2Uqsqwtmjld9bJBy3BKw5ga98/QIK+pLsWIwqfZC7s5jayIU+fXgx0T3s5upMpnZShqjzvto126+y3L+f63c8E7A1m9rCHPexhD3vwoMQZNwQBjiOGu4RpJG1TwnWACZMg6BHbZYMkEE3Bs4P23mN8Gk9MufrTm+5eeGSH3WGmbex60RCyLPf96NbRvbEpSZrg6cJE4j4NzxIgGrX4Z1mTeSOXtj9agmcag2kaRBSiBMnCWAYhphtTYwy1qbE+IvOQ0jQIgrCB+HTtdDGtgoDXelmbcuGMvOcJnWXeOEKh9QydZagY/kPItUZsQyaaXAnLhfDw1QccHR9xdLzkYJmjlcHaClOtsM0V1fqcF8/ucH72gt/44bf45je+wdHhIZ2h6BDJCbNnnIGQUhnGgBg/5olQLjVCCoyiG5MgiBK3rGQzTJDznKPJMt3e8G9cGA0XdkZQaDLtDGZUEBaD5yKcQY8Wty8yrVA6eO/wBgumNe46PT3l7t275HnO5eUll5dXLBYL8jyPeyQNSRDaGTwlBIOXED6oaZoYaieu1AGFqvEKtbCqCOvfCxfCM0mY1Y6gSroGOGNC0fC8ryTfJgCK5faedfIM5ItpB4RNY0K3/s30bcLBjbYkQoDQLkQ2ygmKUknzJd9TYUOnb6nAYAdhaioLFC9EDx6XjOl75ZH4vFV8OJVmJhL3TlgTolovXjYKoP2cigvxM6ZoSA03unORNL5zTrSffXa5P/e7CECUfPEs8WA7+sq4gWedMpIQO5OKygEl39Dz/rM0XWs003NT69eBaRKPL0pRzPKYti986oeESsPXhfB8wcAj5EnD06SeJABspv2R57xXkKA15zXFey9r3J+1sF6X0Zgv4MxtYIXxi0q+37HesPBxp8ks0yxunXDnV3+AKI0ShTHC+eUK3bzg/oni9PSMqmq8kWkGSnj69CkfP3rK+fkF61WGWS04kxzRS45O7nB8/ArIAiUzFxqxcZ3Xutun4IFqCnYxkNn13cuEmyo7t63v/u/r1nPd9Ol6lkAUTo2h7X7xFC6NMT6sXTCIgvV6xdOnT7h8cIv57MTRmKiIf7FC5g2XU7yrvCfBSCsqQVSLf0V54/EJoeLQOtAiidA41AdBKbkp5LcYmxjrpQr3VMhM/0xIaAX3wO/RhDBPh3II0vyxxkTBHMqlX2+3f+PFX+/8ia0YWF9bFe6jbRh7N4XQJqu6NgTa4Ca7+SZ5btL8Ifoy/Rz63qc7dqpn6lzf8vuLgm6/IChGhhvTp7RSKmxzljfXbargGKddXgaM4fyXWWdK5+yidBl69nmMejz5M1Bul37fyDU5BNNn/67Gcn18HZ4N8VFTedMyJumSzzWOziOGiPiwnbPIO+d5znK57Hgss8Dw1YRxvJ+wa4RzNe2OYxHbcWrlVC3srnS3g8gp8ms32AN9hX1b1+b3NM/U77Gypp4NlTeV96bGaNfJFde07c5YZ48M7CvbMRsahjFFfn9P7ULnb8NRu/KSU2XsAkP4L9Zhr1/e+GyN9Bc39n3pb5RjJGRkd4/e7Ozoz9/Y2ryeUdfQBt/06LYTpB2+Brxsmi49tWzv2RgM7dVIjRg7uNbSkOqqJw8wxlDXdbzME+sZkU+KSNzH6dinMtkgR1QiZHlOURTkec5iviTLinhZQcQZH1tjwQZ9hsZacZ5amob1es16dRXlsfPZjPl8zuHBAZeX7pJMnucA1HnNwiy4Wl1xdn5KVdWu3sWSPC8wwIvTMx5/9oQf/PKv8OjRY5Qozi8u+PijTyjlPujMyVJse/k2Nf4R5bynW7x8JpEdBhYzytwZMdR3AzbwLBnvyK9KLBN/adWNXXeOp8+5sNPT32E+h35/eXKPnwXYG8zsYQ972MMe9uBBlEZE4wxVmqgn6N8u6xIodtBKO6oOxmgtX561EPRFQRnc6qo1ibf7pB2DhUWBflT8+vZneTHC/BKV3sETio+g4L21tOU6zy0NxlqaunLEtQ1eP1zCps6SPGCtI+SbxqCMwagmIfgd2+AUhFUU/gSjjiDsSQ0XgsGOUgqFomkMzmuKckQw2iv5gjDJz5NY5vMDRLznAKXQOifLZyAqMiuZMsxyhW0ssyzj+CDj3isLvvPte9x+5ZCTkyMWiwUqzBGgvJl+XXvGBq9EtdDYyhPHXWalZXjAYAi37qwxmCRNXdes1+sYLiplKkMZbRgRvPDM9txjGrTOfHgm8QpdUEaR6SwaQ/iRigwsOIGehPpEQLrGOH2BfF3XPH36lLt371IUBRcXF1xdXXk3mgrlF7P2obBSbw0AZVkiIhweHrJcLjk/P98Ij9J3y58qt0WEXGe+PYayLFsDIuPCoAVDtrT9oU/9sC/p2gt//bAw6bt0LNL2DQls00/3stsfV6Z/YekY3qWQGviEmPWpgVG/rk0BZwvRYMlaijxnPp87xtJ2w6n0DYumYFeh2JRAfrOOJG00jEuftQImgkJyhImcUkSLOO9N6dNo/DCSLyhtp9vfXRcbCuoteTvvR57fVKkxNT5TAt2p+tI9M7Zm+mPQ7sdUybUpBO+vxW57Qxo69QfFgrKtsjltfYpjwpnTD31kOudmCAtIPJ/CWZy2s67riF/jGZcYDyof2lFE0N5b1GafdrvZjFzfmMoF3HM0SRYlRxYtluODgl/7lV/E0RfeCMhat96N4cMPP+DHP/kx73/wARdXK1ZlzadPnnF+9oRFUVMVhsYeorMDdD7H20nE8xhoDfMC7pNARSVeAqLSskuThbFpYVfx5fXhZRrG9FJ0aK70eQoigXYbLy8V5G5rRyCTAu5qjSxaLBqIYSHcZu3SquJVck4g2GBtw/LAGWovZjnz/JBydcCTTz/k/PSU09Mzbt86cZ5krMVQO3pKZ2ilOy1XvhJJ17SEusNeHQ+FOEQ7xDN5IP2UkiCcyemZHva+a0+gawPN3IZTHTt7Uxqj2444O2lvYl0gjOHSLxNuUt/naeOQgmUoxKP4iRk6w2ALZrgB/gxt+1IhURwF48fB8zml8UdgUOm/tfqXu9ZGRy/dr0kfA4lMb47F833dLn3+tl7HyOQm5Y0pvG5aXv9df/xakISOloD649ewHwJt3Sk3lOk/t+2dIVq/j2s3xmXH8jb6ROtNqE3W9xzWrXeXPdw/n2++7/tncaBHE9lR0k4lCq2zKK/JtCYvCpaLBXRoQ4uxFgkGlRNraYquT/ngsXCafQOJ/lhO8XMBR48arziCuPss9nACbL//AMED3naes/8s0B6TPPxmCYOtjHPbW4MRfyd1TrWvX9OuuKKLV7x8YYIP7tezi0+klC6bascu8oHrwq57+Cb1hHKjkf9INTc9D6bGZJtsYIoWHN1fve9De7XPl++SD8Znvs+lddZ7ODsGaLexvn3RMFXPy6S/reetlaiOUY3WisVi7jy7FEVyAdbSNIaqqlitQqijcNHUXQAVSbx9JzyJ+2wvZ0JbnmkadJZ5z7ea5eKAg8NDL59QXiZjEtmHy3/r1i1u3bqVyG4MdVN7mbPCGBduebFYUBQz6rqOHsSNMWRZRl07Hq6uah4/fsKL01Nef/01To5v8ff+3t/n4uKSDz/8kB/96Ee88867/N7v/T6XF1fMZgXL5SGXK4OVxnGj1mKswlqNVtr9NhZlne6iqtfUdYmIYl4s4yU8a4M3GnduWNM3E0xmx448B3fbLj53HzYhoFqeMeVLfdINOZwi3TnpayXt+ZauJmT4cvUerg97g5k97GEPe9jDHjyE2902UjVBON0qaLoMSCCIDJNXuvtglSeSpEMsBeXgGMGdupfefDdQvzgivGmupptjLXXTCgIcYxRCP3XLt7YNlZQSzCKCFMHC3Id56CnZ01inabkW01OSmhjqIngYMcawXq9DtxADpmna+fFKJNOY+DsQkSJCMcvJihzRgtJCUeTkkqOlQKGgAdUYtG4w5gxRl7z19i3+7t/5IZkFsd69cePmKChfjHX15XkgtmsaaieUEWcEEsZKa935g9ZIQURcWj8Gl5eXXF1d8fTpU+bzObdv30YpxXw+Hwxb0Sp2FVlmfZogSK+p6gYRiyiDFlAGsAqzMe/tLYMoHEkUc2IMIl2jktC3PM/52te+5m4UrNeICHfv3m3nrpcnfIb8WaIkbpoaYzYVYP2YyGEMgsLEGBNvaSjROOOvxLijx9MEJtX4dS0i0UikNdYJwgITlXKpoiadh1QhH8ZEa43SysfOJQrs0nyhX5m/uWG95yYRRWOaaDATxizOxxZB6JRAPvy21q2X8/Nznj9/TtM0vPrgAW+88QbHx8esViuePXvG+fl5p9y07jEhVdeYpBWuhvkf8pixTeDg2PVQPk5QTLuOQ5q4pgnouSvoGRubiONdo6Pgpm+cMSyM6gqJ+/t0Wz/TfLsITKfG6mUr74bmPEDfkC0dA2tD3k1lUIoPhpQW/fqGxmVIgJcqREL91toYpg7caijXa/orsGusqdDaeZNJy1ZKPO6uo7Fk6IexrWLBCZ3aNdCEMrR29QZjIuUMN0mEhtYL/fuwKUwZmOcx49pJsCBdL1ixTleR/+7CKsZ3ufD62+/y6ptvImLRWlE3ls+ePOeDDz/lg48e8Tu/+4dcXCkWB69wcvsu84NjSis0RjBWwDqvUZlfBxJosBhjLVWUOA9xzlw1fHeqkYgdpIn5pCds+rKgvzb7oQna9ZQoISRRFA2UkcKUr6ExxY7QxYVhKYkIosMYeaNABHCG0ihBKUcvYQRBIyjEGhQVWmqsVGhdUtfnXF48ZZEf8o2vv8Vbb7zGnduvsFjOMU1Npj1lYQ0S5jZOT5jvnrDPBi8zoT8tDR7GyAzgDKVS/NEdn7Gx7eOXvgezrkfIVinfoTOgkycIuMfq6D8Lz/voPaU30r9uP3YT8Hdx9M0UVy9babGhpOyVHwytAw0dab4RemSyXzc4H78sJc02qIOBUI8ugc09P7a++jD43h2eo+lvOh4baz387TIn/oyEhM0bzCds4JHOu+s8D1VP07shzfD+Hi9/iEYcow/H9kiqfNzSia7GhaC8ke67cAbR/cTzQhtlJp+D7bDd3g/1Zej7tj5Nz0M39O5YPvd1E0/vUg9s0r+75CFegujSCE4x2V6ASPdzXhQcHZ1Q5EWHnmiMD1Wounx8MHMSX802ejptc9qnwF9P0elp3ngmJ2dnn3dN2+CHfxSGRnF6bIlrOeCVwFOjJIYsT3n99Dzt1xFosqGx2oqzBvolYUJslwZDxMkIJnjD4TO7pUP6+2jqTI3rY2DvjeK6CUXsGI9oe/x3v65+H3c5V7bh4OtAXx7TfzeGm9Ozp9+Wm56NY7jk88B1ZQHDczg+f+Gz2SJj6ZeNktaDalrHDWizrxbcYO79RV13n9Txw0VRcHh4yGw2Ty4ShHB5Lpyz1hmLxXK02CBjLsuSq6srJ4t18WO9fCNv8bqtqGyNEk2Ru/BLWVZQlQANWkNZrrHWxFDVxhjyvPUKKtKGVtZas5wvKHIdDWPCBaOqMhwdnfD8+XO0biiKOUoZbzSjeP/9D/jzv/gLmsbw+uuvA7BardBa8+abb/LRRx9RlmtW60uUhne/9hbms1OenV2yLg0GDVKg9BFW5TSNpWpKVhdXPH/xhMurU6xtODk64vUHr/uQ8RqRzOFFa7G2xvGjxvPpyp2mVloZBSM0X8Kj+kRY9Gj48jH6R+J8T62dtg3tWbclzx52hr3BzB72sIc97GEPHpraGWcEocWQYABSJsG5Y7GO0r9GTY7olR7j+XmEsdN5p5nKlKnultMX/BOJ4KF6ha5CKFWQiwiz2awTMiiOq4wr37MsYzabAXDordxN8ADkRYThtnvwaKOVYlYUjsBNDClCOCtrG8zqBefVU5Q2ZFpYXV7x8QePuDi95P79ezx4cJ/V5TFPPi25/8qRV/K0QsK+krZpmmjkE8JXOYYmuK50fXYed5ooPArM8enpafQMkhqTHB0dMZ/PY6iKYBjTH6t0XkI6sIgCMaH+NsxVEJUMrfPJmON2Wmgb2p+uDRFnPNQR7www090b4L6ykfSBCbTWRuWJta1HnH77+0LC9Lm1FqUVTdVweXlJ0zScnJzEsUnDLN8P4AAAIABJREFUrIS+hramArcwdn3mEUiMeMIt/W7fxgR3IX9tGu/1yuUrimJSkLErhDqMMSyXS2azGdZacq159OgRn3322WA4ttCuXULEBEjTDnlq6bdrCvq5xtIPzXd43h+/oXTB01iAsCZGhaoj7Zl6N9bu6wgPQ7ohReGY4CtlsAP0b+qneYYE3gGGvDd0x7r7PMVbKQ4KZYlINDYDqKqKi4uLjkB2SMCdtsH0PHD0+4q1iFaoBKdZa6ORY8CpSmlv+BKMHt1nuB2V1t8fv7Fzrb//B9uXlHEdCLqC/s3Rz0NfjIEVqLEYBVYpf3vL1f/K7SNODhd8893X+PUffIuqtjw/PefjTx7z/vsf8smnzylLoaxA6YJbt++RzQ8RXYDOsAiNFYzVTrDqTDS8YEt5HOIEW1VV+fA/IcSaRqkCrQRDjWXY+8gXBUPzOKbwsLa9wdbPN/XbDtBnsDnPnf0sOOMXH35UxI2fWK9ss33vABZRNZluODpWvPbqCbduHbJc5GhlUbYhV5ZcOc8wWjLECsZUZIVhtlAUuQv5KKoh0+LpRH+eWiD+DoLF+GJwDMM52e/j5rnvveFIOGt6ZQ3WsDk/Q4ZO6V/AYX182qWDhvHAmBLRvdts2xD+7c//tjN5DM+8TBhTLG6rt3/29Mcpz/ModAeYzWbcvn2bp0+fxvMhpYO/CJz3VYChsZyiOW4KwbvTVxVCy8bmeYiW2VrmxDhuo1vDu2GaBLZpMcaUJv39M9qvG83VphHgUBteBgzRR/06Xyb06dftsGk0s0vbps778XodU+zvsyM+pLQ1jr48PFhSFDO0dl74lFJkWiMdw1H3OUR/A4P85Bi9PMYXTNH9fRg6l4e+98dmip/aZW+P1d1fyxao6wpsl5cba1tcn0AzcWHty4D+WHVpQde+ftuHeJFO/v74TPAn4bvZcnFvaL2IbPJ9Q/X+5zyvd11n3ZdEzxRfVRhcLzvIXcbkGlPjoUSB7IL7frZhc04sohSzWcFsNvNh7AuAaEA5RT9MzWfgTULovsBv2mjB2p4nxljC9lYqeDJLL5y4CzH9dmitfVioCmj1J8Y0rNeXPHt2yawonBzRy6CtsZydn7s+S0Zdr6mbmqouUQq+9wvfRWnNv/pX/4r33nsPa93Fvvl8zp07d/jN3/xNlFIsFgvu3bvHu+++wxuvX+D0KposmyF6xr//D3/M0+fPWdOwtjWoC5b5OTNlQCkac85fv/cjjo4OObl1SFFkNHXDalVR5EsyPQdboFVGUWSsVpfOZtDzdbC5xofONZQztJmi0QbPZlwYqe3g59A21HUzeOF0DzeDvcHMHvawhz3sYQ8BpBWW9EOvtEmGmA+YIppGKrtB866bZ5rImhLypAL+UPd2wVFXMeqL2fAqk77r19sy9SrSlY7BDsS/pqkrKlO7O+UKcgXWNChlmR/PuXvnFsdHS6ypqas1Ra6ZFznWWOqqYnV1wfPnF/z4J3/F2fkLV75V6AZmUvHwzoxvvHOPr71zj1dOCjJtfFs2lR6Hh4cURcHp6Wm0tg/96Aux+kqWVPEzm82i0UQArTVFUXQMj1KDro53n4RA76xRYz2N3jWYCcZNqVJ1J8Fg+n0Hpjv83sWN70ZdIwpGaA1mwo3j0G8tCq30xriMts/r6cLcBYYsvbWcrt++QCGtJ1WU9Z/FPBP9S8tPb+Y1TcPz0xe8OH3BYrHgW9/6FpeXl9HzUj9vX4G/K7S3GwG/1obCO6V97/flyxCQTK2kceODYc8Z29d866kkPpkQrAVcNVniNcdoStjfF473FWlDAuu2ncMeCoYURkPrMqQdEqZv4oBWNjsmRA9lBcPD8BnaMJ/Pqapqo499Yf+YUilN16ZR8RxKx6XNB86zVKuor2unYOqPxS7wRSuqwe8Pazu4PYXRtRTyDcD4+nNzq/1tfhF/QxZLrnPQYGeW4+NjGmt55c4Jd+8e8+Zb9zg9O+f99z/m0aPPWK1KlsszkIqydh7vqtpwsVrz9NlzF4dcCUqDymA+c2H+sqxgsVhysDzCGAE0Ta2wRgM5onKcZ6Pt++fzwpBAegP/D6XpGeKOKcI33iUKiDZdv5/uXQj/5SxoU4GnC2vp/PM0aCXkmSbPNLNZzuuvPuCVoxmzrCFTFbOZZrlYUhQapZwDLu1Da6n/n703b7Ik1+7DfgAy8261d3X3zPTMvHl8O/nMRSZFRVgSJVEK/2PZ4a/gCH8f6+tYIf9nMxxhURRJk2/fZ+b1cHqprqq75AL4D+AgD5BA3qVrho/0PR3V995MLAfbwdlwoBw9AWD7Hl45KByPLATAXXJEKi6CRKIdocEl1U/DPu952UMgx/vnnHVy6ft3aX6a84Mh/sO9h+Bt5u0+NOFtIMkHRrR5V96TaK8xxjulC2GjMt7c3ASOi7sYxw9t74PTb3MIZ/wlghAHrZ59+8nXsQOfM8i7A445mrot7Rj9fqj6xmBfGfyh59JDz/cxg+vomIy0bNe+HeNxD8mb0gWl0ufLdCf8pUJRKBRFicmkco6scI7aKnBmGtsTqF7io2Men3CO95o4auuufZOSE8b2ll1kmFQ5D02ryag/piOI8xvsEEkmAYfgvgs9i8s2sLJMzJvkxoTeCSA7N+Iy/Jw5wEHEOGN/rAPjdRwCX4a+YbR+4MGJ7ra97tDyxvRNb4sXgTbkhHGEbWDXAVCWJWazKSZVBRgNpSTKsoBSdEWyYYcMDucjuK7GsH88Cp+UAAzRgFi/bJWldFV2zMvTNYFd1+HnP/85Pv74Y1RViXeePsbJyRQ/+OH30bYtiqLA6ekJHj9+DOvbbvDZZ8+xWq1wdnaKxeIE2micnZ3h61//Oj777DN8/PHHeP36NYyxDvEvX770OtCu63CyWOBXv/wl/ui//X3MJiWEVPZwhuzw4TsTfPDODBASn798gb/8qx+je/McL1+9RF3XePz4Cf7FH/8zvP/+Ozg9n6GcKHRGYL0WqOsJfvXLG7x40WBTC2w2HQAFIbTXHVN/bqXaB9MJ6mvj5wwVNtSDOZ2UYMgd4a3h6DBzhCMc4QhHOIIDIciWYJl+z25ESn4CQ8rOwIYRKjfGICV/iNFsaWXJdmUzsC/zFCtZtimFbF/4M89WgEdsKHCOE2Q4BWDvmXen9jR8uELi904XM1xenGA2q9A1NZpmA4ESVWk9waUS0F0L3dVQElgsZrh+dInT0zl022CzWaFQAov5DEZrdG2Dut7g7vYElyctbm9v0bUdlCoxmSxgOuDZ++/h3Xef4urRJU7nlT/Jbu+FJc957SNvxE4Ltl965UOsiOi6Loi0A8BH36EyN5tNMiIHfad8/nqRrIEOTptCBlHhJno0lsE4hhCw3qZ/EtU07sjA+sfXs9WwwUq0luvABEanX6nPpFLOi19DQEIKmoNxqe4aJ2PQ1g3KssD9/RLL+yUmkwmePn6CN2/eeMGD7gKmtUlG9KCPEsqmpGGfgiA7maZfmq4uJyBrLiS5kyBFUaAs+/uLc84wuyg2RvvdC1xxv4XTJnVdzF71HAjCmVnHgM8t3x8iWifRfErN+4CaD4izcV3VU73UfBs2IEnEt2Qa301iQ3Lc9pRyf8zIG6fTrL/6+9uNM8JT5KQeNFeyJoxHcd2xMwvRWe58NplMUJald5ajv10gTR+FNwjuorwN6Xz4bldjgzxkPYwYVUedX/wnrdx4BSfypHiFbW3yWSTFDQnWE2EvhMFsNsdkOsP140fodIPH15d48flLrNc1hChgoNC0HbrWoO06LNcb3NxMXJhmA1lKlBOF9XqDly9foa5vUZoVpoXGcrXBfHaOlRa4XwFicoq2BYRS9vR23N49lPRjaccMrKlng30heCsoUTBqfg4Eifnatswr7VNCaEhowGhIGJzOS0wmJbRpsVrdwpgO773zFKcnc8sOmA5CaChhIAVQKOkcZk5xcTJHpQDT1Wib1ipyhT0Rb/dGh6gwgDQMSWn5DTbnDOuPnovgVNhGuRmH1PvhXtv3zf6l9S97ukbj4A1akTE75XA3oHMwnrcV7ovd5ns62XPLY6KAyO4Zh6pJv0jj0670cWydpa7jbNsWd3d3oTEgwXMfim8Kv1yZB/Xf2DjuMYcfEgaG8D3S2gypa8l2a89BLTWGyY0R7rTv0++ormz6hxzjA4HTSoZAPv2Bc30Uh2w/HFCYAISSPT11G5ofm6FYyrKm+dn4+9v3QUiDeR0kD/p3/vfwQEg//x32oherKGquPQnPIxeq4ODMmLNWrv18vwmcZoiTMIZEzVA342Tl/mfvyir6bnFlwPEj/ToP0wz7Ycy5KAUph9IBRLwQtXIbEZEqHY1n7DdJ4qm5thOPkaEzsZ6NdI+2GfssMscv7qCDGOLby6/EZHLenWkhDiTQfd3x73ic94ExZ6cvDUZks7coNPHscMfVWNIwKWVHFhOW2y1yY3IpqM7d+T2gn1Im+v3Q8PDj9PYgpcR0OnHXLk2gW7pK2MlCEFauYsg/jJOT8KR88Dyog5ww3Dunr/eHPIhWCUtXCygYGEglUFXWAbSaVJhOJ1gs5j6C9+3trdeDTyYTrNcrtG2DsixxcXGGrjNoGxvZ+4/+8A9RKIn/5z//Zzz/7DmUKnB1dYnF4gQ/++lP8eb1DS4vL/Ds3XfdYUmJtmmwWq2wXq/xkx//Ld577xmevPMEJ4trSPN13HzlKf7us8/w5vYNnj55gn/+x9/F48ePUE0KCCWx2nT4/MU9Pv30DZRYQ2Bl5Q8JSGlgtHbzXEHJAlJIdLpzujAb6dZeNS1DZkkAEBrhOuKRzLg8DNAO7LRUTu/rKLLhn9YmQNG/pBQwo5c2H2EfODrMHOEIRzjCEY7gQAh72jZQinjGhjOpTEFhAGNcmGEmJGxV1poMM+uVG+lMqRK3O8zklX955juv6EgZOq3wC9sh6KM5mF4GD/J6oykAY4TXlllDqwZMB6M7TIoCTy4LvPfOJUrVYbO6xWJe4urqDIuFNfasVms0TQMAKFzY9sl0CqM16s0Cre5QKOWvxSmKAkXxEX7/934fAIIrZ+Iro4DwtBbhTsr51WqF5XLpFV5UnjHGG3QpUoIQNlpJ6nobfg2Y1treMwv4cnkUByGEd9jhuI4pQyyzLdkz4RQs8POWWPVBOUF/hEUb09+PPgYphRFXGsX49xj26bkBSUgJ5fqEnJaEUjAAOm0A01n7nVL2+gm3PnWnrUDnBJzlZo0TNcd6tcbtm1vgxGA6mWKpln3EDm3gLhYHvD5LkMyZbWesCAoVVwlFJ1jYZyEACdg7hhXOz89xdXUFKSVevHgZGOe4oSi+Mz6OWuTrGjEI0XjHIEToqBKMIYZjnOqThwBOT3atyzABNTUeXllJv+GcGwLHqNAZxs99lqdXIDywYSOxtlN7zNjYxnOD5yG8yGmPfvM6NCnfXHptjL3HWetg7yM60jkaZdyVebEyn189R3OJaKMxxl/JRGnKskRZliiKwkeaiR1mcg4LuXan7pPebb6mx3BsbMfWyFgt3mixD4g+b6DVovJS9gdf0Z61MQcHMi8EvSD68q09QECggBQFPnj3K/jwvY8A2PlJ4x3zHXa/6yCVRDWp8Oknv8b3v/dDvHz5Cp3WaE2H+vYWp9MF6mWD1f0GVTmFMfa02a480pgBNeVsFu+9OX6J50/tpcFadvymoHJSey+A/toiGzVGCLoK0KBSGpXqoISB0RvMZI3Lkznm0wKr+xpGd/i9b1/gnXee2DXfdSgKCUCja1tod6VjURjArKCNhFASVTlJ0qG+w4Le85/xvpEGG+lGmvQJZiolx4uM7mkZyHLa0b5GtN44mrersYZ4FlJupnJQMTHvNVa8gOWBYtAm70gLHNZHQPoqqDgvx32fPW6b0XJb+ngscmt4nzrGYNThI2GwHMsT4x73ZYqnt/zPF2P+ieWzbREKc/0oWVkx7TsIr5H6Nfr+ykvOIWnq5dO8bLwPvM18SpaH2EH3izIjjkO+3v3bG++PFLWD09rMaCTx4HOV78MpZ4S98EzQF/fFP/P1GNIXpZ34+yy2dUJIVNUEZ2fnTl8gBzin6GjoWJF2IIl5El4eQI7NBuQcY3VWfX67x4V7jwCs/Mtb1wtSoROJsVc7InJO3qYPy41Tin4E701IFzh/vcu4p+XyDF/vKnhbuhDjF46rCGTbba4YAd4AtNEhjWM0PNf/hv2fqs64+QLRO7qR39W+wHEYyGGpfW6HSh6a7h4ED06aR/iL3PPE+Bovr0dyID0zZuscA8J5GMuOlgRawVGIXo/FcSD8+LNQz8cKY+35IuA3YLYA6PuFrnrWWqPe1IBmc9rtLUAYtZq+p8rbD1ikcf40up7RsKveSOa0ByUYLRPGHQYSKIXCBx+8jw8//ABCAG2zwe2b1zg/P4fWGjc3N3j16hVevHiBs7MzXF5e4uLiAtfX17i+vsbFxQWMAZZ3K5jO4Nm77+CdJ/89hBL44Y9+hJOTE3z3u9/F5eUl/o//+J/w/NNP8f57z/DHf/iHmC9OrI5dr7BeL/Hq1Q0+ff4c1XyG6ckcj66v8d/9yz/BdD7H7e2tPRgJg6tHV1BFhUYD97cbfPb8FX76s1/gk09+jWo6w+mJxMmpwGw2Rac1ulbBGAkpCqiihFIFNo0GIKFUCUChMwoQCjTLDQy03qBp12gae51323YQ0h50MQbodOecXsg+4mR7lDBGwDhvN+NpsGE02mkN4jE7wlvD0WHmCEc4whGOcAQH0gBKA0O2Woxy2l3I9gPYgYEl5mYPsDr3tJCTFzAEhEhv9/soFXK/eVlW/2K84j8WgrnwTr+llNAoIWCdTYTpbLQYAQhl8OMf/y2+///+n/jtb30V/+pf/jGevn+Ji9M5FrMZDIT1Utct1ujQ6c4pkzo07QpSKVSLCpUAVssVhBJQIrxepygKCCHQNA3u7+9RlqV3oBFCYDqdQgiBtm2x2WzQtq11yJlMMJtO0XadvxKIt9kY48NFrlYrVFWFxWKB6XTqr7qhvqAoMUB/DdNsNvPXMZGgRHjE/de2bVIxQ8ZkSs9P6PbjMjQC8nEeU/TTZ5x24IiQeJZSHAXKQUTKsGge8f7mfdR1Go22/d7qDkVhIIsCwoW51toZ5WDDnE5UCd10uLq4xKPLKwDAixcv0HUdiqLwjknB6Wa3ds1w2XuIjaOxYVVK5a87ohOG9D1WENI4escgpmDi33NhuFPj+TYGMsofjMmWtDk41IC3jXYNlaGhUnTMiObXC4bK85Rib6z+h4SxuuOxTq/1UPEiJEWjGNIWTpuovE5rHzmG5ivVF9Ozgt47g5YI1mg3aAfNXV4mAE9DAXgHGr6OZrNZcD1bUrGenWMYRB7JzY1hmVuTfOGw3bCcSx+fEuzhIds1phznNIuA5lRqDGivhtBo1mu88/gaT6+vYYzBm9tb/ORnP4EwDYTssF6+xHq5xtMnj1FWAo0Bms62mSsb+zUCd2pruAemlPnx2rLznuPN+zfs65xxJt4vtvatcGsG1g1DQEEIhUIKKAUspgKXpwXOTxdY3tX4m7/+v2DqJ/jOP/vn+OjD34MwwirrmtaeuNYGUhUoygooBHP2lb5NHNe3VWjn2zh+faNX8pshHrm1fxCudkDDurdkyfXL9nXK9qoDDH7Rw635UrCttn0dC3bZn3cxVKZw2KePv2ylcc5Amk2vtTNC9Txbin9Olf22uOXS5AyY+9aVaseDG8KY4Y3qDV8P955/iMDHhX4Db0HfHgCfMdi2Rk1v8dmKPx9bPi95n+R4jX3xz+UY4yvTbpAhf0A8LxlHV6sVJpMplCoCPihuR9wG+3u4tvhhmxg/L0+bfg3w61v9HBIikHdS/Rp/8nbZvkByXH1d7qBJPJdzNG/XNRvQKxE+y9XF+QhW4c5zYFdZelfYZU1xPYIfa8IjQjy3X+6zR8WRkIHgfESqFTAmVXd6jabwOcLbg+/TA7eGsTGJaQyt/dS4jvFsuXr/PvazQyHPFwNjnU/5KNrKzc0NtNaoVAXAOr/B9P17enrqo4/RmiS9pCEJUCkvtsR75du0KeAxxPDKcdLpAHDXJBdYrVbumcHNzSv8zV//Jf7sz/4ML1++RNM0Pv35+Tmur6/xjW98A0opzGYzd+11i2k1xXw+w3qzRmsM/vTf/Cn+9N/+W6+ruru9w7//9/+D3dcM0DYN6rrGbDaz+vnZDGVV4X/7D/8Br169wvd/8AN8/uJz3N7eomlbNG2L6XSKrmvx+eef4+riEuvVGt///g/wve99H8v7Jd599118+9tfwQcfPMP5xSnKUmFTb1BNCqiigAbQNK2LgGuvzdLa7itSVRBCAUbAaKDtOrx6cYcXn9/gxecv8OLF53j95gbkkNgag3XbYrWuAalQVXNIVUHrAhoa2jnX0tzo15Zijk8GEPawn5RHN4+HgmNPHuEIRzjCEY7gwAgBw72rnSrEaA06u2H54D4ku30aGpf3FRJ2BSHcfxkDTA7I3sGZeBGVk8yHNOOcUljZ3zXsFQAAXf1jHWGk7UOjUUgJ03XQukMr7H2txbz0TLfRLZTQMO0GRrfY3L/E7evn+ORjBSX+GaRUWK43WK43gLEGX3s1jAuNqGzkEa0NtAZ008LAoJIVlJQolEKhCkgpsVwuUa/XKMsSVVXh8vzcGl6NgXYGo6auMZ1MMClLlIVlmwoXJaZrW8AYKDIGwwpABi6yiZSo6xpCWI/8tm2wXBpIacNV8jGs6xpNU2M6nWI2W0ApakOHpmmgtfbOPZRHa+OFEj6u9BdHxhk6QQydAeL5NOZckFPq8XpS5XE8s/kIO6/c6r+DtVFICWF6Jy1IgbIqoYxykWGcosn9s/fB984u1bSCFNKe1nZ9umkbwABdU1vhk1Sioo8w4uLzbD3xwxV2XFHZdS2UIuOtVYL29wLHTjZ27cbrj/+mcmPDbmqMdhGkd1ViBeUcoPg6XFnWzyNbRN9XvZE6r4TdlTYH8WUIVzcgqTJE9LkrxJFOuEHBFui1wOGJLNM7HnBnq3itc4Vx27ZY1zWUlN7hr21bSCnxlQ8/hAGsc2DTYNM0vVHP1dk2DbSL+KKKwju3dV1n8XF1KUv4UJU28kXXdV5ZQjjSWJCzBN9PeKQbAI6Whgo6rvinfqJe485AfJbxcaOyeqc4T3kGe52nXegvH/pSwOxyDjAEwWhVJgWonYERwXfjYeslBTkFXOyMxhJkMBaAtvyE0BoQBkZ2WJzO8M3vfAMffeMjaAN0ncKmEbi/3+DmzRI//+UNXr5eoesMVFmgaw2apnPz2kZeKycTCKGg4ZzDWo3C9AYVIwDtjD2qqqBNh063KAuBTq/RNBuAHHalQVVNoY1AWUxhRIHb23tIaU+bOQrv/mlIuKiC/vQYjXdvABrulQJlKaB1C2M0uvYWdX2P86szPH50gdNFgWmpMalafPMrX8cf/d7XMJtOcbI4waSqABgUpfL7mh0nja6p7XcYq/4zbDUFKHADSmocdzOoxgZg2yPuFCX6/tB+z+pPzdJaF+50a2rexIalXeexAADvkBSWnbtWLeXcwOlSvjIRfPYUaEeg+eLqGrv2Ldt+tt+Q8XTwPpWNlZull1G/jCnzc/jl0n9RxrZdjbTbnELiZ7HTAI21YP0f1ywSz8f6aQzfbcD51l3T87KN408OMtTwcmxhqaMrvPKgfwdrbgTfbe9jPnpbuWPg2xXxyr3Uls4zeJaZaym6sy+G++bblj7nYEJzeT8+2Xi+1waiDRQgg3LIcWB/rilPe8dKIr2KZkZDOvgyn88HUfP66IrSO9uYsLDsdbd2faX7ln/GtInWk2A8hT253vMaViUUPLFXrWbKBBA4zgvhjj2JXj8GY3xk38Gou/ea5DUv4kQ0MqFr8AdHvFxkZXreYgMDaBPI76w3Aj6CQ26sY2k/pjc5fUjq3SgdkiJJ/3TXWj7I5RdK9rTFdWBMC7gOYF/IOQQplZsP1Dag78Xd1uDRaWY7GAA6159R/2291fRA4PI3/Q7RCPeobTyebZN/4Xn6bbNhX/0VpR4/BpYoh/CKyt1Nxz/Gh1B5/aENe3i0c3UagOix0XhzfwO5lIw372k0jIExNoq6KkoURR+JVwrl6uoj+hK9sHLTnuvOycSexoNIqPS0XusWs8kUxmg0bYt60+CT55/hdnmPzmhIaQ86XZydYbNa4asfvodn7z2FKhVu7+/xV3/zN/j88xd48+olCinx4Vc+xLvvvIfLqyuUpXUoQjXB6WTqrgoHjDbodIe267CuN1it15jMZyi1xk9+8hMsFgt859vfhjYGN69fo65r3N3dYXGywOMnj3FyeoKua9DUNb72Wx/hT//Nn2Cz2aAsS0ynM0wmFYpC2TExNpoOHQLjOigbjI34Z2CzqbFer9HUNQoA71zN8OR8Bv3RYzRtjXWzhIa24rUsYGSBrhOoa42imOCnv/gE3/vBL/D6roYWyu131mnJD53oIEU/s6VwkZu/RBXVP3Y4Oswc4QhHOMIRjuBAQ6DRVsi0CnqnNJASQkXGBTDjEnpJPVYa5+EwI1Rc5C5l0KmesJyh8o3/Do1oYaXxaaj+vbLhsbWGFBoSBjA12maNQgm8e32Jk1kFJYD1eoX1eoVCAdNTgdXqHm3XoutaLO9u8fHHv4DuWnz04fv4+p/8Hq4uzjGdVjaairbMPwydbmJRY2CjjJCiwBuThYTRBq3poDsrpNC1HtzIHBtgpQgjtcSnKbiilvebVApKSkynU1+P7SsdnAaj+pRS9gQ9bFQFco4hZS1Ff0gJoRTOkcYidtaIxzU3D3j+XHo+bw+Zv2N5wjnp6ve1huJncm15RR0gjYQRQ6FWyDhstbBrnZTifiFHSsu438W4QTplJAbCKAr9OPVtNiZ1QnBokNpFSb5rX+8Db2M4f7C6nAHVfk1/PlRd256njIG71JVTNJnody49pSHjaIpGcwctAqUUirJPHcuHAAAgAElEQVSELApsNhsYY3B7ewtjDD788EN88umnePLkCU5OTlDXVtivWUQYolVaa9R1DeXeEf0sqyqgXfyKJSGENx6M9cNA2R8942shVr4Zlp4MEzKxdrYZduNxyb3PwWF7e2buMOVULn3KcBnjEaYZb9cXtc49XgfVR7SZG5ollCwwnygspnNobSBlAQ2B1ckKj88qPDqbYlN3lpcrShhtYISCgYA2gNbCGo+EdSBbLld4/foWv/rVHdbrGkUhIZVEa1q0bQPTdhDQOJ1XeP/ZNZ5cfxXvPr3AybxEWQBFASzXG7y5ucX85BynZ1dYrmp0ncSf/d9/gZ/9/GOsVjXazqDTVslmFVzSOlFKUjxqGKMhbJxuSGkNWI8eXeG/+e7voCwBKQyE0NBmjaa5RaEMTuYznCymmJQFjNYoiwoCzkCnJZqm9muRK7/J8aU3wJAdxhnRHsCmEfMWQ0MfW5MiXJ+59UGmZ6/AjfZpRGWM8zdU5nCO8vJ2bScvb5Rh2BFGFfa9Fn5AD3r+OItwXFH0OkMbjbHzg9HoXZwSdt0rx+r/ImFX3FKyU6qc7XN4BJcd8dul37dBLD/skn7fOnLlGIw7CrgK+roifPfCga3jbcYvLocdCmQATz4fgUPG4MuAlPyxTafwEPVt44PiNPv2zNgcoHlGPDXxl2VZYTKZePmd8CGnmbTMLmDIUXYHCPimgOQPo1Ll2sLXl/Dyq1sHgnhnJn8mHDDGyuf4EPD17HUSUVkCImnJTq3L4Fm8x6H/PdBr2BfDSjIw2DczbY3llFSasfJTaVPyD0B2aqYs4HJBhgbmZMeHgHhcBJuctg2E9TD9WFlHyMMhlD7LcxzAx36R82kf2HfPy/Lze9b1Re61QjD9Y18jDOxhpA5dIg85odori0XbQogNiqLAdDrFYn4C4ZxmhAivv96Fx8vJGym9Fz+0pzuNpmlwd3+HX/7i5/jrv/xLfPZ3f4fZfI6zs1M8ffoUH330VXRti6vH1+hEgdvbJdabFgLAk+trvPP0MYpCoqoq1F2NT379KZbLJbpO4/LyCicnJ9Da4PbNLeqmxsXFBS4uLjBdzHHStv6g6cnJCabTKSaTCQCgLAp0XYfLy0sb+X2+wKScQMsSWk1xOnN7JV33nZKNBDwNNtLKxoa9ExBo2gYb01iPMCMArVGVCnKiIFBCmwqdngIwLtKxcK6dEk3XAUZiqp7i6dUC60Zg02o0LbBcbnBzc4eXr9/g1etbCFEGOBphoIWNSXOEh4Gjw8wRjnCEIxzhCA5aKbEyBpt6Y69uUc5r2jiDCp0K0vb8rfXkBYxuURUKVVGgVMpGUdEaQtvT9sZod7+w8d6/gFP4cTbe658FrPtwGHHCCysixbjnGHkRfSaAGEBKZ7TDrAOF4rCe7jZR02gY00IKDaUMBDSaZoNJVUDrFkCHaTVB06ywXt5AoMVstsDJbIZJscF0UkFhhcKssFjMcXpWAJdnKEsb+eV+eYcnF9bY881vfhPf+ta3UVYlurZziksXVcLAn9SyzdDoOmdkCoykwkXv0Hbs3Jg4Xb+9aqSumTDheGF7tBtaN17YECK8UoQLH/H1SeSBDsOuSHH9bbSG0dorcYQQUC7KSduw+mAZfCWj0LiRocQaL8JXQhATz58JP9Z8CuUEokD55a6e6CcLn3PC66CHijWeJ6wzr1CKy08Laal3PT7Uhr7M0AAXjt8uSrJdYZsROid4x2ly4W63lfM2MNrqLfVto0I747Cl/6SbbFbJ21PRnGHPTsH9DUr7Oknsqpjlc40Mj5QrWUakHPXGHl4eX09Eg1xZxtEcbQyUq7frOtR1jdVqBa01NpsNNpsNlsslytKeUmqaxp5UkhLaRd8SUgLChsXVLjKNlBLaGLRdBwhrjDcAhNsLiT4UUvq13Tcxig4U0ZfY+Bt/J9BsPlAaUuTE64jSkDPkNoNmDGOpxJb3+5S7q7HU1z1i8BmDXRVn++TJ5QMS7dzV4CkMYLTf1+xasPtmp22o4k7YqHKlFCjmUyxmE0CgjyQmBIqihJA2XLI2vdOK7jTWmw1u38zx+GKBzbqBKhSkkqjbGuvVEk1TQwqD09M5nr17jSePr/HuO5dYzCsoKVAo4H61wt3dCaazOU5Oz9C0Bl0nsH7zFNcnBut1g847zBjvmC2VhHL8nXEOMzC9w4wQAleXF/jOtx5DSgPbHAOtG9T1GVabJQqpMJ1OUFUVjAbqukPb9A6hnJeMFeApA/TbKJsH49kzCcE6Eey1HjF8DaHfy/s29GVR6YxkDtIlcd6WYEcIef38e87XEdpjRvrA6Mj690s3ZexIAx7agP6bAllHoh2eUf5sT4y8i/s0NKgPjdLbZvI+TjI7wRivy3id5PsMfjnY5vCSyRTwCrwszmf5dUsEJMGLvM1+Pwa/iWskdlwx0fexPG9R6W7v2bwikdPjxseZkutebldKQakCUip/7Sc5fJPTNyCt86yUkFKhKJTLW6CqSu8cEzupZ2lEjldLtEkMUtinCTEhaCSvWyT1RpTG0LYc5Iv5gW0OJKm88ftkvoROwkeD9TowemPY8/QaztYz8j6VNtWuXLpEKeyz/x7OjT41Pab2pnAdw+FQHj2bItFNviUkZoIiEgmrZ6JsBj7yL43XIWTgi6Cr/38COycOo7+58Tp0nv1DA0M8wmia/vvfRxfY+gWEUBBSoSxKCCmhpIJUdBW904/bJWo/o2kxRkNivQs/MEt7HT9oGlyzLBXOzy/w27/92/h602KxOMHJ6RnOzy9weXWNsiyxWt0DRkNIgaZu8PTpO1jMZ1BKYrVe4dfPP8P3fvkTvHz9BuVkiqurR6hFiY2RePF3n+HjX/0Cy/s7PH38BN/+zm/DuHonkwqTyRSnp2dY3i9htMF8Nsd8OoPWBqeLU9/utmndQEvAaaCUJAdYMN7C2YPAxz7kiQiaTYNmU0N3HUm0MC5GFEnjdu+TPR011u5SCAODFlcXMzy6XACQaNoOTSdwv2zw5s0Sr27u8OrNPT55/gq3yzU6bTHXAJquhTFDB6sjHAZHh5kjHOEIRzjCERw8e3aJr339CZarlWX8VGENiU2LpjWAKtBpgfW6RV1rGCNQFAJG1ziZT7CY2qt7JkpBasDUG7SbDTabFZbLe6xWS3vVj9boDAChAFhFjVIFlLAKG6kojKJlsKyBSANCArJ/BzMUVAIlKgAY4RhmptbzWqX+mWXYQNyhO7kMGNDd1BJGSMBodLpGoQweXU1xdTGB1ht8/nc3aOsVNut7dG0HKaZYvX6NerPE48fXePZ4jpO5QNvUKAqF2UxhUs1wcX6K09MzXFxc4OzsDJPJZKCs8My8Gw9SYllBoXck0bp3TLEKsD5cMBlkDZxh1TADt1M8UeQZ1nmWgRXwUQpiIwZXjpFh1gsMzuhF4RsDz344oz8pYyKLjz1R0IdvLsoyyM+VUbGBi7eZjOWksAj6UwjXF2FZ/KRALEjZT+qDUBmXupqBG+X2MSRQf8bl5IC3IVb6sVTurtkhjrFQGBv5EirPSFhOKSjTitKdjcOJvBy/L0JJQQqxXXAP3kWfQNgnWWX6gcpLCv0dKzWSTklCDK482hd2UUpyx5xttcVOHUF5URpgSB8oXZcwRkkp0VEoblp72p43aZsGom192W3bous63N/f40c/+hG+9rWvYbPZ4ObmBtPpFEL0UWGklDBFgbZtrXOfoxVCCEil7FVPm407dVt6+muvoqG+sgqJ0MxE35li1RgoGdKOtm2z/Q5YeqpN2pCYC01+8MnxMVpkKx4+zyi/Uwa/VNrYQHC4Ij8PuXUf0+Jd6xqj77k3Y1fKAAJCxvTa/nVd2D/BPmDcaWdtnV07A0jpItQJAUX0tACm5QSXp1N88OyR3aeds2rbtvYax6axCjWlUJYljGnw8rPneBEYe+y+vbyt8eL5K88bfPDkDB8+PQ/6JzX+2/eRjb/CT3cabduhazRMI6CVQL3W3plNSYViWvgINcTLULuoDr7WBjTtoSDe/xJJQoNbYj/2RcUnsf23IN3wero+HZ3pS0GOZzlUMx7nSq4bzov5Rz0Ofm042j5wlIzweygeIdcPtN/FdW0zSubw2uYMmFov2+jPrk6Q22AXh5KkA8YIr8ZNqf7ZDu2K56BJPB/w7ok6ckZnjvshYMDGK3qnR8bkEH44B3FZ2xyIuFzF+WDPX2ZkwF1m12+aQXEXQ3zuvRDR1UriYZytsjQB2Mq/kwMKn+tS9nPcX6EAQCproOp0B6ONiwQzQVlVULJAUZQwxvLG9qpke40o8bX0RwdsaAZ0XRdEUMy1a6yvqB3+rd0Ag3UdG8FDepiWQz2PzIydPB9vB1+3tP9S3jG+JOcgk5KdhvsVyYhcH8HbyPNTeUOeNFXHofJ2DNzxnsN4mWGfWVTi32C/aRzycmauztT+m+VhKI9J82CulHQex0/zZALRnKK0/P89t+Ev6lqhh4bUXvpl0/t47Idjnp4veX1Geg7mZNB/TJBeL+P8qu1L+O/buII8/7PfpVFWjlMoCuuwOZvN/AEn0v/wmjpPMw0pKpJXbKX42FhHSrojrxtifUHR1RaLOS6vLvCt73zLts0AxgjUdYf7+yWqqsKLFy+gTQspDZbLJc7PL2FMh+X9HV6+eonnn32Ov/3eD/HrFzf49u98F1978gzaGHz+5h6fPP8Mn/76U9zfvsHq/haPrh9jtd6gqia4urzE+bmEbjXub+8wm81wOj+1urDORrKxkV3cYZvRjuZ8tBkZ3n7drJb3aJsNYDoIGChpoE031JPHfe3q69dWB6EbVAooC4nZpMT15SWMuYYWCn/xl3+LT59/jlYbAAqdFtjUNU5n5XibjrAzHB1mjnCEIxzhCEdw8L/+z/8U/8v/9EfQwhlYpbTe2AJoDVB3wM1ti0+ev8EvfvUcL16+RqWAi/kEk1IA6CABTKsJZrMZXv3dc3z261/j00+W+PnPnuNHv/o+nv/6OV68eIW7VQOUM6jJDCcn5zg/u8D52RVOTy4BYY0cykUWgbD3UWrdQAsNqQSUVBBCoVA23L42AjA2H4yEMaT00JAFi/4BA2EAbbQ/SWUM/DUbWruoMqKAQQk60S1EAyFawDSYqBoffeVd/Ot/8U/wB9/9LdzfvcRf/dc/x3/83/8TfvKrn+H2zR1+8vo1Xr16jT/4g3+C73z1XXzjG9/Eo6trnJyceqWSVUpptLoFZG9k4sx3zKh7B5KiDN7xfEqpXtHkgIRYA7iT2yzqixCD3/RnIyu0gBA2Eg1zJqErnLzRmCmjYgOndoaNXY0/PCKCMSaIapNSwMfCb05xz9MDvVKYl0u4pIzJY4q+2DgQfqYV+bFzTqoPcnXxdlGZZETk7eFAcz7uI64MjMdCRGX15W/vj30h12Yai7i/4uvR4rHMOQSMGplsgVkFXaptwtHMeD7F+VOCd5xm1NCRMfBsUyD6dmVgrD/IgBIo5DP0idov2TrapmTKGtPY89w4xm0iWpEqh2hVWZY4Pz+HEALz+RybzQYvXrzAq1ev8OGHH+Ly8hL39/e4u7vDkydPXBjcDufn53Zfe/UKAFBVla+zbVs/N7uu8/haXX9ooKcTvTwiV4Cva1lZFKiqCkop79RDV9PxtnEjCb2J+z3Xf9yp8qEgNX85reP7B38f90VqzfB8YzBGew55N1bnWHmH5htbE/YKQtufpLTj+xt99v2r/W++z8T7Pc/LeQDAzpPJZAKllA313HU7n34lBWI8B+M9hfojdk7KzVEhrBMPOZJNp1PnwNOfmud9QdeTSTGkzWNrJMY1xje19/BPiu6XKieGHB/Gy+N10vdcX9r69eC9++KUyum2jvVLzGPEa5SXlcIpLiPFC9EVH7l+SvE52/iOQ9bcKA72y175xmAXfipOs8u8zfEsvHz+fehkZceHX6mZG+/YsDw2JpJ4ixH8d4F4/HNt5Z9cThnr913qTeVL0YhtsMvcjef9YF2z9PvO6W3r9ZD98TcFUrwrQbzv5fLS910c3VOwjfanM8md8g3WpCEjpkBZ2WuTyNklR1uN6ckZ7fn0nfjczWaDu7s71HUNrbU7ADTFZDKFMU7/AAEbxdZ4Xtce6Ol5FYqOm1q7YzQtxevE6y21Loiuxftb3O/9lVO93M7pWq7sFE657yHPK31Eyq7rPE/D09hy7ViGv8M5kKPpvN5tazU1D2lMYpmMlxf3iXC8VtxP26CPkJzmJVJ7yyG07lDYh0/cFXbdHx6irIfEb2x8HrJNXxTk5ayeDo7xtQQ53ix+P3y+F7pfCgRtMMHHeFrKYnqniZ3q2BEnokGhrrvAYrHA2dn51r6PaTRR91g+okOpvZ7eDP5oH9xsNvbqp8XClzGZTOx13XRotQPQ2D10s6khhEJVlTBmDiEErq6ucHt3g/v7Wwgh8PLlS7x+/RpKSpycnuI737rEfHGKn/70F/jq134L3/zK+3j18iX+/M//HM/ee4qvvPsUbV3j8tEV3v/gQ0wnUxTK7u9t06BtGjx9+tQeJOs6KwM73b1xEZGFFIO+4n2fkn9j2dTmsdGU267FarW0zrlCwh8y9YeX8+M0eC4MtAQgNKQEpDvkIQwghME//d1nAJ71TorGwAjgo6++lyzvCPvD0WHmCEc4whGOcAQHxjhHDWMjrMBoSGWF4UoAMwWcnik8nZ/iO+9N0bTPYAwgIMEvYSblwscTg8VE4p3HF/jd3/kW6j/9V9Cdi5CiNYRQgLQe4spFlpFCDYUPYfoTHGAMHOzJfsBGRzHGWObPuie7c/sGxnQgp2gy/Nrw/va0v43YYplmpWy4YQ2Dpmlsv4hekSQATKcVCqUwER1+/MOfQesO8/kT/Lt/9z+i+ZMGXdc7lsznc0ynU1RVhbKsYJSEdjYKIwAooCiKpNI/Zko5CGuZdgy/gTbaO7Q0bdsr2RizS8ZsoQooCBTCKiesM4tGYRTsFQjoeVo6VSRcFBrjOtIYdMZdHiAtC9tqDWjTR6Mxhik9bKMNxLjhfuTEc87wY3yH9GIafQaCkM3kpVTB0hHETkux0julkEopCFLKg9gQxn8DgJDSBsR0aVPtpTzjd/HmhdFYyNkGY0rylEEgpXjmgug22KaMIoNNTrEf51cyvALOaxm3aSoyCpGcEcSPAdO08HkJPkdMFDo9Ucc22NdAESv5BT9VM5ZRMIOWCcP106c2LpIUzUmtrdNlos/y1Ryo7HQ4SSn9CVqu3JVSWkV029q9wl2RdPfmNaqqQiEFPnj2Hp4+ucbd/T1+8KMf4v7uHgDw3rNneP/DD1G5yBqr9dpH95pOp35/INyLoggc0gD4qF8cJ3rPnQDj8bT0s0FNDjLG2Gg61MeUjn0HQkXGmPJ8lz5P7Un8XaxESuXvHTwLu394p0vNnPuG+No6R9HbCjFOY8bFLwpSiqf4fc7QQ7/j+QR0wV7Ajdi8DD+3hHKnyaSP6kY1kMF/YIQAoJ0jSgegEfbKRCElhFtz+67YHM0xRDcdqHhepgw4GM5JUqam+jl07A2vWAj2BcKNzRPeVlqnPLJe7LTp9yCp+thRwtIme/2V8fuAYLyG5c8kHMud5f2S42z6frJFx0prVg7jq10Mx76Paf9iPBJYH1Ff8Hkb9/nYfpyD2MkizsvXAf9O9JbqJ2U257FyayuGbZimDHXx810h1Z5dy4v7OabFvC9iXI0x3sGO0gZRIVn76JPqI6c3nm+AmyXyXk4D0DsRx/xx9GwfyBu6MpEcEUZ2SfHqh8Cu8zuu49A6c3ta6vnYHrfNuJQCuWX95ECzcmPj+sER7g6AeE3Q5y68UgyHzNqUvJlLB6LtgOeb2FuARfikyC9FUWAyqTCdznqDWIYnyPMb6SVJzi9SApNJiaoqIMSJd3oxxqBpWnSdBiCdswmPpuh3UP/M8n+tx4PaMiY3CoFIbuaOb/A9bEyKpzQQFDk4oLf91aR0xZTvI4e+NQW6fdEIUmewvrLjock5mfE09gpzA6MNhOxlEsvLGShXQe9Ya6CU7T9qbz8n+3XE28v7iwMfdy8PbZHHcu9oTlFZsSPzYG4BADSEJQBWd4ThnBvUT+MTpc3pGqR0kRvYFd8DvFJtEruuyCPkYGwuxfQ20A2Z/eQHP/sP36qHZY7S+YfhD36TIJYI9sn35YFJbpQ0VEVRYjKZYjabeV19UQyjmhGkaAfJS/aRtT9YvlgHDp0WEdIHG0fO7bvptMJ8PkPX2T2P9EJdp3F7e4+qKjGdCgipIIsSoizw45/8GCcnJzg/v8BkWqGaFXj+6a+xvF9iNp3g0fvPIJXAYj6H7gxWqzXquoGUEhdnF/j93/ldzJw94fr0FE+vrlAWhd8jhBBYr9do9BrrroUBMJ1M8bNf/AKLxQLX149wenoKu78Q7+4OpLo9Cm7f8ryeMf1BWbh9Tdq91lCEUiEgCwFoQGugrmvc3t3CAGgpar2XL4fR2VPjFTwz0loNjIRuzYCWC3/rgC8EsEelk3UcYX84Oswc4QhHOMIRjuDAifXuuzPG0Ul5OAONMVAATqYlgAoagA3Kwh1VLPcyn06xms1RqAJKCK8wgGe2UkwTE8C8YceAdBfGG9l6Qxvl8+Bw6F/FSjmuTKETTaHy2MCgdUoU23aLgxDCGf+sYn61Wts+URUuzie+DFIoxMavpmks/l5xSP+FTH38fcBICoBuT4YQEEZ45wCraCigjUHbtWidYdaKAE7ZISUKqazjkBSQqoACoF10BDJqwpUV2l5ChRaNh7WzaH9NCles87S7hPXdxcDO83ROwZJThCcF+4RAz43asWImVkLzNsWK16GBOTRKpMbUOKGE+jOlxI1xi/FzT5L5xj63KddTfZkSRnk5hxiUdlFWbzMG+HTur6dhYRmpz204jLUlqZBmuLCEAPUVS/+2/TRWBinhWeIQnwwE6uZcv3iFdTpKhK3i7ZROsYGR8BHsN5iSlZ+gFQDgTrkWTsHQNBuvaKmqElVXoSgLfAiBzab218D9+Kc/xfX1NeaLBYzWaJrGh/wtisIbH2MHtp4eDMckNdeGVyYZaJ3pMxHunH6bi9bkNsX0NkjtQ6n3XIHODak8oozd9/JK7xEs+nYKkVxjKWMhfcZ0MlXfQxhPc+UGSuIIf9pnczin5gnxKjkanJprxGJwWjQWvYzSCOeMoLX266xQCqqq0HWd52Vy130lCu+/xjjy/DvwAkTPyEltrC3hMw0egMrXzeYxmfhSZfWRo/rx6LrO05veMGwdwDfuFD7lJaceSqfAxsINknegydHyiKfskfTIemOenx/0PNjvhLtRnvFOUb2W5+5pOV1plXIozvErOUjxCqn32+ZW/J7zm2OOIEHeHebvkLZnxiFR15jRL+6HXLtz+y/Pw6OYxTgTpCJDxk5fMa9K+GzbU3I4ptbTLpR2rM3JejK8Ic3/XFmH7gGpcU0q/TN70q4Qj8Eu5R6yl43yt0hfF5iUraJ8xJdR/+xLH94mzQCfLet2LH0uT4o3ivPw9vM09I70CtyhTRvjHGGmfq9LjTmtYaWUP4CzC71IrWch0vy7LbOnFf0z6+xRlqWnJ6E8IDzvl+PZUs85neXzhq6aAkLnGduMcZqZ5CUYveT95tO6D50YU/7dgPH/KTopiH/T/jfVw/u7N2aG84bvPUqRQ9SgOYO8vO1j1zzHMhxvI83LfWQKA/hriIQQ3hE6hRfPY1jGlMw31t6gfj9+ebk1le/vA5I05UBXhUPbs0/f7pInu6eansPehZYC/R6yS128XPv4kP5g+uMtuO1UWpaXP6i4Lw8EMnr6tyw2yw8DGDhZ2sNIRVGgLCtMJlMf+YyXFdMvu1cM5VxjBSMIKaA1ep080WMA0AaQgGD3qCkpIVj0K1u0sgd+lULTtGia1v8GBO7v73Hz5gYv3rzEo0ePcXlxBiUVutaW8/jxY9zPl5BCoCpLCMBGzS+sM1BVWef/BRZ+XweAoqrw6PICgEDXdajrGuv1Gl3bQHdtL6dqjbIsoHWH29tb1HU94MEAd1hA9HIh7aVCEO3v7QFSSlxcXEAphdVqheXy3uNF0Xnqug7X61tOdI9qbj0PPOl+0xfWPyw4Oswc4QhHOMIRjuDBOsyESnbS49t/PSsrAGFPGweHVwM7rIR0f0JIaHSesWEyUwTCK9cIB1K2APH9773SNRD8fRQTpzQXuWsnJNkoIJTp8xrbwuCKIWngGXkD6M6eGOobEhpaUoYyAIEhlxRihv2OIS0IGpDTEXWSNYwJuGtS/dgYo3yfGRpQwEb4MYAxAhLulJitwNXT5yHjlIjwiBU5IY5DSKXl77i+K6d0TisWwvLjtNuE3Jyyjivskoq0qM7xusygz2Ich6ct00qAsb7J64bC8PP7CP7xHO7xzI95TjH5ELCXYsdKfIP5uc3Asa2Obf04ZjhJ4UJpyZi1Dfg839YWSvc2kFN05xSfDw1jRo7UOk8ZAK1BwSrztVbQunOnivpICZeXlwCs88fd3R1+/stf4p133sHJyQk2qxXWy+XAoD1mfDAGkDKt2B5XNgIpFeG+4zg2J3bNH55wHe5tPCoXPeOOBeEfgrwxpMZ2jKbvvmeG73bdG3aBsf6N+z/Vd7ERg+fNtY87dsb7wqAMkNGqd2CNxzNlOIn3PTLIlaW9G5wieXzRUQKye74Zd4jI7Unx3puqI85v6xuOhzVeKX8t1GazQdu2mE6nmC9O/PVs8fVQNIapiDixU04KR94WyzsJz3vHSmP+SeNvfyA6JT+si/Mqcd/ECuocrql3u667bbRrGx1O4c3T+nc7YdPjlKNfcbosr5vDY2TMc2nidqfoQlxOKqJZrq6YBsT1+voT5WyjjV8EpOb8tpp26fd96k2NPR+Ph953HooPG123B+RJwS6y4qHljcEuPOQheVN4xHwLXc9AjtYUrYmcEMjRhfYF+rN7bO8ER9cq8T3kEPllH9q1bZ80pt9Xdouh/vgAACAASURBVOFfYv6D45vaa3i9FneZzZNKn8In3r/G6uTPYpxTdJw/G+Nzd+V/9y0jBbvIiPR+jKc+lJ7HcyjHm4lEmpgXicu1/A/8gb2UbPwPEZym7x8nWKKx07w6wj9uCNaoNyDQZ7j2u06jrmsfESzW7/hi3H5ETpz0rE8AHzWsg4aGgW77/bgsS9Rdg/Vyg816AyGAxWKOUkrMJlUQwY32JNrbrXOrRNPYqDOqKFGoCkVRoigqSCGhuxaAwWJxAiEUdNtBCljHFA1o2EhtZC+IaSbVS/2xXC6xXq9hTHgdeV3X3rmormvUdT3sfwBGmmEEQWEdM6tqAkCjaWo0TQMhJcrSOgqt12ssl8tgDFN76q6Qo9ejdNyqN9LPj/AgcHSYOcIRjnCEIxyBQFiP4lC4BaS0p0q1D2XvmFh7ZAZCWIdsY0xvyTAGQP9nA79zDsbADLyCY6aLGKW8Q0Zs1KG8/Blzqwmby95Ru8gwAiBwWrZ19mnpdA+/gxvOOGVD7eq++QI+sktZlIBAoCzzVxUY4683IfxI2csxF31smWS7qO/Ja70sC3S6sxF+WHphOxi66wBDLDq1V9rrRrVx82KofEgZZrjiLHV6fuvd5E7p0T/kX8Mx7p2GhB+roCc4brGiJfo+6E0h+k/2nYDCKfeCgXC/XRk2Q9iUSOGzTZnD38eGNa7sC9fGoPnJ8gg/wtn/RP/cP/LrKCgt2ZaHUtw/KMSCG83lEfw4HciVFb+N84wpg5JCPHu3T9/FBrKxdDk4ZKxSyt2HGvMxgwb/zpUkqegP9EdK+qZp7H6lgbatUdcNtLF3YZeTCu16A2OATko0TeMjKpDBmwzgOaUv0b/eoGH3udTaTykWhmNE86T/nRpGp3/s5180vwL6xfEY1MSeub1Id513YvURJlg0GaqDXz1Fn0FLRuZfTy9T68LS2jHF+bA/ekUaL8tGksvh8LBK23h/TDnDpfbUmLaPGU1yZXDQMJCMieCKPgI7v/spYt8Zd3Vl73BsI7T0UZWAoXPa/pCe86xF0TO39/vrI8O9miFr+QPiI9ncCucZnaTbjmnP3tqrLKWUqMoK680GMMDa3WtvDDCZzUDzlgymbdsGxk4yovbzRLM5Eq993yzQ/uvnCISL/iBcu10abUNqUzlSsCtRJD8VPyyfgK7dsH1kPF2D4HM8ZRALo/5xGrTvTNmHb8rlN8Z4Op7iXbfBvoZpni82QMeG1hSvkNsDU0ZDjk+Kb4zxTTm+DOqg5/y9TZTkCUleSbVhrJ8egvcYK4vW/i61vM0eEMic7PNh+CLiyfPt3reOXEsP6YGt/baFl/4y4G15ZF7OWNqYvtCaIGfTyWSCikVpA+DpEp8r2kU03Gzs6XG7rxAdk+g661CTi7Bm6wbGR5Tmafws5r/GQILLjP3+ZD9Jz0G6HPud0nA5vucxEfch8YbCa2mC91p3vU7GlWP5Add+XpaM5PWY/gU8s32d47GGMgDphYa8RlBHmCu9PNynNhqkZ6Jnne6wfaXmxi0tQ1j8R3BJZjKj08NxVwGq9FuwMTDEq8GpnCTnecOoir4czscBkEyC6VmYPM388oFwH0ha2dSH7Bq/GVqX9DwCSKcU6pySUUxE/2HwFv2RucdpyEelvydyjryL1zrVlU7ddV36xQ4QU+jdZtVvHoT8UZrPadvWHUrY+HfhGJHeRQQHO7SeBroTymfAop45OWaz3qBpGqjCXvPUdi3u7+/w6uUrtF2L60ePsJhOUSiJkjm3FkWBpqkdfgJad85ZR2EyPcPZxTmurh/hk08/RSlLzOc26j4ANHWLriGn2QJAB4PwKtke+v2V6l6vV1itVvYqprZxUebT/dz3MJN9hYsaqASUkwfpakAB+24yKWGM3YfargGg8er1K8DkD5IeDCn+/e1LPcJbwtFh5ghHOMIRjnAEB0o5JwkGpCRvO4227fypWH9iXwAo7HVLRveGaK0NBDoArf0zwlopvQJVMEeWHvJMFwnQmbcR4xYoU7xTS1h2q9PCty9Pp3EhxTv3MtdaoxDSMqPGRqDR6AB0QZldx04VQ9qrkcq+rLZtsXFGlVxYdADQSCth7d3ALsYOUxBKwDuVeMNupGgzztDilRDGAML49vXGkuHd6AFuCacYSkfXmMQKJXsPtcXZRu5xOLG2c+NhXx8pTChCDTMOMJxjPPx88QYnloffo079YBGgJz4sNC9fqYKF0+6VlRbvoWEipVjlQHfrxgYWpcLnseF9zEhBuAT9QOPp53u/VnxZiTEXCUNpbOSN6z4cDlN6tW48fClO6Rg8AwanK+I0WaGQK1eDx0MjVfw8ZUjZpozPwbb0KQX+LjBmnIvL4nMwpsE8/dg8iJ0DUgYoPr+4sZ7WBYCBwoGiYbhKoIoCqpyikqXPW1UVJtUUdV1jtVrBdB3OT07w+fPnWN7eYrPZYLVaoaoqXF1dYTKxV/A1TYOyLLFarbxBnHAxxmAymcIY66xDtLG/87rzdDGO0pIzPsY00Ld1cPUg61ceJp89j08oc3qitYbR2q8NapdUiu3j4d7Ax2rbtT/xuLu32TRj62gsbZgPg/2LOyzsszZ4+eNtsjDmQJTqP45LKpR+3B+kfI33gUJI0hLaLRYG/V3i5BRjXPQltkaFPX9nqxHoowN2UKrAZFKirpt9uioPTKmdihoT0hUAxtgQ/0EXR3SeXRtECa3SPT2+8bD7dkfrptOdM2RuIITAyckJymoCrTXOJ5eQUvrrOrmDRu2uZ+JXl/FruXo8mFMLaw+1nxTKnPZpba/CJJaIjJJG2vL8PDIG2mjrPK2Hc4joltb9HDTGoCylp1dlWdq5ZhyuwmFEV7GZ3unbGnOtAtbAhjU3xvi5aq8/Ddvovyf27hwNyAHfhzhditc531Pievj8i8veBnHULRrr0ElqPBoMpeF5U7ilystFfUjxbAHeUf1UgrCMbP/dfsm2f1sfHUJvgbyhKaZ9Hge3fvlcG9tDsvxeVFccbW7bHM2VS7JMri+4LBFmjRznIt4hh78USRNlsv8I35SsMiZr+DKR5gVy+6Zt1WGQ678cP0p5cvv/WHm5cmJ5jHi/tm2xXq9xe3u7d7sIbm5e4+ZmOy6EzyF0a185jeRu3o+p/hy827MeX98B9CLOP7a+Pb7or2Hi7cmt73js430mJdsZkzvOtR3Mgf0w1n9ja0Rl8u0SYTBHl1P7M80lRH2Xopm+XOT775D2PjTEtNPYh6N5ts3z3PtupE35/WV8Hx6bFzkak8UBu831AY+G4bVou0Auy9h8OnQHOmR/PASoD3n5njZF+w+nZwe26gEwjkpM8j9U1XB29NMg1Qo68NCh64CuA5oGWK9XuL194+ciyf1SSu+sJ6g6AxfBbYpKSGzub7FYzLG4vkJhOrx8+RLdegVdKizv7zGdTr0uezabwZgaVmRpcXd3g6aZuDT2aqWpKvHB03etDNDZP8CuVeV4I+JpKVqpJYHSt7eX/Ww/1PUKd/dvvFypdQMpC6QcxOK5bX/b50VRYLZY2Kg6TvdV1zUgBOq6xebFa1Z/f4DUOtekaX9WjkqOLssjh9HjaNSP8PcHR4eZIxzhCEc4whEcdJ1Bp0nYFwGTKQRc2GAFgz7qjDHWOUQK4ZxtrKOJFvbEhzSAIEO8i1YCAevYIWL+WPR3pJNCj3NXJmQaY6EzUOqiVygYs5vAklOKxCBl/156j25lo0maviyu5KZyeUhEUgpUpvTMKwBMp9PACDlQPgkBaQyMCB0ucgr4Pr/0jLIx9lRW+JzK668QsR77ll1KGXdIWOH10/f4Wo6+/zL3ylIbpcuj+xPKpJQDKRtsJidJ9QaaVJm8v2MBU7A5QoPH04TjJ5kxajg2gdDK2i2E8I40OSNN3zfCC0ncmM2jAnCHI96uePxTEQ0kMyL6+gF/qs/WowNDS1JRwtoXGCHQrzuBfo36teqFrS8GYmXmLgaZnDGAQ04B4sc0VsAS/UrgRe+Tz9MIjhqlxtL6dcOT7Fov5Wct8aPN6Bz8iSATnA3K9b2Q7CygMWi7DmBRW2LaRaFuif7EYxyPBf9MGSgBe291URReWWGMQe1O8AoXyncxn2Mxn8MYg08++QSXl5d49uwZbm5ucHd3h7qug3ronu2mabwTTVmWaNvG3QHd46mZQZmXwdcuOdH0/RLSKTjHPSGc4b3rldepfsztE34N01zme7AbK09j4BQ7iXWQUxYOxn/L/rov7FtWbHCO960xOpBBIKkEMqyM1DoUQgTjGf/m6egdj/DC+5nmDP/NCgiRisqGM8TGRmh7fzvVQU/tKT47z+g6oi6MihIQ+L7CoigBGHZFpP2zDlnSJ6XoJb2iEIBz8rAOHzZanipUrzSmNjMFG6fFvk3upyHG0xgXHXHc6ENKVusoIlGVExSqtFEA6tbt2RodOlc35xMFTQAAQNva/VsqCSXDiCfG6MHY0a+6ri1NcDzAerNB5SIWSCmjk/z9XCYawqNjxZFWOJ8RRwYEEDi49OX0V9w1TZNchzH/QY6Lqb05qVyN+Bz/juXV3tF3yCvHznExTp5HRb+LSSn7OUN9Ge/n9G6ERnB8ubzA2zpmcIohxTfnnMvitu5juBGsrXvTwj1hGz4ppfsu+MQ8Qsx35vLnDDlx+ngvjfNw3hesXgK5Y3/ytTncv/lWHRqPiefO1pKZuzE9CJ5T+/hzsL5J0V6GS1A3B74GeBk53CNI0Yhcml3m2y71JfsnnnOJcrfPW//Nfw+3g2E5uTal5MKY98vNrRSPlJJdPdLG7s3x2PI14PGK2rIv7EoT4nQxH0zPYnme3mtq04748rLGZMjUM/4mlo+z9RozXGs75DtkDfC9OO7vMcf4uK64j3mdvvwww+B9si6GZwzbnCzit9vm567yRjAP+NrxFXG+PC07jdWUeyeFOMiZ6lDauM+VrAGtjn+P0Gjj9qtdeaWwzuGWQ/V90WvnIeXcuNxYBtzGUw5wZGUE9IbqSNQ5Wt6WdKm08f7kZThOFylNslxLLRMzxpWZ5rW1MGihsWlqrNYrrNcr6E5jOplg6uSp2f0cZVliubzHm/oen928xOf/9TM8vnqEi/MLzGZTKFVgU28wnUwwmUwwmUxxcnKCyWwCKQWatoHuNmjqxsuFIYosQrn7pJVvW6UhZH/ostMa69UKNzdv0LQ14GRXAycP0+GIaF3Zg7klBOy1wSSDwxh0dY1N0wz2wRwPw3/HcykcAhPy3Iky4hHzZST2DY7Dtjl+hIeFo8PMEY5whCMc4QgEBiDvZH7C1IPj66RP7hhVIdBpYmiJ0bWJjfuTEICQ1oPYMcVCCC/Mkj1BeONCXyVDz/GBofCZZeTd+zGltk+bTJMuN6XIojJihUl8ej2l3OkdV9InAwenRBN4pwxoQ7x1IED0uFAeahtXRoVRCHYSxBjevJ6+vba8+DoPoGeqtTF+mPmd5cOICHRacii0xf0Q4Oc0skJKF9HGzl0hrAOY7ysyZkJASE2dNVDYkWEqpwja1m+98ZqQy7clLs8r+JjTQW5NxMoqrfvQm2PpRgUocu6C7U8frYUpvwFklThjiuY+Tfg+JQTHONp+2F2Zk8Inh1d2Xm2jNVwRxhXYqbI5Hvz7tjWYoBWkeCAla7K8BC6DecHUKWE/0Uph9Dyu3zclcjAQIqk84/Oa8gVlCDGgB/w3pSfHk45FLJDCRlai/hK8fGNP/UinODFa4+ryEjPnPMMjRBCufWQGuxaapsHt7S3u7+8xn8+xWJygqipPJ+heaWoDRZ/p16+9wjCI5uajNfR/bcvWPtKQMwL6vufjL4SfKzKan8ZWNCg/pbRL1RvnSdHQTGq/R+1SFn8eO1kJ0Ufz4ePF8e1pcYIHSmKXVtTHxpB4bfaKfBqDkC7b+unqI6cYNEP6H+8Lw72B1+MzsXxAcLWkA3IG7su0jhE2qkw/N3tHL8vbGWq0sZFKtNtLpQ6oh+/frmN8o59/QMAKCgDS7tMSAlDkZNPTs74UZJSr9N5AGEfL+H5LFRsXmto5rRrAO+tYGsLnhOMboD3vyo0kfvUQabEMi30nJTrh5r7WPa/BnGboFD7V5mkEgKoo7VWpnfZ8cM5JOTZUpfhFbizdZoQk2hc7hMcQOvD1z8ecpnPlxTj1bQFSvHqKH4iBr1E+f+LoB8TfRA+RrjlPk3LAldQpfjGmUdvqSBkqY/yy5bh9IE63KwzHZ8jfxWn499x+ksu3C46cCqbK21Zmni8d4gwM94Tk3An2B8HoxZC/5XtSj4vbF5OYUYqw/oAPHJmfo/IDLyueZ7x9qecBcj2vYdgzVpl7tGX/3WOOpuXi/fthl7KJ/+B0eXy0+P5u05JMGKM9lOGHdC61B+TaFM+tlLyXoyn9bERSNgnmYIqOJnDZBmO0PMaPILVXxX2Uogc5mjyWNofTrrQqwJvj1xc06vzH51yM5+g+OIIf359iXiKXPvV9Wz1Bur6AgF4EZZo+etjuq5XhmXvOcaa694BgHrgyfH3xOohpcqK9pFOh/GNg4voT++ZDQG7tbFufMnq+jV+hZ2PYp9u2+94R65IAk13j/HeuTw/hnfaBHO+SS5far+nZYK5GwHNto7O5dCmI50+gb4pwGnMC0ya8apn2TSun2hc2gntnlxqsDNrVDW5evMJ/+Yv/gtPTUxRS4X55j/v7e5wsTnD9+BqPHz/G6dkZJpMJrq4uUVYltNC4W97h1atXkFLi8vISC7PA/eoen33+HO+//76PJloUJVrtosw1bX8YVjs5ygCFCqMSSyGgHT8g3fV01slFo2s7NF2LrnNtkwpKCBRlYe02xvgon55vBKDdYd3OybR8XzaRHo2PTVbvgpCuBfTNFuDrya0VE5fRD+CgrhiXXfUzR3h7ODrMHOEIRzjCEY7gQAjiU4znZLgDCzFIJOB02p2CEhJtp6Fb4xlyKaS74UVCwDnJCAN/55OAFxJDJMZEnP2FvR7/3ZmqnhHbry4vzvH+EgLuQiQELxP1pZQZsbLGmL6PSQyyAgDzwhehAwl1sxU4UwoiepbGzZ56Hmt5Wjjuyw6NJVqbYK4ZE52EHRHCjT99Tn1BPdsLhcZ96YtxjjCG6nPz1gDSuDtbYfxcMZr6gyl8AHuLhYCdxxFuHp9EHwjBr/3o6+fjulUQSA9PMn1s8E3hlhJcGOIDoWdQj+nDawbCNKGZGkOa50J4g1TcrJywLoJfVK8f/GjNcqWl6F059lDabVOi5tLy9GPrOqfMpvz8/QDPjNLTJU63x+VLljui+LFTPtVmXjIvpx9X/jY4oU9zyj1T7jq2sfFIOe2RAo0E8sGYcUGe/hx9JIocjAGiuU3X4kmJ8/NzGNgoD3QdH8dHKeUjPPDr9Owal4ln/RxNOW8AYXQrw8aOtz92JuJKEGprFlgfJZUWHKI5EivPd1VaEErDucbz0+lqPk8FSxdTnP55n6/f13i/xmHyyaj1tgrlnKo26Be3L/t555XjvtWkvaIN2z8Tws11QdfcjNOZeC3wXhviap2aRXQfp5DKpxfOoCukgum0d4SRul/LfJ+gP9738ZVRfK4bt2nbKSlcm323AUb4fddhM1jzYHMyBb4PeBb07KE2xPf2NC2gxcbxteidmahgIaRT2tKaMmi1RtPUkEL6yIwCAtJV2GlXhgCatrHXJAnAaA2lZD/OEDaSi1KAAbSxdahSBePK5/TY3gIMryWL3wf9JoZ9wdc+0K+r3L7G9+VUeSlc+R4RQ0wLOa7bDJu5NZ6L+jFGE3JvttGRXXmPbc9Sbd2FhsV5d813KOR404CP4HTQMfA9JedlAcF+YVj57P8AetLh66V9iPaM0AgMb2gBBIZdY7HqDTNhuRGy4e7G2hWnye6ngreTWskcjxNjlzOCxf25D/TDtd3xIQsJmSedLL+OLQrj9P4Q2HXtxHhl9xzRO83kZGxWsitfsLnX17mrQSveEz0uDCfCJJyqCce5LRjHZacgK4eO0NtR+jioXAyeJ+VdtjiN6U+/5/qR8+mxDmaXObdtXz0EIjKWLHvbvtDzQSbYXwU921I31ZH6HkOu3Tn52uOxT3nE0zzQ/sXnRIATr5veM9od7lFhWhP/TlWcWX/E16b6eYzXTfFO+/Id24DTEkR1DmWfQYW+3p3nU+Z5TFn7dbKN5vKyex6kH6M+f88z8CaYaMnwdqRInBg824Zdqje25olkwXg+7lIeH1OjdS9fMbyIZ+H1Up40p2Gf0V4Y6p9dvsQcNcmyIlw1o2eM1pE4R7KXgIA2GsIYKAhUUuHq9AyLxQKd1qhXaygImLbF5n6J+8ktJATKokChFM4uznB6coKu09CAu8qowcs3b9zhpxaoJjDGoChKVFUFIQTatneWIfleCqv7KaSEkgJN06JzTj1FUaIsCy8Htk0LA3dQRUjcLu9QKIXZfO4PYGnd+Ogx9CkAoOvQIZoXbOz2oQvBeFPfJ3hN/84thBQv79fZlj31IXm8I+wPR4eZIxzhCEc4whEcWBbXgAw1wgjQdZjeaEHskDbQnWXKpBTOxqN9tA4jjH0GqwDyClB2LRMzOQRiDWfkOHghP8HAjQngKQGY0sVpeyNlLAhtB8f68wpCBecByjh6NnhuAK7q8Mof+hUkF/7KLD0idOTw286r5vLZcY/zK9ULcpQ/VF4zBXg0rjxqDY17l2G2ycglnJDEDXm+TzWvj9KLwV2q1Eorz6UVubECN1a0hcL2iEMEwz9wDoh+8zp4nrhc/iwOtR3nHxhh3fMg7K7LR3EPRhW2CfDOMqZX+OcMdSRcDte0E6GNZlcywF4hY19QIYPpGSsQcrQj1T+pvs0ps7ghO/c8Nh5m5zHy8ySVNoY4kgatJW5ATYHIKffQzz3fB/ZpNi19Jvt7S9tSEQm01l4Qj5WlBnDRozQ6l05zDRZXsrK1JVw62mvo5I0Q/ZUmRVFYhQSLlBWvr6qqUFUVHj16RC0d9AGvsyxL/4xfg8gN0fxalPCqptgo0/cBts2dkbWa2nfGjAZje3BflXFbeI/XcH4Ln862r490kkKZl0f5AxrvIHaWifGOaTdvyxhNS1/I5PREAVaOR3JjbJV3YQbCma7II2crhgwghtew8PnI54Jw6YVzSuP1BODXL+vL6PozKW05Uimb3u29HA/eBr4mCK+wSt7HYY9S//WfEd21CCbHLkW3w/7iY9zPx64NI/3Z6yhdBB3R87CAsqcVu87e+V5vMJ/PrWJTA9o0MC6y0d3tG0wnM0xOTtDpDqooLC/iIsrY6HgSpuugO3YFIzQKVXq+SEBCSBHSY2GdQYWQ1uUpYD2Hkebi6xhTSnWlVPIkfm6/5HWlojX1dQ55p3jeBuPL52oCj7ieFA+TgtyevG2Np/LswBiPlpXiI3M45OZ5rpxdcTgk39uWG7wfinOeZ+fzHEFbw4hwg+wJGcLKRqGUGe9DxEfS3mvZhoGKP2jXUL6zdWxzJ8mMsuWpRaIP/X/9l8F+H+2/2/jJQyCVd0wG2ZZ2/7p7eXKMF9kH9pVfUnlSwGlgKkritjLtz3xfxvUM6hUiKZ+NlZFKyeW0HOTmWTw/d8Fl23iYRLocXY8KTpYz4Hui8nMycopHzO2NW3GLIF7L8d6Q+84hJTMJR0vt7emsP3bAzYzUFZQ/8nssz779JCL8D6V1Y32bK8v0D0Gyb26P3oVPiOk153/477ivZGJe7gOpPSOF21h+TmOCNR7s82E/jO0RORhrnd0fWd8F/bXj3GByRr/H8mfp3/l2hDrknlfoceEyYArHscixvNw40q7F7XCH6qggG5GX/RYi7RhlCGeKNur6h+ttaXhIHtDasIj2wzJtuWG/BW2CPZKq432K8YdCCCghoYoKANDpFp3WqMoS19eP8P77/xqbusZmvcZqvcZqtfKySds0WN7f2/6UEtdPn2C6OIEqCiwuLtG2HX7605/ibrnEbDbD/PQcn372EpPJBPP5HK0WkEK7iDOkg7CRuO36sVeotdqg6TrUTQ2jNeZTYFKWkGCHYR1vKgBsVit0RYH5bIZCKtR1jbZtB2u6747huKfkp1yaoM9FQl+QA0azcrxEjodJ1ct5wCN8OXB0mDnCEf4/9t6sSZIcORP8FGbm7nHkXVndVcVmd5M9y6OHsiLz71dkZR72YWVlX/gwnOUMhbvs5dEXqyqPiIwIdzeD7gOggEINMPOIyu59GNeqSHc3w6EAFHpBAZzhDGc4Q4RxnHAc87U9YdFAFDxJpYxCOHQdo+uAjgiEPjlpAOB3bsQ07TH6A0gWKUBw1MG5LgaEUypWO4BbSposJFlYdEQ1FCzt5HiKA71S4EwZ1App667nNagtZhc71aEXeeo7feVaByqcu1JWxL2hhdry9OfMUA1fFt3F1fYkp1DAh2ShxQejxfPcILT5TwHtfKoZFrJoJAahr7Rb59Hl2FMnyrLLU2Vk8XsJ9AKXBX2aRa1+i2/NGdVydMuCvJ6LdrENzPAr9F57ph1DNed5zXGlx0TjUHMIzJy0pj+LdjNXd6XZsmuOMF1mSud9QS9rTpqWI1bjqvOc4sgTurBtsXnFiS/zt4azzAGdX3a7FDwgjg8AFexRX8xoLZiszd+WM0j4hL1GRJ9moWnO0p73PvWZHIlr+9QGIOgymBnjOBbywpbVdX0qp3YdXY2Hx2GZtVvj0nUdhmEonCQtx/1j+rXlcLF9v+RkbtdPyRFladPKsNqpPLoP7Ak8mvdq/HR5wkf+mCD1HY9HTOMUZBmAzuU2luNOM7wTXQJgzIMT7HwUGRzShXItD5W69PyVoLBpmoq5LvXpK5g0riHdnJZP6euabNLv8ljmE2iyTJ3POb04aWlByvDep/6epgnjOKZ5nMaECdQRpik4gJk97qJTlJnx8PCA3//77/Gvv/41vvnmG/z85z8HA7j9eAs/jegYeLi9xcvLS7x58Qyf7u5wdXmJw+GAw+EABqGPfdxvNmD2GIYBV1dXlCzV5gAAIABJREFU2O/3GIYBQDjV6ng8hh2RXRfGlgMl7Pf7EOQCSifcTNOEvu8xDAP6vk/P5Oo3eS+nYkn/ee+LwD09fpa+LA1p/UBO4GLm4hq8cLLgXOfQOuts7Bs00qIryxdq8BQZtKhrVHTKNbpv8eiafnA6b/3DQ023sO+X9M4Zj1aLJTbPTIcQvrbQb8zzHathjJYXfIU3Ll0/a9vQkpMyN2s8sKa31sqt8vSQCvK1VrbF67FQnYMNvXQt3yl1PF4W1zeyWH71h4bHzsklW+4xdbRkZO25vuJziV/W6nostPCyG1zk+al16rmQ0hsa1PLHziGbLs218GCxbt1vp9BW673GaU02teAUWWGfNfvXL22bKsuztluNjz8FWnaFrUc/X6IXRvuEmTVe9Fid1Y5hbRxa49zik7U2ElHz1Dud1z5b7CczL07hxYWeU8HZ0ojF5RSb8ofCkvx5Un3BvGiW36qrla5FV545X7tawbk1F2ydS/PJjtsS3di5MMWTZcLVQv3s6ugWJH0NWccHgHEck/1RXudbygptF1ifVgusbiJtsj4EZgbTAHRhmPstME0jJu5w9A43n/b4zW9+h/1+jxcvXuDNmzd4fnmJ43jEcHmJ7+4PePeb3wEM7B8e8OnmFkPn8OL5C3zx+g2uLy/xf/zj/44v3rzGV1/9CG9/9CU+7e/x7bffwhFhin3g+gHTcYRzLmyw2g7wmwHH4waHwwEAYb/fFzapvgr37du3qa9ub2/Dd5fbbumgpY8+Fn7IXK5t2FzSDdrzOuvB/3/aQ/+jwDlg5gxnOMMZznCGCP/vr/4V37/7mByTAJKyLZAUFnmuFvXIpL+7u8fxyCDqwRIwAIA9Y/ITiKMClfIQUqEVqF0NImAVsVOdMUWb1DMw4FDZodNGb83/smhMLcGSgqsNKt1ue+JA6OcFZwczWq6cwnbUyrJ5ZlvBcUFejCe9+JFwNmWKA93zEXLai3MOneuWg3Cw0DZVb/pkDuWr58nRHq9GAOQyrUzzwRVe1iUL4bI4VfQByy7qKRkGXdeh63tM41jFT+dtPa8tpuo8S9Byakj+2qKBvjIrLfYz57FfMOAt/tapeYpT0uJojUCB2ikGcpcv6zY5FxatKezugDh2EOnYBB9pB2tyHmWLLaWb7fiSei0/jc+mSv/VFlhqz1t9Yx202vFmeTRF/O1clu9Fn6nyW/Qhz05xqC61a81wljTpqGBpS8S703Pa+xlvk8UzjbcsossclbmRnuu+qjjenQ3qis+naYzJZZwoLR4LBKdQlDcccEpBN6pP5PoqZgZPE8b4riOCl/baPmrwh0jGFViTR6eNazt/GVCk82naYebZNT6WXwFIRx3LexdPmdLlZWdT6cS1zr9Fx2OrPdzoMSIQI502gsnDIVzrE/gH4FyX7ijX/aNx0zQagn5cOsqZOexQS6cjSMLOoVM8p7zuaw5jlEW2bzRONWeVaW6i4ZbMqgFHQUzxJEJmF4N2fAr0GHoHzx6eg7P16vICfkIa55A+BL0cj0c459D3PbL2IsE2eTy1I3YYhuqVacGZma9M2+22uL29wTSF/nr75g1+8iffYLfbYbPZYBxH9M+fo+86HPZ7vH7xAh/ev8d//2//gC+//BJ+9OiHHpthm9p/PAZdx7kOAOHu4QGOwuc0TQAzXBfuqZeAF+EJnsPuT0cOXdSnqR/CaTTkgHhsODHDgbDpByCecgMidL2WwwBPIzoKV0Cl0ZF5BICJwpVQhtMEWiZFG6G8risXimvO25q+nmTnjMbaeoWlNwutuqBao2Vzes6cTmjSejArHFq6mn2v8ajBqTrgqaB5YE3f0ukK2bASGJFSWrwqPL3WBuFtk88yURcVSSgMha5C9KbIm9IGCsXrZMr7VGeUz7BUm0EHdgnetp8K2d6gr5y37AP7fUYDDHhpNEjhHX/LjnewqAcwSk+VdloBQEnnDQmlAbPxTPQff7e2fPAT6HMtx9NCC2LZFdpuza0l+6k9757QXnpKrpUypeAFeCwPOYU3LfEwXU6V1y70dw1Pzb9sW9Mv0eOAZMPNZId5lvpOzQVtH4lvytYlc4IRr5ONdoiPGyYg5S60e6nNVld7jA11yljPZF0lPVfSpj55JNRoZakvJi0zciEgw5/ENko4PlFGWrzWylnqgyX/xVJ9BY2vlBUzJr1OPytkIUpaLdKFCsJH/L44m4W+VJ1pviy0rdUWhtHFaL75al5g+qfxroZ3I5CK0j+N8uqBmcDT6GxxPqq+TentGOaCInpcPLM+NAIwjSPkFnmO6XgtYE/jYnQVvaEAKH2CCVfD24W+x3GC6Ch93yd9y9re2ubUtr/Vx4prlAFMrPxcws+ZwYS02ZI4+Jaz/9ID3iedZjf02HRXuN7t8OO3XwDMuLu/x7t373D74T1evXqF7nDEOE7oNj2ePbvG89dfBd9CF2VGPA33l7/8azjXYX+Y8O7793j1+gW6N1/g7u4et7c3OBxHYOK0cYGZcZSNT85hE69Y0lST54umTU0H2f4uhzTTTF0mPz7Q2LKaMI6CcXvu1PDSPsSnBpSe4Q8L54CZM5zhDGc4wxki7A8H3N8/VN/VHL9WibXfw873oMQV+hhn45uZ4/H087rs9+CgruO+5oSR56c4cYCInzGoiOQezjl+4d3n2z1kyz/V2SK/9Y629F6MUprnY+UUrYFTZazhk6rQaSuOjblTE+hcMHIczxevdPv0OOqjOFsLFBrSIrSf46T7TP6KRVXl9dSnRXRdl64zsHQWFms7iMGYFnCVg6SGd23BUu/ImC1yVJzxtYUpW2fp6K87lbWTqDbnNdSeneIYrTmr7bjUYM3JxLXnPD9dRhwNTSeiceTJ+LHCQefQzteqU48oLeLM5mKFB64582r55JSIlovvVEPZ8vdTeZalwxbedmGvdsRwta5Q+KJDlowTUTte7Wkma7uZam3XbbPObpa/FZlTXBcUVwh7FVSiHVW1turFn5acazmug3zOY6ZP32iPc3tXW3ucy98tOW+frcl24b3WAQe12C/t0ksBtt8+h8O9APEqoZyLAiFupn4CQYtXO+fgrFNJ5B9RKcOFJlXZ6yjPZUglVdmOot+WZYPUYeVc/k3xek+Ccz2IgqN2nMZQb2xjOBXGl/5CokhjlP7s4gazCsIZhmLe2vHRJ5/I/BuGHrvdFszhXvq+77HZbMJuyWkCARji7snNZgMHwtXVNTabbSqfjIOyCNRBvuoq0a7CqXZCknMOTi2qh4bGXZPqJDp98ovo3aU4qh/trnUOUouIS/PX8t8Wr2jRWEFRZn6swSl6Qk1nYM70xSodM4Mqu8pP4Vktvq/1sZo+/BhYk1e1z1q+x/bzKbjotupyU/m6TijdPj6RuWL13dTPoTBVv7bTSmjZHy1aZZ6fflQ7Qa/W7rX2zyDZFDFwjaVME5yosue6y9+1ttj3VZ1kwRaR/mzSWqUffig96Xk4r25uwyzxE52nNn6fE2rjEL/BfWYVYxFW7Cv7rI33OqzNgxY8Jv0pennLjyS/mzxvIW2a+4a+RF5KmvSHCu+p9E+r75dsmRbU9fplO3xtThdlPsImavVRDU+dTiWq1quvz30MnCIfNTzFFlhL3xp3S5NLelQNvCkLBvfCB6Fk7qljWwOLUU3n0TK7yCtzCaZtau62/QxcXDt6Eq6RyGfZuNaSDAH/x9Ul+T4HaP2zSh8NPqY/nT4xNxRW9UNxnFe1ciD51PsWD5U0XdfN9DKb3p6GLVA7bXJJp5R3aQOO0gulhOTPoOw/7bouBXuN6rRvyU0APt7c4Pvvv8fd3R26rsPD/T0IhDdvXuPVq5fYXWzhpxF936HrZZNHsC3HcQ/nOgxDj2EIGxSOhyOOhwMIhO1mW/SD+CcKOdHSmRfgsbwx9GFzqFbKLDU0NnNqTf5USzx5/pRBOX8IPe4MGc4BM2c4wxnOcIYzGFhaqBKlqOb0tU6GmhJvFW/ZLVc4QxMiKA0kqScUMNvxUwNZP1lzptn2ArUdbuF9uFMU0O4Zl9q/7JB9LNTzzl3BhaMIFHYYS+OjRswLymzNuC1q4/kzMUbrKm79Rc3wKurm+XgmBxTpJaGgrCenD89QnNVZbRirNME/rU2A5CQjRYstg1FHyNs6nTMLWur0HW2wJiNJ0FM0T0C6SzgZwLZtFed8ywBdc9bojnLO7ojNxmnLyfNDjRiL/ymOrFMMsprz6hTjrmXEr6Vbc9hV3ypemJwc5rkug4HiJBsxwIUeu65Lu28K3FXZ2uGc8G44SppOVqgFcA67e6SGfJJGnLupLUJH9WtAavWt8dZW+iR31HN93G26VisUDjAr3l6nQ+3cssGfNexqCxPpGjjKpwEx+yTzwukN4pQvSsvOFmGehpfUcCHzzC4InhKwtDR36s9CzaeOWaXG1KQ8ngBgAnIrOOoy1nB/NBCjPAZhXn+VD0QhWiz0sFp4KWR2mCVhQXUq6HmGjpmnxNyUjUt5W9CSJUmAqnRFvUkOMTzidT0+/DYu/rBTL55Y4lyH8RiOk3Eu/B0PRwgtaUctOYKLp6N4hOtFyeVdl/AB177vi2PB5ahwCSqp8Q95tt3OnZ2WL3jv4aKDdndxgYvLy6LfZL6mfFE/YMQT9qRfKJ4UE0Efy13gFxUXzz7qUJH/x74NvITQkQS8RL7BQlmhbgZjGqfU3qD/+KT3Owb6vgunJKlx9jH4RoLjhU9JN4r+FjMk/iq9XKW7irxfW9QNbSrntl3IaYGVr6zxKyst2/MEOFU3OlVXaeXVbZ/JrRNwOMWG0XI8UK1Jm8TS/HlgG+uyvTXuNbyWnolKk1Wbsk/FfiOaX89UO6WrphMEXsOzxWjR81O6siDIjhCxasTuKFJKu2Onahq1kALzxFir2AFWnmZ+aik/YJU2J+gxi3OOdOdiPn6PlbVPsR5OXVRqLkR+BtCLeWT6aS1fDWZy9IeCKq9Gz3ZutXwDVd3WlLXY5qU+f4LtuOjDaNh9S5ACNCp5xC4rylG2XEsv07rC54BT6Lbmd5N5WvAoJZ+Btu1i/Tat9jAwt4cq6bSNa+u1PGRd/ut3UvrjYYlfteTwqfJ5iU4fCzXfTqv+tXpbbV7Kl2RCkkv5+Vzei96nU56OR0BGZScZ3VJGJb2ieLcMdVr5rFy3VXNRz2PkUMvHAZR9uOaPW6qz2QOKLxZ8IOWz8xTQ/SuB+3ozouDMPD+N1M79gs5FdXIu8ZzRT/DThMDCfdxU04O6kGZihj1TiQg4Hkc8PDzEK5GA6+trXF9fJ7tQrsy9vLxA33c4klhNwU4KATOM7XYDigEzAPDw8IC7u7twtS4RhmGYXR1s+Yft09SDn0lXOcUuOkXv19+X/BIhXRv9RTo8EY9TyjrD4+EcMHOGM5zhDGc4QwFU+a6drvGNMZoFtGLbdFJEBdeD4znZlIIRrPKj1UXmcN9rWAQCmMQpg+CebBp12Vmacbb+AXESJjNgZiyIYukRFiZkQVra2XcOnTopQBsBS/Aos4zFJZ1cNjl4AsFJ6slHZ2kaufwv63ZqvMyiXXqbF7lqkBV4Kp7NHGcoDQH73N5fWwylODilxcmhY+kx4xn8xFSkAWQs8oLH3DUUc3FYTAIQaDT5s2MvU96145nTtT+gvJCWZg9zcZqN7gML1imn51BybomBWssvjce8vwEUi4Ha0F3CqQXSXj1YesFKDU6eCwqvU+tIbaX5zmH7O+WJ3yXYIaWL/TfzrJk+LcbOwMygNfzOOuSXHGmk3sunM+NScOS2tQkgn0o0eQ/2vrj2i+OumnCFR+nkIOQdlDJGmlbUUJYLIorvhPqnUHcYMDD7tMhSznNARs914boLQj7JoTgJwThQWrJHg5zm0HS0aKdwTOP1TiNDC7JDib0HufmJLHocNVj60Hin8VYnTEjbCYzj4QhZvPJ+7pjWdCPp9OkVvHBdm/CRgofF8Uz9AlbBTNqpzvJ/Lk8+GzvHELELYrp0zBd9Ncsj8qSU4bodS/yk9u5zOavLih5fpojVjE+QVRL0EAvO6Qmz4JcWba31S6o/6XamOdQ+ep7Igbk8jlvkKjMirfpEs6Bw3VAIYPFJho/TiGnyGDqHjlwK23COEYLngh7T9YTODak3mBnHacQwDGDmdLw3swcIIBf1Sw71EcI1Voj0Tc5hiEdhSz9J0IwOmNFHjmtek06KMXpecfpErMczh0BBF56xD3pv4Dc+XtUIuKg7ylxPVzHF0+mkf4XfKmUtPKfwXK6qAQA4gkO+Jm6Ki1cuOpa99GjS30JQjfcTEE8/GqcpVBunvfOMTgldafc0Tem6sEx7Wg5yccz8KY5fretJXTVZq8em4CGKl2neJvKfpRyhX6W32PILPUzpChrHpQUKy/OtTlzT1XTeNVjTJx+r46Wj7aF0oVadUfZw1I29SZjsiOI3lP4tP6UvpNj2qSEhTdkv2k6pN1NsgYgv6/mt3+eLDCalE8zryrgG8omB9URNcUDmM32Pc4qJEo6BdZIqW8kCSR/JukYijLAjX9Oc1os1BF7PmKbcR7lf4gYRZniOu7XtvEt1lrpzUfeCHvxYsGWcUnYrzSmycl7WAm7IelBSl+IgLdaicIjZZrg/Dsd2HssPUh9QOEVM561daTIru6FnPVY3S3mbb7JOWM1jeFaJX+SxM39IpV5F1yKr6ITriKgxxvLci56gyp03hMt26Lmj2vMYmk0yDChOtrXvCxu4wiOW7I+ZHJR3K7jVxmGpHSXuwh9TQXrQVvtIS6AZBmbO1mVVltuPmaMtvFr6fKsMPceqvtYT6rVjasfZ8u6ZLmH1sAWcQ/rwz6OlAEkYKgdbCMFCzcwyv7MSdr0ufaKM6MKRV1To+tGoq++FHmRwTfxDdFSlq0pKq3O2xt2OgdWVgdLGK3h+42ocWz4RJd8Bq7zJXmlCmLBShnOEaYr2Gol/PugZwjOB7M8DRR8Wwmmck/fo+h7MPv0eo13oHCEcW+ox9H20w6KeQ5Q2TYS/KdX1xRdvcHV1DQDY7/fptE72Hu/ff8But8Wr1y+xf9hjPB5xPB5xPI4gcnjx4hW8D9csffr0CcPQY7/fQ3w82l7UJ5sW8zPqawVPMLZoZYCeoCucEsBnaSk/z2xgzhNFBxL9MeuUp8Mp7Zn5tmD68gw/CM4BM2c4wxnOcIYzJBBFZ+7skvdWB9G6TM0h1TIoSa24FU7EBUcAs6jZ2ekhjruiIJuvciSsHNNYc2SLst9ygOu0dlHJLqKcsng1NYyTsu3GSEWJm3Z4BedBORbi5NTOInvlT10xZRC38aPotS0M/Jx1tlubiNLiil4Yl3f6WEvdvzWHxFz5rrqqKnnCM8+cjCrbD7a+0I6w8z2sfXl1kkb4c9E7SmmXdzaAly68WpsvLcdj69mq6TOjpbmzpaRdQNNb8U7llf6QnfqpDjY7Rp7g/PXivIo0bnFN887Jwmt21hHpUztUQI8qSztbZwElqo6Ej/eJVqxDqXY1l+YLmj/ovpdPfY2GHidNuy0jsu/7ZIRrnK2jozj+NT7rYlBIgY/Lxnzhk1RlFO2EOLSF6qlYnOHJLrQDmGLQoVPBZmZOCG+wbRA601eVSDqNnx4rIsKk+mMKnZ7yaJ4ltOIVn9Djq3HTp/nIONSuaNPjIc/lihh5ZoOHdLukLcInc3/WnVRSl3WOabnoINnnvEjGKY/Z/Nhknaft4AhMsfBLKpAdvbosIgITJZfnkiyutbkFa47jPwYQIZ2iIvVPky/ktJ6L+m8NCvmBJZmQgz3m+M3HOdDQFE9ACaWnT3JgBo7HI6ZpSvTZdR0uLy/B4zRzFG42GxCHe+QdlbyHoOi/K9s1dD3GuHNQ5s04jrG+PvM91VUc5f00TpjGEdvtNvENOXHGyjKd1/atfjaOY7yCNI9b3/dwfbiKUU6LCsG1cVEBwal7OB7RxSuchmEIp7dQyOMQru1zIHSuS3xmxnfjzkkdwG0dssyc+kj43GaziQ7NcF0ZEbDZ9GCEgB7HHtPkE2/uYuDP8Xis9of3U8D2RKelpoeanmhlGEddQgctWdCBOYDiikruJl4dTxnSekFtzlnZk+qNegmAQl7rMRIaFt2WmRPN6jKlTt2fNpiy1Yc1Z3VLv9P1NSHy4qKddoxy4dBfu8oijF0kCO2hdPVYCVk3sPwn833AOvElvR7jUvdyKv/8pARdR0u2iV4lZWsbRo85pEytu6lAPHuVhnO5n0Xfzt3K6b2mjcC72ov4gpPmw3Znd26/8Dsu6i37udRna32pxyi1W9GkHR9Lt61y7DjovliT5brepb6ybVnSZVZDJzjovqRo2fPKpc2m36ztIPhZnFrtWmrvWl+s1fmHhjX8qp6KBt2l8uJcEXtH5LG1kbJdVJ4wVsOopX+2wBGB9FUptX41ZXXxqljdLuccJsNHaqcyaNzsp97wZdtg82oZVuiWFdrIemcbluhJXxG71J78HDGw0Jn4g8h/Z9GLpQ9tUWbq3/lFtR0zekObD9We19rWeqbLrtW7Ro9ruNZoocV7arpFKXdp9k7rNktzqMgLQHRLeVqTAUUpHJ+cwL5S0yhuzES8srSQh+1NXy1ZBKC04ZfkkSCReFB5TZHWXVvywdap8bM4lv6Dcnxq42p1Y+conoiZceq6rqq7Sz7dF+HUYSkb6ERH8x6MaMswwyHrjBGbYCfHjWGdc6B4Ja4jwmazATabZN+JPYpoX6cxJMLEwOGwx36/x3a7xevXr5Le9PBwn/Dve4eL3Rbff/cdHh4e8MUXX+D1i5/he/8OH7/9gA83twAI19fX+P2334I52El91+H1q1f49OkTtttt2ughp80EG4ySnhbq6me2gB6HFqzpOU+HOS3YK6RCtXnzluQTdANeOcDmUbWfoLvp33qenOGHwzlg5gxnOMMZznAGgZrBeAIsOWNbyh3H+tYMtyKPGO+PVAg75aDQz1o4t55ZXGsGpF44tbDk9G6BNbCzkhqU0poxqnFddMyo5/UFs2gcVQKlWuXY+ie10KzbYhVam0YWnOV57SqCJUdey5FTGCAVg/4UR0PNEVCrc2leSH5NL7rMNcOn5swlksXlOiz1lx3/mqPDvrPGtaQXx7ykrZaxgOMqWEdWw2HQcsrUcNaLKzK7avOphWvNMSC/W7gB5a49/UxD7XSVGqzRn05To2O92Cpgd5da/mb7SBwRzgRYadBOX3EUyJUhOhCp1Wf6+zRN6Psem80Gfd/jcDgkh41tt26vi/VqfAAsOvF0P9l8fd+rXUoex+NxVkbLqVXlBWB0ruQHNuBFnmleqvtOl1vrQ9u+Glg5V+NP+n2N/lr0X5vrVZ7awMumOxUek/YPCbU+CA7Erpr+czjCHuN4snNI05Z2euZFFABxsUPoUtI9PDzM6vaTBzyjJwIoH+2u54SlvyV9RgIpUh5LORQDLTY5fcsZWXO4Wfw1buHI7272PpTBIBdP35kmsM+BnX3fYxiGPL8Z4MjT7KKABKlY5zNz2FVr531tp7B9bvs57+R0cL0rgwOdKwJJrfx4irO2phNbvnFKGZbvtUDTZUvutvQ6e3x8WIvJuNqFDClT3hFRcpZrvUDXqQPFW/pHS57a97LAudSmVhng+eLIKXyzZX/UZKbtgzXcmOcLi0t8wcryoPLXacu2T+qc0i7lMmhVl5HmTCUYRZdZ6wNdTi1PTbdt0XtL9mreVJujNTup1Ueav0paOzY2j/1udXFLu7adLVh6b8s8lX5buNh3oHU7a6ZzxpO9HgO1MZA61mApTavfLP2ewouXbI41Hm7n7VNkiK3rlPxWt6jOHZR2ao3vapmxNiY1+84uOrbyWRnpvQeIFn1hrXk+MSf+XmxsWcir8XyMDRG8VOu4mbf1pyvjGsarkqZ4xMV3OcXs1DpOATv31+yemux+rO7z1PxLeLTwrPFs/byFU4lzvd413APpPtKGDYkqZa3MV6nQlqfaqG2klg5hZfVjxqYl03Vwtz2N1/K2tTI1Tmt6oi1jmuZjoftE60Y278zPFdslPiRJ29IRrX5qdTOt/0nacRzTO+3zu7y8xHa7TYEyREFXPxyOuLy8wNXVFbyfsN8/4KuvfgwAGIYB+/0en25vcXN7i/E4YrvbYb8/4H/9z/8ZP/vZz/DVV1/h8uoKXddhv9/j5uYGu90OV1dXuLi4wOXlJZ4/f47D4YD379/j4eEh98eC3+8p8/sUneFUIAo++qVya3a7zl+bH0+Bls5yhs8H54CZM5zhDGc4wxkKeIri8ljj92nKkXZgpMWEVORymVUMjQNMypGSqgt1Jt9sUaaBx5LCm9RiqbvhwJT6ieLOtUW9sDRKQxk5T/gtf9aepPSMiMIiDuk3qRHFrnDbLiKatYcBQBYWVNtSGzmc1GINLL07V8quGee6LPvcGpaCmx0xWnCGPsa4rBkJtfdSzmOCqawTmG0fqzpr32t42RM51pzRNZo+pT6Lo2pU2IEZVjbC2HA+SSSVv+TIruBpf9fGwD7z5rltc81IqzmKWsa+LVOPZ2vBqDbej3FotxYnbFvK9/F7+ifeogeEkxKUg8OROoYe+ehxxGNFHMkpCCGfZ4aDg+sonKNAbcezdX4w55OMZFH3cDjknUQxrT75oY/XsLgY0BVOVYn9d4LBvuR449h/vSwwa+eNLiPmn11bJm2T72CMnosFXnudWiFDnEtFWTqpzck1x6qlzVqdOq1Ot7Sz59RFnIR/+NHUGFr4f07n0B8bWnLi1L6ryUaZv6pXc/kAEE+64ZiQmQGOAWWhUACBxqQMZsBzOKEpHMtNGCePh/0e9/f38Oyx3Wyw226STCcigDjtBHR9F3YJRgeccyHYbYp6QOATmp7ijkQQOpJGBd2mUydUeR93H+q2Umxj2nFc4zNhASlclSQBEpn3tIJQcv6ST9n5Vsix2vhRDJqKOypFx0plcOANQX3TOtycr2uncVHHrF4XdT1An8KRuizZic+4AAAgAElEQVRxfKh0XVFnbqPhZzR3lNv6HxtEbmFpPGr9XJOxtrwWrrPvijcJvaZR0boi1DwiSjuNIbomEbzskEUMtEFeGG3hxQwwT009uNVGMmXOaKOhyzxmcVHGVvJWA8NjP1kQ20B0C41H0XjMx7zZ1pxFNxOJpyTeN89fsztqOKWFBEUHUmCic12WsUlsv8/arHCw+vopsKY/1vRMPVZgihsoIq1Lx8XGBhar7CdBXdib6cuaPqXnSQuaeotpZ8a73Ud2hpyy0DgpXa1WHqEMhobuw1a+iszXoOdsS09updefp+St0Vzr92xMF/LZOh6T/lSot83qVEApqyiSnJLlAOjEqzZP0Tdr81poQ9uciV5qZVp5ohukZMkSTjU7psljF8qx72u2qJ2Pqe4FnV70tEcBox4sg/lYz2f83NZZgmQrtvSBWI6kS9rTCbT9FPpf41U/tHydd8k39Jiyl7q5qZc18j21Tc18ItK4DLrX13snW53K0ztZzU9WfH+RqhTtpLRa1hh7OtgBXMxzOwdrPL+mz1l5n1HKc8Ip/JLOocpQ3ZY+yZXByrpMnT69jWXaEbH6ltVNUrlyyowpczoeCxWkV1fuyrOu74O/hgjTOMJzPv305uYGx8MBt/Gqpr7v0oaoh4cHkAvlXV9e4d3+HW4+vMf11TX+0//8N7i6vELfO5A/YBgY19cbXF6+wtXlNch1eHg44DiN+Kdf/Qr7Q7iuabPd4MWLFxiGHnef7nF3+wnOudmJlE+h+cfqiEv5l3xK8qymQy7p0SvYr7yjRZ5yhh8G54CZM5zhDGc4wxn+YPDDDZmZ48uYxYS2grdaT11DLxYt1/DTBTBLoY/CAumUSVEyySxcVWqb65lU7W7jogEgQSxSTiUT25+cnrHKQ/OkZb6GIc/mvXWCy524Uk+6I1cZlLLYLeNfU9p1na3FDuuYIiyfYGSvjSjaZRYGalDLW3t+qjNU152+m/enGCU1w7nliF9zmiw58GtjrtPmEzZiepTOpjVHbqs++c7M1YWbhLN2WphydNtqTgooPNP3hXEUJ6le0Km1ERZHAGEhshx378PR/cI7EieLE1UbqXoXUG1xN9Ez8iLPbPFEtb24eo05JQi+T4tHbppnH68gqc+NpSvvdDodTGcNdWePNBf8a/Q7e5L7SMsG/Vz4oJTriOBNWrtI5NQz3bcMTTYyDmU5aXzJwTmotuWjmy2NP8ahb3nHGi+xc77GHxLf17xBl1WTBarsFiwtHtXm56l98VioqRLyPCJTBjJCFsNzwiRnqSzAs48BslHeeT2/cj/LXHGu3NVe4oEYcJGDLuRUMmaA4aMeYxsQcYHH5PMd9cdpAoNwOIyYGPBwODBwf5zg/QjqOmwQFoY9M3oXT4ujcNVA3zvwFGjXybVqXnijB8MuxgXkyFG4+sXQVZ6DgNcKSkGL1SGM9XDRd3n+zOWF7v+aPJMypFzABofkuSzMkWLbhFoyt6XE20mNX553+RrBiEWsX+M7DwyYq0D1BfPMqjjRl4YQcImC5opuZ/VDCrPzcmlwKrA07y1+S3NedLaW3lIrS660ig9Cv3TdjKfNZIDSGwAlR82nV9eWankMIC1G6LprrSvaw2JXZLqy+ruWiTpIi9mDfWhfrZ6QtK7r1PiTPE84VssUWViXyBTpSVEQYOwUpDlERtZzwQ8L1JnUWMQTGAy9pn5T/S68J6WhkJ+R+a3MGznVQBajvKaJYk4ojHUalTTjzQV+gZfEfqRw5VLGl6BTOiqpIXIKMDjTQazCSS5W5RAFGZVoLW/WYNEFlX5tdceUTp6LzDL8giv5LCzJ4HYum44Szvq5Tdxc8icA5MKJXI5SX9aSzx5VeMOseGOHUPlyVt7MJlPzxs7/+vwuaVs/X8N1FRQ/0r/bkLT3R9ajLlgS+ZdKLPlItnFkUbxR5Aqua7b8jI6JYpAvCn3Y2lzSBBfxlmV98Wc9eSwyImhQ/SK0FtB1eQSKc0e4Y6VupmoQ5SLGVZQLBbDx/elAle9WfRceDKzTyx8DZjrOI3jrD/G9tCD3TZGzljL+qy9KW4dSmtdqqBhc6ZGx96nUIxhIJ0VqW37my2u0KONocSq/25NTTtVtW6cLCj/PqkPmNYVBoPj+bMZEudOUUaouW7euU9ss4mNZgqr/EHnIgo4BIOpcwTcSN3a6bI+N4xg2WHmP7XYTTtTsHJzrMPQ9hqFH3w+4uLjA8XiAn8ImKOc6jOMRk59AYBz29+j7Hnd3t3h4uEPf97i62uHVq5/h+3ff4+PHj/DTDl9/9SVev3qJvu+x3fYg6uB5wv5wwMPhDuM4Ybvdoes7wDkw8onDXRd8fd4HXTz4fcKmEFBJpUkXfyQs8aglH3ArXcvnsuYffirU6v7cdfyPDOeAmTOc4QxnOMMZfhA8TSlJzjyzqLWs5FBSCJORIf64pxj4wGJ8SxUXbvt01pTVejCCuD5ynbYtwZCRBOGjvCql5XxYc8gp44vVTm7OfZOO+q91BecFH1m00TXbRaUW1IyfZLzJc6f6KBRatK/leLeLDak8hVNNif+hSndtsVYvJOsj3i1d1L5bqOEnCye8kk6XbRecWwvktcWpmpFV62v7ztbdwk9w0Vdd2ECVtfGZ4sITMO9rW096htLRpdNqHGb1yyIP5k6SmovOOnDEQHZy9UUqNjgw0rwISKCLR7wLPmHRssv4ydJHWL1J+Oq764UW9ckItfGx/SV4zRZO2ReLQxbCuzKwQ8aoRXtA6fzRfZ/bndPKiTNCO8Mw5H4194G3QNO2rqN2LRwwv/7BXuEg5dWuvdL1xNpjmi5dM+NcdpKE0y+ArqN4IkfGjcjNHGwaL027S+1e66PWYldrbjBzWgygXEjpLNQ0TiqwqVLvKTyzWFRa4RMzJ6eZB0sgMlA7Wq3A9n4SP14QXUTBCYfQLzIn94d9nP+BVru+x3aziW0IJ4GwD05AoizDha6dkz8XRWRwBAJhbvopLFUUOwURTooRLYpTmzLfkX7w7HE8jonXPewPOI4jDvs9XD9g2F1is93gyl+CvcfQd+icw9B1YD+hp/C960LQDBHAfYdwes38OpOaXE60JZ+RXgR3krEzvFk7Vsvxq5+0led6XgDW76wcsvRS0wEsBgH9qMFyqk26PvR/XAlzjhKZiQ5MInOIEK7Dmp/WIjxf4xDUKwmyXNeda+2rpWnJkmLemnFJY7cyzyxY2qj1u70mqcXDZew1/ponyDHt4oT33mMYhuZ1UjVcl3QX3RbBJexoDa5KCapIpy8mGld0qnR5i3+qw+Dl1Dyq6cRCI4DSXyIJJ7tABZlYaOmPS3ruku6d3inbJdByDj7kgg+rvMpSdGplOY1JqCB9TzU5FRgi8jzyRe99CqLX+oiLixqh/IwnycTmgEngw7W2ZjwSQ2bRK8MXEh2L8zMg2I9p8VxkLLnQRymZi+MocpaiHPCpfgeCBGYHe7M+/y3tpDEQiol0skT7teeJZmRMmJtXzia9u8JDVmW/LjHiLUFWqS9VagDqlDL7JpZIMQxDxiaNWRnslqqU/Ir+lpFeSafkYn6k8hg9Sp6xwanIq/uxMWc1WBt+Bl50C1PWausbuutiPgdiQhrMNLEStnGshRbje2rTlJWJLXu0ZjvLc5uGK9dEJl6k+DszA64Lc1zxl/SlUKxTJYks5iMMRatSa3iYwusWZNvSe3AemyJwTNGjlS2QJqxOBI3tTLNDlBRgXXDVGj9d/2jSOtp9IWPYrKFaNy33wQpfa4Ke41oOp9ftvtG83tK1tRlrMr+keX1iqq6XDI1G/TsGUs1aPWNWihekKU8gcWgWmbKkL3Rw0bNWutjqKrWTek/Jr7/XdOYlX9kSPc7qy5lEcSreyYlxBW0QGTbS9u1IvbVgnTWfw1p7TvXXZNS1XZyDz8XndHv3Cff399hsNri8uEC/GbDdbtH1HTyAw/EI1zlsux2YPaZxjLYSY7cdQnALe0x+xPfvvoNnxqs3r3FxdYkPHz7id//+e9zefsKLFy/x4WaPh/sDbm6/w2Yz4Pr6Gq4LwdIXFzv0/YDNsMXhcMTN+4/o47Xi4Spfxjj52K8MRx5EA4ZNl07EET5tebseq6X+O8XPo9PquX0K/bXSn27zrY294RVV79EZngrngJkznOEMZzjDGQSorvyUijsAlMp7S+dZVHAr9dnFRl13SFDDLTsin+JwX8pxqoKvy1tS7Cx+6fcq3qVDLxm2cz/fSil5ETJl5fzWITtrCEhOv8k0d47uXFFPbyrG1aLijpqhDbCfZk6p4ntlLOcLXyW4mnPKGv0xeEHwrjn6xS9Zw0un1fNIn/DR6pNTDG/rvAh2Yh3fmuNOntWc2BxXHvLOWJ79tYwxWWhhzncY2/6pOVz0QqQ2sLSxK3Xr4/51Gv2X6yWEdSZO12Loa76Ku9yN0ye3x5f9rOpmAFDv7XVNXOkjonR+Cxjh6N3j8YhhGMCqv3SbAWAaR+zv93j+/Dn6vm8arLLoxszo+xBII1cU6cVBG+wh5XVdB0LuYzvmOo/Gb+mEpiXjvU5/mKW3Y95yJFnnXXLaGpoDAPY5YNDi4acQoOL6HGyj+0MHOgkt6dMHZJFEBwdZHPq+T+UAQN/3GIahmCPeM6bJx3mVHQTOdWmu2nKt023pvf2sOers+LdA5pXUMU1TXJBrLxrbhWqgDAyV4CE9b5NjU42XxrtGn0RULBTLe8uXdIDdkrMnjMuUFtU1HyJy6DqH/X5f3PkdAptCmoeHBzw8POB4POK3v/0t+r7HZrPBdrvFs2fP8Gd/9mcYxxHgsGDuu9GMpXz38D7Qg3PZkbTZheOcHx4ecPdwi3D9gFxbFOb5OGbcw7U8U7zKTI9quHLJM+Pu4Q739/c4Hif89re/xe7iAl9//TWeXWxxf3+Pq01owzSNmMYj0BF2my3G4x7MoY7jOIIIkfeWPNuCddQThfvobRr7Oy/EmNMgSIIffAxAC/PWzhOpC6jrHVbe6Pf2dJdME4JrdtSnE05AAOV5IPoQwJj8goLnJLg0u7b0XO+6Oc8BdBBpXiyQ3+JwFnrWc47ZV9qb+VyLJ+uAwTTe5nfKV5ERGkSG63qW9E2rO2p8hLdY3iF4SPulPs2r8slO80AcP3mM01jwKsuXbJtEVknwqfCrNNvjOOh3ppACB1Jl6zmmA5Et8BROJCFmdJEOOlfOjzB2cs0axWC6IwBgs9nMdIaaPK+NFxAXvBr2YdDR5LQlSaN1wXl7pJzJ+3R6j+hOwrdnct/7sJM48igJVCKicNoOM6ZxBFNY+AhXTjL86OH6Dn6i2JIYvMjA5CVYLQ+V5gWFDsycZESY12XAU1goj/2qyCjopzKHp6JciieejNMUTg1yc3knfUgUT/EC0HEImqmdnmnHV3if4E6u5IW2LiD3b2281SC2144lTyVvi8ZyRWE8gk6QS5N+rckV7zO/nNcR5Oo02f4EOgCgfJqgJoYlHO38ofwi4Wr5Z6G76TxSb+UZxTKrmNjxSAIDKtDCJlnyAWmPhHm30Bdc8QNJnno+CvxCLsehiDTpvvJgtWGIwHBdW+/VdFzjHXW85zZMBdPETyVdbV7IlX65LwzfE7q1VUjzQUknqsuiulyqQUveIo2vkLkps1qTodVlFaDIVepUklnTef6to+CWaLQGp6SvjXXnXHXTTqGnlqUUHxZadra182qlkpnjjKC/FL4GZkDpLEKXOq+eG7ptVs+Z25ohGLP0PZS8S88t/WwGDXlf6JCGl8s8m49T6A2OE8XqqVa5sP3c9/1MvonNeiqd2b6y8x9Yvr5d6pnpd4bnVHmWkuWs+IPtK8lfs9dauNX4hG5fm4+U9dl8AXxxsqqkd25Iuo8OnmG+xtWzS3y8ucXD/gHbiws8f/EMPl4pTOMR03HC4bhPYwgOm5Q2fY8JeePS5I/48Vc/wXGccBwn/Nuv/x0fb2+xPxI2u2e4eZjwv/xv/yf+7V9/jefPr/GTb77G82fPcPfpBj/90z/Fv/3br/HFm1f4+sc/wqebW/jpiOfPXsDBYX8/4sPHD7i+vsbz58+TDt73W7z98ku8f/ced3d3Ya44wjQdVX/Z4a/zBW3DWKjJPTs2j+WfLXhqOVZuhZ+K15/hB8M5YOYMZzjDGc5whgg15wUpB1LbGfm4epgZPnyJimyXjBvvPTzkaFrroMm45EfiLFxQjhoOoKJ8aUTNKVUrsvLMa09oNUM24JKzLD6O/tTS+Vnxdwiu2eybQ9MZ71x03s7zyQ6ctHMu+KRX47SXlVyqOkrWoK7UOzVEwbDVZWuDO9ee3SRzzABQef1P3o2iYPKYlCO0sTErDl7enfnIKVEF0t8qxk9waBinJeeMpeEtuz6UM8s6hxsYSD8XjjCSsfUzki8dJbLTNu9uC44QhWjKx6ns1CiUdTvXFW3LBjTSSRu6bdHnk3Ahyk4XZqR2eLUYGcp25QJ/dPIEz7eLvwMfozBxoc+GIiEKykRF0o+pXQC7cMRqeE8Yuh4dxcO2I0lTqjeU3Q0OQzeAEIJn5sMW6E8vlvkxtLmjDt3QleNNoe6CaqNvWRvMsvtIyreLj1JW+FAOFpI2FMNa8N+0C5Dr6dN4g8GeMfkJ0xivYSKAXDlHOurSs2KHZCqbcfRyrDABnUOP6NiCKso59K5Lz4go8EXhReTATjn64qdD+N65LgTMEIrFZ+0IzFWVgaKy+ChQcz5qB6J24uty7Hs9d0afFwnSB+f9mIjzoHCYMedrBAFYbueoAxMnGg4kE+ZMRyjuedd41mU0MMV6dbuWHIZFWZo2LaOK81raPIFxHH2SxVrfSKQcA12OxyMOhz2AEOzU910KVhC+Is6bafJwrof3+RSpyR8DnfQdthcX2F5cAMx4+fpFCCCIPMwR4dPNO+VkJiDtKM6Ow77v4FzY9bYZBnRxh9o4jvj4/lM++YmG2CdhQYh6CbToijLDszjfhG95Ruc4nBJzfYXnV5dgJnz55jWICJvNBr0jdLttktHbzQC326TFSOIOgMc4HUEu1KMXrIPTMw9P6K8JzoVTaQqHaEyUHLsy5JC5numgTFNSWgiU0PxM+kHPublepT/FGauD3saxrveEtNrhiDy2ACb2Afc03wLeS4GIPHlgGk3bZN5w+p3pGLN0GTeRoQwgB9QENiYMXp1yEhvB05QKlv6GolEiArwPMlMqJEp6s3xKvpqjtipzDJAiBCITKEkAE4fQA87Hygf1LeuDLAscFPUGBroY/Baa79I89VMI4AOrYMm0wDOBOOMhPJHgakMV6yegAzruogyn/FzaHpEu7IVaX6j2A6HtIgN5IQBLdKWsP8Uj4NOilktzVVRvYsKm38QxiPM5BpFIRyd8FS0lnUiPm9J/kp6Q1Amz+Mb1xawadM6lIBDhH07zk9C4gK5z6IUvggGPECAEAqIq3VFX0BmBQB2hKwJEovpG4UIjZg+fTYUoS0U3AQCfddYgMMNclL6G6GChgzjl03ND9PPcJ0F2SD90EpcX8BS+qvSD2ICUxlEIFDoJqBLIBaCIEC/SB5qZzQOVdkb3NVA0op+tWWR1v0bjRAMAnZOAFyTC0cve4dAw0i8TXwmkzfN2FChzovMgg9VvlYfNeNVOvsnFUyq7xTNkLlq+ofGSOannYXxZ2AvyrJY34dQYliWfQS7f+qMYtU1VVWSg+sOLVlAgCz+V6QVvsU0cQgCaLkvTmrQ3jQ0yn0v8LWRu02cSTiXeHXWLMhAo9WWrC+niUzmSplFuVV4Q0Lv2clrSkZKgWJbdKmfmdadA4jc2SCMiKchmBqGramFQf75Am4sochi36hytdUllnqX5mYVFu6wWmq18jtBpnWuhqKII0bX1qYvyV7PTkhxiUNK5tO8kfHcu106x3ba4Kh9K9eTTwbJrjtVci3p2oWci2bvSbqFdsSlKBLL9QRF3225a009a803ZYrMs9ZKK+csmXeHLqczFWoCKTdPCU4O2zWVzi/V3FDzIPLd+Duvv0JuKQpDXhOORMQybZDNKGSEpY5pGEBH6Ppw2DCL0/RbX1w5uGDB5xt3+CGbGxARHHe72e7AndHAY7yd8+nSLT59u8eMff4XdxQXGacQ4eQzDBh9uHvDf/+EfcXNzi7/+5d/g229HfPX1zwAQ/vnXv8M//fO3+Jd/vsGbVw6de8BmeI2vf/RzXG4u8Zf/4Zd48fwKu90Gndvg5uYjvvv+Iy53F3h+/QwED4bH4fiAYbODR4/ff/cJ//a7X+H/+vt/xLffv8Or16/xl3/xH/Dtb36FF88u8PVXP8KbN69AjnB//wkgxjgeMY4jCA5d1+NwOEY7vzd+pNr4zgOEl2A+znlcH8M+T5EVou+e4Q8H54CZM5zhDGc4wxkMlApwMDJPiQC3YKPZtSIclPfy6PakLMfTN7SCnxY7ZwaLGLZthUkuJ2njZ43PqGy32tUoT4pq4mH7q3CkxDQ6f83vxIga59wBUQSIsBh/Kg0DIF5RWKn4yD1bLmTlAJWFfm847+JyfnKIZKe8bazKY2hpEfecsPZ0sQxeeBcJcLFW25aszNd3mFgDUefTpyvYWvNClcUv57f1zXcLzAqYgS6nhufcaTnPL0jJwp0EvZQBOPOygp8iB0cB9X7Sn7MyOR9Pn/zEkXSDP8Zl747mJcbBl+an7jPrTGc1Tgv0nBa+4oJTYIOCfwgMy35SCdjJDgRHIbCtFqwEBEcTN8al3V8GuEwvGNYcYHXHSs3RI+2O80RSMlJQVeAtPtFD6bbMO2A750C99JJBGjmvdtDL4lEgSakvhQoClBdBwiJUpl1BZ+aPd3J1QT5lKzkzZYEWSMdC52ASRPqpTR61C906L4BykbTGY9MjdfqbtEdoNpbvpI1G7rD0dSEP0ogViFW4GsAMWRovssJUpfSKutOT4Fb0jNluJ+YKTvX6E/4k5fhIAw7TFE5kmiYP9sDFxWU4WcCPYA8MQzhFQV8/pp1C4rAnyqeZhZ33hI7zyQwpwIcchuEiLWJQLG+KDsBxPGKaPHrX4+LiEl3nkjPy6uoqOJQpnvSwP2KawklSE5fOV81Pa05UeeZcX/CfTPtqHgHYDL36zeg7SnNN942fZMeog94d6F28KkTJQoGQ38oLwIGzcz+2xyd1hLL+k+hfyT3U6a6UNfKulH22n+wzKa/m6Nb1lTIM68AhoGTdgTinfFLjNvf3Kw0v8cRQjvdyGo4EK4f3IgFs4EuxyC5lUQi0CkEC6sQmqS+m1bqFo/kJTxk/jXf+bnUS9bLgVFltzTw4Kwbl2CY+K4HVevykRO/DInikGaE5imUSHMjlMRC0Z+M4+5l5sp2XogvI+1qAZCvYyGmbaxYkPJfXc3pJ31KaYl7qHeORtHTQT1akcpuzbaLwte8qfWTbeQpUF58ajSzHO/T3NE0QO3RpJ3V5NYPI8yk90ye7rC1aybH84TcA5Lzhl+SVEw7rZRXttfXkl8t904BZXY125YC7k4ot5kEoaCV9A9+aPbSWJ9Rf70fhUy3QNNzkYUZHLvAwY9jS14t5G3W8lKaFniqitoBqddIZXpTHUfsebHssSBprW3yOOawX5k4tV7+WeVO3cSt5QcVnM42pY8VlMqPTJbpdAstXTlp4DAkfXdcSDq2yTxvzlc5q5MlFV3xLuugVWAuyeyqcXC7N09bm51L+xwBLQKye45Tlhe4yn0UbcvCX0lnWEEjpqtbj+rMkwxbmR1Ayg9bqDC4E5EhTLp5TjkAV67g5L6xqwpW0QZ1+/BwORZ1Qr5LnUj8RhYB7o5Nn2VDxYVfwFvm3zHPn+qa1kVoBMrXftjx5L3jICdGiZwEUT/YJ6fXpj3pzHJBPlGQAYzwx8mKzw6e7O/jjiO+/f4/37z/i+uoZ+n7AdrPFze0nvPv+HQ77PV68fA7qekzscTge4P2Erifstg5/8s1b7PcvcXUx4M3LZ/CHBwAO19sNXj/f4V+mPZ4/2+GrH3+BP/nmR3j57AJ3n26w3V5iv9/j7vYWh/0B437CP/7D/42Xr17hJ3/yDW4+3GAz9Nh0OxzGCd+9f49f/ctv8en+gOcvXuFPf/oTXOw24OkBr148wzdf/xivXr3EdhuC13/7299iGHocDnscxxEvX7zAxcUl+n5Mp+SIvaVP7JQ+b/mtl3j4PI8ez2a2J8Ifhk+fIcM5YOYMZzjDGc5whghVQyUtstQdjacY8za/LtMqZC0jv4XDScCNAJdaeZT+WTByWk65+btkxizYdAyzGCR9o8sWBxpxLk4c57HOwj2RDL7SeSSLIfrZOpAxsKRVxvFaGGdAq58CCuI8k70l2dKejXUsb9E5teiEqrdJ/Fe6T3TfqqTK0ZsdFtYQJll8KdoqC5+A7Y+cfu4EtTAnxXbfZiwMXTxh/ugFHpmvEviyNCdzGIJ+n2lRFpRnQXEG9KLDvM3hd3kli108ygsXeacmQl9QTufIhUU9Tn6YGU61BdJFB7FyRjcd3STknV0g7FldtT3Pm+hTpr7uGhbfSNqHBuEHlktINyxB+V4vMtdocj5GpUNenCf1OmQ+6EW5ss/Lcp2bP8tp54GBrE6Ayg0TGUZlHo4LGhpBaSIzVElgCovIyTlEkj/Of2b4Cp7s827eEv/cDzOHIpsvxWsynyaf4ndyUo8rHIaRTohiII0Bxd7Lvq3Q5wyPzG9r+OQ1H0o0HfrvNEfjbKG7goPQoAQAzJ16gOdwtBJzvHYBBM+EcZyw8fGYfhJ5yBjStR4e43HE5MOJT84RhmGIV6GFHW1CNGHuB9zkBBfBNASkxdN/pgnjNIJAuLi4QD9swZPHZhhweXmFrnM4Ho8paMZ7j+M0YRpHjNMxntIHhFOCyLQ1LybU5krAs5MlrmIoUwBN0iNmOWMXlbsDZb6KzpLnWuDTqS+Ufkgu8ObylJQwn4rd3VFGc8EDkE4IoPQPRx3D6pco8tV0pJauWg/0mV8vJr+Xdeb6LkyNm/g9dZsAACAASURBVOUXEujT5uXq+o/wEzryrziRRUaccxIC0iJCkifpXyAtSiQ9UfUdM7gDvCd4nmYdzerTyaktsQwPNtdalf1XCziw/R3IyacyEj1yxjvzpBKfclEnpBS9PMyB4KwPQZehFM8e7Oc4CUnZ01IsaP2NkGlrHsxWXkVo37cc3U19bbagYd/HnohBuqVeVtcFynmk02i+u7xYon+3HPdLbTvVxqnpZ60yWgFCNvhwzXY+xaY+dQxFttk+Fl5ck4Py3pa7NB62nS2o0aZ995RAgFa+pfpOwXGpnqXxawW0lLyZqrSw1s9LYOtZG49T58naItiSzVej3TX76Mk+Hcz7+NT0FrSsPpW+nwpPpc813ndqOTbfY9p5iuyog31PlWen1NfOE2ySerueymd+CA08tY/XyrN853MBi7Ul9RQKv/mM+lOhK8ljpVc+HkMJdqLimYA8Tf0pSsUa77NFmgJneD5iuFjwOCVdA2ZU/hh5Ke8q5Wmdv0qPauxWodbPQoeia6pydVpS/JUUzkXbimLnskjrs3oOpGfOYapcBes5XqkNFCc/in3tfTgVsncdHAi96zC4Dn4c4YnQuS0uLndgvAQz4/nzZxi2A5g9ut6hA6HvwxXDb794EYLOCOhfXWD/cATAePmsx9dfXuP2p1/gzasd3rzc4vqyx+3tO4zjEcAW43HEYb9H58KJhX3fIfjwPIbNBhfbLfpuwOiD7n+x22Cz3eKLty8w9A7j4QHj/Xv89Cff4Msv32IY+nA6NjiePuvQ9+Hk2WEYwJyvYDseD7i7uwcRYbPdpBNXJz/la704tGuN96zpTE+Fz83vzvA4OAfMnOEMZzjDGc4QYWaQNH6f+m4pz1MVq5bRv6hQEc2MklOcdo9umz7jWhY8o1NYPqvZQNAL/aCggIvDPCZKH3kht46n5LFXfOh3M4d+w8EeWoLCI144xcqKi0xrO2HyQtd8l2xY1GzjPC+rgndabKikp7ijDJiPDef8enFFcE7+A2PExS9l/+h2mfrlSdMRVX2q85v00t6IZzIeK+mKslD2ca3f9QIJs9r53RwTBwnZyEmXHXZ2wcG2d4lX5PTSp/E75UXUNNamjUQEOAJ7tfjFa/XUcW4tpui0RVk87+ewnqEdRdmzU3WcKT6Ql+4U3VLIvMzras9qfa7bUCtv7shvjesSD3qsw7OGazufBAuctkiQ0rDmKRpPLhbqhWXk2gzP5HJRc4Z7zO8bY6Z5xymQyuDyN7O5fgrCN9wi7zHkWcevInML5yLZPkEObDB4LkFTZin2pPUD7xnOZdms/ybPcQ083kcGQtcNMf0enieMU2wJAYf9IVzDxMB49BjHEOByf3+Hw/6Aq+tLvHjxDH3fI58wFh15PuMGxKs+HAWHGcJJBtM04Xg4ou96bLdb7LZbEICh76NTKwQU7Pd73N3dgdmcyiHX5gCJK+g+K+l+HmgUXuerEHVazChnDkLXqY0uXBMl41PUl4riAleK/8kGUU7tyafYpH6084Kyk1bmaaFTGSp35hoVKdsguAqaryzJ6fqialh00DJDlxmeZR0pvJNdgfM2cfwnTatEczGoiS0dSKKF9ul22rysQmSFtwHhOlCrG6m55ygERum+67oy6MLyzYRPg3/r+mp9rvOyorscxKjTcsGj9E7MlF8USqAIaKkx03xOzxzSzCLKV0Ii62lWbojjW7fP/k5lL+he3iw4WP7gfSV4V6v8MxsnaqJGX9BzP9B7sytmOGvbxupVNXjMAuOSzmlpzuJhdQk9JvoqxrzjeZl+a/pCC0+hz/jLtKEsv6SLPCZr+nUNN6u/1do107PNu5bduTamtWdrOqPNt6T/2TbW+EZtHGo0tFZXDb9TdNJWuhbOa2Wv1bn0/tT0ut9OLW9t/j4Gr1PrOwVqNN2iZ/1e8tbqbNnhazziVLC2yxpv+eFQ02PqPhkLc9ViOVPW2R5HY600jxlHy8+W+MSpUJM9NrjrKdDM5whUObE0bK5IWAEsgcbJE5ne/XD64XLc03XWQSe1GzlOGV8tHYvnn4On1PSrE2RP6/2a3HqMHlPTtdOVoTBXtlXyF/UaXAqbWuoxcyHrv8uBlgWuXPGRVdIWbdNtqcjkSXSugFzSgSTpNE0YhgFEhLdv3+D161e4v7/H4XDAZtvh1evn2G6/AhFwf7/H8XgAM9D3OyAGpDw8TLGDAOcY222H3S6EGdzePeD6ssNf/8XPMY1H9DTh8HCD7779Pa6vr8EcNsFstxvsdlt8+PAB/9Nf/QKdI1xebHB9/QWGocdxZHRM+OriDb788Rvsdju8+/57fP/ddzjcfcJwcYFXL5+D/YiH+0NosQOev3iGcRzR+x7T5HH3cMDx+IDjOIKZcTwc8fHDe2y3G7x48Ry7XY+ud+jh4hWcHO12Ttc3iampx6Jml1ke9lRZ/bll/BkeB+eAmTOc4QxnOMMZBBaU2pYiZN+Vxa07h2qOqVMM1fLZ3Lg2OWdPrKOzBqcazHXHUDixQtK0HHACnbkbfsnJ9RhHk/1ux62GW83QOqUO+7z1zh5lLvfcyk556xxoKdtPoRnbD9Zo1AsRLSdVzUEu72r1A2aRCev9uva+BWv4rM1VuxgjMA9oajtjl5zDshDUApkH+nhQ731cdJ63oeW4kmqmyafFK1m4mOJRrEBe2JL6dHnlsfoZv1qdYA53PNn+pXx0u+5XPffsmLX4a32hBLO8tTSOKJ3IsOa0RVosL5+3HL41mvHeJx5bcyrWHM1Lv1vOd0kr47fEJxPNpn/mUJ5WVAZU1MrSaWvfW2D7q3A8IDgjPc8dEKeWfwqQc+icOmXBOj6oHfL4mEWFBK4cRysHavMgPC/Ly38QzBVd1svSDj/m2LfexwCacILMfr/H5IHLePWS7u9hCHefj6OcIOMwDFt4zzju9/DxiqbN5gL//Ktf4+///r/j2bNn+Ku/+kv85CffwPsJrgeGoUPfBd2gdy6yjCzvUrv7HpebDswXYbcZJhwfPsF74JM64UtAL4SWjk5Rjko61gv6LR2mplelueyqZxDNeFuRRxUmx2pLAA24QwqFoTi3Y+SYZ71AzgUvs3VrHGp4L4GVXcJXTpGjNji5wCHSn9UZ5U/4VvgeAlJrPK/Wt+U7oKbr5v534jXOzxPvzuWs9dHSVSS6Pv2b0ebjNV5PFE652u/3Rf8gynGZv8ycaFn653g8ouu6YnFAy/PavAHyGIoeqmVZi/eu2UV1WU4FvjX5WdPJGXUeqQMy5E/aovWpGu2kvm7IPavLtWSq/a5p3db5GPmlcVjCp4Vva75YnK090NLx5bfQXKtO/UwHy9TaU+ubMC6AzNXW4lbM1WxbTZfKn3MdpsWjbF5NM7PgsdjWGk+06Vp0b9PZZ632tUCPl712oAa2bjtG9Xldx6/1/jGwNO/W8mg+U2vDTFdq8IjanLK6Q6udNT6xxBPsPNH1ntIftTa3+qw1t06RhRbnpXwtPaI2R9fmwWN56BJ+n8ueWIKn1FnTcdbqsDRyCn+o2flLdbVoakluLkELP/3cbr55Kh+RvIUOxB7MHulo1BouANSxt6GcUFgSI1nfhQo6fjwU4ycVESd7oNWmPxY8Zb60ZDBHG7alIxGV9oH81nyjRuctvcnK3FJ2h/G388jyeNsea8e3+E2Tp0V6AfLp6hrWxtbqvLZu6zuUthKh6NeYAkQdrq+v0PfPARAOhwNub28wTRP6vsdut4NzQ+G3HoYhBd2wZxyOx1C+C5tf7+7usd1u8NXXX+Pq4gLMDl9/9Q0+fviAj+8/4su3X+CL16/R9z2GrsP11QUe9nc4TgcQAR4Thm0+7YWZQNjj9ctLvHy+AwB0roOfPD58vMXtp1scpwm73RZus8XD8Yjv373Ht99/wN1+wu7iGh8+3oJchxdXF3hxsQXgcHNzD+d6vH3xBZ4/f4ZPnz6BwTgc9hjHI4ZhgHMO43EMJ/fEvg80CdWHdd7r406h1oj+MefxGU6Hc8DMGc5whjOc4QwVWNrJsGbAy/fWHe+qFpA+Dx6y4NVyOCyV9ThFq+Y8n5W44PhYcqbq9lsHVK3MP4aSuOYwbj1bcjgsOdGYOTnrbR12Eco5h81m0zQa5bssZNi6a2ORje2snFsjsJW31k5taNYCfmoOvlo97OcBOtaIFdxbhqbuC73wqWm6NWZrc1JcJp7DYprux1lZFK8n8PmkCsHbSZ+FBpR9sDCR7Q5cIiqDydIaZOkUq41faAJhmmQhNhjJwWYL2HqPmQM95GM410F28WfayQsNwruYs2MjLMCHnRnSl2m5Pqx4pWdMDMclX6u1ReopH5/mUC7np/U3kflO6RvLHjLVN3aRSNdlnRU1p28dp7lzs+aEr9FtMNTzuGSZheLaMF1X8O8FJ1/Nod4KuvkcjsolKGRKbITmAafCY9OzOjFrRg7I9MIMRagMS0kGCcUzMv+1bhJCyVtqPNtzuH4nBA955I1keUEx0XbCz0FOe/M+OnO8h+ccJOdch64f0IFwf38HZmDYbLFzDv3gwnVZ8SolRyGQ4fb2FkM/4NOnO+wPe1xeXOLv/uvf4ebmBr/4xS/wV3/5l3CO8Bd/8ef481/8FI7CaTBDL4v6oe6+69B1G4zHI5jDySuBdsN1UXKCF1Ho8tDmOZ3rudKpAB+9OA4AXfAMAkUf5SFkxIqgruNB8I/XeLXlUTX5JaBxkeAYOX0hpWXOPEfPPQDsQ3BTcSUTKOBmcKnxGzLlQeg4ygJpKwViCw/EL8+I54BQ2p0IqvVf6gggJslLD/KvapvwOR+rRAwGEpxd5mtrcq7GUzXosZnxbSAtgkg2kWUiK2vgKzRhoUU38lnTp3Qe7z0mMKjr0XVhhIRGKA4cU5zmUWb7JLfdrJ+kfHmu5YnQqA2UsX2/BIF3yamFcXEHDhyvg5V2dn0nIRBYWygpyq7IAz3fi3QFrkrupee1TQZ67mQ6EEEg9OjilXEW3xmuVJap85S72OfBQ1KOfLcBGVa3sH1Yw6v2TpdneWZrDggrlbbZdpZ0HenSTyqvtZekDxDbKsFrLtUfPsNO37w4MQ86Xmpr2Qbpv/qpL/GXLsX0W3iWAw3m79McVXLB1qF5km2H5eW1NrV0siWdzdpMp0K7n+bvW3N6SYe0/XAqLkvQ0r/Xytb9Z+WLfK/R1VKb19q3Noa1Ntg+r+Fyapvrz8vyyjry3Azvy7lfg2WZWKQs0guPsDp35tFz26U1Rk8FbT9pvJ8Ky/mfXnaNXvVpZEt5avZgyx5tlUZAuoIGsBKwnqvVFbX5VNbUyHdC/1laBnXxxtiGf4gaiDLAfi4zZuLflFU7yUbyE4ltH8eGRPtDsBVqPKBZFyvPhoElX1hjjEkQTMnKdLW+F30q97n10dV47PydyFRKJ6AmVIu0kj7rGFnPDvoIg4gVX9H1SJ9oWT/rgaL98/ZSNJNiGZFPsdiwjGCikwMpfVnaZ8ta+03Mc6oVPZ+o8EHa91C6Z/YZZX4KBP5xcbFT/FXbsj28n/B3/+W/4nA44tWr17i8vMJ2u8XFxQWeXz3Hm1dv8c2Xb1P+4/EIP03YbDfYdi/hOodx3OO3v/112ozgOW4AQwdy4vMds+2KLo6lw+Hgcdgf4ZngX1/j5pPH3T2jHwZcXTzHhw8f8fLVF/D+Er/7zT3+23/5exyPR1xeX+Dt29f40y9f4T/9xz/H7c2HYLV0Dh08pvEIR8CnuzvcP9yHK6/2+9DncBiPE+4+3eP9+w/Y7/f4j7/8JV69eY1xHLE/HsE84eb2FswhePpw2OP9d9/jYrfB82fPcHV1BSLC3d0dxnGcXTO7Rmdn+OPBOWDmDGc4wxnOcIYIjsqFT1HS9U6yrHi3dxfVoGrw0UpAjRgjyiix+nurzkLh4qq5FIy9JT0sLVTXlThb35oDr4VzzTn0Q+CHOjPWytWGmH7e+lwrs3Sqzh17zHJdgk4jY8fJcSSLqIKbc66wv5jtuMwdetp5r3HMBmhp/GpjNRiihPIaC2NOG6efOMD174xc6WiUtNIH4eqG3D+k5lNtEcrWWxjoqlOYOThPpHBq7QgIu8D1dTRIxnJ4T2lRQNWyQOaSNtjVoQ+IKK5lKieBLPJSMLgLo1gcLETRoPXRaRJ2f6Rd9qZdQk8A4mJH6fCX8ddOUsHG+9BPxckUqp/kI3dF6DsJLLI73fW4OdeZsRd89S7kOu9huyus4VAtFqoSxgRyXeEkYgk2sf0XHQmhHEXjmg2nhXn1GwDidTShNNmpkud4bmOuKtEJWOFWNDW3iyRIqRzjJYek4F/IvPQSJbB6xql0k7jtIJS3WsoRx91WppqVOJVH8f5QZ3YntuSXLK6V3rPye8kCrBOuSAnh2bN5qx2KMaOMWQjscYgeNoA4dTuDMfkpBrmEd0QSGONSgAamCeM4JvqZpjC2fT/EMSZ0XTg5ZT8eol8v4OCZsdls0PcDLgnYTTvsdjv8+S/+HIf9A16/foWuI5AjXFzt0HXhOqQQrMPhyjeEZfLJc8Q/UjwD7ONIOIA9YmAAEj9ORFaRT+U4lfIqLa5WnLKSp3ACSzVm4PIQCcVwokeKLWHP8N4GcsYxJB2kQDKoUvpsLgZHeVyU4hC4Z+k7cSrW80S3g2KXZTpkopxEoVD05gyvzGcL/hv/LYPzFH/UTbRMQ3QNDnfFywqDBFqQLDar9iT5rlmryKMk+kr8EueT/oifOSjLRWd12fRCVyoc/bklltXkAAAlQYpiSj4jOpOcxFjQJoXrycJ1aCWtc9RLiEo9MGTrgC7qPpEyU5GuizyFSjypi+JLUUMh2+b9mnUNFZAdxz5LUC2fkeYyk8jfmE+1ocBXt01YADxcooM476TtCt/cVyqYRgqN2HrO89xKKSmT88SPHZGvitVB1VoG6zyFtJ8TzIyGBNecpB4YXOYjo6+FZ1m/p3Td2jSF3fQSwCi4hfxl3+sxEhWLXJd6R+uCur0MqMB4TQeqoCQHMx0D+Vq4uX0jbSJ0ncILOU0Z0FK2JdddPsvXq9p3ZUDqXJ8p5Xw5RzUfyGW1giBqcKoeUyvrMcE2Nk2t3sfa5TU7uLRx23ns95P8Gw1cywVIJceUjqrNTSvfat+tnLY641qgTCs4YQnm9njCQJ4oWWBx0n1Q78/SnmO00Fr2/wge4beX4FvFe2Qel32Qy9D2X37PaRxrPgmNl6Wvtb4+1XdXpC/0hNPm6B8DCJFOgMCH2chwGB1P0qn8DCTGm+g3Piu5W8xT4y0LNNIKNKascM8b1YBT+v8xfCu0c9kfW6Uh5BN6gTkNVoGAxdNsoq6bpq+2GbVOTIhXNTHs/JBWSd+SklEk+hxnvW6mmmA+JJaX6eYU+cy8y8EgSXMIWr4LOPhg8BUFznkXJ7+aq9GKwcIzA2JTxvodOWiNrFC3QXFjwoQsr12UFVz0ne6L2nWgyfeKeSCKGBBZT9QMcHH6KLxrfE3JCMrjyko/nulyMUX2Z6PAR5edN7XEMeZywL765scgAJeXV+i7HuQIwzCAccR+P2IaR7x/9wGH4yFs1nEd7n//Pf72b/8WNzc3+Prrr/Dzn/8MF5cXOB4OuL+/x9X1FV6+ehGuaSZgHKdEPcdxxDh6/Muvf4+7/RGXV9d4+8WP8JwYL18+w+tXV+h7h2HoQX6PDR3w9uWAy7/5U3z1dgcGsNkEv8dm2+Pu/gauk403DsdxxKfvvgMA7A8H+InhqAMxwU+McfJ4OEy4e5hwf5jw7sNH3B0OuDyOuL9/wPv3t9hutvh0d8Td3Q12uwE//dnXePHiGuM44f37j/jN79+h73a42O2wu9iBwHDEuLzcpdNDpzFsQqSO4JVNUjtRWmhD61tn+DxwDpg5wxnOcIYznCGC5w4T92CeME0jLi8vMY5HdI4w9CGimWNQwDR6+GlKDoCu68Dk0266rutCRDSy8t+5HlNxdF+AliMguxWzOVBTgVqLnZKjtdy/aFA+QtdqLULXgi9q9becerV3S+WciudTHYAC9qqVGr6tttecbPq50Erp+AGYXUEbuV7tjEwm8swZpVqjnmsKQ5G+ljeuDzTTaudj/u5Ue4HsVNMGvFPO/Yyn7CTR/Vjm0X0xp/ui1cmhqPtNzTdGMi0JBEeMvPMjIW9AxloF5yRn7LzPMi5lMI+lHz12yV1QHUy16GToihEXzTuXcNI0xmIwx/anq0EiPwsOhHiiEcvJCzHghlRglZcGlosCtu+rc0Q1kHSZqi1610W5Kz4vNLp47CvA1d102YFh6q/QVQ1365itMUft4NFBLDOeo/qnvNqDkjMABb3FOUoUF81lEbTtXUmOT6m34Syu8cPWNUGyKDh3enJRV+ZFur9j+xTfYTXuut5i7FHSEzPPrtUq3oWZO6ujBrKAyi6fqGTbUOsHvbjWXgSy8iyXwcWcDdefjMcR4zhid7GL9BuvWiEHD44nROUAmMMxOJQ2mw12ux28nxBOcnCq6lIOWWeeHlc5sln4wjR5POyP6Pse3cYFR+PA2Gw34TS0KRzH3HUOP/3pn0TnZ3Ychz4Upy6BdeAtETwIPHmRVNFBH5Or02W0rEByqmty1u3KY+ecQ9e5gjfqcdT8wC6mWBkir2RBWs85me16vFkPrnrjyKUTfiLmKKCiC8jj4JSdinqEgeedjDmYVhyxckIQKPcfR97S0kMMUkr+QI1FfBbrnYdzZ/21xiu1vqJ94kn3QT6VxOJTK9HykvIFzWUCAwQXHeGhQNEFmJN7uRTk8VkI5Mv6ktVBcj2lLtfSFwHA7uxM+SMa6U/mBAfeyBR6y8NHGZ1lesIv9hiBKryTMvsWfihSqMH/gEBzLAF7Vd1deEvGBUDEM7QlyZnIc2QMisElIQ51Ioiiyfxd0xuCTlIDRWvSP7bP5m0p8ZE8WaxGIk7zUCdXgTg1YRTnpuhmxdipMor0nBc3NI/M/Dw3tmxSTpdOKYp6b5o/Qh/xVKuOXDEejKw7VoEoIV7gb2lEeEbsn4xLpj19SgFYArLVWFFR4IxuJF2r3/MsU7vVbV/rT1uMeU9QOkSaSVn2fs7Fi1ZZWh+xC3hLsKTvtGzYGi4tmdLSNZf6pLroo/p6ljYUnr9LcqUDpCFzlOKO9cDmIV0eq8SSje5g26fLmtvt9fQWWv2vn5dyw+avy6msM5QyJ29CENyWA51qkMu3zxJWqv5a+9v6SLW+9Lo8TUFoYVaD4rGkn1VstAL5zziHPztoHipzB0omArO5qful9t2mb9n2knZ13jTlBpI+XPPh1PT3NailWbT31zYvtiB2stXxpL7ad8m33Azr64ufqdKo/8y6y8w7MIjN2T4hYrmcTYppUkxSmTkz3jPHWrJxPGnSzqUyLUs7NB9G2Eyl9Qlbi7VFZliwT4HZoVmECjZFluhBKnQSjnbA0lDVZCdH/BgAO+Ef0jokXUdD3kKCkji0DhaVTza5oLtKMTat60vgj9b0tXystCy1p7BlkE/KCbY04e3bL0KAf5dPpyUKdus4efjJwxODug5d18fgJWDYbjDsN+iGAa7vw4a7zsENPajrMU7A/f0DxnHEw8MDnj1/hutnz+H5gP3hAe8/fMDD4Yjd5SUuLrfY7QaMhz2myaNzPfzkcdzvsb+7w/MXz/DFm2e4vOgwHo8AgOPhiJtPd/h//ulf8OrVawxDjy7ai8fjEcPQg30YNWIGPMMxwzNhcD0udtcADdiPwG/+/SN+/+4Oh4c9/Djh2eUOnSM4dujdAOe2/1979/YruXHgd/xXJPt+Zs4ZzcwZjSw5kTZax0hsx46wSR4CJFjkn8hrsH9g/oYAftjdvNmwYyuw11pZGs39ck7fSFYe6s5mnxlpHSNIfz+ANDPdbLJYLNadRe12O212nb55/EbPn73U+5fv6+LiTLPZVJOm17Sxms+m2m7Wur5eSzKaTmeaTBu1XStT15J1D5n0vdVk0rgJPX1qG4V27Ttkk3hHTJgBAMDb7TvtW1eRbNteq7rxla9WlZlq0ky07ztfyTQyxs1G7rswG7hV2+0lo/h+z7ppNJvN1DQTyVTqWj+gJKt9u1fb7tV3vSaTRpPpVJUxmkwnklIjLLwPPcwq7q11E3cqo77rtN3utNvtJMm/e7QZLLucatBjDbtj4ix1WzZmhq2Hg8HgVEePvUvhnItGZNbhbfLthx29GvnMaLTx+7ZOuIMwZ98dm8gyXFFo2AF4rHE+ts27dTwdbj/WKVYO4Iemp2JHbZp4Ef5dnnveOXYYL2Eb6XAJ+fxPxw36DJ5cjucS+nJM3Gd5jun1Z/mxx843f1Xa4WBN2i4MXuUDquMNbKMwjpk1V2Wy8zOhgz6LhrwhHdLiwaSVQfoMA/7p6Q9bNIBN/Cw8GeQ+6fPGtTHxKhfJzmQr/FiTOmR6q7brtNvt1HW9mqbRarXSfr+XbK+qdpOV0uQYKbzSpWutqio89Vu+Pi40oGV6952P3oMYzm/ecP5xgpTUda27rnUdnwBq2zY2xGOnhUmDbGlQPrzWJK3AVHY0pXTuViDKG5EhXfo7xqRXAIylk7FXIt2UD+QdS8NBjLwTxxg3WSlfZSmFUDFPNcYof2Z72OE1DMfYK6LyNDn8Pv88f2Kq7Bxz/y7DmkKRrzRhzOHEm3BZ3O/LfRYTGPo+60DLrqXvxDLGxKWMU0T1vtPTTxZT5SeS2PibFJ0my6LSjT12D4ewuXjoY74SD+t+GDufqsrEp2vzDizXCVf5652eDOo7q+12p+12q9ls7ju2/X+Vm7yy27nVXqbTqeq60X7f6vWbKy2XVtPZ3K3YIjfIGMpZGf/EXNe5iTbGvSat8fmHMSZO2Aqr03S9q1e49BieoKvVNLVbeca4+6jrKu33O/W207SZyZjKvbbJWtmuj+H3URPTgnvFW95x5/LcPH+I0xV697ExfmKZUYp7a1Pno8knQnZ+9RqpjpOHrIxJg2VjgwDHymdrQ96Q0v1Ng5A2S1MuPP5VV7jBagAAHPtJREFUff5+cBNYUmds5fPQMEnB/c6qqt1ExFAq1FWtsDpVXhOLhU/8JJUZ4fcuCrJtXEIs7mm/ZviR0jE/r/xc317nuqmuk8d3mbeGPNwHLb//Q1jGOvL9//Kn2UNsVZVb+jw+9Z7dA2FQUNY9AX2Q/dsUjnDX5/XdeB4hDCa/TinibHbOw7gbrZdaVyYPfxPrn1I8hzShdWTg26bJEaGeEuM0FPfxnjLZIEdex0hlZTxPqxgjIX8NYRy+GvOmenc4p/zPse+klKm87RUTuVTGj9cPQ5jSyiam+O0wLHm9cvy8xsuOsfJ9+HtrbXqV58gxsoq0+33aUdpfyuhSmMM2xqiqjYzN7res7lr7V6P1sQ7hNjgYNIp1UKU8ZpAPpdd1ZnfCIGwx7OH6ZNsN6yd912Xl7GFeffDvkTQV4zU7zlg7Im6fhzU/v3CNRsJStIVtmpx6LCc0g+s9/Hy47zDxI9UdQ6yVeckwqlMaP54nh+3SfTvMn0Ke4OpCMZ8etPXSOUipjHa/zW+D8reHcRhWDbWD/R6EudxhasP5si7mbflxKrnl7uL3Kd+7MWdJ1UXJT7zJA3FTmXcsvY71Rdz0+36QxkL5HM4+5POhzElXJ+X7WaSpvAbZcfJXwWXxl9UcsjxUKZ+IAUr9EeHhhlCPyc5q9FxjYI7/s6h/j7GHiTGez0G+FPLWbJu4j3A/HA/pn9Bhn8y7GquTpfO02Xb5inblwb5tn9q7lsPHjpfX5Ybf55fFZuk1//dBmohtuHzf+YB/vq3bJvbvFPXiss4V/jzaj2fiDmOayUtEG/OY/Acpvy3joDx+cZiQl4Z9mViaFYFxu7GpUA2f+9+EP4u2bB4fMRAp7aS64A311z4vp8rJ6u4PE/fbhzrOMA+KtdsQxnCscAwflzeky6OvXn9L/hwmDWenr94Y1br5/iriwIRoD+HMHh7yOw19GAeKfHn42SBfD8c05f19LFw3hfmw3uvS1OHqYFVMJ6HdGvLG/PXuIQ0aU6tuajUTq8vV/VgX7rpOZ+dLPfzwPxfnmlY0rmVUab9rtVnvtV7v9OZqraqeaTa3qqtGy/lC792+pbbtdO/WSrdmtYy1evr0uTabtRbLhW6dnenp89eSterVaLOzevnyudbXV6qrSk3TaL3e6dHjZ5Kmms6mquvKvUp6OlFvK726utZ+t3Mr8DaNJpOJduu9mnqqs/mZbp3d1nJ1S89evdazFy9l+07nZwvJbrRaLrVcXqiqZ/rm0Wv9/vd/1PX1Wk+ePNV8PtGHH36g5XKqrt1pMZtoOZ/K9r3WvdWbN1eaTKaaL5aSqbTd7bRcLNRMJur6Rl3faTqZarfv5PoajNq2VS+rvuvVdodtDnw3TJgBAMDb717Ltm80n89lJo3269cyXaerqyu9etHpzp072mw2ms1munXrllbLlWrVevH8lZ48fa7r641kKqmq9fnnv9PZ+S3dufue7t090+2LCz178o12u41qU2m/7/Tomyd68/qN2nany8v7unxwX8ZIt2/fVte16rpO+/1eW3/M3b7VZrPVZrPRfr9XM5lou9no66+/1ldffSXbW/3s3/5Md+/e1Xw+T09F9zYb9EsNnt6vdpPqyqGSayRryoZO1md2vI08qLQXT3q6VkR6ctCGfirZbljdP2y0lJ3qvlGsw4q/C+/bl38e68wffi+lBkA+aSZ/TYlrDHeDY2bxOAhP3ohMA//l9cnPKW/859uV5yuF1xONdZ6mVnP4LjSAQkP1sCMvhC9cj6KTycqvMFDH6+EGJccHSMYGGsPgQ95JUtd1jHP3RP3hqwrC38P7iNOrFUyxr+HvjjmYHDCI+xTBgw6McJ72ML3lA0Z5fLqO/16d6Q/uxdApWXaSpAF8Uxt/7/VyE0AqWWtip6+R0Xp3raaeuNUVeqvedpo0RlebjZ49f67Neqfbt891/t59bfavtd2tJfWqG2mxnMqYXvtdK7uvNZ8utd3uZK3VbDbTfD7zHdhGYQng1Hnu/vTLFwzSbug8qRQ6pU3ICyT11v27MpVsHFQ2quoqewrdFn9Wxq3WdXzQKqaAwd/LDrPYAWOtjOmLeysfnIiDHln6tta9omY6narruuI9xGHSSVVV6jqXN9R1WtI2TydhZR93n6R7ND9m+C+sBBLSfZ52hx2dwwHWPB8bi6s8TGOdpu7vVqaqDvYxzNdSnJqDdJ5vn/87hC91jlVx4C4OWhujvkt5b1XV7ndGqpup+r5X6+NzMmlcGdq7CSNGfvDSh70LrwrK7tWQn+Wv8TFViv+uyzpjTXVwfi7/CBNCBtfCWj8U0xXxVlWVVquVzs7OVFWV2rZVXdduOWO/37qWn8TSqqpmWiznms4eqJfVrt1r37qJuUZW23av/X7vnpLqOlXGPaE0m0wkY+Siy7rvJXVtF+O7riRTS5NprdXZIp5b13UxHU+nU1VVrclk5tNTrc1mE9Nn3ZSTfW026JJW13H3ojXj+WYctO3DtZz4/MPnn/61R6GzNXRNV00jazpVdS1bGW23Wxfm7DVxKZ2Fa5SvUpXXMSSpimm6bV19LKSR0RVqjBsQNMZNcinTUSVTN7HDU3Ir7bjXJnZpQoXx8VOnCU3WZBPQBvdRuD+srPZ+glh4fZr1S5271Q672LHZ+FfcDTv203mnfDJsI5OuV25Yzo3d00PHVrEqNxp+5u7PMGk8r2ekwaxUJ5RJu7DWp/F42JTP1j4NhX3m+W7vJ+6Fax4Hz4b1A//3YkKnSwguRH3v7v+Yt5X59Xh5mfKdvI4ev6+qmD6K+DcqXhGZztSm6vlgX2kfNn6nLB7jhybtwqUvfyf79BfCEepxQyE//U5iu0TFuRoN60zDzv+xyecuPZvB78L2YZthPTDkBcfaDGUd2+dx/rd1XRdhyX93bABjbMDsWNiUlUXFQHf259hxxo6bX7/O9uqzOB/WkYZ1XVdHtarjwFpoH5hiH5JiueImUpbhHZ77cAJNHg/5fTMWp3nbLb+/hnEZ9+UOMhr31kp1XR3Uk4b1nVD/u8mwTnT4XZlHWJvaY+nzMqihvpriw6ZXMrpfHYRjWB/LlWnpWHhTXNf18fJBMmqaw9VZU/yX7cFyR6PBezdZGZdCKzfhZWTnY4cqr5XSrW7KB1Hy7cba6u73MQMe/f6m/MyFL5/wFtJClr371TZjuzuGMQxQh3CXr5WLdaQsT/FfF9sU5VUIs6+kh8na8VxC4IafjcRJ3O/g85vywXBeg2/8fZHf6+6iDdvq+b5yx7b7do6k5Xf63aFj8TD8vszPrS+g87K9D1/K9fPddM+++/HdNtKRK6xQn873l/ZZTmItwzGcRJRf38PjDPPJEK5QHplYp3H/7sPk/DorA0bKlDzcMWw264esyrLkoIzO/+77SsZWvh0eN5Wtvg1u8vgo48Da0Bb39Y28TqzBlYltsUF0+SRjBl/4knxQNrp2XX53hzxH2f13rN4U7pG8/A/1usO4y+MpTOIe1Kf9hsfu23e9h8JxjKlUm1DfLdPE0bqgVXhmLf67+NOEtt1hOguTiEJ/UV6fS+d+qCzjB+23YfiKMna0tMvKtLJ/I6ygP9zfzfmk+314EM7tVzLG1TPnM/fQzW6313631XQ6UWMqLeYTzW6f6d57t9W2rZ6/vtKvf/O5fvm/fqXvffiR/tnHH+u9hx9ovd3KTmd6udvr8dMnqmS1WE41mRjt241un5/FsD95+lgvXrzUYjHXfO76OJq+1727ZzLaatI0ms7nqidzWdV6/OK1/vbvfqFX1ztd3H1f9+4/0PJsqj/89h+0qnp98v1LffjRHX380Up/de8jVZrp+mqn9fW1qslGVjsZSW9e7/XHP7yQaXv99re/1eMnj/WDTz/R5f0LffmPv9d2faU757e0mt3TYrFQ17a6OL+jrpe2W6vN6yt98cUXurx8oNVqpa7vtN1sfZqRZI32u1Zvrt5oMZ/LVEb77eG1wnfDhBkAALzbt+baba8l7dXUE1krrRZLzSaNrq/X2q63kjVav9lofbWV7BPt962ev3itqqo0m89V10av37zQy9ePdffBhepKevT11/rHL77UnYs7qpuFHr98o1/95nP94le/1t/8t/+qD793X/vtlbbXVzpbzKWu19NHz/Tq1Wu9evVK3zx+pOVqobv372m2XKk3tfrK6qtHj7WYzvXjH/1M/+WvL7V+80aVMWoq90qZvm91tVnrqyfPNF8stFquVNW1rq6u9NUfv9Lnn/9v9b3V+e1zv+zfRFVV6+LiQvcu7+v84rYkq+1uK2N6NbV76tU9eJgGvl0rpfIDEmUDwPGNU2t9Az5UmFPDY4yRyTpaskZ+kDWwxxqqw8/77OkHd9zQ4HJHyzu+QmPa+FUL0r5T4zusquIap/lvQ+POZP+F36VOKGsrhcZJ34dGY5XtW8obNtZKXZfCUXYIpO3T+YSnAFOHZNp+2FkZOqtsfO2YG6h0Dab9fl80eCTX4V0O7Bw+KZmHz70qoy5+m3cYHK60kYc9dD7m8dIrdDqEeBt2muermfSDCVzu+D4ewpWqTFwuVNn+8k7X3rolRm2fXpMSJu64TqGykydP67LunbRuSc1eVYiDysgtROs7MY2RehWvfXO3kZXx/7lVHVxYVFVaLRo1dThfI2vdpKJby6VW87m/BrX26zeq1Wk5m8bVGyaayEiqm159ZSX1Wq0WMe5dB2x2rxn5zjb5DreQxvuD9BAa/X3fx9WvwueTpopD3kZuGd3aTwxJCdYfN14+Ewc/y07TskM3/NaFsVPszPHnVPtJOS5vsG7VDN/J7L4r31Ed0mb493a7jSt7hfQdzjv8PR8oC/dGWkGnyuIinVtVVWr8KwB3u12cRLFcLrXf71TXtabTmdq2U9ft4r0RBlDc+bR+lRCruq40m838K2F8ftOpSJ+pA8oWnw/zynyQ7HjnZ9nZqXykteCvTbp6MQ5iIeH3WRk/6cC4Aej4NJPvBLU2rVpjrdVut4vxO1Y2hHivTB3TrmT98rt1dq4+dDZNdAhpYNgpmudddV2raZr4ede2Wm826rtOy+Uym/xU3h+SiklW15u1tvudZKVF1Wg2nWrWNJo0UzV1LSur3X6valJr33b+3d6tbNvJ+DBXJuRJUmfCiiZO1bjXPqX8zsV107gJaWFQM4+zfBAy5mGmUm3chKRQNFkfd23bpnu/rlNHauOWZk4dpb3Pz8L94PKydt/LTTRyT51PJzNXFvaduraXMVZN0/jJQJX6Tuq7XlXVKEwm6WP1IUx0CemgvA55523K092/Q5zk90D4LpQhobZgJE18WRf23eSdmsatDti2raqmjuXUwR1i3eSu8I+U14VB5NCZ7SdshGJGveRf4yhrXOekn0DT9f41JL4OZwf5QHm/pu5wa8sJUKk8zsvIUO4NJ0EnRqnOFeNPsVLkjxnKmTTA1+9D/cN/b9M24XoW+b/NrmtR97ExXYSLFfLpXD5BpzwBE8OXcg6jkMgqm9JZ2N5Noisn+uThGQ5GSlLvr0Oe74RV12StX1nKfReff7dhIvpIHWwwtOG2yvPsg58chDNt68Nry3ZA3H+2L5MPyPnkFa/5yP6LwduQ3iQ3EWhQlLg6W7in++L+cBuk1wqFT9NKC8dSaD7Z6oZtDiZxDOunKUnHFRZGdhfaGCHfKdtFh6tjSdaV5VkdPv8zH9BJxxirG72dWz1Mh9fDlJO+hvHU+RMPg3f5/ZDqQqFcChMNJanKJg7ncZIm57vXcVpfvwnfD/PPcD3CbenCUfmJ1q6G6+tl6WzjvWX9vV1MPvT3W75CnCuTUj4crpcLb4q30XGpEJ8j1ybWD7PPhnXq/PP8d3l+NZzsfWzwbZjHDduFRboxWXqPpxfyuEG4QpjTT/MCoMiP3FU/fr/dZCytv21wNP9d3i6QTXlJGHSOAYx1pWwng2s7di8eC+e7nM/bwj92vsOJbWPHy9Ncvo9jaWVY3x1Li9+V28Wx+Bj/PG8zHdufy0tTu8Lf3rH+Ef7tfpPyWsmMbDd+nmkfoQ1lBp9/O981PkN5NLznNZg0kQIe/mdj2PO+r+rI5Nabg5fiO8Vd6GspH7TI69D554fHK+sFw/ZS/p0k/+CNjfW8UN+IfUS9fx1sLJNcn1fqa6n8gyGhsmGLMikvD0O7yRVN2T3oqt1+92Wda8ywz3L031lea0w6tkzeTnHhDCuP5eXUu+Y9eZwX2xqfX+fVOX+NfU0grXLsfugn+2f1olRNdeWsJMV+yphy4v0W70mT/zDL90IFPvs+lN3peO5GjGXt2AmHtOrDXfk6gksv6ZjDVXSPRWNaITSddJqcqOxV0FmzR3KvwZTrjwqTU0KeUuYnpkgXVuX97m4NW/QvhfpInhbCZ3m9bvjgk3R8wve7MMaoMZV/eKmO8Wrk2rbtbqu6bjRtKjXLmazcQzqv172evLrSkydP9POf/1xfP3qke/fu69NPP9VqtdTjb75WVdVaNJWMOu2vX6tte00nU3W20m6912Z3JWusb2O7Ktx0dSZTVbreulW3nz9/o1//5kv98he/1L/7q8/0H/79Z7q7WumrL/+gDy4v9fGDc11fr3X54Jbef3ih3/3u92q2T/XNi1f68ovPNZ02+uyzn6qZ/IMeff2Vnj55otVqqbt37+ju3fd0fn6upplpsZppdXuu1a0fa725lqzV//z7v9XV1Rtd3D5X20pX61b371/KWml560IvX77S1dW1FsszvXq11v/4+X/Xy9cvNZ3PdX7xnv7yBz/Us2dXquuJmrrRi+dP9BeffE8PH15qsph+62uFcUyYAQDA++jDD3T/3l1JoRMzPJ3bq207P1hg4pPv1ronnrf7veqqVjNxnXG73U4/+dE/dxWlyVT7fauu7bRYLN0T2dudfviDS/2n//hD/eRHH+vs1kLt/tzNrm4a9b3V++/f1m6313a302Z9rbpptFgu1EymsRNqfb1WUze6uLjQrTP3mpWu7WTiwGivfdvq+5v3VddNnACx3+/1l//ioX7y409krdVsOlNV16r9KxOms5mWy4Wms5kkN7hvZN3TodbGNoik2Bh0DalQyZY01kCPbWlTfn+sDn60Ted+f9A3XgRs8IuiY2R4YDMI0ljDcrjf1AgpPv0uHSSje0/M4LObm7r/tOPmn4cOz9DYdE9cH4Zr2HlwvFHqG3nKOktix+l4x/toh20IZ+ycMP73MRRF519+XrohjCH5xAHCNFpVfh7uf5WdF64RWHYsl8nc7S92LMdwlB0i8QL4jtuyoyLrBFLojA4dOaZ4gjv2fWXhT8cexK9/VVTRQaybOhdSWMc648KxYl+z328+QO4mLOjgJnqn9D3WUzFyXYtrnu3cyBRPhMn6V9NkHTGxo8aGiR02bhsHH48ENnS8hGNn3Yh+4kpIOz4vy5OaSeVPmERWGaNmMnGdetlEmzDxrDjZvLNJ7toOX2PhljXOElx2/IM4jSeV3RchfrKIPsgbYmfVeBwV6WaQGQ3TT7w/wnUY7jP+Nk0qCBN2zME26dSKfGWwz7Hj5PdwHgfDMi8MBsZBF+vqELJWzcRNFCn2N5Y+jdGu3cfOrKauNZ/NJWvdCkwmrWihynV69b5D2FrrV37Ir4XKdOxDXAwI+WThJja6SSN9fCe5GT3nkO/F181lyaoIjx8ADOdcVWnVqRAXRUd3CHeRBH1alvXvSndfFoPXoQw4KDkPZf2p5ec3jHbY+P8yQRUdk0p5Szjf4aBWyBONGX8SPfw2/mYsjMfCF/atkfsmK3MPMvMxRT6Wxe1IxeRIiTGyz8NtYzylmz6FMFyOIj+KISlLrDJbU3mtbPG5MWUsFHWsmPcPj5mOW4b/JjaF/8h1O7wSJgt/dsz8eo4f6uaK3bFjv+XSjRQFkr3hit+0v3wQJQ9fERirIls8GvaR+to7BeItwZNi2e0+M2VZ/pZBp295xPFztHaQMGx2L0hZZdB/n+d/+e5DOv92YR4sPvDO7RuTxVNezw87yXdTDM5prB4xmOgTB9pskTDeltsPr1m8t4p0V+4kTK4ZVnDKPEcxrzg86Eg6zw9jj9cjQzky3D4LXrn9yAdF/p/99mje5eP0IJ0c1KvLvaTTL69e+bn5094yeXjG8qbv9Dufl2Rl7jtP4hnZdizW0nfp/8MdveMRi+O48t7vs0h2qa165MdjQcjqC+kY+bapnvZtQ/suAfi/bCyzzQubg7JIOpr5ZeVCsdebb/0/vaK+ZAZJ4Ia8yZbb/ZPKt5EbMQ+PdHist/2+CHL4/UG9zGTfl23H8EXef1PWHW3KH/12w/6YvH02Vm8t6iA63Oao/N66cZvjW7hjjiW07OYdqRrdFMLDfGr0L4e/s9mks5SQsj0WFZXyOIO69VgZH3+R7ftoWTb81bAuVSjLsvyeL9NrlpPeVCkdyQ+KfrV06+V/OdqHPVa3GW5b1AxC1p0fKL8Ww/wt3PfD4w/j/2geOP6x+ypNgMruOL8797fwQFQod/rebdN2vdbre/rew9tar9c6OzvT3bt3NZvP1HW96qryfZ7+/uttXLEwrjhspLz/KAbXuocTt5u9Pvvpv9STv/6J3n/wQA8fXmo+n+r731vobLXShx+s1LatFouFFsulPv3kjq6ufqDN1j3MJhldXt6XZHV19ZG2m40m04kW87nmi4Vms1lc8cm9srvzr0xq48q1c79NXVdaLBaScavUbnfn2u9bTSZTvf9grn/z04+12W7UNI1m87nuvHdXm81extSqq0rb7UYX5yutVkvduTg7flHwrTBhBgAA7/z8ts7P/1xHezD4dyNpmf379nfY5/hS6AAAAAAAAAAAAP8v+vQvPvzzH/TSTTh58KAcFHr48M6fMRBpTOjh++f61//qkz/jsRHc/HJVAAAAAAAAAAAAAAAA4P8zTJgBAAAAAAAAAAAAAADASWHCDAAAAAAAAAAAAAAAAE4KE2YAAAAAAAAAAAAAAABwUpgwAwAAAAAAAAAAAAAAgJPChBkAAAAAAAAAAAAAAACcFCbMAAAAAAAAAAAAAAAA4KQwYQYAAAAAAAAAAAAAAAAnhQkzAAAAAAAAAAAAAAAAOClMmAEAAAAAAAAAAAAAAMBJYcIMAAAAAAAAAAAAAAAATgoTZgAAAAAAAAAAAAAAAHBSmDADAAAAAAAAAAAAAACAk8KEGQAAAAAAAAAAAAAAAJwUJswAAAAAAAAAAAAAAADgpDBhBgAAAAAAAAAAAAAAACeFCTMAAAAAAAAAAAAAAAA4KUyYAQAAAAAAAAAAAAAAwElhwgwAAAAAAAAAAAAAAABOChNmAAAAAAAAAAAAAAAAcFKYMAMAAAAAAAAAAAAAAICTwoQZAAAAAAAAAAAAAAAAnBQmzAAAAAAAAAAAAAAAAOCkMGEGAAAAAAAAAAAAAAAAJ4UJMwAAAAAAAAAAAAAAADgpTJgBAAAAAAAAAAAAAADASWHCDAAAAAAAAAAAAAAAAE4KE2YAAAAAAAAAAAAAAABwUpgwAwAAAAAAAAAAAAAAgJPChBkAAAAAAAAAAAAAAACcFCbMAAAAAAAAAAAAAAAA4KQwYQYAAAAAAAAAAAAAAAAnhQkzAAAAAAAAAAAAAAAAOClMmAEAAAAAAAAAAAAAAMBJYcIMAAAAAAAAAAAAAAAATgoTZgAAAAAAAAAAAAAAAHBSmDADAAAAAAAAAAAAAACAk8KEGQAAAAAAAAAAAAAAAJwUJswAAAAAAAAAAAAAAADgpDBhBgAAAAAAAAAAAAAAACeFCTMAAAAAAAAAAAAAAAA4KUyYAQAAAAAAAAAAAAAAwElhwgwAAAAAAAAAAAAAAABOChNmAAAAAAAAAAAAAAAAcFKYMAMAAAAAAAAAAAAAAICTwoQZAAAAAAAAAAAAAAAAnBQmzAAAAAAAAAAAAAAAAOCk/B+LF1OrgGpSywAAAABJRU5ErkJggg==" + } + }, + "cell_type": "markdown", + "id": "353b76bd-2315-4f54-92d2-c8fdb63cb088", + "metadata": {}, + "source": [ + "It is also possible to open this file with qgis: open a new project, load the netcdf file (this can take a while and QGIS may stop responding for a moment). Three layers are added:\n", + "\n", + "- A tabular layer\n", + "- A mesh layer\n", + "- A raster layer\n", + "\n", + "Keep only the mesh layer. You can also add a map background (google earth, open street maps...). So far, your project should look like this:\n", + "\n", + "![qgis_load_ncdf.png](attachment:2861c41c-a656-4287-a6b8-d7623961fb25.png)\n", + "\n", + "In the mesh layer options, you can adapt the colorbar values range for a better visualization. Finally, open the temporal controller (see details [here](https://www.qgistutorials.com/en/docs/3/animating_time_series.html)) to display an animation. The raster layer also has temporal information, where each bands corresponds to one date." + ] + }, + { + "cell_type": "markdown", + "id": "2dcddecf-e2a3-4cac-8ee1-55198a902e4d", + "metadata": {}, + "source": [ + "## Zarr\n", + "\n", + "Zarr is a modern, cloud optimized format. It stores data as compressed chunks, in different files, making storage and access highly efficient. Let's create a .zarr containing 10 dates arrays of size 1000x1000. This could represent 10 satellite images (10 different observations) i.e. a time series:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "200c6f8a-e2d9-4ebc-b4ca-5f029ff97553", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(10, 1000, 1000)\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import zarr\n", + "\n", + "sample_file = \"./sample_data/data_cube/example.zarr\"\n", + "n_time, n_lat, n_lon = 10, 1000, 1000\n", + "\n", + "data = np.random.rand(n_time, n_lat, n_lon)\n", + "\n", + "zarr_file = zarr.open(sample_file, mode='w')\n", + "zarr_file.create_dataset(\"data\", data=data)\n", + "\n", + "z1 = zarr.load(sample_file)\n", + "data = z1[\"data\"]\n", + "print(data.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "f6585705-f4a0-478e-a21e-5966d45e96f5", + "metadata": {}, + "source": [ + "A new directory was created, with the data. We can check the number and size of the chunks using:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "5a40f0b4-556d-4db9-a5de-9ce8584a94ee", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Name/data
Typezarr.core.Array
Data typefloat64
Shape(10, 1000, 1000)
Chunk shape(2, 250, 250)
OrderC
Read-onlyTrue
CompressorBlosc(cname='lz4', clevel=5, shuffle=SHUFFLE, blocksize=0)
Store typezarr.storage.DirectoryStore
No. bytes80000000 (76.3M)
No. bytes stored70046233 (66.8M)
Storage ratio1.1
Chunks initialized80/80
" + ], + "text/plain": [ + "Name : /data\n", + "Type : zarr.core.Array\n", + "Data type : float64\n", + "Shape : (10, 1000, 1000)\n", + "Chunk shape : (2, 250, 250)\n", + "Order : C\n", + "Read-only : True\n", + "Compressor : Blosc(cname='lz4', clevel=5, shuffle=SHUFFLE, blocksize=0)\n", + "Store type : zarr.storage.DirectoryStore\n", + "No. bytes : 80000000 (76.3M)\n", + "No. bytes stored : 70046233 (66.8M)\n", + "Storage ratio : 1.1\n", + "Chunks initialized : 80/80" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "zarr_file = zarr.open(sample_file, mode='r')\n", + "data = zarr_file[\"data\"]\n", + "data.info" + ] + }, + { + "cell_type": "markdown", + "id": "d97a3579-ee85-4ac9-b896-ae61cdb18d54", + "metadata": {}, + "source": [ + "80 chunks of size (2, 250, 250) were created, meaning each chunk contains a quarter of two images. However, with satellite images, it is generally more efficient to access one complete image at a time. In this setup, opening a single image could require loading 2 to 4 different chunks, depending on whether any chunk holds two quarters of the same image. To streamline this, we could adjust the chunk size to store only one full image per chunk, with each chunk shaped as (1, 1000, 1000). This configuration can be specified in the `create_dataset` method:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "6d3602b9-48c7-48de-ba54-180277ea56fd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Name/data
Typezarr.core.Array
Data typefloat64
Shape(10, 1000, 1000)
Chunk shape(1, 1000, 1000)
OrderC
Read-onlyFalse
CompressorBlosc(cname='lz4', clevel=5, shuffle=SHUFFLE, blocksize=0)
Store typezarr.storage.DirectoryStore
No. bytes80000000 (76.3M)
No. bytes stored70068822 (66.8M)
Storage ratio1.1
Chunks initialized10/10
" + ], + "text/plain": [ + "Name : /data\n", + "Type : zarr.core.Array\n", + "Data type : float64\n", + "Shape : (10, 1000, 1000)\n", + "Chunk shape : (1, 1000, 1000)\n", + "Order : C\n", + "Read-only : False\n", + "Compressor : Blosc(cname='lz4', clevel=5, shuffle=SHUFFLE, blocksize=0)\n", + "Store type : zarr.storage.DirectoryStore\n", + "No. bytes : 80000000 (76.3M)\n", + "No. bytes stored : 70068822 (66.8M)\n", + "Storage ratio : 1.1\n", + "Chunks initialized : 10/10" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sample_file = \"./sample_data/data_cube/example2.zarr\"\n", + "zarr_file = zarr.open(sample_file, mode='w')\n", + "zarr_file.create_dataset(\"data\", data=data, chunks=(1, n_lat, n_lon))\n", + "data = zarr_file[\"data\"]\n", + "data.info" + ] + }, + { + "cell_type": "markdown", + "id": "ab1259f6-2477-4a13-916a-27a5c825e4c3", + "metadata": {}, + "source": [ + "Only 10 chunks are then created, as expected. If images are too big to be loaded entirely, it would be possible to chunk the images themselves. For example, splitting each image in 4 smaller images, creating 4 times more chunks using `chunks=(1, 250, 250)`. " + ] + }, + { + "cell_type": "markdown", + "id": "fac1c87e-1c41-464e-b4b1-34500dd7f478", + "metadata": {}, + "source": [ + "The [official zarr library tutorial]( https://zarr.readthedocs.io/en/stable/tutorial.html#reading-and-writing-data) presents many more concepts and optimization methods. For example, using `write_empty_chunks=False` will not write empty chunks, improving both speed and storage size.\n", + "\n", + "The `xarray` library can also be used to manipulate .zarr files:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "5a91f3ae-d609-4472-8f48-2784e2858446", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Size: 80MB\n", + "Dimensions: (time: 10, lat: 1000, lon: 1000)\n", + "Coordinates:\n", + " * lat (lat) int64 8kB 0 1 2 3 4 5 6 7 ... 992 993 994 995 996 997 998 999\n", + " * lon (lon) int64 8kB 0 1 2 3 4 5 6 7 ... 992 993 994 995 996 997 998 999\n", + " * time (time) int64 80B 0 1 2 3 4 5 6 7 8 9\n", + "Data variables:\n", + " data (time, lat, lon) float64 80MB ...\n" + ] + } + ], + "source": [ + "import xarray as xr\n", + "import numpy as np\n", + "\n", + "sample_file = \"./sample_data/data_cube/example_from_xarray.zarr\"\n", + "\n", + "data = xr.DataArray(np.random.rand(n_time, n_lat, n_lon),\n", + " dims=[\"time\", \"lat\", \"lon\"],\n", + " coords={\"time\": range(n_time),\n", + " \"lat\": range(n_lat),\n", + " \"lon\": range(n_lon)})\n", + "\n", + "data.to_dataset(name=\"data\").to_zarr(sample_file, mode=\"w\")\n", + "\n", + "\n", + "ds = xr.open_zarr(sample_file)\n", + "print(ds)" + ] + }, + { + "cell_type": "markdown", + "id": "698e85dc-d83b-48e9-ab5c-4f68c8be422a", + "metadata": {}, + "source": [ + "As an example use case, we can load a COG file (see the [raster formats tutorial](./raster_formats.ipynb)) and write it to a zarr, using `xarray`." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "9900959f-8859-4c49-a6f6-74027ba59d8e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Name/band_data
Typezarr.core.Array
Data typefloat32
Shape(4, 2080, 2410)
Chunk shape(1, 520, 603)
OrderC
Read-onlyTrue
CompressorBlosc(cname='lz4', clevel=5, shuffle=SHUFFLE, blocksize=0)
Store typezarr.storage.DirectoryStore
No. bytes80204800 (76.5M)
No. bytes stored35688703 (34.0M)
Storage ratio2.2
Chunks initialized64/64
" + ], + "text/plain": [ + "Name : /band_data\n", + "Type : zarr.core.Array\n", + "Data type : float32\n", + "Shape : (4, 2080, 2410)\n", + "Chunk shape : (1, 520, 603)\n", + "Order : C\n", + "Read-only : True\n", + "Compressor : Blosc(cname='lz4', clevel=5, shuffle=SHUFFLE, blocksize=0)\n", + "Store type : zarr.storage.DirectoryStore\n", + "No. bytes : 80204800 (76.5M)\n", + "No. bytes stored : 35688703 (34.0M)\n", + "Storage ratio : 2.2\n", + "Chunks initialized : 64/64" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "input_cog_path = \"./sample_data/rasters/data/xt_SENTINEL2B_20180621-111349-432_L2A_T30TWT_D_V1-8_RVBPIR_cog.tif\"\n", + "output_zarr_path = \"./sample_data/data_cube/example_from_cog.zarr\"\n", + "\n", + "with xr.open_dataset(input_cog_path, engine=\"rasterio\") as xds:\n", + " xds.to_zarr(output_zarr_path, mode=\"w\")\n", + "\n", + "zarr_file = zarr.open(output_zarr_path, mode='r')\n", + "data = zarr_file[\"band_data\"]\n", + "data.info" + ] + }, + { + "cell_type": "markdown", + "id": "bdc7d9d0-77c0-4981-8246-c38c53648c70", + "metadata": {}, + "source": [ + "Another useful cloud-optimized library for dealing with datacubes is [kerchunk](https://fsspec.github.io/kerchunk/). It can be used to open files in formats discussed in previous tutorials (zarr, netcdf, (geo)tiff ...). Kerchunk generates a JSON file that contains an index and metadata for all the relevant files, enabling efficient access and management of large datasets.\n", + "\n", + "In order to keep this notebook concise, no tutorial will be provided, but you can easily find detailed examples and documentation on the [Kerchunk website](https://fsspec.github.io/kerchunk/).\n", + "\n", + "## Formats comparison\n", + "\n", + "In order to compare the 3 presented formats, we need an equivalent data array. In order to keep the code simple, a function was written [here](./utils.py) which creates a random numpy array, write it to 3 files (HDF5, netCDF and zarr) and read them right after. This allows us to measure the read and write times as well as file sizes. Here are the results:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "1f4055fc-03f5-4a9d-bb91-eddb0f94a20a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Write times:\n", + "\th5: 0.469 seconds\n", + "\tnc: 0.979 seconds\n", + "\tzarr: 0.889 seconds\n", + "Read times:\n", + "\th5: 0.329 seconds\n", + "\tnc: 0.005 seconds\n", + "\tzarr: 1.373 seconds\n", + "File sizes:\n", + "\th5: 800.002 MB\n", + "\tnc: 800.008 MB\n", + "\tzarr: 701.546 MB\n" + ] + } + ], + "source": [ + "from utils import compare_datacube_formats\n", + "\n", + "comparison_directory = \"./sample_data/data_cube/formats_comparison\"\n", + "compare_datacube_formats(comparison_directory, (100, 1000, 1000))" + ] + }, + { + "cell_type": "markdown", + "id": "57969276-ed04-442b-913d-615160ccf515", + "metadata": {}, + "source": [ + "## Conclusion\n", + "\n", + "Datacubes are a powerful way to store data, even of different data types. Many different tools can be used to visualize and amnipulate such files depending on your needs. Each format has specific technicalities and details to optimize read/write time and file sizes, so carefully choosing a format for a given use is important. It is also important to choose the right tool: for example, for a quick visualization of data, `matplotlib` can be sufficient and may be easier to use. But for a more interactive plot, while keeping a simple code, `hvplot` can be a better solution, especially if used with `xarray`." + ] + } + ], + "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.11.0rc1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/data_type/readme.md b/data_type/readme.md index 67a8ea2..673a298 100644 --- a/data_type/readme.md +++ b/data_type/readme.md @@ -4,10 +4,10 @@ Geospatial data allows the communication of information in a wide range of field 1) [Raster formats](./raster_formats.ipynb) 2) [Vector formats](./vector_data_formats.ipynb) -3) Data cube formats (or multi-dimensional raster) +3) [Data cube formats](./datacube_formats.ipynb) 4) Cloud-optimized formats - For each of these tutorials, sample data will be used, which you can visualize using QGIS. +For each of these tutorials, sample data will be used, which you can visualize using QGIS. To run a notebook, first create a virtual environment and install the required packages (if not already done) @@ -16,4 +16,4 @@ python3.11 -m venv venv pip install -r requirements.txt ``` -Then you can simply use `jupyter notebook xxx.ipynb` to run the corresponding noteboook. +Then you can simply use `jupyter notebook xxx.ipynb` to run the corresponding notebook. diff --git a/data_type/requirements.txt b/data_type/requirements.txt index c1715cd..a691aaa 100644 --- a/data_type/requirements.txt +++ b/data_type/requirements.txt @@ -1,8 +1,11 @@ geopandas==1.0.1 +h5py==3.12.1 hvplot==0.11.1 jupyter==1.1.1 matplotlib==3.9.2 +netCDF4==1.7.2 numpy==2.1.3 pandas==2.2.3 rasterio==1.4.2 -rioxarray==0.18.0 \ No newline at end of file +rioxarray==0.18.0 +xarray==2024.10.0 \ No newline at end of file diff --git a/data_type/utils.py b/data_type/utils.py index 60b6e6a..064dd39 100644 --- a/data_type/utils.py +++ b/data_type/utils.py @@ -1,11 +1,16 @@ import io +import time import zipfile +from datetime import datetime from pathlib import Path +import h5py import numpy as np import pandas as pd import rasterio import requests +import xarray as xr +import zarr from rasterio.plot import show @@ -77,18 +82,24 @@ def show_raster(input_image: str): raster_data = raster_data[0:3, :, :] # create new range values for visualization purpose - flat_array = raster_data.flatten() - lower_bound = np.quantile(flat_array, 0.001) - upper_bound = np.quantile(flat_array, 0.999) - mask = (raster_data >= lower_bound) & (raster_data <= upper_bound) - filtered_array = np.where(mask, raster_data, 0) - min_val = filtered_array.min() - max_val = filtered_array.max() - rescaled_array = (filtered_array - min_val) / (max_val - min_val) * 255 + rescaled_array = rescale_raster(raster_data) show(rescaled_array.astype(np.uint8), title="Raster Data") +def rescale_raster(raster_data): + flat_array = raster_data.flatten() + lower_bound = np.quantile(flat_array, 0.001) + upper_bound = np.quantile(flat_array, 0.999) + mask = (raster_data >= lower_bound) & (raster_data <= upper_bound) + filtered_array = np.where(mask, raster_data, 0) + min_val = filtered_array.min() + max_val = filtered_array.max() + rescaled_array = (filtered_array - min_val) / (max_val - min_val) * 255 + + return rescaled_array + + def download_sample_vector_data(download_dir): data_dir = Path(download_dir) / "departement-31" output_file = data_dir / "landuse.shp" @@ -106,3 +117,137 @@ def download_sample_vector_data(download_dir): assert output_file.exists() return output_file + + +def generate_hdf5_file(output_file, raster_file): + # assumes raster with 3 bands + output_file = Path(output_file) + + if not Path(raster_file).exists(): + download_sample_data(output_file.parent) + + if raster_file: + with rasterio.open(raster_file, "r") as src: + image_data = src.read() + data_2d = image_data[0] # 1st raster band + data_3d = image_data # all raster bands + desc_2d = "st band from a raster" + desc_3d = "RGB bands from a raster" + else: + data_2d = np.random.rand(10, 10) # 10x10 random array + data_3d = np.random.rand(5, 10, 10) # 5x10x10 random array + desc_2d = "Random 2D data" + desc_3d = "Random 3D data" + + with h5py.File(output_file, 'w') as f: + # Main group + group = f.create_group("data") + + # 2D dataset (lon, lat) + dset_2d = group.create_dataset("data_2d", data=data_2d) + dset_2d.attrs["description"] = desc_2d + dset_2d.dims[0].label = "latitude" + dset_2d.dims[1].label = "longitude" + + # 3D dataset (time, lon, lat) + dset_3d = group.create_dataset("data_3d", data=data_3d) + dset_3d.attrs["description"] = desc_3d + dset_3d.dims[0].label = "time" + dset_3d.dims[1].label = "latitude" + dset_3d.dims[2].label = "longitude" + + # metadata + group.attrs["creation_date"] = str(datetime.today().strftime('%Y-%m-%d')) + group.attrs["project"] = "Tutorial example project" + + +def download_netcdf(download_dir): + output_file = Path(download_dir) / "precip.mon.total.v7.nc" + if output_file.exists(): + return output_file + + zip_file_url = "https://www.kaggle.com/api/v1/datasets/download/bigironsphere/gpcc-monthly-precipitation-dataset-05x05" + r = requests.get(zip_file_url) + z = zipfile.ZipFile(io.BytesIO(r.content)) + z.extractall(download_dir) + + assert output_file.exists() + return output_file + + +def compare_datacube_formats(comparison_directory, random_shape=None): + """ + compare hdf5, netcdf and zarr files: create a random array of size (10, 1000, 1000) and for each format: + 1) measure the write time + 2) measure file size + 3) measure the read time + """ + if not random_shape: + random_shape = (100, 1000, 1000) + Path(comparison_directory).mkdir(exist_ok=True) + data = np.random.rand(*random_shape) + + # HDF5 + # write + h5_start_write = time.time() + h5_file = Path(comparison_directory)/"h5_file.h5" + with h5py.File(h5_file, 'w') as f: + f.create_dataset('array', data=data) + h5_write_time = time.time() - h5_start_write + + # file size + h5_file_size = get_file_size_in_mb(h5_file) + + # open + h5_start_read = time.time() + with h5py.File(h5_file, 'r') as f: + data_hdf5 = f['array'][:] + h5_read_time = time.time() - h5_start_read + + # NetCDF + # write + nc_start_read = time.time() + nc_file = Path(comparison_directory)/"nc_file.nc" + ds = xr.DataArray(data, dims=["time", "x", "y"]) + ds.to_netcdf(nc_file) + nc_write_time = time.time() - nc_start_read + + # file size + nc_file_size = get_file_size_in_mb(nc_file) + + # open + nc_start_read = time.time() + ds_netcdf = xr.open_dataset(nc_file) + data_netcdf = ds_netcdf.values + nc_read_time = time.time() - nc_start_read + + # Zarr + # write + zarr_start = time.time() + zarr_file = str(Path(comparison_directory)/"zarr_file.zarr") + zarr.save(zarr_file, data) + zarr_write_time = time.time() - zarr_start + + # file size + zarr_file_size = zarr.storage.DirectoryStore(zarr_file).getsize() * 1e-6 + + # read + zarr_start_read = time.time() + zarr_data = zarr.open(zarr_file, mode='r') + data_zarr = zarr_data[:] + zarr_read_time = time.time() - zarr_start_read + + print(f"Write times:\n" + f"\th5: {h5_write_time:.3f} seconds\n" + f"\tnc: {nc_write_time:.3f} seconds\n" + f"\tzarr: {zarr_write_time:.3f} seconds") + + print(f"Read times:\n" + f"\th5: {h5_read_time:.3f} seconds\n" + f"\tnc: {nc_read_time:.3f} seconds\n" + f"\tzarr: {zarr_read_time:.3f} seconds") + + print(f"File sizes:\n" + f"\th5: {h5_file_size:.3f} MB\n" + f"\tnc: {nc_file_size:.3f} MB\n" + f"\tzarr: {zarr_file_size:.3f} MB") \ No newline at end of file From fc37617d2212d90193bafc34bacfe6ecdde032c9 Mon Sep 17 00:00:00 2001 From: EugenePlanteur Date: Tue, 19 Nov 2024 11:00:04 +0100 Subject: [PATCH 09/31] style: fix typo --- data_type/raster_formats.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/data_type/raster_formats.ipynb b/data_type/raster_formats.ipynb index 739f7e5..fdde333 100644 --- a/data_type/raster_formats.ipynb +++ b/data_type/raster_formats.ipynb @@ -7,7 +7,7 @@ "source": [ "# Raster formats\n", "\n", - "This section presents the 3 most common file formats for geospatial rasters: JPEG2000, GeoTIFF and COG. The COG format (Cloud Optimized GeoTIFF, http://cogeo.org/) is actually a geotiff format, organized in a way to optimize its usage on cluod infrastructures. For example, it allows the streaming of only the required part of the image, instead of reading it in its entirety.\n", + "This section presents the 3 most common file formats for geospatial rasters: JPEG2000, GeoTIFF and COG. The COG format (Cloud Optimized GeoTIFF, http://cogeo.org/) is actually a geotiff format, organized in a way to optimize its usage on cloud infrastructures. For example, it allows the streaming of only the required part of the image, instead of reading it in its entirety.\n", "\n", "First, we import all the required libraries." ] From e68b422d0aa981380e3c55eef5958f28cee040c2 Mon Sep 17 00:00:00 2001 From: EugenePlanteur Date: Tue, 19 Nov 2024 11:19:57 +0100 Subject: [PATCH 10/31] fix: fix internal references for datacube tutorial --- data_type/datacube_formats.ipynb | 62 ++++++++++++++++---------------- 1 file changed, 31 insertions(+), 31 deletions(-) diff --git a/data_type/datacube_formats.ipynb b/data_type/datacube_formats.ipynb index c837503..476cb1f 100644 --- a/data_type/datacube_formats.ipynb +++ b/data_type/datacube_formats.ipynb @@ -23,11 +23,11 @@ "\n", "![xarray-datastructure.png](attachment:f2298fd0-2dc2-4bed-93ef-be7cb7e4246b.png)\n", "\n", - "The following formats will be presented: \n", + "The following formats will be presented:\n", "\n", - "1) [hdf5](##HDF5-format)\n", - "2) [netcdf](##Netcdf)\n", - "3) [zarr](##Zarr)" + "1) [hdf5](#HDF5-format)\n", + "2) [netcdf](#Netcdf)\n", + "3) [zarr](#Zarr)" ] }, { @@ -150,7 +150,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Read time: 0.00127 seconds\n", + "Read time: 0.00124 seconds\n", "File size: 100.26 MB\n" ] } @@ -836,12 +836,12 @@ "data": { "application/vnd.holoviews_exec.v0+json": "", "text/html": [ - "
\n", - "
\n", + "
\n", + "
\n", "
\n", "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "(function(root) {\n", + " function now() {\n", + " return new Date();\n", + " }\n", + "\n", + " const force = true;\n", + " const py_version = '3.5.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", + " const reloading = false;\n", + " const Bokeh = root.Bokeh;\n", + "\n", + " // Set a timeout for this load but only if we are not already initializing\n", + " if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_failed_load = false;\n", + " }\n", + "\n", + " function run_callbacks() {\n", + " try {\n", + " root._bokeh_onload_callbacks.forEach(function(callback) {\n", + " if (callback != null)\n", + " callback();\n", + " });\n", + " } finally {\n", + " delete root._bokeh_onload_callbacks;\n", + " }\n", + " console.debug(\"Bokeh: all callbacks have finished\");\n", + " }\n", + "\n", + " function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n", + " if (css_urls == null) css_urls = [];\n", + " if (js_urls == null) js_urls = [];\n", + " if (js_modules == null) js_modules = [];\n", + " if (js_exports == null) js_exports = {};\n", + "\n", + " root._bokeh_onload_callbacks.push(callback);\n", + "\n", + " if (root._bokeh_is_loading > 0) {\n", + " // Don't load bokeh if it is still initializing\n", + " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", + " return null;\n", + " } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", + " // There is nothing to load\n", + " run_callbacks();\n", + " return null;\n", + " }\n", + "\n", + " function on_load() {\n", + " root._bokeh_is_loading--;\n", + " if (root._bokeh_is_loading === 0) {\n", + " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", + " run_callbacks()\n", + " }\n", + " }\n", + " window._bokeh_on_load = on_load\n", + "\n", + " function on_error(e) {\n", + " const src_el = e.srcElement\n", + " console.error(\"failed to load \" + (src_el.href || src_el.src));\n", + " }\n", + "\n", + " const skip = [];\n", + " if (window.requirejs) {\n", + " window.requirejs.config({'packages': {}, 'paths': {'plotly': 'https://cdn.plot.ly/plotly-2.31.1.min'}, 'shim': {}});\n", + " require([\"plotly\"], function(Plotly) {\n", + " window.Plotly = Plotly\n", + " on_load()\n", + " })\n", + " root._bokeh_is_loading = css_urls.length + 1;\n", + " } else {\n", + " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", + " }\n", + "\n", + " const existing_stylesheets = []\n", + " const links = document.getElementsByTagName('link')\n", + " for (let i = 0; i < links.length; i++) {\n", + " const link = links[i]\n", + " if (link.href != null) {\n", + " existing_stylesheets.push(link.href)\n", + " }\n", + " }\n", + " for (let i = 0; i < css_urls.length; i++) {\n", + " const url = css_urls[i];\n", + " const escaped = encodeURI(url)\n", + " if (existing_stylesheets.indexOf(escaped) !== -1) {\n", + " on_load()\n", + " continue;\n", + " }\n", + " const element = document.createElement(\"link\");\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.rel = \"stylesheet\";\n", + " element.type = \"text/css\";\n", + " element.href = url;\n", + " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", + " document.body.appendChild(element);\n", + " } if (((window.Plotly !== undefined) && (!(window.Plotly instanceof HTMLElement))) || window.requirejs) {\n", + " var urls = ['https://cdn.holoviz.org/panel/1.5.3/dist/bundled/plotlyplot/plotly-2.31.1.min.js'];\n", + " for (var i = 0; i < urls.length; i++) {\n", + " skip.push(encodeURI(urls[i]))\n", + " }\n", + " } var existing_scripts = []\n", + " const scripts = document.getElementsByTagName('script')\n", + " for (let i = 0; i < scripts.length; i++) {\n", + " var script = scripts[i]\n", + " if (script.src != null) {\n", + " existing_scripts.push(script.src)\n", + " }\n", + " }\n", + " for (let i = 0; i < js_urls.length; i++) {\n", + " const url = js_urls[i];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " const element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (let i = 0; i < js_modules.length; i++) {\n", + " const url = js_modules[i];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (const name in js_exports) {\n", + " const url = js_exports[name];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " element.textContent = `\n", + " import ${name} from \"${url}\"\n", + " window.${name} = ${name}\n", + " window._bokeh_on_load()\n", + " `\n", + " document.head.appendChild(element);\n", + " }\n", + " if (!js_urls.length && !js_modules.length) {\n", + " on_load()\n", + " }\n", + " };\n", + "\n", + " function inject_raw_css(css) {\n", + " const element = document.createElement(\"style\");\n", + " element.appendChild(document.createTextNode(css));\n", + " document.body.appendChild(element);\n", + " }\n", + "\n", + " const js_urls = [\"https://cdn.holoviz.org/panel/1.5.3/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.holoviz.org/panel/1.5.3/dist/bundled/jquery/jquery.slim.min.js\", \"https://cdn.holoviz.org/panel/1.5.3/dist/bundled/plotlyplot/plotly-2.31.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.5.2.min.js\", \"https://cdn.holoviz.org/panel/1.5.3/dist/panel.min.js\"];\n", + " const js_modules = [];\n", + " const js_exports = {};\n", + " const css_urls = [\"https://cdn.holoviz.org/panel/1.5.3/dist/bundled/plotlyplot/mapbox-gl-js/v3.0.1/mapbox-gl.css?v=1.5.3\"];\n", + " const inline_js = [ function(Bokeh) {\n", + " Bokeh.set_log_level(\"info\");\n", + " },\n", + "function(Bokeh) {} // ensure no trailing comma for IE\n", + " ];\n", + "\n", + " function run_inline_js() {\n", + " if ((root.Bokeh !== undefined) || (force === true)) {\n", + " for (let i = 0; i < inline_js.length; i++) {\n", + " try {\n", + " inline_js[i].call(root, root.Bokeh);\n", + " } catch(e) {\n", + " if (!reloading) {\n", + " throw e;\n", + " }\n", + " }\n", + " }\n", + " // Cache old bokeh versions\n", + " if (Bokeh != undefined && !reloading) {\n", + " var NewBokeh = root.Bokeh;\n", + " if (Bokeh.versions === undefined) {\n", + " Bokeh.versions = new Map();\n", + " }\n", + " if (NewBokeh.version !== Bokeh.version) {\n", + " Bokeh.versions.set(NewBokeh.version, NewBokeh)\n", + " }\n", + " root.Bokeh = Bokeh;\n", + " }\n", + " } else if (Date.now() < root._bokeh_timeout) {\n", + " setTimeout(run_inline_js, 100);\n", + " } else if (!root._bokeh_failed_load) {\n", + " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", + " root._bokeh_failed_load = true;\n", + " }\n", + " root._bokeh_is_initializing = false\n", + " }\n", + "\n", + " function load_or_wait() {\n", + " // Implement a backoff loop that tries to ensure we do not load multiple\n", + " // versions of Bokeh and its dependencies at the same time.\n", + " // In recent versions we use the root._bokeh_is_initializing flag\n", + " // to determine whether there is an ongoing attempt to initialize\n", + " // bokeh, however for backward compatibility we also try to ensure\n", + " // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n", + " // before older versions are fully initialized.\n", + " if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n", + " // If the timeout and bokeh was not successfully loaded we reset\n", + " // everything and try loading again\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_is_initializing = false;\n", + " root._bokeh_onload_callbacks = undefined;\n", + " root._bokeh_is_loading = 0\n", + " console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n", + " load_or_wait();\n", + " } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n", + " setTimeout(load_or_wait, 100);\n", + " } else {\n", + " root._bokeh_is_initializing = true\n", + " root._bokeh_onload_callbacks = []\n", + " const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n", + " if (!reloading && !bokeh_loaded) {\n", + " if (root.Bokeh) {\n", + " root.Bokeh = undefined;\n", + " }\n", + " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", + " }\n", + " load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n", + " console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", + " run_inline_js();\n", + " });\n", + " }\n", + " }\n", + " // Give older versions of the autoload script a head-start to ensure\n", + " // they initialize before we start loading newer version.\n", + " setTimeout(load_or_wait, 100)\n", + "}(window));" + ], + "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n const force = true;\n const py_version = '3.5.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n const reloading = false;\n const Bokeh = root.Bokeh;\n\n // Set a timeout for this load but only if we are not already initializing\n if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n // Don't load bokeh if it is still initializing\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n // There is nothing to load\n run_callbacks();\n return null;\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error(e) {\n const src_el = e.srcElement\n console.error(\"failed to load \" + (src_el.href || src_el.src));\n }\n\n const skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {'plotly': 'https://cdn.plot.ly/plotly-2.31.1.min'}, 'shim': {}});\n require([\"plotly\"], function(Plotly) {\n window.Plotly = Plotly\n on_load()\n })\n root._bokeh_is_loading = css_urls.length + 1;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n const existing_stylesheets = []\n const links = document.getElementsByTagName('link')\n for (let i = 0; i < links.length; i++) {\n const link = links[i]\n if (link.href != null) {\n existing_stylesheets.push(link.href)\n }\n }\n for (let i = 0; i < css_urls.length; i++) {\n const url = css_urls[i];\n const escaped = encodeURI(url)\n if (existing_stylesheets.indexOf(escaped) !== -1) {\n on_load()\n continue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } if (((window.Plotly !== undefined) && (!(window.Plotly instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.5.3/dist/bundled/plotlyplot/plotly-2.31.1.min.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(encodeURI(urls[i]))\n }\n } var existing_scripts = []\n const scripts = document.getElementsByTagName('script')\n for (let i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n existing_scripts.push(script.src)\n }\n }\n for (let i = 0; i < js_urls.length; i++) {\n const url = js_urls[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n const element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (let i = 0; i < js_modules.length; i++) {\n const url = js_modules[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n const url = js_exports[name];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n const js_urls = [\"https://cdn.holoviz.org/panel/1.5.3/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.holoviz.org/panel/1.5.3/dist/bundled/jquery/jquery.slim.min.js\", \"https://cdn.holoviz.org/panel/1.5.3/dist/bundled/plotlyplot/plotly-2.31.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.5.2.min.js\", \"https://cdn.holoviz.org/panel/1.5.3/dist/panel.min.js\"];\n const js_modules = [];\n const js_exports = {};\n const css_urls = [\"https://cdn.holoviz.org/panel/1.5.3/dist/bundled/plotlyplot/mapbox-gl-js/v3.0.1/mapbox-gl.css?v=1.5.3\"];\n const inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (let i = 0; i < inline_js.length; i++) {\n try {\n inline_js[i].call(root, root.Bokeh);\n } catch(e) {\n if (!reloading) {\n throw e;\n }\n }\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n var NewBokeh = root.Bokeh;\n if (Bokeh.versions === undefined) {\n Bokeh.versions = new Map();\n }\n if (NewBokeh.version !== Bokeh.version) {\n Bokeh.versions.set(NewBokeh.version, NewBokeh)\n }\n root.Bokeh = Bokeh;\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n // If the timeout and bokeh was not successfully loaded we reset\n // everything and try loading again\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n root._bokeh_is_loading = 0\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n if (root.Bokeh) {\n root.Bokeh = undefined;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + "if ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n", + " window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n", + "}\n", + "\n", + "\n", + " function JupyterCommManager() {\n", + " }\n", + "\n", + " JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n", + " if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " comm_manager.register_target(comm_id, function(comm) {\n", + " comm.on_msg(msg_handler);\n", + " });\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n", + " comm.onMsg = msg_handler;\n", + " });\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " console.log(message)\n", + " var content = {data: message.data, comm_id};\n", + " var buffers = []\n", + " for (var buffer of message.buffers || []) {\n", + " buffers.push(new DataView(buffer))\n", + " }\n", + " var metadata = message.metadata || {};\n", + " var msg = {content, buffers, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " })\n", + " }\n", + " }\n", + "\n", + " JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n", + " if (comm_id in window.PyViz.comms) {\n", + " return window.PyViz.comms[comm_id];\n", + " } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n", + " if (msg_handler) {\n", + " comm.on_msg(msg_handler);\n", + " }\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n", + " comm.open();\n", + " if (msg_handler) {\n", + " comm.onMsg = msg_handler;\n", + " }\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " var comm_promise = google.colab.kernel.comms.open(comm_id)\n", + " comm_promise.then((comm) => {\n", + " window.PyViz.comms[comm_id] = comm;\n", + " if (msg_handler) {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " var content = {data: message.data};\n", + " var metadata = message.metadata || {comm_id};\n", + " var msg = {content, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " }) \n", + " var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n", + " return comm_promise.then((comm) => {\n", + " comm.send(data, metadata, buffers, disposeOnDone);\n", + " });\n", + " };\n", + " var comm = {\n", + " send: sendClosure\n", + " };\n", + " }\n", + " window.PyViz.comms[comm_id] = comm;\n", + " return comm;\n", + " }\n", + " window.PyViz.comm_manager = new JupyterCommManager();\n", + " \n", + "\n", + "\n", + "var JS_MIME_TYPE = 'application/javascript';\n", + "var HTML_MIME_TYPE = 'text/html';\n", + "var EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\n", + "var CLASS_NAME = 'output';\n", + "\n", + "/**\n", + " * Render data to the DOM node\n", + " */\n", + "function render(props, node) {\n", + " var div = document.createElement(\"div\");\n", + " var script = document.createElement(\"script\");\n", + " node.appendChild(div);\n", + " node.appendChild(script);\n", + "}\n", + "\n", + "/**\n", + " * Handle when a new output is added\n", + " */\n", + "function handle_add_output(event, handle) {\n", + " var output_area = handle.output_area;\n", + " var output = handle.output;\n", + " if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", + " return\n", + " }\n", + " var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", + " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", + " if (id !== undefined) {\n", + " var nchildren = toinsert.length;\n", + " var html_node = toinsert[nchildren-1].children[0];\n", + " html_node.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var scripts = [];\n", + " var nodelist = html_node.querySelectorAll(\"script\");\n", + " for (var i in nodelist) {\n", + " if (nodelist.hasOwnProperty(i)) {\n", + " scripts.push(nodelist[i])\n", + " }\n", + " }\n", + "\n", + " scripts.forEach( function (oldScript) {\n", + " var newScript = document.createElement(\"script\");\n", + " var attrs = [];\n", + " var nodemap = oldScript.attributes;\n", + " for (var j in nodemap) {\n", + " if (nodemap.hasOwnProperty(j)) {\n", + " attrs.push(nodemap[j])\n", + " }\n", + " }\n", + " attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n", + " newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n", + " oldScript.parentNode.replaceChild(newScript, oldScript);\n", + " });\n", + " if (JS_MIME_TYPE in output.data) {\n", + " toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n", + " }\n", + " output_area._hv_plot_id = id;\n", + " if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n", + " window.PyViz.plot_index[id] = Bokeh.index[id];\n", + " } else {\n", + " window.PyViz.plot_index[id] = null;\n", + " }\n", + " } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", + " var bk_div = document.createElement(\"div\");\n", + " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var script_attrs = bk_div.children[0].attributes;\n", + " for (var i = 0; i < script_attrs.length; i++) {\n", + " toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n", + " }\n", + " // store reference to server id on output_area\n", + " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle when an output is cleared or removed\n", + " */\n", + "function handle_clear_output(event, handle) {\n", + " var id = handle.cell.output_area._hv_plot_id;\n", + " var server_id = handle.cell.output_area._bokeh_server_id;\n", + " if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n", + " var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n", + " if (server_id !== null) {\n", + " comm.send({event_type: 'server_delete', 'id': server_id});\n", + " return;\n", + " } else if (comm !== null) {\n", + " comm.send({event_type: 'delete', 'id': id});\n", + " }\n", + " delete PyViz.plot_index[id];\n", + " if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n", + " var doc = window.Bokeh.index[id].model.document\n", + " doc.clear();\n", + " const i = window.Bokeh.documents.indexOf(doc);\n", + " if (i > -1) {\n", + " window.Bokeh.documents.splice(i, 1);\n", + " }\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle kernel restart event\n", + " */\n", + "function handle_kernel_cleanup(event, handle) {\n", + " delete PyViz.comms[\"hv-extension-comm\"];\n", + " window.PyViz.plot_index = {}\n", + "}\n", + "\n", + "/**\n", + " * Handle update_display_data messages\n", + " */\n", + "function handle_update_output(event, handle) {\n", + " handle_clear_output(event, {cell: {output_area: handle.output_area}})\n", + " handle_add_output(event, handle)\n", + "}\n", + "\n", + "function register_renderer(events, OutputArea) {\n", + " function append_mime(data, metadata, element) {\n", + " // create a DOM node to render to\n", + " var toinsert = this.create_output_subarea(\n", + " metadata,\n", + " CLASS_NAME,\n", + " EXEC_MIME_TYPE\n", + " );\n", + " this.keyboard_manager.register_events(toinsert);\n", + " // Render to node\n", + " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", + " render(props, toinsert[0]);\n", + " element.append(toinsert);\n", + " return toinsert\n", + " }\n", + "\n", + " events.on('output_added.OutputArea', handle_add_output);\n", + " events.on('output_updated.OutputArea', handle_update_output);\n", + " events.on('clear_output.CodeCell', handle_clear_output);\n", + " events.on('delete.Cell', handle_clear_output);\n", + " events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n", + "\n", + " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", + " safe: true,\n", + " index: 0\n", + " });\n", + "}\n", + "\n", + "if (window.Jupyter !== undefined) {\n", + " try {\n", + " var events = require('base/js/events');\n", + " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", + " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", + " register_renderer(events, OutputArea);\n", + " }\n", + " } catch(err) {\n", + " }\n", + "}\n" + ], + "application/vnd.holoviews_load.v0+json": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ] + }, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "d4e516f2-6345-4305-b493-deb89054be20" + } + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ], + "text/plain": [ + ":Scatter3D [x,y,z] (intensity)" + ] + }, + "execution_count": 3, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "50111b5c-5a35-4205-9a17-9bc322481025" + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "import holoviews as hv\n", + "from holoviews import dim, opts\n", + "hv.extension('plotly')\n", + "\n", + "with laspy.open(las_file) as fh:\n", + " las = fh.read()\n", + " x, y, z = las.X, las.Y, las.Z\n", + " intensity = las.intensity\n", + "\n", + "data = pd.DataFrame({'x': x, 'y': y, 'z': z, 'intensity': intensity})\n", + "hv.Scatter3D((data), kdims=['x', 'y', 'z']).opts(cmap='plasma', color=\"intensity\", size=1.5, colorbar=True, height=600, width=600)" + ] + }, + { + "cell_type": "markdown", + "id": "0e233dad-a3c6-4090-800f-e133205aa684", + "metadata": {}, + "source": [ + "All the raw data is stored as numpy arrays, meaning we can use numpy methods. For example, we can easily filter the data we're interested in: let's say we want to remove all low-intensity (intensity < 10):" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ad3e15cf-a6ad-44ce-af51-db9a3d57b51f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "648 values are masked out\n" + ] + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ], + "text/plain": [ + ":Scatter3D [x,y,z] (intensity)" + ] + }, + "execution_count": 4, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "e378a2af-c7a8-4858-80e6-a19f611497b1" + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "low_threshold = 50\n", + "high_threshold = 150\n", + "\n", + "# create the mask based on the intensity\n", + "intensity = las.intensity\n", + "intensities_mask = (intensity > low_threshold) & (intensity < high_threshold)\n", + "masked_out_values = len(intensity) - np.sum(intensities_mask)\n", + "print(f\"{masked_out_values} values are masked out\")\n", + "\n", + "# filter out the values\n", + "intensity_masked = las.intensity[intensities_mask]\n", + "x, y, z = las.X, las.Y, las.Z\n", + "x_masked = x[intensities_mask]\n", + "y_masked = y[intensities_mask]\n", + "z_masked = z[intensities_mask]\n", + "\n", + "data = pd.DataFrame({'x': x_masked, 'y': y_masked, 'z': z_masked, 'intensity': intensity_masked})\n", + "hv.Scatter3D((data), kdims=['x', 'y', 'z']).opts(cmap='plasma', color=\"intensity\", size=1.5, colorbar=True, height=600, width=600)" + ] + }, + { + "cell_type": "markdown", + "id": "70697226-a9a9-479b-9e1b-99a1a28db831", + "metadata": {}, + "source": [ + "The low intensity points were successfully filtered out.\n", + "\n", + "\n", + "Another important feature of `laspy` is adding new dimensions. For example, let's define a `brightness` dimension which is the norm of the red, green and blue values:\n", + "\n", + "$$B=\\sqrt{{red}^2 + {green}^2 + {blue}^2}$$\n", + "\n", + "Here is how to compute it, add it to the file and use it in the plot instead of the intensity" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4ba22a22-d787-4076-b201-eff1700c062a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X\n", + "Y\n", + "Z\n", + "intensity\n", + "return_number\n", + "number_of_returns\n", + "scan_direction_flag\n", + "edge_of_flight_line\n", + "classification\n", + "synthetic\n", + "key_point\n", + "withheld\n", + "scan_angle_rank\n", + "user_data\n", + "point_source_id\n", + "gps_time\n", + "red\n", + "green\n", + "blue\n", + "brightness\n" + ] + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ], + "text/plain": [ + ":Scatter3D [x,y,z] (brightness)" + ] + }, + "execution_count": 5, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "e98f01c7-aa64-4fe8-9063-4a7fe228b323" + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "with laspy.open(las_file) as fh:\n", + " las = fh.read()\n", + "\n", + "r, g, b = las.red, las.green, las.blue\n", + "\n", + "brightness = np.linalg.norm([r, g, b], axis=0).astype(np.uint32)\n", + "\n", + "las.add_extra_dim(laspy.ExtraBytesParams(\n", + " name=\"brightness\",\n", + " type=np.uint32,\n", + " description=\"Norm of rgb values\"\n", + "))\n", + "\n", + "las.brightness = brightness\n", + "\n", + "for dimension in las.point_format.dimensions:\n", + " print(dimension.name)\n", + "\n", + "\n", + "data = pd.DataFrame({'x': x, 'y': y, 'z': z, 'brightness': brightness})\n", + "hv.Scatter3D((data), kdims=['x', 'y', 'z']).opts(cmap='plasma', color=\"brightness\", size=1.5, colorbar=True, height=600, width=600)" + ] + }, + { + "cell_type": "markdown", + "id": "1fe6b307-e00e-45a2-956c-759d6d79c7a7", + "metadata": {}, + "source": [ + "Finally, we can write this data into a new file:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5601f783-e5c9-424b-82f4-5ddeed1b4e10", + "metadata": {}, + "outputs": [], + "source": [ + "output_file_path = \"./sample_data/point_clouds/output_file.las\"\n", + "las.write(output_file_path)" + ] + }, + { + "cell_type": "markdown", + "id": "8158c87f-537d-4205-83f1-0e7eae81a28c", + "metadata": {}, + "source": [ + "## Dealing with large files\n", + "\n", + "Sometimes, files can get too large to be fully loaded in RAM. In this case, the same strategy as for any data type is used: read/write and process the file by chunk. This is easily implemented in `laspy`. In this example, we want to \n", + "\n", + "1. Read an input file by chunk\n", + "2. Create a new file, which will only contain the filtered intensity\n", + "3. Write this output file by chunk" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "f78d3b81-64d7-4d53-a920-7e32856afb88", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "300\n", + "300\n", + "300\n", + "165\n" + ] + } + ], + "source": [ + "las_file = \"./sample_data/point_clouds/simple.las\"\n", + "\n", + "with laspy.open(las_file) as f:\n", + " for points in f.chunk_iterator(300): # only read 300 points everytime (max)\n", + " print(len(points))" + ] + }, + { + "cell_type": "markdown", + "id": "33a6f86e-a119-49b6-9141-91070bb5a078", + "metadata": {}, + "source": [ + "Here is a more complete example of reading a file, applying a filter to its intensity values and writing it, chunk by chunk:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "c60c5981-b887-4c55-8806-a682a78f8a6b", + "metadata": {}, + "outputs": [], + "source": [ + "input_file = \"./sample_data/point_clouds/simple.las\"\n", + "output_file = \"./sample_data/point_clouds/filtered_by_chunk.las\"\n", + "intensity_threshold = 50\n", + "chunk_size = 300\n", + "\n", + "with laspy.open(input_file) as f:\n", + " with laspy.open(output_file, mode=\"w\", header=f.header) as writer:\n", + " for points in f.chunk_iterator(chunk_size):\n", + " filtered_points = points[points.intensity > intensity_threshold] # filter usefull points\n", + " writer.write_points(filtered_points)" + ] + }, + { + "cell_type": "markdown", + "id": "739c72f4-9777-40ac-be00-d5015f186966", + "metadata": {}, + "source": [ + "This greatly improves reading and writing point cloud files, but we can also easily optimize their disk space usage. For this, we save the files as `.laz` instead: laz is a lossless compression format for point clouds. Make sure you also installed the required backend for `.laz` files (https://laspy.readthedocs.io/en/latest/installation.html#pip)." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "7b9dea08-8dd3-4cb7-b712-09445b939513", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ".las size: 0.036437 MB\n", + ".laz size: 0.018217 MB\n" + ] + } + ], + "source": [ + "input_file = \"./sample_data/point_clouds/simple.las\"\n", + "output_file = \"./sample_data/point_clouds/simple_compressed.laz\"\n", + "\n", + "with laspy.open(input_file) as fh:\n", + " las = fh.read()\n", + "las.write(output_file)\n", + "\n", + "las_file_size = get_file_size_in_mb(input_file)\n", + "laz_file_size = get_file_size_in_mb(output_file)\n", + "\n", + "print(f\".las size: {las_file_size} MB\")\n", + "print(f\".laz size: {laz_file_size} MB\")" + ] + }, + { + "cell_type": "markdown", + "id": "7a0eff85-38e5-459b-b46b-8f39692ae269", + "metadata": {}, + "source": [ + "This is an easy way to compress point cloud files.\n", + "\n", + "## Cloud optimized point clouds (COPC)\n", + "\n", + "As with any data format, new cloud-optimized formats appeared. As explained in the introduction, COPC isn't a different file format (i.e. files are still `.las` and `.laz`), rather a different way of organizing data in the file. For more details, check out the [official COPC website](https://copc.io/). In order to use COPCs with `laspy`, make sure you have installed the `lzrs` dependency (also used for dealing with `.laz` files, see the [installation documentation](https://laspy.readthedocs.io/en/latest/installation.html#cloud-optimized-point-cloud-copc)). Example files for this section were taken from https://copc.io/#example-data. Although it is possible to open local COPC files (like [this one](https://github.com/PDAL/data/blob/master/autzen/autzen-classified.copc.laz)), it can be more intersting to open a file from a cloud, as this is generally how to deal with COPC files. This script first opens the file without reading all of its data. Using information from the header, it then selects a fraction of the data to read. " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "867125e4-d5c1-448f-8ee2-dc1365bc6eb0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The file contains 364,384,576 total points\n", + "92,459,151 points were selected, i.e. approximately 25.4%\n" + ] + } + ], + "source": [ + "from laspy import Bounds, CopcReader\n", + "\n", + "copc_file_url = \"https://hobu-lidar.s3.amazonaws.com/sofi.copc.laz\"\n", + "\n", + "with CopcReader.open(copc_file_url) as crdr:\n", + " header = crdr.header\n", + " total_points_count = header.point_count\n", + " print(f\"The file contains {total_points_count:,} total points\")\n", + "\n", + " min_coordinates = header.mins # numpy array: [x_min_coord, y_min_coord, z_min_coord]\n", + " max_coordinates = header.maxs # numpy array: [x_max_coord, y_max_coord, z_max_coord]\n", + " sizes = header.maxs - header.mins # numpy array: [x_size, y_size, z_size]\n", + " \n", + " # select a \"column\" in the data (approx. 25% of the data)\n", + " # x_coords: [xmin, xmin + size_x/2]\n", + " # y_coords: [ymin, ymin + size_y/2]\n", + " # z_coords: [zmin, zmin + size_z]\n", + " x_max = min_coordinates[0] + sizes[0] / 2\n", + " y_max = min_coordinates[1] + sizes[1] / 2\n", + " z_max = min_coordinates[2] + sizes[2]\n", + " selection = np.array([x_max, y_max, z_max])\n", + " query_bounds = Bounds(mins=min_coordinates, maxs=selection)\n", + "\n", + " # query only the selected data\n", + " points = crdr.query(query_bounds)\n", + " selected_points_count = len(points)\n", + " selected_points_ratio = selected_points_count / total_points_count * 100\n", + " print(f\"{selected_points_count:,} points were selected, i.e. approximately {selected_points_ratio:.1f}%\")" + ] + }, + { + "cell_type": "markdown", + "id": "686468ac-b3ff-4bc2-84cf-9de825e599f5", + "metadata": {}, + "source": [ + "Querying a limited amount of points is primordial to optimize ressources usage. This is also a better way of going through the data than using chunks: this allows you to select what points you want to select. " + ] + }, + { + "cell_type": "markdown", + "id": "4e0c04b5-0904-403a-8164-e6078a9832fa", + "metadata": {}, + "source": [ + "## Conclusion\n", + "\n", + "Point clouds are an invaluable data format for precisely representing 3D information. They can be compressed and optimized for cloud platforms, and are easily manipulated using `laspy`. `hvplot` can be used to create simple and customizable interactive 3D plots to visualize these points. For more detailed examples, check out the [laspy docuemntation](https://laspy.readthedocs.io/en/latest/examples.html)." + ] + } + ], + "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.11.0rc1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 69e0c69c36f54b42c15340f9a34439ea69827fa4 Mon Sep 17 00:00:00 2001 From: EugenePlanteur Date: Wed, 20 Nov 2024 18:35:52 +0100 Subject: [PATCH 12/31] doc: update readme --- data_type/readme.md | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/data_type/readme.md b/data_type/readme.md index 673a298..93af2c6 100644 --- a/data_type/readme.md +++ b/data_type/readme.md @@ -1,15 +1,23 @@ # Tutorial: Geospatial Data Formats -Geospatial data allows the communication of information in a wide range of fields. Over time, many data formats have emerged to support this diversity. This tutorial introduces these various formats, their evolution, their advantages and disadvantages, and provides guidance on how and in which contexts to use them most effectively. It will be divided into four jupyter notebooks: +Geospatial data allows the communication of information in a wide range of fields. Over time, +many data formats have emerged to support this diversity. This tutorial introduces these various +formats, their evolution, their advantages and disadvantages, and provides guidance on how and in +which contexts to use them most effectively. It will be divided into four jupyter notebooks: 1) [Raster formats](./raster_formats.ipynb) 2) [Vector formats](./vector_data_formats.ipynb) 3) [Data cube formats](./datacube_formats.ipynb) -4) Cloud-optimized formats +4) [Point clouds](./point_clouds.ipynb) -For each of these tutorials, sample data will be used, which you can visualize using QGIS. - -To run a notebook, first create a virtual environment and install the required packages (if not already done) +For each tutorial, sample data will either: + +- be directly provided (from the `sample_data` directory) +- be automatically downloaded (in the `sample_data` by default) +- have to be downloaded by the user (links and instructions will be provided) + +To run a notebook, first create a virtual environment using pip. Then, install the required +packages (if not already done), using the `requirements.txt` file. ```bash python3.11 -m venv venv From b80fc2f417da9096ee3a39eaf410acc4a6f12e99 Mon Sep 17 00:00:00 2001 From: EugenePlanteur Date: Wed, 20 Nov 2024 18:36:08 +0100 Subject: [PATCH 13/31] install: update requirements.txt --- data_type/requirements.txt | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/data_type/requirements.txt b/data_type/requirements.txt index a691aaa..4985877 100644 --- a/data_type/requirements.txt +++ b/data_type/requirements.txt @@ -1,11 +1,19 @@ +Cartopy==0.24.1 geopandas==1.0.1 h5py==3.12.1 +holoviews==1.20.0 hvplot==0.11.1 -jupyter==1.1.1 +laspy==2.5.4 matplotlib==3.9.2 netCDF4==1.7.2 +netCDF4==1.7.2 numpy==2.1.3 pandas==2.2.3 +panel==1.5.4 +pyarrow==18.0.0 rasterio==1.4.2 +Requests==2.32.3 +rio_cogeo==5.3.6 rioxarray==0.18.0 -xarray==2024.10.0 \ No newline at end of file +xarray==2024.10.0 +zarr==2.18.3 From 22f88854609ee46a6abd4b0fc97773ce3d53f1fb Mon Sep 17 00:00:00 2001 From: EugenePlanteur Date: Mon, 25 Nov 2024 08:06:41 +0100 Subject: [PATCH 14/31] doc: fix typos --- data_type/datacube_formats.ipynb | 5258 +++++++++++++++++++++++++-- data_type/raster_formats.ipynb | 22 +- data_type/vector_data_formats.ipynb | 94 +- 3 files changed, 5081 insertions(+), 293 deletions(-) diff --git a/data_type/datacube_formats.ipynb b/data_type/datacube_formats.ipynb index 476cb1f..f2f521e 100644 --- a/data_type/datacube_formats.ipynb +++ b/data_type/datacube_formats.ipynb @@ -90,7 +90,7 @@ "output_type": "stream", "text": [ "List of dataset(s) and group(s): ['data']\n", - "Data group's metadata: {'creation_date': '2024-11-19', 'project': 'Tutorial example project'}\n", + "Data group's metadata: {'creation_date': '2024-11-22', 'project': 'Tutorial example project'}\n", "List of datasets: ['data_2d', 'data_3d']\n", "2d dataset's shape: (2080, 2410)\n", "3d dataset's shape: (4, 2080, 2410)\n", @@ -150,7 +150,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Read time: 0.00124 seconds\n", + "Read time: 0.00064 seconds\n", "File size: 100.26 MB\n" ] } @@ -191,27 +191,440 @@ "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - " Size: 1GB\n", - "Dimensions: (lat: 360, lon: 720, time: 1356)\n", - "Coordinates:\n", - " * lat (lat) float32 1kB 89.75 89.25 88.75 88.25 ... -88.75 -89.25 -89.75\n", - " * lon (lon) float32 3kB 0.25 0.75 1.25 1.75 ... 358.2 358.8 359.2 359.8\n", - " * time (time) datetime64[ns] 11kB 1901-01-01 1901-02-01 ... 2013-12-01\n", - "Data variables:\n", - " precip (time, lat, lon) float32 1GB ...\n", - "Attributes:\n", - " Original_Source: http://www.dwd.de/en/FundE/Klima/KLIS/int/GPCC/GPCC.htm...\n", - " Reference: Users of the data sets are kindly requested to give fee...\n", - " original_source: ftp://ftp-anon.dwd.de/pub/data/gpcc/html/fulldata_downl...\n", - " Conventions: CF 1.0\n", - " References: http://www.esrl.noaa.gov/psd/data/gridded/data.gpcc.html\n", - " history: Created 01/2016 based on V7 data obtained via ftp\n", - " title: GPCC Full Data Reanalysis Version 7 0.5x0.5 Monthly Total\n", - " dataset_title: Global Precipitation Climatology Centre (GPCC)\n" - ] + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 1GB\n",
+       "Dimensions:  (lat: 360, lon: 720, time: 1356)\n",
+       "Coordinates:\n",
+       "  * lat      (lat) float32 1kB 89.75 89.25 88.75 88.25 ... -88.75 -89.25 -89.75\n",
+       "  * lon      (lon) float32 3kB 0.25 0.75 1.25 1.75 ... 358.2 358.8 359.2 359.8\n",
+       "  * time     (time) datetime64[ns] 11kB 1901-01-01 1901-02-01 ... 2013-12-01\n",
+       "Data variables:\n",
+       "    precip   (time, lat, lon) float32 1GB ...\n",
+       "Attributes:\n",
+       "    Original_Source:  http://www.dwd.de/en/FundE/Klima/KLIS/int/GPCC/GPCC.htm...\n",
+       "    Reference:        Users of the data sets are kindly requested to give fee...\n",
+       "    original_source:  ftp://ftp-anon.dwd.de/pub/data/gpcc/html/fulldata_downl...\n",
+       "    Conventions:      CF 1.0\n",
+       "    References:       http://www.esrl.noaa.gov/psd/data/gridded/data.gpcc.html\n",
+       "    history:          Created 01/2016 based on V7 data obtained via ftp\n",
+       "    title:            GPCC Full Data Reanalysis Version 7 0.5x0.5 Monthly Total\n",
+       "    dataset_title:    Global Precipitation Climatology Centre (GPCC)
" + ], + "text/plain": [ + " Size: 1GB\n", + "Dimensions: (lat: 360, lon: 720, time: 1356)\n", + "Coordinates:\n", + " * lat (lat) float32 1kB 89.75 89.25 88.75 88.25 ... -88.75 -89.25 -89.75\n", + " * lon (lon) float32 3kB 0.25 0.75 1.25 1.75 ... 358.2 358.8 359.2 359.8\n", + " * time (time) datetime64[ns] 11kB 1901-01-01 1901-02-01 ... 2013-12-01\n", + "Data variables:\n", + " precip (time, lat, lon) float32 1GB ...\n", + "Attributes:\n", + " Original_Source: http://www.dwd.de/en/FundE/Klima/KLIS/int/GPCC/GPCC.htm...\n", + " Reference: Users of the data sets are kindly requested to give fee...\n", + " original_source: ftp://ftp-anon.dwd.de/pub/data/gpcc/html/fulldata_downl...\n", + " Conventions: CF 1.0\n", + " References: http://www.esrl.noaa.gov/psd/data/gridded/data.gpcc.html\n", + " history: Created 01/2016 based on V7 data obtained via ftp\n", + " title: GPCC Full Data Reanalysis Version 7 0.5x0.5 Monthly Total\n", + " dataset_title: Global Precipitation Climatology Centre (GPCC)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -219,7 +632,7 @@ "\n", "netcf_file = download_netcdf(\"./sample_data/data_cube/\")\n", "ds = xr.open_dataset(netcf_file, engine=\"netcdf4\")\n", - "print(ds)" + "ds" ] }, { @@ -237,16 +650,19 @@ "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Data variables:\n", - " precip (time, lat, lon) float32 1GB ...\n" - ] + "data": { + "text/plain": [ + "Data variables:\n", + " precip (time, lat, lon) float32 1GB ..." + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "print(ds.data_vars)" + "ds.data_vars" ] }, { @@ -262,143 +678,555 @@ "execution_count": 7, "id": "61935296-7078-40c1-bf0f-ca8c047b3db2", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Size: 1GB\n", - "[351475200 values with dtype=float32]\n", - "Coordinates:\n", - " * lat (lat) float32 1kB 89.75 89.25 88.75 88.25 ... -88.75 -89.25 -89.75\n", - " * lon (lon) float32 3kB 0.25 0.75 1.25 1.75 ... 358.2 358.8 359.2 359.8\n", - " * time (time) datetime64[ns] 11kB 1901-01-01 1901-02-01 ... 2013-12-01\n", - "Attributes:\n", - " units: mm\n", - " var_desc: Precipitation\n", - " level_desc: Surface\n", - " parent_stat: Observations\n", - " long_name: GPCC Monthly total of precipitation\n", - " valid_range: [ 0. 8000.]\n", - " actual_range: [ 0. 4530.85]\n", - " dataset: GPCC Precipitation 0.5degree V7 Full Reanalysis\n", - " statistic: Total\n", - " level: Surface\n" - ] - } - ], - "source": [ - "print(ds[\"precip\"])" - ] - }, - { - "cell_type": "markdown", - "id": "8e6eb60b-5451-489d-aab6-54ed3717b7fc", - "metadata": {}, - "source": [ - "We can now plot the precipitation for a given date using `hvplot`. Change the date using the `n_date` variable. The `time` coordinate has 1356 values, so it can't be greater than 1355. We use `hvplot` to plot an interactive map:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "5901216e-29f8-48e0-b2fb-c596a1a54964", - "metadata": {}, "outputs": [ { "data": { "text/html": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": [ - "(function(root) {\n", - " function now() {\n", - " return new Date();\n", - " }\n", "\n", - " const force = true;\n", - " const py_version = '3.5.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", - " const reloading = false;\n", - " const Bokeh = root.Bokeh;\n", + ".xr-wrap {\n", + " display: block !important;\n", + " min-width: 300px;\n", + " max-width: 700px;\n", + "}\n", "\n", - " // Set a timeout for this load but only if we are not already initializing\n", - " if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n", - " root._bokeh_timeout = Date.now() + 5000;\n", - " root._bokeh_failed_load = false;\n", - " }\n", + ".xr-text-repr-fallback {\n", + " /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n", + " display: none;\n", + "}\n", "\n", - " function run_callbacks() {\n", - " try {\n", - " root._bokeh_onload_callbacks.forEach(function(callback) {\n", - " if (callback != null)\n", - " callback();\n", - " });\n", - " } finally {\n", - " delete root._bokeh_onload_callbacks;\n", - " }\n", - " console.debug(\"Bokeh: all callbacks have finished\");\n", - " }\n", + ".xr-header {\n", + " padding-top: 6px;\n", + " padding-bottom: 6px;\n", + " margin-bottom: 4px;\n", + " border-bottom: solid 1px var(--xr-border-color);\n", + "}\n", "\n", - " function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n", - " if (css_urls == null) css_urls = [];\n", - " if (js_urls == null) js_urls = [];\n", - " if (js_modules == null) js_modules = [];\n", - " if (js_exports == null) js_exports = {};\n", + ".xr-header > div,\n", + ".xr-header > ul {\n", + " display: inline;\n", + " margin-top: 0;\n", + " margin-bottom: 0;\n", + "}\n", "\n", - " root._bokeh_onload_callbacks.push(callback);\n", + ".xr-obj-type,\n", + ".xr-array-name {\n", + " margin-left: 2px;\n", + " margin-right: 10px;\n", + "}\n", "\n", - " if (root._bokeh_is_loading > 0) {\n", - " // Don't load bokeh if it is still initializing\n", - " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", - " return null;\n", - " } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", - " // There is nothing to load\n", - " run_callbacks();\n", - " return null;\n", - " }\n", + ".xr-obj-type {\n", + " color: var(--xr-font-color2);\n", + "}\n", "\n", - " function on_load() {\n", - " root._bokeh_is_loading--;\n", - " if (root._bokeh_is_loading === 0) {\n", - " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", - " run_callbacks()\n", - " }\n", - " }\n", - " window._bokeh_on_load = on_load\n", + ".xr-sections {\n", + " padding-left: 0 !important;\n", + " display: grid;\n", + " grid-template-columns: 150px auto auto 1fr 0 20px 0 20px;\n", + "}\n", "\n", - " function on_error(e) {\n", - " const src_el = e.srcElement\n", - " console.error(\"failed to load \" + (src_el.href || src_el.src));\n", - " }\n", + ".xr-section-item {\n", + " display: contents;\n", + "}\n", "\n", - " const skip = [];\n", - " if (window.requirejs) {\n", - " window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n", - " root._bokeh_is_loading = css_urls.length + 0;\n", - " } else {\n", - " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", - " }\n", + ".xr-section-item input {\n", + " display: inline-block;\n", + " opacity: 0;\n", + "}\n", + "\n", + ".xr-section-item input + label {\n", + " color: var(--xr-disabled-color);\n", + "}\n", + "\n", + ".xr-section-item input:enabled + label {\n", + " cursor: pointer;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-section-item input:focus + label {\n", + " border: 2px solid var(--xr-font-color0);\n", + "}\n", + "\n", + ".xr-section-item input:enabled + label:hover {\n", + " color: var(--xr-font-color0);\n", + "}\n", + "\n", + ".xr-section-summary {\n", + " grid-column: 1;\n", + " color: var(--xr-font-color2);\n", + " font-weight: 500;\n", + "}\n", + "\n", + ".xr-section-summary > span {\n", + " display: inline-block;\n", + " padding-left: 0.5em;\n", + "}\n", + "\n", + ".xr-section-summary-in:disabled + label {\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-section-summary-in + label:before {\n", + " display: inline-block;\n", + " content: '►';\n", + " font-size: 11px;\n", + " width: 15px;\n", + " text-align: center;\n", + "}\n", + "\n", + ".xr-section-summary-in:disabled + label:before {\n", + " color: var(--xr-disabled-color);\n", + "}\n", + "\n", + ".xr-section-summary-in:checked + label:before {\n", + " content: '▼';\n", + "}\n", + "\n", + ".xr-section-summary-in:checked + label > span {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-section-summary,\n", + ".xr-section-inline-details {\n", + " padding-top: 4px;\n", + " padding-bottom: 4px;\n", + "}\n", + "\n", + ".xr-section-inline-details {\n", + " grid-column: 2 / -1;\n", + "}\n", + "\n", + ".xr-section-details {\n", + " display: none;\n", + " grid-column: 1 / -1;\n", + " margin-bottom: 5px;\n", + "}\n", + "\n", + ".xr-section-summary-in:checked ~ .xr-section-details {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-array-wrap {\n", + " grid-column: 1 / -1;\n", + " display: grid;\n", + " grid-template-columns: 20px auto;\n", + "}\n", + "\n", + ".xr-array-wrap > label {\n", + " grid-column: 1;\n", + " vertical-align: top;\n", + "}\n", + "\n", + ".xr-preview {\n", + " color: var(--xr-font-color3);\n", + "}\n", + "\n", + ".xr-array-preview,\n", + ".xr-array-data {\n", + " padding: 0 5px !important;\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-array-data,\n", + ".xr-array-in:checked ~ .xr-array-preview {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-array-in:checked ~ .xr-array-data,\n", + ".xr-array-preview {\n", + " display: inline-block;\n", + "}\n", + "\n", + ".xr-dim-list {\n", + " display: inline-block !important;\n", + " list-style: none;\n", + " padding: 0 !important;\n", + " margin: 0;\n", + "}\n", + "\n", + ".xr-dim-list li {\n", + " display: inline-block;\n", + " padding: 0;\n", + " margin: 0;\n", + "}\n", + "\n", + ".xr-dim-list:before {\n", + " content: '(';\n", + "}\n", + "\n", + ".xr-dim-list:after {\n", + " content: ')';\n", + "}\n", + "\n", + ".xr-dim-list li:not(:last-child):after {\n", + " content: ',';\n", + " padding-right: 5px;\n", + "}\n", + "\n", + ".xr-has-index {\n", + " font-weight: bold;\n", + "}\n", + "\n", + ".xr-var-list,\n", + ".xr-var-item {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-var-item > div,\n", + ".xr-var-item label,\n", + ".xr-var-item > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-even);\n", + " margin-bottom: 0;\n", + "}\n", + "\n", + ".xr-var-item > .xr-var-name:hover span {\n", + " padding-right: 5px;\n", + "}\n", + "\n", + ".xr-var-list > li:nth-child(odd) > div,\n", + ".xr-var-list > li:nth-child(odd) > label,\n", + ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-odd);\n", + "}\n", + "\n", + ".xr-var-name {\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-var-dims {\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-var-dtype {\n", + " grid-column: 3;\n", + " text-align: right;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-preview {\n", + " grid-column: 4;\n", + "}\n", + "\n", + ".xr-index-preview {\n", + " grid-column: 2 / 5;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-name,\n", + ".xr-var-dims,\n", + ".xr-var-dtype,\n", + ".xr-preview,\n", + ".xr-attrs dt {\n", + " white-space: nowrap;\n", + " overflow: hidden;\n", + " text-overflow: ellipsis;\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-var-name:hover,\n", + ".xr-var-dims:hover,\n", + ".xr-var-dtype:hover,\n", + ".xr-attrs dt:hover {\n", + " overflow: visible;\n", + " width: auto;\n", + " z-index: 1;\n", + "}\n", + "\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " display: none;\n", + " background-color: var(--xr-background-color) !important;\n", + " padding-bottom: 5px !important;\n", + "}\n", + "\n", + ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", + ".xr-var-data-in:checked ~ .xr-var-data,\n", + ".xr-index-data-in:checked ~ .xr-index-data {\n", + " display: block;\n", + "}\n", + "\n", + ".xr-var-data > table {\n", + " float: right;\n", + "}\n", + "\n", + ".xr-var-name span,\n", + ".xr-var-data,\n", + ".xr-index-name div,\n", + ".xr-index-data,\n", + ".xr-attrs {\n", + " padding-left: 25px !important;\n", + "}\n", + "\n", + ".xr-attrs,\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " grid-column: 1 / -1;\n", + "}\n", + "\n", + "dl.xr-attrs {\n", + " padding: 0;\n", + " margin: 0;\n", + " display: grid;\n", + " grid-template-columns: 125px auto;\n", + "}\n", + "\n", + ".xr-attrs dt,\n", + ".xr-attrs dd {\n", + " padding: 0;\n", + " margin: 0;\n", + " float: left;\n", + " padding-right: 10px;\n", + " width: auto;\n", + "}\n", + "\n", + ".xr-attrs dt {\n", + " font-weight: normal;\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-attrs dt:hover span {\n", + " display: inline-block;\n", + " background: var(--xr-background-color);\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-attrs dd {\n", + " grid-column: 2;\n", + " white-space: pre-wrap;\n", + " word-break: break-all;\n", + "}\n", + "\n", + ".xr-icon-database,\n", + ".xr-icon-file-text2,\n", + ".xr-no-icon {\n", + " display: inline-block;\n", + " vertical-align: middle;\n", + " width: 1em;\n", + " height: 1.5em !important;\n", + " stroke-width: 0;\n", + " stroke: currentColor;\n", + " fill: currentColor;\n", + "}\n", + "
<xarray.DataArray 'precip' (time: 1356, lat: 360, lon: 720)> Size: 1GB\n",
+       "[351475200 values with dtype=float32]\n",
+       "Coordinates:\n",
+       "  * lat      (lat) float32 1kB 89.75 89.25 88.75 88.25 ... -88.75 -89.25 -89.75\n",
+       "  * lon      (lon) float32 3kB 0.25 0.75 1.25 1.75 ... 358.2 358.8 359.2 359.8\n",
+       "  * time     (time) datetime64[ns] 11kB 1901-01-01 1901-02-01 ... 2013-12-01\n",
+       "Attributes:\n",
+       "    units:         mm\n",
+       "    var_desc:      Precipitation\n",
+       "    level_desc:    Surface\n",
+       "    parent_stat:   Observations\n",
+       "    long_name:     GPCC Monthly total of precipitation\n",
+       "    valid_range:   [   0. 8000.]\n",
+       "    actual_range:  [   0.   4530.85]\n",
+       "    dataset:       GPCC Precipitation 0.5degree V7 Full Reanalysis\n",
+       "    statistic:     Total\n",
+       "    level:         Surface
" + ], + "text/plain": [ + " Size: 1GB\n", + "[351475200 values with dtype=float32]\n", + "Coordinates:\n", + " * lat (lat) float32 1kB 89.75 89.25 88.75 88.25 ... -88.75 -89.25 -89.75\n", + " * lon (lon) float32 3kB 0.25 0.75 1.25 1.75 ... 358.2 358.8 359.2 359.8\n", + " * time (time) datetime64[ns] 11kB 1901-01-01 1901-02-01 ... 2013-12-01\n", + "Attributes:\n", + " units: mm\n", + " var_desc: Precipitation\n", + " level_desc: Surface\n", + " parent_stat: Observations\n", + " long_name: GPCC Monthly total of precipitation\n", + " valid_range: [ 0. 8000.]\n", + " actual_range: [ 0. 4530.85]\n", + " dataset: GPCC Precipitation 0.5degree V7 Full Reanalysis\n", + " statistic: Total\n", + " level: Surface" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds[\"precip\"]" + ] + }, + { + "cell_type": "markdown", + "id": "8e6eb60b-5451-489d-aab6-54ed3717b7fc", + "metadata": {}, + "source": [ + "We can now plot the precipitation for a given date using `hvplot` using slicing (see [xarray slicing documentation](https://docs.xarray.dev/en/stable/user-guide/indexing.html) for more info). Change the `date` value to plot the data for a given date: if it's not available, using `method=\"nearest\"` will use the closest available date:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "5901216e-29f8-48e0-b2fb-c596a1a54964", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "(function(root) {\n", + " function now() {\n", + " return new Date();\n", + " }\n", + "\n", + " const force = true;\n", + " const py_version = '3.5.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", + " const reloading = false;\n", + " const Bokeh = root.Bokeh;\n", + "\n", + " // Set a timeout for this load but only if we are not already initializing\n", + " if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_failed_load = false;\n", + " }\n", + "\n", + " function run_callbacks() {\n", + " try {\n", + " root._bokeh_onload_callbacks.forEach(function(callback) {\n", + " if (callback != null)\n", + " callback();\n", + " });\n", + " } finally {\n", + " delete root._bokeh_onload_callbacks;\n", + " }\n", + " console.debug(\"Bokeh: all callbacks have finished\");\n", + " }\n", + "\n", + " function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n", + " if (css_urls == null) css_urls = [];\n", + " if (js_urls == null) js_urls = [];\n", + " if (js_modules == null) js_modules = [];\n", + " if (js_exports == null) js_exports = {};\n", + "\n", + " root._bokeh_onload_callbacks.push(callback);\n", + "\n", + " if (root._bokeh_is_loading > 0) {\n", + " // Don't load bokeh if it is still initializing\n", + " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", + " return null;\n", + " } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", + " // There is nothing to load\n", + " run_callbacks();\n", + " return null;\n", + " }\n", + "\n", + " function on_load() {\n", + " root._bokeh_is_loading--;\n", + " if (root._bokeh_is_loading === 0) {\n", + " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", + " run_callbacks()\n", + " }\n", + " }\n", + " window._bokeh_on_load = on_load\n", + "\n", + " function on_error(e) {\n", + " const src_el = e.srcElement\n", + " console.error(\"failed to load \" + (src_el.href || src_el.src));\n", + " }\n", + "\n", + " const skip = [];\n", + " if (window.requirejs) {\n", + " window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n", + " root._bokeh_is_loading = css_urls.length + 0;\n", + " } else {\n", + " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", + " }\n", "\n", " const existing_stylesheets = []\n", " const links = document.getElementsByTagName('link')\n", @@ -836,12 +1664,12 @@ "data": { "application/vnd.holoviews_exec.v0+json": "", "text/html": [ - "
\n", - "
\n", + "
\n", + "
\n", "
\n", "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "(function(root) {\n", + " function now() {\n", + " return new Date();\n", + " }\n", + "\n", + " const force = true;\n", + " const py_version = '3.5.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", + " const reloading = false;\n", + " const Bokeh = root.Bokeh;\n", + "\n", + " // Set a timeout for this load but only if we are not already initializing\n", + " if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_failed_load = false;\n", + " }\n", + "\n", + " function run_callbacks() {\n", + " try {\n", + " root._bokeh_onload_callbacks.forEach(function(callback) {\n", + " if (callback != null)\n", + " callback();\n", + " });\n", + " } finally {\n", + " delete root._bokeh_onload_callbacks;\n", + " }\n", + " console.debug(\"Bokeh: all callbacks have finished\");\n", + " }\n", + "\n", + " function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n", + " if (css_urls == null) css_urls = [];\n", + " if (js_urls == null) js_urls = [];\n", + " if (js_modules == null) js_modules = [];\n", + " if (js_exports == null) js_exports = {};\n", + "\n", + " root._bokeh_onload_callbacks.push(callback);\n", + "\n", + " if (root._bokeh_is_loading > 0) {\n", + " // Don't load bokeh if it is still initializing\n", + " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", + " return null;\n", + " } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", + " // There is nothing to load\n", + " run_callbacks();\n", + " return null;\n", + " }\n", + "\n", + " function on_load() {\n", + " root._bokeh_is_loading--;\n", + " if (root._bokeh_is_loading === 0) {\n", + " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", + " run_callbacks()\n", + " }\n", + " }\n", + " window._bokeh_on_load = on_load\n", + "\n", + " function on_error(e) {\n", + " const src_el = e.srcElement\n", + " console.error(\"failed to load \" + (src_el.href || src_el.src));\n", + " }\n", + "\n", + " const skip = [];\n", + " if (window.requirejs) {\n", + " window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n", + " root._bokeh_is_loading = css_urls.length + 0;\n", + " } else {\n", + " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", + " }\n", + "\n", + " const existing_stylesheets = []\n", + " const links = document.getElementsByTagName('link')\n", + " for (let i = 0; i < links.length; i++) {\n", + " const link = links[i]\n", + " if (link.href != null) {\n", + " existing_stylesheets.push(link.href)\n", + " }\n", + " }\n", + " for (let i = 0; i < css_urls.length; i++) {\n", + " const url = css_urls[i];\n", + " const escaped = encodeURI(url)\n", + " if (existing_stylesheets.indexOf(escaped) !== -1) {\n", + " on_load()\n", + " continue;\n", + " }\n", + " const element = document.createElement(\"link\");\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.rel = \"stylesheet\";\n", + " element.type = \"text/css\";\n", + " element.href = url;\n", + " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", + " document.body.appendChild(element);\n", + " } var existing_scripts = []\n", + " const scripts = document.getElementsByTagName('script')\n", + " for (let i = 0; i < scripts.length; i++) {\n", + " var script = scripts[i]\n", + " if (script.src != null) {\n", + " existing_scripts.push(script.src)\n", + " }\n", + " }\n", + " for (let i = 0; i < js_urls.length; i++) {\n", + " const url = js_urls[i];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " const element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (let i = 0; i < js_modules.length; i++) {\n", + " const url = js_modules[i];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (const name in js_exports) {\n", + " const url = js_exports[name];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " element.textContent = `\n", + " import ${name} from \"${url}\"\n", + " window.${name} = ${name}\n", + " window._bokeh_on_load()\n", + " `\n", + " document.head.appendChild(element);\n", + " }\n", + " if (!js_urls.length && !js_modules.length) {\n", + " on_load()\n", + " }\n", + " };\n", + "\n", + " function inject_raw_css(css) {\n", + " const element = document.createElement(\"style\");\n", + " element.appendChild(document.createTextNode(css));\n", + " document.body.appendChild(element);\n", + " }\n", + "\n", + " const js_urls = [\"https://cdn.holoviz.org/panel/1.5.3/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.5.2.min.js\", \"https://cdn.holoviz.org/panel/1.5.3/dist/panel.min.js\"];\n", + " const js_modules = [];\n", + " const js_exports = {};\n", + " const css_urls = [];\n", + " const inline_js = [ function(Bokeh) {\n", + " Bokeh.set_log_level(\"info\");\n", + " },\n", + "function(Bokeh) {} // ensure no trailing comma for IE\n", + " ];\n", + "\n", + " function run_inline_js() {\n", + " if ((root.Bokeh !== undefined) || (force === true)) {\n", + " for (let i = 0; i < inline_js.length; i++) {\n", + " try {\n", + " inline_js[i].call(root, root.Bokeh);\n", + " } catch(e) {\n", + " if (!reloading) {\n", + " throw e;\n", + " }\n", + " }\n", + " }\n", + " // Cache old bokeh versions\n", + " if (Bokeh != undefined && !reloading) {\n", + " var NewBokeh = root.Bokeh;\n", + " if (Bokeh.versions === undefined) {\n", + " Bokeh.versions = new Map();\n", + " }\n", + " if (NewBokeh.version !== Bokeh.version) {\n", + " Bokeh.versions.set(NewBokeh.version, NewBokeh)\n", + " }\n", + " root.Bokeh = Bokeh;\n", + " }\n", + " } else if (Date.now() < root._bokeh_timeout) {\n", + " setTimeout(run_inline_js, 100);\n", + " } else if (!root._bokeh_failed_load) {\n", + " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", + " root._bokeh_failed_load = true;\n", + " }\n", + " root._bokeh_is_initializing = false\n", + " }\n", + "\n", + " function load_or_wait() {\n", + " // Implement a backoff loop that tries to ensure we do not load multiple\n", + " // versions of Bokeh and its dependencies at the same time.\n", + " // In recent versions we use the root._bokeh_is_initializing flag\n", + " // to determine whether there is an ongoing attempt to initialize\n", + " // bokeh, however for backward compatibility we also try to ensure\n", + " // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n", + " // before older versions are fully initialized.\n", + " if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n", + " // If the timeout and bokeh was not successfully loaded we reset\n", + " // everything and try loading again\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_is_initializing = false;\n", + " root._bokeh_onload_callbacks = undefined;\n", + " root._bokeh_is_loading = 0\n", + " console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n", + " load_or_wait();\n", + " } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n", + " setTimeout(load_or_wait, 100);\n", + " } else {\n", + " root._bokeh_is_initializing = true\n", + " root._bokeh_onload_callbacks = []\n", + " const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n", + " if (!reloading && !bokeh_loaded) {\n", + " if (root.Bokeh) {\n", + " root.Bokeh = undefined;\n", + " }\n", + " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", + " }\n", + " load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n", + " console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", + " run_inline_js();\n", + " });\n", + " }\n", + " }\n", + " // Give older versions of the autoload script a head-start to ensure\n", + " // they initialize before we start loading newer version.\n", + " setTimeout(load_or_wait, 100)\n", + "}(window));" + ], + "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n const force = true;\n const py_version = '3.5.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n const reloading = false;\n const Bokeh = root.Bokeh;\n\n // Set a timeout for this load but only if we are not already initializing\n if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n // Don't load bokeh if it is still initializing\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n // There is nothing to load\n run_callbacks();\n return null;\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error(e) {\n const src_el = e.srcElement\n console.error(\"failed to load \" + (src_el.href || src_el.src));\n }\n\n const skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n const existing_stylesheets = []\n const links = document.getElementsByTagName('link')\n for (let i = 0; i < links.length; i++) {\n const link = links[i]\n if (link.href != null) {\n existing_stylesheets.push(link.href)\n }\n }\n for (let i = 0; i < css_urls.length; i++) {\n const url = css_urls[i];\n const escaped = encodeURI(url)\n if (existing_stylesheets.indexOf(escaped) !== -1) {\n on_load()\n continue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n const scripts = document.getElementsByTagName('script')\n for (let i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n existing_scripts.push(script.src)\n }\n }\n for (let i = 0; i < js_urls.length; i++) {\n const url = js_urls[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n const element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (let i = 0; i < js_modules.length; i++) {\n const url = js_modules[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n const url = js_exports[name];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n const js_urls = [\"https://cdn.holoviz.org/panel/1.5.3/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.5.2.min.js\", \"https://cdn.holoviz.org/panel/1.5.3/dist/panel.min.js\"];\n const js_modules = [];\n const js_exports = {};\n const css_urls = [];\n const inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (let i = 0; i < inline_js.length; i++) {\n try {\n inline_js[i].call(root, root.Bokeh);\n } catch(e) {\n if (!reloading) {\n throw e;\n }\n }\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n var NewBokeh = root.Bokeh;\n if (Bokeh.versions === undefined) {\n Bokeh.versions = new Map();\n }\n if (NewBokeh.version !== Bokeh.version) {\n Bokeh.versions.set(NewBokeh.version, NewBokeh)\n }\n root.Bokeh = Bokeh;\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n // If the timeout and bokeh was not successfully loaded we reset\n // everything and try loading again\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n root._bokeh_is_loading = 0\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n if (root.Bokeh) {\n root.Bokeh = undefined;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + "if ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n", + " window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n", + "}\n", + "\n", + "\n", + " function JupyterCommManager() {\n", + " }\n", + "\n", + " JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n", + " if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " comm_manager.register_target(comm_id, function(comm) {\n", + " comm.on_msg(msg_handler);\n", + " });\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n", + " comm.onMsg = msg_handler;\n", + " });\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " console.log(message)\n", + " var content = {data: message.data, comm_id};\n", + " var buffers = []\n", + " for (var buffer of message.buffers || []) {\n", + " buffers.push(new DataView(buffer))\n", + " }\n", + " var metadata = message.metadata || {};\n", + " var msg = {content, buffers, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " })\n", + " }\n", + " }\n", + "\n", + " JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n", + " if (comm_id in window.PyViz.comms) {\n", + " return window.PyViz.comms[comm_id];\n", + " } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n", + " if (msg_handler) {\n", + " comm.on_msg(msg_handler);\n", + " }\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n", + " comm.open();\n", + " if (msg_handler) {\n", + " comm.onMsg = msg_handler;\n", + " }\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " var comm_promise = google.colab.kernel.comms.open(comm_id)\n", + " comm_promise.then((comm) => {\n", + " window.PyViz.comms[comm_id] = comm;\n", + " if (msg_handler) {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " var content = {data: message.data};\n", + " var metadata = message.metadata || {comm_id};\n", + " var msg = {content, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " }) \n", + " var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n", + " return comm_promise.then((comm) => {\n", + " comm.send(data, metadata, buffers, disposeOnDone);\n", + " });\n", + " };\n", + " var comm = {\n", + " send: sendClosure\n", + " };\n", + " }\n", + " window.PyViz.comms[comm_id] = comm;\n", + " return comm;\n", + " }\n", + " window.PyViz.comm_manager = new JupyterCommManager();\n", + " \n", + "\n", + "\n", + "var JS_MIME_TYPE = 'application/javascript';\n", + "var HTML_MIME_TYPE = 'text/html';\n", + "var EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\n", + "var CLASS_NAME = 'output';\n", + "\n", + "/**\n", + " * Render data to the DOM node\n", + " */\n", + "function render(props, node) {\n", + " var div = document.createElement(\"div\");\n", + " var script = document.createElement(\"script\");\n", + " node.appendChild(div);\n", + " node.appendChild(script);\n", + "}\n", + "\n", + "/**\n", + " * Handle when a new output is added\n", + " */\n", + "function handle_add_output(event, handle) {\n", + " var output_area = handle.output_area;\n", + " var output = handle.output;\n", + " if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", + " return\n", + " }\n", + " var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", + " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", + " if (id !== undefined) {\n", + " var nchildren = toinsert.length;\n", + " var html_node = toinsert[nchildren-1].children[0];\n", + " html_node.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var scripts = [];\n", + " var nodelist = html_node.querySelectorAll(\"script\");\n", + " for (var i in nodelist) {\n", + " if (nodelist.hasOwnProperty(i)) {\n", + " scripts.push(nodelist[i])\n", + " }\n", + " }\n", + "\n", + " scripts.forEach( function (oldScript) {\n", + " var newScript = document.createElement(\"script\");\n", + " var attrs = [];\n", + " var nodemap = oldScript.attributes;\n", + " for (var j in nodemap) {\n", + " if (nodemap.hasOwnProperty(j)) {\n", + " attrs.push(nodemap[j])\n", + " }\n", + " }\n", + " attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n", + " newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n", + " oldScript.parentNode.replaceChild(newScript, oldScript);\n", + " });\n", + " if (JS_MIME_TYPE in output.data) {\n", + " toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n", + " }\n", + " output_area._hv_plot_id = id;\n", + " if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n", + " window.PyViz.plot_index[id] = Bokeh.index[id];\n", + " } else {\n", + " window.PyViz.plot_index[id] = null;\n", + " }\n", + " } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", + " var bk_div = document.createElement(\"div\");\n", + " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var script_attrs = bk_div.children[0].attributes;\n", + " for (var i = 0; i < script_attrs.length; i++) {\n", + " toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n", + " }\n", + " // store reference to server id on output_area\n", + " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle when an output is cleared or removed\n", + " */\n", + "function handle_clear_output(event, handle) {\n", + " var id = handle.cell.output_area._hv_plot_id;\n", + " var server_id = handle.cell.output_area._bokeh_server_id;\n", + " if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n", + " var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n", + " if (server_id !== null) {\n", + " comm.send({event_type: 'server_delete', 'id': server_id});\n", + " return;\n", + " } else if (comm !== null) {\n", + " comm.send({event_type: 'delete', 'id': id});\n", + " }\n", + " delete PyViz.plot_index[id];\n", + " if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n", + " var doc = window.Bokeh.index[id].model.document\n", + " doc.clear();\n", + " const i = window.Bokeh.documents.indexOf(doc);\n", + " if (i > -1) {\n", + " window.Bokeh.documents.splice(i, 1);\n", + " }\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle kernel restart event\n", + " */\n", + "function handle_kernel_cleanup(event, handle) {\n", + " delete PyViz.comms[\"hv-extension-comm\"];\n", + " window.PyViz.plot_index = {}\n", + "}\n", + "\n", + "/**\n", + " * Handle update_display_data messages\n", + " */\n", + "function handle_update_output(event, handle) {\n", + " handle_clear_output(event, {cell: {output_area: handle.output_area}})\n", + " handle_add_output(event, handle)\n", + "}\n", + "\n", + "function register_renderer(events, OutputArea) {\n", + " function append_mime(data, metadata, element) {\n", + " // create a DOM node to render to\n", + " var toinsert = this.create_output_subarea(\n", + " metadata,\n", + " CLASS_NAME,\n", + " EXEC_MIME_TYPE\n", + " );\n", + " this.keyboard_manager.register_events(toinsert);\n", + " // Render to node\n", + " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", + " render(props, toinsert[0]);\n", + " element.append(toinsert);\n", + " return toinsert\n", + " }\n", + "\n", + " events.on('output_added.OutputArea', handle_add_output);\n", + " events.on('output_updated.OutputArea', handle_update_output);\n", + " events.on('clear_output.CodeCell', handle_clear_output);\n", + " events.on('delete.Cell', handle_clear_output);\n", + " events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n", + "\n", + " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", + " safe: true,\n", + " index: 0\n", + " });\n", + "}\n", + "\n", + "if (window.Jupyter !== undefined) {\n", + " try {\n", + " var events = require('base/js/events');\n", + " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", + " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", + " register_renderer(events, OutputArea);\n", + " }\n", + " } catch(err) {\n", + " }\n", + "}\n" + ], + "application/vnd.holoviews_load.v0+json": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ] + }, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "71e5ebf6-6ed7-4108-8338-357588b94384" + } + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Variable (time: 10, lat: 1000, lon: 1000)> Size: 80MB\n",
+       "[10000000 values with dtype=float64]
" + ], + "text/plain": [ + " Size: 80MB\n", + "[10000000 values with dtype=float64]" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import hvplot.xarray\n", + "import xarray as xr\n", + "zarr_path = \"./sample_data/data_cube/example_from_xarray.zarr\"\n", + "\n", + "da = xr.open_dataset(zarr_path)[\"data\"]\n", + "da.variable" + ] + }, + { + "cell_type": "markdown", + "id": "8900a6b5-29b9-4321-8660-813682977d20", + "metadata": {}, + "source": [ + "The actual values of the array aren't loaded. One way of explicitly loading them into memory is using the `.load()` method:" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "01c1c814-eb79-4ae5-8bbc-6871ead43224", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Variable (time: 10, lat: 1000, lon: 1000)> Size: 80MB\n",
+       "array([[[0.57173056, 0.44281942, 0.16513337, ..., 0.80223243,\n",
+       "         0.78291964, 0.08747034],\n",
+       "        [0.31521199, 0.41597532, 0.49439683, ..., 0.35265298,\n",
+       "         0.60145573, 0.3083475 ],\n",
+       "        [0.20306074, 0.20359435, 0.33797216, ..., 0.26089714,\n",
+       "         0.76296845, 0.6778943 ],\n",
+       "        ...,\n",
+       "        [0.25245384, 0.5276968 , 0.52644091, ..., 0.58426732,\n",
+       "         0.09180941, 0.34140939],\n",
+       "        [0.45087638, 0.46311388, 0.52009816, ..., 0.40293499,\n",
+       "         0.26637495, 0.22535514],\n",
+       "        [0.42322559, 0.72216987, 0.37084262, ..., 0.77784775,\n",
+       "         0.12880648, 0.56547993]],\n",
+       "\n",
+       "       [[0.88587595, 0.43882129, 0.40775621, ..., 0.78691236,\n",
+       "         0.84506516, 0.05957236],\n",
+       "        [0.2105488 , 0.12635273, 0.69809241, ..., 0.92477286,\n",
+       "         0.77313677, 0.17230435],\n",
+       "        [0.94823774, 0.53079968, 0.79555541, ..., 0.47326325,\n",
+       "         0.77537247, 0.14510511],\n",
+       "...\n",
+       "        [0.9682806 , 0.29507893, 0.75662358, ..., 0.46322352,\n",
+       "         0.13547584, 0.9072647 ],\n",
+       "        [0.62804832, 0.59621295, 0.11512536, ..., 0.31490865,\n",
+       "         0.8390884 , 0.46678536],\n",
+       "        [0.22960135, 0.85382707, 0.62060189, ..., 0.30999343,\n",
+       "         0.1842668 , 0.28276561]],\n",
+       "\n",
+       "       [[0.92283423, 0.76045385, 0.82228549, ..., 0.98505589,\n",
+       "         0.60402087, 0.89849785],\n",
+       "        [0.17968167, 0.88254461, 0.3432763 , ..., 0.62870849,\n",
+       "         0.66852378, 0.2862194 ],\n",
+       "        [0.40432042, 0.70899042, 0.34822044, ..., 0.8682068 ,\n",
+       "         0.13327541, 0.13511111],\n",
+       "        ...,\n",
+       "        [0.5277495 , 0.30094765, 0.51537951, ..., 0.38737032,\n",
+       "         0.86513829, 0.44451509],\n",
+       "        [0.35835956, 0.51757299, 0.22708403, ..., 0.50319819,\n",
+       "         0.06690598, 0.2319543 ],\n",
+       "        [0.91434051, 0.30306714, 0.28184485, ..., 0.12336382,\n",
+       "         0.31688197, 0.56079195]]])
" + ], + "text/plain": [ + " Size: 80MB\n", + "array([[[0.57173056, 0.44281942, 0.16513337, ..., 0.80223243,\n", + " 0.78291964, 0.08747034],\n", + " [0.31521199, 0.41597532, 0.49439683, ..., 0.35265298,\n", + " 0.60145573, 0.3083475 ],\n", + " [0.20306074, 0.20359435, 0.33797216, ..., 0.26089714,\n", + " 0.76296845, 0.6778943 ],\n", + " ...,\n", + " [0.25245384, 0.5276968 , 0.52644091, ..., 0.58426732,\n", + " 0.09180941, 0.34140939],\n", + " [0.45087638, 0.46311388, 0.52009816, ..., 0.40293499,\n", + " 0.26637495, 0.22535514],\n", + " [0.42322559, 0.72216987, 0.37084262, ..., 0.77784775,\n", + " 0.12880648, 0.56547993]],\n", + "\n", + " [[0.88587595, 0.43882129, 0.40775621, ..., 0.78691236,\n", + " 0.84506516, 0.05957236],\n", + " [0.2105488 , 0.12635273, 0.69809241, ..., 0.92477286,\n", + " 0.77313677, 0.17230435],\n", + " [0.94823774, 0.53079968, 0.79555541, ..., 0.47326325,\n", + " 0.77537247, 0.14510511],\n", + "...\n", + " [0.9682806 , 0.29507893, 0.75662358, ..., 0.46322352,\n", + " 0.13547584, 0.9072647 ],\n", + " [0.62804832, 0.59621295, 0.11512536, ..., 0.31490865,\n", + " 0.8390884 , 0.46678536],\n", + " [0.22960135, 0.85382707, 0.62060189, ..., 0.30999343,\n", + " 0.1842668 , 0.28276561]],\n", + "\n", + " [[0.92283423, 0.76045385, 0.82228549, ..., 0.98505589,\n", + " 0.60402087, 0.89849785],\n", + " [0.17968167, 0.88254461, 0.3432763 , ..., 0.62870849,\n", + " 0.66852378, 0.2862194 ],\n", + " [0.40432042, 0.70899042, 0.34822044, ..., 0.8682068 ,\n", + " 0.13327541, 0.13511111],\n", + " ...,\n", + " [0.5277495 , 0.30094765, 0.51537951, ..., 0.38737032,\n", + " 0.86513829, 0.44451509],\n", + " [0.35835956, 0.51757299, 0.22708403, ..., 0.50319819,\n", + " 0.06690598, 0.2319543 ],\n", + " [0.91434051, 0.30306714, 0.28184485, ..., 0.12336382,\n", + " 0.31688197, 0.56079195]]])" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "da.load()\n", + "da.variable" + ] + }, + { + "cell_type": "markdown", + "id": "6e4c347b-cbd8-484f-8cc9-3b45f0bebcc1", + "metadata": {}, + "source": [ + "Let's reopen it to reset it to lazy loaded and test lazy computing. For this, let's multiply the array by 10 and compute its mean over all time periods:" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "a0030c03-f44e-4d5a-be66-c776189ee4c8", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lazy loaded array:\n", + " Size: 80MB\n", + "dask.array\n", + "Coordinates:\n", + " * lat (lat) int64 8kB 0 1 2 3 4 5 6 7 ... 992 993 994 995 996 997 998 999\n", + " * lon (lon) int64 8kB 0 1 2 3 4 5 6 7 ... 992 993 994 995 996 997 998 999\n", + " * time (time) int64 80B 0 1 2 3 4 5 6 7 8 9 \n", + "\n", + "\n", + "Lazy computed array:\n", + " Size: 8MB\n", + "dask.array\n", + "Coordinates:\n", + " * lat (lat) int64 8kB 0 1 2 3 4 5 6 7 ... 992 993 994 995 996 997 998 999\n", + " * lon (lon) int64 8kB 0 1 2 3 4 5 6 7 ... 992 993 994 995 996 997 998 999 \n", + "\n", + "\n", + "Loaded and computed:\n", + " Size: 8MB\n", + "array([[5.75989822, 5.02703079, 3.19270113, ..., 6.09194011, 5.12143591,\n", + " 3.23814132],\n", + " [3.71971549, 6.71013608, 5.91276078, ..., 5.03312745, 5.78974382,\n", + " 4.90106614],\n", + " [5.47664988, 4.84102291, 5.12004484, ..., 4.81430401, 4.12448408,\n", + " 3.9516942 ],\n", + " ...,\n", + " [5.70272592, 4.47375299, 6.4134405 , ..., 4.46713774, 4.04691179,\n", + " 5.28627309],\n", + " [3.75683063, 5.1005176 , 4.58812091, ..., 3.73639658, 5.87220076,\n", + " 4.41103159],\n", + " [6.45588892, 5.45363484, 5.23654145, ..., 4.79626276, 3.95544593,\n", + " 2.77086433]])\n", + "Coordinates:\n", + " * lat (lat) int64 8kB 0 1 2 3 4 5 6 7 ... 992 993 994 995 996 997 998 999\n", + " * lon (lon) int64 8kB 0 1 2 3 4 5 6 7 ... 992 993 994 995 996 997 998 999\n" + ] + } + ], + "source": [ + "da = xr.open_dataset(zarr_path, chunks=\"auto\", engine=\"zarr\")[\"data\"]\n", + "\n", + "print(\"Lazy loaded array:\") # lazy loaded\n", + "print(da, \"\\n\\n\")\n", + "\n", + "scaled_data = da * 10\n", + "mean_data = scaled_data.mean(dim=\"time\") # lazy computed\n", + "print(\"Lazy computed array:\")\n", + "print(mean_data, \"\\n\\n\")\n", + "\n", + "\n", + "result = mean_data.compute() # load in memory and compute\n", + "print(\"Loaded and computed:\")\n", + "print(result)" + ] + }, + { + "cell_type": "markdown", + "id": "d911053f-066b-4ecb-aea0-00076c2e165d", + "metadata": {}, + "source": [ + "As explained in the rasters section, an efficient optimization method is to run chunks computation in parallel, using dask for example. And `xarray` uses dask to handle data arrays, making it easier to assemble these methods.\n", + "\n", + "## Conclusion\n", + "\n", + "There are many optimization techniques available for all the data types and formats presented, usable both on local and cloud architectures. It is important to consider which format and what processing methods can and should be used, depending on the architecture and ressources available, as well as the data volume. Generally, a mordern and optimized code should be considered, but over a small dataset, using parallel processing and chunking data may introduce unnecessary complexity." + ] + } + ], + "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.11.0rc1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From fdc0f34c3d74125a6af11a02816bb8688a7f40e6 Mon Sep 17 00:00:00 2001 From: EugenePlanteur Date: Mon, 25 Nov 2024 15:21:09 +0100 Subject: [PATCH 21/31] doc: add data optimization ref to readme --- data_type/readme.md | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/data_type/readme.md b/data_type/readme.md index 93af2c6..1aca901 100644 --- a/data_type/readme.md +++ b/data_type/readme.md @@ -9,12 +9,11 @@ which contexts to use them most effectively. It will be divided into four jupyte 2) [Vector formats](./vector_data_formats.ipynb) 3) [Data cube formats](./datacube_formats.ipynb) 4) [Point clouds](./point_clouds.ipynb) +5) [Data optimization](./data_optimization.ipynb) -For each tutorial, sample data will either: +For each tutorial, sample data will be provided in the `sample_data` directory or automatically +downloaded (in the `sample_data` directory by default) -- be directly provided (from the `sample_data` directory) -- be automatically downloaded (in the `sample_data` by default) -- have to be downloaded by the user (links and instructions will be provided) To run a notebook, first create a virtual environment using pip. Then, install the required packages (if not already done), using the `requirements.txt` file. From 8262143ba08617594d583aefd1d0790e56088b23 Mon Sep 17 00:00:00 2001 From: EugenePlanteur Date: Mon, 25 Nov 2024 16:32:09 +0100 Subject: [PATCH 22/31] style: add types, docstrings to functions + small refactor --- data_type/utils.py | 146 +++++++++++++++++++++++++++++++++++++-------- 1 file changed, 122 insertions(+), 24 deletions(-) diff --git a/data_type/utils.py b/data_type/utils.py index b61e451..fadcf4b 100644 --- a/data_type/utils.py +++ b/data_type/utils.py @@ -5,6 +5,7 @@ from pathlib import Path import h5py +import holoviews import numpy as np import pandas as pd import rasterio @@ -22,7 +23,29 @@ def get_file_size_in_mb(file_path): return raw_size * 1e-6 -def compare_read_write_times(read_times, write_times, labels): +def compare_read_write_times( + read_times: list[str], + write_times: list[str], + labels: list[str] +) -> holoviews.element.chart.Bars: + """ + Given a list of reading and a list of write time and corresponding labels (i.e. formats) + show a bar plot comparing the different times + + Parameters + ---------- + read_times: + List of reading times + write_times: + List of writing times + labels: + Labels to use + + Returns + ------- + plot: + The plot created by hvplot + """ data = pd.DataFrame({ 'Formats': labels, 'Read': read_times, @@ -43,7 +66,20 @@ def compare_read_write_times(read_times, write_times, labels): return plot -def download_sample_data(download_dir): +def download_sample_data(download_dir: str | Path): + """ + Download a .zip containing multiple rasters and only keep one, in the provided directory. + + Parameters + ---------- + download_dir: + Directory to store the downloaded data + + Returns + ------- + output_raster: + The path to the downloaded raster + """ output_raster = Path( download_dir) / "data" / "xt_SENTINEL2B_20180621-111349-432_L2A_T30TWT_D_V1-8_RVBPIR.tif" @@ -87,7 +123,20 @@ def show_raster(input_image: str): show(rescaled_array.astype(np.uint8), title="Raster Data") -def rescale_raster(raster_data): +def rescale_raster(raster_data: np.ndarray): + """ + Rescale and normalize a raster for visualization + + Parameters + ---------- + raster_data: + Numpy array containing the raster data + + Returns + ------- + rescaled_array: + The processed array ready for visualization + """ flat_array = raster_data.flatten() lower_bound = np.quantile(flat_array, 0.001) upper_bound = np.quantile(flat_array, 0.999) @@ -100,7 +149,20 @@ def rescale_raster(raster_data): return rescaled_array -def download_sample_vector_data(download_dir): +def download_sample_vector_data(download_dir: str | Path): + """ + Download an example shapefile and store it in the provided directory + + Parameters + ---------- + download_dir: + Path to the directory where to store the shapefile + + Returns + ------- + output_file: + Absolute path to the downloaded shapefile + """ data_dir = Path(download_dir) / "departement-31" output_file = data_dir / "landuse.shp" if output_file.exists(): @@ -119,26 +181,35 @@ def download_sample_vector_data(download_dir): return output_file.resolve() -def generate_hdf5_file(output_file, raster_file): +def generate_hdf5_file(output_file: str | Path, raster_file: str | Path): + """ + Use a raster to create a hdf5 file + + Parameters + ---------- + output_file: + Path to the generated hdf5 file + raster_file + Path to the raster used to create the file. Download a raster if it doesn't exist. + + Returns + ------- + + """ # assumes raster with 3 bands output_file = Path(output_file) output_file.parent.mkdir(parents=True, exist_ok=True) - if not Path(raster_file).exists(): + if not raster_file or not Path(raster_file).exists(): download_sample_data(output_file.parent) - if raster_file: - with rasterio.open(raster_file, "r") as src: - image_data = src.read() - data_2d = image_data[0] # 1st raster band - data_3d = image_data # all raster bands - desc_2d = "1st band from a raster" - desc_3d = "RGB bands from a raster" - else: - data_2d = np.random.rand(10, 10) # 10x10 random array - data_3d = np.random.rand(5, 10, 10) # 5x10x10 random array - desc_2d = "Random 2D data" - desc_3d = "Random 3D data" + with rasterio.open(raster_file, "r") as src: + image_data = src.read() + data_2d = image_data[0] # 1st raster band + data_3d = image_data # all raster bands + desc_2d = "1st band from a raster" + desc_3d = "RGB bands from a raster" + with h5py.File(output_file, 'w') as f: # Main group @@ -162,7 +233,20 @@ def generate_hdf5_file(output_file, raster_file): group.attrs["project"] = "Tutorial example project" -def download_netcdf(download_dir): +def download_netcdf(download_dir: str | Path): + """ + Download an example netcdf file and store it in the provided directory + + Parameters + ---------- + download_dir: + Path to the directory where to store the netcdf + + Returns + ------- + output_file: + Absolute path to the downloaded .nc file + """ output_file = Path(download_dir) / "precip.mon.total.v7.nc" if output_file.exists(): return output_file @@ -178,10 +262,24 @@ def download_netcdf(download_dir): def compare_datacube_formats(comparison_directory, random_shape=None): """ - compare hdf5, netcdf and zarr files: create a random array of size (10, 1000, 1000) and for each format: + Compare hdf5, netcdf and zarr files: create a random array of size (10, 1000, 1000) and for + each format: 1) measure the write time 2) measure file size 3) measure the read time + + The results are then printed. + + Parameters + ---------- + comparison_directory: + Path to store the test data, used for the comparisons + random_shape + Shape of the random array to use + + Returns + ------- + None """ if not random_shape: random_shape = (100, 1000, 1000) @@ -191,7 +289,7 @@ def compare_datacube_formats(comparison_directory, random_shape=None): # HDF5 # write h5_start_write = time.time() - h5_file = Path(comparison_directory)/"h5_file.h5" + h5_file = Path(comparison_directory) / "h5_file.h5" with h5py.File(h5_file, 'w') as f: f.create_dataset('array', data=data) h5_write_time = time.time() - h5_start_write @@ -208,7 +306,7 @@ def compare_datacube_formats(comparison_directory, random_shape=None): # NetCDF # write nc_start_read = time.time() - nc_file = Path(comparison_directory)/"nc_file.nc" + nc_file = Path(comparison_directory) / "nc_file.nc" ds = xr.DataArray(data, dims=["time", "x", "y"]) ds.to_netcdf(nc_file) nc_write_time = time.time() - nc_start_read @@ -225,7 +323,7 @@ def compare_datacube_formats(comparison_directory, random_shape=None): # Zarr # write zarr_start = time.time() - zarr_file = str(Path(comparison_directory)/"zarr_file.zarr") + zarr_file = str(Path(comparison_directory) / "zarr_file.zarr") zarr.save(zarr_file, data) zarr_write_time = time.time() - zarr_start @@ -251,4 +349,4 @@ def compare_datacube_formats(comparison_directory, random_shape=None): print(f"File sizes:\n" f"\th5: {h5_file_size:.3f} MB\n" f"\tnc: {nc_file_size:.3f} MB\n" - f"\tzarr: {zarr_file_size:.3f} MB") \ No newline at end of file + f"\tzarr: {zarr_file_size:.3f} MB") From e7bb48adb684d1595192c1d28dc8d6914a6e6da6 Mon Sep 17 00:00:00 2001 From: EugenePlanteur Date: Wed, 27 Nov 2024 11:35:52 +0100 Subject: [PATCH 23/31] style: fix typo --- data_type/raster_formats.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/data_type/raster_formats.ipynb b/data_type/raster_formats.ipynb index 55c73f1..41c4d83 100644 --- a/data_type/raster_formats.ipynb +++ b/data_type/raster_formats.ipynb @@ -38,7 +38,7 @@ "source": [ "## GeoTIFF\n", "\n", - "In order to highlight the main differences between these formats, let's start by downloading a Sentinel-2 image in GeoTIFF format, using the `download_sample_data` function. These data are not real Sentinel-2 data, we will only use RGB + Near Infrared data, centred on the city of Vannes in France for our tutorial. Other Sentinel-2 data can be downloaded from https://theia.cnes.fr. We then read the image using `rasterio` and measure the time required to read it, as well as the file size:" + "In order to highlight the main differences between these formats, let's start by downloading a Sentinel-2 image in GeoTIFF format, using the `download_sample_data` function. These data are not real Sentinel-2 data, we will only use RGB + Near Infrared data, centered on the city of Vannes in France for our tutorial. Other Sentinel-2 data can be downloaded from https://theia.cnes.fr. We then read the image using `rasterio` and measure the time required to read it, as well as the file size:" ] }, { From 0f5508f3881528e2593e6a226acf7ac387bbc668 Mon Sep 17 00:00:00 2001 From: EugenePlanteur Date: Thu, 28 Nov 2024 08:51:58 +0100 Subject: [PATCH 24/31] style: fix typos --- data_type/data_optimization.ipynb | 84 +++++++++++++++++-------------- data_type/readme.md | 2 +- 2 files changed, 48 insertions(+), 38 deletions(-) diff --git a/data_type/data_optimization.ipynb b/data_type/data_optimization.ipynb index f28a729..873d53c 100644 --- a/data_type/data_optimization.ipynb +++ b/data_type/data_optimization.ipynb @@ -7,14 +7,14 @@ "source": [ "# Optimizing data access and processing\n", "\n", - "Over the multiple formats presented in the other tutorials, some were presented as cloud optimized. This notebook shows some methods to take advantage of those formats to optimize data access and processing. The methods presented are specifically optimized for cloud usage but can (and should when needed) also be used with local files. The general idea is to limit the data access: either by loading only the required data or opening small fractions (chunks) of a whole dataset and iterate over all these chunks.\n", + "Over the multiple formats presented in the other tutorials, some were presented as cloud optimized. This notebook shows some methods to take advantage of those formats to optimize data access and processing. The methods presented are specifically optimized for cloud usage but can (and should most of the time) also be used with local files. The general idea is to limit the data access: either by loading only the required data or opening small fractions (chunks) of a whole dataset and iterate over all these chunks.\n", "\n", "Some examples in this notebook use data downloaded or generated in other notebooks. Make sure you ran them before running this one. They also provide useful information and context on the files and their formats.\n", "\n", "\n", "## Raster data\n", "\n", - "In the [raster formats tutorial](./raster_formats.ipynb), COGs (cloud optimized geotiffs) were presented as the best cloud-oriented solution, as they are natively split in chunks and allow overviews. In this section, we present how to load and process a raster chunk by chunk. This is particularly usefull when using large datasets which can't be loaded in memory (both on local or cloud architectures).\n", + "In the [raster formats tutorial](./raster_formats.ipynb), COGs (Cloud Optimized Geotiffs) were presented as the best cloud-oriented solution, as they are natively split and compressed in chunks and allow overviews. In this section, we present how to load and process a raster chunk by chunk. This is particularly usefull when using large datasets which can't be loaded in memory (both on local or cloud architectures) or when accessing a specific sub area of a temporal series of images.\n", "\n", "### Using rasterio\n", "\n", @@ -31,7 +31,7 @@ "import rasterio\n", "from rasterio.windows import Window\n", "\n", - "cog_path = \"/home/eplanteu/dev/pluto/pluto-tuto-11-format-donnees/data_type/sample_data/rasters/data/xt_SENTINEL2B_20180621-111349-432_L2A_T30TWT_D_V1-8_RVBPIR_cog.tif\"" + "cog_path = \"./sample_data/rasters/data/xt_SENTINEL2B_20180621-111349-432_L2A_T30TWT_D_V1-8_RVBPIR_cog.tif\"" ] }, { @@ -44,22 +44,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 387 ms, sys: 36.7 ms, total: 424 ms\n", - "Wall time: 136 ms\n", - "CPU times: user 23.5 ms, sys: 5.92 ms, total: 29.4 ms\n", - "Wall time: 29.4 ms\n", + "CPU times: user 85.8 ms, sys: 35 ms, total: 121 ms\n", + "Wall time: 125 ms\n", + "CPU times: user 20.5 ms, sys: 5.02 ms, total: 25.5 ms\n", + "Wall time: 25.5 ms\n", "(500, 2410)\n", - "CPU times: user 17.4 ms, sys: 9.86 ms, total: 27.3 ms\n", - "Wall time: 27.3 ms\n", + "CPU times: user 18.8 ms, sys: 5.99 ms, total: 24.8 ms\n", + "Wall time: 24.8 ms\n", "(500, 2410)\n", - "CPU times: user 19.5 ms, sys: 6 ms, total: 25.5 ms\n", - "Wall time: 25.5 ms\n", + "CPU times: user 18.8 ms, sys: 5.91 ms, total: 24.7 ms\n", + "Wall time: 24.7 ms\n", "(500, 2410)\n", - "CPU times: user 18.5 ms, sys: 6.94 ms, total: 25.4 ms\n", - "Wall time: 25.4 ms\n", + "CPU times: user 21.5 ms, sys: 2.04 ms, total: 23.5 ms\n", + "Wall time: 23.5 ms\n", "(500, 2410)\n", - "CPU times: user 3.04 ms, sys: 996 µs, total: 4.03 ms\n", - "Wall time: 4.04 ms\n", + "CPU times: user 3.39 ms, sys: 971 µs, total: 4.36 ms\n", + "Wall time: 4.37 ms\n", "(80, 2410)\n" ] } @@ -88,7 +88,7 @@ "id": "45fa458b-d339-41a5-a7e1-6dce970ad63d", "metadata": {}, "source": [ - "COGs have an intern chunk size used when writing them. It is easier and usually more efficient to use this chunk size instead, using `src.block_windows`. In this code `ji` is the current chunk's coordinates, relative to the chunk grid. The coordiantes of the first pixel of the chunk are given by the widow's column and row offset." + "COGs have an intern chunk size used when writing them. It is easier and usually more efficient to use this chunk size instead, using `src.block_windows`. In this code `ji` is the current chunk's coordinates, relative to the chunk grid. The coordinates of the first pixel of the chunk are given by the widow's column and row offset." ] }, { @@ -864,7 +864,7 @@ " fill: currentColor;\n", "}\n", "
<xarray.DataArray (band: 4, y: 2080, x: 2410)> Size: 80MB\n",
-       "dask.array<open_rasterio-24ca234cfeb112882a38a016783c832b<this-array>, shape=(4, 2080, 2410), dtype=float32, chunksize=(1, 2080, 2410), chunktype=numpy.ndarray>\n",
+       "dask.array<open_rasterio-df2a314bbacb95f006457625f718f7b3<this-array>, shape=(4, 2080, 2410), dtype=float32, chunksize=(1, 2080, 2410), chunktype=numpy.ndarray>\n",
        "Coordinates:\n",
        "  * band         (band) int64 32B 1 2 3 4\n",
        "  * x            (x) float64 19kB 5.013e+05 5.013e+05 ... 5.253e+05 5.253e+05\n",
@@ -873,7 +873,7 @@
        "Attributes:\n",
        "    AREA_OR_POINT:  Area\n",
        "    scale_factor:   1.0\n",
-       "    add_offset:     0.0
" + " dtype='float64', name='y', length=2080))
  • AREA_OR_POINT :
    Area
    scale_factor :
    1.0
    add_offset :
    0.0
  • " ], "text/plain": [ " Size: 80MB\n", - "dask.array, shape=(4, 2080, 2410), dtype=float32, chunksize=(1, 2080, 2410), chunktype=numpy.ndarray>\n", + "dask.array, shape=(4, 2080, 2410), dtype=float32, chunksize=(1, 2080, 2410), chunktype=numpy.ndarray>\n", "Coordinates:\n", " * band (band) int64 32B 1 2 3 4\n", " * x (x) float64 19kB 5.013e+05 5.013e+05 ... 5.253e+05 5.253e+05\n", @@ -1024,7 +1024,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "id": "68033513-8c95-4cc5-9e8c-19271fa8ec17", "metadata": { "scrolled": true @@ -1110,7 +1110,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 6, "id": "3a1cef2e-94d1-443f-bd10-2c1d8e9a5e0a", "metadata": {}, "outputs": [ @@ -1645,12 +1645,12 @@ "data": { "application/vnd.holoviews_exec.v0+json": "", "text/html": [ - "
    \n", - "
    \n", + "
    \n", + "
    \n", "
    \n", "" - ] + ], + "application/vnd.holoviews_exec.v0+json": "" }, "metadata": { "application/vnd.holoviews_exec.v0+json": { - "id": "29dc891d-5b0e-447f-babd-86e7c031c52e" + "id": "35cc8f21-58a9-4918-bfd8-4f39406bc5b7" } }, "output_type": "display_data" } ], - "source": [ - "import time\n", - "from pathlib import Path\n", - "\n", - "import geopandas as gpd\n", - "import hvplot.pandas\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import pandas as pd\n", - "\n", - "from utils import compare_read_write_times, download_sample_vector_data, get_file_size_in_mb\n", - "\n", - "import warnings\n", - "warnings.filterwarnings('ignore') # ignore warnings when reading invalid polygons" - ] + "execution_count": 13 }, { "cell_type": "code", - "execution_count": 2, "id": "d901cb24-1090-4b9c-b9ca-f2300940fcfe", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Reading time: 0.082 seconds\n", - "File size: 10.418388 MB\n" - ] + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-29T07:16:27.117535Z", + "start_time": "2025-01-29T07:16:07.228904Z" } - ], + }, "source": [ "download_dir = \"./sample_data/vector/\"\n", "land_use_shapefile_path = download_sample_vector_data(download_dir)\n", @@ -680,7 +189,18 @@ "land_use[\"area\"] = land_use.geometry.area # new area column\n", "all_types_area = land_use.groupby(\"type\")[\"area\"].sum() # sum of area by land use type\n", "# print(all_types_area) # uncomment to see the results" - ] + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reading time: 0.068 seconds\n", + "File size: 10.418388 MB\n" + ] + } + ], + "execution_count": 14 }, { "cell_type": "markdown", @@ -692,10 +212,13 @@ }, { "cell_type": "code", - "execution_count": 3, "id": "c81cd7b4-2bea-4a72-adaa-9f6468191015", - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-29T08:49:40.711992Z", + "start_time": "2025-01-29T08:49:40.706701Z" + } + }, "source": [ "def analyze_vector_file(filepath):\n", " start = time.time()\n", @@ -708,7 +231,6 @@ "\n", " start = time.time()\n", " land_use[\"area\"] = land_use.geometry.area\n", - " all_types_area = land_use.groupby(\"type\")[\"area\"].sum()\n", " compute_time = time.time() - start\n", " file_size = get_file_size_in_mb(filepath)\n", " print(f\"File type: {Path(filepath).suffix}\\n\"\n", @@ -723,94 +245,123 @@ " start = time.time()\n", " if Path(output_file).suffix == \".parquet\":\n", " gdf.to_parquet(output_file)\n", + " elif Path(output_file).suffix == \".kml\":\n", + " gdf.to_file(output_file, driver=\"KML\")\n", " else:\n", " gdf.to_file(output_file)\n", " write_time = time.time() - start\n", " print(f\"Writing time of {Path(output_file).suffix}: {write_time:.2f} seconds\")\n", "\n", " return write_time" - ] + ], + "outputs": [], + "execution_count": 28 }, { "cell_type": "markdown", "id": "d7650cb0-052d-4ada-b793-c2d1c7a3bc15", "metadata": {}, - "source": [ - "The shapefile is then opened and converted to different formats, measuring the writing time for each one. Each file is then analyzed to check the file size and read time. These information are displayed in histograms using `matplotlib` in the following cells." - ] + "source": "The shapefile is then opened and converted to different formats, measuring the writing time for each one. Each file is then analyzed to check the file size and read time. This information is displayed in histograms (using `holoviews`) in the following cells." }, { "cell_type": "code", - "execution_count": 4, "id": "9972a4fe-9d99-4a35-aade-e00c5a7329e8", - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-29T08:49:48.472515Z", + "start_time": "2025-01-29T08:49:44.017739Z" + } + }, + "source": [ + "# get files paths\n", + "land_use_shape_copy_path = Path(land_use_shapefile_path).with_stem(\"landuse_copy\") # used to measure the write time of shp\n", + "land_use_geojson_path = Path(land_use_shapefile_path).with_suffix(\".geojson\") # path to the GeoJSON file\n", + "land_use_geopkg_path = Path(land_use_shapefile_path).with_suffix(\".gpkg\") # path to the GeoPackage file\n", + "land_use_geoparquet_path = Path(land_use_shapefile_path).with_suffix(\".parquet\") # path to the fichier GeoParquet file\n", + "land_use_fgb_path = Path(land_use_shapefile_path).with_suffix(\".fgb\") # path to the FlatGeobuff file\n", + "land_use_kml_path = Path(land_use_shapefile_path).with_suffix(\".kml\") # path to the kml file\n", + "\n", + "\n", + "# convert files and retrieve write times\n", + "gdf_to_write = gpd.read_file(land_use_shapefile_path, on_invalid=\"ignore\")\n", + "shp_write_time = write_gdf_to_file(gdf_to_write, land_use_shape_copy_path)\n", + "gpkg_write_time = write_gdf_to_file(gdf_to_write, land_use_geopkg_path)\n", + "geojson_write_time = write_gdf_to_file(gdf_to_write, land_use_geojson_path)\n", + "geoparquet_write_time = write_gdf_to_file(gdf_to_write, land_use_geoparquet_path)\n", + "fgb_write_time = write_gdf_to_file(gdf_to_write, land_use_fgb_path)\n", + "kml_write_time = write_gdf_to_file(gdf_to_write, land_use_kml_path)\n", + "\n", + "# analyze files\n", + "shp_read_time, shp_file_size = analyze_vector_file(land_use_shapefile_path)\n", + "gpkg_read_time, gpkg_file_size = analyze_vector_file(land_use_geopkg_path)\n", + "geojson_read_time, geojson_file_size = analyze_vector_file(land_use_geojson_path)\n", + "geoparquet_read_time, geoparquet_file_size = analyze_vector_file(land_use_geoparquet_path)\n", + "fgb_read_time, fgb_file_size = analyze_vector_file(land_use_fgb_path)\n", + "kml_read_time, kml_file_size = analyze_vector_file(land_use_kml_path)" + ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Writing time of .shp: 0.10 seconds\n", - "Writing time of .gpkg: 0.10 seconds\n", - "Writing time of .geojson: 1.17 seconds\n", - "Writing time of .parquet: 0.07 seconds\n", + "Writing time of .shp: 0.13 seconds\n", + "Writing time of .gpkg: 0.12 seconds\n", + "Writing time of .geojson: 1.21 seconds\n", + "Writing time of .parquet: 0.05 seconds\n", "Writing time of .fgb: 0.10 seconds\n", + "Writing time of .kml: 0.84 seconds\n", "File type: .shp\n", "File size: 10.4 MB\n", - "Time to open: 0.144 secondes\n", - "Time to compute: 0.00378 secondes\n", + "Time to open: 0.069 secondes\n", + "Time to compute: 0.00367 secondes\n", "\n", "File type: .gpkg\n", "File size: 13.3 MB\n", "Time to open: 0.054 secondes\n", - "Time to compute: 0.00437 secondes\n", + "Time to compute: 0.00439 secondes\n", "\n", "File type: .geojson\n", "File size: 18.3 MB\n", - "Time to open: 0.536 secondes\n", - "Time to compute: 0.00414 secondes\n", + "Time to open: 0.678 secondes\n", + "Time to compute: 0.00353 secondes\n", "\n", "File type: .parquet\n", "File size: 9.6 MB\n", - "Time to open: 0.073 secondes\n", - "Time to compute: 0.00363 secondes\n", + "Time to open: 0.058 secondes\n", + "Time to compute: 0.00542 secondes\n", "\n", "File type: .fgb\n", "File size: 12.2 MB\n", - "Time to open: 0.049 secondes\n", - "Time to compute: 0.00422 secondes\n", + "Time to open: 0.068 secondes\n", + "Time to compute: 0.00470 secondes\n", + "\n", + "File type: .kml\n", + "File size: 18.4 MB\n", + "Time to open: 0.298 secondes\n", + "Time to compute: 0.00328 secondes\n", "\n" ] } ], - "source": [ - "# get files paths\n", - "land_use_shape_copy_path = Path(land_use_shapefile_path).with_stem(\"landuse_copy\") # used to measure the write time of shp\n", - "land_use_geojson_path = Path(land_use_shapefile_path).with_suffix(\".geojson\") # path to the GeoJSON file\n", - "land_use_geopkg_path = Path(land_use_shapefile_path).with_suffix(\".gpkg\") # path to the GeoPackage file\n", - "land_use_geoparquet_path = Path(land_use_shapefile_path).with_suffix(\".parquet\") # path to the fichier GeoParquet file\n", - "land_use_fgb_path = Path(land_use_shapefile_path).with_suffix(\".fgb\") # path to the FlatGeobuff file\n", - "\n", - "# convert files and retrieve write times\n", - "gdf_to_write = gpd.read_file(land_use_shapefile_path, on_invalid=\"ignore\")\n", - "shp_write_time = write_gdf_to_file(gdf_to_write, land_use_shape_copy_path)\n", - "gpkg_write_time = write_gdf_to_file(gdf_to_write, land_use_geopkg_path)\n", - "geojson_write_time = write_gdf_to_file(gdf_to_write, land_use_geojson_path)\n", - "geoparquet_write_time = write_gdf_to_file(gdf_to_write, land_use_geoparquet_path)\n", - "fgb_write_time = write_gdf_to_file(gdf_to_write, land_use_fgb_path)\n", - "\n", - "# analyze files\n", - "shp_read_time, shp_file_size = analyze_vector_file(land_use_shapefile_path)\n", - "gpkg_read_time, gpkg_file_size = analyze_vector_file(land_use_geopkg_path)\n", - "geojson_read_time, geojson_file_size = analyze_vector_file(land_use_geojson_path)\n", - "geoparquet_read_time, geoparquet_file_size = analyze_vector_file(land_use_geoparquet_path)\n", - "fgb_read_time, fgb_file_size = analyze_vector_file(land_use_fgb_path)" - ] + "execution_count": 29 }, { "cell_type": "code", - "execution_count": 5, "id": "ceca6f95-7a5d-4faf-8bf2-ab27cfcac563", - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-29T08:50:07.393018Z", + "start_time": "2025-01-29T08:50:07.305598Z" + } + }, + "source": [ + "# Read and write times comparison\n", + "read_times = [shp_read_time, gpkg_read_time, geojson_read_time, geoparquet_read_time, fgb_read_time, kml_read_time]\n", + "write_times = [shp_write_time, gpkg_write_time, geojson_write_time, geoparquet_write_time, fgb_write_time, kml_write_time]\n", + "labels = [\"shp\", \"gpkg\", \"geojson\", \"geoparquet\", \"fgb\", \"kml\"]\n", + "\n", + "compare_read_write_times(read_times, write_times, labels)" + ], "outputs": [ { "data": {}, @@ -819,14 +370,13 @@ }, { "data": { - "application/vnd.holoviews_exec.v0+json": "", "text/html": [ - "
    \n", - "
    \n", + "
    \n", + "
    \n", "
    \n", "" ], + "application/vnd.holoviews_exec.v0+json": "", "text/plain": [ ":Bars [Formats,Type] (Time (s))" ] }, - "execution_count": 5, + "execution_count": 31, "metadata": { "application/vnd.holoviews_exec.v0+json": { - "id": "c7a0ddd1-2ee7-4ec5-b4bf-906531d617ab" + "id": "22035855-2417-40a4-acaa-9d6564021997" } }, "output_type": "execute_result" } ], - "source": [ - "# Read and write times comparison\n", - "read_times = [shp_read_time, gpkg_read_time, geojson_read_time, geoparquet_read_time, fgb_read_time]\n", - "write_times = [shp_write_time, gpkg_write_time, geojson_write_time, geoparquet_write_time, fgb_write_time]\n", - "labels = [\"shp\", \"gpkg\", \"geojson\", \"geoparquet\", \"fgb\"]\n", - "\n", - "compare_read_write_times(read_times, write_times, labels)" - ] + "execution_count": 31 }, { "cell_type": "code", - "execution_count": 6, "id": "40d4dbf3-9f6b-4ac5-b41c-deafb079134b", - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-29T08:52:03.364847Z", + "start_time": "2025-01-29T08:52:03.268584Z" + } + }, + "source": [ + "# Comparison without geojson and kml\n", + "write_times = [shp_write_time, gpkg_write_time, geoparquet_write_time, fgb_write_time]\n", + "read_times = [shp_read_time, gpkg_read_time, geoparquet_read_time, fgb_read_time]\n", + "labels = [\"shp\", \"gpkg\", \"geoparquet\", \"fgb\"]\n", + "compare_read_write_times(read_times, write_times, labels)" + ], "outputs": [ { "data": {}, @@ -927,14 +482,13 @@ }, { "data": { - "application/vnd.holoviews_exec.v0+json": "", "text/html": [ - "
    \n", - "
    \n", + "
    \n", + "
    \n", "
    \n", "" ], + "application/vnd.holoviews_exec.v0+json": "", "text/plain": [ ":Bars [Formats,Type] (Time (s))" ] }, - "execution_count": 6, + "execution_count": 34, "metadata": { "application/vnd.holoviews_exec.v0+json": { - "id": "0903dc7e-f79b-4c8a-a0c9-ed22607a6e21" + "id": "2feda016-a131-42ac-80e4-f69752c24743" } }, "output_type": "execute_result" } ], - "source": [ - "# Comparison without geojson\n", - "write_times = [shp_write_time, gpkg_write_time, geoparquet_write_time, fgb_write_time]\n", - "read_times = [shp_read_time, gpkg_read_time, geoparquet_read_time, fgb_read_time]\n", - "labels = [\"shp\", \"gpkg\", \"geoparquet\", \"fgb\"]\n", - "compare_read_write_times(read_times, write_times, labels)" - ] + "execution_count": 34 }, { "cell_type": "code", - "execution_count": 7, "id": "3d13be6c-14da-40b7-bd61-0b893fd7e136", - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-29T08:52:30.637367Z", + "start_time": "2025-01-29T08:52:30.575310Z" + } + }, + "source": [ + "# File size comparison\n", + "files_sizes = [shp_file_size, gpkg_file_size, geojson_file_size, geoparquet_file_size, fgb_file_size, kml_file_size]\n", + "labels = [\"shp\", \"gpkg\", \"geojson\", \"geoparquet\", \"fgb\", \"kml\"]\n", + "\n", + "# Histogram\n", + "data = pd.DataFrame({\n", + " 'Formats': labels,\n", + " 'File size in MB': files_sizes\n", + "})\n", + "data.hvplot.bar(\n", + " x='Formats',\n", + " y='File size in MB',\n", + " width=500,\n", + " height=400,\n", + " color='#a6bfe0',\n", + " title='File size depending on format',\n", + " xlabel='Formats',\n", + " ylabel='File size in MB'\n", + ")" + ], "outputs": [ { "data": {}, @@ -1034,14 +608,13 @@ }, { "data": { - "application/vnd.holoviews_exec.v0+json": "", "text/html": [ - "
    \n", - "
    \n", + "
    \n", + "
    \n", "
    \n", "" ], + "application/vnd.holoviews_exec.v0+json": "", "text/plain": [ ":Bars [Formats] (File size in MB)" ] }, - "execution_count": 7, + "execution_count": 35, "metadata": { "application/vnd.holoviews_exec.v0+json": { - "id": "c14ff9ba-40af-4e16-b95d-9e72e6e73310" + "id": "6dd5e04b-e3a0-4ef1-82f1-35855deb446b" } }, "output_type": "execute_result" } ], - "source": [ - "# File size comaprison\n", - "files_sizes = [shp_file_size, gpkg_file_size, geojson_file_size, geoparquet_file_size, fgb_file_size]\n", - "labels = [\"shp\", \"gpkg\", \"geojson\", \"geoparquet\", \"fgb\"]\n", - "\n", - "# Histogram\n", - "data = pd.DataFrame({\n", - " 'Formats': labels,\n", - " 'File size in MB': files_sizes\n", - "})\n", - "data.hvplot.bar(\n", - " x='Formats',\n", - " y='File size in MB',\n", - " width=500,\n", - " height=400,\n", - " color='#a6bfe0',\n", - " title='File size depending on format',\n", - " xlabel='Formats',\n", - " ylabel='File size in MB'\n", - ")" - ] + "execution_count": 35 }, { "cell_type": "markdown", "id": "08c976c3-fd87-4c4b-950f-eb5ec3ed473d", "metadata": {}, "source": [ - "As stated in the beginning, the performances obtained from using the GeoJSON are worse than for any other tested format. On the other hand, the geoparquet offers greater performances. However, this benchmarking is not exhaustive:\n", + "As stated in the beginning, the performances obtained from using the GeoJSON and KML are worse than for any other tested format. On the other hand, the geoparquet offers greater performances. However, this benchmarking is not exhaustive:\n", "\n", "- it was tested on only one dataset: performances are data-dependant, see https://flatgeobuf.org/#performance (from the official flatgeobuf documentation) for another benchmark\n", - "- a specific `geopandas` version was used: oledr versions of pandas were much less performant and/or used different engines, which also lowered performances\n", - "- it was run on a local infastructure: cloud-specific performances were not highlighted\n", + "- a specific `geopandas` version was used: older versions of pandas were much less performant and/or used different engines, which also lowered performances\n", + "- it was run on a local infrastructure: cloud-specific performances were not highlighted\n", "\n", "\n", "However, performances aren't the only comparison points. As explained in the introduction of this notebook, the shapefile suffers from many flaws. But every format has its advantages and limitations. Here is a recapitulatory table:\n", "\n", - "| Format | Advantages | Drawbacks |\n", - "|------------|------------------------------------------------------------------------|------------------------------------------------------------------------------------|\n", - "| Shapefile | The most popular and supported format, very stable | Requires multiple files, limitations on attribute names and number, files <2GB ... |\n", - "| GeoPackage | Faster, widely supported, based on SQLite | Bigger files, no streaming possibility |\n", - "| GeoJSON | Streaming available, human-readable | Lower performance and larger file sizes |\n", - "| GeoParquet | Cloud optimized, great performance, lighter files, supports indexation | Less supported, requires modern infrastructure and updated software to operate |\n", - "| FlatGeobuf | Good performance and file compression, optimized for spatial requests | Less supported |\n" + "| Format | Advantages | Drawbacks |\n", + "|------------|------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------|\n", + "| Shapefile | The most popular and supported format, very stable | Requires multiple files, limitations on attribute names and number, files <2GB ... |\n", + "| GeoPackage | Faster, widely supported, based on SQLite | Bigger files, no streaming possibility |\n", + "| GeoJSON | Streaming available, human-readable | Lower performance and larger file sizes |\n", + "| KML | Widely supported, easy integration with Google Earth, human-readable | Lower performance, larger file sizes, not actively maintained (see [libkml github](https://github.com/libkml/libkml)) |\n", + "| GeoParquet | Cloud optimized, great performance, lighter files, supports indexation | Less supported, requires modern infrastructure and updated software to operate |\n", + "| FlatGeobuf | Good performance and file compression, optimized for spatial requests | Less supported |\n" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "db442d81-1df7-46b7-8774-12f4b8143d14", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 694c5044f57c246074b01296b8bb6848a8827a76 Mon Sep 17 00:00:00 2001 From: EugenePlanteur Date: Wed, 29 Jan 2025 13:46:50 +0100 Subject: [PATCH 28/31] doc: update readme with instructions on the need to have an internet connection or download datasets + link to visualization tutotial --- data_type/readme.md | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/data_type/readme.md b/data_type/readme.md index 42af3ec..c2c5edf 100644 --- a/data_type/readme.md +++ b/data_type/readme.md @@ -12,8 +12,18 @@ which contexts to use them most effectively. It will be divided into several jup 5) [Data optimization](./data_optimization.ipynb) For each tutorial, sample data will be provided in the `sample_data` directory or automatically -downloaded (in the `sample_data` directory by default) +downloaded (in the `sample_data` directory by default). This means that an internet connection is +required to run these notebooks. Alternatively, you can manually download data from other providers +and use them to run the notebooks. In some examples, benchmarks are ran and performances are +compared between different formats, but the data used for these tests is generally quite small, +mostly used as example. Using real, larger datasets highlights better the performance discrepancies +between formats. For example, you can use real Sentinel-2 or SWOT products (#todo: link to swot +pluto tutorial). +Some notebooks showcase how to visualize the data from the different file types, but you can find +more detailed tutorials [here](https://pluto.pages.cnes.fr/portal/data/miscellaneous/tuto_python_visu_tools_spatial_data.html). + +## Installation To run a notebook, first create a virtual environment using pip. Then, install the required packages (if not already done), using the `requirements.txt` file. From 6122375f54105c10ced97ea421affe03a35c9d44 Mon Sep 17 00:00:00 2001 From: EugenePlanteur Date: Mon, 3 Feb 2025 08:51:24 +0100 Subject: [PATCH 29/31] doc: update doc to link to data providers --- data_type/readme.md | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/data_type/readme.md b/data_type/readme.md index c2c5edf..b840d5d 100644 --- a/data_type/readme.md +++ b/data_type/readme.md @@ -17,8 +17,13 @@ required to run these notebooks. Alternatively, you can manually download data f and use them to run the notebooks. In some examples, benchmarks are ran and performances are compared between different formats, but the data used for these tests is generally quite small, mostly used as example. Using real, larger datasets highlights better the performance discrepancies -between formats. For example, you can use real Sentinel-2 or SWOT products (#todo: link to swot -pluto tutorial). +between formats. For example, in the [raster tutorial](./raster_formats.ipynb) you can use real +Sentinel-2 data, downloadable from [geodes](https://geodes-portal.cnes.fr/) or +[copernicus](https://browser.dataspace.copernicus.eu/). For the [point clouds](./point_clouds.ipynb) + or [datacube](./datacube_formats.ipynb) tutorials, you can use SWOT data, available on +[hydroweb next](https://hydroweb.next.theia-land.fr/) (with netcdf files for example). For SWOT +data, you can also check out this tutorial (TBD). + Some notebooks showcase how to visualize the data from the different file types, but you can find more detailed tutorials [here](https://pluto.pages.cnes.fr/portal/data/miscellaneous/tuto_python_visu_tools_spatial_data.html). From 9e8292b2bd425f6414dd1d3c6a7f02745027580e Mon Sep 17 00:00:00 2001 From: EugenePlanteur Date: Mon, 3 Feb 2025 10:59:41 +0100 Subject: [PATCH 30/31] doc: fix install instructions --- data_type/readme.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/data_type/readme.md b/data_type/readme.md index b840d5d..2e6b684 100644 --- a/data_type/readme.md +++ b/data_type/readme.md @@ -35,8 +35,8 @@ packages (if not already done), using the `requirements.txt` file. ```bash python -m venv venv -pip install -r requirements.txt source venv/bin/activate +pip install -r requirements.txt ``` Then you can simply use `jupyter notebook xxx.ipynb` to run the corresponding notebook. From 2613ba839c0183d4037f86b7f88d57359bd5ac6d Mon Sep 17 00:00:00 2001 From: EugenePlanteur Date: Tue, 4 Feb 2025 11:56:38 +0100 Subject: [PATCH 31/31] doc: add documentation about sample data used in the notebooks --- data_type/data_optimization.ipynb | 2573 +----------- data_type/datacube_formats.ipynb | 5898 +-------------------------- data_type/point_clouds.ipynb | 3 + data_type/raster_formats.ipynb | 204 +- data_type/vector_data_formats.ipynb | 6 +- 5 files changed, 236 insertions(+), 8448 deletions(-) diff --git a/data_type/data_optimization.ipynb b/data_type/data_optimization.ipynb index 40e8ad0..745d18f 100644 --- a/data_type/data_optimization.ipynb +++ b/data_type/data_optimization.ipynb @@ -9,12 +9,13 @@ "\n", "Over the multiple formats presented in the other tutorials, some were presented as cloud optimized. This notebook shows some methods to take advantage of those formats to optimize data access and processing. The methods presented are specifically optimized for cloud usage but can (and should most of the time) also be used with local files. The general idea is to limit the data access: either by loading only the required data or opening small fractions (chunks) of a whole dataset and iterate over all these chunks.\n", "\n", - "Some examples in this notebook use data downloaded or generated in other notebooks. Make sure you ran them before running this one. They also provide useful information and context on the files and their formats.\n", "\n", + "## Data used\n", + "This tutorial assumes the user ran the other notebooks before, or at least the corresponding ones, e.g. to run the *raster* section of this notebook, it is recommended to run the [raster formats tutorial](./raster_formats.ipynb) first. They give context on the data used and basic instructions on how to deal with the different types and formats. Moreover, the other tutorials download or generate sample data used as example, so make sure you at least ran the generation parts of the corresponding tutorials, or use your own data.\n", "\n", "## Raster data\n", "\n", - "In the [raster formats tutorial](./raster_formats.ipynb), COGs (Cloud Optimized Geotiffs) were presented as the best cloud-oriented solution, as they are natively split and compressed in chunks and allow overviews. In this section, we present how to load and process a raster chunk by chunk. This is particularly usefull when using large datasets which can't be loaded in memory (both on local or cloud architectures) or when accessing a specific sub area of a temporal series of images.\n", + "In the [raster formats tutorial](./raster_formats.ipynb), COGs (Cloud Optimized Geotiffs) were presented as the best cloud-oriented solution, as they are natively split and compressed in chunks and allow overviews. In this section, we present how to load and process a raster chunk by chunk. This is particularly useful when using large datasets which can't be loaded in memory (both on local or cloud architectures) or when accessing a specific sub area of a temporal series of images.\n", "\n", "### Using rasterio\n", "\n", @@ -26,82 +27,37 @@ }, { "cell_type": "code", - "execution_count": 2, "id": "107f18b5-09e2-4a7e-a75e-a4d1517aaed7", "metadata": {}, - "outputs": [], "source": [ "import rasterio\n", "from rasterio.windows import Window\n", "\n", "cog_path = \"./sample_data/rasters/data/xt_SENTINEL2B_20180621-111349-432_L2A_T30TWT_D_V1-8_RVBPIR_cog.tif\"" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 4, "id": "32b3e7bc-3684-4f7d-a715-8dd36b56982c", "metadata": { "scrolled": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 89.2 ms, sys: 8.13 ms, total: 97.3 ms\n", - "Wall time: 96.3 ms\n" - ] - } - ], "source": [ "# read the entire raster (for comparison)\n", "with rasterio.open(cog_path) as src:\n", " %time data = src.read(1)" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 5, "id": "feaa5049-516f-4fa3-a26a-1a89845f3137", "metadata": { "scrolled": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 20.3 ms, sys: 4.03 ms, total: 24.3 ms\n", - "Wall time: 23.5 ms\n", - "(1000, 1000)\n", - "CPU times: user 19.4 ms, sys: 0 ns, total: 19.4 ms\n", - "Wall time: 19.2 ms\n", - "(1000, 1000)\n", - "CPU times: user 7.37 ms, sys: 0 ns, total: 7.37 ms\n", - "Wall time: 7.38 ms\n", - "(1000, 410)\n", - "CPU times: user 17.4 ms, sys: 1 ms, total: 18.4 ms\n", - "Wall time: 18.4 ms\n", - "(1000, 1000)\n", - "CPU times: user 18 ms, sys: 3.93 ms, total: 21.9 ms\n", - "Wall time: 21.9 ms\n", - "(1000, 1000)\n", - "CPU times: user 8.14 ms, sys: 14 µs, total: 8.15 ms\n", - "Wall time: 8.16 ms\n", - "(1000, 410)\n", - "CPU times: user 1.28 ms, sys: 0 ns, total: 1.28 ms\n", - "Wall time: 1.29 ms\n", - "(80, 1000)\n", - "CPU times: user 755 µs, sys: 920 µs, total: 1.67 ms\n", - "Wall time: 1.68 ms\n", - "(80, 1000)\n", - "CPU times: user 0 ns, sys: 969 µs, total: 969 µs\n", - "Wall time: 971 µs\n", - "(80, 410)\n" - ] - } - ], "source": [ "# read chunk by chunk\n", "x_chunk_size = 1000 # number of columns per chunk\n", @@ -117,7 +73,9 @@ " window = Window(start_col, start_row, end_col - start_col, end_row - start_row)\n", " %time data = src.read(1, window=window) # read the 1st band\n", " print(data.shape)" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -129,379 +87,10 @@ }, { "cell_type": "code", - "execution_count": 3, "id": "2f666a3c-8244-48ee-a1b6-38ea477faf23", "metadata": { "scrolled": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Chunk's coordinates: (0, 0)\n", - "Window(col_off=0, row_off=0, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (0, 1)\n", - "Window(col_off=256, row_off=0, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (0, 2)\n", - "Window(col_off=512, row_off=0, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (0, 3)\n", - "Window(col_off=768, row_off=0, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (0, 4)\n", - "Window(col_off=1024, row_off=0, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (0, 5)\n", - "Window(col_off=1280, row_off=0, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (0, 6)\n", - "Window(col_off=1536, row_off=0, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (0, 7)\n", - "Window(col_off=1792, row_off=0, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (0, 8)\n", - "Window(col_off=2048, row_off=0, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (0, 9)\n", - "Window(col_off=2304, row_off=0, width=106, height=256)\n", - "(4, 256, 106) \n", - "\n", - "Chunk's coordinates: (1, 0)\n", - "Window(col_off=0, row_off=256, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (1, 1)\n", - "Window(col_off=256, row_off=256, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (1, 2)\n", - "Window(col_off=512, row_off=256, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (1, 3)\n", - "Window(col_off=768, row_off=256, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (1, 4)\n", - "Window(col_off=1024, row_off=256, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (1, 5)\n", - "Window(col_off=1280, row_off=256, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (1, 6)\n", - "Window(col_off=1536, row_off=256, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (1, 7)\n", - "Window(col_off=1792, row_off=256, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (1, 8)\n", - "Window(col_off=2048, row_off=256, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (1, 9)\n", - "Window(col_off=2304, row_off=256, width=106, height=256)\n", - "(4, 256, 106) \n", - "\n", - "Chunk's coordinates: (2, 0)\n", - "Window(col_off=0, row_off=512, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (2, 1)\n", - "Window(col_off=256, row_off=512, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (2, 2)\n", - "Window(col_off=512, row_off=512, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (2, 3)\n", - "Window(col_off=768, row_off=512, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (2, 4)\n", - "Window(col_off=1024, row_off=512, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (2, 5)\n", - "Window(col_off=1280, row_off=512, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (2, 6)\n", - "Window(col_off=1536, row_off=512, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (2, 7)\n", - "Window(col_off=1792, row_off=512, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (2, 8)\n", - "Window(col_off=2048, row_off=512, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (2, 9)\n", - "Window(col_off=2304, row_off=512, width=106, height=256)\n", - "(4, 256, 106) \n", - "\n", - "Chunk's coordinates: (3, 0)\n", - "Window(col_off=0, row_off=768, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (3, 1)\n", - "Window(col_off=256, row_off=768, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (3, 2)\n", - "Window(col_off=512, row_off=768, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (3, 3)\n", - "Window(col_off=768, row_off=768, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (3, 4)\n", - "Window(col_off=1024, row_off=768, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (3, 5)\n", - "Window(col_off=1280, row_off=768, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (3, 6)\n", - "Window(col_off=1536, row_off=768, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (3, 7)\n", - "Window(col_off=1792, row_off=768, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (3, 8)\n", - "Window(col_off=2048, row_off=768, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (3, 9)\n", - "Window(col_off=2304, row_off=768, width=106, height=256)\n", - "(4, 256, 106) \n", - "\n", - "Chunk's coordinates: (4, 0)\n", - "Window(col_off=0, row_off=1024, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (4, 1)\n", - "Window(col_off=256, row_off=1024, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (4, 2)\n", - "Window(col_off=512, row_off=1024, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (4, 3)\n", - "Window(col_off=768, row_off=1024, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (4, 4)\n", - "Window(col_off=1024, row_off=1024, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (4, 5)\n", - "Window(col_off=1280, row_off=1024, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (4, 6)\n", - "Window(col_off=1536, row_off=1024, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (4, 7)\n", - "Window(col_off=1792, row_off=1024, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (4, 8)\n", - "Window(col_off=2048, row_off=1024, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (4, 9)\n", - "Window(col_off=2304, row_off=1024, width=106, height=256)\n", - "(4, 256, 106) \n", - "\n", - "Chunk's coordinates: (5, 0)\n", - "Window(col_off=0, row_off=1280, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (5, 1)\n", - "Window(col_off=256, row_off=1280, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (5, 2)\n", - "Window(col_off=512, row_off=1280, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (5, 3)\n", - "Window(col_off=768, row_off=1280, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (5, 4)\n", - "Window(col_off=1024, row_off=1280, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (5, 5)\n", - "Window(col_off=1280, row_off=1280, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (5, 6)\n", - "Window(col_off=1536, row_off=1280, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (5, 7)\n", - "Window(col_off=1792, row_off=1280, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (5, 8)\n", - "Window(col_off=2048, row_off=1280, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (5, 9)\n", - "Window(col_off=2304, row_off=1280, width=106, height=256)\n", - "(4, 256, 106) \n", - "\n", - "Chunk's coordinates: (6, 0)\n", - "Window(col_off=0, row_off=1536, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (6, 1)\n", - "Window(col_off=256, row_off=1536, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (6, 2)\n", - "Window(col_off=512, row_off=1536, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (6, 3)\n", - "Window(col_off=768, row_off=1536, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (6, 4)\n", - "Window(col_off=1024, row_off=1536, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (6, 5)\n", - "Window(col_off=1280, row_off=1536, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (6, 6)\n", - "Window(col_off=1536, row_off=1536, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (6, 7)\n", - "Window(col_off=1792, row_off=1536, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (6, 8)\n", - "Window(col_off=2048, row_off=1536, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (6, 9)\n", - "Window(col_off=2304, row_off=1536, width=106, height=256)\n", - "(4, 256, 106) \n", - "\n", - "Chunk's coordinates: (7, 0)\n", - "Window(col_off=0, row_off=1792, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (7, 1)\n", - "Window(col_off=256, row_off=1792, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (7, 2)\n", - "Window(col_off=512, row_off=1792, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (7, 3)\n", - "Window(col_off=768, row_off=1792, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (7, 4)\n", - "Window(col_off=1024, row_off=1792, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (7, 5)\n", - "Window(col_off=1280, row_off=1792, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (7, 6)\n", - "Window(col_off=1536, row_off=1792, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (7, 7)\n", - "Window(col_off=1792, row_off=1792, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (7, 8)\n", - "Window(col_off=2048, row_off=1792, width=256, height=256)\n", - "(4, 256, 256) \n", - "\n", - "Chunk's coordinates: (7, 9)\n", - "Window(col_off=2304, row_off=1792, width=106, height=256)\n", - "(4, 256, 106) \n", - "\n", - "Chunk's coordinates: (8, 0)\n", - "Window(col_off=0, row_off=2048, width=256, height=32)\n", - "(4, 32, 256) \n", - "\n", - "Chunk's coordinates: (8, 1)\n", - "Window(col_off=256, row_off=2048, width=256, height=32)\n", - "(4, 32, 256) \n", - "\n", - "Chunk's coordinates: (8, 2)\n", - "Window(col_off=512, row_off=2048, width=256, height=32)\n", - "(4, 32, 256) \n", - "\n", - "Chunk's coordinates: (8, 3)\n", - "Window(col_off=768, row_off=2048, width=256, height=32)\n", - "(4, 32, 256) \n", - "\n", - "Chunk's coordinates: (8, 4)\n", - "Window(col_off=1024, row_off=2048, width=256, height=32)\n", - "(4, 32, 256) \n", - "\n", - "Chunk's coordinates: (8, 5)\n", - "Window(col_off=1280, row_off=2048, width=256, height=32)\n", - "(4, 32, 256) \n", - "\n", - "Chunk's coordinates: (8, 6)\n", - "Window(col_off=1536, row_off=2048, width=256, height=32)\n", - "(4, 32, 256) \n", - "\n", - "Chunk's coordinates: (8, 7)\n", - "Window(col_off=1792, row_off=2048, width=256, height=32)\n", - "(4, 32, 256) \n", - "\n", - "Chunk's coordinates: (8, 8)\n", - "Window(col_off=2048, row_off=2048, width=256, height=32)\n", - "(4, 32, 256) \n", - "\n", - "Chunk's coordinates: (8, 9)\n", - "Window(col_off=2304, row_off=2048, width=106, height=32)\n", - "(4, 32, 106) \n", - "\n" - ] - } - ], "source": [ "with rasterio.open(cog_path) as src:\n", " for ji, window in src.block_windows(1):\n", @@ -509,7 +98,9 @@ " print(window)\n", " data = src.read(window=window)\n", " print(data.shape, \"\\n\")" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -523,513 +114,16 @@ }, { "cell_type": "code", - "execution_count": 4, "id": "0bc8b66e-7747-4014-950f-f39b2af13d1e", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
    \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
    <xarray.DataArray (band: 4, y: 2080, x: 2410)> Size: 80MB\n",
    -       "dask.array<open_rasterio-df2a314bbacb95f006457625f718f7b3<this-array>, shape=(4, 2080, 2410), dtype=float32, chunksize=(1, 2080, 2410), chunktype=numpy.ndarray>\n",
    -       "Coordinates:\n",
    -       "  * band         (band) int64 32B 1 2 3 4\n",
    -       "  * x            (x) float64 19kB 5.013e+05 5.013e+05 ... 5.253e+05 5.253e+05\n",
    -       "  * y            (y) float64 17kB 5.279e+06 5.279e+06 ... 5.258e+06 5.258e+06\n",
    -       "    spatial_ref  int64 8B 0\n",
    -       "Attributes:\n",
    -       "    AREA_OR_POINT:  Area\n",
    -       "    scale_factor:   1.0\n",
    -       "    add_offset:     0.0
    " - ], - "text/plain": [ - " Size: 80MB\n", - "dask.array, shape=(4, 2080, 2410), dtype=float32, chunksize=(1, 2080, 2410), chunktype=numpy.ndarray>\n", - "Coordinates:\n", - " * band (band) int64 32B 1 2 3 4\n", - " * x (x) float64 19kB 5.013e+05 5.013e+05 ... 5.253e+05 5.253e+05\n", - " * y (y) float64 17kB 5.279e+06 5.279e+06 ... 5.258e+06 5.258e+06\n", - " spatial_ref int64 8B 0\n", - "Attributes:\n", - " AREA_OR_POINT: Area\n", - " scale_factor: 1.0\n", - " add_offset: 0.0" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "import rioxarray as rxr\n", "\n", "xds = rxr.open_rasterio(cog_path, chunks=True)\n", "xds" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1060,67 +154,10 @@ }, { "cell_type": "code", - "execution_count": 5, "id": "68033513-8c95-4cc5-9e8c-19271fa8ec17", "metadata": { "scrolled": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch number 0, n_rows: 1000\n", - "316 occurences of 'forest'\n", - "\n", - "Batch number 1, n_rows: 1000\n", - "273 occurences of 'forest'\n", - "\n", - "Batch number 2, n_rows: 1000\n", - "515 occurences of 'forest'\n", - "\n", - "Batch number 3, n_rows: 1000\n", - "245 occurences of 'forest'\n", - "\n", - "Batch number 4, n_rows: 1000\n", - "286 occurences of 'forest'\n", - "\n", - "Batch number 5, n_rows: 1000\n", - "421 occurences of 'forest'\n", - "\n", - "Batch number 6, n_rows: 1000\n", - "423 occurences of 'forest'\n", - "\n", - "Batch number 7, n_rows: 1000\n", - "437 occurences of 'forest'\n", - "\n", - "Batch number 8, n_rows: 1000\n", - "184 occurences of 'forest'\n", - "\n", - "Batch number 9, n_rows: 1000\n", - "75 occurences of 'forest'\n", - "\n", - "Batch number 10, n_rows: 1000\n", - "28 occurences of 'forest'\n", - "\n", - "Batch number 11, n_rows: 1000\n", - "11 occurences of 'forest'\n", - "\n", - "Batch number 12, n_rows: 1000\n", - "11 occurences of 'forest'\n", - "\n", - "Batch number 13, n_rows: 1000\n", - "15 occurences of 'forest'\n", - "\n", - "Batch number 14, n_rows: 1000\n", - "26 occurences of 'forest'\n", - "\n", - "Batch number 15, n_rows: 297\n", - "49 occurences of 'forest'\n", - "\n" - ] - } - ], "source": [ "import pyarrow.parquet as pq\n", "file_path = \"./sample_data/vector/departement-31/landuse.parquet\"\n", @@ -1132,7 +169,9 @@ " column=batch.column(\"type\").to_pandas() # select the column 'type' and transform the column to a pandas series\n", " n_forest = len(column[column == \"forest\"].index) # count the occurrences of 'forest' \n", " print(f\"{n_forest} occurences of 'forest'\\n\")" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1146,1015 +185,8 @@ }, { "cell_type": "code", - "execution_count": 6, "id": "3a1cef2e-94d1-443f-bd10-2c1d8e9a5e0a", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": [ - "(function(root) {\n", - " function now() {\n", - " return new Date();\n", - " }\n", - "\n", - " const force = true;\n", - " const py_version = '3.5.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", - " const reloading = false;\n", - " const Bokeh = root.Bokeh;\n", - "\n", - " // Set a timeout for this load but only if we are not already initializing\n", - " if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n", - " root._bokeh_timeout = Date.now() + 5000;\n", - " root._bokeh_failed_load = false;\n", - " }\n", - "\n", - " function run_callbacks() {\n", - " try {\n", - " root._bokeh_onload_callbacks.forEach(function(callback) {\n", - " if (callback != null)\n", - " callback();\n", - " });\n", - " } finally {\n", - " delete root._bokeh_onload_callbacks;\n", - " }\n", - " console.debug(\"Bokeh: all callbacks have finished\");\n", - " }\n", - "\n", - " function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n", - " if (css_urls == null) css_urls = [];\n", - " if (js_urls == null) js_urls = [];\n", - " if (js_modules == null) js_modules = [];\n", - " if (js_exports == null) js_exports = {};\n", - "\n", - " root._bokeh_onload_callbacks.push(callback);\n", - "\n", - " if (root._bokeh_is_loading > 0) {\n", - " // Don't load bokeh if it is still initializing\n", - " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", - " return null;\n", - " } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", - " // There is nothing to load\n", - " run_callbacks();\n", - " return null;\n", - " }\n", - "\n", - " function on_load() {\n", - " root._bokeh_is_loading--;\n", - " if (root._bokeh_is_loading === 0) {\n", - " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", - " run_callbacks()\n", - " }\n", - " }\n", - " window._bokeh_on_load = on_load\n", - "\n", - " function on_error(e) {\n", - " const src_el = e.srcElement\n", - " console.error(\"failed to load \" + (src_el.href || src_el.src));\n", - " }\n", - "\n", - " const skip = [];\n", - " if (window.requirejs) {\n", - " window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n", - " root._bokeh_is_loading = css_urls.length + 0;\n", - " } else {\n", - " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", - " }\n", - "\n", - " const existing_stylesheets = []\n", - " const links = document.getElementsByTagName('link')\n", - " for (let i = 0; i < links.length; i++) {\n", - " const link = links[i]\n", - " if (link.href != null) {\n", - " existing_stylesheets.push(link.href)\n", - " }\n", - " }\n", - " for (let i = 0; i < css_urls.length; i++) {\n", - " const url = css_urls[i];\n", - " const escaped = encodeURI(url)\n", - " if (existing_stylesheets.indexOf(escaped) !== -1) {\n", - " on_load()\n", - " continue;\n", - " }\n", - " const element = document.createElement(\"link\");\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.rel = \"stylesheet\";\n", - " element.type = \"text/css\";\n", - " element.href = url;\n", - " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", - " document.body.appendChild(element);\n", - " } var existing_scripts = []\n", - " const scripts = document.getElementsByTagName('script')\n", - " for (let i = 0; i < scripts.length; i++) {\n", - " var script = scripts[i]\n", - " if (script.src != null) {\n", - " existing_scripts.push(script.src)\n", - " }\n", - " }\n", - " for (let i = 0; i < js_urls.length; i++) {\n", - " const url = js_urls[i];\n", - " const escaped = encodeURI(url)\n", - " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", - " if (!window.requirejs) {\n", - " on_load();\n", - " }\n", - " continue;\n", - " }\n", - " const element = document.createElement('script');\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.src = url;\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " document.head.appendChild(element);\n", - " }\n", - " for (let i = 0; i < js_modules.length; i++) {\n", - " const url = js_modules[i];\n", - " const escaped = encodeURI(url)\n", - " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", - " if (!window.requirejs) {\n", - " on_load();\n", - " }\n", - " continue;\n", - " }\n", - " var element = document.createElement('script');\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.src = url;\n", - " element.type = \"module\";\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " document.head.appendChild(element);\n", - " }\n", - " for (const name in js_exports) {\n", - " const url = js_exports[name];\n", - " const escaped = encodeURI(url)\n", - " if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n", - " if (!window.requirejs) {\n", - " on_load();\n", - " }\n", - " continue;\n", - " }\n", - " var element = document.createElement('script');\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.type = \"module\";\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " element.textContent = `\n", - " import ${name} from \"${url}\"\n", - " window.${name} = ${name}\n", - " window._bokeh_on_load()\n", - " `\n", - " document.head.appendChild(element);\n", - " }\n", - " if (!js_urls.length && !js_modules.length) {\n", - " on_load()\n", - " }\n", - " };\n", - "\n", - " function inject_raw_css(css) {\n", - " const element = document.createElement(\"style\");\n", - " element.appendChild(document.createTextNode(css));\n", - " document.body.appendChild(element);\n", - " }\n", - "\n", - " const js_urls = [\"https://cdn.holoviz.org/panel/1.5.3/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.5.2.min.js\", \"https://cdn.holoviz.org/panel/1.5.3/dist/panel.min.js\"];\n", - " const js_modules = [];\n", - " const js_exports = {};\n", - " const css_urls = [];\n", - " const inline_js = [ function(Bokeh) {\n", - " Bokeh.set_log_level(\"info\");\n", - " },\n", - "function(Bokeh) {} // ensure no trailing comma for IE\n", - " ];\n", - "\n", - " function run_inline_js() {\n", - " if ((root.Bokeh !== undefined) || (force === true)) {\n", - " for (let i = 0; i < inline_js.length; i++) {\n", - " try {\n", - " inline_js[i].call(root, root.Bokeh);\n", - " } catch(e) {\n", - " if (!reloading) {\n", - " throw e;\n", - " }\n", - " }\n", - " }\n", - " // Cache old bokeh versions\n", - " if (Bokeh != undefined && !reloading) {\n", - " var NewBokeh = root.Bokeh;\n", - " if (Bokeh.versions === undefined) {\n", - " Bokeh.versions = new Map();\n", - " }\n", - " if (NewBokeh.version !== Bokeh.version) {\n", - " Bokeh.versions.set(NewBokeh.version, NewBokeh)\n", - " }\n", - " root.Bokeh = Bokeh;\n", - " }\n", - " } else if (Date.now() < root._bokeh_timeout) {\n", - " setTimeout(run_inline_js, 100);\n", - " } else if (!root._bokeh_failed_load) {\n", - " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", - " root._bokeh_failed_load = true;\n", - " }\n", - " root._bokeh_is_initializing = false\n", - " }\n", - "\n", - " function load_or_wait() {\n", - " // Implement a backoff loop that tries to ensure we do not load multiple\n", - " // versions of Bokeh and its dependencies at the same time.\n", - " // In recent versions we use the root._bokeh_is_initializing flag\n", - " // to determine whether there is an ongoing attempt to initialize\n", - " // bokeh, however for backward compatibility we also try to ensure\n", - " // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n", - " // before older versions are fully initialized.\n", - " if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n", - " // If the timeout and bokeh was not successfully loaded we reset\n", - " // everything and try loading again\n", - " root._bokeh_timeout = Date.now() + 5000;\n", - " root._bokeh_is_initializing = false;\n", - " root._bokeh_onload_callbacks = undefined;\n", - " root._bokeh_is_loading = 0\n", - " console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n", - " load_or_wait();\n", - " } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n", - " setTimeout(load_or_wait, 100);\n", - " } else {\n", - " root._bokeh_is_initializing = true\n", - " root._bokeh_onload_callbacks = []\n", - " const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n", - " if (!reloading && !bokeh_loaded) {\n", - " if (root.Bokeh) {\n", - " root.Bokeh = undefined;\n", - " }\n", - " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", - " }\n", - " load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n", - " console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", - " run_inline_js();\n", - " });\n", - " }\n", - " }\n", - " // Give older versions of the autoload script a head-start to ensure\n", - " // they initialize before we start loading newer version.\n", - " setTimeout(load_or_wait, 100)\n", - "}(window));" - ], - "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n const force = true;\n const py_version = '3.5.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n const reloading = false;\n const Bokeh = root.Bokeh;\n\n // Set a timeout for this load but only if we are not already initializing\n if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n // Don't load bokeh if it is still initializing\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n // There is nothing to load\n run_callbacks();\n return null;\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error(e) {\n const src_el = e.srcElement\n console.error(\"failed to load \" + (src_el.href || src_el.src));\n }\n\n const skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n const existing_stylesheets = []\n const links = document.getElementsByTagName('link')\n for (let i = 0; i < links.length; i++) {\n const link = links[i]\n if (link.href != null) {\n existing_stylesheets.push(link.href)\n }\n }\n for (let i = 0; i < css_urls.length; i++) {\n const url = css_urls[i];\n const escaped = encodeURI(url)\n if (existing_stylesheets.indexOf(escaped) !== -1) {\n on_load()\n continue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n const scripts = document.getElementsByTagName('script')\n for (let i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n existing_scripts.push(script.src)\n }\n }\n for (let i = 0; i < js_urls.length; i++) {\n const url = js_urls[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n const element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (let i = 0; i < js_modules.length; i++) {\n const url = js_modules[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n const url = js_exports[name];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n const js_urls = [\"https://cdn.holoviz.org/panel/1.5.3/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.5.2.min.js\", \"https://cdn.holoviz.org/panel/1.5.3/dist/panel.min.js\"];\n const js_modules = [];\n const js_exports = {};\n const css_urls = [];\n const inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (let i = 0; i < inline_js.length; i++) {\n try {\n inline_js[i].call(root, root.Bokeh);\n } catch(e) {\n if (!reloading) {\n throw e;\n }\n }\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n var NewBokeh = root.Bokeh;\n if (Bokeh.versions === undefined) {\n Bokeh.versions = new Map();\n }\n if (NewBokeh.version !== Bokeh.version) {\n Bokeh.versions.set(NewBokeh.version, NewBokeh)\n }\n root.Bokeh = Bokeh;\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n // If the timeout and bokeh was not successfully loaded we reset\n // everything and try loading again\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n root._bokeh_is_loading = 0\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n if (root.Bokeh) {\n root.Bokeh = undefined;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": [ - "\n", - "if ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n", - " window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n", - "}\n", - "\n", - "\n", - " function JupyterCommManager() {\n", - " }\n", - "\n", - " JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n", - " if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", - " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", - " comm_manager.register_target(comm_id, function(comm) {\n", - " comm.on_msg(msg_handler);\n", - " });\n", - " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", - " window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n", - " comm.onMsg = msg_handler;\n", - " });\n", - " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", - " google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n", - " var messages = comm.messages[Symbol.asyncIterator]();\n", - " function processIteratorResult(result) {\n", - " var message = result.value;\n", - " console.log(message)\n", - " var content = {data: message.data, comm_id};\n", - " var buffers = []\n", - " for (var buffer of message.buffers || []) {\n", - " buffers.push(new DataView(buffer))\n", - " }\n", - " var metadata = message.metadata || {};\n", - " var msg = {content, buffers, metadata}\n", - " msg_handler(msg);\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " return messages.next().then(processIteratorResult);\n", - " })\n", - " }\n", - " }\n", - "\n", - " JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n", - " if (comm_id in window.PyViz.comms) {\n", - " return window.PyViz.comms[comm_id];\n", - " } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", - " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", - " var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n", - " if (msg_handler) {\n", - " comm.on_msg(msg_handler);\n", - " }\n", - " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", - " var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n", - " comm.open();\n", - " if (msg_handler) {\n", - " comm.onMsg = msg_handler;\n", - " }\n", - " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", - " var comm_promise = google.colab.kernel.comms.open(comm_id)\n", - " comm_promise.then((comm) => {\n", - " window.PyViz.comms[comm_id] = comm;\n", - " if (msg_handler) {\n", - " var messages = comm.messages[Symbol.asyncIterator]();\n", - " function processIteratorResult(result) {\n", - " var message = result.value;\n", - " var content = {data: message.data};\n", - " var metadata = message.metadata || {comm_id};\n", - " var msg = {content, metadata}\n", - " msg_handler(msg);\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " }) \n", - " var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n", - " return comm_promise.then((comm) => {\n", - " comm.send(data, metadata, buffers, disposeOnDone);\n", - " });\n", - " };\n", - " var comm = {\n", - " send: sendClosure\n", - " };\n", - " }\n", - " window.PyViz.comms[comm_id] = comm;\n", - " return comm;\n", - " }\n", - " window.PyViz.comm_manager = new JupyterCommManager();\n", - " \n", - "\n", - "\n", - "var JS_MIME_TYPE = 'application/javascript';\n", - "var HTML_MIME_TYPE = 'text/html';\n", - "var EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\n", - "var CLASS_NAME = 'output';\n", - "\n", - "/**\n", - " * Render data to the DOM node\n", - " */\n", - "function render(props, node) {\n", - " var div = document.createElement(\"div\");\n", - " var script = document.createElement(\"script\");\n", - " node.appendChild(div);\n", - " node.appendChild(script);\n", - "}\n", - "\n", - "/**\n", - " * Handle when a new output is added\n", - " */\n", - "function handle_add_output(event, handle) {\n", - " var output_area = handle.output_area;\n", - " var output = handle.output;\n", - " if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", - " return\n", - " }\n", - " var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", - " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", - " if (id !== undefined) {\n", - " var nchildren = toinsert.length;\n", - " var html_node = toinsert[nchildren-1].children[0];\n", - " html_node.innerHTML = output.data[HTML_MIME_TYPE];\n", - " var scripts = [];\n", - " var nodelist = html_node.querySelectorAll(\"script\");\n", - " for (var i in nodelist) {\n", - " if (nodelist.hasOwnProperty(i)) {\n", - " scripts.push(nodelist[i])\n", - " }\n", - " }\n", - "\n", - " scripts.forEach( function (oldScript) {\n", - " var newScript = document.createElement(\"script\");\n", - " var attrs = [];\n", - " var nodemap = oldScript.attributes;\n", - " for (var j in nodemap) {\n", - " if (nodemap.hasOwnProperty(j)) {\n", - " attrs.push(nodemap[j])\n", - " }\n", - " }\n", - " attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n", - " newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n", - " oldScript.parentNode.replaceChild(newScript, oldScript);\n", - " });\n", - " if (JS_MIME_TYPE in output.data) {\n", - " toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n", - " }\n", - " output_area._hv_plot_id = id;\n", - " if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n", - " window.PyViz.plot_index[id] = Bokeh.index[id];\n", - " } else {\n", - " window.PyViz.plot_index[id] = null;\n", - " }\n", - " } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", - " var bk_div = document.createElement(\"div\");\n", - " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", - " var script_attrs = bk_div.children[0].attributes;\n", - " for (var i = 0; i < script_attrs.length; i++) {\n", - " toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n", - " }\n", - " // store reference to server id on output_area\n", - " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", - " }\n", - "}\n", - "\n", - "/**\n", - " * Handle when an output is cleared or removed\n", - " */\n", - "function handle_clear_output(event, handle) {\n", - " var id = handle.cell.output_area._hv_plot_id;\n", - " var server_id = handle.cell.output_area._bokeh_server_id;\n", - " if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n", - " var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n", - " if (server_id !== null) {\n", - " comm.send({event_type: 'server_delete', 'id': server_id});\n", - " return;\n", - " } else if (comm !== null) {\n", - " comm.send({event_type: 'delete', 'id': id});\n", - " }\n", - " delete PyViz.plot_index[id];\n", - " if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n", - " var doc = window.Bokeh.index[id].model.document\n", - " doc.clear();\n", - " const i = window.Bokeh.documents.indexOf(doc);\n", - " if (i > -1) {\n", - " window.Bokeh.documents.splice(i, 1);\n", - " }\n", - " }\n", - "}\n", - "\n", - "/**\n", - " * Handle kernel restart event\n", - " */\n", - "function handle_kernel_cleanup(event, handle) {\n", - " delete PyViz.comms[\"hv-extension-comm\"];\n", - " window.PyViz.plot_index = {}\n", - "}\n", - "\n", - "/**\n", - " * Handle update_display_data messages\n", - " */\n", - "function handle_update_output(event, handle) {\n", - " handle_clear_output(event, {cell: {output_area: handle.output_area}})\n", - " handle_add_output(event, handle)\n", - "}\n", - "\n", - "function register_renderer(events, OutputArea) {\n", - " function append_mime(data, metadata, element) {\n", - " // create a DOM node to render to\n", - " var toinsert = this.create_output_subarea(\n", - " metadata,\n", - " CLASS_NAME,\n", - " EXEC_MIME_TYPE\n", - " );\n", - " this.keyboard_manager.register_events(toinsert);\n", - " // Render to node\n", - " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", - " render(props, toinsert[0]);\n", - " element.append(toinsert);\n", - " return toinsert\n", - " }\n", - "\n", - " events.on('output_added.OutputArea', handle_add_output);\n", - " events.on('output_updated.OutputArea', handle_update_output);\n", - " events.on('clear_output.CodeCell', handle_clear_output);\n", - " events.on('delete.Cell', handle_clear_output);\n", - " events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n", - "\n", - " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", - " safe: true,\n", - " index: 0\n", - " });\n", - "}\n", - "\n", - "if (window.Jupyter !== undefined) {\n", - " try {\n", - " var events = require('base/js/events');\n", - " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", - " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", - " register_renderer(events, OutputArea);\n", - " }\n", - " } catch(err) {\n", - " }\n", - "}\n" - ], - "application/vnd.holoviews_load.v0+json": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.holoviews_exec.v0+json": "", - "text/html": [ - "
    \n", - "
    \n", - "
    \n", - "" - ] - }, - "metadata": { - "application/vnd.holoviews_exec.v0+json": { - "id": "a36e5bd5-4e61-4c34-869d-f46faf5de44b" - } - }, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/eplanteu/dev/pluto/pluto-tuto-11-format-donnees/data_types_env/lib/python3.11/site-packages/xarray/backends/api.py:652: RuntimeWarning: 'netcdf4' fails while guessing\n", - " engine = plugins.guess_engine(filename_or_obj)\n", - "/home/eplanteu/dev/pluto/pluto-tuto-11-format-donnees/data_types_env/lib/python3.11/site-packages/xarray/backends/api.py:652: RuntimeWarning: 'scipy' fails while guessing\n", - " engine = plugins.guess_engine(filename_or_obj)\n" - ] - }, - { - "data": { - "text/html": [ - "
    \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
    <xarray.Variable (time: 10, lat: 1000, lon: 1000)> Size: 80MB\n",
    -       "[10000000 values with dtype=float64]
    " - ], - "text/plain": [ - " Size: 80MB\n", - "[10000000 values with dtype=float64]" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "import hvplot.xarray\n", "import xarray as xr\n", @@ -2162,7 +194,9 @@ "\n", "da = xr.open_dataset(zarr_path)[\"data\"]\n", "da.variable" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2174,521 +208,16 @@ }, { "cell_type": "code", - "execution_count": 7, "id": "01c1c814-eb79-4ae5-8bbc-6871ead43224", "metadata": { "scrolled": true }, - "outputs": [ - { - "data": { - "text/html": [ - "
    \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
    <xarray.Variable (time: 10, lat: 1000, lon: 1000)> Size: 80MB\n",
    -       "array([[[0.57173056, 0.44281942, 0.16513337, ..., 0.80223243,\n",
    -       "         0.78291964, 0.08747034],\n",
    -       "        [0.31521199, 0.41597532, 0.49439683, ..., 0.35265298,\n",
    -       "         0.60145573, 0.3083475 ],\n",
    -       "        [0.20306074, 0.20359435, 0.33797216, ..., 0.26089714,\n",
    -       "         0.76296845, 0.6778943 ],\n",
    -       "        ...,\n",
    -       "        [0.25245384, 0.5276968 , 0.52644091, ..., 0.58426732,\n",
    -       "         0.09180941, 0.34140939],\n",
    -       "        [0.45087638, 0.46311388, 0.52009816, ..., 0.40293499,\n",
    -       "         0.26637495, 0.22535514],\n",
    -       "        [0.42322559, 0.72216987, 0.37084262, ..., 0.77784775,\n",
    -       "         0.12880648, 0.56547993]],\n",
    -       "\n",
    -       "       [[0.88587595, 0.43882129, 0.40775621, ..., 0.78691236,\n",
    -       "         0.84506516, 0.05957236],\n",
    -       "        [0.2105488 , 0.12635273, 0.69809241, ..., 0.92477286,\n",
    -       "         0.77313677, 0.17230435],\n",
    -       "        [0.94823774, 0.53079968, 0.79555541, ..., 0.47326325,\n",
    -       "         0.77537247, 0.14510511],\n",
    -       "...\n",
    -       "        [0.9682806 , 0.29507893, 0.75662358, ..., 0.46322352,\n",
    -       "         0.13547584, 0.9072647 ],\n",
    -       "        [0.62804832, 0.59621295, 0.11512536, ..., 0.31490865,\n",
    -       "         0.8390884 , 0.46678536],\n",
    -       "        [0.22960135, 0.85382707, 0.62060189, ..., 0.30999343,\n",
    -       "         0.1842668 , 0.28276561]],\n",
    -       "\n",
    -       "       [[0.92283423, 0.76045385, 0.82228549, ..., 0.98505589,\n",
    -       "         0.60402087, 0.89849785],\n",
    -       "        [0.17968167, 0.88254461, 0.3432763 , ..., 0.62870849,\n",
    -       "         0.66852378, 0.2862194 ],\n",
    -       "        [0.40432042, 0.70899042, 0.34822044, ..., 0.8682068 ,\n",
    -       "         0.13327541, 0.13511111],\n",
    -       "        ...,\n",
    -       "        [0.5277495 , 0.30094765, 0.51537951, ..., 0.38737032,\n",
    -       "         0.86513829, 0.44451509],\n",
    -       "        [0.35835956, 0.51757299, 0.22708403, ..., 0.50319819,\n",
    -       "         0.06690598, 0.2319543 ],\n",
    -       "        [0.91434051, 0.30306714, 0.28184485, ..., 0.12336382,\n",
    -       "         0.31688197, 0.56079195]]])
    " - ], - "text/plain": [ - " Size: 80MB\n", - "array([[[0.57173056, 0.44281942, 0.16513337, ..., 0.80223243,\n", - " 0.78291964, 0.08747034],\n", - " [0.31521199, 0.41597532, 0.49439683, ..., 0.35265298,\n", - " 0.60145573, 0.3083475 ],\n", - " [0.20306074, 0.20359435, 0.33797216, ..., 0.26089714,\n", - " 0.76296845, 0.6778943 ],\n", - " ...,\n", - " [0.25245384, 0.5276968 , 0.52644091, ..., 0.58426732,\n", - " 0.09180941, 0.34140939],\n", - " [0.45087638, 0.46311388, 0.52009816, ..., 0.40293499,\n", - " 0.26637495, 0.22535514],\n", - " [0.42322559, 0.72216987, 0.37084262, ..., 0.77784775,\n", - " 0.12880648, 0.56547993]],\n", - "\n", - " [[0.88587595, 0.43882129, 0.40775621, ..., 0.78691236,\n", - " 0.84506516, 0.05957236],\n", - " [0.2105488 , 0.12635273, 0.69809241, ..., 0.92477286,\n", - " 0.77313677, 0.17230435],\n", - " [0.94823774, 0.53079968, 0.79555541, ..., 0.47326325,\n", - " 0.77537247, 0.14510511],\n", - "...\n", - " [0.9682806 , 0.29507893, 0.75662358, ..., 0.46322352,\n", - " 0.13547584, 0.9072647 ],\n", - " [0.62804832, 0.59621295, 0.11512536, ..., 0.31490865,\n", - " 0.8390884 , 0.46678536],\n", - " [0.22960135, 0.85382707, 0.62060189, ..., 0.30999343,\n", - " 0.1842668 , 0.28276561]],\n", - "\n", - " [[0.92283423, 0.76045385, 0.82228549, ..., 0.98505589,\n", - " 0.60402087, 0.89849785],\n", - " [0.17968167, 0.88254461, 0.3432763 , ..., 0.62870849,\n", - " 0.66852378, 0.2862194 ],\n", - " [0.40432042, 0.70899042, 0.34822044, ..., 0.8682068 ,\n", - " 0.13327541, 0.13511111],\n", - " ...,\n", - " [0.5277495 , 0.30094765, 0.51537951, ..., 0.38737032,\n", - " 0.86513829, 0.44451509],\n", - " [0.35835956, 0.51757299, 0.22708403, ..., 0.50319819,\n", - " 0.06690598, 0.2319543 ],\n", - " [0.91434051, 0.30306714, 0.28184485, ..., 0.12336382,\n", - " 0.31688197, 0.56079195]]])" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "da.load()\n", "da.variable" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2700,54 +229,10 @@ }, { "cell_type": "code", - "execution_count": 8, "id": "a0030c03-f44e-4d5a-be66-c776189ee4c8", "metadata": { "scrolled": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Lazy loaded array:\n", - " Size: 80MB\n", - "dask.array\n", - "Coordinates:\n", - " * lat (lat) int64 8kB 0 1 2 3 4 5 6 7 ... 992 993 994 995 996 997 998 999\n", - " * lon (lon) int64 8kB 0 1 2 3 4 5 6 7 ... 992 993 994 995 996 997 998 999\n", - " * time (time) int64 80B 0 1 2 3 4 5 6 7 8 9 \n", - "\n", - "\n", - "Lazy computed array:\n", - " Size: 8MB\n", - "dask.array\n", - "Coordinates:\n", - " * lat (lat) int64 8kB 0 1 2 3 4 5 6 7 ... 992 993 994 995 996 997 998 999\n", - " * lon (lon) int64 8kB 0 1 2 3 4 5 6 7 ... 992 993 994 995 996 997 998 999 \n", - "\n", - "\n", - "Loaded and computed:\n", - " Size: 8MB\n", - "array([[5.75989822, 5.02703079, 3.19270113, ..., 6.09194011, 5.12143591,\n", - " 3.23814132],\n", - " [3.71971549, 6.71013608, 5.91276078, ..., 5.03312745, 5.78974382,\n", - " 4.90106614],\n", - " [5.47664988, 4.84102291, 5.12004484, ..., 4.81430401, 4.12448408,\n", - " 3.9516942 ],\n", - " ...,\n", - " [5.70272592, 4.47375299, 6.4134405 , ..., 4.46713774, 4.04691179,\n", - " 5.28627309],\n", - " [3.75683063, 5.1005176 , 4.58812091, ..., 3.73639658, 5.87220076,\n", - " 4.41103159],\n", - " [6.45588892, 5.45363484, 5.23654145, ..., 4.79626276, 3.95544593,\n", - " 2.77086433]])\n", - "Coordinates:\n", - " * lat (lat) int64 8kB 0 1 2 3 4 5 6 7 ... 992 993 994 995 996 997 998 999\n", - " * lon (lon) int64 8kB 0 1 2 3 4 5 6 7 ... 992 993 994 995 996 997 998 999\n" - ] - } - ], "source": [ "da = xr.open_dataset(zarr_path, chunks=\"auto\", engine=\"zarr\")[\"data\"]\n", "\n", @@ -2763,7 +248,9 @@ "result = mean_data.compute() # load in memory and compute\n", "print(\"Loaded and computed:\")\n", "print(result)" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", diff --git a/data_type/datacube_formats.ipynb b/data_type/datacube_formats.ipynb index 4b48213..b084387 100644 --- a/data_type/datacube_formats.ipynb +++ b/data_type/datacube_formats.ipynb @@ -15,7 +15,7 @@ "source": [ "# Datacube formats\n", "\n", - "A datacube is essentially a multi-dimensional array that enables the manipulation and analysis of complex datasets. In satellite imagery, datacubes are commonly used to create and work with time series data. For example, a datacube might contain a stack of *N* rasters, each with dimensions X × Y, where each raster represents the same spatial area at different dates. This structure allows for efficient comparison, temporal analysis, and trend detection over time. Datacubes can also handle other dimensions beyond time, such as spectral bands, enabling even more detailed analyses across wavelengths. They can store both raster and vector data. Visual example of a simple datacube:\n", + "A datacube is essentially a multidimensional array that enables the manipulation and analysis of complex datasets. In satellite imagery, datacubes are commonly used to create and work with time series data. For example, a datacube might contain a stack of *N* rasters, each with dimensions X × Y, where each raster represents the same spatial area at different dates. This structure allows for efficient comparison, temporal analysis, and trend detection over time. Datacubes can also handle other dimensions beyond time, such as spectral bands, enabling even more detailed analyses across wavelengths. They can store both raster and vector data. Visual example of a simple datacube:\n", "\n", "![datacube_schema.png](attachment:664ca6c2-36b1-4dcb-98ac-b1487a279105.png)\n", "\n", @@ -27,15 +27,39 @@ "\n", "1) [hdf5](#HDF5-format)\n", "2) [netcdf](#Netcdf)\n", - "3) [zarr](#Zarr)" + "3) [zarr](#Zarr)\n", + "\n", + "## Data used\n", + "\n", + "This notebook will use different data sources for the different format types. For all the formats, sample data is provided (automatically downloaded or randomly generated) for simplicity, but you can use any files you wish, links to data providers will be provided. You may need to adapt the notebook's code according to the new files. Some data providers will also require you to create an account\n", + "\n", + "- The HDF5 format example will re-use a raster generated in the [raster format tutorial](./raster_formats.ipynb). You can find multiple other sources of `.h5` files, for example, rainfall data from https://disc.gsfc.nasa.gov/\n", + "- The netcdf format uses sample data from [unidata](https://www.unidata.ucar.edu/software/netcdf/examples/files.html). You can also use SWOT data as netCDF files from [hydroweb next](https://hydroweb.next.theia-land.fr/)\n", + "- The sample zarr data will first be randomly generated, to create a local file. But zarr files are generally hosted on s3 buckets, like the [ERA5 public dataset](https://cloud.google.com/storage/docs/public-datasets/era5), which is used in a second part of the tutorial. Another example is the POWER (Prediction Of Worldwide Energy Resources) dataset from NASA (which can be accessed [like this](https://power.larc.nasa.gov/docs/tutorials/service-data-request/aws/))." ] }, { + "metadata": {}, "cell_type": "code", - "execution_count": 1, - "id": "2dbade8e-0cf5-47f8-a231-4b66358751fb", + "outputs": [], + "execution_count": null, + "source": [ + "from data_type.utils import download_sample_data\n", + "\n", + "# Run this if you haven't used to raster format tutorial\n", + "DOWNLOAD_DIRECTORY = \"./sample_data/rasters\"\n", + "raster_tiff = download_sample_data(DOWNLOAD_DIRECTORY)\n", + "\n", + "# Run this if the raster already exist or use a raster of your choice\n", + "REFERENCE_RASTER = \"./sample_data/rasters/data/xt_SENTINEL2B_20180621-111349-432_L2A_T30TWT_D_V1-8_RVBPIR.tif\"" + ], + "id": "eb90cf253d4ca4aa" + }, + { "metadata": {}, + "cell_type": "code", "outputs": [], + "execution_count": null, "source": [ "# Generic notebook imports\n", "\n", @@ -43,10 +67,9 @@ "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "from utils import download_netcdf, generate_hdf5_file, get_file_size_in_mb, rescale_raster\n", - "\n", - "REFERENCE_RASTER = \"./sample_data/rasters/data/xt_SENTINEL2B_20180621-111349-432_L2A_T30TWT_D_V1-8_RVBPIR.tif\"" - ] + "from utils import download_netcdf, generate_hdf5_file, get_file_size_in_mb, rescale_raster" + ], + "id": "2dbade8e-0cf5-47f8-a231-4b66358751fb" }, { "cell_type": "markdown", @@ -62,14 +85,14 @@ }, { "cell_type": "code", - "execution_count": 2, "id": "fbdaf48d-ef5b-423c-97ee-001a5d2a954c", "metadata": {}, - "outputs": [], "source": [ "hdf5_file = \"./sample_data/data_cube/example.h5\" # change this path if needed\n", "generate_hdf5_file(hdf5_file, REFERENCE_RASTER) # generate a dataset with random data" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -81,34 +104,8 @@ }, { "cell_type": "code", - "execution_count": 3, "id": "5e9f1850-3386-4a98-bd62-405178b71491", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "List of dataset(s) and group(s): ['data']\n", - "Data group's metadata: {'creation_date': '2024-11-25', 'project': 'Tutorial example project'}\n", - "List of datasets: ['data_2d', 'data_3d']\n", - "2d dataset's shape: (2080, 2410)\n", - "3d dataset's shape: (4, 2080, 2410)\n", - "3d dataset's metadata{'DIMENSION_LABELS': array(['time', 'latitude', 'longitude'], dtype=object), 'description': 'RGB bands from a raster'}\n", - "dataset's dimensions names['time', 'latitude', 'longitude']\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
    " - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "import h5py\n", "\n", @@ -138,23 +135,14 @@ " plt.imshow(rescaled_data, cmap=\"gray\")\n", " plt.title(f\"Raster's band n°{n_band+1}\")\n", " plt.show()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 4, "id": "93e0b458-5732-4b41-a3b6-afd50fdcf3d5", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Read time: 0.00162 seconds\n", - "File size: 100.26 MB\n" - ] - } - ], "source": [ "start = time.time()\n", "with h5py.File(hdf5_file, 'r') as f: # open the file\n", @@ -164,7 +152,9 @@ "\n", "print(f\"Read time: {read_time:.5f} seconds\")\n", "print(f\"File size: {get_file_size_in_mb(hdf5_file):.2f} MB\")" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -186,454 +176,17 @@ }, { "cell_type": "code", - "execution_count": 21, "id": "12738f41-5e02-48f8-8f3b-42a7ded481b6", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
    \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
    <xarray.Dataset> Size: 1GB\n",
    -       "Dimensions:  (lat: 360, lon: 720, time: 1356)\n",
    -       "Coordinates:\n",
    -       "  * lat      (lat) float32 1kB 89.75 89.25 88.75 88.25 ... -88.75 -89.25 -89.75\n",
    -       "  * lon      (lon) float32 3kB 0.25 0.75 1.25 1.75 ... 358.2 358.8 359.2 359.8\n",
    -       "  * time     (time) datetime64[ns] 11kB 1901-01-01 1901-02-01 ... 2013-12-01\n",
    -       "Data variables:\n",
    -       "    precip   (time, lat, lon) float32 1GB ...\n",
    -       "Attributes:\n",
    -       "    Original_Source:  http://www.dwd.de/en/FundE/Klima/KLIS/int/GPCC/GPCC.htm...\n",
    -       "    Reference:        Users of the data sets are kindly requested to give fee...\n",
    -       "    original_source:  ftp://ftp-anon.dwd.de/pub/data/gpcc/html/fulldata_downl...\n",
    -       "    Conventions:      CF 1.0\n",
    -       "    References:       http://www.esrl.noaa.gov/psd/data/gridded/data.gpcc.html\n",
    -       "    history:          Created 01/2016 based on V7 data obtained via ftp\n",
    -       "    title:            GPCC Full Data Reanalysis Version 7 0.5x0.5 Monthly Total\n",
    -       "    dataset_title:    Global Precipitation Climatology Centre (GPCC)
    " - ], - "text/plain": [ - " Size: 1GB\n", - "Dimensions: (lat: 360, lon: 720, time: 1356)\n", - "Coordinates:\n", - " * lat (lat) float32 1kB 89.75 89.25 88.75 88.25 ... -88.75 -89.25 -89.75\n", - " * lon (lon) float32 3kB 0.25 0.75 1.25 1.75 ... 358.2 358.8 359.2 359.8\n", - " * time (time) datetime64[ns] 11kB 1901-01-01 1901-02-01 ... 2013-12-01\n", - "Data variables:\n", - " precip (time, lat, lon) float32 1GB ...\n", - "Attributes:\n", - " Original_Source: http://www.dwd.de/en/FundE/Klima/KLIS/int/GPCC/GPCC.htm...\n", - " Reference: Users of the data sets are kindly requested to give fee...\n", - " original_source: ftp://ftp-anon.dwd.de/pub/data/gpcc/html/fulldata_downl...\n", - " Conventions: CF 1.0\n", - " References: http://www.esrl.noaa.gov/psd/data/gridded/data.gpcc.html\n", - " history: Created 01/2016 based on V7 data obtained via ftp\n", - " title: GPCC Full Data Reanalysis Version 7 0.5x0.5 Monthly Total\n", - " dataset_title: Global Precipitation Climatology Centre (GPCC)" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "import xarray as xr\n", "\n", "netcf_file = download_netcdf(\"./sample_data/data_cube/\")\n", "nc_dataset = xr.open_dataset(netcf_file, engine=\"netcdf4\")\n", "nc_dataset" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -645,25 +198,13 @@ }, { "cell_type": "code", - "execution_count": 6, "id": "cb7e452d-d897-44d4-8b80-f76e73c2e58a", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Data variables:\n", - " precip (time, lat, lon) float32 1GB ..." - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "nc_dataset.data_vars" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -675,449 +216,13 @@ }, { "cell_type": "code", - "execution_count": 7, "id": "61935296-7078-40c1-bf0f-ca8c047b3db2", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
    \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
    <xarray.DataArray 'precip' (time: 1356, lat: 360, lon: 720)> Size: 1GB\n",
    -       "[351475200 values with dtype=float32]\n",
    -       "Coordinates:\n",
    -       "  * lat      (lat) float32 1kB 89.75 89.25 88.75 88.25 ... -88.75 -89.25 -89.75\n",
    -       "  * lon      (lon) float32 3kB 0.25 0.75 1.25 1.75 ... 358.2 358.8 359.2 359.8\n",
    -       "  * time     (time) datetime64[ns] 11kB 1901-01-01 1901-02-01 ... 2013-12-01\n",
    -       "Attributes:\n",
    -       "    units:         mm\n",
    -       "    var_desc:      Precipitation\n",
    -       "    level_desc:    Surface\n",
    -       "    parent_stat:   Observations\n",
    -       "    long_name:     GPCC Monthly total of precipitation\n",
    -       "    valid_range:   [   0. 8000.]\n",
    -       "    actual_range:  [   0.   4530.85]\n",
    -       "    dataset:       GPCC Precipitation 0.5degree V7 Full Reanalysis\n",
    -       "    statistic:     Total\n",
    -       "    level:         Surface
    " - ], - "text/plain": [ - " Size: 1GB\n", - "[351475200 values with dtype=float32]\n", - "Coordinates:\n", - " * lat (lat) float32 1kB 89.75 89.25 88.75 88.25 ... -88.75 -89.25 -89.75\n", - " * lon (lon) float32 3kB 0.25 0.75 1.25 1.75 ... 358.2 358.8 359.2 359.8\n", - " * time (time) datetime64[ns] 11kB 1901-01-01 1901-02-01 ... 2013-12-01\n", - "Attributes:\n", - " units: mm\n", - " var_desc: Precipitation\n", - " level_desc: Surface\n", - " parent_stat: Observations\n", - " long_name: GPCC Monthly total of precipitation\n", - " valid_range: [ 0. 8000.]\n", - " actual_range: [ 0. 4530.85]\n", - " dataset: GPCC Precipitation 0.5degree V7 Full Reanalysis\n", - " statistic: Total\n", - " level: Surface" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "nc_dataset.precip" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1129,713 +234,8 @@ }, { "cell_type": "code", - "execution_count": 22, "id": "5901216e-29f8-48e0-b2fb-c596a1a54964", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": [ - "(function(root) {\n", - " function now() {\n", - " return new Date();\n", - " }\n", - "\n", - " const force = true;\n", - " const py_version = '3.5.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", - " const reloading = false;\n", - " const Bokeh = root.Bokeh;\n", - "\n", - " // Set a timeout for this load but only if we are not already initializing\n", - " if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n", - " root._bokeh_timeout = Date.now() + 5000;\n", - " root._bokeh_failed_load = false;\n", - " }\n", - "\n", - " function run_callbacks() {\n", - " try {\n", - " root._bokeh_onload_callbacks.forEach(function(callback) {\n", - " if (callback != null)\n", - " callback();\n", - " });\n", - " } finally {\n", - " delete root._bokeh_onload_callbacks;\n", - " }\n", - " console.debug(\"Bokeh: all callbacks have finished\");\n", - " }\n", - "\n", - " function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n", - " if (css_urls == null) css_urls = [];\n", - " if (js_urls == null) js_urls = [];\n", - " if (js_modules == null) js_modules = [];\n", - " if (js_exports == null) js_exports = {};\n", - "\n", - " root._bokeh_onload_callbacks.push(callback);\n", - "\n", - " if (root._bokeh_is_loading > 0) {\n", - " // Don't load bokeh if it is still initializing\n", - " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", - " return null;\n", - " } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", - " // There is nothing to load\n", - " run_callbacks();\n", - " return null;\n", - " }\n", - "\n", - " function on_load() {\n", - " root._bokeh_is_loading--;\n", - " if (root._bokeh_is_loading === 0) {\n", - " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", - " run_callbacks()\n", - " }\n", - " }\n", - " window._bokeh_on_load = on_load\n", - "\n", - " function on_error(e) {\n", - " const src_el = e.srcElement\n", - " console.error(\"failed to load \" + (src_el.href || src_el.src));\n", - " }\n", - "\n", - " const skip = [];\n", - " if (window.requirejs) {\n", - " window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n", - " root._bokeh_is_loading = css_urls.length + 0;\n", - " } else {\n", - " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", - " }\n", - "\n", - " const existing_stylesheets = []\n", - " const links = document.getElementsByTagName('link')\n", - " for (let i = 0; i < links.length; i++) {\n", - " const link = links[i]\n", - " if (link.href != null) {\n", - " existing_stylesheets.push(link.href)\n", - " }\n", - " }\n", - " for (let i = 0; i < css_urls.length; i++) {\n", - " const url = css_urls[i];\n", - " const escaped = encodeURI(url)\n", - " if (existing_stylesheets.indexOf(escaped) !== -1) {\n", - " on_load()\n", - " continue;\n", - " }\n", - " const element = document.createElement(\"link\");\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.rel = \"stylesheet\";\n", - " element.type = \"text/css\";\n", - " element.href = url;\n", - " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", - " document.body.appendChild(element);\n", - " } var existing_scripts = []\n", - " const scripts = document.getElementsByTagName('script')\n", - " for (let i = 0; i < scripts.length; i++) {\n", - " var script = scripts[i]\n", - " if (script.src != null) {\n", - " existing_scripts.push(script.src)\n", - " }\n", - " }\n", - " for (let i = 0; i < js_urls.length; i++) {\n", - " const url = js_urls[i];\n", - " const escaped = encodeURI(url)\n", - " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", - " if (!window.requirejs) {\n", - " on_load();\n", - " }\n", - " continue;\n", - " }\n", - " const element = document.createElement('script');\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.src = url;\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " document.head.appendChild(element);\n", - " }\n", - " for (let i = 0; i < js_modules.length; i++) {\n", - " const url = js_modules[i];\n", - " const escaped = encodeURI(url)\n", - " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", - " if (!window.requirejs) {\n", - " on_load();\n", - " }\n", - " continue;\n", - " }\n", - " var element = document.createElement('script');\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.src = url;\n", - " element.type = \"module\";\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " document.head.appendChild(element);\n", - " }\n", - " for (const name in js_exports) {\n", - " const url = js_exports[name];\n", - " const escaped = encodeURI(url)\n", - " if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n", - " if (!window.requirejs) {\n", - " on_load();\n", - " }\n", - " continue;\n", - " }\n", - " var element = document.createElement('script');\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.type = \"module\";\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " element.textContent = `\n", - " import ${name} from \"${url}\"\n", - " window.${name} = ${name}\n", - " window._bokeh_on_load()\n", - " `\n", - " document.head.appendChild(element);\n", - " }\n", - " if (!js_urls.length && !js_modules.length) {\n", - " on_load()\n", - " }\n", - " };\n", - "\n", - " function inject_raw_css(css) {\n", - " const element = document.createElement(\"style\");\n", - " element.appendChild(document.createTextNode(css));\n", - " document.body.appendChild(element);\n", - " }\n", - "\n", - " const js_urls = [\"https://cdn.holoviz.org/panel/1.5.3/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.5.2.min.js\", \"https://cdn.holoviz.org/panel/1.5.3/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.13.0/dist/geoviews.min.js\"];\n", - " const js_modules = [];\n", - " const js_exports = {};\n", - " const css_urls = [];\n", - " const inline_js = [ function(Bokeh) {\n", - " Bokeh.set_log_level(\"info\");\n", - " },\n", - "function(Bokeh) {} // ensure no trailing comma for IE\n", - " ];\n", - "\n", - " function run_inline_js() {\n", - " if ((root.Bokeh !== undefined) || (force === true)) {\n", - " for (let i = 0; i < inline_js.length; i++) {\n", - " try {\n", - " inline_js[i].call(root, root.Bokeh);\n", - " } catch(e) {\n", - " if (!reloading) {\n", - " throw e;\n", - " }\n", - " }\n", - " }\n", - " // Cache old bokeh versions\n", - " if (Bokeh != undefined && !reloading) {\n", - " var NewBokeh = root.Bokeh;\n", - " if (Bokeh.versions === undefined) {\n", - " Bokeh.versions = new Map();\n", - " }\n", - " if (NewBokeh.version !== Bokeh.version) {\n", - " Bokeh.versions.set(NewBokeh.version, NewBokeh)\n", - " }\n", - " root.Bokeh = Bokeh;\n", - " }\n", - " } else if (Date.now() < root._bokeh_timeout) {\n", - " setTimeout(run_inline_js, 100);\n", - " } else if (!root._bokeh_failed_load) {\n", - " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", - " root._bokeh_failed_load = true;\n", - " }\n", - " root._bokeh_is_initializing = false\n", - " }\n", - "\n", - " function load_or_wait() {\n", - " // Implement a backoff loop that tries to ensure we do not load multiple\n", - " // versions of Bokeh and its dependencies at the same time.\n", - " // In recent versions we use the root._bokeh_is_initializing flag\n", - " // to determine whether there is an ongoing attempt to initialize\n", - " // bokeh, however for backward compatibility we also try to ensure\n", - " // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n", - " // before older versions are fully initialized.\n", - " if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n", - " // If the timeout and bokeh was not successfully loaded we reset\n", - " // everything and try loading again\n", - " root._bokeh_timeout = Date.now() + 5000;\n", - " root._bokeh_is_initializing = false;\n", - " root._bokeh_onload_callbacks = undefined;\n", - " root._bokeh_is_loading = 0\n", - " console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n", - " load_or_wait();\n", - " } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n", - " setTimeout(load_or_wait, 100);\n", - " } else {\n", - " root._bokeh_is_initializing = true\n", - " root._bokeh_onload_callbacks = []\n", - " const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n", - " if (!reloading && !bokeh_loaded) {\n", - " if (root.Bokeh) {\n", - " root.Bokeh = undefined;\n", - " }\n", - " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", - " }\n", - " load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n", - " console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", - " run_inline_js();\n", - " });\n", - " }\n", - " }\n", - " // Give older versions of the autoload script a head-start to ensure\n", - " // they initialize before we start loading newer version.\n", - " setTimeout(load_or_wait, 100)\n", - "}(window));" - ], - "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n const force = true;\n const py_version = '3.5.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n const reloading = false;\n const Bokeh = root.Bokeh;\n\n // Set a timeout for this load but only if we are not already initializing\n if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n // Don't load bokeh if it is still initializing\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n // There is nothing to load\n run_callbacks();\n return null;\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error(e) {\n const src_el = e.srcElement\n console.error(\"failed to load \" + (src_el.href || src_el.src));\n }\n\n const skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n const existing_stylesheets = []\n const links = document.getElementsByTagName('link')\n for (let i = 0; i < links.length; i++) {\n const link = links[i]\n if (link.href != null) {\n existing_stylesheets.push(link.href)\n }\n }\n for (let i = 0; i < css_urls.length; i++) {\n const url = css_urls[i];\n const escaped = encodeURI(url)\n if (existing_stylesheets.indexOf(escaped) !== -1) {\n on_load()\n continue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n const scripts = document.getElementsByTagName('script')\n for (let i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n existing_scripts.push(script.src)\n }\n }\n for (let i = 0; i < js_urls.length; i++) {\n const url = js_urls[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n const element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (let i = 0; i < js_modules.length; i++) {\n const url = js_modules[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n const url = js_exports[name];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n const js_urls = [\"https://cdn.holoviz.org/panel/1.5.3/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.5.2.min.js\", \"https://cdn.holoviz.org/panel/1.5.3/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.13.0/dist/geoviews.min.js\"];\n const js_modules = [];\n const js_exports = {};\n const css_urls = [];\n const inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (let i = 0; i < inline_js.length; i++) {\n try {\n inline_js[i].call(root, root.Bokeh);\n } catch(e) {\n if (!reloading) {\n throw e;\n }\n }\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n var NewBokeh = root.Bokeh;\n if (Bokeh.versions === undefined) {\n Bokeh.versions = new Map();\n }\n if (NewBokeh.version !== Bokeh.version) {\n Bokeh.versions.set(NewBokeh.version, NewBokeh)\n }\n root.Bokeh = Bokeh;\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n // If the timeout and bokeh was not successfully loaded we reset\n // everything and try loading again\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n root._bokeh_is_loading = 0\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n if (root.Bokeh) {\n root.Bokeh = undefined;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": [ - "\n", - "if ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n", - " window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n", - "}\n", - "\n", - "\n", - " function JupyterCommManager() {\n", - " }\n", - "\n", - " JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n", - " if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", - " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", - " comm_manager.register_target(comm_id, function(comm) {\n", - " comm.on_msg(msg_handler);\n", - " });\n", - " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", - " window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n", - " comm.onMsg = msg_handler;\n", - " });\n", - " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", - " google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n", - " var messages = comm.messages[Symbol.asyncIterator]();\n", - " function processIteratorResult(result) {\n", - " var message = result.value;\n", - " console.log(message)\n", - " var content = {data: message.data, comm_id};\n", - " var buffers = []\n", - " for (var buffer of message.buffers || []) {\n", - " buffers.push(new DataView(buffer))\n", - " }\n", - " var metadata = message.metadata || {};\n", - " var msg = {content, buffers, metadata}\n", - " msg_handler(msg);\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " return messages.next().then(processIteratorResult);\n", - " })\n", - " }\n", - " }\n", - "\n", - " JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n", - " if (comm_id in window.PyViz.comms) {\n", - " return window.PyViz.comms[comm_id];\n", - " } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", - " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", - " var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n", - " if (msg_handler) {\n", - " comm.on_msg(msg_handler);\n", - " }\n", - " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", - " var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n", - " comm.open();\n", - " if (msg_handler) {\n", - " comm.onMsg = msg_handler;\n", - " }\n", - " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", - " var comm_promise = google.colab.kernel.comms.open(comm_id)\n", - " comm_promise.then((comm) => {\n", - " window.PyViz.comms[comm_id] = comm;\n", - " if (msg_handler) {\n", - " var messages = comm.messages[Symbol.asyncIterator]();\n", - " function processIteratorResult(result) {\n", - " var message = result.value;\n", - " var content = {data: message.data};\n", - " var metadata = message.metadata || {comm_id};\n", - " var msg = {content, metadata}\n", - " msg_handler(msg);\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " }) \n", - " var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n", - " return comm_promise.then((comm) => {\n", - " comm.send(data, metadata, buffers, disposeOnDone);\n", - " });\n", - " };\n", - " var comm = {\n", - " send: sendClosure\n", - " };\n", - " }\n", - " window.PyViz.comms[comm_id] = comm;\n", - " return comm;\n", - " }\n", - " window.PyViz.comm_manager = new JupyterCommManager();\n", - " \n", - "\n", - "\n", - "var JS_MIME_TYPE = 'application/javascript';\n", - "var HTML_MIME_TYPE = 'text/html';\n", - "var EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\n", - "var CLASS_NAME = 'output';\n", - "\n", - "/**\n", - " * Render data to the DOM node\n", - " */\n", - "function render(props, node) {\n", - " var div = document.createElement(\"div\");\n", - " var script = document.createElement(\"script\");\n", - " node.appendChild(div);\n", - " node.appendChild(script);\n", - "}\n", - "\n", - "/**\n", - " * Handle when a new output is added\n", - " */\n", - "function handle_add_output(event, handle) {\n", - " var output_area = handle.output_area;\n", - " var output = handle.output;\n", - " if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", - " return\n", - " }\n", - " var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", - " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", - " if (id !== undefined) {\n", - " var nchildren = toinsert.length;\n", - " var html_node = toinsert[nchildren-1].children[0];\n", - " html_node.innerHTML = output.data[HTML_MIME_TYPE];\n", - " var scripts = [];\n", - " var nodelist = html_node.querySelectorAll(\"script\");\n", - " for (var i in nodelist) {\n", - " if (nodelist.hasOwnProperty(i)) {\n", - " scripts.push(nodelist[i])\n", - " }\n", - " }\n", - "\n", - " scripts.forEach( function (oldScript) {\n", - " var newScript = document.createElement(\"script\");\n", - " var attrs = [];\n", - " var nodemap = oldScript.attributes;\n", - " for (var j in nodemap) {\n", - " if (nodemap.hasOwnProperty(j)) {\n", - " attrs.push(nodemap[j])\n", - " }\n", - " }\n", - " attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n", - " newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n", - " oldScript.parentNode.replaceChild(newScript, oldScript);\n", - " });\n", - " if (JS_MIME_TYPE in output.data) {\n", - " toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n", - " }\n", - " output_area._hv_plot_id = id;\n", - " if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n", - " window.PyViz.plot_index[id] = Bokeh.index[id];\n", - " } else {\n", - " window.PyViz.plot_index[id] = null;\n", - " }\n", - " } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", - " var bk_div = document.createElement(\"div\");\n", - " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", - " var script_attrs = bk_div.children[0].attributes;\n", - " for (var i = 0; i < script_attrs.length; i++) {\n", - " toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n", - " }\n", - " // store reference to server id on output_area\n", - " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", - " }\n", - "}\n", - "\n", - "/**\n", - " * Handle when an output is cleared or removed\n", - " */\n", - "function handle_clear_output(event, handle) {\n", - " var id = handle.cell.output_area._hv_plot_id;\n", - " var server_id = handle.cell.output_area._bokeh_server_id;\n", - " if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n", - " var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n", - " if (server_id !== null) {\n", - " comm.send({event_type: 'server_delete', 'id': server_id});\n", - " return;\n", - " } else if (comm !== null) {\n", - " comm.send({event_type: 'delete', 'id': id});\n", - " }\n", - " delete PyViz.plot_index[id];\n", - " if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n", - " var doc = window.Bokeh.index[id].model.document\n", - " doc.clear();\n", - " const i = window.Bokeh.documents.indexOf(doc);\n", - " if (i > -1) {\n", - " window.Bokeh.documents.splice(i, 1);\n", - " }\n", - " }\n", - "}\n", - "\n", - "/**\n", - " * Handle kernel restart event\n", - " */\n", - "function handle_kernel_cleanup(event, handle) {\n", - " delete PyViz.comms[\"hv-extension-comm\"];\n", - " window.PyViz.plot_index = {}\n", - "}\n", - "\n", - "/**\n", - " * Handle update_display_data messages\n", - " */\n", - "function handle_update_output(event, handle) {\n", - " handle_clear_output(event, {cell: {output_area: handle.output_area}})\n", - " handle_add_output(event, handle)\n", - "}\n", - "\n", - "function register_renderer(events, OutputArea) {\n", - " function append_mime(data, metadata, element) {\n", - " // create a DOM node to render to\n", - " var toinsert = this.create_output_subarea(\n", - " metadata,\n", - " CLASS_NAME,\n", - " EXEC_MIME_TYPE\n", - " );\n", - " this.keyboard_manager.register_events(toinsert);\n", - " // Render to node\n", - " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", - " render(props, toinsert[0]);\n", - " element.append(toinsert);\n", - " return toinsert\n", - " }\n", - "\n", - " events.on('output_added.OutputArea', handle_add_output);\n", - " events.on('output_updated.OutputArea', handle_update_output);\n", - " events.on('clear_output.CodeCell', handle_clear_output);\n", - " events.on('delete.Cell', handle_clear_output);\n", - " events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n", - "\n", - " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", - " safe: true,\n", - " index: 0\n", - " });\n", - "}\n", - "\n", - "if (window.Jupyter !== undefined) {\n", - " try {\n", - " var events = require('base/js/events');\n", - " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", - " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", - " register_renderer(events, OutputArea);\n", - " }\n", - " } catch(err) {\n", - " }\n", - "}\n" - ], - "application/vnd.holoviews_load.v0+json": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.holoviews_exec.v0+json": "", - "text/html": [ - "
    \n", - "
    \n", - "
    \n", - "" - ] - }, - "metadata": { - "application/vnd.holoviews_exec.v0+json": { - "id": "e306c5b6-3398-4e92-aaf5-79bf65e4e556" - } - }, - "output_type": "display_data" - }, - { - "data": {}, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.holoviews_exec.v0+json": "", - "text/html": [ - "
    \n", - "
    \n", - "
    \n", - "" - ], - "text/plain": [ - ":Image [lon,lat] (GPCC Monthly total of precipitation)" - ] - }, - "execution_count": 22, - "metadata": { - "application/vnd.holoviews_exec.v0+json": { - "id": "71277d10-1f60-4cd8-b996-820e60d7ba97" - } - }, - "output_type": "execute_result" - } - ], "source": [ "import hvplot.xarray\n", "import cartopy.crs as ccrs\n", @@ -1853,7 +253,9 @@ "image.opts(tools=['pan', 'wheel_zoom', 'hover'], show_grid=True) # additional parameters for the plot\n", "\n", "image" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1865,110 +267,8 @@ }, { "cell_type": "code", - "execution_count": 9, "id": "97acd29d-ff84-4d69-a99d-a10a8416e56e", "metadata": {}, - "outputs": [ - { - "data": {}, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": {}, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.holoviews_exec.v0+json": "", - "text/html": [ - "
    \n", - "
    \n", - "
    \n", - "" - ], - "text/plain": [ - "Column\n", - " [0] ParamFunction(function, _pane=HoloViews, defer_load=False)\n", - " [1] Player(end=1355, interval=100, loop_policy='loop', name='time')" - ] - }, - "execution_count": 9, - "metadata": { - "application/vnd.holoviews_exec.v0+json": { - "id": "dfe1653b-e2a2-41fb-badd-c24b80f51565" - } - }, - "output_type": "execute_result" - } - ], "source": [ "import panel as pn\n", "\n", @@ -1987,7 +287,9 @@ " )\n", "\n", "pn.Column(update_image, time_slider).servable()" - ] + ], + "outputs": [], + "execution_count": null }, { "attachments": { @@ -2024,18 +326,8 @@ }, { "cell_type": "code", - "execution_count": 10, "id": "200c6f8a-e2d9-4ebc-b4ca-5f029ff97553", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(10, 1000, 1000)\n" - ] - } - ], "source": [ "import numpy as np\n", "import zarr\n", @@ -2051,7 +343,9 @@ "z1 = zarr.load(sample_file)\n", "data = z1[\"data\"]\n", "print(data.shape)" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2063,41 +357,15 @@ }, { "cell_type": "code", - "execution_count": 11, "id": "5a40f0b4-556d-4db9-a5de-9ce8584a94ee", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
    Name/data
    Typezarr.core.Array
    Data typefloat64
    Shape(10, 1000, 1000)
    Chunk shape(2, 250, 250)
    OrderC
    Read-onlyTrue
    CompressorBlosc(cname='lz4', clevel=5, shuffle=SHUFFLE, blocksize=0)
    Store typezarr.storage.DirectoryStore
    No. bytes80000000 (76.3M)
    No. bytes stored70046241 (66.8M)
    Storage ratio1.1
    Chunks initialized80/80
    " - ], - "text/plain": [ - "Name : /data\n", - "Type : zarr.core.Array\n", - "Data type : float64\n", - "Shape : (10, 1000, 1000)\n", - "Chunk shape : (2, 250, 250)\n", - "Order : C\n", - "Read-only : True\n", - "Compressor : Blosc(cname='lz4', clevel=5, shuffle=SHUFFLE, blocksize=0)\n", - "Store type : zarr.storage.DirectoryStore\n", - "No. bytes : 80000000 (76.3M)\n", - "No. bytes stored : 70046241 (66.8M)\n", - "Storage ratio : 1.1\n", - "Chunks initialized : 80/80" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "zarr_file = zarr.open(sample_file, mode='r')\n", "data = zarr_file[\"data\"]\n", "data.info" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2109,43 +377,17 @@ }, { "cell_type": "code", - "execution_count": 12, "id": "6d3602b9-48c7-48de-ba54-180277ea56fd", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
    Name/data
    Typezarr.core.Array
    Data typefloat64
    Shape(10, 1000, 1000)
    Chunk shape(1, 1000, 1000)
    OrderC
    Read-onlyFalse
    CompressorBlosc(cname='lz4', clevel=5, shuffle=SHUFFLE, blocksize=0)
    Store typezarr.storage.DirectoryStore
    No. bytes80000000 (76.3M)
    No. bytes stored70068763 (66.8M)
    Storage ratio1.1
    Chunks initialized10/10
    " - ], - "text/plain": [ - "Name : /data\n", - "Type : zarr.core.Array\n", - "Data type : float64\n", - "Shape : (10, 1000, 1000)\n", - "Chunk shape : (1, 1000, 1000)\n", - "Order : C\n", - "Read-only : False\n", - "Compressor : Blosc(cname='lz4', clevel=5, shuffle=SHUFFLE, blocksize=0)\n", - "Store type : zarr.storage.DirectoryStore\n", - "No. bytes : 80000000 (76.3M)\n", - "No. bytes stored : 70068763 (66.8M)\n", - "Storage ratio : 1.1\n", - "Chunks initialized : 10/10" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "sample_file = \"./sample_data/data_cube/example2.zarr\"\n", "zarr_file = zarr.open(sample_file, mode='w')\n", "zarr_file.create_dataset(\"data\", data=data, chunks=(1, n_lat, n_lon))\n", "data = zarr_file[\"data\"]\n", "data.info" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2167,511 +409,8 @@ }, { "cell_type": "code", - "execution_count": 13, "id": "5a91f3ae-d609-4472-8f48-2784e2858446", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
    \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
    <xarray.Dataset> Size: 80MB\n",
    -       "Dimensions:  (time: 10, lat: 1000, lon: 1000)\n",
    -       "Coordinates:\n",
    -       "  * lat      (lat) int64 8kB 0 1 2 3 4 5 6 7 ... 992 993 994 995 996 997 998 999\n",
    -       "  * lon      (lon) int64 8kB 0 1 2 3 4 5 6 7 ... 992 993 994 995 996 997 998 999\n",
    -       "  * time     (time) int64 80B 0 1 2 3 4 5 6 7 8 9\n",
    -       "Data variables:\n",
    -       "    data     (time, lat, lon) float64 80MB dask.array<chunksize=(2, 250, 250), meta=np.ndarray>
    " - ], - "text/plain": [ - " Size: 80MB\n", - "Dimensions: (time: 10, lat: 1000, lon: 1000)\n", - "Coordinates:\n", - " * lat (lat) int64 8kB 0 1 2 3 4 5 6 7 ... 992 993 994 995 996 997 998 999\n", - " * lon (lon) int64 8kB 0 1 2 3 4 5 6 7 ... 992 993 994 995 996 997 998 999\n", - " * time (time) int64 80B 0 1 2 3 4 5 6 7 8 9\n", - "Data variables:\n", - " data (time, lat, lon) float64 80MB dask.array" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "import xarray as xr\n", "import numpy as np\n", @@ -2689,7 +428,9 @@ "\n", "ds = xr.open_zarr(sample_file)\n", "ds" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2701,36 +442,8 @@ }, { "cell_type": "code", - "execution_count": 14, "id": "9900959f-8859-4c49-a6f6-74027ba59d8e", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
    Name/band_data
    Typezarr.core.Array
    Data typefloat32
    Shape(4, 2080, 2410)
    Chunk shape(1, 520, 603)
    OrderC
    Read-onlyTrue
    CompressorBlosc(cname='lz4', clevel=5, shuffle=SHUFFLE, blocksize=0)
    Store typezarr.storage.DirectoryStore
    No. bytes80204800 (76.5M)
    No. bytes stored35688486 (34.0M)
    Storage ratio2.2
    Chunks initialized64/64
    " - ], - "text/plain": [ - "Name : /band_data\n", - "Type : zarr.core.Array\n", - "Data type : float32\n", - "Shape : (4, 2080, 2410)\n", - "Chunk shape : (1, 520, 603)\n", - "Order : C\n", - "Read-only : True\n", - "Compressor : Blosc(cname='lz4', clevel=5, shuffle=SHUFFLE, blocksize=0)\n", - "Store type : zarr.storage.DirectoryStore\n", - "No. bytes : 80204800 (76.5M)\n", - "No. bytes stored : 35688486 (34.0M)\n", - "Storage ratio : 2.2\n", - "Chunks initialized : 64/64" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "input_cog_path = \"./sample_data/rasters/data/xt_SENTINEL2B_20180621-111349-432_L2A_T30TWT_D_V1-8_RVBPIR_cog.tif\"\n", "output_zarr_path = \"./sample_data/data_cube/example_from_cog.zarr\"\n", @@ -2741,7 +454,9 @@ "zarr_file = zarr.open(output_zarr_path, mode='r')\n", "data = zarr_file[\"band_data\"]\n", "data.info" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2756,3438 +471,8 @@ }, { "cell_type": "code", - "execution_count": 15, "id": "72a8f0ff-c188-4ff4-851f-ee77521c7a10", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
    \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
    <xarray.Dataset> Size: 31TB\n",
    -       "Dimensions:              (time: 374016, values: 542080)\n",
    -       "Coordinates:\n",
    -       "    depthBelowLandLayer  float64 8B ...\n",
    -       "    entireAtmosphere     float64 8B ...\n",
    -       "    latitude             (values) float64 4MB dask.array<chunksize=(542080,), meta=np.ndarray>\n",
    -       "    longitude            (values) float64 4MB dask.array<chunksize=(542080,), meta=np.ndarray>\n",
    -       "    number               int64 8B ...\n",
    -       "    step                 timedelta64[ns] 8B ...\n",
    -       "    surface              float64 8B ...\n",
    -       "  * time                 (time) datetime64[ns] 3MB 1979-01-01 ... 2021-08-31T...\n",
    -       "    valid_time           (time) datetime64[ns] 3MB dask.array<chunksize=(48,), meta=np.ndarray>\n",
    -       "Dimensions without coordinates: values\n",
    -       "Data variables: (12/38)\n",
    -       "    cape                 (time, values) float32 811GB dask.array<chunksize=(48, 542080), meta=np.ndarray>\n",
    -       "    d2m                  (time, values) float32 811GB dask.array<chunksize=(48, 542080), meta=np.ndarray>\n",
    -       "    hcc                  (time, values) float32 811GB dask.array<chunksize=(48, 542080), meta=np.ndarray>\n",
    -       "    istl1                (time, values) float32 811GB dask.array<chunksize=(48, 542080), meta=np.ndarray>\n",
    -       "    istl2                (time, values) float32 811GB dask.array<chunksize=(48, 542080), meta=np.ndarray>\n",
    -       "    istl3                (time, values) float32 811GB dask.array<chunksize=(48, 542080), meta=np.ndarray>\n",
    -       "    ...                   ...\n",
    -       "    tsn                  (time, values) float32 811GB dask.array<chunksize=(48, 542080), meta=np.ndarray>\n",
    -       "    u10                  (time, values) float32 811GB dask.array<chunksize=(48, 542080), meta=np.ndarray>\n",
    -       "    u100                 (time, values) float32 811GB dask.array<chunksize=(48, 542080), meta=np.ndarray>\n",
    -       "    v10                  (time, values) float32 811GB dask.array<chunksize=(48, 542080), meta=np.ndarray>\n",
    -       "    v100                 (time, values) float32 811GB dask.array<chunksize=(48, 542080), meta=np.ndarray>\n",
    -       "    z                    (time, values) float32 811GB dask.array<chunksize=(48, 542080), meta=np.ndarray>\n",
    -       "Attributes:\n",
    -       "    Conventions:               CF-1.7\n",
    -       "    GRIB_centre:               ecmf\n",
    -       "    GRIB_centreDescription:    European Centre for Medium-Range Weather Forec...\n",
    -       "    GRIB_edition:              1\n",
    -       "    GRIB_subCentre:            0\n",
    -       "    history:                   2022-09-23T18:56 GRIB to CDM+CF via cfgrib-0.9...\n",
    -       "    institution:               European Centre for Medium-Range Weather Forec...\n",
    -       "    pangeo-forge:inputs_hash:  5f4378143e9f42402424280b63472752da3aa79179b53b...\n",
    -       "    pangeo-forge:recipe_hash:  0c3415923e347ce9dac9dc5c6d209525f4d45d799bd25b...\n",
    -       "    pangeo-forge:version:      0.9.1
    " - ], - "text/plain": [ - " Size: 31TB\n", - "Dimensions: (time: 374016, values: 542080)\n", - "Coordinates:\n", - " depthBelowLandLayer float64 8B ...\n", - " entireAtmosphere float64 8B ...\n", - " latitude (values) float64 4MB dask.array\n", - " longitude (values) float64 4MB dask.array\n", - " number int64 8B ...\n", - " step timedelta64[ns] 8B ...\n", - " surface float64 8B ...\n", - " * time (time) datetime64[ns] 3MB 1979-01-01 ... 2021-08-31T...\n", - " valid_time (time) datetime64[ns] 3MB dask.array\n", - "Dimensions without coordinates: values\n", - "Data variables: (12/38)\n", - " cape (time, values) float32 811GB dask.array\n", - " d2m (time, values) float32 811GB dask.array\n", - " hcc (time, values) float32 811GB dask.array\n", - " istl1 (time, values) float32 811GB dask.array\n", - " istl2 (time, values) float32 811GB dask.array\n", - " istl3 (time, values) float32 811GB dask.array\n", - " ... ...\n", - " tsn (time, values) float32 811GB dask.array\n", - " u10 (time, values) float32 811GB dask.array\n", - " u100 (time, values) float32 811GB dask.array\n", - " v10 (time, values) float32 811GB dask.array\n", - " v100 (time, values) float32 811GB dask.array\n", - " z (time, values) float32 811GB dask.array\n", - "Attributes:\n", - " Conventions: CF-1.7\n", - " GRIB_centre: ecmf\n", - " GRIB_centreDescription: European Centre for Medium-Range Weather Forec...\n", - " GRIB_edition: 1\n", - " GRIB_subCentre: 0\n", - " history: 2022-09-23T18:56 GRIB to CDM+CF via cfgrib-0.9...\n", - " institution: European Centre for Medium-Range Weather Forec...\n", - " pangeo-forge:inputs_hash: 5f4378143e9f42402424280b63472752da3aa79179b53b...\n", - " pangeo-forge:recipe_hash: 0c3415923e347ce9dac9dc5c6d209525f4d45d799bd25b...\n", - " pangeo-forge:version: 0.9.1" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "import xarray as xr\n", "\n", @@ -6197,25 +482,19 @@ " consolidated=True,\n", ")\n", "ds" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 16, "id": "8d35e07d-9865-4dee-a040-64e7ea3ed873", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "dataset size: 28.0TiB\n" - ] - } - ], "source": [ "print(f\"dataset size: {ds.nbytes/(1024 ** 4):.1f}TiB\")" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -6241,35 +520,16 @@ }, { "cell_type": "code", - "execution_count": 17, "id": "1f4055fc-03f5-4a9d-bb91-eddb0f94a20a", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Write times:\n", - "\th5: 0.481 seconds\n", - "\tnc: 0.509 seconds\n", - "\tzarr: 0.728 seconds\n", - "Read times:\n", - "\th5: 0.330 seconds\n", - "\tnc: 0.004 seconds\n", - "\tzarr: 1.081 seconds\n", - "File sizes:\n", - "\th5: 800.002 MB\n", - "\tnc: 800.008 MB\n", - "\tzarr: 701.546 MB\n" - ] - } - ], "source": [ "from utils import compare_datacube_formats\n", "\n", "comparison_directory = \"./sample_data/data_cube/formats_comparison\"\n", "compare_datacube_formats(comparison_directory, (100, 1000, 1000))" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", diff --git a/data_type/point_clouds.ipynb b/data_type/point_clouds.ipynb index d0431a4..b7290db 100644 --- a/data_type/point_clouds.ipynb +++ b/data_type/point_clouds.ipynb @@ -9,6 +9,9 @@ "\n", "Point clouds are a specific type of file: they contain a set of points, located in a 3d space (sometimes with more optional arguments). They are very popular to store LiDAR data and can be used to produce digital elevation models (DEMs). For this, we will be using the `laspy` python library. Optionally, you can also download [cloud compare](https://www.danielgm.net/cc/) to visualize point clouds. Similarly to the [raster formats tutorial](./raster_formats.ipynb), we will start by presenting classic `.las` files and then their cloud-optimized versions (COPC: Cloud Optimized Point Cloud).\n", "\n", + "## Data used\n", + "This notebook will use a `laspy` example file to showcase how to read and visualize them. You can also download las/laz files from [the usgs](https://apps.nationalmap.gov/downloader/#/) for example. For COPC files, examples from the officiel [COPC documentation](https://copc.io/) are used.\n", + "\n", "## Basic usage of .las files\n", "\n", "First let's import the required libraries" diff --git a/data_type/raster_formats.ipynb b/data_type/raster_formats.ipynb index 41c4d83..21fdb5b 100644 --- a/data_type/raster_formats.ipynb +++ b/data_type/raster_formats.ipynb @@ -9,15 +9,22 @@ "\n", "This section presents the 3 most common file formats for geospatial rasters: JPEG2000, GeoTIFF and COG. The COG format (Cloud Optimized GeoTIFF, http://cogeo.org/) is actually a geotiff format, organized in a way to optimize its usage on cloud infrastructures. For example, it allows the streaming of only the required part of the image, instead of reading it in its entirety.\n", "\n", + "## Data used\n", + "\n", + "In this tutorial we will be using a cropped sentinel-2 image of the city of Vannes, France, automatically downloaded in the `sample_data` directory. Make sure you have an available internet connexion, or use other rasters on your local machine. You can also download full S2 products on [geodes](https://geodes-portal.cnes.fr/) or [copernicus](https://browser.dataspace.copernicus.eu/) (or from the [USGS](https://earthexplorer.usgs.gov/) for Landsat data).\n", + "\n", "First, we import all the required libraries." ] }, { "cell_type": "code", - "execution_count": 1, "id": "4fe30afe-0572-4168-81c1-8c50cac8fd35", - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-04T10:42:56.189142Z", + "start_time": "2025-02-04T10:42:54.348552Z" + } + }, "source": [ "import time\n", "from pathlib import Path\n", @@ -29,7 +36,9 @@ "\n", "import rioxarray\n", "import numpy as np" - ] + ], + "outputs": [], + "execution_count": 1 }, { "cell_type": "markdown", @@ -38,24 +47,18 @@ "source": [ "## GeoTIFF\n", "\n", - "In order to highlight the main differences between these formats, let's start by downloading a Sentinel-2 image in GeoTIFF format, using the `download_sample_data` function. These data are not real Sentinel-2 data, we will only use RGB + Near Infrared data, centered on the city of Vannes in France for our tutorial. Other Sentinel-2 data can be downloaded from https://theia.cnes.fr. We then read the image using `rasterio` and measure the time required to read it, as well as the file size:" + "In order to highlight the main differences between these formats, let's start by downloading a Sentinel-2 image in GeoTIFF format, using the `download_sample_data` function. These data are not real Sentinel-2 data, we will only use RGB + Near Infrared data, centered on the city of Vannes in France for our tutorial. We then read the image using `rasterio` and measure the time required to read it, as well as the file size:" ] }, { "cell_type": "code", - "execution_count": 2, "id": "c501598a-e670-4a1c-96a5-4b4498e3570f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Read time: 0.11 seconds\n", - "File size: 80.2 MB\n" - ] + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-04T10:42:56.360610Z", + "start_time": "2025-02-04T10:42:56.196159Z" } - ], + }, "source": [ "DOWNLOAD_DIRECTORY = \"./sample_data/rasters\" # change this directory if needed\n", "raster_tiff = download_sample_data(DOWNLOAD_DIRECTORY) # this may take some time to download\n", @@ -70,7 +73,18 @@ "print(f\"File size: {tiff_size*1e-6:.1f} MB\")\n", "\n", "# show_raster(raster_tiff) # un-comment this line to plot the raster" - ] + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Read time: 0.11 seconds\n", + "File size: 80.2 MB\n" + ] + } + ], + "execution_count": 2 }, { "cell_type": "markdown", @@ -84,19 +98,13 @@ }, { "cell_type": "code", - "execution_count": 3, "id": "bd534bf6-358d-4597-96b5-f519600f85b3", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Read time: 0.18 seconds\n", - "File size: 10.0 MB\n" - ] + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-04T10:42:57.384579Z", + "start_time": "2025-02-04T10:42:56.451586Z" } - ], + }, "source": [ "raster_jpeg = raster_tiff.with_suffix(\".jp2\")\n", "\n", @@ -121,7 +129,18 @@ "print(f\"Read time: {end - start:.2f} seconds\")\n", "size_jpeg = Path(raster_jpeg).stat().st_size\n", "print(f\"File size: {size_jpeg*1e-6:.1f} MB\")" - ] + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Read time: 0.20 seconds\n", + "File size: 10.0 MB\n" + ] + } + ], + "execution_count": 3 }, { "cell_type": "markdown", @@ -133,19 +152,13 @@ }, { "cell_type": "code", - "execution_count": 4, "id": "a723698b-ce43-4dd9-99ce-4056bb7ffa06", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Read time: 0.14 seconds\n", - "File size: 38.5 MB\n" - ] + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-04T10:42:59.109919Z", + "start_time": "2025-02-04T10:42:57.396406Z" } - ], + }, "source": [ "image_tif_zstd = raster_tiff.with_stem(raster_tiff.stem + \"_compressed\")\n", "Path(image_tif_zstd).unlink(missing_ok=True)\n", @@ -164,7 +177,18 @@ "print(f\"Read time: {end - start:.2f} seconds\")\n", "size_tif_zstd = Path(image_tif_zstd).stat().st_size\n", "print(f\"File size: {size_tif_zstd*1e-6:.1f} MB\")" - ] + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Read time: 0.19 seconds\n", + "File size: 38.5 MB\n" + ] + } + ], + "execution_count": 4 }, { "cell_type": "markdown", @@ -182,19 +206,13 @@ }, { "cell_type": "code", - "execution_count": 5, "id": "9a558b71-b910-4424-ba14-77a4ce97b73c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Read time: 0.09 seconds\n", - "File size: 45.0 MB\n" - ] + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-04T10:43:01.602290Z", + "start_time": "2025-02-04T10:42:59.119600Z" } - ], + }, "source": [ "image_cog = raster_tiff.with_stem(raster_tiff.stem + \"_cog\")\n", "Path(image_tif_zstd).unlink(missing_ok=True)\n", @@ -226,7 +244,18 @@ "print(f\"Read time: {full_res_time:.2f} seconds\")\n", "size_cog = Path(image_cog).stat().st_size\n", "print(f\"File size: {size_cog*1e-6:.1f} MB\")" - ] + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Read time: 0.08 seconds\n", + "File size: 45.0 MB\n" + ] + } + ], + "execution_count": 5 }, { "cell_type": "markdown", @@ -238,9 +267,37 @@ }, { "cell_type": "code", - "execution_count": 6, "id": "f23bc95d-c43f-4baa-992c-d055c9f6629d", - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-04T10:43:01.783270Z", + "start_time": "2025-02-04T10:43:01.609178Z" + } + }, + "source": [ + "with rasterio.open(image_cog) as src:\n", + " print(f\"Original image size: {src.width} x {src.height}\\n\")\n", + "\n", + " # liste of overviews (for the first band)\n", + " overview_levels = src.overviews(1)\n", + "\n", + " # Iterate over the overviews\n", + " for n_overview, overview_factor in enumerate(overview_levels, start=1):\n", + " overview_width = src.width // overview_factor\n", + " overview_height = src.height // overview_factor\n", + " pixel_size = int(src.res[0] * overview_factor)\n", + " print(f\"Overview {n_overview} of size {overview_width} x {overview_height} => pixel size: {pixel_size} meters\")\n", + " start_time = time.time()\n", + " overview_data = src.read(1, out_shape=(src.height // src.overviews(1)[n_overview - 1], # read the data from the overview\n", + " src.width // src.overviews(1)[n_overview - 1]))\n", + " overview_time = time.time() - start_time\n", + " print(f\"Load time {overview_factor}: {overview_time:.4f} seconds\\n\")\n", + "\n", + " # plot the last overview to compare the quality of the image\n", + " plt.imshow(overview_data, cmap=\"gray\")\n", + " plt.title(f\"Overview using {pixel_size} meters pixels\")\n", + " plt.show()" + ], "outputs": [ { "name": "stdout", @@ -249,54 +306,31 @@ "Original image size: 2410 x 2080\n", "\n", "Overview 1 of size 1205 x 1040 => pixel size: 20 meters\n", - "Load time 2: 0.0243 seconds\n", + "Load time 2: 0.0261 seconds\n", "\n", "Overview 2 of size 602 x 520 => pixel size: 40 meters\n", - "Load time 4: 0.0070 seconds\n", + "Load time 4: 0.0149 seconds\n", "\n", "Overview 3 of size 301 x 260 => pixel size: 80 meters\n", - "Load time 8: 0.0035 seconds\n", + "Load time 8: 0.0047 seconds\n", "\n", "Overview 4 of size 150 x 130 => pixel size: 160 meters\n", - "Load time 16: 0.0009 seconds\n", + "Load time 16: 0.0016 seconds\n", "\n" ] }, { "data": { - "image/png": "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", "text/plain": [ "
    " - ] + ], + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "source": [ - "with rasterio.open(image_cog) as src:\n", - " print(f\"Original image size: {src.width} x {src.height}\\n\")\n", - "\n", - " # liste of overviews (for the first band)\n", - " overview_levels = src.overviews(1)\n", - "\n", - " # Iterate over the overviews\n", - " for n_overview, overview_factor in enumerate(overview_levels, start=1):\n", - " overview_width = src.width // overview_factor\n", - " overview_height = src.height // overview_factor\n", - " pixel_size = int(src.res[0] * overview_factor)\n", - " print(f\"Overview {n_overview} of size {overview_width} x {overview_height} => pixel size: {pixel_size} meters\")\n", - " start_time = time.time()\n", - " overview_data = src.read(1, out_shape=(src.height // src.overviews(1)[n_overview - 1], # read the data from the overview\n", - " src.width // src.overviews(1)[n_overview - 1]))\n", - " overview_time = time.time() - start_time\n", - " print(f\"Load time {overview_factor}: {overview_time:.4f} seconds\\n\")\n", - "\n", - " # plot the last overview to compare the quality of the image\n", - " plt.imshow(overview_data, cmap=\"gray\")\n", - " plt.title(f\"Overview using {pixel_size} meters pixels\")\n", - " plt.show()" - ] + "execution_count": 6 }, { "cell_type": "markdown", diff --git a/data_type/vector_data_formats.ipynb b/data_type/vector_data_formats.ipynb index c23efdf..9d44199 100644 --- a/data_type/vector_data_formats.ipynb +++ b/data_type/vector_data_formats.ipynb @@ -13,7 +13,11 @@ "\n", "For even better performance, FlatGeobuf was developed, based on [FlatBuffers](https://flatbuffers.dev/). Unlike GeoPackage, it allows for advanced and optimized operations like data streaming; however, it is more recent and not yet as widely supported. Finally, optimized for cloud computing, GeoParquet was created, implementing features particularly useful for cloud applications. Like FlatGeobuf, it requires modern infrastructures and software.\n", "\n", - "As an example, we will be using a land use shapefile, available here: https://www.data.gouv.fr/fr/datasets/carte-des-departements-2-1/#/resources/d823cf85-5f6d-4767-a9fe-25a50a266a04. This will allow us to benchmark and compare the different formats performances (reading and writing time, as well as file sizes). To this end, we will use `geopandas`, a library based on `pandas`. `pyarraow` is also required to use parquet files with `geopandas`." + "This notebook showcases how to use `gepandas` to read and write vector files. This allows us to measure the different reading and writing times, for each format type. `pyarraow` is also required to use parquet files with `geopandas`.\n", + "\n", + "## Data used\n", + "\n", + "As an example, we will be using a land use shapefile, available here: https://www.data.gouv.fr/fr/datasets/carte-des-departements-2-1/#/resources/d823cf85-5f6d-4767-a9fe-25a50a266a04." ] }, {