From 205b566d7fba8d5bd9fcbc1ad120344911bce943 Mon Sep 17 00:00:00 2001 From: DangoMelon Date: Fri, 14 Jun 2024 01:19:54 -0500 Subject: [PATCH 1/4] Add example notebook of enso nonlinearity index computation with rookie/intake-esgf --- notebooks/rooki_enso_nonlinear.ipynb | 518 +++++++++++++++++++++++++++ 1 file changed, 518 insertions(+) create mode 100644 notebooks/rooki_enso_nonlinear.ipynb diff --git a/notebooks/rooki_enso_nonlinear.ipynb b/notebooks/rooki_enso_nonlinear.ipynb new file mode 100644 index 0000000..7856d43 --- /dev/null +++ b/notebooks/rooki_enso_nonlinear.ipynb @@ -0,0 +1,518 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "931a4b84-bb67-44e4-aa91-30f3d8bcc529", + "metadata": { + "tags": [] + }, + "source": [ + "# Compute Demo: Use Rooki to access CMIP6 data" + ] + }, + { + "cell_type": "markdown", + "id": "81f6c01b-1e08-463d-90d5-b9e7be5a61ac", + "metadata": { + "tags": [] + }, + "source": [ + "## Overview\n", + "\n", + "Here we use intake-esfg with Rookie to subset and regrid CMIP6 data\n", + "\n", + "**ROOK**: **R**emote **O**perations **O**n **K**limadaten\n", + "\n", + "* Rook: https://github.com/roocs/rook\n", + "* Rooki: https://github.com/roocs/rooki\n", + "* Clisops: https://github.com/roocs/clisops\n", + "* Rook Presentation: https://github.com/cehbrecht/talk-rook-status-kickoff-meeting-2022/blob/main/Rook_C3S2_380_2022-02-11.pdf" + ] + }, + { + "cell_type": "markdown", + "id": "31d3693d-4e01-4982-b1d0-dffcd2a13157", + "metadata": { + "tags": [] + }, + "source": [ + "## Prerequisites\n", + "\n", + "| Concepts | Importance | Notes |\n", + "| --- | --- | --- |\n", + "| [Intro to Xarray](https://foundations.projectpythia.org/core/xarray/xarray-intro.html) | Necessary | |\n", + "| [Understanding of NetCDF](https://foundations.projectpythia.org/core/data-formats/netcdf-cf.html) | Helpful | Familiarity with metadata structure |\n", + "| [Knowing OGC services](https://ogcapi.ogc.org/processes/) | Helpful | Understanding of the service interfaces |\n", + "\n", + "\n", + "- **Time to learn**: 15 minutes" + ] + }, + { + "cell_type": "markdown", + "id": "288086a4", + "metadata": {}, + "source": [ + "## Init Rooki" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "a2339b90", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import os\n", + "\n", + "os.environ[\"ROOK_URL\"] = \"http://rook.dkrz.de/wps\"\n", + "\n", + "from rooki import rooki\n", + "import xarray as xr" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "0e9a82d3-aef2-4826-91e3-b3a6338a2157", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from intake_esgf import ESGFCatalog\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f4cd53c1-e327-4cff-a845-d2a90c137c6e", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Perform a search() to populate the catalog.\n" + ] + } + ], + "source": [ + "cat = ESGFCatalog()\n", + "print(cat) # <-- nothing to see here yet" + ] + }, + { + "cell_type": "markdown", + "id": "d6ed87c2", + "metadata": {}, + "source": [ + "## Retrieve subset of CMIP6 data\n", + "\n", + "The CMIP6 dataset is identified by a dataset-id. An intake catalog as available to lookup the available datasets:\n", + "\n", + "https://nbviewer.org/github/roocs/rooki/blob/master/notebooks/demo/demo-intake-catalog.ipynb" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "65dee489-24d3-437d-a864-6eb1dabe8c99", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def keep_ds_id(ds):\n", + " return ds[0].split(\"|\")[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "66b3b3c0-6aa0-465b-bc17-86ae2ce5f25b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "dd675893f78745e6a357beecca8d4b26", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " Searching indices: 0%| |0/2 [ ?index/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Summary information for 11 results:\n", + "experiment_id [historical]\n", + "mip_era [CMIP6, nan]\n", + "activity_drs [CMIP]\n", + "datetime_stop [nan, 2014-12-16T12:00:00Z, 2014-12-15T12:00:00Z]\n", + "table_id [Omon]\n", + "grid_label [gn]\n", + "datetime_start [1848-10-25T13:00:00Z, 1850-01-16T12:00:00Z, 1...\n", + "source_id [FGOALS-g3, CAMS-CSM1-0, EC-Earth3-Veg, CMCC-C...\n", + "member_id [r1i1p1f1, r1i1p1f2]\n", + "variable_id [tos]\n", + "institution_id [CAS, CAMS, EC-Earth-Consortium, CMCC, CNRM-CE...\n", + "project [CMIP6]\n", + "dtype: object\n" + ] + } + ], + "source": [ + "cat.search(\n", + " experiment_id=[\"historical\"],\n", + " variable_id=[\"tos\"],\n", + " table_id=[\"Omon\"],\n", + " project=[\"CMIP6\"],\n", + " grid_label=[\"gn\"],\n", + " source_id=[\n", + " \"CAMS-CSM1-0\",\n", + " \"FGOALS-g3\",\n", + " \"CMCC-CM2-SR5\",\n", + " \"CNRM-CM6-1\",\n", + " \"CNRM-ESM2-1\",\n", + " \"EC-Earth3-Veg\",\n", + " \"CESM2\",\n", + " ],\n", + ")\n", + "cat.remove_ensembles()\n", + "print(cat)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "46726e56-030d-4e54-a1a4-5e2f2ca11b43", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['CMIP6.CMIP.CAS.FGOALS-g3.historical.r1i1p1f1.Omon.tos.gn.v20191107',\n", + " 'CMIP6.CMIP.CAMS.CAMS-CSM1-0.historical.r1i1p1f1.Omon.tos.gn.v20190708',\n", + " 'CMIP6.CMIP.EC-Earth-Consortium.EC-Earth3-Veg.historical.r1i1p1f1.Omon.tos.gn.v20211207',\n", + " 'CMIP6.CMIP.CMCC.CMCC-CM2-SR5.historical.r1i1p1f1.Omon.tos.gn.v20200616',\n", + " 'CMIP6.CMIP.CNRM-CERFACS.CNRM-ESM2-1.historical.r1i1p1f2.Omon.tos.gn.v20181206',\n", + " 'CMIP6.CMIP.CNRM-CERFACS.CNRM-CM6-1.historical.r1i1p1f2.Omon.tos.gn.v20180917',\n", + " 'CMIP6.CMIP.NCAR.CESM2.historical.r1i1p1f1.Omon.tos.gn.v20190308',\n", + " 'CMIP6.CMIP.CAS.FGOALS-g3.historical.r1i1p1f1.Omon.tos.gn.v20191107',\n", + " 'CMIP6.CMIP.CMCC.CMCC-CM2-SR5.historical.r1i1p1f1.Omon.tos.gn.v20200616',\n", + " 'CMIP6.CMIP.CNRM-CERFACS.CNRM-CM6-1.historical.r1i1p1f2.Omon.tos.gn.v20180917',\n", + " 'CMIP6.CMIP.EC-Earth-Consortium.EC-Earth3-Veg.historical.r1i1p1f1.Omon.tos.gn.v20211207']" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "collections = cat.df.id.apply(keep_ds_id).to_list()\n", + "collections" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d3192d1b-e738-4b54-bb0b-40b0af93037c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from rooki import operators as ops" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "188dc7b7-5486-41a7-9c76-5eaea85183a2", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def get_pacific_ocean(dataset_id):\n", + " wf = ops.Regrid(\n", + " ops.Subset(\n", + " ops.Input(\"tos\", [dataset_id]),\n", + " time=\"1900-01-01/2000-01-31\",\n", + " area=\"100,-20,280,20\",\n", + " ),\n", + " method=\"nearest_s2d\",\n", + " grid=\"2pt5deg\",\n", + " )\n", + " resp = wf.orchestrate()\n", + " if resp.ok:\n", + " print(f\"{resp.size_in_mb=}\")\n", + " ds = resp.datasets()[0]\n", + " else:\n", + " ds = xr.Dataset()\n", + " return ds" + ] + }, + { + "cell_type": "markdown", + "id": "f822b3c8", + "metadata": {}, + "source": [ + "### Open Dataset with xarray" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "eacbecbd", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "resp.size_in_mb=47.618300437927246\n", + "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_eeycmnvc/tos_Omon_FGOALS-g3_historical_r1i1p1f1_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n", + "resp.size_in_mb=47.61820125579834\n", + "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_o3534mko/tos_Omon_CAMS-CSM1-0_historical_r1i1p1f1_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n", + "resp.size_in_mb=47.622283935546875\n", + "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_o3979ci5/tos_Omon_CMCC-CM2-SR5_historical_r1i1p1f1_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n", + "resp.size_in_mb=47.6201171875\n", + "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_88m3g_jj/tos_Omon_CNRM-ESM2-1_historical_r1i1p1f2_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n", + "resp.size_in_mb=47.621718406677246\n", + "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_ikcleyfz/tos_Omon_CNRM-CM6-1_historical_r1i1p1f2_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n", + "resp.size_in_mb=47.61574363708496\n", + "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_kxuizmv6/tos_Omon_CESM2_historical_r1i1p1f1_gr_19000115-20000115_regrid-nearest_s2d-72x144_cells_grid.nc.\n", + "resp.size_in_mb=47.61813259124756\n", + "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_9xf8m5hh/tos_Omon_FGOALS-g3_historical_r1i1p1f1_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n", + "resp.size_in_mb=47.622283935546875\n", + "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_f6f13xzj/tos_Omon_CMCC-CM2-SR5_historical_r1i1p1f1_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n", + "resp.size_in_mb=47.621886253356934\n", + "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_s7cmttjd/tos_Omon_CNRM-CM6-1_historical_r1i1p1f2_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n" + ] + } + ], + "source": [ + "sst_data = {dset: get_pacific_ocean(dset) for dset in collections}" + ] + }, + { + "cell_type": "markdown", + "id": "46301d38", + "metadata": {}, + "source": [ + "### Plot CMIP6 Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "1ce6fe94-b836-4f7b-b808-6a78e87657f6", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import xeofs as xe\n", + "import numpy.polynomial.polynomial as poly\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "f43be532-c565-45e7-84d8-21be6e4e351e", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def compute_alpha(pc1, pc2):\n", + " coefs = poly.polyfit(pc1, pc2, deg=2)\n", + " xfit = np.arange(pc1.min(), pc1.max() + 0.1, 0.1)\n", + " fit = poly.polyval(xfit, coefs)\n", + " return coefs[-1], xfit, fit\n", + "\n", + "\n", + "def correction_factor(model):\n", + " _eofs = model.components()\n", + " _subset = dict(lat=slice(-5, 5), lon=slice(140, 180))\n", + " corr_factor = np.zeros(2)\n", + " corr_factor[0] = 1 if _eofs.sel(mode=1, **_subset).mean() > 0 else -1\n", + " corr_factor[1] = 1 if _eofs.sel(mode=2, **_subset).mean() > 0 else -1\n", + " return xr.DataArray(corr_factor, coords=[(\"mode\", [1, 2])])\n", + "\n", + "\n", + "def compute_index(ds):\n", + " tos = ds.tos.sel(lat=slice(-20, 20), lon=slice(100, 280))\n", + " tos_anom = tos.groupby(\"time.month\").apply(lambda x: x - x.mean(\"time\"))\n", + "\n", + " # Compute Eofs\n", + " model = xe.models.EOF(n_modes=2, use_coslat=True)\n", + " model.fit(tos_anom, dim=\"time\")\n", + " corr_factor = correction_factor(model)\n", + " # eofs = s_model.components()\n", + " scale_factor = model.singular_values() / np.sqrt(model.explained_variance())\n", + " pcs = (\n", + " model.scores().convert_calendar(\"standard\", align_on=\"date\")\n", + " * scale_factor\n", + " * corr_factor\n", + " )\n", + "\n", + " pc1 = pcs.sel(mode=1)\n", + " pc1 = pc1.sel(time=pc1.time.dt.month.isin([12, 1, 2]))\n", + " pc1 = pc1.resample(time=\"QS-DEC\").mean().dropna(\"time\")\n", + "\n", + " pc2 = pcs.sel(mode=2)\n", + " pc2 = pc2.sel(time=pc2.time.dt.month.isin([12, 1, 2]))\n", + " pc2 = pc2.resample(time=\"QS-DEC\").mean().dropna(\"time\")\n", + "\n", + " alpha, xfit, fit = compute_alpha(pc1, pc2)\n", + "\n", + " # Do a 45degree rotation\n", + " # eindex = (pcs.sel(mode=1) - pcs.sel(mode=2))/(2**(1/2))\n", + " # cindex = (pcs.sel(mode=1) + pcs.sel(mode=2))/(2**(1/2))\n", + "\n", + " return pc1, pc2, alpha, xfit, fit" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "140ee71c-01ad-4df5-a4af-d3f7f28c622a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "alpha_fits = {}\n", + "for key, item in sst_data.items():\n", + " if len(item.variables) == 0:\n", + " continue\n", + " alpha_fits[key] = compute_index(item)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "6b327ec5-f261-4ae8-9ee8-19fff28b62dc", + "metadata": { + "tags": [], + "trusted": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAArYAAAPvCAYAAAA29Y1nAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1iUV/YH8O/QBARBRRCkCfaCvQKiUiyAVI2JGjuWGM3upmj2t6vJumpiYpqJ2LO2GB2GDgqCYO+IxoZUu4JK7zP39wdhQmcGZnhnhvN5Hh5l5i3nHeDMnfveey6PMcZACCGEEEKIklPjOgBCCCGEEEJkgRq2hBBCCCFEJVDDlhBCCCGEqARq2BJCCCGEEJVADVtCCCGEEKISqGFLCCGEEEJUAjVsCSGEEEKISqCGLSGEEEIIUQnUsCWEEEIIISqBGrakzfz666/g8XgNfn388cfi7crKyvDzzz/DyckJXbt2haamJrp27YqJEydi586dKCgoqHfs169fY926dRgwYAB0dXXRqVMnjB07Fj///DMqKioajSksLAw8Hg9du3ZFWVlZg9tYW1vDw8OjyWtjjOHo0aNwdHSEsbExtLW1YW5ujilTpmDPnj0SvkKSuXnzJtzd3WFpaQkdHR106dIF48aNw6FDh2R6HkJI27p16xYWLlyInj17QltbG3p6ehg+fDi+/vprvHnzpt72w4cPB4/HwzfffNPg8Wrm3ISEhHrPM8bQq1cv8Hg8TJw4sdZzNXNqx44dYWBggH79+mHevHm4deuWxNeUnp6OVatWoU+fPtDR0YGuri4GDhyI//u//8PTp09rxSJpDq2+pgULFjR4zi+//FK8TWZmpvjxO3fuYOXKlRg3bhw6duzY6OvSnFOnTmHcuHHQ1dWFkZERFixYgFevXkl9HCIf1LAlbW7//v24ePFira/Vq1cDALKzszF+/Hj8/e9/R9++fbFr1y7Ex8dj7969sLOzw6effoqVK1fWOt79+/cxbNgw7Ny5E3PmzEFkZCSOHj2K4cOHY82aNXB1dUVxcXGDsezduxcA8ObNG4SEhLT4mtatW4d3330X/fv3x549exAdHY2NGzfCxMQEoaGhLT5uQ3Jzc2FhYYFNmzYhKioKBw4cgLW1NebNm4eNGzfK9FyEkLaxe/dujBgxAlevXsUnn3yCEydOIDg4GDNnzkRgYCAWL15ca/ubN28iKSkJwF95rDH6+voNbpOYmIi0tDTo6+vXerywsBBjx47Fr7/+iiVLliAsLAyHDx9GQEAAMjIycPPmTYmuKSIiAnZ2doiIiEBAQAAiIiLE/w8PD6/VYSBtDtXX18fx48frdXQwxvDrr7+iU6dO9fa5du0aQkJC0KVLFzg7O0t0DXUlJiZi2rRp4rh++OEHnDp1Cs7Ozo12jpA2xghpI/v372cA2NWrVxvdxs3NjWlqarLExMQGn8/JyWEHDx4Uf19ZWckGDBjADAwM2IMHD+ptf/ToUQaALVu2rN5zz58/ZxoaGmzy5MlMW1ububq6NnhOKysr5u7u3mjMxcXFrEOHDuz9999v8HmhUNjovrI0ZswYZmFh0SbnIoTIzoULF5i6ujqbOnUqKy0trfd8WVkZCw0NrfXYBx98wAAwd3d3BoCdP3++3n7VOXfJkiVMR0eH5eXl1Xp+7ty5bNy4cWzgwIHMyclJ/Pi+ffsYABYfH99gvJLktPT0dNaxY0c2bNgwlpubW+95kUjEgoKCGGPS51AAbO7cuUxHR4ft2rWr1nOnTp1iANjSpUsZAJaRkdHgcY4fP84AsNOnTzd7LTWNGjWKDRgwgFVUVIgfO3/+PAPAfvnlF6mOReSDemyJwrh69SpiYmIQEBCACRMmNLhN165dMXfuXPH3wcHBuHv3LtauXYs+ffrU2/6dd96Bm5sb9u7dixcvXtR67n//+x8qKyvxt7/9Db6+voiLi0NWVpbUcRcVFaGsrAympqYNPq+mJtmfWW5uLhYvXowuXbpAT08P7u7uSE9PB4/Hw4YNG5rd38jICBoaGtKETghRAJs2bQKPx8OuXbvQoUOHes9raWlhxowZ4u9LS0tx5MgRjBgxAt999x0AYN++fY0e/9133wUA/Pbbb+LH8vLyEBQUhEWLFtXb/vXr1wDQqpy2bds2FBUV4ZdffoGBgUG953k8Hnx9fQG0LIcaGBjAx8en3nXv27cP9vb2Db4fSJqLG/P06VNcvXoV8+bNq5Vrx48fjz59+iA4OLhVxyeyQQ1b0uaEQiEqKytrfQFAbGwsANRK4M2p3sfb27vRbby9vVFZWVlvLNW+fftgamqKadOmYdGiRRCJRPj111+luhagqkHZq1cv/PLLL9i2bRvu378PxphUxxCJRPD09MSRI0fw2WefITg4GGPGjMHUqVOb3KeyshLZ2dn45ZdfcPLkSXz22WdSx08I4Y5QKER8fDxGjBgBCwsLifYRCAR4+/YtFi1ahN69e8PBwQG///47CgsLG9y+U6dO8Pf3r9UI/O2336CmpoZ33nmn3vbjxo0DALz//vsICQkRN3SlERMTAxMTE4wdO7bZbVuaQxcvXoxLly7h3r17AKo6BwQCQb1hG7Lyxx9/AADs7OzqPWdnZyd+nnCLGrakzY0dOxaampq1viorK/H48WMAgJWVVa3tGWO1GsFCoVD83KNHjwAAPXv2bPR81c9VbwsAZ8+eRUpKCubPnw91dXVMnjwZPXv2xP79+6VulALAkSNH0LlzZ/zjH/9A//79YWBgAE9PTxw8eFCi4504cQLnzp3Dd999h88++wyurq7497//3WBvSrWVK1dCU1MTxsbG+Nvf/oYff/wRy5Ytkzp2Qgh3cnJyUFxc3GQOq2vv3r3Q1tbGe++9B6CqgVdYWIhjx441us+iRYtw5coV3LlzB0DVB/uZM2fWG18LAPb29vjyyy+RnJwMHx8fGBkZwcbGBitWrJB44tijR4+kuqaW5NBJkyahZ8+e4gb7kSNHoKGhgZkzZ0p8XmlUN/C7dOlS77kuXbq06AMAkT1q2JI2d+DAAVy9erXWV1O30ENDQ2s1ghu6rdWU6qTI4/HEj1VPpKhuOFbPsM3KykJcXJy0l4RRo0YhNTUVJ06cwOeff45x48YhLi4O77//PmbMmCGOoW5vtUgkAlA1IQEAZs2aVeu41bcQG/L555/j6tWriIyMxKJFi7Bq1apGZ0cTQlRDRkYGTp8+DV9fXxgaGgKAuIHa1HAEJycn2NraYt++fbh9+zauXr3a5Afnf/3rX3j06BH27duHZcuWQU9PD4GBgRgxYkStIQ117761pGMAkDyH1lSdtw8ePIjKykrs3bsXs2bNgp6eXotiqNZYnq553oY09jhpW9SwJW2uf//+GDlyZK0vALC0tASAeuNcJ06cKG4A1y27Vb1PRkZGo+erLvdSfZuvoKAAx48fx+jRo9GtWzfk5uYiNzcXPj4+4PF4zc4wboympiamTJmC//73vzh58iQeP36MiRMnIiIiAtHR0QAAZ2fnWo306jeW169fQ0NDo15PgImJSaPns7S0xMiRIzF9+nTs2LEDAQEBWLduHbKzs1sUPyGk7RkZGUFXV7fJHFbTvn37wBiDv7+/OHdVVFRgxowZOH/+PO7fv9/gfjweDwsXLsShQ4cQGBiIPn36wNHRsclzmZiYYOHChQgMDMStW7eQmJgILS0trFmzBkBVbq179636Q7qlpaXE11RNkhxa18KFC5GdnY1Nmzbhxo0bMhmG0Fie7tq1KwA02DP75s2bBntySdujhi1RGK6urgCqasvWZGhoKG4AVyeWuvs0VaorJCQEGhoa4jqNv/32G4qLi3HlyhV07txZ/GVnZwfGGIKDg/H27dtWX0/Xrl3x0UcfAfhrbNbOnTtr9VRXTwrr2rUrKisr69WqrDvhrSmjR49GZWUl0tPTWx07IaRtqKurw9nZGdevX8eTJ0+a3LbmPABfX99a+evw4cMAmp5EtmDBAuTk5CAwMBALFy6UOtYJEybAzc0N2dnZePXqFczMzOrdfRsxYgQAYMqUKXj58iUuXbok9XmqNZRD67KwsICLiwu++OIL9O3bF+PHj2/x+ao1lqcHDRoEALh9+3a9fW7fvi1+nnCLGrZEYYwcORJubm7YvXs3zp49K9E+Pj4+GDBgALZs2YKUlJR6z//++++IiYnBkiVL0L17dwBVwxD09fURFxeH06dP1/raunUrysrKxG8SkqioqGh0bFX1pAYzMzMAQN++fWv1VFtbWwOouk1YHW9NR48elTiO06dPQ01NDTY2NhLvQwjh3rp168AYw9KlS1FeXl7v+YqKCoSHh+PkyZN48uQJPvjgg3q56/Tp0xg4cCAOHDggnpBbV48ePfDJJ5/A09MT8+fPbzSely9f1rv9DlTdon/48CF0dXVhaGgILS2tenffqsfs/u1vf0PHjh2xcuVK5OXl1TtWdSdC9fVJmkMb8o9//AOenp7417/+1eg20mgsT/fo0QOjR4/GoUOHas31uHTpEh48eCCu8kC4RbWBiEI5dOgQpkyZAhcXFyxYsABTpkyBsbEx8vPzcevWLZw6dapW4W11dXUEBQXB1dUV48aNwz/+8Q+MGzcOZWVlCA8Px65du+Dk5IRvv/0WQNWn/itXrmDFihWYPHlyvfPb29vj22+/xd69e7Fq1Srx4y9evACfz6+3vbW1tfhr5syZcHFxgYWFBQoLC5GQkIAffvgB/fv3bzbhTZ06Ffb29vjHP/6B/Px8jBgxAhcvXsSBAwcA1C5TExAQgE6dOmH06NEwMTFBTk4Ojh8/jt9//x2ffPIJunXrJt2LTgjh1Lhx47Bjxw6sXLkSI0aMwIoVKzBw4EBUVFQgKSkJu3btwqBBg6Curg4NDQ18/vnnDTb0li1bhtWrVyMyMhJeXl4NnmvLli3NxnPw4EHs3LkT7733HkaNGgUDAwM8efIEe/bswZ07d/Dvf/8bWlpaTR6jZ8+eOHr0KN555x0MHToUq1atwrBhwwAAd+/eFQ+p8PHxQV5eXqtyqJubG9zc3Jq9ruLiYkRFRQGAuCc5MTEROTk56NixI6ZNm9bsMb766iu4urpi5syZWLlyJV69eoW1a9di0KBBLeoFJ3LAQe1c0k5JskADY4yVlpayn376iTk4ODBDQ0OmoaHBunTpwhwdHdlXX33FXr9+XW+fnJwctnbtWtavXz+mra3N9PT02OjRo9n27dtZeXm5eLuPPvqIAWA3b95s9Pxr165lANj169cZY1ULNABo8Gv+/PmsrKyMffPNN2zatGnM0tKSdejQgWlra7P+/fuzTz/9tMF4G/LmzRu2cOFCZmhoyHR1dZmrqyu7dOkSA8B++OEH8Xb79u1jjo6OzMjIiGloaDBDQ0Pm5ORUa+EKQojyuXnzJps/fz6ztLRkWlpa4gUO/v3vf7NXr14xLS0t5u3t3ej+b9++ZTo6OszT05MxJnnOrbtAw927d9k//vEPNnLkSNatWzemoaHBOnfu3KI8k5aWxlauXMl69erFOnTowHR0dNiAAQPY3//+d/HiCdLmUADsgw8+aPK8W7durbdAQ0ZGRqO53MrKSuJriomJYWPHjmXa2tqsS5cu7P3332cvX76UeH8iXzzGWjiFkRAid0eOHMGcOXNw/vx5mYwdI4QQQlQZNWwJURC//fYbnj59isGDB0NNTQ2XLl3C1q1bMWzYMPFMY0IIIYQ0jsbYEqIg9PX1cfToUWzcuBFFRUUwNTXFggULsHHjRq5DI4QQQpQC9dgSQgghhBCVQOW+CCGEEEKISqCGLSGEEEIIUQnUsCWEEEIIISqhXU0eE4lEePbsGfT19cHj8bgOhxCighhjKCgogJmZWa2FNVQF5VFCiLy1Jo+2q4bts2fPYGFhwXUYhJB24PHjxzA3N+c6DJmjPEoIaSstyaPtqmFbvYb148ePay3LSkhDRCIRkpOTAQBDhgxRyd43Inv5+fmwsLAQ5xtVQ3mUSIPyKGmJ1uTRdtWwrb5t1qlTJ0rIRCKOjo4AQMmYSE1Vb9NTHiXSojxKWqolebRdNWwJkRYlYkIIaR3Ko6Qt0W8bIYQQQghRCdRjS0gjGGPIysoCAFhZWansrWVCCJEXyqOkrVHDlpBGMMbw+vVrAIClpaVMEzJjDJWVlRAKhTI7Jmkb6urq0NDQoDdoQiQgzzwKAEKhEBUVFTI9JpE/eeZRatgS0sbKy8vx/PlzFBcXcx0KaSFdXV2YmppCS0uL61AIabcKCwvx5MkTMMa4DoW0gLzyKDVsCWlDIpEIGRkZUFdXh5mZGbS0tKjnT4kwxlBeXo7s7GxkZGSgd+/eNDGGEA4IhUI8efIEurq66NatG+VRJSLvPEoNW0LaUHl5OUQiESwsLKCrq8t1OKQFdHR0oKmpiaysLJSXl0NbW5vrkAhpdyoqKsAYQ7du3aCjo8N1OERK8syj1NVACAeol0+50c+PEMVAPbXKS155lLIzIYQQQghRCdSwJYQQQgghKoHG2BLSCDU1NQwZMkT8f0IIIdKhPEraGv2WEdIEDQ0NaGjQ5z9F8csvv6Bnz57Q1tbGiBEjcPbsWZns05LjEkIkQ3lUsUib786cOQNPT0+YmZmBx+MhJCSk3jaVlZX4v//7P/Ts2RM6OjqwsbHBl19+CZFIJKeraBw1bAkhSuH333/HRx99hH/+859ISkqCo6Mjpk2bhkePHrVqn5YclxBClFFL8l1RURGGDBmC7du3N7rNV199hcDAQGzfvh337t3D119/ja1bt+Knn36Sx2U0icfaUWXj/Px8GBgYIC8vD506deI6HKLgGGN4/PgxAMDCwkIms29LS0uRkZEh/rT854kArhZr0NUFpLyuK1eu4NNPP8Xly5dhZWWFgwcPIikpCREREQgLC5NToMCYMWMwfPhw7NixQ/xY//794e3tjc2bN7d4n5Yct8Gf459UPc+o+vUR2ZJHHgUa+BukPCqRluS7mng8HoKDg+Ht7V3rcQ8PD5iYmGDv3r3ix/z8/KCrq4uDBw82eCx55VHqsSWkEYwxZGdnIzs7W74r2xQXA3p63HxJ+UZw6dIlODk5YerUqbh16xYGDBiADRs2YOvWrfjiiy9qbbtp0ybo6ek1+SXpLf/y8nJcv34dbm5utR53c3PDhQsXWrxPS45LCJEc5dH6lCmPSsrBwQFxcXFISUkBACQnJ+PcuXOYPn16q47bEjTohRAisb///e/w8/PD2rVrAQCzZ8/Gu+++Cy8vLwwbNqzWtsuXL8esWbOaPF6PHj0kOm9OTg6EQiFMTExqPW5iYoIXL160eJ+WHJcQQlpDmfKopD777DPk5eWhX79+UFdXh1AoxH//+1+8++67rTpuS1DDlhCu6eoChYXcnVtCT548wcWLF7F161bxY1paWmCM1etlAIAuXbqgS5cuUod0+PBhLFu2TPx9dHQ0bG1tAdQvxs4Ya/bWpiT7tOS4hBAFQnm0Flnn0eb8/vvvOHToEI4cOYKBAwfi5s2b+Oijj2BmZob58+e36tjSooYtIVzj8YCOHbmOoln37t0DAIwcOVL82IMHDzB69GgMHjy43vabNm3Cpk2bmjxmdHQ0HB0daz02Y8YMjBkzRvx9jx49oK6uDnV19Xq9Cq9evarX+1DNyMio2X0k2YYQogQoj9Z6TFZ5VFKffPIJ1q5di9mzZwMABg8ejKysLGzevJkatoQQxZSXlwd1dXXx92/evMHXX3+NQYMGNbh9S2+h6evrQ19fv97jI0aMQGxsLHx8fMSPxcbGwsvLq8Fja2lpNbuPJNsQQoisKFselVRxcXG9OsXq6uqclPsCU1KbNm1iANiaNWsk3icvL48BYHl5efILjKgMoVDIrl27xq5du8aEQqFMjllSUsLu3r3LSkpKZHK8tvTw4UMGgH355Zfs3r17zM3NjQ0bNox169aNZWZmyv38R48eZZqammzv3r3s7t277KOPPmIdO3asde6ffvqJTZ48Wap9JNmmrqZ+jsqUZyiPEnmTRx5lTHlzqTLm0YKCApaUlMSSkpIYALZt2zaWlJTEsrKyxNvMnz+f9ejRg0VERLCMjAwmEAiYkZER+/TTTxuNRV55VCkbtleuXGHW1tbMzs6OEjKRG2rY1vfll1+yrl27Mm1tbTZ//nyWnZ3Nhg8fznr16tUm5//555+ZlZUV09LSYsOHD2eJiYm1nl+/fj2zsrKSah9Jt6lJFRq2lEdJW6CGbX3KlkdPnz7NANT7mj9/vnib/Px8tmbNGmZpacm0tbWZjY0N++c//8nKysoajUNeeVTp6tgWFhZi+PDh+OWXX7Bx40YMHToU33//fYPblpWVoaysTPx9fn4+LCwsqP4ikVh5eTmAqlvWstBU3T6iPBr7OTLGkJiYiEmTJil0nqE8StqSrPMoQLlUFTT1M0xKSsLw4cPbRx3bDz74AO7u7nBxcWl2282bN8PAwED8ZWFhAQDiYtGENEdLS0umyZiorpKSEhw7dgwnT57kOpRmySKP3rlzR95hEhVBeZRISigUIiYmBseOHWvxMZSqYXv06FHcuHFDotUxAGDdunXIy8sTf1U3aA8dOoTExERuBjUTQlTOo0ePEBgYiIyMDPj6+nIdTpNklUfDwsIQEhIi7o0jhJDWePPmDfbu3YvLly9j8uTJLT6O0lRFePz4MdasWYOYmBiJbzt06NABHTp0qPe4vb09EhISxG9CdDuNNIQxhqdPnwKomnVKdU1JXSKRCImJiUhISICFhQX8/PwU+vdElnnU3d0dZ86cwePHj+Hv7w9TU1NZh0tUAOVRIolbt24hIiICenp6WLx4MfT09Fp8LKUZYxsSEgIfH59aZTKEQiF4PB7U1NRQVlZW67mG1Fx7+M2bNxAIBKioqIC3tzf69u0r70sgSkYkEiEpKQkAMGzYsHqlTFqCxoWphtLSUqSlpeHWrVtISUmBk5MTJkyYADU1tVatcS5vss6j5eXlCAoKwqtXr+Dq6ooxY8ZQw4XUIo88ClAuVQWlpaVIT09HWloarl+/Djs7O7i7u6NDhw6tyqNK02Pr7OyM27dv13ps4cKF6NevHz777LNmk3Fd1tbWWL58OcLCwvDbb79h9OjRcHNzg4aG0rwkRIkpyedJ0oiSkhIUFBQgNzcX8+fPh7W1NdchSUTWedTIyAiLFy9GXFwcTpw4gbS0NHh7e6OjEhTKJ6qBcqnyKi8vR0FBAdLS0uDj44MhQ4bI5LhK04rT19evV8C4Y8eO6Nq1a6OFjZujq6uLd955B1evXkVMTAyysrLg7++Pbt26ySJkQurR1NQEUFXMWkdHh+NoiLQYY8jPz8fr16+hpqaGuXPnNlgEXVHJI49qaGhgypQpsLGxQXBwMAIDA+Hr64uePXvKImRCGlT9Iay8vJxyqZJhjKGoqAivXr0CYwxz5syRabtLaRq28sLj8TB69GhYWVmBz+dj165dmDZtGoYNG0a31IjMqaurw9DQEK9evQJQ9eGKfs+UQ0VFBfLy8lBaWoqioiKYm5srVaNW3nr37o0VK1YgODgYBw4cgIODAyZOnCh1LzAhktDQ0ICuri6ys7OhqakpsyEORL6EQiHy8/NRVFSEwsJCWFhYyLwzUakbtgkJCTI7lomJCZYuXYqTJ08iLCwMaWlp8PT0pLE7ROa6d+8OAOLGLVF85eXlKCkpAY/Hg66uLoyNjcU/R2Unyzyqr6+PefPm4fz584iPj0dmZib8/PxgaGgos3MQAlR1SpmamiIjIwNZWVlch0MkUFlZieLiYjDGoKOjAxMTE7nkUaVu2MqalpYWPD09YWNjg/DwcAQGBsLPz09ct5EQWahOyMbGxqioqOA6HNKEsrIynD59GqmpqRg4cCAcHBygq6tLvZBN4PF4cHBwgLW1Nfh8PgIDA+Hp6YmBAwdyHRpRMVpaWujduzeVnFNwQqEQly9fxo0bN2Bubg5XV1cYGhrKLY9Sw7YBAwcORI8ePcDn87F//35MmjQJ9vb2dKuDyJS6ujo1kBTY48ePERQUhNLSUmqYtYC5uTmWL1+O8PBwHD9+HGlpaZg6dSoV6icypaamRndWFdjbt28RFBSEZ8+eYfLkybC3t5f78DulKfclC9KWjxAKhUhISMC5c+dgbW0NX19fGlPXzpSUlAAATU5oR0QiEc6fP4/Tp0+jR48eUt9KV+RyX7Ig7fUxxpCUlITo6GgYGBjA399fZYZxEMlQHm2f/vjjD4SHh0NXVxd+fn4wNzeXeN/W5FFq2EogIyMDAoEAQqEQ3t7e6NOnjxyjJIRwpaCgAAKBAJmZmXB0dMTEiROlvlNDDduGZWdng8/n4/Xr13Bzc8OoUaNo4iQhKqi8vBzR0dFISkrC4MGD4e7uLnWvOjVsJdSaF6qoqAihoaFISUnB2LFj4eLiQjVvCVEhKSkpCAkJgbq6eqvKVVHDtnGVlZWIiYnBlStX0LdvX3h5eUFXV1dOkRJC2tqLFy/A5/ORl5cHd3d3DBkypEUfYKlhK6HWvuEwxnD58mXExsbC2NgY/v7+6Nq1qxwiJYqAMYbnz58DAExNTal3SUVVVlbi1KlTuHTpEvr06QNvb+9WNbaoYdu8Bw8eICQkBJqamvD19VWaBS6I9CiPtg+MMVy5cgUxMTHo1q0b/P39YWRk1OLjtSbP0GwoKfB4PIwdOxZLlixBeXk5du7ciZs3b9LKJyqqOiE/f/6cfsYq6vXr19i7dy+uXr2KadOm4d1336UexDbQt29frFixAl26dMH//vc/nD59GiKRiOuwiBxQHlV9xcXFOHr0KKKjozFq1CgsWbKkVY3a1qJ76S1gamqKZcuWITo6GiEhIUhLS4OHhwc6dOjAdWiEEAkwxpCcnIyoqCh06tQJS5cupQlNbaxTp054//33cfbsWSQkJCAjIwN+fn4wMDDgOjRCiIRqzkF67733FGIOEvXYtpCWlha8vLzg5+eHlJQUBAYG4unTp1yHRQhpRllZGQQCAUJCQjBw4EAEBARQo5YjampqcHJywsKFC5GXl4cdO3bg7t27XIdFCGmGSCRCfHw8Dhw4ACMjI6xYsUIhGrUA9di22uDBg2Fubg4+n4+9e/fC2dkZ48ePp3FEhCigp0+fgs/no7i4GH5+fhg8eDDXIREAlpaW4pq3x44dw8iRIzFlyhRoampyHRohpI7c3FwEBQXh6dOnmDRpEhwcHBSqzj81bGWgc+fOWLRoEU6fPo3Y2Fikp6fDx8cHenp6XIdGCEHV0IMLFy4gLi4OpqameP/999G5c2euwyI16OjoYObMmbh+/TpOnDiBR48ewd/fH8bGxlyHRgj50507dxAeHg5tbW0sXLhQIVdmpYatjKirq8PFxQU9e/ZEcHAwduzYAR8fH/Tq1Yvr0Ahp1woLCxEcHIy0tDQ4ODhg0qRJtOKbguLxeBg5ciQsLS3B5/Oxa9cuTJ06FSNGjKC7YIRwqKKiAidOnMD169cxcOBAeHp6KuyKb9SwlTFbW1usWLECwcHBOHToEMaPHw9nZ2d6IyWEA6mpqQgODgaPx8O8efNga2vLdUhEAsbGxli6dClOnjyJiIgIpKWlYcaMGbRyFSEcePnyJfh8PnJzc+Hp6Ynhw4cr9AdNqmMrJ4wxXLp0CadOnYKJiQn8/f3RpUsXuZ6TyBZjDMXFxQAAXV1dhf5DJrUJhULExcXhwoUL6NWrF7y9vdtsaBDVsZWte/fuITQ0FB06dICfnx8sLS3lfk4iO5RHlRdjDFevXkVMTAy6du0Kf39/dOvWrU3OTQs0SIiLN5xnz56Bz+ejsLAQHh4esLOza5PzEtJevX79GkFBQXj58iVcXFwwduzYNn0zpYat7OXl5SEoKAiPHz/GxIkT4ejoqFCTVQhRNSUlJQgNDcX9+/cxevRouLm5telqq9SwlRBXbzhlZWWIiopCcnIyhgwZgunTp1PNW0Lk4NatW4iIiICenh78/f1hZmbW5jFQw1Y+RCIRzpw5g8TERFhaWsLPz08lX19CuJaVlYWgoCBUVFTAy8sL/fr1a/MYqGErIa7fcBThTZdIjjGGV69eAaga80e30BSXIn145DrPyBvX16cIb7pEcpRHlYcifXhsTZ6hyWNtyM7ODj169EBQUBD27t3LyW1SIjnGGJ48eQIA6NatG/2cFFTN4T6+vr403EfFWVlZYfny5QgLC8PRo0c5uU1KJEd5VDnk5eVBIBDg0aNHSj/chzJBG+vatSsWL16MuLg4nDx5Eunp6fD29kbHjh25Do0QpVJ3gubcuXNpgmY7oauri3feeQfXrl3DyZMnkZWV1aYTWwhRJffv30doaCi0tLSwYMECWFlZcR1Sq1DDlgPq6upwc3ODjY2NuOatr68vbGxsuA6NEKVQVFSE4OBgpKamUkm9dorH42HUqFG1at5OmzYNw4YNo15BQiRQUVGBmJgYXL16Ff3791eZknrUsOVQr169sGLFCggEAhw8eBD29vZUPJ6QZqSlpSE4OBiMMcydO5cWQWnnTExMEBAQgBMnTiAsLAxpaWkKXTyeEEXw6tUr8Pl8vHnzBh4eHiq1CAo1bDmmp6eHefPmiZf7zMzMhJ+fHy33SUgdQqEQp0+fxrlz52Bra0vLVhMxTU1NeHp6wsbGBuHh4QgMDISfn59CLvdJCJcYY7hx4wZOnDiBzp07IyAgQOWWraaGrQLg8Xiwt7eHlZUVgoKCEBgYCE9PTwwaNIjr0AhRCG/fvgWfz8fz58/h6uqK8ePHq0zvApGdgQMHiifo7t+/H5MmTYK9vb3SToIhRJZKSkoQHh6Ou3fvYuTIkZgyZQo0NTW5DkvmqGGrQMzNzbFs2TJERkaCz+cjLS0N06ZNg5aWFtehEcKZ27dvIyIiArq6uli8eDF69OjBdUhEgRkaGmLBggVITExEfHw80tPT4evrC319fa5DI4Qzjx8/Bp/PR1lZGWbNmoUBAwZwHZLcUB1bBcQYQ3JyMiIjI2FgYAB/f390796d67DaHcYYCgsLAVQNGaEewrZVXl6O6OhoJCUlYfDgwfDw8FCKhU2UJc+0lDJdX0ZGBgQCAYRCIby9vdGnTx+uQ2p3KI9ySyQS4dy5c0hISIC5uTn8/PxgYGDAdVjNogUaJKRMCRkAcnJywOfzkZ2dDTc3N4wePZqSAmkXnj9/jqCgIOTn52P69OkYMmSI0vzuK1uekZayXV9xcTFCQkKQkpKCMWPGwNXVlWreknYhPz8fAoEAWVlZmDBhApycnJRmWA41bCWkbAkZACorK3Hq1ClcunQJffv2hZeXF3R1dbkOixC5YIzh8uXLiI2NhbGxMfz8/GBkZMR1WFJRxjwjDWW8PsYYrly5gpiYGHTr1g3+/v5K93tFiDQePHiAkJAQaGpqwtfXF9bW1lyHJBVq2EpIGRNytZSUFISEhEBdXR2+vr7o2bMn1yGpPMYYcnJyAABGRkZK02OorIqKihAaGoqUlBSMHTsWLi4uStmzpsx5RhLKfH0vXrwAn89HXl4epk+fjqFDh9LftZxRHm1blZWViI2NxeXLl5W6M4wathJS5oQMAAUFBRAIBMjMzISjoyMmTpyoNLcVlJFIJEJSUhIAYNiwYfRay5EqjYVU9jzTHGW/PmUdu62sKI+2nZrDF6dMmYJRo0Yp7QeJ1uQZ5esOacf09fUxb948nD9/HqdPn0ZGRgb8/PxgaGjIdWiEtIhQKERCQgLOnTsHa2trmr1O5E5LSwteXl6wsbFBRESEuOatubk516ER0iKMMSQlJSE6OhoGBgZYunRpu55wTg1bJaOmpgZHR0dYW1vXqnk7cOBArkMjRCq5ubkICgrC06dPMXnyZKo3StrU4MGDYW5uDj6fj3379sHZ2ZnqIxOlU1paioiICPzxxx8YPnw4pk6d2u5LhFLDVklZWFhg+fLlCA8Px/Hjx5Geno6pU6eqZLFlonru3LmD8PBwaGtrY+HChbRCFOFE586dsWjRIpw+fRqxsbFIT0+nFe2I0njy5An4fD5KSkrg7+9Pizr9iRq2SkxbWxv+/v6wtbVFdHQ0Hj16BH9/f5iYmHAdGiENqqiowIkTJ3D9+nUMHDgQnp6e0NbW5jos0o6pq6vDxcUFPXv2RHBwMHbs2AEfHx/06tWL69AIaRBjDOfPn0d8fDzMzMwwf/58dO7cmeuwFAbd91NyPB4Pw4cPR0BAANTU1LB7925cvXoV7WhOIFESL1++xK5du3Dr1i3MmDED/v7+1KglCsPW1hYrVqyAmZkZDh06hJiYGAiFQq7DIqSWgoICHDx4EHFxcbC3t8fChQupUVsH9diqiG7dumHp0qWIiYlBZGQk0tLS4OXlBR0dHa5DI3WUlJRg7dq1SEtLg62tLbZs2aLSPyfGGK5evYqYmBh07doVAQEB6NatG9dhEVJPx44d8d577+HSpUs4deoUMjMz4e/vjy5dunAdGiF4+PAhgoODoa6ujnnz5sHGxobrkBQSlftSQffv30doaCg0NTXh5+cHKysrrkNSSowx5OfnAwA6deoks0kla9asgYuLCzw9PREeHo64uDh8//33Mjm2oikpKUFoaCju37+P0aNHw83NTSlr00pD1fOMql9ftWfPnoHP56OwsBAeHh6ws7PjOiSlJK882p5UVlYiLi4OFy9eRO/eveHt7Y2OHTtyHZZcUR1bCbWXhAxUXWtQUBAePXoEJycnTJgwgWacKwgPDw9EREQ0+r2qyMrKQlBQECoqKuDl5YV+/fpxHVKbUPU8o+rXV1NZWRmioqKQnJyMIUOGYPr06VTzlrSp169fg8/n49WrV3B1dcWYMWPaxYcDqmNL6unUqRPmz5+Ps2fPIiEhARkZGfD19YWBgQHXobV7tra2CA8PF/fYqtokFZFIhDNnziAxMRFWVlbw9fVV+QYQUU0dOnSAj48PbG1tERERgcePH8Pf3x9mZmZch6bQ2ttwK3lgjOHWrVuIjIyEvr4+lixZAlNTU67DUgrUY9sOPHr0CEFBQSgvL8eMGTPQv39/rkNSCowxvHnzBgDQpUsXmX1KLikpwbp165CamopevXph8+bNKpP08/LyIBAI8OjRI0ycOBGOjo7t7k6BqucZVb++xrx58wZ8Ph8vX76Ei4sLxo4d2y56zlqi5nCrsLAwREZGYtOmTTLNo6qsrKwMkZGRuHXrFoYOHYrp06e3u9q0NBRBQu01IQNVjamwsDDcu3cPo0aNgpubG9W8bQYtBSmde/fuISwsDFpaWvDz84OlpSXXIXFC1fOMql9fU4RCIeLj43H+/Hn06tULPj4+Kj/WsSVqDq8SiURwcnLC999/T3lUAk+fPkVQUBCKiorg7u7ebsd2tybPKM1v2ObNmzFq1Cjo6+vD2NgY3t7eePDgAddhKQ0dHR3MmjULHh4eSEpKwu7du/Hq1SuuwyIqoKKiApGRkfj9999hbW2N5cuXt9tGraKjPNo66urqcHV1xdy5c/H8+XPs2LED6enpXIelcKqHWwFAeHg4LVcsAcYYLly4gL1790JHRwfLli1rt43a1lKahm1iYiI++OADXLp0CbGxsaisrISbmxuKioq4Dk1p8Hg8jBw5EgEBAQCA3bt34/r161TzlrTYq1evsHv3biQlJcHDwwOzZs1SmWEVqojyqGz06tULK1asgImJCQ4ePIhTp05RzdsatmzZgri4OHh4eCA+Ph6rVq3iOiSFVlhYiMOHDyMmJgbjxo3DokWLqMRcKyjtUITs7GwYGxsjMTEREyZMkGif9nwLra6KigqcPHkS165dw4ABA+Dp6UkNkjpoKELjGGO4fv06Tpw4gS5dusDf3x/GxsZch6UQlCnPUB5tnepetri4OJiamsLf35+K5ddBebRpqampCA4OBo/HE09UJO20KkJeXh4ANPmppqysDGVlZeLvq2vpEUBTUxMeHh6wsbFBWFgYAgMD2/W4SCK5kpIShIeH4+7duxg5ciSmTJlC47WVFOXR1uHxeLC3t4e1tTX4fD4CAwPh6emJQYMGcR0aUXBCoRBxcXG4cOECevXqBW9vb+jp6XEdlkpQyo9OjDH8/e9/h4ODQ5MJZPPmzTAwMBB/WVhYtGGUymHAgAFYsWIFDAwM8Ouvv+LMmTMQiURch0UU1KNHjxAYGIj09HTxmG1q1ConyqOy06NHDyxfvhx9+vQBn89HaGgoysvLuQ6LKKg3b95g3759uHTpEtzc3DBnzhxq1MqQUg5F+OCDDxAZGYlz5841OSi9oZ4GCwsLuoXWAJFIhMTERJw5c4Zqj/6JbqH9RSQSiWsiW1hYwM/Pj2oiN0JZbtVTHpU9xhiSk5MRFRWFTp06wc/Pr93XHqU8Wlt1bdqOHTvCz88PPXr04DokhdSuyn19+OGHCAkJwZkzZ9CzZ0+p9lWWNxwuZWZmQiAQoLKyEl5eXujbty/XIXGGMYbc3FwAgKGhYbutv5ifnw+BQICsrCxMmDABTk5O7f7NqSnKkGcoj8qXPFeLUrbFDyiPVikvL0dkZCSSk5NhZ2cHd3d3WsWuCe2iYcsYw4cffojg4GAkJCSgd+/eUh+DErJkiouLERoaigcPHmDMmDFwdXWFhobSDscmrfDgwQOEhIRAU1MTvr6+sLa25jokhafIeYbyaNuprKxEXFwcLl68iD59+sDLy0smNW9rLn4QHh6OuLg4fP/9960PmMjN8+fPwefzUVBQAHd3dwwZMoTrkBReu2jYrly5EkeOHEFoaGitXkQDAwOJP61SQpYcYwxXr15FTEwMjIyM4O/vDyMjI67DIm2ksrISMTExuHLlCvr164cZM2ZAV1eX67CUgiLnGcqjbS8lJQUhISFQV1eHr6+v1D3kddVc/KCh74niYIzh0qVLOHXqFIyNjeHv74+uXbtyHZZSaBcN28ZuX+zfvx8LFiyQ6BiUkKX38uVL8Pl85ObmYtq0aRg2bFi7uZXUXm+hZWdnIygoCDk5OXBzc8OoUaPazbXLgiLnGcqj3CgoKIBAIEBmZiYcHR3h5OQEdXX1Fh1L2Xps22seLSoqQkhICB4+fIhx48bB2dmZ7nxKoV00bGWBEnLLlJeX48SJE7hx4wYGDRoEDw8PaGtrcx0WAPmON2tvkx4YY0hKSkJ0dDQMDQ3h7+8PExMTrsNSOqqeZ1T9+uRFJBLh/PnzOH36NHr06AE/Pz8YGhpKfZySkhKsW7cOqamp6NWrFzZv3qzQY2zbWx4FgPT0dAgEAjDG4O3t3aIhP+0dNWwlRAm5de7cuYPw8HBoa2vD399fIZZJlGfvRXtKyKWlpQgPD8edO3cwYsQITJkyBVpaWlyHpZRUPc+o+vXJ25MnT8Dn81FaWgpPT08MHDiQ65Dkqj3lUaFQiNOnT+P8+fPo2bMnfHx8oK+vz3VYSqldLtBA2t7AgQPRo0cP8Pl87Nu3D5MmTYKDgwOnt5bS0tLwww8/AAA8PT2xc+dOzmJRVo8fP0ZQUBBKS0sxc+ZMlX+jJYRL5ubmWL58OcLDw3H8+HHcu3cPCQkJyMzMVIoqB6Rhb9++RVBQEJ49ewZnZ2fY29u3m2EXikZ1PzoRuTA0NMTChQthb2+P+Ph4HDx4EAUFBZzFY2tri/DwcABAeHg4evXqxVksyqa6Nu3+/fuhp6eH5cuXU6OWkDZQfddrxowZ2LZtGyorK7F37164uLhg3bp1XIdHpPTHH38gMDAQRUVFWLRoEecdPu0dNWyJ1NTV1eHs7Ix58+YhOzsbO3bswMOHDzmJZcuWLYiLi4OHhwfi4uKwefNmTuJQNgUFBTh48CDi4+Nhb2+PhQsXtmi8HyGkZXg8HoYPH46OHTtiyJAh2L17N0xMTDjLpUR65eXlCA0NBZ/PR+/evbFs2TKFGKLX3tFQBNJiNjY2WL58OUJCQnD48GFOZn7q6Ogo9IxgRfTw4UMEBwdDXV0d8+bNg42NDdchEdJuDRgwAKamprC2tsZ3330HkUiE4uJiKq+n4F68eAE+n4+8vDx4eXlh6NCh1EurIKhhS1qlY8eOeO+993D58mXExsYiMzOTavUpqMrKSpw6dQqXLl2SacF4QkjLbdmyRVzloGvXrrC3t0dgYCD8/PxgZWXFdXhSq1upZtOmTVyHJFOMMVy5cgUxMTHo1q0bli1bRjXeFQxVRSAAZFM2q+bqKtOnT8eQIUOU+hMsYwxv3rwBAHTp0kWpr0WeS3yS2lQ9z6j69XFN2Zewrlup5tSpU/j3v/8NQPnzaM1VOceOHQsXFxeqTSsnVO5LQpSQGyerslnl5eWIiorCzZs3FWI9bGVbV13WGGNITk5GVFQU9PX14e/vD1NTU7mcq72/1tVUPc+o+vUpApFIhHPnzuH06dOwsLCAn58fDAwMuA5LIqq6MlpGRgYEAgGEQiG8vb3Rp08frkNSaa3JM8rzMZDIVVpaGjw9PQFUlc1KTU1t0XG0tLTg7e0NPz8/PHjwAIGBgXj69KksQ5XK2rVr4eLigoiIiHY347isrAwCgQAhISEYMGAAli1bJrdGLdC+X2tCZElNTQ0TJkzAwoULkZeXh8DAQNy7d4/rsCSiapVqRCIR4uPjceDAAXTt2hXLly+nRq2Co4YtASD7ZDR48GAsW7YMurq62Lt3L86fP4+2uDlQUlKCNWvWwMPDA2vWrEFKSkqLG+yMMeTl5SEvL6/Z2Ouet6SkpFXX0VpPnz5FYGAgUlJS4OfnB29vb7kvuCCrD0eEkCqWlpZYvnw5rK2t8fvvvyMiIgIVFRVch9WkupVqNm3aJHEe5UJTuTs3Nxf79+/HuXPnMGnSJLz//vt0l0IJUMOWAJBP2awuXbpg0aJFGDduHGJjY3Ho0CEUFhbKINrG1e01LCgoaHGDnTGG1NRUpKamNpuQFaW3kjGG8+fPY+/evdDV1cWyZcswePDgNjm3qvXUEKIIdHR0MGvWLHh4eODmzZvYvXs3Xr16xXVYjaquVBMREYHvv/8e2traEudRLjSWu+/evYvAwEAUFBRg4cKFmDBhglKNdW7PaIwtaRNpaWkIDg4GYww+Pj4ya/TUHdf58OFDREVFiZ+fPn06+vTp06J11aVZClIRxpUVFhYiODgYaWlpsLe3x+TJk6Gurt5m51e2NezlRdXzjKpfnyJ79eoV+Hw+3rx5g6lTp2LEiBEKPxlLlkvqymMcf91cPX36dKxYsQLXr1/HgAEDMGPGDGhra7fqHER6NMaWyF1rb7Xb2tpixYoVMDU1xaFDhxATEwOhUNjquOp+2s7Pz6/Va9inT59avQfyamhx3VuZmpqKHTt24OXLl5g3bx5cXV3btFEL1O+paY+NWkLkydjYGEuXLsXQoUMRERGBY8eOyWXYk7yHVrX0+PK4M1Yzdx84cAAlJSW4desWPD09MXPmTGrUKiFq2BKJyCKhdOzYEXPmzMGUKVNw+fJl7N27V1xOq6XqjuvU19fnZCUyrlZAEwqFiImJwaFDh2Bqaorly5fD1ta2Tc5NCKmtLcbaa2pqwsPDA7NmzUJGRgYCAwPx6NEjmcYp76FVLT2+PMbxb9myBadOnYKDgwMCAwPh7e2NgIAApegNJw2jhi2RiKwSCo/Hw7hx47B48WKUlpYiMDAQt27danFcdXtK+/bty0mvYVv0VtZ9M3r69Cn27t2Ly5cvw83NDXPmzIGenp7Mz0sIkUxbjrUfMGAAVqxYAQMDA+zfvx+JiYkQiUQyiVPeE0Fbenx53RkbP348XFxc8H//939YuXIlunXrJpPjEm5Qw5ZIRNYJxczMDMuWLUP//v0hEAgQHByM8vJyqY/DVU8pF2q+Gdna2mLmzJkoLS3F4sWLMX78eLn3Liha5QdCFE1bVwYxMDDAggULMGHCBCQkJODAgQPIz89vdZzyHlrV0uPLOt9nZWVhx44dyMzMxOzZszF9+nRoamq26piEezR5jEhEnhODkpOTERkZKdMFBGQxyUCWkx5kwcPDA0FBQYiKikJycjLCw8Nx4cKFNlsAQ1aLeKg6Vc8zqn59rcHl30hmZiYEAgEqKirg5eWFfv36tThOWeb7hvIo1xNNRSIRzpw5g8TERFhaWsLX11dpFsBoL2jlMQlRQlZcr1+/RlBQEF6+fAkXFxeMHTu2VT2QLXmDqdsY3rx5M4qKigAARkZGnI+3Wrx4MdTV1WFtbQ09PT2kp6e3acNSESo/KANVzzOqfn2twXWDrbi4GGFhYbh//z5Gjx4NNze3Bpd8lXecNXOpjY0NPv74Y+jo6ChEHs3Ly8PRo0exf/9+8Hg8jBo1Cl999RVNdlUw1LCVECVkxSYUChEXF4cLFy6gd+/e8Pb2RseOHaU6RnVCPX36dK2xu5I0whS1R5IxhkuXLiE6Ohrnz5+Huro6BgwY0OZvmor6+igaVc8zqn59yo4xhqtXryImJgZdu3aFv79/m48ZVdRccf/+fYSGhiIyMhLz58/H4sWLFSo+8hdq2EqIErJySE1NRXBwMHg8Hnx9fWFjY9PotnV7WSsrKzF16lScOnUKkyZNgre3d6O32uoOVZg5c2areyRlXWexqKgIISEhePjwIcaPH4/Jkyc32APTFrjujVIWqp5nVP36VMXLly/B5/ORm5uLadOmYdiwYW3WW6pod3cqKioQExODq1evon///vj1118RHR2tMPGR+qiOLVEpvXr1wooVK2BsbIyDBw/i1KlTjda8rTu79/z58/D09MSWLVuQkJAAOzu7BicZNDQruOaEBj6fj7dv32Lq1KlYsWIFiouLJYp97dq1cHR0hK2tLW7evAlXV9cWT7JKT0/Hjh078OzZM8yZM6fR24ptherUEqI8TExMsHTpUtjZ2SEsLAx8Ph+lpaVtcu6auTQsLAyWlpYoKCiQ2cpj0kxkzc7Oxp49e5CUlAR3d3fMmjULffr0oVUSVRj12BJOSNKzWb08bHx8PMzMzODn54fOnTvX2qbuJ+0RI0Zgw4YNzd4Ca6hH4fjx4+IeydzcXHz88cewsLDAmTNnkJmZiR9++KHZ6/Lw8ICtra34NpxAIMCZM2ekus0lFApx+vRpnD9/Hj179oSPjw/09fUl3p9wS9XzjKpfnyq6c+cOwsPDoa2tDT8/P1hYWMj1fDXv7tja2mLWrFnQ1taW2SRcSYY6MMZw48YNnDhxAoaGhvD394eJiUm9+Ojuk2KioQgSooSsOKQZg/XkyRMEBQWhuLgYnp6eGDRoUKPHOXnyJDQ0NJpNWM2d38PDA2FhYeLZvP/+978RGRkp0XXdvHkTiYmJtY5V3YhurkH/9u1bBAUF4dmzZ5g8eTLs7e05n2xBpKPqeUbVr0/e5LEsrCRyc3MRFBSEp0+fYtKkSbC3t5dppZfGrkse1WWaG+pQUlKC8PBw3L17FyNHjsSUKVOojJeSoaEIpM3IqpapNPUezc3NsWzZMvTu3Rt8Ph+hoaHimrd16xpu3bpVotvlzdVDrHkr7cyZM1LVWRQKhRAIBACqbsPV3Lepwuh//PEHAgMDUVRUhEWLFsHBwaFVjVqqO0uI4mnLRRxqMjQ0xIIFC+Dg4ID4+HgcPHgQBQUFMjt+U9dVWlqKb775Bp6enjLJRU3VwX38+DECAwORnp6OWbNmwcPDQyaNWsqnSoS1I3l5eQwAy8vL4zoUpbV69WoWFhbGGGMsLCyMrVmzps2OIxKJ2I0bN9jGjRvZTz/9xJ4/f96ic0uiuLiYrV69mjk4OLDZs2ezwsLCes+5u7uzlStXspUrVzJ3d3e2evVqVlxczIqLi9maNWuYu7s7W7NmDSsuLhbv6+7uXus87u7urKysjIWEhLD169ez48ePs5KSEoliq3nOhsjqZ0Wko+p5RtWvT94aygFtLT09nX3zzTfsq6++Yg8ePJDJMRu7LqFQyGbPns22bdvGhEIhCw0NZfb29s3mr6Y0lGMLCwuZn58f69OnD3N2dmbPnj2TyXVVo3zatlqTZ6hhS6QiTVJuqgHWVOOvOdnZ2WzHjh3syy+/ZJcuXWIikUj6C5GAUChk165dY9euXWNCoVD8eM0EFxQUxHx9fRljjIWGhjab7OomxyVLlrCffvqJbdy4kd24cUOia5E0wSrCG2h7pOp5RtWvT96a+/uV9IOrJJo6VlFRETt8+DBbv349i46OZhUVFS0+D2ONX5dQKGQODg618uiECRPqbdcaL168YL169WLvvPMOi4+PZ8HBwTJveFI+bVutyTM0FIFIRZqlEJu6NdWaGfZGRkZYsmQJRo0ahejoaBw9elTiqgWyUHMYha+vL8rKygAAM2bMaHYJzeohEO7u7jh8+DBMTU2hoaGBZcuWSVyOR9JhHPJeFpMQIr3mhkG1dqhCzVvmLi4ucHR0bPBYurq6ePfddzFt2jRcvXoVe/fuxevXr+VyXebm5jhz5gwAQCAQYPDgwVizZg1++eUXREZGYvr06S2+vZ+SkgI/Pz+IRCJs2bJFXOZR1ssZUz5VHtSwJVKRZq1uea6brqGhgalTp+K9997D48ePsWPHDmRkZLTJOKiaCS44OBja2toAqhJ2c8lOR0cHmzZtwpw5c9CvXz+MHz8eS5YsgZGRUYvO31SC3bJlC06ePIkRI0bgX//6FyoqKmhcGCEca+5DfWvzZs2G8T/+8Q+cO3eu0WPxeDyMGTMGS5cuRUVFBXbu3ImbN2+2qCxXU9e1atUqXLlyBZ6enti2bRuePn0KFxcX9OnTB1u3bkVUVJTUjfjKykpER0fjyJEjKCoqwpQpU3D79m0AkuViaUnz3ke4RVURiNy01eoz+fn5EAgEyMrKQnJyMubPnw8vL69655R2NjJjDK9evQIAGBsbi3tTq0vFnD17FlZWVjAzM8Pt27chFAoRGxvb5DEzMjIgEAggFArh7e2NPn36SH290pSqUdQVgFSZqucZVb8+rrX2b7ZuhQAnJyckJiY2e6zy8nJER0cjKSkJgwcPhoeHBzp06NDKq6mfR0tLS+Ho6IizZ89i7NixsLCwaHSRnMbk5OSAz+cjOzsbbm5uOHz4MCZMmIBz584hKSlJolxMFBtVRSAKqa0+4Xbq1Anvv/8+Jk2ahDt37iAnJwe5ubn1eiikvcXH4/FgYmICExOTWkMEqnsmzp07B0tLS2RmZmLYsGFNJlKRSIT4+HgcOHAARkZGWL58eYsbtWvXrhXXh2yu/qI8e80JIbLX2rxZd3EEoVAo0bG0tLTg5eUFPz8/pKSkIDAwEE+fPpXq3A3dMaubR3V0dGBvb4958+Zhw4YN4nw8b968ZntZGWNISkrCzp07UVlZiaVLl2LMmDH46quvcO7cOaSmpjabi4nqox5bJcVVLURFt2jRIqipqaFXr17Q19fHw4cPxT0UXC3zKMv6kdL25lCPbdtTpTzTEFW/PmUni8UH3r59Cz6fj+fPn8PZ2Rnjx4+XaPy/pPmmpKQEjo6OuHbtmvixkSNH4uzZs43G+vbtW8yZMwepqano27cvDh06BAMDA4mvid4zlQv12LZDXNVCbIyi1Pj7+eefoa2tjePHj+PgwYNwcHBARUUFgKqejLCwMABVY7Byc3PrxVnzOlavXo2cnBwUFRW1eCnIu3fvIjAwEAUFBVi4cCEcHR1bVaBc2h5YGhdGSPsii6WvO3fujEWLFmH8+PGIjY3FoUOHUFhY2Ox+DeUnxhiKiopq5dHqXtuacwUcHBwajfXJkyfw8vKCkZERBAIBAgIC8M9//lOq9xxp3zMV5T2NtICsSjMoA1UqU9NU6RFZlouRlKLV+BOJROzatWts48aNbPv27ezFixfs9evXrH///szR0ZGtWbOGHTt2rF6cNa8jJCSEzZ49u165L0mUl5ezsLAwtn79enbs2LFma9NKStFeZ1KfKuWZhqj69amyuu8Nr1+/bva9IjU1lW3dupV9/fXX7OHDh00ev6H8VF028dy5c+zDDz+sde7mSj6KRCJ29uxZ9sUXX7DBgwezN2/eiJ8bMGAACwoKYoxJVmpR2nJdTeVaLt5j2xuqYyshVUrIq1evZqGhoYyxqlqq9vb24j8uLho/ilrj79WrV+yXX35h//nPf9g777zDHB0daz3fVNwN1V+UxIsXL9j27dvZxo0b2bVr12RaZ7c19X8VkSq+QahSnmmIql+fopDH30bd9wZ7e3uJ3isKCwvZwYMH2fr169nJkydZZWVlozHXzU/VDdvZs2ezkJCQZs9VLT8/n/3vf/9jGzZsYKdOnWKrVq0SxyoQCNiAAQNqbd+ahmpDmnpvoA4G+aM6tu3Qli1b8PXXX8PJyQlnzpzBRx99JL61wsWEoaZKUHF5S6dbt25YunQphg8fjhs3bqBjx47g8/kAGi4JU/c6zM3NJT4XYwxXr17F7t27oaamhoCAAIwYMaJVy+LWJYvbjIpE0YbUECJvkuZDefxt1H1vyM/Pl+i9omPHjpgzZw6mTJmCc+fOwc3NDW5ubvXibyo/PXnyROL3pYcPH2LHjh3Izs7GzJkzERYWhtTUVHz11VeYPn06vvjiC0ycOFGcqyUp7yXtsKym3tNoUq5ik7phm5ycjI0bN+KXX35BTk5Orefy8/OxaNEimQVHGqejowNDQ0MkJibi+++/h7+/v/iPi4tC0k0lDa4bLxoaGpg+fTrGjBmDrl274scff8SYMWOwbdu2esmt5nXEx8dj1apVEp2jpKQEx44dQ2RkJIYPH46lS5eiW7du8rgcldKe3yAol7ZPkuZDefxt1H1v6NSpU+PvFYwBZWVAYSGQnw9ebi7G9e2L1xkZ6G9lhckODrC1sZE4n5ubm9c7V91GfkFBAU6ePInDhw+jR48eWL58OXbu3AkXFxdER0fjs88+Q58+feDk5IRJkyYhLi4OTk5ODebyuqTtFGjqPY0Wa1BsUlVFiImJgaenJ3r37o2CggIUFxfj2LFjmDRpEgDg5cuXMDMzg1AolFvAraFqs3kbm4Eqi1mxsiSPagQtmeFaUlKCv//977hw4QJ0dHTwxRdfwNXVtdHJXCKRCElJSQCAYcOGNbpdVlYWgoKCUFFRAS8vL/Tr169V16bIZD2zWBWrNkiSZ5Q5l6paHm1rkuZDmf5tMAa8fo3Shw9xcPNmlGdkwKZjR0waMAD3z54F7+1bdFFXR4+OHaFWUAAUFwMlJVX7NXVYACVqatAxMgJPTw8wNAS6dAE6dwa6dQO6d4fI2BjpxcUo6NwZv1+8iD+ePEGv3r2xefNmcSPf09MThw8fxr59+zBx4kS4urpizJgx4PF4Db5ex48fb/I9rmaesrKyAlCVp2VVDaGkpASffPIJLl68CKFQCHt7e3zzzTdKfwdNkbQqz0gzbmHcuHHs888/Z4xVDer++uuvmZ6eHouOjmaMVY0tVFNTk3o8RFtRtbFhyjLeUh7jkVpzTKFQyBISEtiGDRvYvn37WG5ubqPbXbt2rdExtkKhkJ0+fZpt2LCB7d+/X2V+r5oi65+lsvwOS0OSPKPMuVTV8mhbk/RvqEV/G2/fMnbhAmO7dzP28ceMeXszNmgQY7q6jFU1U7n/0tdnzM6OMT8/dszWlrF9+1jKwYNs67//zczNzZmzs3OtMcUtyTk19/Hz82MCgUCq/SVB42zlqzV5RqoeWwMDA9y4cQO2trbix3777TcsXboUv/32G0aPHq2wvQwA9TRwRR49yLLoBc7KyoJAIEB5eTlmzJiB/v3713q+qR7bvLw8CAQCPHr0CBMnTmx1GS9lwVUtYGUiSZ5R5lxKebR1ZJIPGQMePwauXQOSkqq+bt4EmltQwcQEsLAAevSo+r+JCWBsDHTtChgYVPW4duoE6OoCurqYNX8+jgUHA2pqKCkvh72DA8xNTVGcn4/OenroZ22NlQsW4NzJkyh8/hxj+vZFfxMT8N6+BbKzgRcvwF68QHFaGrRevIDm27dNhvdKVxfGzs54oKeHM4WFWBoYiJLOnaV+vWrmpaZyVmvuQFEulK/W5BkNaTbu0KEDcnNzaz327rvvQk1NDbNnz8a3334r1clJ+1A9tqmlGko+1WOcqm/TtWSMk7GxMVJTU3Hx4kUIBAJ89tln8PT0hKamJoCqlcdMTU3F/6927949hIWFQUtLCwsXLoSlpWWLr01W2qr4uCxe95ZQteLqlEvbrxblw/Jy4Pp14OxZ4NKlqq/nzxvetkcPYOBAoH9/oFevqi9bW8DSEpByiVzTfv0QHhcHT09PzJs7F//64gv4+PiIh0b858/r8B07FqdOncKxixfRq3t3eC9aBD09vaqDMIa8P2M1NTAA7/FjID0duVevIiMmBpV37qBnSQmMysthXFwMhIejL4C+ABAeDh1zc3w/bhzg7AzY2wN/5uem1MxT2traCA4OFsddM2dVD4X44YcfEB4ejnXr1kn8s+EqFxIJSNO96+rqyrZu3drgc0eOHGGamppyv332888/M2tra9ahQwc2fPhwdubMGYn3ValbaJWVjBUVMVZezpgMy0kpooZu+cjiFnb1cUUiEfv222/ZuHHj2M8//8xevnzZ4Pbl5eUsIiKCrV+/nh09elShbpu31W0xroYOKNNtP0nyDNe5lPKogquoYOziRca+/JKxyZMZ09Gpf0tfXZ2xoUMZW7SIsZ9+YuzsWcbevpWoTJikpcRq/r2PGDGi1nMNlddKSUlhX3/9Ndu6dStLTU1t8JgikYjFx8ezMWPGsMGDB7OAgABWXFzM1gYEsHObNjH2ww/s0aRJ7GnXroypqdW/bj09xqZOZWzLFsauXWOsgWFiNeP+4IMP2AcffNBgzmpNmcq651i5cqVKlS3kWpsNRQgODsaZM2fw3XffNfj8b7/9hl27duH06dMyaXTX9fvvv2PevHn45ZdfYG9vj507d2LPnj24e/euRL1mKnULLSEB+HOiCYCqT7GamoCW1l//b+ixhv7f1GM1/21su8aO09g2Nf+vrg40Uw5LXrd86h7H1dUV3t7eyM3NxdSpUzF8+HBxT+2rV69w5MgR/P7771BXV8fw4cPx1VdfcdZrWLcH8+HDh4iKihI/r2q3xZTptp8keYbLXEp5VEE9ewZERQHR0UBcHJCXV/t5IyPA0bGq13LMGGD48KohA3VIMumsJRPTJN2nsLAQAoEA6enpsLe3x+TJk6Guri5+LiQkBD/99BPc3d3xz3/+E1FRUeKqA/WGHAiFVcMtLl6s+jp3Dqg7nMHICHBxAaZOBaZNqxpaISFZTdBTxUmwXGtNnpGqYcu1MWPGYPjw4dixY4f4sf79+8Pb21uipUKrX6i3b982+kLVHCcpEomaPB6n28bGQm3q1CaPowwYj9do45f35/ePXryAXpcu6GxiguzcXGTn5WHA0KG19uF16CD+nmlqglU/18Bx1bS1AS0tBO7bB7uRIzHW0RHnrlzB5aQkrPnkE5y9fBm37t9Hz7594ejsjIdZWUi4cAHRcXHQ+/P3RltbG927d8dPP/0kvhYejyduCLOqxU8ave7WbvvRRx/B2dlZnEi//vprfPrpp5gxYwYiIiIQFxeH7777Tq4xSLIt0PTvu6TbfvTRR3BxccGMGTPEbxzbtm2TSQyAbP8+8/Pz0blzZ4Vt+FEeVZBtGQP++AMIDgYvPBy8GzdqP21oCEyaBObsDDg5VQ0t+PN3uuZx6/49VueEatU5oea2dbep/r6p45aUlODzzz8XNzxrDgequy1jDBcuXEB8fDy6d+8ODw8P5ObmIjo6GiKRCFFRUYiPj28w5iZzjUgE3L4NJCaCFx8PJCSAV1Dw13l5PGDsWDB3d8Dbu+o1+1NDx617TZs2bYKOjo7U+c7T0xMRERGNvr5NxdDUcWWdR+W5LaA4eVSqhu3bt29x6NAhzJ8/v96J8vLycODAgQafk4Xy8nLo6uri+PHj8PHxET++Zs0a3Lx5E4mJifX2KSsrQ1lZmfj7/Px8WFhYICEh4a/xPzUYGBjUGieTlJTU6A9HX18fffr0EX+fnJyMysrKBrfV1dWtNTHp9u3bKC8vb3BbbW1tDBw4UPz9nTt3UFpaWn9DoRDajGFgnz5ARQVQXo7Ue/dQWlAAXkUFeJWVtb40RCLYWlqKt33+6BHKCgqqnq+5fUUF1IRCmHbtWrVtWRnycnJQUVxc/7h/ft9JW7uq3mFFBcqLiiAqK6u9TUUF1Kr3VcDJMNIQqamBaWmhgsdDYXk5OhkZgWloQKSpCS09Paj/2WguV1NDiVAIpqEBpqkJUXWD+8/vDYyN0UFfH9DSQnFlJV4XFYmfE2//5/cmFhbQNzICtLSQX1qKJ9nZ+O/WrVi7fr14+398/jnMrK3x8u1b9B84EJs3b0Z5eXmTtS8tLS3FtXYLCgqQkpLS6Lbm5uYwMTEBABQVFeH+/fuNbmtqagozMzMAVW+Gd+/ebXRbExMT8SIY5eXluH37doPblZaWYu/evXj16hV69eqF//znP03G27VrV1hbWwOoPQmwIZ07d4aNjY34++vXrze6rSQ5orCwEBMnTmwyIXOVSymP1qelpYXBgweLv7937x6Ki4sb3FZDQwNDhgwRf5+SkoKCGg2rmtTU1DBs2DDx96mpqcjLzYXu/fvoHBsLw9Onof348V878HjAqFGAuzueDh6MFz16VN3RakDNyayZmZl4/fq1+LlvvvkGo0ePxoQJE3DmzBlkZGTgxx9/BAA8evQI2dnZ9ba5cuUKPv74YwwePBhaWloAqhZUePnyZYPnB4ABAwZAR0cHJSUlWLVqFVJSUmBubo5Vq1ZBW1sbQFXZuqioKERGRqKkpAR2dnb47rvvsHHjxgbPDwB9+vSBvr4+ACA7OxuPHj1qNIZeVlbQTk5Gwrp1sLl/H73r/CxKevbEW2dn5Do7w9TNDZ27dAFQ9feXnp7e6HGtra3RtWtXAFV/j83l0Y0bN8LFxQUTJ07Enj17al1PTVznUaBq0aLqOzOVlZVITk5udFtFz6ONkWry2Pbt23Hr1i18+OGHDQZ69uxZ5Ofn45///KdUQUgiJycHQqFQ/EtRzcTEBC9evGhwn82bN+OLL76QeSyKoLSiAtt++QV5eXniyTQV5uYoayIho0ZCLmgmIZvWSMjZqanIq3tbrIYRI0aI//8kPR1vm5j5OmzIEKgJhUBFBR6lpuLtq1e1Gsxq5eXi//eysoJGZSVQUYHsp09R8Pp1rcayeJ+KCnTv3BnqIhFQXo6CN29QmpdXf9s/G9gdNTWhLhQC5eWoKCqCsKTkr22rz//n/9XqfO5TE4mA0lKoA9AGgEYSv9afX5LQ/fNLEp0ADABwGAC8vMSPnwKAq1ervklIAPbsQQdNTdipq0P0Zw+2uJH95/cd9PSAPxvX2mpqsCorq92wrvF/XSOjqlt+WlrQANA5OxtMS+uvY9c4rkZRUdUHHS0tQCSCWmGheJvmhp00RltbGxs2bKiVkJUZV7mU8ihHHjxAl+3bYR4WBu0aDbVyNTUUjB+PgsmTYb1yZVWVAgBl6enA27coLS3F9u3b8eTJk3qNxsasWrUK27dvh0AggLm5OXbt2tXsNpIuRNOQtWvXwtHREStXrsSZM2ewfft2caNOW1sbFy9ehL6+Puzs7DBgwAB8++23sju/piY+DQuDy7/+hS7jx2PXjz9CLSoKMzt0gP7ly9DJyIDOnj0w27MHwn79gHnzgHffrar+IENbtmzBunXr8PPPP6Nz586tej1J60nVYzt06FB8++23cHZ2bvD5uLg4fPzxx0226lvq2bNn6NGjBy5cuIBx48aJH//vf/+LgwcPNvjJp7GeBlW4hVZ9K9rLy0uiW7MNHbe67Ez1OM2aZVTa4tqauxWjpqYmHkuamppaL8bWHLexbUUiEc6ePYvExET06NEDttbWSH/wAK+ePsWVs2cxd9Ys+Hp4IDYiAlcvXMDnH39cNWO5rEzciEZZGVh5OVhpadVz5eXinnKUlYH352PibcvK/truz/8/+OMPGOnro6u+PvKys1GcmwtNoRCsrAzaamrQ09RERXEx1CsroaE8o4n+GiLSoYP4SzyMpEMHsBqPo8bj4m21tcX/F/3970AjY5wV/RYaV7lUVfNoQ7msY8eObRpDPW/fQu34ceDXX4HLl8UPl6urI3vMGJiuXo0oxhB78SK+++67Bo9bd8hRfHx8vW1bk+9ksa2HhwfCw8PF21bHeuvWLURFReHQoUPYunUr8vLykJ6ejt9++w2xsbHo3r17g8eV2TCA3FwgIgK8oCDgxImqvPsn4fjx+F1HBwJ1dZj17VvvfaUth5VJsi1AQxGkIVWPbVpaGnr37t3o871790ZaWppUAUjKyMgI6urq9XoVXr16Va/3oVqHDh3QoYHyJmpqahLVHJWmLmlbb5ueni6+veTp6YmdO3dKfdzPP/8crq6u+PHHHxEeHo5//vOfDQ54l9e11f2jaUjdciyNxSjtcRvaNj8/HwKBAFlZWXBycoKjoyOSk5MxbNw46OjoIPLMGazesgXrd+7EpEmTsHX/fqg10LCStjRVQ5F+XGNylCEA5xEjsGHDhoYnJ/zZU12zcVyal4dvN2/Gi6wsWJuaYlVAADrweOKGc4P/1m1gN/Rc9f+b27b6q87Qk+pGPQoLJX4tGqO2Zg0g4e9bW/59SrI/V7lUVfNoc7mszX7+jAGJicDu3UBQUNXfAFA1pGDKFODddzHn0CEcP3ECJSUliF27FqdPn8bf/va3Wnmi+rg187yXlxe+/PJLzJgxo1ZeaWm+k9W2tra2iIiIEOcmGxsbhIWF4ebNm7Czs8OkSZOQkpKCCRMmQCgUonv37ti7dy/c3NwwevToJs8hSQw1y25FRESgd+/eVa9fly7A++9XfeXmAgIBcOQIEB8P9QsX8B6A9zp2RFZFBVYMHYrO06ZhSwMTgrl+faspcntEHtu2pi68VA1bdXV1PHv2rNGZs8+ePZNbkXotLS2MGDECsbGxtcaGxcbGwqvGLdn2QhY19NLS0vDDDz8A+KtxrGjaKsYHDx4gJCQEmpqamD9/PqytrWt9igwMDMTf/vY3VFRUICwsDE+ePBHXu62rNbURq9X9+QqFwlrrxtd6HdTUAG3tqq8/ffb113CZNQv//HP/z8LDuZml++eQj2YbyWVlQHUPd93HG3qsrKzR3lplwFUuVdU8ynkue/MG2L8f2LULqDn2e/BgYMEC4L33gD97KM2uXkV4eDhOnTqFSZMmNZknauaB4OBg9OzZE3w+v8V5RR6qb8Pv3LkTpqam6N+/P+7evQsfHx8MGTIEU6ZMwZIlSyAQCDB8+HCEhITg/PnziI6ORlpaGry8vGr1rtfVXEdBzfNXV1Oox9AQWLSo6uvpU/zq7IwFjAEpKbA6fRoHAOSHhSHy9m34h4ZWLVJBlJc0tcEmTpzIPvvss0af//TTT9nEiROlOaRUjh49yjQ1NdnevXvZ3bt32UcffcQ6duzIMjMzJdpfleovyrKOK2OKWxtU3jFWVFSwqKgotn79enbkyBFWVFQkfq7mkrrTp09njFXVYLx06RLr06cP27FjB8vOzq53zNbURqxW9+e7cuVKqV6HuuccPHgw1VdsI5LkGS5zqSrmUc5yWXIyY0uW1K4zq6fHWEAAY1evNlhjvPpve/DgwbUebyhP1MwDQ4YMabIGK5dEIhG7ePEi+/LLL1lgYCDLyclhjFXF/+GHHzIHBwc2e/ZsVlhYKN7nwYMH7KuvvmLffPMNS09Pb/TYcluSPTSUsfPnWZazMytTV6/98/vwQ8YePJD4eJLWBSaSa02ekaphy+fzmYaGBvvpp59YZWWl+PHKykr2448/Mk1NTXb8+HGpg5DGzz//zKysrJiWlhYbPnw4S0xMlHhfRUzIXOKq2L405BljdnY227FjB/vPf/7DLl26xER13oRqNmw//PDDWsl1yZIl7KeffmIbN25kN27cqLWvPBKxtK9DzRiCg4PZmjVr6sXSWDKmJN06kuQZrnOpquVReeSJRv8OhELGIiMZmzSp9sIBdnaM7dzJWH6+RMeXNk8oakdEYWEhO3ToEFu/fj07ceIEq6ioED+3evVqFhISwq5du8a2bdvGVq9eXWvf/Px89uuvv7INGzawuLi4Wn8L1WTRUVBX9e/L8OHDmZ+fHyt++pTdXrqUPe/SpfbPdNo0xk6danYRJEX92SizNmvYMsbY559/zng8HuvUqRMbOnQoGzZsGOvUqRNTU1NrsgdCEShiQiZtTyQSsevXr7ONGzeyn376iT1//rzR7R4/fsweP37MioqK6r1xlpWVsdDQULZ+/Xp2/PhxVlJSwhhTjA8MNXuFasZQ802hsWRMSbp1JM0zyppL20serft38PdVqxjbu5ex/v1rr/41cyZjZ85IvQKktHlCEfJKXWlpaeybb75hX3/9NUtJSan3vLu7e608Wn3nqyahUMjOnDnDvvjiC7Znzx729u3bWs/LMx/Ve02LihiLjWXMw4MxHu+vn/OwYYwdPly10mcD5NH4bu/abOWxalevXsXhw4fx8OFDMMbQp08fvPfeexg9erSsRkjIBa2YU5+0E52UXWlpKSIiIvDHH39g+PDhmDp1qrhuY0v98ccfCA8Ph46ODvz9/cX1BBVBUyviNLaalzKt8qWIpMkzyphL20seFf/eFxUBu3cjZ906GFXXwtXXBwICgNWrAQlWa1M1QqEQCQkJOHfuHHr27AkfHx9x7dmapFmR6/HjxwgKCkJpaSk8PT3FdYirK17UWpGsxntUa97Dmtw3NRX44Qdg716gpKTqMWtr4LPPqsZN15jTQCuPyV6r8ow0reCioiK2cuVKZmZmxrp168Zmz57d4BhDRdVeehqk0Z565x4/fsy+++47tmnTJnb79m2ZHbe4uJgFBASwwYMHszFjxrBTp07VG9bAlaZ6eajHVj4kyTPKnEvbSx79ZPlydnfePMa6dv2r587MjLGtWxnLzeU6PM68efOG7d69m33xxRfs7NmzTeY6aXuZS0pK2LFjx9j69etZWFgYK2+kh7TmMJHx48eLh+1Ikq+k3jcnh7H//Iexbt3++j0wNWVs2zbG/pyToYi96cquzYYifPzxx0xXV5ctXbqUrV69mhkZGTF/f3+pT8qV9pKQpSHtLRRlHH8pEonY2bNn2RdffMF2797N3rx5I/G+ZWVlrKysrMltqhuCBQUFzNHRkZmamjJXV1f28uXL1oYuV40lY0rSrSNJnlHmXKryeTQ/n7FNm5ioxnjLVwYGrGz7dsZKS+VySmXJq7dv32abNm1i3333HXv8+HGT29a8pg8++IDlSvhhoOZQse3bt7MXL17U26bmh++goKBaDdLm3sNavG9REWM//MCYuflfDdzu3ase+3MYGpGdNmvY2tjYsN9++038/eXLl5mGhkaDA74Vkcon5BZQlQkMjcnPz2f/+9//2IYNG9ipU6ek+l2tOXlMKBQ2ul11Mqx+bdLS0tjChQuZvb19g+POiGqTJM8ocy5V2TxaUsLYt9/W7qHt04exQ4cYqzEhSh4UPa82Np+gKdXXJBQK2bZt29js2bPr5dGajd+VK1eylStXihv3WVlZ7JdffmH/+c9/WGJiIvvwww/Fz02bNq3WcSZMmMAYa1nFGGn2ZYxVfbjZtYsxa+vaPfm//NLoGFwivTZr2GpqarInT57UekxbW5s9evRI6hNzQVUTcms+7UvbO6dMg+RTUlLE5WTS0tKk3l/Shm11Aq/5WmRnZzMLCwvWu3dv5uXlxV6+fMl5j4yse4WUpZeprUmSZ5Q5l6pcHq2oYGzPnto9cb17M3bwoNwbtNUUOa8+f/680QowTam+huo86uDgUC+P1mzQCwQC5ufnxxj7q5FZUVHBIiMj2ejRo9nHH3/MiouLWVhYGLO3txfvFxoayuzt7VtUMUbafWspK6uqgmFh8dfvja0tY7/9VlU5g7RKa/KMVBXAhUJhvYk2GhoaSr9uu7KrXhAgIiICLi4uWLduncT76ujo4Pvvv0dERAS+//77ZgfdVxcMB9DihSFKSkqwZs0aeHh4YM2aNSipHpgvI5WVlTh58iQOHz6MHj16YPny5bCxsZHpOWrasmUL4uLi8OjRIwgEAgBAQEAAvv/+exw4cAAdO3bE+PHjMXr06Bb9jKq19nVrze9JWxyvPaFcqgAYAyIiADs7YMkS4MkTwNwc2LMHuHsXmDsX0JBqDaMWk0VelTXGGK5cuYI9e/ZAQ0MDy5Ytw7BhwyReLavmNZ05c6bBSbVpaWnihWd8fHxQ+ufkPE9PT6SmpkJDQwPTp0+Hjo4OjIyMsGPHDtjZ2UFfXx9xcXHw8PBAfHw8YmNjJX4Pq87XLdm3Fi0tICAAJbduge/khLdaWkBaGvDuu8CIEUBcnOTHIjIlVVUENTU1TJs2rdbyiuHh4Zg8eXKtlUOq39wVjarO5m3LWezNzVCVhDxnkL5+/Rp8Ph+vXr2Cq6srxowZI9WyhTWJRCIkJSUBAIYNG9bsSlAffPABXr58idLSUjx+/BjJyckAgOfPn2PEiBFYtWoVpk+fjiFDhoiXf5RGa183Wf+eUPWEhkmSZ5Q5lyp7Hi0pKcH2RYvgFhuLIa9fVz3YtSvwz38CK1bUmu3eljG1Nq/KUnFxMUJDQ/HgwQOMGTMGrq6u0JCykV99TQ8fPkSnTp2watUqjBs3rlYerZnTgoODcfjwYfHKajXz25o1azB+/HiUlJQgJiYG5eXlOHbsmNxWOpXGBx98ABcXF/i4uuJuQAB68vnQqaioetLdHdi6Fejfn9sglVBr8oxUv6nz58+v99jcuXOlOiGRPVksr1tXY2VQqnt4W0Mey18yxpCcnIyoqCjo6+tjyZIlMDU1bfVxpZGVlSVu2K1ZswYCgQC+vr64ePEitLW1cejQIYSGhmLChAmwtraW+vitfd1k/Xsi7fHaW2m5plAu5ciLF0h2dsbH9+6BxxiEmpo4bWcHl7g4wMCAs7BkkVdlJTMzEwKBAJWVlXj33XfRt2/fFh2n+ppqdhDUVXM5XGtra3Tv3h0eHh71lsat3u7hw4fQ0dFBv3798L///Q++vr4w4PDnBgCXLl3Czz//DAAYcOQInO/eRZyTE/DLL0BkJHDiBLB8OfDll0CXLpzG2m7IeFiEQlO5sWF/knScrDRjIuU5mUHWxy4tLWVBQUFs/fr1LDg4uNkqBpKSdIxttZrXdfz4cda/f382YcIEZm9vz44ePcoYY2zbtm3MysqKffPNN/XGWEpz/Ja8brKudtCa1dAUcYKMrKhqnqmmlNdXVlZVpktf/6/xkO+9x1hmpkKNZ+WSUChkcXFxbMOGDWz//v0y+/lKm0clkZWVxbZt28a2bNnC7t69K5NjtpSdnV2tvDZkyJCqJx48YMzL66/fty5dqiaYKcEEUUXQ5gs0KCtlv4XWWtLcypbnbWZZ3nZ7+vQp+Hw+iouL4eHhgcGDBzd7bkl7DaUdilD3ulJSUhAVFVXvtXNzc8PMmTPx/PlzuLi4YNy4cRINl1C025XSai9DF1Q9zyjd9Z06BaxaBTx4AADIMjHB43/8Aw6ffKIyxfRbezckNzcXQUFBePr0KSZOnAgHBweZ3eaXJo9Kcx0lJSUICwvDvXv3MGrUKLi5uUFTU1MmMUuj5hA0bW1tdO/eHdu3b/9rg9Onqxby+OOPqu+HDAF+/hmwt2/zWJVJa/IM9wNUSJupOVC/enB+Q0pKSvD27Vvx+L6wsDCZTmaQdsJaQxhjOH/+PPbu3QtdXV0sW7as2UYtIN2EJx6Ph27duqFbt25NNjyrJ3XNnDkTjDEcP34c33//PXr37o3w8HDY2toiJCQEQNU4ygEDBmDRokUYN24cYmJicPjwYRQWFjYbuyxet7oxy2sCX0MUcYIMUWFPnwLvvAO4ulY1ak1MgP37YZyWBv7Tp/Dw8EBcXFytW97KqjUTOe/evYvAwEDk5+dj4cKFmDBhgkzHrkqaRwHprkNHRwezZs2Ch4cHkpKSsHv3brx69UpmcUvqm2++EU+MMzc3x9atW2tvMGkSkJQE/PQT0LkzkJwMODgAixcDOTltHm+7IOPeY4WmlLfQZEjSW8GrV69mx48fZ2vWrBHfSlekUk4FBQXswIEDbP369SwmJkaq2p/yKKvT2Otafat+6tSpzN7enk2bNq3eLfvU1FS2detW9vXXX7PU1NRWx9LamOWpvSz8oOp5RuGvr7Kyqmi+nl7VLWA1NcY+/JCxt2+5jkxuWpLXysvLWVhYGFu/fj37/fffFeLvsSXXUVxczJYsWcIGDhzIxo4d2+xqaJzKzmZsyZLawxN276byYA1oszq2yk7hE7KcSdqwUOSaig8fPmRff/0127p1a4sags016CQdh1xzu+HDh9d6TtrXq6CggB08eLBFDfWWaupnTPVpW0fV84xCX9/Nm4yNGvVXw2HsWMZu3OA6KrmT9oPqy5cv2fbt29nGjRvZtWvXFKYh2JIP3NX7lJeXs3/9619szJgxTTbUucpvNc+7beZMJhw8+K/f0wkTGLt/v03iUBbUsJWQQidkBaKIk3wqKyvZyZMn2fr169nBgwdZQUFBi47TXOO+7rV/+OGHrKKBIu01t/Pz82MCgUC8T0teL5FIxM6fP8+++OILtmvXLvb69WupjyGNpn7GivjzVyaqnmcU8vpKSxn79FPG1NWrGgqdOjEWGChRT5gqfJCTtNNCJBKxM2fOsLFjx7KBAweyJUuWyOV6676m+fn5DebRhvaT9q5OQyuJbd68mW3bto1lZWXV256r/Fb3vH/78EPGvvmGMV3dqt/ZDh0Y+89/qiY6EmrYSkohE7ICUrRbxq9fv2Y7d+5kX375JTt//rxcexdqJkmhUMgcHBwanM1bt4dzyJAhMnm9njx5wn744Qe2adMmlpyc3OLjNKepn7Ei99grA1XPMwp5fZWVjI0ZU9VA8Pdn7OlTiXdtLx/kiouL2dGjR9no0aPZv/71L/FQhJpDp2TVwK/5moaEhLDZs2fLtCpCY+eqvp63b9+yvXv3sg0bNrCEhIRa562bz4YPH94mH2oazavp6YxNmfJX7+2QIYwlJcktDmXRZiuPEdXR1OQhWU5Saq1bt24hMDAQpaWlWLx4McaPH9/iBRckUXeCU0Or5dTd7tSpU5g4caJMXq8ePXpg2bJl6Nu3LwQCAUJCQlBeXt7i4zWmqZ8xTfIiSkddHdi9GwgLA44fB8zMJN5V0km1yiwrKwuBgYHIzMyEjo4OvvzyS2hqata6XlmuJFj3NX3y5IlMrqMhNVcSq54MaGhoiAULFmDChAlISEjAgQMHkJ+fD6B2fgsODkbPnj3bZPXERvNqz55AdDRw6FDVQiHJycCoUcD69YAccn+7IIeGtsJSyJ4Gjih6L0VpaSkTCARs/fr1LCgoiJWWlkq0X2t7HWr2ZK5evZqdO3euwZ4GefdqFxcXs3fffZf17duXOTk5sTt37jR6XbK+lapoPfbKRtXzjKpdn6LnwtYQCoXs9OnTbMOGDWzfvn0sNze30euV5Z2atuyxbU5GRgb79ttv2ZYtW9i9e/dq5bchQ4Y0ebdKliTKqy9eMObn91fvrZ1d1bjxdoiGIkhI1RJyayjy7eanT5+yH3/8kf33v/9lN6X8o5bVm1RxcTH78MMPmYODA5s9ezYrLCxs0XFaqvo6cnJy2MqVK5mlpSX7+uuvmUgkojGxCk7V84yqXZ+qfpDLzc1l+/btYxs2bGCnT58WNyobu15Z5hFJOwjaSlFRETty5Ahbv349i4yMFI/3bek1y6MzoebxSg8dYszIqKpxq6nJ2ObN7W5hB2rYSkjVEnJrKGJjSCQSsQsXLrAvv/ySBQYGspycHKmPIasG++rVq1lISAi7du0a27ZtG1u9enWLjtNSNeOuqKhg1tbWbP369ezQoUOssLCw1vOK/CGlPVL1PKPq1ydvbTFZ7d69e2zLli3s22+/ZZmZmRLHJY8GvjxWHmsJkUjELl++zP7zn/+wX375hb169arF1yzr988Gj/fyZe2Vy8aPZ6wNS0JyjcbYEqk1NC6JS0VFRThy5AhOnjyJ0aNHY/HixejatavUx5HV+NCaY8QmTJjQ5uPual5HdHQ0evToAVNTUzx79gwffvghunXr1uC2NCaWENmS9WImshzLWldlZSWioqJw9OhRWFlZYcWKFbCyspJoX0WaWyEPPB4Po0ePxpIlSyAUCrFr1y7cu3cP3333ndTXLOtx2Q0ez9gYCA4G9u8H9PWBCxeAf/+7VedpL6hh204pUhJLT0/Hjh078OzZM8yZMwdTpkyBhoYGAOnfVGTVYK/ZWDxz5kybNxbrXkf10pFxcXF4+vQpevTogbi4OAiFQoX7kEKIKpF1Q1Rek9Wys7Oxe/du3LhxA+7u7njnnXdUrnHaGtXvJUuWLMH9+/fRp08fhIWFgc/no7S0VKpjybozodHj8XjAggXArVuAvz+g5Es/txUeY4xxHURbUbo1zlWcUCjE6dOncf78efTs2RM+Pj7Q19evtc2aNWvg4uICT0/PNl3XvXrN8tu3b8Pa2hrbt28Hj8fD2rVr8fDhQ/HvUJ8+faRel721GGO4cOEC4uLiYGZmBj8/P3Tu3LnNzk+apup5RtWvry4PDw9EREQ0+r20ZJ3TGGO4ceMGTpw4AUNDQ/j7+8PExKTFx5M1xhiysrIAAFZWVnKtatOUhl73pUuXIjw8HNra2vDz84OFhYVExyopKcG6deuQmpqKXr16YfPmza1e4lyWx1MFrckz1LAlnHj79i2CgoLw7NkzTJ48Gfb29g0mPFm/qbRGzcQYEhKChIQEODs7t1lju64nT54gKCgIxcXF8PT0xKBBg9o8BlKfqucZVb++umTdEJVVI6akpAQff/wxLl68CE1NTXzyySfw8vKCpqZmi2NTZY29l+Tm5oLP5+PZs2eYNGkSHBwcOGt8k7+0Js/QUATS5v744w8EBgaiqKgIixYtajKRKNL40Zq3EL29vZGamspp3Utzc3MsW7YMvXv3Bp/PR1hYmFxq3hLSnsl6qI+shoF98MEHKCsrw6xZs/D+++/j3Llz1KhtQmPvJYaGhli4cCHs7e0RHx+PgwcPoqCgQObnb8lYbVmP724vqMeWtJny8nJER0cjKSkJgwYNgoeHB7S1tZvch+tbNCKRCACgpqbWJj221UMg0tLSYGtrK9EwB8YYbt68iaioKBgYGMDf3x/du3eXSTxEeqqeZ1T9+hSdSCTCuXPnsHTpUnz66afw8/ODoaEhp3ezmlMzj3JFkveSjIwMCAQCCIVCeHt7o0+fPjI7f0t6/rkaiqcIaCiChCghc+fFixfg8/nIy8vD9OnTMXToUJne7mlJg7A5IpEISUlJAIBhw4ahrKwM69atQ0pKCvLz86Gvr4++ffvKtLHdmkSWk5MDPp+P7OxsuLm5YfTo0XRLjQOqnmdU/foUWX5+PoKDg5GZmYnk5GTMnz8fXl5eLW70yCNv1lU3j3LZuJVEUVERQkNDkZKSgrFjx8LFxUU8mbk1WjKsTpGG4rU1GopAFBZjDJcvX8bu3buhoaGBZcuWYdiwYTJvcMmzhE616luIUVFROHfuHKKjo2VeUaI1M6aNjIywZMkSjBw5EtHR0Th69CiKi4tlFhshhDspKSkIDAxETk4O3n//fRw+fBinT59u1RCJtsibyqZjx4549913MXXqVFy9ehV79+7F69evW33clgyrU6SheMqEGrZEboqLi3H06FFER0dj5MiRWLJkCYyMjORyLkVZ7721Y6Jam8g0NDQwbdo0vPvuu3j8+DF27NiBjIwMqY5BCFEclZWViI6OxpEjR2BhYYEVK1agZ8+eMhmrqyh5U9HweDyMHTsWS5YsQXl5OXbu3ImbN2+iNTe4WzJWm0o5tgwNRSBykZmZiaCgIAiFQnh5eaFv375yPZ88xiK15BZaU3FIcttPlmOK8/PzIRAIkJWVBUdHR0ycOFHhbwOqAlXPM6p+fYpE3sOL2mIMZ0NDuuQ9/EGWas4NGTx4MDw8PNChQweuw1J5NMZWQpSQ5U8kEiEhIQFnz56FlZUVfH192+S1bkmDsLmGZksatk2NieJiIkD1RJOEhAT06NFDPNGEyI+q5xlVvz5F0FYTQtticm7dPPq3v/1NKSdE3b59GxEREdDV1YW/vz969OjBdUgqjRq2EqKELF+5ubkICgrC06dPMXHiRDg4OCh0D2FzDU1Z99hyORHg8ePH4PP5KCsrw4wZMzBgwIA2OW97pOp5RtWvj2ulpaWIjIzE7du3MWzYMEybNg1aWlpch9VidfPojBkzlHZC1Nu3b8Hn8/H8+XM4Oztj/PjxNEFXTmjyGOHc3bt3ERgYiIKCAixcuBATJkxQ6EYtIJ/xZU2NieJyIoCFhQWWL18OGxsbHDt2DOHh4aioqGiz8xNCmvfkyRPs3LkTKSkp8Pf3h5eXl1I3ahuizBOiOnfujEWLFmH8+PGIjY3FoUOHUFhYyHVYpA7qsSWtUlFRgRMnTuD69esYOHAgPD09m61Nqygk6bHNzMwEAFhbW7e6oc51TV5A8ZffVAWqnmdU/fq4wBjD+fPnER8fDyMjIyQnJ+Pp06dKMQa1OXXzaHXZRGVfPjYtLQ3BwcFgjMHHx0epGujKgIYiSIgSsmy9fPkSfD4fubm5mDp1KoYPH65Ut2UUoaHJlezsbPD5fLx+/RpTpkzByJEjlepnp8hUPc+o+vW1tYKCAgQHByMjIwMODg4ICQmBm5ub0o1BbY+KiooQHByM1NRUjB8/Hs7OzlBXV+c6LJVADVsJUUKWDcYYzp07h08//RSFhYUYO3Ysfvzxx3bTKFQVFRUViI2NxZUrV9C/f3/MmDGDfoYyoOp5RtWvry09fPgQISEh4PF48PX1hY2NTbsuyq+MGGO4ePEi4uLiYGJiAn9/f3Tp0oXrsJQejbElbaakpATHjh3Dxx9/DFdXV9y4cQMzZsygwt5KSFNTE9OnT8fs2bORmZmJHTt2ICsri+uwCFF5lZWVOHnyJA4fPgwzMzOsWLECNjY2AJR7DGp7xOPxMH78eCxevBilpaUIDAzErVu3uA6rXaMeWyKxrKwsBAUFoaKiAtHR0UhISBA/p4q9Csq2FGRr5OXlQSAQ4NGjR3ByclKKyX+KStXzjKpfn7y9fv0afD4fr169gqurK8aMGVNrGJCqDZFqT3m0rKwMkZGRuHXrFoYMGYLp06dTzdsWak2eaf0CyETliUQinDlzBomJibC0tISfnx+ePXuG8PBw8Tgw6lVQbgYGBpg/f77455yRkQFfX18YGBhwHRohKiM5ORmRkZHQ19fHkiVLYGpqWm+b6hXFiPLp0KEDfH19YWtri8jISDx58gR+fn4wMzPjOrR2hXpsSZNq9uRNnDgRjo6OUFNTU7lehYa0p56Gmmr2zHt5eaFfv35ch6RUVD3PqPr1yUPNnryhQ4di2rRp7aYnr73m0Zo98y4uLhg7dixN0JUCTR6TECVk6dy7dw9hYWHQ0tKCr68vrKysuA6pTbXXhAxU3Q4NDQ3F/fv3MWrUKLi5uUFTU5PrsJSCqucZVb8+WXv27Bn4fD4KCwvh4eEBOzs7rkNqU+05jwqFQpw6dQoXL15E79694e3tjY4dO3IdllKgoQhEpioqKhATE4OrV6/SbPl2SkdHB++88w6uXbuGkydPIisrC/7+/jA2NuY6NEKUQt3Z8nPnzqXZ8u2Muro6pkyZAhsbG4SEhGDHjh3i6hdEfpTio1NmZiYWL16Mnj17QkdHB7a2tli/fj3Ky8u5Dk3lZGdnY8+ePUhKSoKHhwdmzZpFjVo5KSkpwZo1a+Dh4YE1a9agpKSE65Bq4fF4GDVqFJYuXQrGGHbv3o3r16+jHd3kUSmUR9tOYWEhDh8+jJiYGIwdOxaLFy+mRm071rt3byxfvhzGxsY4ePAgTp06BaFQyHVYKkspemzv378PkUiEnTt3olevXvjjjz+wdOlSFBUV4ZtvvuE6PJVQd0WqgIAA6p2Ts7Vr18LFxQU//PADwsPDsW7dOoWcNGJiYoKAgACcPHkS4eHh4qWI6QOPcqE82jZqrkg1d+7cdjmxtqSkBGvXrkVaWhpsbGzwzjvvKM2KlPKir6+PefPmiVeYy8zMhJ+fHzp37sx1aCpHacfYbt26FTt27EB6enqj25SVlaGsrEz8fX5+PiwsLGhsWB0lJSUIDw/H3bt3MWLECEydOpXGU6JqbFj175eNjY3Mx4YpYyH2u3fvIiwsDB06dIC/vz8sLCy4DknhKNMYVMqjsiMUChEfH4/z58/D1tYWPj4+0NPT4zosTtRcrjw0NBTBwcH4v//7P7nkUWX05MkTBAUFobi4GJ6enhg0aBDXISmcdrlAQ15eXrO3djZv3gwDAwPxF70J1/f48WMEBgYiPT0ds2bNgqenJzVq/6SmpoZevXqhV69ecknGyliIfcCAAVi+fDkMDAywf/9+nDlzBiKRiOuwSAtRHpWNt2/fYt++fbh48SJcXV0xd+7cdtuoBSC+qwMAXl5eyMnJkVseVUbm5uZYtmwZ+vTpAz6fj9DQUBoSJENK2WOblpaG4cOH49tvv8WSJUsa3Y56GhonEolw7tw5JCQkwNzcHL6+vjA0NOQ6rHZFmUumiUQiJCYm4syZM7C2toaPj0+7/5uqpiw9tpRHZeP27duIiIhAx44d4efnhx49enAdEudq9tiGh4cjLi5OIYdZcY0xJq5tbGBgAH9/f3Tv3p3rsBSC0pb72rBhA7744osmt7l69SpGjhwp/v7Zs2dwcnKCk5MT9uzZI9X5lOUNR97y8/MRHByMzMxMTJgwAU5OTvRJmrRIZmYmBAIBKisr4eXlhb59+3IdEufaOs9QHuVGeXk5oqKicPPmTdjZ2cHd3b3d1KZtjjJ/aOdCTk4O+Hw+srOz4ebmhtGjR7f7mrdK27DNyclBTk5Ok9tYW1uLB50/e/YMkyZNwpgxY/Drr79K3RijhAw8ePAAoaGh0NDQgK+vL6ytrbkOSWGJRCIkJycDAIYMGUKN/0YUFxcjNDQUDx48wJgxY+Dq6goNDaWYlyoXbZ1nKI+2vefPn4PP56OgoADTp0/HkCFD2n1DpDGURyVTWVmJU6dO4dKlS+jTpw+8vb2hq6vLdVicUdo6tkZGRjAyMpJo26dPn2LSpEkYMWIE9u/fT38cUqqsrERsbCwuX76Mvn37wsvLq13/0UiKxo82T1dXF7Nnz8aVK1cQExMjrnkr6d82aR3Ko22HMYbLly8jNjYWxsbGWLZsGbp27cp1WAqP8mjzNDQ0MHXq1Ho1b3v27Ml1aEpHKbpVnj17hokTJ8LS0hLffPMNsrOzxc/ReJTmVd/myMnJwfTp0zFq1CjqXSAyxePxMGbMGFhZWYHP52Pnzp2YPn06hg4dSr9rCoLyaOsUFRUhNDQUKSkpGDduHJydndv1nQkiH3369MHy5cshEAhw4MABODo6YuLEifQhVApK8VcZExOD1NRUpKamwtzcvNZzSjj3rc0wxpCUlITo6GgYGBhgyZIl9AZG5Kp79+4ICAjAiRMnEBoairS0NHh4eLT7GpaKgPJoy2VkZEAgEEAoFGLOnDno3bs31yERFdapUye8//774gneGRkZ8PPzowneElLKqggt1Z7GhpWWliIiIgJ//PEHhg8fjqlTp0JLS4vrsJRKe17jXBb++OMPhIeHQ1dXF35+fvUaU6pK1fOMql9fTUKhEAkJCTh37hx69uwJHx8f6Ovrcx2WUqE82jqPHz9GUFAQSktL4enpiYEDB3IdUptQ2jG2RD6ePHkCPp+PkpIS+Pv7U/FnwolBgwahR48eCAoKwr59+zB58mTY29vT0ASiFN6+fYugoCA8e/YMzs7O9LtLOGFhYYHly5cjLCwMx48fR3p6Oi2i1Axq2KoQxph4uT4zMzPMnz+flusjnOrcuTMWLlyI06dPIy4uDunp6dTrRRTenTt3EBYWBh0dHSxatKjd3G0giklbWxszZ84UL3v/6NEj+Pv7w8TEhOvQFBI1bFVEQUEBgoODkZGRAQcHB0ycOBHq6upch6X0qAHWeurq6nBxcYGNjQ0EAgECAwPh7e1N4xSJwikvL8eJEydw48YNDBo0iMaHywjl0dbj8XgYMWIELC0twefzsXv3bkyZMgUjR46kOwl10BhbFfDw4UMEBwdDXV0dPj4+sLGx4TokQhpUVFSEkJAQPHz4UGVnlqtqnqmmqtf34sUL8Pl85OXlUUUPotAqKioQGxuLK1euoF+/fvDy8lK5BTCUdoGGtqZqCbmyshJxcXG4ePEievfuDW9vb3Ts2JHrsAhpUt1aoP7+/ipVC1TV8kxdqnZ9jDFcvXoVMTExMDIygp+fH7p168Z1WKSdKSkpwdq1a5GWlgZbW1ts2bKl2cbq/fv3ERoaCk1NTfj5+cHKyqqNopU/athKSJUS8uvXr8Hn8/Hq1Su4urpizJgx1LtAlErN1Zvc3d0xZMgQrkOSCVXKMw1RpeujVfOIolizZg1cXFzg6emJ8PBwxMXF4fvvv292v/z8fAQFBeHRo0dwcnLChAkTVKLyBDVsJaQKCZkxhuTkZERFRUFfXx/+/v4wNTXlOiyVJBKJcPv2bQDA4MGDVSJZKJry8nJERUXh5s2bsLOzg7u7Ozp06MB1WK2iCnmmKapyfZmZmRAIBKisrISXlxf69u3LdUgqifKoZDw8PBAREdHo900RiUQ4e/YsEhISYGlpCV9fXxgYGMgr1DZB5b7aibKyMkRGRuLWrVsYOnQopk+fTrVp5ayyspLrEFSalpYWvL29YWNjg8jISDx58gT+/v4wMzPjOjSiokQiERITE3HmzBlYWVnB19dXqRvoyoDyaPNsbW0RHh4u7rHt1auXxPuqqanByckJPXv2RFBQEAIDAzFjxgz0799fjhErLuqxVRJPnz4Fn89HcXEx3N3dYWdnx3VIKo8Ki7etN2/eICgoCC9evICzszPGjRunlMNrlDnPSEKZry83NxcCgQBPnjzBxIkT4eDgQH/XckZ5VDIlJSVYt24dUlNT0atXL2zevLlFE8JKSkoQFhaGe/fuYdSoUXBzc1PKmrfUY6vCGGO4cOEC4uLiYGpqinnz5qFLly5ch0WIzHXp0gWLFi1CfHw8YmJikJ6eDm9vb+jp6XEdGlEBd+/eRVhYGDp06ICFCxfCwsKC65AIEdPR0ZFoTK0kx5k1axauX7+OEydOICsrC/7+/jA2Nm59kEqCGrYKrLCwECEhIUhNTYW9vT0mT55MtWmJSlNXV4erq2utmrc+Pj6wtbXlOjSipCoqKnDixAlcv34dAwYMgKenp8qVRiKkJh6Ph5EjR9aqeTt16lQMHz5cKe+CSYsatgoqNTUVwcHB4PF4mDdvHr2xk3bF1tYWK1asQHBwMA4ePEgf7EiLvHr1Cnw+H2/fvoWnp2e7eWMnBACMjY2xdOlSnDx5EuHh4UhLS2sXH+yoYatghEIh4uLicOHCBfTq1YtuxZJ2S09PD3PnzsXFixdx6tQpZGZmws/Pj4bikGYxxnDt2jWcPHkSXbp0QUBAANWmJe2SpqYmPDw8YGNjg7CwMAQGBsLPzw+WlpZchyY31LBVIDUnz7i5uSnt5BlVoqury3UI7RqPx8P48eNhZWWFoKAg7Ny5kyZPkiapyuQZVUJ5lHsDBgxAjx49EBQUhF9//VWlJ09SVQQFcevWLUREREBPT4/KHRHSAGUpd6fIeUYWFPn6srKyIBAIUF5e3q7LHRHSGGUpd0cLNEhIEROyKhaoJ0ReGGO4desWIiMjFXaBEkXMM7KkiNcnEolw5swZJCYmqkyBekLkqXqBkoqKCnh7eyvcAiXUsJWQoiVkVV1SlBB5q7mktIuLC8aOHasww3YULc/ImqJdn6ouKUqIvCnyktLUsJWQoiRkxhguX76M2NhYGBsbw9/fH127duUsHtIwkUiEO3fuAAAGDhxIb5YKprKyEnFxcbh48SJ69+4Nb29vdOzYkeuwFCbPyIsiXd/9+/cRGhoKTU1N+Pn5wcrKitN4SH2URxUbYwxXr15FTEwMjIyM4O/vDyMjI67DogUalElRURFCQkLw8OFDjBs3Ds7OzgrzCYnUV15eznUIpBEaGhqYMmUKbGxsEBISIq55a2Njw3VoRM4qKysRExODK1euoF+/fpgxYwZNUFJglEcVF4/Hw+jRo8U1b3fu3Ilp06Zh2LBhCnMXTFrUompD6enpCA4Ohkgkwpw5c9C7d2+uQyJE6fXu3RvLly8X17x1cHDAxIkTqeatisrOzgafz8fr16/h7u6OkSNHKu0bMCGKonv37ggICMCJEycQFhaG9PR0eHh4QFtbm+vQpEYN2zYgFAqRkJCAc+fOoWfPnvDx8YG+vj7XYRGiMvT19TFv3jycP38e8fHxyMjIgJ+fHzp37sx1aERGGGO4ceMGTpw4AUNDQyxduhQmJiZch0WIytDS0sKMGTNga2uL8PBwBAYGwt/fH+bm5lyHJhVq2MrZ27dvERQUhGfPnsHZ2Rn29vbUu0CIHPB4PDg4OMDa2hp8Ph+BgYGYMWMGBg4cyHVopJVKS0sRHh6OO3fuYMSIEZg6dSrVpiVETgYOHAgzMzMEBQVh3759mDRpEhwcHJSm7UINWzm6c+cOwsLCoKuri0WLFindpx5ClJG5uTmWL1+OiIgIHD9+HGlpaZg6dapC1rwlzXv8+DGCgoJQWlqKmTNn0gcVQtpA586dsXDhQiQkJIjvginL3WZq2MpBeXk5Tpw4gRs3bmDQoEFKO06FEGWlra0NPz8/2NraIioqCo8ePYK/vz+6d+/OdWhEQiKRCOfOnUNCQgJ69OiBBQsWwNDQkOuwCGk31NXV4ezsjJ49eyI4OBg7duyAj4+Pws8PooatjL148QJ8Ph95eXnw8vLC0KFDlab7ntRHH0iUF4/Hw7Bhw2BhYQE+n489e/bAzc0No0aNor9JBZefn4/g4GBkZmbC0dERTk5ONBlQiVEeVW42NjZYvnw5QkJCcPjwYYwdOxYuLi4KW9GJ6tjKCGMMV65cQUxMDLp166YwteAIIVXloWJjY3H58mX07dsXXl5ecisPpUh1XuVB3teXkpKCkJAQqKurw9fXFz179pT5OQgh0mvLGvy0QIOE5JWQFXn1DkLIXx48eIDQ0FBoaGjA19cX1tbWMj8HNWxbpuaHjz59+sDb25tq0xKigGqumjp9+nQMGTJE5nfBqGErIXkk5MzMTAQFBUEoFMLLy0vh1lsmhNSWn58PgUCArKwsTJgwAU5OTjJdDYkattLLyckBn89HdnY23NzcMHr0aBouQogCKy8vR1RUFG7evAk7Ozu4u7ujQ4cOMjs+rTzGAZFIhISEBJw9exZWVlbw9fVVyTex9kwkEuHevXsAgP79+9NSkCqiU6dOeP/998UTk6pr3hoYGHAdWrvDGMPNmzcRFRWFTp06YcmSJTA1NeU6LCJDlEdVk5aWFry9vWFjY4PIyEg8fvwY/v7+6NGjB9ehUcO2JXJzcyEQCPDkyRNxfTf6Y1VNpaWlXIdA5EBNTQ0TJkyAtbU1goKCsGPHDsyYMQMDBgzgOrR2o7S0FJGRkbh9+zaGDRuGadOmUUk2FUV5VHXZ2dnB3NwcfD4fe/fuhbOzM8aPH8/pHRdq2Erp7t27CAsLQ4cOHbBgwQJYWlpyHRIhpIUsLS2xfPlyhIeH49ixYxg5ciSmTJlCxf/l7OnTp+Dz+SguLoafnx8GDx7MdUiEkBbq0qULFi9ejPj4eMTGxiIjIwPe3t7Q09PjJB5q2EqooqICJ06cwPXr1zFgwAB4enpCR0eH67AIIa2ko6ODmTNn4vr16zhx4oS45q2xsTHXoakcxhguXLiAuLg4mJqa4v3336dljwlRAerq6nB1dYWNjY245q2vry9sbW3bPBa6fy6Bly9fYteuXbh16xY8PT0xc+ZMatQSokJ4PB5GjhyJgIAAAMCuXbtw7do1tKO5tXJXWFiIQ4cOITY2FuPHj8eiRYuoUUuIirG1tcXy5cthamqKgwcPIiYmBkKhsE1joB7bJjDGcO3aNZw8eRJdunRBQEAAunXrxnVYhBA5MTY2xtKlSxETE4OIiAikpaVhxowZ9EG2lVJTUxEcHAwej4d58+Zx0otDCGkbenp6mDNnDi5evIi4uDhkZmbC398fXbp0aZPzU8O2ESUlJQgLC8O9e/cwatQouLm50bg7QtoBTU1NuLu7w8bGBmFhYQgMDISvry+srKy4Dk3pCIVCnDp1ChcvXkSvXr3g4+ODjh07ch0WIUTOeDwexo8fD2tra/D5fOzcuRPu7u6ws7OT+7mpYduArKwsBAUFoaKiAu+88w769+/PdUiEIzRLu/3q378/zMzMIBAI8Ouvv2LixIlwdHSkCigSev36NYKCgvDy5UtMmTIFY8eOpdq07RTl0fbLzMwMy5YtQ2RkJAQCAdLS0uDu7i7X3wlaoKEGkUiEM2fOIDExEZaWlvD19aXaloS0c3Xzgp+fX5M1q2mBBiA5ORmRkZHQ09ODv78/zMzM2jhKQoiiqc4L+vr68Pf3b7JmNa08JqGmXqi8vDwIBAI8evQITk5OmDBhAvXMEELEat7J8fLyQr9+/Rrcrj03bMvKyhAZGYlbt25hyJAhmD59ukxXIyKEKLfXr1+Dz+fj1atXcHFxafRODjVsJdTYC3X//n2EhoZCU1MTfn5+NJaOENKg4uJihIWF4f79+xg9ejTc3NygoVF7RFd7bdg+e/YMfD4fhYWF8PDwaJOxdIQQ5VNZWYm4uDhcvHgRvXv3hre3d72x99SwlVDdF6qiogIxMTG4evUq+vXrBy8vL5r9TMREIhEePHgAAOjbty/14BMAtauldO3aFf7+/rWqpbS3hi1jTDz72cTEpE1nPxPFR3mUNObhw4cICQkBj8eDr68vbGxsxM+1Jo8q3W9YWVkZhg4dCh6Ph5s3b7b4ONnZ2dizZw+SkpLg7u6Od955hxq1pJ7i4mIUFxdzHQZRIDweD6NGjcLSpUshEomwa9cu3LhxQ6lq3soqjxYWFuLw4cOIiYnBmDFjsHjxYmrUknooj5KG9O7dG8uXL4exsTEOHjyIuLg4mdS8VbqqCJ9++inMzMyQnJzc4mMkJSXh3LlzMDQ0xNKlS2FiYiLDCAkh7YGJiQkCAgJw4sQJhIWFIS0tDZ6enlyHJRFZ5NH09HScOnUKjDHMnTsXvXr1kmGEhJD2QF9fH/PmzcP58+cRHx+PjIwM+Pn5QV1dvcXHVKoe2+joaMTExOCbb75p1XFOnDgBOzs7BAQEUKOWENJimpqa8PT0xKxZs5CWlobAwEA8efKE67CaJKs8+vvvv8PExAQrVqygRi0hpMV4PB4cHBywaNEiFBUVITAwEHfv3m3x8ZSmx/bly5dYunQpQkJCoKurK9E+ZWVlKCsrE3+fn58PAPDx8cHo0aPlEichpP0ZMGAAzMzMEBQUhEOHDnEdTqNkmUcnTZoEV1dXqk1LCJEJc3NzLFu2DBEREQgNDW3xcZSix5YxhgULFmD58uUYOXKkxPtt3rwZBgYG4i8LCwsAaLRMDyGEtJShoSEWLlyIcePGcR1Kg2SdR2nBBUKIrGlra8PPzw/Tp09v8TE4bdhu2LABPB6vya9r167hp59+Qn5+PtatWyfV8detW4e8vDzx1+PHj+V0JYQQAqipqcHJyalNz0l5lBCiSng8HoYMGdLy/bks95WTk4OcnJwmt7G2tsbs2bMRHh5eq3dAKBRCXV0dc+bMwf/+9z+JzqfqZXiIbIlEIty+fRsAMHjwYCpTQyTS1nmG8ihRZJRHSUuofB3bR48eicd1AVWFwKdMmQI+n48xY8bA3NxcouNQQiaEyJui5hnKo4QQZdGaPKMUk8csLS1rfa+npwcAsLW1lTgZE0JIe0Z5lJD/Z+++w5o827+Bf8OUraLgQGS5RdyKEwRRGTKtWidO1Cq+fTrU9qnVtmqrbfXXIbirPtbWsHGAgmDdqLgHAgKuOlD2Tq73D0pKJECAkDsJ5+c4OJTkHucd4MyZ674GaQnongAhhBBCCFEJStFi+y4LCwulWuWHKCehUIjU1FQAgI2NDfUNIyqF8iiRB8qjRN6UsrAlRF7y8/O5DoEQQpQa5VEiT/TRiRBCCCGEqAQqbAkhhBBCiEqgwpYQQgghhKgEKmwJIYQQQohKoMKWEEIIIYSoBJoVgZA60NQ0hBDSNJRHiTxRYUtILdTU1DBgwACuwyCEEKVFeZTIG32MIoQQQgghKoEKW0IIIYQQohKoKwIhtRAKhUhPTwcAWFlZUT8xQghpIMqjRN6osCWkDrm5uVyHQAghSo3yKJEn+uhECCGEEEJUAhW2hBBCCCFEJVBhSwghhBBCVAIVtoQQQgghRCVQYUsIIYQQQlRCi5oVgTEGAMjLy+M4EqIMhEIhCgoKAFT+ztA0NUQaVfmlKt+oGsqjpCEoj5LGaEoebVGFbXZ2NgCgS5cuHEdCCFF12dnZMDIy4joMmaM8SgiRl8bk0RZV2LZt2xYAkJWVpZJvOI2Vl5eHLl264PHjxzA0NOQ6HIVCr41k9LrULjc3F+bm5qJ8o2ooj0pGfxO1o9dGMnpdateUPNqiCtuqWyBGRkb0SySBoaEhvS61oNdGMnpdaqeqt1wpj9aN/iZqR6+NZPS61K4xeVQ1My8hhBBCCGlxqLAlhBBCCCEqoUUVttra2li7di20tbW5DkWh0OtSO3ptJKPXpXaq/tqo+vU1Fr0utaPXRjJ6XWrXlNeGx1R1ThpCCCGEENKitKgWW0IIIYQQorqosCWEEEIIISqBCltCCCGEEKISqLAlhBBCCCEqgQpbQgghhBCiElp8YVtaWor+/fuDx+Ph+vXrXIfDqYyMDMyfPx+WlpbQ0dGBtbU11q5di7KyMq5D48Svv/4KS0tLtGrVCoMGDcJff/3FdUic27hxI4YMGQIDAwOYmJjAy8sLDx484DoshbNx40bweDysXLmS61DkgvKoOMql/6I8WhPlUek0No+2+ML2k08+QadOnbgOQyHcv38fQqEQwcHBuHPnDn788UcEBQVhzZo1XIcmd3/88QdWrlyJzz77DMnJyRg9ejQmTZqErKwsrkPjVGJiIpYtW4aLFy/i5MmTqKiogIuLCwoLC7kOTWEkJSVhx44d6NevH9ehyA3lUXGUSytRHpWM8mj9mpRHWQt27Ngx1rNnT3bnzh0GgCUnJ3MdksL57rvvmKWlJddhyN3QoUNZQECA2GM9e/Zkq1at4igixfTy5UsGgCUmJnIdikLIz89n3bp1YydPnmRjx45lgYGBXIfU7CiPSqcl5lLKo9KhPCquqXm0xbbYvnjxAgsXLsSBAwegq6vLdTgKKzc3F23btuU6DLkqKyvD1atX4eLiIva4i4sLzp8/z1FUiik3NxcAWtzvSG2WLVsGNzc3ODs7cx2KXFAelV5Ly6WUR6VHeVRcU/OohozjUQqMMcydOxcBAQEYPHgwMjIyuA5JIaWlpeGnn37C999/z3UocvX69WsIBAKYmpqKPW5qaoq///6bo6gUD2MMH374IUaNGoW+fftyHQ7nDh8+jGvXriEpKYnrUOSC8qj0WmIupTwqHcqj4mSRR1WqxfbLL78Ej8er8+vKlSv46aefkJeXh9WrV3MdslxI+7pU9+zZM0ycOBFTpkzBggULOIqcWzweT+x7xliNx1qyDz74ADdv3sTvv//OdSice/z4MQIDA3Hw4EG0atWK63CahPJo7SiXNhzl0bpRHv2XrPIojzHGZBgXp16/fo3Xr1/XuY2FhQWmTZuGqKgosT8ugUAAdXV1zJgxA7/99ltzhypX0r4uVb9Iz549g6OjI4YNG4Z9+/ZBTU2lPv/Uq6ysDLq6ujhy5Ai8vb1FjwcGBuL69etITEzkMDrFsHz5coSHh+PMmTOwtLTkOhzOhYeHw9vbG+rq6qLHBAIBeDwe1NTUUFpaKvacIqM8WjvKpdKjPFo/yqPiZJVHVaqwlVZWVhby8vJE3z979gwTJkwAn8/HsGHDYGZmxmF03Hr69CkcHR0xaNAgHDx4UGnejGVt2LBhGDRoEH799VfRY71794anpyc2btzIYWTcYoxh+fLlCAsLQ0JCArp168Z1SAohPz8fmZmZYo/5+/ujZ8+e+PTTT1XyFiPl0bpRLqU8WhvKo5LJKo+2yD625ubmYt/r6+sDAKytrVt0Mn727BkcHBxgbm6OLVu24NWrV6LnOnTowGFk8vfhhx9i1qxZGDx4MOzt7bFjxw5kZWUhICCA69A4tWzZMhw6dAgREREwMDAQ9ZUzMjKCjo4Ox9Fxx8DAoEbS1dPTg7GxsUoWtQDl0bpQLq1EeVQyyqOSySqPtsjClkgWGxuL1NRUpKam1nhjamkN+1OnTkV2djbWr1+P58+fo2/fvjh27Bi6du3KdWic2r59OwDAwcFB7PG9e/di7ty58g+IEAVEubQS5VHJKI82rxbZFYEQQgghhKieltOTnRBCCCGEqDQqbAkhhBBCiEqgwpYQQgghhKgEKmwJIYQQQohKoMKWEEIIIYSoBCpsCSGEEEKISqDClhBCCCGEqAQqbAkhhBBCiEqgwpa0KHPnzgWPxwOPx4OmpiasrKzw0UcfobCwULRNSEgIHBwcYGRkBH19ffTr1w/r16/HmzdvAADPnz/H+++/jx49ekBNTQ0rV67k6GoIIYQblEuJoqLClrQ4EydOxPPnz5Geno6vv/4av/76Kz766CMAwGeffYapU6diyJAhOH78OG7fvo3vv/8eN27cwIEDBwAApaWlaN++PT777DPY2dlxeSmEEMIZyqVEEdGSuqRFmTt3LnJychAeHi56bOHChYiOjkZERASGDRuGrVu3IjAwsMa+OTk5aN26tdhjDg4O6N+/P7Zu3dq8gRNCiAKhXEoUFbXYkhZPR0cH5eXl+N///gd9fX0sXbpU4nbvJmJCCCH/olxKFAEVtqRFu3z5Mg4dOgQnJyc8fPgQVlZW0NTU5DosQghRKpRLiaKgwpa0ONHR0dDX10erVq1gb2+PMWPG4KeffgJjDDwej+vwCCFEKVAuJYpIg+sACJE3R0dHbN++HZqamujUqZOoVaF79+44e/YsysvLqaWBEELqQbmUKCJqsSUtjp6eHmxsbNC1a1expPv++++joKAAv/76q8T9cnJy5BQhIYQoPsqlRBFRiy0h/xg2bBg++eQT/Oc//8HTp0/h7e2NTp06ITU1FUFBQRg1apRohO/169cBAAUFBXj16hWuX78OLS0t9O7dm8MrIIQQ7lEuJVyi6b5IiyJpipp3/fnnn/jll1+QnJwMoVAIa2tr+Pn5Yfny5aLRvJL6j3Xt2hUZGRnNEzghhCgQyqVEUVFhSwghhBBCVAL1sSWEEEIIISqBCltCCCGEEKISqLAlhBBCCCEqgQpbQgghhBCiEqiwJYQQQgghKoEKW0IIIYQQohKosCWEEEIIISqBCltCCCGEEKISqLAlhBBCCCEqgQpbQgghhBCiEqiwJYQQQgghKoEKW0IIIYQQohKosCWEEEIIISqBCltCCCGEEKISqLAlhBBCCCEqgQpbQgghhBCiEqiwJVK7efMm/P39YWlpiVatWkFfXx8DBw7Ed999hzdv3gAAHBwcwOPxYGVlBcZYjWOcOXMGPB4PPB4P+/bta9Q5qgiFQhw4cADOzs5o164dNDU1YWJiAnd3d0RFRUEoFEp1XXl5efjmm28wePBgGBoaQltbGxYWFpg3bx6uXbsm2m7fvn2i2BMSEmochzEGGxsb8Hg8ODg4iB5//vw5Pv/8c9jb26Ndu3YwNDTEoEGDsGPHDggEAqliBIB79+5h1qxZsLKyQqtWrdCuXTsMHDgQH3zwAfLy8kTbzZ07VxQnj8eDlpYWrK2t8dFHH4ltV8XCwkJs+6qvgIAAqWMjhDRNQ/LrxIkTa+yfkZEBHo+HLVu2iB5LSEgQ+5tWV1dH+/bt4eHhgStXrtQ4RlXuMDAwQEFBQY3nMzMzoaamBh6Phy+//LLea6qKqbav6sdgjOHw4cMYPXo0TExM0KpVK5iZmWHChAnYtWuX2HGr9p87d67E865fv160TUZGhujxXbt2wcvLCxYWFtDR0YGNjQ2WLFmC58+f13stVaKjozF79mzY2tpCU1MTPB5P6n2JfGhwHQBRDjt37sTSpUvRo0cPfPzxx+jduzfKy8tx5coVBAUF4cKFCwgLCwMAGBgY4NGjR4iPj4eTk5PYcfbs2QNDQ0OJBVZDzlFSUgIvLy/ExsZi2rRp2L59Ozp06IBXr17hxIkTmDJlCv744w94enrWeV1paWlwcXHBy5cvERAQgHXr1kFfXx8ZGRn4888/MWjQIOTk5MDIyEi0j4GBAXbv3i1WvAJAYmIi0tLSYGBgIPb41atXsX//fsyePRv//e9/oampiePHj2PJkiW4ePEi9uzZU+/rn5ycjJEjR6JXr1744osvYGFhgdevX+PGjRs4fPgwPvroIxgaGoq219HRQXx8PAAgJycHfD4f33//PW7evInY2Ngaxx85cqTYGyIAmJqa1hsXIaTpGpL7ACAmJgbx8fEYN26cVMffsGEDHB0dUV5ejuTkZKxbtw5jx47F9evX0a1bN7FtNTU1UVFRgT/++APz588Xe27v3r0wMDCQmL/rsnz5crz//vs1HjczMxP9f/Xq1fj222+xcOFCfPzxxzAwMEBmZibi4+MRERGBBQsWiO1rYGCAI0eO4KeffhLLuYwx7Nu3T+L7zNq1a+Ho6IgNGzagc+fOePDgAb766itEREQgOTlZqpwXFhaGixcvYsCAAdDW1sbVq1cb9FoQOWCE1OP8+fNMXV2dTZw4kZWUlNR4vrS0lEVERDDGGBs7dizr06cPGz58OHv//ffFtsvLy2O6urps4cKFDADbu3dvo87BGGNLlixhANhvv/0mMeaUlBR248aNOq+roqKC2draMkNDQ3br1i2J2xw7dowVFhYyxhjbu3cvA8AWLFjAdHR0WG5urti2M2fOZPb29qxPnz5s7NixosffvHnDysrKahx72bJlDADLysqqM07GGJs9ezbT09NjeXl5Ep8XCoWi/8+ZM4fp6enV2MbR0ZEBYOnp6WKPd+3albm5udUbAyFE9hqaX7t3786srKzYoEGDxP7uHz16xACwzZs3ix47ffo0A8COHDkidszffvuNAWBffPGF2ONVuWPatGlsxIgRYs8JhULWtWtXUf5eu3ZtvdcmKSZJioqKmLa2Nps9e7bE5wUCgdj3ANjMmTOZjo4O27Fjh9hzp06dYgBEcT569Ej03IsXL2ocOykpiQFgX331Vb3X824sVTmcKBbqikDqtWHDBvB4POzYsQPa2to1ntfS0sLkyZPFHps3bx5CQ0ORk5Mjeuzw4cMAgGnTpjXpHH///Td27dqFCRMmYPbs2RJj7tatG/r161fndYWHh+PWrVtYvXo1+vbtK3GbSZMmQVdXV+yx6dOnAwB+//130WO5ubkICQnBvHnzahyjTZs20NTUrPH40KFDAQBPnjypM04AyM7OhqGhIfT19SU+L83tsMGDBwMAXrx4Ue+2hBD5aGh+1dTUxDfffIOrV6/ijz/+aNQ568sF8+bNw/nz5/HgwQPRY6dOnUJmZib8/f0bdc66FBYWorS0FB07dpT4vJpazVLFyMgI3t7eNe547dmzByNHjkT37t1r7GNiYlLjsUGDBkFdXR2PHz+WKlZJsRDFQj8hUieBQID4+HgMGjQIXbp0kXq/adOmQV1dXaz42717N/z8/MRumTfmHKdPn0Z5eTm8vLykjkeSqlvyDT2OoaEh/Pz8xBLq77//DjU1NUydOlXq48THx0NDQ0NiAn6Xvb09nj9/jhkzZiAxMRHFxcUNihkAHj16BA0NDVhZWdV47syZMzAwMICmpiZ69+6N77//vkH9fwkhDdfY/Dp16lQMGjQIn3/+OcrLyxt83kePHgFArbnH2dkZXbt2Fctxu3fvxpgxY2p0XZCGUChERUVFja8q7dq1g42NDX799Vf88MMPuH//vsQxGu+aP38+Ll68iHv37gGo7HYVGhpaowtFXRITEyEQCNCnT58GXxdRTFTYkjq9fv0aRUVFsLS0bNB+BgYGYsXf3bt3cenSJYktmg09R1ZWFgA0OCZZHmfevHm4fPky7ty5A6CylWDKlCk1+tfWJjY2FgcOHMDy5cthbGxc7/YfffQRvLy88Pvvv8PBwQEGBgYYOHAgPv/8c7x69UriPlVvHtnZ2QgKCkJoaCg++eSTGq0Wbm5u2LZtG44ePQo+n4+BAwfio48+qnVgBiFENhqbX3k8Hr799lukpaUhODi43u2rCsvi4mKcP38e//nPf9C7d2+J+bjq+HPnzsX+/ftRUVGBN2/eIDw8vNbt6/Ppp59CU1OzxtfZs2dF2xw6dAht2rTBf/7zH/Tq1QtGRkbw8PDAgQMHai1yHR0dYWlpKXqfOXToEDQ0NDBlyhSp4srPz8fSpUvRpUuXRl8bUTw0eIw0m3nz5mHs2LG4desW9u3bB2tra4wZM0bune0FAoFYYlRTU2vy7aSxY8fC2toae/bswdy5c5GUlITvv/9eqn2vXbuG9957D8OHD8fGjRvFnqveigEA6urq4PF40NbWRlhYGO7du4eYmBhcuXIFiYmJ+OabbxAUFIRz586hR48eov0KCwtrdH+YPn06vvnmmxrx/PLLL2Lfe3p6ok2bNvj555/x4YcfYsCAAVJdFyFEfpycnODi4oL169djzpw5dW777p2kjh074vz582jdunWt+/j7+2P9+vU4fvw4MjIyoKWlhSlTpqCoqKjGtrXlrSqBgYGYOXNmjf169uwp+v+QIUOQmpqK+Ph4nDlzBleuXEFcXByio6Px559/IjIyskaXq6oC/Ndff8XGjRuxe/duvPfee7V22aqupKQEPj4+ogFq1fdpjvcMIj/0kyJ1ateuHXR1dUW3rhqi6rZVcHAwDhw4gHnz5knsC9rQc5ibmwOA1NtbW1uLtRKsX7++Ucepjsfjwd/fHwcPHkRQUBC6d++O0aNH17tfcnIyxo8fj27duuHYsWNifeoyMjJqtGgkJiaK7d+rVy+sXLkSBw8eRFZWFn744QdkZ2fjv//9r9h2Ojo6SEpKQlJSEqKiouDg4IDff/8dmzZtkur6qt6ELl68KNX2hJCGa0p+BYBvv/0Wr1+/rjGjiaTtkpKSkJiYiM8++wwvXryAl5cXSktLa92na9eucHJywp49e7Bnzx5MmzatxniDKu/mrd9++03seTMzMwwePLjG17sFqKamJiZMmIBvvvkGMTExePz4MRwcHBAdHY3jx49LPLe/vz9evXqFDRs24Nq1a1J1QygtLYW3tzfOnj2LyMhIDBs2TOx5Jycnseuh1lzlQi22pE7q6upwcnLC8ePH8eTJE7HpWaTh7++Pzz//HDwer9ZWhYaew9HREZqamggPD5dqrtWoqCixBN6pUycAwIQJE7Bjxw6Eh4dj1apVDbiqSnPnzsUXX3yBoKAgiS2h70pOThb1XYuNjRWbQqwqrqSkJLHHqrfCvovH4+H//b//h/Xr1+P27dtiz6mpqYkGiADA+PHjMWjQIKxbtw4zZsyotz9fVWsFtVIQ0nyaml/79++P6dOn44cffoCrq2ut21lZWYnywZgxY6Cjo4PPP/8cP/30Ez766KNa95s3bx5mzpwJoVCI7du317rdu3mrqd3EqhgbG2PlypVISEjA7du3JV5jly5d4OzsjHXr1qFHjx4YMWJEnccsLS2Fl5cXTp8+jYiIiBpTUgJAcHAw8vPzRd+3a9eu6RdD5IbetUi9Vq9eDcYYFi5ciLKyshrPl5eXIyoqSuK+c+bMgYeHBz7++GN07txZJufo0KEDFixYgJiYGOzfv1/i8dLS0nDz5k0AgK2trVgrQVVh6+npCVtbW2zcuLFGYVglJiZG4q03AOjcuTM+/vhjeHh41Hsr8Pr163B2doaZmRlOnjyJNm3a1NhGS0urRotGVZ/d2iYQf/bsGfLy8kTXVBttbW388ssvKCkpwddff13ntgBEr+vw4cPr3ZYQ0nhNya8A8PXXX6OsrAzr1q2T+pyffPIJbGxssGnTJrEC7l3e3t7w9vbGvHnz6swF7+YtacYNVFdeXo7s7GyJz1UNDKsrx/3nP/+Bh4dHjTtX76pqqY2Pj0dISAgmTJggcbsePXqIXY+FhYV0F0IUArXYknrZ29tj+/btWLp0KQYNGoQlS5agT58+osm+d+zYgb59+8LDw6PGvp06dUJ4eLjMz/HDDz8gPT0dc+fORUxMDLy9vWFqaorXr1/j5MmT2Lt3Lw4fPlznlF/q6uoICwuDi4sL7O3tsWTJEjg6OkJPTw+ZmZng8/mIiorC27dvaz2GNLf2Hzx4AGdnZwDAN998g4cPH+Lhw4ei562trdG+ffs6j7Fo0SLk5OTA19cXffv2hbq6Ou7fv48ff/wRampq+PTTT+uNY+zYsXB1dcXevXuxatUqWFpa4tChQwgNDYWbmxu6du2KnJwcHDlyBIcPH8bcuXNhZ2dX73EJIY3XlPwKVLaOLlmyBNu2bZP6nJqamtiwYQPee+89bNu2DZ9//rnE7Vq1agU+n9+o66ouKytLYrem9u3bw9raGrm5ubCwsMCUKVPg7OyMLl26oKCgAAkJCdi2bRt69eoFHx+fWo/v4uICFxeXeuPw8/PD8ePH8dlnn8HY2FgsJkNDQ/Tu3bveY2RmZopaqNPS0gBA9BpZWFiI3SkjHOFuCl2ibK5fv87mzJnDzM3NmZaWFtPT02MDBgxgX3zxBXv58iVj7N8FGupSNSF29QUaGnKOKhUVFey3335j48aNY23btmUaGhqsffv2bNKkSezQoUM1JvWuTU5ODvvqq6/YwIEDmb6+PtPU1GTm5uZs5syZ7Ny5c6LtqhZoSEpKqvN47y7QULVfbV+SXod3xcTEsHnz5rHevXszIyMjpqGhwTp27Mh8fHzYhQsXxLatbYEGxhi7desWU1NTY/7+/owxxi5cuMCcnJxYhw4dmKamJtPV1WVDhgxhv/76q9SvHyGk6ZqSX1+9esUMDQ2lXqChyrBhw1ibNm1YTk4OY6zu3FH9XGjgAg21fc2YMYMxVrkIxZYtW9ikSZOYubk509bWZq1atWK9evVin3zyCcvOzhY7LgC2bNmyOs+9efPmGgs01BVL9Zxdl7ry+Zw5c6Q6BmlePMakmCyOEEIIIYQQBUd9bAkhhBBCiEqgwpYQQgghhKgEKmwJIYQQQohKoMKWEEIIIYSoBCpsCSGEEEKISmhR89gKhUI8e/YMBgYGEpd2JYSQpmKMIT8/H506dVLJldsojxJCmltT8miLKmyfPXtW71KihBAiC48fP27wEqnKgPIoIUReGpNHW1RhW7U86ePHj2FoaMhxNETRCYVC3LhxAwBgZ2enkq1vRPby8vLQpUsXUb5RNZRHSUNQHiWN0ZQ82qIK26rbZoaGhpSQSb2EQiH09fUBVP7OUEImDaGqt+kpj5KGoDxKmqIxebRFFbaENISamhoGDBgg+j8hhJCGoTxK5I0KW0LqQImYEEKahvIokSf6bSOEEEIIISqBWmwJqQVjDJmZmQCArl27yrzPpEAgQHl5uUyPSZqfpqYm1NXVuQ6DEKXQ3HkUoFyqjJozj1JhS0gtGGPIzs4GAJibm8ssITPG8PfffyMnJ0cmxyPy17p1a3To0EFlB4gRIivNlUerjk25VHk1Vx6lwpYQOatKxCYmJtDV1aXiSIkwxlBUVISXL18CADp27MhxRIS0XJRLlVNz51EqbAmRI4FAIErExsbGXIdDGkFHRwcA8PLlS5iYmFC3BEI4QLlUuTVnHqXBY4TIUVU/MF1dXY4jIU1R9fOjfn2EcINyqfJrrjxKhS0hHKBbZsqNfn6EKAb6W1RezfWzo8KWEEIIIYSoBCpsCSGEEEKISqDBY4TUQk1NDXZ2dqL/E0IIaRjKo0Te6LeMkDpoaGhAQ4M+/ymKX3/9FZaWlmjVqhUGDRqEv/76q87tt2/fjn79+sHQ0BCGhoawt7fH8ePHxbapqKjA559/DktLS+jo6MDKygrr16+HUChszkshpMWgPKpYGppHpdnHwsICPB6vxteyZcua6zJqRYUtIUQp/PHHH1i5ciU+++wzJCcnY/To0Zg0aRKysrJq3cfMzAybNm3ClStXcOXKFYwbNw6enp64c+eOaJtvv/0WQUFB+Pnnn3Hv3j1899132Lx5M3766Sd5XBYhhMhNY/KoNPskJSXh+fPnoq+TJ08CAKZMmdLs1/QuHmOMyf2sHMnLy4ORkRFyc3NhaGjIdThEwTHG8PjxYwBAly5dZDKCs6SkBI8ePRJ98v3nREBRUZOP3Si6ukADr+vy5cv45JNPcOnSJXTt2hUHDhxAcnIyoqOjERkZ2UyBAsOGDcPAgQOxfft20WO9evWCl5cXNm7cKPVx2rZti82bN2P+/PkAAHd3d5iammL37t2ibXx9faGrq4sDBw5IPIbEn+M/VD3PqPr1EdlqjjwKSPgbpDwqlcbk0cbss3LlSkRHR+Phw4e1/sybK49Siy0htWCM4dWrV3j16hWa9fNfURGgr8/NVwPfCC5evIixY8di4sSJuHnzJnr37o0vv/wSmzdvxrp168S23bBhA/T19ev8kuYWGACUlZXh6tWrcHFxEXvcxcUF58+fl+oYAoEAhw8fRmFhIezt7UWPjxo1CnFxcUhJSQEA3LhxA2fPnoWrq6tUxyWE1I7yaE3KlEcbu8/Bgwcxb948TqZjo04vhBCpffjhh/D19cWqVasAANOmTcP06dPh6emJAQMGiG0bEBCA9957r87jde7cWarzvn79GgKBAKampmKPm5qa4u+//65z31u3bsHe3h4lJSXQ19dHWFgYevfuLXr+008/RW5uLnr27Al1dXUIBAJ88803mD59ulSxEUJIQyhTHm3MPuHh4cjJycHcuXOlikvWqLAlhGu6ukBBAXfnltKTJ09w4cIFbN68WfSYlpYWGGM1WhmAylv+bdu2bXBI//vf/7B48WLR98ePH4e1tTWAmhN6M8bqbRHo0aMHrl+/jpycHISEhGDOnDlITEwUFbd//PEHDh48iEOHDqFPnz64fv06Vq5ciU6dOmHOnDkNjp8QwgHKo2JknUcbss/u3bsxadIkdOrUqcFxywIVtoRwjccD9PS4jqJe9+7dAwAMHjxY9NiDBw8wdOhQ2Nra1th+w4YN2LBhQ53HPH78OEaPHi322OTJkzFs2DDR9507d4a6ujrU1dVrtBC8fPmyRkvCu7S0tGBjYyOKPSkpCdu2bUNwcDAA4OOPP8aqVaswbdo0AICtrS0yMzOxceNGKmwJURaUR8Uek1UebdeuXYP2yczMxKlTpxAaGlpnzM1JaQvbjRs3Ys2aNQgMDMTWrVu5DocQlZebmwt1dXXR92/evMF3332Hvn37Sty+sbfQDAwMYGBgUOPxQYMG4eTJk/D29hY9dvLkSXh6ekp7CQAqWxpKS0tF3xcVFdWYX1NdXb1FTPdFeZQQ+VK2PKqlpdWgffbu3QsTExO4ubnVGXNzUsrCNikpCTt27EC/fv24DoWQFqN///4QCAT47rvvMGXKFAQGBqJr1664d+8eMjMz0bVrV7HtG3sLrTYffvghZs2ahcGDB8Pe3h47duxAVlYWAgICRNv8/PPPCAsLQ1xcHABgzZo1mDRpErp06YL8/HwcPnwYCQkJOHHihGgfDw8PfPPNNzA3N0efPn2QnJyMH374AfPmzZNZ7IqI8igh8qeMeVSafQBAKBRi7969mDNnDqfzFivdrAgFBQWYMWMGdu7ciTZt2nAdDiEtho2NDdavX49t27ZhwIAB6NixI2JjY9GlSxc4Ozs3+/mnTp2KrVu3Yv369ejfvz/OnDmDY8eOib0RvH79GmlpaaLvX7x4gVmzZqFHjx5wcnLCpUuXcOLECYwfP160zU8//QQ/Pz8sXboUvXr1wkcffYTFixfjq6++alScyjCDIuVRQrihjHlUmn0A4NSpU8jKyuK8UUDp5rGdM2cO2rZtix9//BEODg7o379/rbfQSktLxW455uXloUuXLjT/IpFaWVkZgMrbMbJQ17x9RHnU9nPMz8/HoUOHEBAQoNB5RhZ5NCcnB0ZGRnKKmCgzWedRgHKpKqjtZ1hWVobQ0FBMnz5d9eexPXz4MK5duyb1ZOwbN26EkZGR6KtLly4AKj9VVFRUNGeoREVoaWnJNBkT1fXw4UMEBQXh1atXXIdSJ1nl0ZCQEBQXFzdnqERFUB4l0nrx4gV27NghtjpkQylNYfv48WMEBgbi4MGDUn86W716NXJzc0VfVaufXL16Fbt370Z2dnZzhkwIaQEqKioQExOD//3vf+jUqZNoRTNFJMs8+vjxY2zfvh2ZmZnNGTIhpAVgjOHy5cvYuXMn1NXV4e/v3+hjKU1XhPDwcHh7e4uNJhQIBODxeFBTU0NpaanYc5JULdF2//59xMTEoKCgAG5ubrCzs2vu8IkSYozh6dOnACpHnTbbkrpE6VT9HFu3bo3IyEi8fPkSzs7OGD58OPLz8xV2yVlZ5tGsrCxRn7qxY8dizJgxNWaXIKQ58ihAuVQVVP0MO3TogJiYGNy/fx/Dhg3D+PHjUVRU1Og8qjSzIjg5OeHWrVtij/n7+6Nnz5749NNP603G1XXs2BGLFy/G8ePHERYWhrS0NLi5uUFbW1vWYRMlxhjDixcvAACdOnXiZGlAorjKysrw559/Qk1NDQsWLEDHjh25DqlessyjRkZGmDNnDs6cOYPExEQ8evQIPj4+1O+WiKE8SupSUVGBw4cPIy8vD9OnT0ePHj2afEylKWwNDAxqzPOmp6cHY2PjWud/q4u2tja8vLxgZWWF6OhoPHnyBH5+fpytlEFalpYwR6qqEgqFyMnJQVFREaytreHi4qI0/QdlnUfV1NTg4OAAS0tLhIaGIigoCJ6enujZs6esQiakTpRLlRNjDPn5+SgoKICRkRFmzJghsztcSlPYNpd+/frBzMwMfD4fu3fvhpOTE+zt7elTJWkWWlpaUFNTw7Nnz9C+fXtoaWnR75oSKSsrw9u3b/H27Vu0atUKrq6udPsdQNeuXREQEIDIyEgcPnwYQ4YMgYuLCzQ1NbkOjagoyqXKq6KiAm/fvkV2djY0NTXx3nvvyXTeW6XpYysLVX3DJPXZEAgEiI+Px7lz52BjYwMvLy/o6+tzFClRBEKhEMnJyQCAAQMGyKyAKSsrw/Pnz1FUVCST4xH5KC0tRXFxMXg8Htq2bQsLCwuJLbV15RlVUNf1McZw5coVxMTEwNjYGH5+fmjfvj1HkRJF0Fx5FKBcqozKy8tRVFQExhgMDQ3RrVs3mefRFt9iW0VdXR3jx4+HpaUlwsLCEBQUBG9vb1hbW3MdGlExWlpaMDc3R0VFBQQCAdfhkHoUFhYiLi4OWVlZGDBgAEaNGkWtQ7Xg8XgYMmQIzM3NwefzsWPHDkycOBEDBw6k14vIHOVS5VFeXo6zZ8/izp07sLa2hrOzM/T19ZslL1Bh+w4bGxssWbIEYWFhOHDgAEaOHIlx48Y1aFAFIfXh8XjQ1NSkW7UKLi0tDaGhoQAAb29v2NjYcByRcjA1NcWiRYsQExODqKgopKWlwcPDAzo6OlyHRlQM5VLF9/LlS/D5fLx58wYTJ07EoEGDmvWDLhW2Eujr62PmzJk4f/484uLikJGRAV9fX5mu10wIUVzUNanpNDU14e7uDisrK0RGRiIoKAh+fn6iBR4IIaqNMYarV6/ixIkTaNu2LRYtWgQTE5NmPy/1sa3H06dPwefzUVRUBHd3d9ja2jZzlESRVK2sRC1NLcebN28QEhKC58+fw9nZucGDSVtyH9va5OTkICQkBE+fPoWDgwNGjRpFg+5aEMqjLU9xcTEiIyNx7969Rg0mbUoepcJWCqWlpYiOjsatW7fQv39/uLq6Ks30PoQQ6d28eRNHjx6Fnp4efH190blz5wYfgwpbyYRCIRISEvDXX3/BwsIC3t7eKvn6ENLSZWZmIjQ0FKWlpfD09ESvXr0afAwqbKXUlBeKMYYbN27g2LFjMDAwgJ+fn1JMyE4IqV9ZWRmOHTuG69evo1+/fk1asIUK27plZGQgJCQEAoEAnp6eMpmQnRDCPaFQiL/++gsJCQno0qULfH19G71gCxW2UpLFG052djb4fD5evnyJ8ePHY9iwYTTaV0UxxvD8+XMAlavV0c9ZNT1//hx8Ph/5+fkyWWKbCtv6FRUVISIiAg8ePBAtoSnLeSyJ4qA82jLk5eUhJCREZkts03RfcmRsbIz58+cjLi4OJ06cQHp6Ojw9PaGnp8d1aETGqifkDh06UEJWMYwxXLp0CSdPnoSJiQkWL14MY2NjrsNqEXR1dTFt2jRcvnwZsbGxyMzMhJ+fH9q1a8d1aETGKI+qvvv37yMiIgKampqYM2cOLCwsOI2HCttG0NDQwIQJE2BlZSWa89bHxweWlpZch0YIkUJhYSHCw8Px8OFD2Nvbw8nJiVoM5YzH42HYsGHo2rUr+Hw+goOD4erqiv79+1PxQ4gSqKioQGxsLC5fvoyePXti8uTJ0NXV5TosKmybolu3bliyZAlCQ0Oxf/9+jBo1Cg4ODjTnLSEKLD09HWFhYRAKhZgxYwa6devGdUgtWocOHbBo0SKcOHECERERSEtLg7u7O1q1asV1aISQWrx69Qp8Ph/Z2dlwc3PD4MGDFeYDKRW2TWRgYIBZs2bh/PnziI+Px6NHj+Dr64s2bdpwHRohpBqBQICEhAScPXsWlpaW8Pb2hoGBAddhEVSuIDV58mRYWVkhKioKwcHB8PX1hZmZGdehEUKqYYzh2rVrOHHiBFq3bo2FCxfC1NSU67DEUGErA2pqahg1ahQsLCzA5/MRFBSEyZMno0+fPlyHRggB8PbtW4SEhODZs2dwcnLCyJEjFaZ1gfyrb9++6Ny5M0JCQrBnzx6MGzeOflaEKIiSkhJERUXhzp07GDRoECZMmKCQU59SYStDZmZmCAgIQFRUFI4cOYK0tDRMnDhRIX/whLQUd+7cQWRkJHR0dDBv3jxqBVRwbdq0gb+/PxISEhAXF4f09HRqXSeEY48fP0ZISAhKSkowZcoUhW64o8JWxlq1agU/Pz9YW1vj+PHjyMrKgp+fHzp06MB1aIS0KGVlZThx4gSuXbuGvn37Ur9NJaKurg4nJydYWloiNDQUQUFB8PLyov7QhMiZUCjEuXPncPr0aXTu3Blz585F69atuQ6rTjSPbTOq3rnaxcUFQ4YMoVtqSoQxhqKiIgCV0xPRz055/P333+Dz+cjNzZX7SHuax1a2aAYL5UZ5VHnl5+cjNDQUGRkZGD16NBwcHOS2FDYt0CAlLt5wKioqcPLkSVy6dAk9evSAp6enQkyHQYgqYowhKSkJsbGxaNeuHXx9fdG+fXu5xkCFrey9O+ewn58fzTlMSDNKSUlBeHg41NXVOZnOlApbKXH5hvPgwQNERERAQ0MDPj4+nE9gTIiqUZTVrKiwbT6yXiWOECKuoqICp06dwsWLF9G9e3d4eXlx0hhHha2UuH7DycvLQ2hoKDIzMzFmzBiMHTtWbs36pOEYY3j58iUAwMTEhG6hKbCMjAyEhoaioqICnp6e6NGjB2excJ1nmhvX11dWVoZjx47h+vXr6NevH9zc3KCtrS33OIh0KI8qj+zsbPD5fLx8+RIuLi4YOnQoZz8vWlJXSRgaGmL27Nk4e/YsEhISRHPeGhkZcR0akYAxhidPngAA2rdvTwlZAQmFQiQmJuLMmTPo2rUrfHx8VLKYJP/S0tKCl5cXrKyscPToUTx58gR+fn7o1KkT16ERCSiPKj7GGG7cuIFjx47BwMAACxYsQMeOHbkOq9GosJUzNTU1jBkzBhYWFggJCcH27dsxefJk9O7dm+vQCFEqOTk5CA0NxZMnT+Do6IhRo0bRHZAWpF+/fjAzM0NISAh2794NJycn2NvbU+FESAOUlpYiOjoat27dwoABAzBp0iSln6KUCluOmJubi+a8/fPPPzF48GBMmDABmpqaXIdGiMK7e/cuIiMjoa2tjblz58Lc3JzrkAgH2rZti3nz5iE+Ph6xsbFIT0+Hl5cX9PX1uQ6NEIX39OlT8Pl8FBUVwdfXF7a2tlyHJBNU2HJIR0cHU6ZMwbVr18TmvDUxMeE6NEIUUnl5OWJiYnDlyhX07t0bHh4e0NHR4ToswiF1dXWMHz8eVlZWojlvvb29YW1tzXVohCgkxhjOnz+PuLg4dOzYEbNnz0abNm24Dktm6L4dx3g8HgYNGoRFixYBAHbs2IErV66gBY3pazGKi4sRGBgId3d3BAYGori4mOuQlMrLly+xc+dOXL9+HR4eHpgyZQoVtUTE2toaS5YsQYcOHXDgwAGcPHkSAoGA67AIUSgFBQU4ePAgTp48iREjRmDevHkqVdQCVNgqDBMTEyxcuBADBgxAdHQ0/vzzTyp8VMyqVavg7OyM6OhoODs7Y/Xq1TW2oeK3JsYYrly5gh07dgAAFi1ahEGDBlFfSlKDvr4+ZsyYARcXF1y4cAF79uzBmzdvuA6LEIWQmpqK7du348WLF5g1axacnZ2hrq7OdVgyR4WtAtHU1ISbmxumTp2KjIwMBAUFISsri+uwiIykpaXBw8MDAODh4YHU1NQa20hT/LYkxcXF+PPPPxEdHY0BAwZg4cKF1FWH1InH42HEiBGYP38+iouLERwcjJs3b3IdFiGcEQgEiI2NxcGDB9GxY0csWbJEpbvqUGGrgHr16oWAgAC0bt0ae/fuRWJiIoRCIddhtTg8Hg/du3dH9+7dZdI6aG1tjaioKABAVFQUbGxsamwjTfHbUmRmZiIoKAgZGRmYOnUq3NzcaHAlkVrnzp2xePFi9OjRA6GhoQgLC0NZWRnXYbU4ss6jpGHevHmD3bt349KlS5gwYQJmzJgBPT09rsNqVjR4TEEZGRlhzpw5OHPmDBISEpCeng5fX1+ao1OOeDweDAwMZHa8TZs2YfXq1QgODoaNjQ02btxYY5uq4tfDw6PW4lfVCYVC/PXXX0hISIC5uTl8fHxormfSKNra2vD29oaVlRWOHTsmmvNWmefoVDayzqNEejdv3kR0dDT09fUxf/78FjPXM608pgQyMzMREhKC8vJyeHp6omfPnlyHRJpJcXExVq9ejdTUVFHx25IGSFVfnW/s2LEYM2aM0s1Nq6x5RlrKen3VV1VydnbG8OHDqQWRqKTS0lIcO3YMN27cgJ2dHVxdXZVudT5aUldKypqQAaCoqAiRkZG4f/8+hg4dChcXF2hoUIN7c2KM4fXr1wCAdu3a0ZtgM7t//z4iIiKgqakJX19fdO3aleuQGkWZ84w0lPn6KioqEBcXhwsXLqBbt27w8vJS+duyXKM8Kl/Pnj0Dn89HQUEB3NzcYGdnx3VIjUJL6rYAurq6mDp1Kq5cuYKYmBhkZmbCz88P7du35zo0lcUYEw3eMzY2poTcTMrLyxEbG4ukpCT07NkTnp6eLaqVmsiPhoYGJkyYACsrK4SHhyMoKAg+Pj6wtLTkOjSVRXlUPhhjuHDhAuLi4mBqaooZM2bA2NiY67A4oVz3+Fo4Ho+HIUOGYOHChRAKhdixYweuXbtGc94SpfXq1Svs2rULycnJohlBqKglza1bt24ICAhA+/btsX//fsTFxdGct0RpFRQU4H//+x9iY2MxbNgwzJ8/v8UWtQC12ColU1NTLFq0CCdOnEBkZKRoJH2rVq24Do0QqTDGcO3aNZw4cQKtW7fGwoULYWpqynVYpAUxMDDArFmzcO7cOcTHx+PRo0fw9fVVucnqiWpLS0tDWFgYGGOYOXNmixxw/C5qsVVSmpqaotWX0tLSEBQUhMePH3MdFiH1KikpAZ/PR1RUFPr164dFixZRUUs4wePxMGrUKMybNw8FBQUICgrC7du3uQ6LkHoJBAKcPHkSBw4cgKmpKZYsWUJF7T+oxVbJ9enTB507d0ZISAj27t0LR0dHjBw5UulGkpOW4fHjxwgJCUFJSQnee+899O7dm+uQCIGZmRkCAgIQHR0NPp+P9PR0TJw4EVpaWlyHRkgNb9++BZ/Px/PnzzF+/HiMGDGC+i5XQ4WtCmjdujX8/f2RkJCA+Ph4pKenw8fHh+YOJApDKBTi7NmzSEhIQOfOnTF37ly0bt2a67AIEWnVqhV8fX1hbW2NY8eOISsrC35+fujQoQPXoREicuvWLURHR0NXVxfz589H586duQ5J4VBhqyLU1NQwbtw4WFpaIjQ0FNu3b4eXlxe6d+/OdWikhcvLy0NYWBgyMjIwevRoODg40B0FopB4PB4GDBgAMzMzhISEYOfOnXBxccHQoUOpRYxwqqysDMeOHcP169dha2sLd3d3pZubVl5oHlsVVFRUhIiICDx48ADDhg3D+PHjac7bRmCMIS8vDwBgaGhIb2yNkJKSgvDwcKirq7eYaZVUPc+o+vVVqaiowMmTJ3Hp0iX06NEDnp6e0NXV5TospUN5tOmeP38OPp+P/Px8uLq6ws7OTuVfR1qgQUotJSEDlcnk8uXLiI2NRfv27eHn54d27dpxHRZpIVpyUaDqeUbVr+9dDx48QEREBNTV1eHr6wsLCwuuQyItBGMMly5dwsmTJ2FiYgJfX98W8z5Oha2UWlpCBoC///4bfD4fubm5cHV1Rf/+/VX+kx7h1uvXr8Hn8/Hq1asWeRtX1fOMql+fJNWXeqbuNEQeCgsLERERgZSUFAwfPhzOzs4t6s4rFbZSaokJGajsm3P8+HEkJyfD1tYWbm5uNOetFBhjePPmDQCgbdu2Lao4awzGGK5fv45jx47ByMioxQ68UfU8o+rXV5vqAyDNzMzg4+NDAyClQHm04R49eoTQ0FAIBIIWO1aGltQlddLS0oKnpyesra0RFRWFJ0+ewM/Pj0ZT1oMxhoyMDABAmzZtKCHXobS0FNHR0bh16xYGDBiASZMm0VRJRKWoqalhzJgxsLS0BJ/PR1BQECZPnkxT1tWD8qj0BAIBEhMT8ddff8HCwoJmN2okpbmXsnHjRgwZMgQGBgYwMTGBl5cXHjx4wHVYSqVv374ICAiAnp4edu/ejXPnztFyvM2kuLgYgYGBcHd3R2BgIIqLi5Xi2I3x5MkTBAUFISUlBX5+fvD09KSiVkFRHm26Ll26ICAgAFZWVvjzzz8RFRWF8vJyrsMiSi4nJwf79u3D2bNnMW7cOMyaNYuK2kZSmsI2MTERy5Ytw8WLF3Hy5ElUVFTAxcUFhYWFXIemVNq0aQN/f3+MGDECJ0+exMGDB1FQUMB1WCpn1apVcHZ2RnR0NJydnbF69WqlOHZDMMZw9uxZ7NmzB3p6eggICEDfvn05iYVIh/KobOjo6GDKlCnw8PDAzZs3sXPnTrx8+ZLrsIiSunPnDoKCgpCfnw9/f3+MHj2a+nA3gdL2sX316hVMTEyQmJiIMWPGSNymtLQUpaWlou/z8vLQpUuXFtc3rDbV15j28vJCt27duA5JoQiFQiQnJwMABgwY0KBE4+7ujujo6Fq/b4rmPLa0CgoKEBYWhvT0dIwcORKOjo5QV1eXawyKSpn6oFIebbpXr17hyJEjePPmDSZOnIhBgwbR7fZqmpJHVV15eTlOnDiBq1evok+fPvDw8KDxL/9oSh5V2t+w3NxcAJWd0WuzceNGGBkZib66dOkir/CUgrW1NZYsWYKOHTvif//7H2JiYiAQCLgOSyVU9WcGgKioKJmu4d2cx5ZGamoqtm/fjhcvXmDWrFlwdnamolZJUR5tuvbt22PhwoUYMGAAoqOj8eeff3LePYgovhcvXmDHjh24efMmJk+eDD8/PypqZUQpW2wZY/D09MTbt2/x119/1bodtTRIhzGGixcv4tSpUzA1NYWvry+MjY25DotzTWlpKC4uxurVq5GamgobGxts3LgROjo6MomrOY9dF4FAgLi4OJw/fx7dunWDl5cX9PT0mv28ykZZWmwpj8revXv3EBkZCS0tLfj4+KBr165ch8Q5arEVxxhDUlISYmNjYWxsDD8/P7Rv357rsBROi5sV4YMPPsDNmzdx9uzZOrfT1tamJeekwOPxYG9vj65du4LP5yM4OBhubm6ws7PjOjSlpaOjg61btyrdsWuTnZ2NkJAQvHjxAhMmTMDw4cPpdquSozwqe7169UKnTp0QGhqKffv2YezYsRgzZkyLL+ZIpeLiYkREROD+/fu0KmgzUroW2+XLlyM8PBxnzpxp8PKcytKSwqXS0lIcP34c169fh52dHVxdXVvsmxpjDDk5OQCA1q1bN7iQKy4uxqpVq5CWlgZra2ts2rRJLi2rsnbjxg0cPXoUBgYG8PPzQ8eOHbkOSaEpQ56hPNq8hEIhzpw5g8TERJibm8PHxwdGRkZch8WJpuZRVZGZmYmQkBCUl5fD09MTPXv25DokhdYiFmhgjGH58uUICwtDQkJCowY6UUKW3s2bNxEdHQ19fX34+fmhU6dOXIekdAIDA+Hs7AwPDw9ERUUhLi5O7i2tTVFaWoqjR4/i5s2b6N+/PyZNmtRiP+Q0hCLnGcqj8kXFDKn+Iadr167w8fGhvxsptIjCdunSpTh06BAiIiLQo0cP0eNGRkZSt4JRQm6YN2/egM/n48WLF3BycoK9vX2L/bTdGIowe0FjPXv2DHw+HwUFBXB3d0e/fv24DklpKHKeoTwqf9VvPw8ZMgQuLi7Q1NTkOiwiB7m5uQgNDUVWVhYcHBxoGq8GaBGFbW0F1d69ezF37lypjkEJueGqDxiysbGBt7d3ixkw1NRbaMrYYssYw4ULFxAXFwdTU1P4+fnVOWKe1KTIeYbyKDcYY7hy5QpiYmJa3IChltoVofpAQl9fX5ibm3MdklJpEYWtLFBCbrzU1FSEhYWBx+PB29sb1tbWXIfU7Jo6mper2Qsaq6CgAOHh4UhNTcWIESPg5ORE03g1gqrnGVW/vub04sUL8Pl85OTkYOLEiRg4cKDKF3otbVaE8vJyxMbGIikpCb1794aHh4dC531FRYWtlCghN03VpPxpaWkYOXIkxo0bp9KFT0tKyNUX6/D29pb73LiqRNXzjKpfX3MrLy9HTEwMrly50iIm5W9JefTly5fg8/m0WIcMtLjpvgg39PX1MXPmTJw/fx5xcXHIyMiAr6+v0t+qVpXZCxpDIBAgPj4e586dg7W1Nby9vaGvr891WISoLE1NTbi7u8PKygqRkZEICgqCr68vLXyhxBhjuHr1KmJiYtCmTRssWrQIJiYmXIfVYqnuRyfSLHg8HkaOHIn58+ejqKgIwcHBuHXrFtdhNcmqVavg7OyM6OhoODs7Y/Xq1VyHJBdv3rzBnj17cOHCBYwfPx4zZ86kopYQOenduzcCAgJgYGCAvXv34syZMxAKhVyHRRqouLgYR44cQXR0NOzs7LBw4UIqajlGhS1plM6dOyMgIADdu3dHSEgIwsPDUVZWxnVYjZKWlgYPDw8AgIeHB1JTUzmOqPndunULwcHBKCoqwvz58zFy5Ei6ZUaInLVu3Rr+/v4YNWoUTp8+jQMHDiAvL4/rsIiUsrKyEBQUhPT0dEydOhXu7u4044UCoMKWNJq2tjZ8fHzg5eWFu3fvIjg4GM+fP+c6rAaztrZGVFQUACAqKqpG/9KSkhKsXLkS7u7uCAwMVOp14MvKyhAeHo6QkBB0794dAQEB6Ny5M9dhEdJiqampYdy4cZgzZw5ev36NoKAgpKSkcB0WqYNQKERiYiL27t0LIyMjLFmyBL169eI6LPIPKmxJk/B4PPTv3x+LFy+GlpYWdu3ahYsXL0KZxiRu2rQJcXFxcHd3R1xcHDZu3Cj2/M8//wwnJyel76rw/PlzBAcH4+7du/Dy8oKPjw8tuECIgrCwsMCSJUvQpUsXHDp0CMePH0dFRQXXYZF35OXlYf/+/UhISMCYMWMwd+7cFruqnKKiwWNEJoyNjTF//nycOnUKJ06cQHp6Ojw9PRV6ztt3B40dOXJEbNAYj8eDhYUFsrOzMXnyZACVXRWCg4O5CrlRGGO4dOkSTp48CRMTEyxatAjt2rXjOixCyDt0dXUxbdo0XL58GbGxscjMzISfn59S/71W5dGq/yuz+/fvIyIiApqampgzZ47ouohioRZbIjMaGhqYOHEi3n//fTx58gRBQUF49OgR12HVqr5BYzweD8bGxujVq5doxTBJXRWa05s3bzBq1Cj069cPI0eOxJs3bxq0f2FhIX7//XecOHECQ4YMwfz58xXuTbK4uBiBgYEq0dWDkKbi8XgYNmwYFi5ciIqKCgQHByM5OVmp7oJVV5VHjY2NlbawraiowLFjx3D48GGYm5sjICCAiloFRvPYkmaRn5+P0NBQZGRkYNSoUXBwcFC4OW+lXfKWy4UWRo0ahY8++gheXl4IDw/Hli1bcPbsWan2ffToEUJDQyEQCODl5YXu3bs3c7SNo4wrtNVF1fOMql+fIikrK8OJEydw7do19O3bF+7u7io9560ievXqFfh8PrKzs+Hi4oIhQ4YobYGuTGiBBilRQpYvoVCI8+fPIz4+Hp06dYKfnx9at27NdVgi9RVUjDHRCGVDQ0NOklm/fv1w8+bNWr+XRCAQICEhAWfPnoWFhQV8fHxgYGDQ3KE2mrQfMJSFqucZVb8+RXT79m1ERUVBV1cXvr6+MDMz4zokqSlCHm0MxhiSk5Nx/PhxGBkZwc/PDx06dOA6rBajKXmGuiKQZqOmpoZRo0Zh3rx5KCgoQFBQEO7cucN1WCL1DRpjjCE1NRWpqalitwHleevcwMAA4eHhAIDw8PB6/8BzcnKwd+9enDt3DuPGjcOsWbMUuqgF6p+VgpCWrm/fvggICICenh727NmDs2fPKk3XhNryqCIrKSkBn89HZGQkbG1tsWjRIipqlQi12BK5KCkpQVRUFO7cuYOBAwdi0qRJCj/fX21LQcrz1vmbN28wefJk5OXlwdDQEJGRkbWu9Hbnzh1ERUWhVatWSrWSEZddPZqDqucZVb8+RVb9boylpSW8vb0V/oOrsi2p+/jxY4SEhKC4uBgeHh7o27cv1yG1SNQVQUqUkLlV/dZO69at4efnB1NTU7mdv6FL59aWkBXt1nn1fngtYe15RafqeUbVr08ZpKenIzQ0FIwxeHl5oVu3blyHVCtlKWyFQiHOnTuH06dPK2TXuZaGuiIQpcDj8TBw4EAsWrQIampq2LlzJy5fviy321OyWjpXkW6dv3jxAjt27MCtW7cwefJk+Pn5UVFLiIqzsrLCkiVL0KlTJ/zvf/9DTEwMzXnbBPn5+Thw4ADi4+MxcuRI+Pv7U1GrxKiwJXLXvn17LFy4EAMHDsSxY8fwxx9/oKioqNnPK6ulc+vrmysPjDFcvnwZO3fuhLq6OhYtWoSBAwcqzcAMQkjT6Onp4f3338eECRNw+fJl7N69G9nZ2VyHJTVFmeYvJSUF27dvx+vXrzF79mw4OTkp3Aw+pGGosCWc0NDQgKurK6ZPn47MzEwEBQUhMzOzzn1qS4TSJkhZtbTq6Ohg69atiI6OxtatWyV2Z2jOpF1UVITDhw/j2LFjGDRoEBYuXIj27ds3+DiK8sZCCGkcHo8He3t7zJ8/H6WlpQgODsaNGzea/byyyB1NvYPW1BgqKipw4sQJHDp0CGZmZggICIClpWWDjiGvWEnDUGFLONWjRw8sWbIEbdu2xb59+3D69GkIhUKJ29aWCKVNkPJsaZVVt4d3ZWRkICgoCFlZWZg+fTomTZoEDY3GLSDYXDESQuSrU6dOWLx4MXr37o2wsDCEhoaitLS02c4ni9zR1DtoTYkhOzsbu3fvRlJSEiZOnIjp06c36yqZlGvliwpbwjlNTU1cu3YNJ06cwOrVq7Fjxw7k5ubW2K62RChtgpSmpbU6Ho8Hc3NzmJubN/gWv6y6PVQRCoU4ffo0fvvtN7Rt2xZLlixBjx49mnRMWcdICOGOtrY2vLy84OPjgwcPHiA4OBjPnj1rlnO9mzv++uuvWlsha8ujTb2D1pj8xRjD9evXERwcjLKyMixYsADDhw9v9i5clGvliwpbwrlVq1Zh/PjxuHDhAhYtWoRDhw5h+/btuHfvnth2tSXC5hrMxePx0L59e7Rv377BiU+WMeXm5mLfvn04c+YMHBwcMHv2bJmMRlekQXCEENno168fFi9ejFatWmH37t04f/58gwboSnPb3NraGmFhYQAqc4elpWWtrZC15dGm3kFraP4qLS1FaGgowsPD0adPHyxevBgdO3Zs0Dkbi3KtfNF0X4Rz706XNWnSJPj7++Pu3bsYPHgwJkyYAE1NzVrnO1XEeVBlFdO9e/cQEREBbW1t+Pr6wtzcXOrz1ze1mSK+bqpA1fOMql+fqhAIBIiPj8e5c+dgY2MDLy8v6Ovr17ufNPN0FxcXw97eHmZmZqLcMWXKFLlOe9iQ/PX06VPw+XwUFRXB3d0dtra2TTpvQ6aNbGispBLNYyslSsiKSVIi/fHHH3H16lWcOHECbdu2hZ+fH0xMTOQaF2MMBQUFAAB9fX25zjhQXl6OmJgYXLlyBb1794aHh0eDEmFdb06NScxEeqqeZ1T9+lRNamoqwsLCwOPx4O3tDWtr6zq3l3aebmkXquEyjzLGcP78ecTFxaFjx47w9fWtdYEbaclzgZ6WjOaxJUpN0i0pHo+HwYMHY9GiRQCAHTt24MqVK3JdkpExhpSUFKSkpMj1vC9fvsTOnTtx/fp1uLu7Y8qUKQ0uPOvq00UDGQhpOWxsbLBkyRKYmpriwIEDOHnyJAQCQa3bS3vbXNquBLLKow2dWaCgoAAHDx7EyZMnMWLECMybN6/JRS1A/WWVAbXYEoVXXl6O2NhYJCUloVevXpg8ebJcWhjrWjGnOVo9GWMya6Wuq1VB0VZOUzWqnmdU/fpUlbStl7K8bV5cXIxPP/0UycnJMDMzw65duxo9+0BDWkob2krdXHGQxqOuCFKihKzc7t27h8jISGhpaTWov2lj1VXYyjq5FRcXIzIyEvfu3cOQIUPg4uICTU3NJh2vtjcnSszNS9XzjKpfn6p7+vQpQkJCUFhY2OT+pvUJDAzEuHHjYGZmhjNnziAjIwPbtm1r1LGk+UAuEAgQFxeH8+fPw8bGBt7e3o0upGtrvKD+svJBha2UKCErp+oJxszMDP3798eLFy/g4OCA0aNHN9va43UVtrJs9czKykJISAjKysowefJk9OrVq2mB16MxiZn65UpP1fOMql9fS1BaWoqjR4/i5s2b6N+/P1xdXaGlpSXz87i7uyMyMlKUR7/44gscPXq0Uceq7wP5mzdvwOfz8eLFCzg7O9c6jZe0uYwaALhFfWyJSqveJ9TNzQ337t3D2LFjkZCQgF27diEgIEDuK7rU1Q9N2r5gQqEQiYmJ2Lt3L4yMjBAQENDsRS3Q8Pl8AeqXS4gq0dbWhre3N7y9vXH37l0EBwfj+fPnMj9P9Tx55syZJk1zVb1Pb0xMDMrLy0U59vLlywgKCkJJSQnmz58Pe3v7WgepSZvLqC+t8qLClii8dxNMWloaHBwcMGfOHBw4cAAlJSXYsmVLsxZc7xara9eurXXghDSJMy8vD7/99hsSEhIwduxYzJ07F0ZGRs0SuyxQkidEtfB4PNjZ2WHx4sXQ0tLCrl27cPHiRdEAL1ksA7tp0ybEx8dj5cqVuHz5MjZs2NDoeKt/IFdXV8fEiRMREhICPT09rFixAr169cLixYvRqVOnOo8jbS6juWeVFxW2ROHVlmAsLCygr6+PiRMn4vDhw1BXV0dKSkqzrMu9evVqsWJ1/fr1tbZ61pc479+/j+3bt+Pt27eYM2cOHBwcmq07haxQkidE8TUm9xkbG2P+/PkYOnQoTpw4gUOHDqGwsFCqD+j1nU9HRwc//vgjtm7dio8++qjB3ZdqO35aWhoGDRqEHTt2QF9fH1paWvD29oa2tna9x5Q2l61duxbffvst+vXrh2+//RZffPFFg2In3KE+tkTh1TcQysnJCR07dsS2bdvw7NkzWFtbY/LkyU3uG8UYw8uXLwEA8+bNE+sbJrFPLWPA06f4KTAQYzp2hJ2eHp5cvoyC9HT0bNMGLDsb5Xl5QHExNAQC8Hg88LS0AC0toFUrwNgYaNeu8qtzZ8DKqvLLxgbo1g2QYjBZc/WFpQET0lP1PKPq16fMmtov9OHDhwgPD4eamhqOHj2K+Ph40XOScp4056ueR01MTBo0j21tc5xPnToVmpqaGDt2LPT09JCUlCT1dUqby6iPLbealGdYC5Kbm8sAsNzcXK5DITJSVFTEAgMDmZubG1uwYAH74YcfWPfu3dnVq1eZUChkjDHm5ubW5POsWLGCRUZGMsYYi4yMZIGBgYy9esVYSAhjn37KmLMzY23bMlZZ3sr+S1ubsUGDGJs/n7GgIMbu3WPsn+urN04iV6qeZ1T9+ppDUVERW7FiBXNzc2MrVqxgRUVFzXKed3Pdu99LE0deXh777bff2LBhw9hXX33FKioqas0l9Z2vsaritLW1FXt8woQJ7ODBg2zNmjXMy8uLubq6ssDAwBrXIYvXu7mujUinKXmGWmyJSikrK4Ovry/09fXh4+MDNTU1/PXXX03+pF1cXIzPP/4Yepcvw6m8HKMrKqB2+3bNDdXVAUvLylZWGxuwLl2QWVKCsykp+OvePVRoacG8Rw988t//QkdXFygrq/wqKgKys4HXryu/srKA9PTKr5QUID+/5rlMTYExY4BJkwA3N8DEhOaoVQCqnmdU/fqag7xa/949T0xMDNTV1UV3cCoqKjBx4kSpVguLj4/H559/jsLCQowYMQI//vhjjZbN5rququOeOnUKjo6O8PLyws6dO7F//35MnjwZXl5e6Natm9SvQ2PikneLLc08I45abKVELQ0tQ1FREZs5cybr0aMHGzNmDEtJSWnUcYRCISt48YIV79nDhO+9x5iBQc2W1L59GVu0iLHgYMauXGGspES0f3FxMfvzzz/Z2rVrmbu7OwsNDWWM1d6SWmsrg0DAWGoqY0eOMLZmDWMODpUtuNXj4PEYGz6cRYwYwU7u3l3neUjzUvU8o+rX1xzk1fpX/Q5WYGAgW7p0qegOTmhoKLOxsRHLLfXF8fjxY/bjjz+yDRs2sFu3btV7Pkkto0KhkBUUFLCCggLRXbT6VMVVVFTEli9fziwtLdmwYcPYzp07WX5+fp3XL6mltzGvtzTXJkt0t01cU/IMFbZEZb19+5bt2rWLrVu3jp05c4YJBAKJ29UoKPPzGTt1iglnz2YVurriBWSnTpWF7J9/MvbiRa3HSElJYT/++CPbuHEju337tlRvbA1KbCUljP31F2Nr1zI2cGCNgvtm27bs8LhxrOj58wa/bqRpVD3PqPL1NVeXAa6KFkl5JywsjAUGBkqMQ9L1FxcXsyNHjrC1a9eyiIgIVlpa2qAYBAIBu3LlCrty5UqtOfhdVa/Xmzdv2LJly9jw4cPZ2bNn6y2Mq/ZbsWIFCwsLY4zV/3rL8mfelGNR1wdxVNhKSZUTMhFXlWBcXV2Zt7c3++yzz9i+fftYXl5ejW1FbzrZ2ey2vz97ZWgoViSWdO7MhKtWMXbpUmXrqQRVxxAIBGzjxo1s+PDhbNeuXezt27fi52C1J9p3E9nAgQOlT4xPnjC2fTtjY8eKF7l6epWFeHKydMchTabqeUaVr0/S36ksCh95t/5VqS3v2NraSoyjtu2FQiG7du0a+/rrr9lPP/3Enkv5gbmqxXXUqFFs2rRprKCgQOr9ZsyY0eC7btVbegMDA2u9zupk+aGjKceiFltxVNhKSZUTMhH3bpKYO3cu27JlC/v222/ZgwcPxLZdPHZs5aCsVq3+LQiNjJhw0SJ2b9cudiUpqd6WBjc3N5aXl8f27dvHvvzySzZs2DCxfaR5Y1uxYoVYdwVfX9/GJbesLMa++46xXr3Ei9yRIxmLiKi1OCeyoep5RpWvT1KrWVMLDnkNHKvt3IGBgWzgwIHM19eXFRUV1XkN9bUavnr1im3fvp2tX7+eXbx4UaoW1PDwcHblyhX2ww8/sBUrVtQbc2lpKQsLC2Nr165lfD6fFRcX17tP9fM19Gfl5uYm9jPq169fo39GTWl15erDj6KSa2F7/fp19tVXX7FffvmFvXr1qkYg/v7+DQ5CXlQ5IRNxkyZNEvu+d+/ebPz48czZ2ZkNHjyYDRkyhH373nuswsuLCaoVfzmWluyQkxNjhYUNuoU2a9YsNmfOHLZlyxa2Y8eORhWkRUVFzM7OTiyxNel2lFDIWEICY1OnMqah8W+B27s3Y/v2MVZW1vhjk1pJm2eUNZeqch6VVBg19RaxIrTESVs0SRNreXk5O3bsGFu7di07dOgQKywsrPW8bm5uYnnU1dW1zjifP3/OfvrpJ/b111+za9euSd0nt0pjisMVK1YwX19fsb7Ijf0ZKcLPWlXIrbCNiYlhWlparE+fPszc3Jy1a9eOxcfHi57/+++/mZqaWoODkBdVTshE3IgRI1hISAhjrDLB+Pj4sMDAQBYSEsLmDx7MUrp1E2vNvGFtzT62t2eB1VpUpClsy8vL2fHjx9maNWvYhAkT2MSJE5v0abu5boWyZ88YW7WKserdLKytGfvf/6gFV8akyTPKnEtVOY9KKoyaWqzIYgoueWlIYXj//n327bffsu+//549evRI4jbSttgKhUJ28eJFtn79erZ9+/YaH/SqYmuO16moqIgNGjRI7LHGNihQq6vsyK2wtbe3Z2vWrGGMVf4ifvfdd0xfX58dP36cMabYyZgx1U7ILd27SW/8+PE1Wj/nOToyNmOGqIVWwOOxCAMDdu/IEYktA/UVtq9fv2ZBQUFS35aT9jpk/cYqJieHsU2bGDMxEZ/ZISJC4ry4pOGkyTPKnEtbWh5tarFS399vU/6+uS6Kc3Nz2d69e9mXX37Jjh8/zpYvXy4WS1V8dfWxLSwsZHv37mVDhw5lQ4YMYR988EGtXbVklQfffd2qzx5BLa2KQW6FraGhIUtNTRV77NChQ0xPT49FRkYqdDJmrOUlZEXVHMn43aQ3cuTIf28v5eayFE9PVq6m9m8xN3Uqi/npJ+bu7s7WrFnDXF1d2cSJE8Xiqa2wFQqF7MKFC8ze3p716dOHzZ8/v1nfUJpltGx+PmMbNjDWuvW/r4mTE2MSpvQhDSNNnlHmXEp5tGHqK4yb8vetCLe+BQIBS0hIYMOGDWPLly9nb9++FYulrgaC9PR0tmXLFjZy5Ei2fft2xljldSxbtqzGe4Qs8+C7r9uyZcuopVXBNCXPNGiBem1tbeTk5Ig9Nn36dOzevRvTpk1DWFhYQw5HWihp1iBvqLS0NHh4eAAAPDw8YGhoiI6mpri0bBleGxujW0QENIRC3OvSBZveew/uBQU4lpqKP//8ExkZGTA2NsbEiRMxYMAAUTw8Hg8dO3ZEx44dRctAlpaWIjQ0FIGBgXB0dMS1a9fg6ekpk2uojbRrmzeIvj6wenXlAhCrVgHa2kBcHGBnB3zwAfDmTdPPQWpFubTl0NHRwdatWxEdHY2tW7fWmHS/KX/f7+a91NRU2QUuJTU1NYwdOxatWrXC9evXMXz4cPzxxx948OABgHfyKACUlkKYnY2zf/yB6B9/hE1JCewEAgT06wckJMBFTQ3FoaHQjYuDJ4+Hqdra+H3KFHgzhqTVq4GwMCR99hk81dSA48eB2Fjg9Gng3DkgKQm4cQN48KBykZtXr4DCQkAoFIv53dctIyOj1p9RcXExAgMD4e7ujsDAQBQXF8vrpSWN1ZAqePz48Wzz5s0Snzt06BDT1NRs9laGX375hVlYWDBtbW02cOBAdubMGan3pZYGxdAcLZDvfgL/ZtYsxkaN+rc10saGsaNHa43nzZs3bMeOHWzdunWse/fuEgdEPH78mG3dupVt2LCBjR49WubXUJt3W3yys7Nlf/sxPZ0xX99/Xy8TE8YOHaLuCY0gTZ7hOpdSHlUcTenqwEmLrUDA2KtXrPjaNbbV15d9PXAg+33cOPaLuTm76+HB0saNYxfMzNhZPT0mGDKEsZ49GevcmTEjI8bU1Ztv2fH6vnR1K/OajQ3Lat+evbK1ZczTk2WNG8dO9+/P2Lp1jP38M2O//85YbCxj164x9uQJ+3/LlnHeKt4Sya0rQmhoKFu5cmWtzx86dIg5ODg0OAhpHT58mGlqarKdO3eyu3fvssDAQKanp8cyMzOl2p8SsmJojmRc9ebgOWkSi7a3Z0ItrX/ncd20SWxFMEnxhIaGsoqKCrZ+/XrWq1cv5uLiIlrhRigUsr/++outW7eO7dixg71584bTW4DNeu7TpytnTah6M5g0ibFaBoYQyaTJM1zmUsqjqkOmg5WEQsZevaqc8zoykrFff2Xs888ZmzePsYkTGbOzY6xDB5kVp0J1dcYMDJiwfXv2Rk+PZWppsTRtbXZfS4s9NDRkGaamTDB0KLtpaMjSOnasbKgYOZKxESOYYOhQ9sjUlD00NGRP2rVjgl69KhsvzM0ZMzWtLKKr3gNk8FWorc2y9PRYSufOLL5jR8Y+/JCx779n7I8/GDt7lrHMTMbKy2v9GSnK4EBl0pQ8w2OMMe7aixtm2LBhGDhwILZv3y56rFevXvDy8sLGjRvr3b9q7eG3b9/Wuvawmtq/vTOE79y+oG1ls21xcTFWr16Nhw8fwsbGBhs2bJC4Jnb147LKD2F1x3DtGjB3LnDrVuU+kyaB/forYG6O4uJifPzxx7h48SLKy8thYGCA1q1bw8bGBh9//DEcHR2ho6MDQ0NDbN26FbNnz4a/vz/Gjh2LW7du4cmTJxgxYgQcHR2hrq6O4uJirFmzBqmpqaJr0NXVFXVZqC9eHo/X6G3d3d1Fty4BiNYyb+pxRduWlQGbN4P39dfglZWB6ekBW7aAt3gxwOM16LhA3b8TirAtINvf97y8PLRp06Zxa5zLAeXR5t+2Kselp6fD2toamzZtgra2doOPW3WctLQ0WFtbY+PGjdDR0Wl4bqzaNjsbLDUVePQIePQIvEePgIyMytv2WVngNeA2e76mJgwsLID27cGMjRFx9iz6jh4Nq0GDcOvJE4ScOoU3FRUQGhhg5pIlyBUIcDczE1b9+mGCtzdaGRiguLgYLi4uUFdXR//+/ZGVlYVZs2bB19cXUVFR2Lt3L168eIHY2Fix94iVK1fCyckJkydPRnR0NOLi4vDjjz/WfB2EQqCoCP/98EM4Dh2Kq4mJsO/bF6Pt7HDl9GmkX72KKS4u4L19W9n9quorOxu8V68quzIIBNK9IGpqYJ07A+bmQNeugKUlWNeu+Pn4cfRwdcX4uXMRfewY4uPjsXXrVsqjzZhHG1TYvn37FgcPHsScOXNqnCg3Nxf79++X+JwslJWVQVdXF0eOHIG3t7fo8cDAQFy/fh2JiYk19iktLUVpaano+7y8PHTp0gUJCQnQ19evsb2RkZFY/6bk5ORafzgGBgbo3r276PsbN26goqJC4ra6urro1auX6Ptbt26hrKxM4ratWrVCnz59RN/fuXMHJSUlErfV0tKCra2t6Pt79+6hqKhI4rYaGhqws7MTfZ+SkoL8/HyJ26qpqWHAgAGi71NTU5GbmytxWwAYNGiQ6P/p6el4+/ZtrdsOGDBAVNwuXboUqampMDMzwwcffIBWrVqJbWtnZwcNDQ0AQFZWFl69eiX5oAIB7GJjobFuHVBRAUHbtsj88EO8nTAB+OePcsuWLRg0aBAcHR3x9ddfY9asWfDx8cG+ffuwdetWzJw5E46Ojjhz5gyio6PRtm1bdOrUCefPn4eZmRk2btyINm3a4MmTJ7VeW/fu3WFgYAAAePXqFbKysmrd1sbGBkZGRgCA7OxsZGRk1LqtlZUV2rRpA6Dyb3Dp0qUYOnQoxowZgzNnzuDy5cv46KOPAACmpqbYvHkz0tLSYGZmhlmzZtV4XauYm5ujffv2AID8/HykpKSIPa+dkYGuGzbA4Nq1ygcmTQJ270ahoSHu379fa7wdO3ZEp06dAFS+Md+9e7fWbU1NTWFmZgag8m/81j8fSiRp3749zM3NAQAVFRW4ceNGrdsaGxvDwsICQGXSTE5OrnXbNm3awMrKSvT91atXa91WmhxRUFAABweHOhMyV7mU8mhNzZFHt2zZgmHDhmHlypWIiopCXFwcPvjggwbn0S1btkj8W6/KowCQkZGBp0+f4ueff8aTJ09g3q4dOuXnQ+/JE/TR1IRXr17QzMwEUlOl6ztvagp06YLitm2Ro6eHM6mpSC8uxuOKCgz18MDASZMQk5yM3fv3w9TUFP3790efPn1w6tQpqKur48mTJ8jPz8f06dPh4OCAbdu2IT4+Hv369cMXX3wBGxsbPH36VPQ6DRw4EOPGjcOZM2ewfft2XL16VZRH7ezs8Ouvv9bIYStXrsTWrVtFedTd3R2//fZbrXl05cqViIyMxKxZsxAdHY23b98iPT1ddJx3WVhYwNjYGBAK4ePoiK8++AAab95A8/VrRO/ahfdGjYLWy5fQfPkSum/eQP35c6C8vM6XVailBWHXrkjKy4P9rFko7doVGdraKLG0REXr1qL3qiqUR+vPo7XRaMjGP//8M27evInly5dLDPSvv/5CXl4ePvvsswYFIY3Xr19DIBDA1NRU7HFTU1P8/fffEvfZuHEj1q1bJ/NYSNOtWrUKI0eOxAcffIAzZ87g559/FhVnDaH19Cks1q6FxvXrlQ94e+PF2rV4+86b45MnT0THLykpgY+PDwDAxcUF33zzDRwdHQEAY8aMQXBwMNzd3XHnzh307dsX6urqSEhIgIODQ6OvV5Li4mKsWrUK9+7dg7GxscTiXpIPPvgAP//8M0JDQ0UfCqqsX78eHh4e2LZtGw4fPtzo1xUASi0skBIUBJPff4fZL7+Ad/w48rp2xeFx49Dnv/+VKlYiGVe5lPKofDx58gSffPIJgMo7KsHBwY0+TtXf75gxYxAaGvrvk0VFwL170D99Gm9278Y3PB465+ZC++xZ8YPcvi32bVm7dijr3Bml/3yVdeyIso4dUdqxI3qMGwetf4rK7CdP8PHHH2Oovz9cxoxBfHw8Yq5dg62JCa7duoW1a9di+vTpCA0NxcaNG7F161ZRTqhqUb1z5w4MDQ2hrq4Oc3NzXL58GTweT1SEv379Wuz6/u///g98Ph/+/v6IiorCsGHDJOYZMzMznDlzBjY2NlINuDMzM8OJEyfQtWtX+Pr6oqCgABUVFTAxMcGWLVvw5MkTyQ0samow6dULsU+e/PvhYvhwjFy5UrSJubk52hsbAy9eoPDePby4dAlaz55B+/lzaD17hqJbt2BSVAT1sjKoPXwIewDYsgXaAHr8c4wKIyOUWFig2MoKxdbWKLGygtrIkcA/hS1poIb0W7Czs2OnTp2q9flTp06x/v37N+SQUnv69CkDwM6fPy/2+Ndff8169OghcZ+SkhKWm5sr+nr8+DEDwN6+fcsEAoHEr+pq24a2bfq2bm5uTCgUih53dXWt87jVt636Kj54kBX904+qWFOTlQYHMyYUStx2+fLljM/nM4FAwHx9fUWLN0RERLARI0aw8PBwJhAI2IEDB9i4cePYunXr2JkzZ9jly5fZ8ePH2datW9nXX3/NkpOTa7226vPYSorh3W2r+soKhUIWHh7OVqxY0eTjVl/ZRygUSnxdG3Pcb95/n+VYWYn6nCX268cERUX1Hre+3wlF2FbWv+9v376tt28YV7mU8qh8tl2+fDkLDw9njP3bD74xx12+fDkLDwtjgowMdmHNGhY9fDgT+voy1q0bYzxe7f1XjY2ZcMQIJpw7l+3t0YOxkBDGbtxgwvx8qWOQlD9Gjx4t+re6d7cLCAhg//nPf9gXX3zB1qxZw2xtbdnw4cOZk5MTGzx4MPv6669ZeXk58/HxYUeOHGECgYCFh4czb29vZm9vL+ozXPjPCpDvfhUUFLAVK1YwV1dXUd/iunJY1fa2trYsJCSECYVCxufz2fDhw0W5v3oOrp4/CgsLRedasWIFKygoqDXXSIqhoKCArfzgA+bv4MB+8fRkpT/8wNiKFUw4cSITWlgwYR0/R2ZiwpizM2MffsgE+/YxwfXrTFBS0qR8p0p5tDYNKmz19fXrHGCQmZnJDAwMGhyENEpLS5m6ujoLDQ0Ve3zFihVszJgxUh2DBj00naw6wlcfABUaGsrs7OzYihUrpBvxX1LC2IoV//7x29uzUzt2SJz7sHrcy5YtY4MGDWK2trZsxIgRbNKkSaJZBgIDA9no0aOZvb0927JlC3v69CkTCP6df7GoqIiFhoaytWvXstDQUFZSx2A0acljdghZDSxzc3NjrLSUsU8++fd1HziQsYcPZXJ8VSJNnuEql1IelY/qg7qWLVvGli5dKl3OFAoZy8hgjM9nbNUqVuHkxPJ1dGovfNq1Y8zRkSX268duLF3KWGIi83d3F/18m5oDqueTiIgINnLkSObm5sZGjhzJIiIiJJ4jIyODbdq0iY0cOZKNHTuWjRgxgm3atIlduXKFhYaGsu7du7Mvv/yS7dmzh/3999/MxsZGdsuIVyPpverdY9va2op9P3DgQPkP8iosrByw97//MbZmDWOenpUD4WoreLW1GRs8mLHFixnbsaNy9gYVXB5dbrMiGBkZsQsXLtT6/IULF5iRkVGDg5DW0KFD2ZIlS8Qe69WrF1u1apVU+1NCbrraCqeGFrxViX/gwIHM19eXFRUViRZWqLMwy8hgbMiQf//IP/5Y9Efdr1+/RhV1JSUlEovW6oVt1SfM69evs2+++YZt27aNPX36VKrj16Y5Z4eQ9UTj1WO9+MUXLL9Vq8rX38CgctUyIiJNnuEyl1Iela/aPsQXFRUx9uYNYydOVE415epaWahKKmbU1RmztWVs5kzGNm+unI7q779F53i3kF62bJlMckBt+UTS4wKBgJ0+fVpUtFb9fri6uorl0X79+rFdu3ax77//ns2ZM4cNGDCgWT6MS1qEofpS61WFevWfja+vr8zjaLSCAsYuX2Zs1y7GPviAsdGjK/OtpN+PVq0Ys7evbPA5eLCyWFZycitsHRwc2Kefflrr85988olcpvvavXs3u3v3Llu5ciXT09NjGRkZUu1PCbnpamtlbGyRVt8naLHnExL+Tfxt2rBgd3exc0pa77u+gvvp06ds27Zt7JtvvmE3btwQe05SYcsYY9nZ2Sw4OJitX7+enT9/vtFL6SrTuuI1Yk1JEZ8neO3ayvktiVR5hstcSnlUvkQ5TChk7N49ttXWlmU6O7PnbdtKLlI0NBgbMICxRYsYCw5mLCmJseJibi+iHjk5OWzPnj3syy+/ZAkJCWL5cvny5eyHH35gV65cYeHh4aJVviZOnMgmTpzIPvnkEzZ58mTRHTRZ5cF331v69u3LvLy8mJ2dHevXrx8bMWKE6G6dm5sbs7OzEzt3c85N3lBV72Purq5s/ezZrPTAgcq7Z05O4qtHVn0IkrB0sbKRW2HL5/OZhoYG++mnn1hFRYXo8YqKCvZ///d/TFNTkx05cqTBQTTEL7/8wrp27cq0tLTYwIEDWWJiotT7UkJuutoK2MbeVpe0FG6N4wuFjP3yS2XCByqT/qNHNYotSet91xavUChk58+fZ+vXr2fBwcHsyZMnNQrg2gpbxip/52NiYtjatWvZwYMHJa6BrvLKyhhbvvzfhOrhwVhODtdRcU6aPMN1LqU82nAN7oZVXs7Y5cssbNQo9nzYsNpbY21sGJsxg7Ft2xi7cEHhi9h33b17l23atIn98MMPErvXFBQUsGnTprFRo0axpUuXinXLKCwsZGfOnGHDhw9nffv2ZQsWLGiWu0yRkZGse/fuLDIykhUVFTFfX1/Ws2dPse5v79495LzFtpo6G46EQsZSUipbalesYGzWLG6ClDG5FbaMMbZmzRrG4/GYoaEh69+/PxswYAAzNDRkampqdbZAKIKWmpBlqbZWxsa22EpaVWvZsmVs4MCBzM7Ojn2weDErnzfv3zeBadNqvc0iKTZJBXdBQQE7cOAAW7t2LYuJiWEVFRUS4xcKhezx48fs8ePHtbbKPnz4kH333Xds8+bNLDU1VaprVjn79lX2+wIY69WrchWzFkzaPKOsubSl5tF6c1x5OWOXLlUuCDNhAmP6+jWK2BI1NVYxahRL8fNjOzw8GHv5st7zymOC/8aco6ysjEVHR7O1a9eyw4cP17pP9Ty6fPlyiY0Pv/32G/v555/ZzJkz2bRp0xp9F+zda6r+fjBw4EDGWN2NKVVdRRTtDlpzjMdQdHItbBlj7PLlyywwMJC5urqKbh9cunSpMYeSq5aakOVBlrfVRYknJ4e97N+/8k2Bx2Ps228bvMTru0lszpw5bPPmzey7775jD6sNfGpK4sjPz2f79+9nX375JTt58qRYC1yLkZRUuWxm1Ujeixe5jogzDckzyphLW2oerZEjXF0Zu32bsa1bGXN3Z8zQsGZrrJFR5XPffceKExLYhx980OAcKY9VDht6jhcvXrBffvmFffXVVywpKUnqQlRSnq16rKysjEVGRrJu3bqxP//8kxXLuOV66dKlLDQ0tN7ub7a2tgq3QhiXK11yRW6FbWFhIVu6dCnr1KkTa9++PZs2bRp79epVg0/KlZaakJWNm5tb5RKFfftWTuWlrl65xGMjVBXcrq6uzMvLi61Zs4bt379ftFxulaYmDqFQyM6ePSu27K6ik3lL0JMnjFV9EGnVirFm7pakqKTJM8qcS1tqHl2xYgU7sX8/YwcPsixHR5ajp1ezkG3dunJU+9atlSPdZfAhVx6tddKeQygUsqSkJPbVV1+xX375hWVkZDQoh0jKs+8+NnPmTLZx40b2448/sqysrBrHaGzeqnov6Nevn9isEdVbbMPCwlhgYKDCFY/KNB5DVuRW2H700UdMV1eXLVy4kK1YsYK1a9eO+fn5NfikXGmpCVkR1ZWcvp0+nRX/M7CiuG1btnn69CadKzs7m+3YsYOtW7eOnT17VtS6UD2GxYsXs+HDhzNbW1s2cuRIlp2dzRirnB6ptLRU6muZN28e27x5M9uwYQO7efOmVNfLlWZpBcjPr2yhqnqj//HHph9TyUiTZ5Q5l7aoPFpRwdi5c4x99hkTVH1oe3c0uosLY999x9iVKzIpZN+lKC22RUVF7I8//mBr165lUVFRrKysTOrYqvKopAJN0mNv375lu3btYuvWrWOJiYliYxya+npI6v4WGBjIbG1txYpGrm/3K+J7hjzJrbC1srJiv//+u+j7S5cuMQ0NDaW59dqiErKCqzU5JSQw4T+39B4ZGLC1/v6N/oMuKipi77//PuvRowcbM2aMWNeDd2OQNNVLXYPH6rqWZcuWMT6fz9auXcvCwsJYaWmpxOvlOnE1W0tQRYX4oLJVqxrchUSZSZNnlDmXqnwezc6unFN0+nTG2rSpWcz27185Iv3UKbkM9JJVa11d+aa+c2RmZrIffviBbdy4kd25c0f0uDQ5RNo8Kmm/uLg49uWXX7J9+/aJft+aK28p2u1+RYtH3uRW2GpqarInT56IPdaqVSuJtwsUkconZCUiMTlFRPw7CGnMmCaNsC8tLWVubm5s2rRpjM/nMz6fXyMx1JUg3dzcSIc/YQAA0whJREFUpE7Iko4jFApZcnIy+/rrr9lPP/3Exo0bJ7bNpEmT5Ja4antDa9bzC4WMbdjwbzEwb17l4JoWQJo8o8y5VCXzaEpK5fywo0czpqYmXsi2acPY1KmM/fYbY8+fcx1pozXm710gELCEhAT25Zdfst27d7O3b982+JiNLWyrpKensy1btrBvv/2WPXjwoNnylqLd7m+JA8aqa0qeUWvI8rsCgQBaWlpij2loaKCioqIhhyEE1tbWiIqKQnFxMfz8/DDozh0IvLyA0lJg8mTgxAnAyAjFxcUIDAyEu7s7AgMDUVxcXO+x//77b+zYsQOpqan49NNP4ePjA19fX6SmpkqMAQDCwsJEa4RLs/Z4bcep2pfH46F///5YvHgxNDQ08PDhQ3z33XdgjCE8PBx5eXlIS0uDh4cHgMr15N+NT1ZWrVoFZ2dnREdHw9nZGatXrwYAbNq0CXFxcXB3d0dcXBw2btwou5PyeMDq1cDOnYCaGrBnDzBlSuXPl1Au5RpjQFISsGYN0Ls30L078PHHwF9/AUIhYGtb+ft79izw8iVw+DAwezbQoQPXkTdaQ/NNXl4e9u/fj4SEBIwZMwZz585F69atxbaRdQ6RlO8tLS2xZMkSmJmZ4dChQxg3bhxOnjwp87ylo6ODrVu3Ijo6Glu3boWOjo5MjttYkt5XiHR4jDEm7cZqamqYNGkStLW1RY9FRUVh3Lhx0NPTEz0WGhoq2yhlJC8vD0ZGRsjNzYWhoSHX4bRoxcXFWL16NU6fPo199vYYEBwMALjcqxeG3rwJaGgAAAIDA+Hs7AwPDw9ERUUhLi4OW7dulXhMxhguX76M2NhYmJiY4OrVq/Dw8Kh136oYUlNTYWFhAQDIyMiAjY0NNm7cCG1tbSQnJwMABgwYADU1yZ8Dqx+nat/qSbGiogLDhw+HhoYGSktLMWLECKSnp6N79+5SX1v1c61atQppaWmwtrbGpk2b6k3A7u7uiI6OrvX7ZhcRAUydWlnUTpoEhIQAHL9pNCdp8owy51KlzaMCQWWhGhIChIUBT578+5yGBuDgAHh6Au7uwD/5QJU0JJc+ePAAERER0NDQgI+Pjyg/NoZQKJQqj9YW48aNG7Fq1SqkpqZCX18fPXr0QKdOneDn54d27do1Oi5FV9/7iqprSp5pUGHr7+8v1XZ79+5tUBDyorQJWYUF9+mDxXfvVn4TGAiPhw8RdfSo6Hlpi7LCwkJEREQgJSUFw4cPh7OzM8rLyxucGKoXjlZWVpg6dSpatWpVb0KuT2BgIHr16oW8vDzcv38fjDH8+uuvDY6vIW9OTdlH5k6dqmyJLy4GnJwqi91qBZwqkSbPKHMuVao8KhQC8fEAn19ZzL58+e9z+vqVH7S8vQFXV8DISOrDNuYDJtekKZQqKioQGxuLy5cvo0ePHvD09ISurq5o/4Zec3FxMT799FMkJyfDzMwMu3btEvvg9i5J+d7a2losf0VGRsLOzg65ublwdXVF//79wePxmvDKEEXUpDwjyz4Rik4l+4Ypsy1b/u3H9sknLDIiokZ/KWn6U73bB6spqp8vPDycTZs2rdF9w6qr6r81YcIENn78ePbZZ5+xuLi4Bh+3Mf2uFKbvWGIiE/4zaf2ttm3ZxwEBnPdjaw6qnmeU6fqKCgrYm2oLJQjbtGHM35+xqKgmDfxSxYE9L1++ZL/++iv76quv2KVLl2rMTduYa16xYgULDw9nV65cYT/88ANbsWJFvdu/ew5JOa+0tJSFh4eztWvXMj6fL/M5bwn35NbHlhCZ2bwZ+OgjAEDM0KFwv30bcfHxNfpL1dWHSyAQIC4uDvv370e7du2wZMkSdO/evUlhvdsP7Un125VNUNV/68SJEzhx4gQmTJiAs2fPYu/evcjJyZH6OA3td1XVypKamgpra2tub2eNGYOtkyahXFcXfd+8wadnzmDtP78DhDSHVWvW4KWHB7BwIS6uW4f/zJhR2d/b3R34p099Y8irf7w8MMZw7do17NixAwKBAAsWLMDQoUNrtII25pqr7zNmzJh695GU79/NeRYWFvj444+xc+dOPHz4EHfu3EFwcLDMcnVjNWY8CGkeVNgS+fu//wM++aTy/+vWYcKlS4g+elRih/3aOvTn5ORg3759OHfuHMaNG4dZs2bBwMCgyaFVT6LR0dHo1q0b2rdvL9NbXWpqahg9ejT8/f2Rn5+PoKAg3LlzR6p9GzpYo7aBY81BmsQeV1QEzcREwNAQxnfvYsYffwBFRc0WE2nZ0tLS0OPQIWDHDgz/4gukPHokk+OqysCekpIShISEIDIyEra2tli0aBE61DJArjHXbG1tjejoaLRv3x43btyodx9J+f7dnMcYE+W0adOm4dmzZ9DT08OePXtw9uxZMOl7V8qUPHMtqVuD+tgqO6XqG6aqgoOBgIDK/3/xBbBunVS7Ve/f1bp1a/To0QMGBgbw9fVFly5dZBaevDrsV11PSkoKeDweBgwYgOHDh2PixInQ1NSU2Xne7bM2adIkdO/evVn6BkrTl1e0Tfv2qBg3DhrFxYCLS2Wf2ya0oCkSVc8zynR9zdW/XBUG9jx58gR8Ph8lJSXw8PBAnz596ty+MdfcHK+TpH64EREROH36NM6ePQsrKyv4+PhAX1+/SeeRRVxyHaSrYuQ2eEzZKVNCVkm//QbMnVv5/08+ATZtqpwWSgqBgYFwcHCAhoYGDh06hLy8PISEhKBVq1ZKOZCj+htuZGQkDh8+jD59+qB169bw8/ODqampzM8TFRWFb7/9Fp9++mmzDCSTJrFXf6Mbr6ODFcePg1dYCLi5VQ7ukWFRzxVVzzPKdH2qUIDKGmMM586dQ3x8vGh2gXen8VJkdX1YSUtLQ1hYGBhj8PLyQrdu3RQiLtJwVNhKSZkSsqop/f13aM6YATXGkGhnh6Hnz0NHV1fqonT8+PHw8vJCTk4OJk2ahP/+9784+s/sCc2ZUKrmFdX4Z/oxWZFUBO7duxd8Ph/Z2dlwcXHBkCFDmtwF4t039pSUFBw7dqzWOJqiUT+HxMTKkenFxcD77wMHDlTOe6vEVD3PqPr1qbL8/HyEhYXh0aNHGDVqFBwcHKCurt7s55VlHq3vw0phYSHCw8Px8OFDjBgxAk5OTnK5RvoQJVs0K4KUlGk0r0qJi2PlVav5LFggNvtBfSNthUIhu3TpEhs+fDgLCAhgL1++rLFdc63Q0tQVc+pS23WXl5ezo0ePsrVr17Lff/+dFRYWyuW8stDo2ReOHmVMQ6Py9+ODD5R++V1VzzOqfn2qKiUlhX377bdsy5YtLD09vcbzzbXEd3Pm0doIhUJ2/vx5tn79ehYcHMyys7Plcl4iO03JM9RiS5rXlSuAoyNQUAD4+AB//gmoq4taCuu6fV1UVITIyEjcv38fdnZ2OH36NNLT02t8Gm6uFtuGTCzeUPV9ur9//z4iIiKgqakJX19fdO3aVS7n5czvvwMzZlROytSAvteKSNXzjKpfn7zIqwtVRUUF4uLicOHCBXTv3h2enp4S55JVxjxan2fPnoHP56OgoADu7u7o16+f3M5Nmoa6IkiJErJs1ZuYU1KAkSOB16+RYmaGh1u3ws3XVyxp1pZMMzIyEBoaivLycnh6eqJnz551xtEcxRqXCRmo/H0NDQ1FZmYmxowZg7Fjx8o9Brn69Vdg2bLK///0E/DBB9zG00iqnmdU/frkRR59MrOzs8Hn8/Hy5UuMHz8ew4YNq7V7U3MNfpKUR+U5LqK0tBTHjh3DjRs3YGdnB1dXV7EV/4hiakqeUeF3SdLc6pze5MULYOJE4PVrYNAgdLl6FSf/+qvGNFXvTuXyzTff4PTp0/jtt9/Qtm1bLFmypM6iFlC8Nb5lxdDQELNnz4aDgwPOnDmDffv2ITc3l+uwRGQ+b+PSpcD69UCbNsCQIbIJkhAF1Zxz4TLGcP36dQQHB6OsrAwLFizA8OHD6+yzL88pzOQ5NZa2tja8vb3h4+ODe/fuITg4GM+ePWu28xHuUYstabRaP+EXFlZ2P0hKAqytgfPnAROTeo+Xm5uLkJAQPH78GA4ODhg9erSohbKuT/jN9emf6xbb6rKyshASEoKysjJMnjwZvXr14iyWKs3S4sQY8Pw50KmTTGLkgqrnGVW/Pnlprhbb0tJSHD16FDdv3kT//v3h6uoKLS2teveT550vrqbGevPmDfh8Pl68eAEnJyfY29vTcrwKilpsCSckfsIXCIDp0yuLWmNj4NgxwMRErHVv2bJlWLZsmVhL37179xAUFITc3Fz4+/vXuO1e1yf8ljAxtrm5OQICAmBhYYE//vgDR48eRXl5OacxNUuLE4+n1EUtIdJq6GIr0nj69CmCgoLw4MED+Pr6wsvLS6qiFpDvnS+uFrho27Yt5s+fj2HDhiE2Nhb/+9//UFBQIJdzE/mhwpY0Wo3EvGEDsHIlEBVVOdl+ZCTwzxK37xafL168QHR0NBwcHDB16lT88ccfsLCwQEBAAMzNzWucq64iSpWWt6yLjo4O3nvvPbi7uyM5ORk7d+7Ey5cvOYtHVVZfIoQLsiwk2T9z0+7evRu6urpYvHgxbG1tZRarrLsdNUdRLy11dXW4uLhg5syZeP78OYKCgpCWlia385PmR4UtabR3E7N6UBDw888QAtgzbhyKBwwQbVu9+PT29kZJSQlevnyJ58+f48GDB3B3d8d7771Xa3Kvq4hqrgKLx+PB2NgYxsbGCnO7isfjYfDgwVi0aBEAYOfOnbh69Sony0hy+eZECKlUUFCAgwcP4uTJk7C3t8e8efPQtm1bmZ6jKXfFJOVRRRgXYWNjgyVLlsDU1BQHDhzAyZMnIRAI5B4HkT3qY0tkIyYGwkmToMYYsHkzonr0EOszVr0/WWhoKH755Rc4Ojri6dOnEAgE2LFjR52Hr6v/l8JOYdXMysvLERMTgytXrqB3797w8PBoEdet6FQ9z6j69SmT27dvIyAgANnZ2Rg6dCiCgoKaJQeo8nKxjDGcP38ecXFx6NixI3x9fWX+waC5KOOqm9Ki6b6kRAm5mdy7B9jbA7m5gL8/sHs3wOOJJb+q4vPBgweoqKjAvXv3oKGhgU6dOiE6OlppEokiunv3LiIjI6GtrQ1fX1+JXTmI/Kh6nlH161NU1YsYS0tLuLi44Ouvv8bIkSOxfv16nD59utmWcW0Jy8U+ffoUfD4fRUVFcHd3l2lXjuaiyj8XGjxGuJOdDXh4ALm5SOvUCUfd3QEer0aXAB0dHXz44YdwcXFBUVER1qxZg4yMDKxevRrr16/n8ALqJhQKIRQKuQ6jTr1798aSJUtgZGSEvXv3IjExUeFjJkTZyXy6u3pUdQfYv38/hEIhNmzYAHV1dXz//ffQ19dv1vEFTe12pAx5tHPnzggICED37t0REhKC8PBwlJWVcR1WnVrK+JKGosKWNF5FBTB1KpCWBlhYoNOFCzh55kyN5CcUCpGYmIi9e/fCyMgI+vr6WLp0KQDF/mOsmqYmOTlZ4ZOykZER5s6dizFjxiAhIQH79+9HXl4e12ERotCaUpzKezaWtLQ0dO3aFUFBQejRowf09PQwZMgQ0V2x5hzA2ZQ+scqUR7W1teHj4wMvLy/cvXsXwcHBeP78Oddh1YoG8EpGhS1pvFWrgLg4QE8PiIqCjrm5KPlt3LgRq1atwoQJEzBhwgScPHkSY8eOxdy5c9GzZ0/6Y2wGampqcHR0xJw5c/DmzRts374dDx484DosQhRWU4pTebaWlZaWAgA2btyInj17wszMDH379qUBnM2Ax+Ohf//+WLRoEbS0tLBr1y5cvHiRkwG69aGfv2TUx5Y0zu+/A++/X/l/Ph/w9RV7OjAwED179kReXh5SUlLAGMOePXsAKM9gL0VaoKGhioqKEBkZifv372Po0KFwcXGBhoYG12G1CKqeZ1Tp+poyKEpe/RufP38OPp+PN2/eICUlBbm5uQqdN9+lzHm0oqICp06dwsWLF9G9e3d4enpCT0+P67BahKbkGXqnIw134wYwf37l/1evrlHUVlRU4MKFC2jTpg169uyJ5cuXY9iwYRg1ahQMDQ3RrVs3lRq9qYh0dXUxdepUJCUlITY2FpmZmfDz80P79u25Do0QhVF1K7eqOG3I3aNNmzZh9erVCA4OFhWassQYw8WLF3Hq1CmYmprigw8+gLGxsUzPQeqmoaGBiRMnwsrKCuHh4QgKCoKPjw8sLS25Do3UQXk+OhHFkJ0NeHsDxcXAhAnAV1+JPf3q1Svs3LkT6urqMDAwwNSpUxEbGwsjIyN89NFHOHbsmMquDqZoeDwehg4dioULF4qmVLt27ZpC3lIjhAtNuZXbnHOxFhYW4tChQ4iJicHQoUMxf/58Kmo51L17dyxZsgTt2rXD/v37ERcXR3PeKjBqsSUNk5AAZGYCVlbAoUOAujqAytaF5ORkHD9+HK1bt8bvv/+OrVu3ws7ODuPGjYOBgQG8vLwAVPZHCw4O5u4aWhhTU1MsWrQIJ06cQGRkJNLT0+Hu7o5WrVpxHRohnKoqThVJeno6QkNDwRjDjBkz0K1bN65DIgAMDAwwa9YsnDt3DqdPn8ajR4/g5+eH1q1bcx0aeQe12JKG8fUFYmKAsDDgn7lnS0pKwOfzERkZiX79+mHhwoWwsLDA1q1b4ejoCCcnJ3Tv3h3h4eEAaMAYF7S0tDB58mRMmTIFqampCAoKwpMnT7gOixDyD4FAgFOnTuHAgQMwMTFBQEAAFbUKRk1NDaNHj8a8efNQUFCAoKAg3Llzh+uwyDto8BhpksePHyMkJAQlJSXw8PBAnz59xJ6vvjBDfn4+DA0N0b17d6UY+CAUCpGRkQEAsLCwUKpBD3XJyckBn8/Hs2fP4OjoiFGjRinMksGqQNXzjKpfHxfevn2LkJAQPHv2DOPGjcPIkSNV5m9SVfNoSUkJoqOjcfv2bQwcOBATJ06ElpYW12GpDFp5TEqUkGVHKBSKbsl07twZvr6+Db4lo8rLASo6gUCAhIQEnD17FpaWlvD29oaBgQHXYakEVc8zqn598nb79m1ERUVBV1cXvr6+MDMz4zokIqXqXfCMjIwwZcoUmJqach2WSqDCVkqUkGUjPz8foaGhyMjIwOjRozF27Fio/9PXtiFUeTlAZfHo0SOEhoZCIBDA29ubbn3KgKrnGVW/PnkpKyvD8ePHkZycjL59+1K/dyX26tUr8Pl8ZGdnw8XFBUOGDFGZFneuUGErJUrITZeSkoLw8HCoq6s3edqTd+eMHDRoEM6ePUuttnJWWFiIiIgIpKSkYPjw4XB2dqY5b5tA1fOMql+fPPz999/g8/nIzc2Fq6sr+vfvT4WQkquoqMDJkydx6dIl9OjRA56entDV1eU6LKXVlDyjGp1dSLOrqKjAiRMncOjQIZiZmWHJkiUNKmolLV1pbW2NsLAwAJUDyiwtLRVqGjChUIirV6/i6tWrCr8UZFPo6elh+vTpmDhxIpKSkrB7925kZ2dzHRYhKocxhkuXLmHnzp3Q0NDA4sWLMWDAAJUualtKHtXQ0MCkSZMwffp0PH78GEFBQaK+xUS+qLAl9crOzsbu3buRlJQk+sNt6CdRSUtXbtq0CevWrRPNIXngwIFmXZaS1I7H42H48OFYsGABysrKEBwcjOvXr9Oct4TISFFREQ4fPozjx49j8ODBWLBgAdq1a8d1WETGevTogYCAALRt2xa//fYbTp8+rdIFvSKi+42kVowx3LhxA8eOHYOBgQEWLFiAjh07NupYaWlp2LZtG4B/57HV0dHB2LFjxfrZ0jRg3OrYsSMWL16M48ePIzw8HGlpaXB3d4e2tjbXoRGitKr3ZZ8+fTp69OjBdUikGRkaGmL27Nk4e/YsEhIS8OjRI/j6+sLIyIjr0FoEarElEpWWliI0NBTh4eHo06cPFi9e3OiiFvh36UpAfB7bpqz8Q5qHlpYWPD094evri5SUFAQFBeHp06dch0WI0hEKhYiPj8f+/fthbGyMgIAAKmpbCDU1NYwZMwZz585Fbm4utm/fjnv37nEdVougFIPHMjIy8NVXXyE+Ph5///03OnXqhJkzZ+Kzzz5r0LxxNOhBOk+fPgWfz0dRURHc3d1ha2vb5GNWzWebmpoqWldd0QeJCYVCJCcnAwAGDBigMvMvNsTbt2/B5/Px/PlzODk5YcSIESrdH1AWFDXPUB6Vr5ycHISEhODp06dwcHDAqFGjWmQOoTxa+f4XFRWFu3fvYvDgwZgwYQI0NTW5DkuhNSXPKEVXhPv370MoFCI4OBg2Nja4ffs2Fi5ciMLCQmzZsoXr8FQGYwznz59HXFwcOnbsiNmzZ6NNmzYyObYiLl1J6temTRvMmzcPp0+fxsmTJ5Geng5vb2/o6+tzHRppIMqj8nP37l1ERkaiVatW8Pf3R5cuXbgOiXBIR0cHU6ZMwdWrV3HixAlkZWXBz88PJiYmXIemkpSixVaSzZs3Y/v27UhPT5d6H2ppqF1BQQHCwsKQlpaGUaNGwdHRsVFz06oSamkQl5aWhrCwMDDG4O3tTf2ha6FMeYbyqGyVl5fjxIkTuHr1Knr37o3Jkye3+LlpKY+Ke/nyJfh8Pt68eYOJEydi0KBBdBdMApVvsZUkNzcXbdu2rXOb0tJSlJaWir7Py8tr7rCUUmpqKsLCwsDj8TBr1ixYW1s3+zmVZdUx6uz/L2trawQEBCA8PBwHDx7EiBEj4OTk1OI/ACkzyqOy8+LFC/D5fOTk5MDDwwMDBw6kguUflEf/ZWJigoULFyI2NhbR0dFIS0vD5MmTFfL9T1kpZYttWloaBg4ciO+//x4LFiyodbsvv/wS69atq/E4tTRUEggEiIuLw/nz52FjYwNvb2/o6enJ5dy06pjyYozhwoULiIuLg6mpKfz8/OotjloSZWnRpDwqG4wxXLlyBTExMWjbti2mTJmC9u3bcx0WUQL37t1DREQEtLW14evrC3Nzc65DUhhKu/JYbQmzuqSkJAwePFj0/bNnzzB27FiMHTsWu3btqnNfSS0NXbp0oYQM4M2bN+Dz+Xjx4gWcnZ0xfPhwubYuvLvq2LvfE8X37Nkz8Pl8FBQUwN3dHf369eM6JIUg78KW8ih3iouLERERgfv372PIkCFwcXGhQUGkQXJzcxESEoLHjx/DwcEBo0ePbvHdNQAlLmxfv36N169f17mNhYWFqI/Ss2fP4OjoiGHDhmHfvn0N/uErS0tKc7t58yaio6Ohr68PPz8/dOrUSe4xUIutaigtLcWxY8dw48YN2NnZwdXVtcXPeSvvPEN5lBuZmZkICQlBeXk5PD090bNnT65DIkpKKBTizJkzSExMhLm5OXx9fVv03xagxIVtQzx9+hSOjo4YNGgQDh482Kh+fS09IVcvQvr16wc3NzfOihBlmP5LKBTixo0bAAA7Ozv6FF2HGzdu4OjRozAwMICvry8nH5YUhSLnGcqjTfduEeLj40N9SOtAeVR69GHpXypf2FbdNjM3N8f+/fvFknGHDh2kPk5LTsjPnj1DSEgI8vPz4ebmBjs7O65DUng0mrdhauveoiwDBWVFUfMM5dGmy83NRWhoKLKysui2sZQojzZMUVERIiMjcf/+fQwdOhQuLi7Q0FDacf6NpvKzIsTGxiI1NRWpqakwMzMTe04J6nJOMcZw8eJFnDp1Cqampnj//fdhbGzMdVhEBbVt2xbz589HXFwcYmJikJ6eDi8vL6xZswbOzs7Ytm0boqKisHr1aup2wgHKo01z//59REREQEtLC/7+/jTQhzQLXV1dTJ06VTQgMTMzE35+fjQgsQGUosVWVlpaS0NhYSHCw8Px8OFDmpqpEailofEePnyI8PBw8Hg8HDt2DPHx8aLnVH2goKrnGVW/vneVl5cjNjYWSUlJ6NWrF03N1ECURxuv+hRykyZNwoABA1rMFHJNyTP0G6ai0tPTsX37djx79gwzZ86Ei4sLFbVEbrp164YlS5bAxMQERUVF+OqrryAQCBAVFUULOxCl8fLlS+zcuRPJyclwd3fHe++9R0UtkRtTU1MsWrQI/fr1Q2RkJPh8PkpKSrgOS+EpRVcEIj2BQIDTp0/j3LlzsLKyouVPCWf09fUxa9YsmJmZ4bPPPsORI0cwYsQI/Pjjj1yHRkidGGO4du0aTpw4gdatW2PRokW0/CnhhKamJjw8PGBlZYWoqCgEBQXB19eXlmmuAxW2KuTt27fg8/l4/vw5nJ2dMWLEiBZz24IoJh6Ph3HjxuHIkSMICQlBUVER0tLS0LdvX65DI0Si4uJiREVF4e7duxg8eDAmTJhAc9MSzvXp0wedO3dGSEgI9u7dC0dHR4wcOZK6dkhAha2KuH37NqKioqCrq4t58+bVGBxCGsfAwIDrEFSCmZkZFi9ejKNHj4LP5yMtLQ2TJk2ClpYW16ERIvL48WPw+XyUlpbivffeQ+/evbkOSSVQHpWN1q1bw9/fHwkJCYiPj0d6ejp8fHzo9X0HDR5TcmVlZTh+/DiSk5Nha2sLNzc30UTshCgaxhiuX7+OY8eOwcjICH5+fg2aakoZqGKeqU4Vr08oFOLs2bNISEiAmZkZfHx80Lp1a67DIqRWjx49QmhoKAQCAby8vNC9e3euQ5IplZ/HVlZULSH//fff4PP5yM3NhaurK/r3709dD4hSeP36Nfh8Pl69egUXFxcMHTpUZX53VS3PvEvVri8vLw+hoaHIzMzE6NGj4eDgQLd3iVIoKipCeHg4UlJSMHz4cDg7O6vMnLdU2EpJVRIyYwyXL19GbGws2rdvDz8/P7Rr147rsAhpkIqKCpw6dQoXL15E9+7d4eXlBV1dXa7DajJVyTO1UaXre/DgAcLDw6GhoQFfX19YWFhwHRIhDaKq9QAVtlJShYSsyp/QFI1QKMStW7cAALa2ttSK00xSUlIQHh4OdXV1+Pj4wNLSkuuQmkQV8kxdVOH6KioqcPLkSVy6dAk9evSAp6enSnyoUkSUR+Wj6g5uXl4eXF1dYWdnp9R3wVR+5TFSqXqfmvfff1/l+tQoooqKCq5DUHndu3fHkiVLEBoaiv3799PtYNKsqrrBvH79Gq6urhgyZIhSFwDKgPJo8+vQoQMWLVqE48ePIzw8HGlpaXB3d4e2tjbXockdFbZKQCAQIDExEX/99RcsLCxoFCRROQYGBpg1axbOnTuH06dP49GjR/D19aUBPERm3h24uGDBApUbuEhaNi0tLXh6esLa2lo0562fnx86d+7MdWhyRYWtgsvJyUFISAiePn2KcePG0bx1RGWpqalh9OjRsLCwQEhICIKCguDh4YE+ffpwHRpRciUlJYiOjsbt27cxcOBATJw4kaaaIyqrb9++6Ny5M/h8Pnbv3g0nJ6cWNa89Fbb/n737DmvqbP8A/g17ihMV2eAe4MKqCCiKC2SlVuveWG2x49dq+76v1rfVDtvat0Nw1FrrqoSNA0UBBw4U3AuQpSjiYM/k+f1BSUWGAZKcjPtzXblaw8k598m4c+c5z1BgN27cQFRUFPT09LBgwQJaaYSoBQsLCwQEBCAqKgoHDx5ERkYGJk2aRJPkk1bJzc1FSEgIysvLwefzaXEQohY6dOiAhQsX4uTJkzh27BgyMjLUZiVSKmwVUHV1NQ4fPozLly+jf//+8PLyorlpiVrR09MDn8+HnZ0dDh8+jOzsbPD5fHTt2pXr0IiSYIzhzJkzOHHiBMzMzDBv3jx06NCB67AIkRtNTU2MHz8eNjY2CAsLw5YtW+Dr6wt7e3uuQ5MpuqatYB4/foytW7fi2rVrmDZtGvh8PhW1RC3xeDwMGTIES5cuhYaGBrZt24aLFy9CjSZyIa1UXFyM3bt3Iy4uDqNHj8aCBQuoqCVqy87ODsuXL4eZmRn+/PNPxMbGQigUch2WzFCLrYJgjOHixYuIjY1Fp06dsHTpUnTp0oXrsNQeTQHEvS5dumDJkiWIjY1FTEwM0tPT4e3tDX19fa5DIwro3r17CAsLg6amJubMmQNbW1uuQ1J7lEe5Z2hoiLfffhvnzp3D8ePHkZmZCT6fj44dO3IdmtTRPLYKoKysDJGRkbh9+zacnJzg4eFBc9MS0ojbt28jIiIC2tra8Pf3h5WVFdchNaCoeUZaFPX8ampqEBcXh6SkJPTs2RM+Pj4wNDTkOixCFM7Dhw8REhKCkpISeHp6YtCgQVyH1AAt0CAhRUzIWVlZEAgEqK6uhre3N/r06cN1SIQotKKiIggEAmRnZ8PV1RUuLi4KNVOIIuYZaVLE83v69ClCQkKQn5+PCRMmYMSIEWozApyQ1qisrMShQ4dw5coVODg4YMqUKQo15y0t0KCERCIREhMTkZCQACsrK/j5+SnMlwQhiqxdu3aYN28eTp06hfj4eNy/fx9+fn4wMTHhOjQiZ4wxXLlyBYcOHYKxsTEWL16M7t27cx0WIQpPV1cXvr6+sLOzQ3R0NHJycsDn82FmZsZ1aG1GLbYcKCwsRGhoKLKzs+Hm5oYxY8YoVIsTqSUSiXDjxg0AQP/+/ek1UkBZWVkIDQ1FVVUVpk2bhr59+3IdksLkGVlRlPOrrKxETEwMrl69CkdHR0yZMoXmplVAlEcV37NnzxASEoLHjx9j/PjxeOONNzi/4kEttkrk1q1biIyMhI6ODhYsWABLS0uuQyLNqKqq4joE0gwrKysEBAQgMjISBw4cwPDhw+Hh4UFz3qq4Bw8eQCAQoLS0FH5+fgrZR5D8g/KoYuvYsSMWLVqEuLg4HD16FBkZGUrdR50KWzmprq5GbGwsLl68iL59+2LatGk0qpsQKdDX18f06dNx6dIlHDlyBFlZWeDz+TA1NeU6NCJljDEkJSXh+PHj6N69O2bPnq2So7oJkTdNTU14eHjA1tZWPOetn5+fUs4qQtcE5CA/Px/btm1DSkoKPD09MX36dCpqCZEiHo+HYcOGYenSpQCAbdu24dKlSzTnrQopKSnBnj17EBsbi5EjR2LhwoVU1BIiZfb29li+fDm6du2K3bt34/jx40o35y212MoQY0zcitSxY0csXbqUWpEIkSFTU1MsWbIER48eRVRUFNLT0+Hl5UU/JJVcWloawsLCwOPxMGfOHNjZ2XEdEiEqy8jICLNnz8bZs2cRFxeH+/fvg8/nK80iJ9RiKyPl5eU4ePAgoqOj4ejoiCVLllBRS4gcaGtri6+MZGRkICgoCNnZ2VyHRVpBKBQiNjYWf/75J7p3746AgAAqagmRAx6Ph9GjR2PRokUoKytDUFAQrl27xnVYEqEWWxnIzs6GQCBAZWUl3nrrLYUYqU2IuunXrx969OgBgUCAnTt30gwkSubZs2cQCATIy8uDh4cHRo4cyflIbULUTY8ePRAQEIDo6GgIBAJkZGRg8uTJCj0DCRW2UiQSicRza1pYWMDf35/m1lRyenp6XIdA2sDExATz589HQkJCvTlvVXEaLlVy9epVxMTEwNDQEIsXL1aJuTXVGeVR5aarqws/Pz/Y2dnh0KFDyM7OBp/PV9g5o2keWynuOzQ0FFlZWXBxcYGrqyu1DBGiQDIzMxEaGorq6mr4+Pigd+/eMjmOoszzKiuyPL+qqiocOnQIqampGDRoEKZOnapQqyERou4KCgogEAhkvsofLakrIVkl5Dt37iA8PBza2trw8/ODtbW11PZNCJGesrIyRERE4M6dO3BycoKHhwe0tKR74YoK29bJy8tDSEgIiouLMXXqVDg4OEht34QQ6ampqcHx48dx7tw59OrVC97e3lKf85YKWwlJOyHX1NQgNjYWFy5cQJ8+fTBt2jQYGBhIIVJCiKwwxnDx4kXExsaiU6dO4PP56NKli9T2T4VtyzDGcP78eRw7dgympqbg8/no1KmTFCIlhMjS3bt3ER4eDk1NTfj5+cHGxkZq+6bCVkLSTMgFBQUICQlBQUEBPDw8MHz4cBrYoGJEIhFu3boFAOjbty91LVExjx49QkhICAoLCzF58mQMHjxYKp9hKmwlV1paivDwcNy7dw8jR46Eu7u71FvQCbcoj6q24uJihIaGIjMzE87OznBzc4Ompmab90tL6soRYwwpKSk4fPgwTExMsHjxYnTr1o3rsIiMVFRUcB0CkZFu3bph6dKlOHLkCCIjI5GRkQFPT08a6CInGRkZCAsLg0gkwqxZs9CzZ0+uQyIyQnlUdRkbG2POnDk4c+YMTp48iczMTPj7+6N9+/acxUSFbQtUVFQgOjoa169fx9ChQzFx4kSFnvKCENI8HR0dTJs2Dba2toiKikJQUBD8/f1hYWHBdWgqSygUIj4+HqdPn4aNjQ18fX1hbGzMdViEkFbS0NDAmDFjYG1tDYFAgKCgIHh5eaF///6cxEOFrYRyc3MREhKCiooKvPnmm5y9YIQQ6RswYEC9OW/Hjh0LZ2dn6l4kZc+fP4dAIMDDhw/h7u6O0aNH03NMiIqwsLBAQEAAoqKicPDgQaSnp2Py5MnQ1taWaxxU2L4GYwxnzpzBiRMnYGZmhvnz53PaxE4IkY0OHTpgwYIFiI+Px4kTJ3D//n1qTZSi69evIyoqCgYGBli4cCHMzc25DokQImV6enrg8/mws7PD4cOHkZOTAz6fj65du8otBipsm1FcXIywsDDcv39fqp2iCSGKSVNTE+7u7rCxsUFYWBi2bNkCX19f6v/ZBlVVVThy5AguX76MAQMGUD9mQlQcj8fDkCFDYGFhgZCQEGzbtk2ug+ypsG3CvXv3EBYWBk1NTcydO1eq01gQQhSbra0tAgICEB4ejj179tCI/VZ6eeYJb29vODo6UtcDQtREly5dsGTJEsTGxuLQoUPIyMiQy7SolKVfIY+Jh4nyoMGB6svQ0BBvv/22eI7VzMxMmmNVQi/PFdy5c2csW7YMnTt35joswhHKo+pLS0sLU6ZMgZ2dHcLDw8UDdK2srGR2TJrH9iVPnz5FSEiIzJeKI4Qol1dXxRo0aFCTuUHd57F9eXW3ESNGYMKECdTSTQhBUVERQkNDkZWVBRcXF7i6ujY5rzEt0CChpp4oxhiuXLmCQ4cOwdjYGHw+H927d+cwUkKIoqmqqsKhQ4eQmpqKQYMGYerUqdDV1W2wnToXtvfv30doaCiEQiG8vb3Ru3dvjqIkhCgikUiEU6dOIT4+HhYWFvD394eJiUmD7aiwlVBjT1RlZSWio6Nx7do1ODo6YsqUKXTZhBDSpKtXryImJgYGBgbg8/no0aNHvb+rY2ErEokQHx+PU6dOwcrKCn5+fip57oQQ6cjOzoZAIEBlZSW8vb3Rt2/fen9vSx5VurXtKisrxQMQUlNT27SvBw8eICgoCHfv3oW/vz98fHyoqCVidUtB3rp1CyKRiOtwiIIYNGgQli1bBgMDA+zYsQNnzpyBsrUPSDOPvnjxAjt37sTp06cxduxYzJ07l4paIkZ5lDTG0tISAQEBsLGxwYEDBxATE4Pq6mqp7FvpOj59/PHHMDMzw5UrV1q9j7q5aePi4tC9e3fMmTMHHTt2lGKURFWUlZVxHQJRQB07dsTChQtx4sQJHDt2DBkZGfD19YWRkRHXoUlEGnkUAG7evInIyEjo6upiwYIFtGIbaRTlUdIYfX19TJ8+HZcuXcKRI0eQlZUFPp8PU1PTNu1XqVpsDx8+jNjYWGzatKlN+zlw4ACOHTuGkSNHYuHChVTUEkJaTFNTExMmTMCcOXPw+PFjbNmyBWlpaVyH9VrSyqOHDx/GX3/9JZ4ajYpaQkhL8Xg8DBs2DEuXLgUAbN26FcnJyW26CqY0LbaPHz/GkiVLEB4eLvEcaJWVlaisrBT/u6ioCACQn5+POXPmwM7OTiaxEkLUh52dnXjO2z///BMODg5ch9QkaebR69evw8fHB0OGDKHZYwghbWJqaoolS5bg6NGjiI6OhrW1dav3pRQttowxzJ8/HwEBARg2bJjEj9u4cSNMTEzEt7oWhYULF1JRSwiRGiMjI8yaNQseHh5ITk7mOpxGSTuPLliwAEOHDqWilhAiFdra2vD09MT06dORmZnZ6v1wWtiuW7cOPB6v2VtycjJ++uknFBUVYc2aNS3a/5o1a1BYWCi+5eTkAIDS9IMjhCgPHo+HUaNGYe7cuXI9Lld5lBZcIITIQr9+/bBo0aJWP57T6b4KCgpQUFDQ7DbW1taYMWMGoqKi6rUMCIVCaGpqYtasWdi1a5dEx1P1aXiIdIlEIqSkpAAABg8e3ORE0oS8TN55hvIoUWSUR0lrtCXPcNrHtnPnzhL96v/f//6HL774Qvzvhw8fYuLEiThw4ABGjBghyxCJmqMVk4iiozxKFB3lUSJPSvFus7S0rPfvuq4EdnZ2MDc35yIkogY0NDQUeiAQIS1BeZRwgfIokTe6JkAIIYQQQlSCUrTYvsra2lrpVvohhBBFQnmUEKKKlLKwJUQeRCKReMJ9e3t7GvRACCEtRHmUyBsVtoQ0o7i4mOsQCCFEqVEeJfJEP50IIYQQQohKoMKWEEIIIYSoBCpsCSGEEEKISqDClhBCCCGEqAQqbAkhhBBCiEqgWREIaQZNTUMIIW1DeZTIExW2hDRBQ0MDgwcP5joMQghRWpRHibzRzyhCCCGEEKISqLAlhBBCCCEqgboiENIEkUiEjIwMAICtrS31EyOEkBaiPErkjQpbQppRWFjIdQiEEKLUKI8SeaKfToQQQgghRCVQYUsIIYQQQlQCFbaEEEIIIUQlUGFLCCGEEEJUAhW2hBBCCCFEJajVrAiMMQBAUVERx5EQZSASiVBSUgKg9j1D09QQSdTll7p8o2ooj5KWoDxKWqMteVStCtunT58CACwsLDiOhBCi6p4+fQoTExOuw5A6yqOEEHlpTR5Vq8K2Y8eOAIDs7GyV/MJpraKiIlhYWCAnJwft2rXjOhyFQs9N4+h5aVphYSEsLS3F+UbVUB5tHH0mmkbPTePoeWlaW/KoWhW2dZdATExM6E3UiHbt2tHz0gR6bhpHz0vTVPWSK+XR5tFnomn03DSOnpemtSaPqmbmJYQQQgghaocKW0IIIYQQohLUqrDV1dXF2rVroaury3UoCoWel6bRc9M4el6apurPjaqfX2vR89I0em4aR89L09ry3PCYqs5JQwghhBBC1IpatdgSQgghhBDVRYUtIYQQQghRCVTYEkIIIYQQlUCFLSGEEEIIUQlqX9hWVlbC0dERPB4PqampXIfDqczMTCxatAg2NjbQ19eHnZ0d1q5di6qqKq5D48Svv/4KGxsb6OnpYejQoTh16hTXIXFu48aNGD58OIyNjWFqagofHx/cuXOH67AUzsaNG8Hj8bBq1SquQ5ELyqP1US79B+XRhiiPSqa1eVTtC9uPP/4YZmZmXIehEG7fvg2RSITg4GDcuHEDP/zwA4KCgvDpp59yHZrcHThwAKtWrcJnn32GlJQUjBkzBpMnT0Z2djbXoXEqISEBK1aswLlz53Ds2DHU1NTAw8MDpaWlXIemMC5evIitW7di0KBBXIciN5RH66NcWovyaOMoj75em/IoU2OHDh1iffr0YTdu3GAAWEpKCtchKZxvvvmG2djYcB2G3Dk5ObGAgIB69/Xp04etXr2ao4gUU35+PgPAEhISuA5FIRQXF7OePXuyY8eOMVdXVxYYGMh1SDJHeVQy6phLKY9KhvJofW3No2rbYvv48WMsWbIEu3fvhoGBAdfhKKzCwkJ07NiR6zDkqqqqCpcuXYKHh0e9+z08PHD27FmOolJMhYWFAKB275GmrFixAlOnTsX48eO5DkUuKI9KTt1yKeVRyVEera+teVRLyvEoBcYY5s+fj4CAAAwbNgyZmZlch6SQ0tPT8dNPP+G7777jOhS5KigogFAoRNeuXevd37VrVzx69IijqBQPYwwffPABnJ2dMWDAAK7D4dz+/ftx+fJlXLx4ketQ5ILyqOTUMZdSHpUM5dH6pJFHVarFdt26deDxeM3ekpOT8dNPP6GoqAhr1qzhOmS5kPR5ednDhw8xadIkvPnmm1i8eDFHkXOLx+PV+zdjrMF96mzlypW4evUq9u3bx3UonMvJyUFgYCD+/PNP6OnpcR1Om1AebRrl0pajPNo8yqP/kFYeVakldQsKClBQUNDsNtbW1pgxYwaioqLqfbiEQiE0NTUxa9Ys7Nq1S9ahypWkz0vdG+nhw4cYO3YsRowYgd9//x0aGir1++e1qqqqYGBggIMHD8LX11d8f2BgIFJTU5GQkMBhdIrh3XffRXh4OBITE2FjY8N1OJwLDw+Hr68vNDU1xfcJhULweDxoaGigsrKy3t8UGeXRplEulRzl0dejPFqftPKoShW2ksrOzkZRUZH43w8fPsTEiRMREhKCESNGwNzcnMPouPXgwQOMHTsWQ4cOxZ9//qk0X8bSNmLECAwdOhS//vqr+L5+/frB29sbGzdu5DAybjHG8O677yIsLAzx8fHo2bMn1yEphOLiYmRlZdW7b8GCBejTpw8++eQTlbzESHm0eZRLKY82hfJo46SVR9Wyj62lpWW9fxsZGQEA7Ozs1DoZP3z4EG5ubrC0tMSmTZvw5MkT8d+6devGYWTy98EHH2DOnDkYNmwYRo4cia1btyI7OxsBAQFch8apFStWYO/evYiIiICxsbG4r5yJiQn09fU5jo47xsbGDZKuoaEhOnXqpJJFLUB5tDmUS2tRHm0c5dHGSSuPqmVhSxoXGxuLtLQ0pKWlNfhiUreG/bfeegtPnz7F+vXrkZeXhwEDBuDQoUOwsrLiOjRObdmyBQDg5uZW7/6dO3di/vz58g+IEAVEubQW5dHGUR6VLbXsikAIIYQQQlSP+vRkJ4QQQgghKo0KW0IIIYQQohKosCWEEEIIISqBCltCCCGEEKISqLAlhBBCCCEqgQpbQgghhBCiEqiwJYQQQgghKoEKW0IIIYQQohKosCWEEEIIISqBCluiVubPnw8ejwcejwdtbW3Y2trio48+QmlpqXgbgUAANzc3mJiYwMjICIMGDcL69evx7NkzAEBeXh7efvtt9O7dGxoaGli1ahVHZ0MIIdygXEoUFRW2RO1MmjQJeXl5yMjIwBdffIFff/0VH330EQDgs88+w1tvvYXhw4fj8OHDuH79Or777jtcuXIFu3fvBgBUVlaiS5cu+Oyzz+Dg4MDlqRBCCGcolxJFxGOMMa6DIERe5s+fjxcvXiA8PFx835IlSxAdHY2IiAiMGDECmzdvRmBgYIPHvnjxAu3bt693n5ubGxwdHbF582bZBk4IIQqEcilRVNRiS9Sevr4+qqursWfPHhgZGeGdd95pdLtXEzEhhJB/UC4lioAKW6LWLly4gL1798Ld3R337t2Dra0ttLW1uQ6LEEKUCuVSoiiosCVqJzo6GkZGRtDT08PIkSPh4uKCn376CYwx8Hg8rsMjhBClQLmUKCItrgMgRN7Gjh2LLVu2QFtbG2ZmZuJWhV69euH06dOorq6mlgZCCHkNyqVEEVGLLVE7hoaGsLe3h5WVVb2k+/bbb6OkpAS//vpro4978eKFnCIkhBDFR7mUKCJqsSXkbyNGjMDHH3+MDz/8EA8ePICvry/MzMyQlpaGoKAgODs7i0f4pqamAgBKSkrw5MkTpKamQkdHB/369ePwDAghhHuUSwmXaLovolYam6LmVX/99Rd++eUXpKSkQCQSwc7ODnw+H++++654NG9j/cesrKyQmZkpm8AJIUSBUC4liooKW0IIIYQQohKojy0hhBBCCFEJVNgSQgghhBCVQIUtIYQQQghRCVTYEkIIIYQQlUCFLSGEEEIIUQlU2BJCCCGEEJVAhS0hhBBCCFEJVNgSQgghhBCVQIUtIYQQQghRCVTYEkIIIYQQlUCFLSGEEEIIUQlU2BJCCCGEEJVAhS0hhBBCCFEJVNgSQgghhBCVQIUtIYQQQghRCVTYEpm4evUqFixYABsbG+jp6cHIyAhDhgzBN998g2fPngEA3NzcwOPxMGnSpAaPz8zMBI/Hw6ZNm8T3xcfHg8fjiW+ampro0qULvLy8kJyc3GAf8+fPB4/Hg7GxMUpKShr8PSsrCxoaGuDxeFi3bp3E5/b48WOsXr0aAwcOhJGREfT09NCzZ08EBgbi3r174u3WrVsHHo8HDQ0NZGRkNNhPaWkp2rVrBx6Ph/nz5zca38KFC2FmZgZdXV306NEDvr6+EsVYXFyMjz/+GB4eHujSpUuLz5EQoj5akq8bu1lbW9fb361btzBnzhzY2tpCT08PnTt3xpAhQ7By5UoUFRWJt2ttjr506RJWrFiBgQMHwtjYGF27dsX48eNx4sQJmTw/RLlocR0AUT3btm3DO++8g969e+P//u//0K9fP1RXVyM5ORlBQUFISkpCWFiYePujR4/ixIkTGDdunET737BhA8aOHYvq6mqkpKTg888/h6urK1JTU9GzZ89622pra6OmpgYHDhzAokWL6v1t586dMDY2rpdoX+fChQvw9PQEYwwrV67EyJEjoaOjgzt37uDPP/+Ek5MTnj9/Xu8xRkZG2LlzJ/773//Wu//gwYOorq6GtrZ2g+Ncv34dbm5usLW1xaZNm2Bubo68vDwcPXpUojifPn2KrVu3wsHBAT4+Pti+fbvE50gIUR8tyde2trbYs2dPg33o6uqK/z8lJQWjR49G37598Z///AfW1tYoKCjAlStXsH//fnz00Udo166dePvW5Oh9+/bhwoULWLhwIRwcHFBaWoqgoCC4u7tj165dmDt3rjSfIqJsGCFSdPbsWaapqckmTZrEKioqGvy9srKSRUREMMYYc3V1Zb169WK2trZs6NChTCQSibe7f/8+A8C+/fZb8X0nT55kANjBgwfr7XPXrl0MAPvPf/5T7/558+YxQ0NDNmPGDDZq1Kh6fxOJRMzKyootWbKEAWBr16597bkVFhaybt26MQsLC5aTk9PoNi/HtnbtWgaALV68mFlYWDChUFhvW2dnZzZz5kxmaGjI5s2bVy82R0dH5ujo2OhzKAmRSCR+Pp88eSLxORJC1EdL83X//v1fu8+5c+cyQ0NDVlRU1OjfX87zrc3Rjx8/brDfmpoaNmjQIGZnZ/faGIlqo64IRKo2bNgAHo+HrVu31vsVX0dHRwfTpk0T/1tbWxtffvklLl26hAMHDrTqmMOGDQNQ20WgMQsXLsTZs2dx584d8X3Hjx9HVlYWFixYIPFxtm3bhkePHuGbb76Bubl5o9vw+fxGj5+Tk4Njx46J77t79y5Onz6NhQsXNtg+MTERqampWLVqVaPPoSTqLhESQkhTWpqvJfH06VO0a9cORkZGjf69sbzU0hxtamra4D5NTU0MHToUOTk5LYqXqB4qbInUCIVCnDhxAkOHDoWFhYXEj3vrrbcwdOhQ/Otf/0J1dXWLj3v//n0AQK9evRr9+/jx42FlZYXffvtNfN+OHTvg4uLSoOtCc2JjY6GpqQkvL68WxdezZ0+MGTOm3vF/++03WFtbw93dvcH2iYmJAABjY2NMmTJF3OfN09MTt2/fbtGxCSGkMa3N1zU1NQ1uIpFI/PeRI0ciLy8Ps2bNQkJCAsrLy1+7T2nk6JqaGpw6dQr9+/eX+FyIaqLClkhNQUEBysrKYGNj06LH8Xg8fP3110hPT0dwcPBrtxeJRKipqUF5eTnOnj2LDz/8EP369Wu09bNu//Pnz8cff/yBmpoaPHv2DOHh4U1u35Ts7Gx06dIFhoaGLXocUNsiERERgWfPnkEoFOKPP/4QD5x41YMHDwAACxYsgJmZGWJiYhAUFITr169jzJgxyMvLa/HxCSHkZa3J1zdu3IC2tnaD29KlS8XbfPTRR/Dx8cG+ffvg5uYGY2NjDBkyBP/617/w5MmTRvcrjRy9bt06pKWlYe3atRI/hqgmGjxGFIK7uzs8PDywfv16zJs3r9lt33rrrXr/7t69O86ePYv27ds3+ZgFCxZg/fr1OHz4MDIzM6Gjo4M333wTZWVlDbatqamp929NTc02X9Z/88038d5772HPnj2wtrbGo0ePGp0JAYC49WPkyJH1Bn0NGDAAgwcPxi+//IIvvvgCjDEIhcJ6j9XSoo80IUQ27OzssH///gb3d+nSRfz/urq6CAsLw61bt3D06FEkJycjISEBX375JYKCgnDmzBn07t27wT5akqNftX37dnz55Zf48MMP4e3t3baTJEqPvgWJ1HTu3BkGBgbirgEt9fXXX2PIkCHYtGlTs31fv/76a4wbNw5lZWWIjY3Fxo0b4ePjg/PnzzfZJ9XKygru7u747bffkJmZiRkzZsDAwKDRpPnqLAU7d+7E/PnzYWlpiXv37qG0tLTFrbaGhoZ466238Ntvv8HKykp86a0xnTp1AgBMnDix3v2Ojo7o3r07Ll++DABISEjA2LFj621z//79BlPvEELIq1qTr/X09MRjGl6nb9++6Nu3LwCAMYbNmzfjgw8+wL///W/89ddfDbZvSY5+2c6dO7Fs2TIsXboU3377rcTnQlQXFbZEajQ1NeHu7o7Dhw8jNze3yQFWTXF0dMTMmTPx/fffY8qUKU1uZ2trK06uLi4u0NfXx7/+9S/89NNP+Oijj5p83MKFCzF79myIRCJs2bKlye0uXrxY7991l+omTpyI2NhYREVFYcaMGS05NfHxt2/fjqtXrzY6ZU6dQYMGNfk3xhg0NGp7EA0dOrRBrGZmZi2OixCiftqar1uCx+Ph/fffx/r163H9+vUmt5M0R9fZuXMnFi9ejHnz5iEoKIgGzBIA1MeWSNmaNWvAGMOSJUtQVVXV4O/V1dWIiopq8vFffPEFqqqq8Pnnn0t8zI8//hj29vb46quvUFxc3OR2vr6+8PX1xcKFC/HGG280ud2wYcPq3epaUBctWoRu3brh448/FveDfVVoaGiT+x05ciQWLlwojqMpkydPhoGBAQ4fPlzv/suXL+PRo0fi2I2NjRvEqqOj0+R+CSHkZW3N141pagzAw4cPUVRU1OyPb0lzNAD8/vvvWLx4MWbPno3t27dTUUvEqMWWSNXIkSOxZcsWvPPOOxg6dCiWL1+O/v37ixdT2Lp1KwYMGNDkzAI2NjZYvnw5fvzxR4mPqa2tjQ0bNmD69On48ccf8a9//avR7fT09BASEtKq8wIAExMTREREwNPTE4MHD663QMO9e/fw559/4sqVK/Dz82tyHzt27Hjtcdq3b4/169fjo48+wvz58zFz5kw8evQI//73v2FpaYl33nlHongPHz6M0tJScbF/8+ZN8flPmTIFBgYGEu2HEKKaWpqvy8vLce7cuUb3VVeILl26FC9evIC/vz8GDBgATU1N3L59Gz/88AM0NDTwySefNBmPpDn64MGDWLRoERwdHbFs2TJcuHCh3t8HDx7c6qkSiQrgdBZdorJSU1PZvHnzmKWlJdPR0WGGhoZs8ODB7D//+Q/Lz89njDU94feTJ09Yu3btJF6goc6IESNYhw4d2IsXLxhj/0z+3ZzWLF7w6NEj9sknn7D+/fszAwMDpqury+zt7dmyZcvYtWvXxNvVLdDw5MmTZvf36gINdbZt28YGDBjAdHR0WKdOndisWbOaXBiiMVZWVgxAo7f79+9LvB9CiGqTNF83lU8AsOrqasYYY0ePHmULFy5k/fr1YyYmJkxLS4t1796d+fn5saSkpHrHbW2OnjdvXrOxUH5TbzzGGJNbFU0IIYQQQoiMUB9bQgghhBCiEqiwJYQQQgghKoEKW0IIIYQQohKosCWEEEIIISqBCltCCCGEEKISqLAlhBBCCCEqQa0WaBCJRHj48CGMjY1plRJCiEwwxlBcXAwzMzPx8seqhPIoIUTW2pJH1aqwffjwISwsLLgOgxCiBnJycmBubs51GFJHeZQQIi+tyaNqVdgaGxsDqH2i2rVrx3E0RNGJRCJcuXIFAODg4KCSrW9E+oqKimBhYSHON6qG8ihpCcqjpDXakkfVqrCtu2zWrl07SsjktUQiEYyMjADUvmcoIZOWUNXL9JRHSUtQHiVt0Zo8qlaFLSEtoaGhgcGDB4v/nxBCSMtQHiXyRoUtIc2gREwIIW1DeZTIE73bCCGEEEKISqAWW0KawBhDVlYWAMDKykomfSaFQiGqq6ulvl8iO9ra2tDU1OQ6DEKUAuVR0hhZ5lEqbAlpAmMMT58+BQBYWlpKNSEzxvDo0SO8ePFCavsk8tO+fXt069ZNZQeIESItlEdJU2SVR6mwJYQDdcnY1NQUBgYGVCApCcYYysrKkJ+fDwDo3r07xxERor4ojyonWedRKmwJkTOhUChOxp06deI6HNJC+vr6AID8/HyYmppStwRCOEB5VLnJMo/S4DFC5KyuL5iBgQHHkZDWqnvtqF8fIdygPKr8ZJVHqbAlhCN02Ux50WtHiGKgz6LyktVrR4UtIYQQQghRCVTYEkIIIYQQlUCFLSFN0NDQgIODAxwcHGjlHAXx66+/wsbGBnp6ehg6dChOnTrV7PaJiYnw8vKCmZkZeDwewsPDG2yzceNGDB8+HMbGxjA1NYWPjw/u3LkjozMgRL1QHlVMqpxL6V1GSDO0tLSgpUWThyiCAwcOYNWqVfjss8+QkpKCMWPGYPLkycjOzm7yMaWlpXBwcMDPP//c5DYJCQlYsWIFzp07h2PHjqGmpgYeHh4oLS2VxWkQonYojyoWlc+lTI0UFhYyAKywsJDrUIgaKy8vZzdv3mTl5eVch9Iq58+fZ66urkxPT4/17t2bXbhwgQUHBzMvLy+ZHtfJyYkFBATUu69Pnz5s9erVEj0eAAsLC3vtdvn5+QwAS0hIaHKb5l5DVc8zqn5+RDkoex5ljHKprPIotdgS0gTGGLKzs5GdnY3az7JMDwaUlsr/1sLzOnfuHFxdXTFp0iRcvXoV/fr1w7p16/Dtt9/i888/r7fthg0bYGRk1OztdZe/6lRVVeHSpUvw8PCod7+HhwfOnj3bonN4ncLCQgBAx44dpbpfQtQR5dHGUS6VHbo2QEgTGGN48uQJAMDc3Fy208qUlQFGRrLbf1NKSgBDQ4k3/+CDD+Dv74/Vq1cDAGbMmIGZM2fC29sbgwcPrrdtQEAApk+f3uz+evToIdFxCwoKIBQK0bVr13r3d+3aFY8ePZI4/tdhjOGDDz6As7MzBgwYILX9EqKuKI82jnKp7FBhSwiRSG5uLpKSkvDtt9+K79PR0QFjrEELA1D7K701v9T37NmDZcuWif99+PBh2NnZAWg47yFjTKpflCtXrsTVq1dx+vRpqe2TEEJeRrlUtqiwJUQRGBjU/urn4rgSunXrFgBg2LBh4vvu3LkDJycnDBw4sMH2GzZswIYNG5rd5+HDhzFmzJh6902bNg0jRowQ/7tHjx7Q1NSEpqZmgxaF/Pz8Bi0PrfXuu+8iMjISiYmJMDc3l8o+CSFypAR5FKBcKmtU2BKiCHi8Fl/KkrfCwsJ663k/e/YM33zzTZOXmVp7+czY2BjGxsYN7h86dCiOHTsGX19f8X3Hjh2Dt7e3pKfQKMYY3n33XYSFhSE+Ph42NjZt2h8hhCNKkEcByqWyprSDxzZu3Agej4dVq1ZxHQohasHR0RFCoRDffPMNbt++jZkzZ8LKygq3bt1CVlZWg+07duwIe3v7Zm/6+voSH/+DDz7A9u3b8dtvv+HWrVt4//33kZ2djYCAAPE2P//8M9zd3cX/LikpQWpqKlJTUwEA9+/fR2pqar1pbVasWIE///wTe/fuhbGxMR49eoRHjx6hvLy8Fc+ScqE8Soj8US6VsRbPo6AALly4wKytrdmgQYNYYGCgxI+jaWpISwiFQpacnMySk5OZUCiU2n6VeZqa9evXs06dOjE9PT02b9489uTJEzZkyBBmb28vl+P/8ssvzMrKiuno6LAhQ4Y0mEZm7dq1zMrKSvzvkydPMgANbvPmzRNv09jfAbCdO3c2GYcqTPdFeZTIA+XRxlEulV0e5f0djNIoKSnBkCFD8Ouvv+KLL76Ao6MjNm/eLNFji4qKYGJigsLCQrRr1062gRKlJxKJkJKSAgAYPHiw1FbNqaiowP3798WrvhDl09xrmJWVBWtra4XOM5RHibxQHiVNae41rOvz25o8o3RdEVasWIGpU6di/Pjxr922srISRUVF9W5A7TxuhLyOhoYGBg4ciIEDB9JSkEQi169fx2+//cZ1GK8ljTxaXFws6zCJCqA8SloqJycHO3bsaPXjlepdtn//fly+fBkbN26UaPuNGzfCxMREfLOwsAAA7Ny5U6rztRHVpaOjAx0dHa7DIAquqqoKERERCAkJEU+no6iklUd37NiBu3fvyjJUoiIojxJJiEQiJCYmYufOnY0OepOU0hS2OTk5CAwMxJ9//inxZYc1a9agsLBQfMvJyQFQu271tm3bcP78edmvhEIIUWmPHj3C1q1bcf36dXh7e7d5ZLEsSTOPmpmZYe/evThy5AhqampkGTYhRMUVFRVh9+7dOHnyJJydnTF79uxW70tp+tiGh4fD19e33hQZQqEQPB4PGhoaqKysrPe3xtT1DXv69CnOnz+P8+fPo3fv3vD29oZBC+ehI6qPMYYHDx4AqJ1KRVqTV1PfMOVX9xoWFRUhNjYWXbp0AZ/PR+fOnRW6D6o08+iLFy9w69YtHDt2DKampuDz+ejUqZOsT4EoGcqjpCl1ryEAREVFQVNTE/7+/rC2tm5THlWaeWzd3d1x7dq1evctWLAAffr0wSeffPLaZPwyLS0tTJ48Gba2toiIiMCWLVvg5+dH81eSehhjePz4MYDa1ilpLwWpJL8pSSNqampQWlqKxMREDBs2DBMmTICWluKnU2nmUR6PhzfeeANWVlYICQlBcHAwpkyZAgcHB9kum0qUCuVR0hSRSITy8nLExcXBwsJCao2Mip+J/2ZsbNxg8mJDQ0N06tSp1esQ9+7dGwEBAQgLC8Mff/yBMWPGwM3NjTq4E5nS1tYGAJSVlbVo7kGiGCorK5Gfn4/Kykp4eXmhT58+XIckMVnk0e7du2PZsmU4fPgwwsPDkZ6eDk9PT+jq6kojZEIaRXlUuVVXV+Px48coKyuDi4sLnJycpPajR2kKW1lp164d5syZg9OnTyM+Ph7379+Hv78/2rdvz3VoREVpamqiffv2yM/PBwAYGBhQC5cSYIyhpKRE3Ne0R48esLa25joshaCjowNvb2/Y2toiOjoaQUFB4PP5ja6GRIg0UB5VTowxlJeX4/nz53j+/Dm6du2Knj17SvUYSl3YxsfHS2U/GhoacHFxgY2NDQQCAYKCgjBt2jT069dPKvsn5FXdunUDAHFSJopNJBKhrKwMNTU10NXVRffu3dG9e3euw5IKaeVRABg4cCDMzc0REhKCHTt2wN3dHaNGjaKCg8gE5VHlUlfUVlVVQUtLC927d5fJj1+lLmylzcLCAgEBAYiKisJff/2FoUOHYtKkSeJLHoRIC4/HQ/fu3WFqaorq6mquwyHNSEtLw4kTJ6CrqwsPDw9YWlq2qC+quunQoQMWLlyIkydP4tixY8jIyICvry+MjIy4Do2oGMqjyuPRo0eIjY1FeXk5xo4di/79+8ssj1Jh+wo9PT3w+XzY2triyJEjyMnJAZ/Ph6mpKdehERWkqalJRZKCqq6uxpEjR3Dp0iX0798fXl5eNPpaQpqamhg/fjxsbGwQFhaGLVu2wNfXF/b29lyHRlQQ5VHFxRjDmTNncOLECZiZmWHu3Lno0KGDTI9Jo6QawePxMHToUCxduhQ8Hg9bt27FxYsXafQlIWri8ePH2Lp1K65evYpp06aBz+dTUdsKdnZ2WL58Obp3744///wTsbGxEAqFXIdFCJGD4uJi7N69G3FxcRg9ejQWLFgg86IWUKJ5bKWhNfOi1dTUIDY2FhcuXEDfvn0xbdo0GoGpRsrLywGAXnM1wRhDcnIyjh49ik6dOoHP56NLly4t2ociz2MrDa05P8YYzp07h+PHj6Nr167g8/no2LGjjCMlioLyqPq5d+8ewsPDoaGhAV9fX9ja2rbo8W3Jo1TYSuj27duIiIiAjo4O/Pz8YGVlJaMoCSFcKC8vR2RkJG7dugUnJyd4eHi0am5aKmyb9vDhQ4SEhKCkpASenp4YNGiQjKIkhHChpqYGcXFxSEpKQs+ePeHj4wNDQ8MW74cKWwm19QunsLAQoaGhyM7OhqurK1xcXGjOW0JUQFZWFgQCAaqrq+Ht7d2muWmpsG1eZWUlYmJicPXqVTg4OGDKlCk05y0hKuDp06cICQlBfn4+JkyYgBEjRrR6RhS1WHlMEZiYmGDevHk4deqUeM5bPz8/mJiYcB0akQHGGPLy8gDUTkJPUxapHpFIhMTERCQkJMDKygp+fn4qWYwqEl1dXfj5+cHOzg4xMTHIzc0Fn89XmenTSH2UR9XDlStXEBMTA2NjYyxevJjTzzMVti2koaEBV1dXWFtbIzQ0VDznbd++fbkOjUjZywm5W7dulJBVzMtXYNzc3DBmzBi6AiNHDg4OMDc3h0AgwPbt29vcwkMUE+VR1fbyFRhHR0dMmTIFOjo6nMZEhW0rWVlZISAgAJGRkThw4ACGDx8ODw8PmvOWECXwcp/5BQsWwNLSkuuQ1FKnTp2waNEixMXF4ciRI0hPT291nzxCiHzV9ZkvLS2Fn5+fwvSZp8K2DfT19TF9+nRcunQJR44cQVZWFs15S4gCq66uRmxsLC5evEiznCgITU1NeHh4wMbGBuHh4diyZQv8/PxaPIqaECIfjDEkJSXh+PHj6NatG2bPnq1Qs5zQdbc24vF4GDZsGJYuXQrGGLZt24ZLly7RnLeEKJgnT55g+/btSElJgaenJ6ZPn05FrQLp2bMnli9fDlNTU+zevRvHjx+nOW8JUTAlJSXYs2cPYmNj8cYbb2DRokUKVdQC1GIrNaampli6dCmOHj2KqKgopKenY9q0aTSpOyEcY4zh8uXLOHLkCDp06IClS5fSVRUFZWRkhDlz5uDs2bOIi4vD/fv3wefz5TKpOyGkeenp6QgLCwNjDLNnz1bYlQSpxVaKtLW1xS1BGRkZCAoKQk5ODtdhEaK2ysvLcfDgQURFRcHBwQFLliyholbB8Xg8jB49GgsXLkRZWRmCgoJw/fp1rsMiRG0JhUIcO3YMu3fvRteuXbF8+XKFLWoBarGViX79+sHMzAwCgQA7d+6Em5sbnJ2dacQ1IXKUk5ODkJAQVFZWYvr06ejXrx/XIZEWMDc3x7JlyxATE4OQkBCkp6dj8uTJnI+4JkSdPHv2DAKBAHl5eZgwYQJGjRql8DNb0AINMiQSiZCQkIDExERYW1vD19eX5shUIowxlJWVAQAMDAwU/sNMaolEIpw+fRrx8fEwNzeHn58f2rdvL7fj0wIN0sUYE8+RaWJiAj6fj27dusn8uEQ6KI8qr2vXriE6OhqGhobw9/dHjx495HZsWnlMQlx94WRmZkIgEEAoFMLb2xu9e/eW27EJUSdFRUUIDQ1FVlYWXFxc4OrqKvcrJVTYykZBQQFCQkLw5MkTeHh4wMnJiYokQmSgqqoKhw4dQmpqKgYNGoSpU6fKfXVAKmwlxOUXTllZGSIiInDnzh2MGDECEyZMaNU69ISQxt25cwfh4eHQ1taGn58frK2tOYmDClvZqampwfHjx3Hu3Dn06tULPj4+MDAwkGsMhKiyvLw8hISEoLi4GFOnTsWgQYM4+QFJha2EuP7CYYzh4sWLiI2NRefOncHn89G5c2e5x0EkwxhDfn4+gNpZL6h1SDHV1NTg2LFjOH/+PHr37g1vb29Oix2u84ysKcL53b17F+Hh4dDU1ISfnx9sbGw4iYO8HuVR5cAYw/nz53Hs2DGYmpqCz+ejU6dOnMXTljxDo5nkiMfjwcnJCYsXL0ZNTQ2Cg4ORkpJCc94qKMYYcnNzkZubS6+RgiooKMD27dtx6dIlTJkyBTNmzKAWPDXQq1cvLF++HJ07d8Yff/yBEydOQCQScR0WaQTlUcVXWlqKffv24ciRI3BycsKiRYs4LWrbiq6Fc6Bbt25YunQpjhw5goiICKSnp8PT05PmvCVEQowxpKam4tChQzAxMcHixYtpQJGaMTY2xpw5c8QDBe/fvw9/f3+5DhQkRNllZGQgLCwMIpEIs2bNQs+ePbkOqc2oxZYjOjo6mDZtGvh8Pu7du4fg4GDk5uZyHRYhCq+iogICgQAREREYOHAgli5dSkWtmtLQ0ICLiwsWLFiA4uJiBAUF4caNG1yHRYjCEwqFiIuLw+7du9GlSxcEBASoRFELUIst5wYMGIAePXpAIBDgt99+w7hx4zB69Gjqh0RII3JzcyEQCFBWVgY+n48BAwZwHRJRABYWFggICEBUVBQOHjyIjIwMTJo0Cdra2lyHRojCef78OQQCAR4+fAh3d3eVqzmosFUAHTp0wIIFCxAfH4+4uDhkZGTA19cXxsbGXIdGiEJgjOHMmTM4ceIEzMzMMHfuXFpmldSjp6cHPp8POzs7HD58GNnZ2eDz+ejatSvXoRGiMK5fv46oqCjo6+tj4cKFMDc35zokqaPCVkFoamrC3d0dNjY2CAsLQ1BQEHx8fFTm0gAhrVVcXIywsDDcv38fzs7OcHNzg6amJtdhEQXE4/EwZMgQWFhYICQkBNu2bYOHhweGDx+uUi1ShLRUVVUVjhw5gsuXL2PAgAEqPa6HClsFY2tri4CAAISHh2PPnj0YOXIk3N3dac5bopbu3buH8PBwaGhoYM6cObC1teU6JKIEunTpgiVLliA2NhaHDh1CRkYGvL29oa+vz3VohMjd48ePcfDgQRQWFsLb2xuOjo4q/UOP5rFVUIwxnDt3DsePH1eIOeXUEWMMJSUlAAAjIyOVTgSKpqamBnFxcUhKSkLPnj3h4+MDQ0NDrsOSiDLlmdZQtvO7ffs2IiIioK2tDX9/f1hZWXEdklqhPModZZ47nxZokJCyJWSg4SogDg4OXIdEiEw9ffoUISEhyM/Px4QJEzBixAil+jJUxjzTEsp4fkVFRRAIBMjOzoarqytcXFzkvtQyIfKk7KudUmErIWVMyIBirNtMiKwxxnD16lXExMTA2NgYfD4f3bt35zqsFlPWPCMpZT0/kUiEU6dOIT4+HpaWlvDz84OJiQnXYREidZmZmQgNDUVNTQ28vb3Ru3dvrkNqMSpsJaSsCblO3Ze+oaEh/P390aNHD65DUmmMMRQUFAAAOnfurFSthsqmsrISMTExuHr1KhwdHTFlyhTo6OhwHVarKHueeR1lP7/s7GwIBAJUVVVh2rRp6Nu3L9chqTTKo/IjEomQkJCAxMREWFlZwc/PTyk/o0Db8ozytEsTDBo0CObm5hAIBNixYwfGjx+PkSNHUqKQEcYYsrOzAQCdOnWi51lGHjx4AIFAgNLSUvj7+2PgwIFch0RUmKWlJQICAhAZGYkDBw5g+PDh8PDwoDlvZYTyqHy8ePECoaGhyM3NxdixY+Hs7Ky23W2osFUyHTt2xMKFC3HixAnExsYiIyMDPj4+MDIy4jo0QlqEMYakpCQcP34c3bt3x+zZs9GxY0euwyJqQF9fH9OnT8elS5dw5MgRZGVlgc/nw9TUlOvQCGmxmzdvIjIyErq6upg/fz4sLS25DolTVNgqIU1NTUyYMAG2trYIDQ3Fli1b4OfnBzs7O65DI0QiJSUlCA8PR1paGkaPHo1x48bR3LRErng8HoYNGwZLS0uEhIRg69atmDx5MoYMGUKtikQpVFdX48iRI7h06RL69esHLy8vmtIOVNgqNTs7Oyxfvhzh4eHYvXs3FQhEKaSlpSEsLAw8Hg+zZ8+Gvb091yERNWZqaoolS5bg6NGjiIqKQnp6OhUIROHl5+cjJCQEz549g5eXF/0gewkVtkrOyMgIs2bNEl/SzczMhL+/P13SJQpHKBQiLi4OZ8+ehb29PXWhIQpDW1sbnp6esLW1RWRkJIKCguDv76/2l3SJ4mGMITk5GUePHkXHjh2xdOlS6kLzCipsVQCPx8OoUaNgZWUFgUCA4OBgeHp60iAcojCePXsGgUCAvLw8eHh40KBHopD69esHMzMzhIaGYufOnXBzc8OYMWPUdhAOUSzl5eWIjIzErVu3aNBjM6iwVSE9evTAsmXLEBMTA4FAgPT0dKWeNomohpenqVu0aBFNU0cUWvv27TF//nwkJCQgPj4e9+/fV+ppk4hqyMrKQmhoKKqqqvDWW2/RNHXNoHlsVdSVK1eUfqJ7rjHGUFRUBABo164dtTC2UFVVFWJiYnDlyhW1WlhE1fOMqp/fy+omuq+uroaPj49STnTPNcqjbSMSiZCYmIiEhARYWFjA399fLRYWoQUaJKROCRmovzTp+PHj8cYbb1BSIXKhzktBq3qeUfXze5WyL01KlFdhYSFCQ0PVciloKmwlpG4JGQBqampw/PhxnDt3Dj179oSPjw8MDQ25DouoKMYYzp8/j2PHjsHU1BR8Ph+dOnXiOiy5UvU8o+rn1xjGGC5evIjY2Fh07twZfD4fnTt35jososJu376NiIgIaGtrw9/fH1ZWVlyHJFdU2EpIHRNynXv37iEsLAwaGhrw8/ODra0t1yEpPMYYnj17BqB2YQxq7W5eaWkpwsPDce/ePYwcORLu7u5q2bKl6nlG1c+vOY8ePUJISAgKCwsxZcoUODo6Ul54DcqjLVNdXY1jx47hwoUL6NOnD6ZNmwYDAwOuw5K7tuQZpWnT3rhxI4YPHw5jY2OYmprCx8cHd+7c4TospdGzZ08sX74cpqam2L17N44fPw6hUMh1WAqNMYbMzExkZmZCjX7/tUpGRga2bNmChw8fYtasWZg4caJaFrWKjvJo23Tr1g1Lly7FwIEDERERAYFAgIqKCq7DUmiURyX35MkTbN++HZcvX8bUqVPx1ltvqWVR21ZKU9gmJCRgxYoVOHfuHI4dO4aamhp4eHigtLSU69CUhrGxMebMmQN3d3ecPXsWO3fuxPPnz7kOiyixurlpd+/eDVNTUwQEBKBnz55ch0WaQHm07XR0dDBt2jS8+eabSEtLQ1BQEHJzc7kOiygxxhguXbqErVu3QiQSYcmSJRg+fDi1breS0nZFePLkCUxNTZGQkAAXFxeJHqPOl9BelZubi5CQEJSXl8PLywsDBgzgOiSFIxKJkJKSAgAYPHiw2nTal9Tz588hEAjw8OFDjBs3DqNHj6ZEDOXKM5RH2+bFixcICQlR+89AeXk5Vq9ejfT0dNjZ2eGrr74Sr9xGebR5FRUViIqKwo0bNzB06FBMmjSJ5qaFmnRFeFVhYSEANLvCVmVlJYqKiurdSC1zc3Nx61pISAgiIyNRVVXFdVhESdy4cQNBQUEoLS3FwoUL4ezsrJZf6MqO8mjbtG/fHgsWLMDo0aPFVy6Ki4u5DkvuVq9ejfHjxyM6Ohrjx4/HmjVruA5JKeTk5CAoKAjp6emYPn06vLy8qKiVAqUsbBlj+OCDD+Ds7NxsS+PGjRthYmIivllYWMgxSsWnp6cHf39/eHt749q1a9i6dSsePXrEdVhEgVVVVSEyMhIHDx5Ez549sWzZMpibm3MdFmkFyqPSoampCXd3d8ydOxdPnjzBli1bcO/ePa7Dkqv09HR4eXkBALy8vJCWlsZxRIqtbm7anTt3wtjYGAEBAejXrx/XYakMpSxsV65ciatXr2Lfvn3NbrdmzRoUFhaKbzk5OXKKUHnweDwMHjwYy5Ytg5aWFrZt24bz589TJ3/SwKNHj7B161Zcu3YN3t7e8Pf3h56eHtdhkVaiPCpdNjY2CAgIgLm5Ofbs2YOjR4+ipqaG67Dkws7ODlFRUQCAqKgo2NvbcxyR4ioqKsLu3btx8uRJODs7Y8GCBWjfvj3XYakUpetj++677yI8PByJiYmwsbFp0WOpb1jzampqcOzYMZw/fx69e/eGt7e3Wo/IpL5htRhjuHDhAmJjY9GlSxeaw/M1lCHPUB6VHXWcy7m8vBxr1qxBWloa7O3tsXHjRupj24i7d+8iPDwcmpqa8Pf3h7W1NdchKSy1mMeWMYZ3330XYWFhiI+Pb9XIa0rIkrlz5w4iIiKgpaUFPz8/tf3wMcbw4sULALV96dSxDymtutRyipxnKI/Kz8ur702ZMgUODg4KnUOaGwDWFpRHqdGoNdSisH3nnXewd+9eRERE1Fuv28TEROIPHyVkyRUVFSE0NBRZWVkYM2YM3Nzc1PqXtjq6f/8+QkNDIRQK4ePjg169enEdklJQ5DxDeVS+qqqqcOjQIaSmpmLgwIHw9PSErq4u12E1KjAwEOPHj4eXlxeioqIQFxeHzZs3cx2W0isoKEBISAiePHkCDw8PODk5qWVx31JqUdg29UbYuXMn5s+fL9E+KCG3jEgkwunTpxEfH48ePXrA39+f+gIpMGm1uIhEIsTHx+PUqVOwsrKCn58ffV5aQJHzDOVRbly7dg3R0dEwMDAAn89Hjx49uA6pAU9PT0RHRzf5b9IyjDFcuXIFhw4dQrt27cDn89GtWzeuw1IabckzSnNNUUnqb5WioaEBFxcX2NjYQCAQICgoCNOmTVOb0ZvKdgmtbsqdH3/8EVFRUVizZk2LW1xevHgBgUCABw8eYOzYsXB2dqaWehVCeZQbAwcORI8ePSAQCLBjxw64u7tj1KhRCpVT6gaA1bXYSmsAmLLlUWmorKxEdHQ0rl27hsGDB2Py5MnQ0dHhOiy1oTQtttJALQ2tV1FRgcjISNy8eVNtJpFWtkEPbW1xuXnzJiIjI6Grqws+n0/TOrWSqucZVT8/WRIKhThx4gTOnDkDOzs7+Pr6wsjIiOuwADQ/AKwtlC2PttWDBw8QEhKCsrIyWvyoDdSixZZwS09PD2+++SYuX76MI0eOIDs7G3w+H127duU6NPK31ra4VFdX48iRI7h06RL69esHLy8vqXyhEULq09TUxIQJE2Bra4uwsDBs2bIFvr6+CjE9lr6+PvWpbQPGGM6ePYu4uDiYmZlh7ty56NChA9dhqSVqsSUt9uTJExw8eBDPnj3DxIkTMWzYMJW8vKRsLQ2taXF5/PgxQkJC8Pz5c0yePBlDhgxRyddSnlQ9z6j6+clLSUkJwsPDkZaWhlGjRsHd3R2amppchyV1ypZHW6OkpAShoaG4f/8+Ro8ejbFjx6rkaylP1GJL5KpLly5YsmQJYmNjERMTg4yMDEybNo1a+TjWkhYXxhiSk5Nx9OhRdOrUCcuWLUOXLl1kGyAhRMzIyAizZs1CUlIS4uLikJmZCT6f3+zyxopMVtOFKbp79+4hPDwcPB4Pc+bMga2tLdchqT3V++lE5EJbWxtTp07FjBkzkJmZiS1btiArK4vrsIgEysvL8ddffyEmJgaDBw/G4sWLqaglhAM8Hg+jRo3CokWLUFFRgaCgIFy9epXrsFqlbvBqdHQ0xo8fjzVr1nAdkkwJhUIcPXoUe/bsgZmZGZYvX05FrYKgwpa0SZ8+fRAQEIAOHTrg999/R3x8PEQiEddhkSZkZWVhy5YtyMzMxIwZMzB16lSVHwRIiKIzMzPDsmXL0KdPH4SGhiIsLAxVVVVch9Ui6enp8PLyAgB4eXkhLS2N44hk5+nTp9ixYwcuXLiAiRMn4u2334ahoSHXYZG/UVcE0mYmJiaYN28eEhMTkZCQgPv378PPzw8mJiYyOZ66XvJqC5FIJH59LC0tZfr6EEJaTldXF35+frCzs0NMTAxyc3PB5/PRvXt3rkOTiKymC1M0V65cQUxMDIyNjbF48WKleX3UCQ0eI1KVlZWF0NBQVFVVwdvbG3369JH6MeS1Qg5jDA8ePMD69evx4MED2NvbK2URXVhYiNDQUGRnZ8PNzQ1jxoxRyQEcikLV84yqn58iePr0KUJCQpCfn4/x48fjjTfeUPhBnc+ePcO0adNQVFSEdu3aITIyEh07dgRjDM+ePQMAdOzYsUXnoUiNGJWVlYiJicHVq1fh6OiIyZMnK+wqcqqgLXmGvt2IVFlZWSEgIADW1tbYv38/YmJiUF1dLdVjyOuSF4/Hw7fffgsvLy/ExMRIvd9YeXk5AgMD4enpicDAQJSXl0tt33Vu376NoKAgvHjxAvPnz4erqysVtYQouE6dOmHx4sVwcnLC0aNHsXfvXpSWlnIdVrM+//xzfPLJJ7h69So++eQTrF+/HkBtHu3UqRM6derU4uJcUfrtPnz4EMHBwbh9+zb8/Pzg4+NDRa0Co284InX6+vqYPn06pk6dipSUFGzfvh1PnjyR2v7rLnkBkNklr7qi8+TJkzIromWZtKurqxETE4P9+/fD2toaAQEBsLKyktr+CSGypampiYkTJ2LWrFnIysrCpEmTMG7cOJn9CG6rphoc2vIDnut+u3Vz0+7YsQN6enoICAjAoEGD5BoDaTkqbIlM8Hg8DBgwAFlZWfjll1/g7e2NM2fOSGVJz6+++gpxcXHw9PREXFwcNm7cKIWI61u9erV42cs9e/aAMSb1IlpWSfvJkyfYvn07UlJS4OnpienTpytd9wlCSK2ePXsiJycHw4YNg6urKzp37oxPPvmE67AaaKrB4ZNPPsHIkSOxZ88euLu7t+gHvDwaMZpSUlKCPXv2IDY2Fm+88QYWLVqktFOxqRsqbInMrF69GtOmTUNKSgrGjx+PDz/8EAcPHkRFRUWb9ls3X2t0dDQ2b94sk6ItPT0dnp6emDNnDqKjozFo0CCpF9HSTtqMMVy6dAlbt26FSCTC0qVLVXbxDELUSU5ODr7//nu4u7uDMYb4+Hg8f/6c67DqaarBIT09HT179kRaWho8PT1b9ANeHo0YjUlPT0dQUBDy8vIwe/ZsTJgwgRZcUCI0KwKRmfT0dPz4448AgPXr1yMhIQEZGRkICgqCv78/LCwsOI6waXVFp7m5OZycnGBqair1AWpfffUV1qxZg+DgYPFKYa1VUVGBqKgo3LhxA0OHDsWkSZNoGi9CVISdnR2io6Ph5eWFe/fuoUOHDggKCoKXlxcGDBjAdXgAml4gxs7ODomJiXBxcWnwA/51g8PkvcyvUCjEiRMncObMGdjZ2cHX1xdGRkZyOz6RDpoVgchMY7MXrFu3DqGhocjNzYWbmxucnZ1lOpiptaNq6x53+fJlmJubY/v27Qo7T2FOTg4EAgEqKiowbdo09OvXj+uQ1Jqq5xlVPz9F9Opy2WvXrkVcXByuX7+OIUOGYNKkSdDR0eE6zEaVlpZi8eLFyM3NxZAhQ+rlYHnNcCOJZ8+eQSAQIC8vT9wNja52cacteYYKWyIzrybjjRs3Ql9fHyKRCAkJCUhMTIS1tTV8fX1l9nq0JXEq+hrnIpEIp0+fRnx8PMzNzeHn54f27dvL7fiKNBWPIlH1PKMq56fs71/GGFJTU3Ho0CGYmJiAz+ejW7duXIfVQHN51NPTE9HR0U3+W16uXbuG6OhoGBgYgM/no0ePHnKPgdRH030RhdRUX1gNDQ2MHTsW8+bNQ0FBAYKCgnD37l2ZxMD1qFpZKSoqwu7du3Hy5Ek4Oztj/vz5ci1qAcWZioeQ1lD29y+Px8PgwYOxbNkyaGlpYdu2bTh//rxUBujKC5eDwwCgqqoK4eHhEAgE6NWrFwICAqioVQFU2BLOWFtbY/ny5bCwsMDevXtx+PBh1NTUSPUYXCfOtmpsqpw7d+4gKCgIBQUFmDdvHsaNG8dJa7Kq/mgg6kGR378tmSKrc+fOWLx4MYYPH47Dhw9j//79KCsrk+ox2qK8vBybNm3CqlWrsGrVqnrHaWpwmDxiy8vLQ3BwMG7evAkfHx/4+fnR3LQqggpbwikDAwPMmDEDkydPRnJyMrZv346CggKp7Z+rUbXS8nKr0tixYzFz5kzs27cPFhYWWL58OaytrTmLTdl/NBD1psjv35a2JmtpaWHSpEl4++23kZOTgy1btiAzM1Oqx2itNWvWwMnJCZs3b6433VddV5C0tDTY2dmJu6q9Lra2Fr2MMZw7dw7bt2+Hjo4Oli1bBkdHR+pPq0qYGiksLGQAWGFhIdehkEbk5eWxn376iX3xxRfs8uXLTCQScRqPSCRi+fn5LD8/n7NYpk6dyhhj7MmTJ2zLli2sV69e7Ny5c5zEU1ZWxt577z02depU9t5777GnT5+ywMBANnXqVBYYGMjKysrkHpMiUvU8oyrnV1ZWJtH799X3vTze53Wf+6b+3ZzCwkK2c+dOtm7dOhYXF8eEQqHUj9ESU6ZMqZdH647z3nvvscjISMYYY5GRkSwwMFCi2OoeV1ZWxvz9/dnQoUMlfl1KSkrYnj172Nq1a9mRI0dYdXW1FM6QyEJb8gy12BKF0a1bNyxduhQDBgxARESEeKQ/V3g8Hrp06YIuXbqgoqKiRa0E0rqUZmtri82bNyM4OBgpKSlwcXHBiBEjOGldeLUVZf369TKfT5gQWZF0Pmwu+uK2pTW5Xbt2mDt3LsaOHYvTp09j586dePHihVSP0RL29vY4d+4cunTpgujoaPFxmusK0lxsdY9bvXo15s2bh+Tk5Ne+LuXl5Zg/fz6GDx+OX3/9Ff7+/pg4cSK0tGjGU1VEhS1RKDo6OvD29gafz8e9e/cQHByM3NxcqR+nscKzuWK0pV9uL2/v7u6OCRMmtLjIraiowBtvvIH9+/cjPDwcOjo6+N///tem824LRe6TSIiscPG+b2sXKg0NDbi4uGDBggUoLi5GUFAQbt68KdVjSKqp4zRXvDYXW93jJH1dhEIhZs2ahaqqKqxevRrvvvsuduzYIZNzJYqBpvsiCuv58+cQCAR4+PAhxo0bh9GjR0utpbKxacAYY/XuO378OL744gsAwIwZMxATEyN+fGPT0rw8fVBOTg7OnTsnbgVydXVFQkJCo1OONTbt0NOnTyEQCFBWVqYwk7Ar0pyTikzV84yqn9+rlP19X1FRgcjISNy8eVPqi7dIMmUaYwwlJSUAACMjI3EOb2o6SEmOuWbNGpw8eRJr1qxBUlISUlNTIRQKcezYMfE+ysvL8f777+Ps2bPIz8/Hnj17MG7cOPB4PM6mFSOSa1OekXK3CIWmKn3D1ElNTQ07fvw4W7duHdu1axcrKiqSyn4b68P16n1TpkxhycnJLDk5mb377ruN9gd7uf/d6NGjWUREBGOMsdDQUObv788YY0wgEDTbf+zlPmN+fn6sd+/ebMSIEeyXX35hz549k8r5SoOkfRLVnarnGVU/v1e19n3PRd/cpohEIpacnMy++OIL9vPPP7NHjx61eB+NnU9z/WTrCIVCcR5tqr9va5SVlbHRo0czgUDAGGMsIiKi3vFnzZrF5s6dy3744Qe2detWcT5uKk6iWNqSZ6jFliiFjIwMhIaGgjEGHx8f9OzZs037k7TFdu7cuQCAPn364LPPPmvQuvDyfupaZesMGzYM3bp1w4sXL7Bq1Srw+fxGW3zqWg+WL18OPT09tG/fHpqamsjPz+e06wFpHVXPM6p+ftKiiC29T548QUhICJ4+fYqJEydi2LBhjV4Fa6wltq571cvnk5aW9toFFmS50E1jCzyEhobiyJEj+Oijj7BhwwZ4enpCT09PnI9b0jpMuEMLNBCVZ2tri+XLl8PMzAx79uzB0aNH2zTnbWN9uF69b8OGDeLtmxpo8nI/L0dHR4SGhgKo7TPm7OyM6OhoHDt2DKdPn26yL5udnR2Cg4MRHx+PHj16YM6cOfjXv/6FjIyMRmOX1/yThJDWU8Q+6V26dMHixYsxePBgxMTE4MCBA43mj8bGFDR2PlxPmfbq8bt3746tW7fi2rVrGDp0KHR0dKCnp1cvH9NAV9VHLbZEqTDGcP78eRw7dgympqbg8/no1KlTs49p7dKZkrQ0vNwqExISgs2bN6N9+/YStwrU1NTg0KFD2LBhAx4+fIivv/4aM2fObLaFp7GWoI0bNzZ5jsq+dKiyUfU8o+rnJy2K2GL7stu3byMiIgLa2trw9/eHlZWV+G+NtYTa2dk1mnde109Wli22df1t7927B2NjY/Tu3Rvdu3eHv78/jIyMWtWHlyiGtuQZKmyJUsrLy0NISAiKi4sxdepUODg4NLntq18wR48ehaam5msLPUkScmsHQADA06dPERISgvz8fEyYMAGDBg3Cp59++tp9SfqlU/clquhfsKpG1fOMqp+ftLQlN8hLYWEhQkNDkZ2dDVdXV7i4uEBDQ6NezoiMjMQ333yDdu3aoaioSFxASno+rS1sJf1BXlZWhsjISNy+fRsjRozAhAkTaBovFUCFrYQoIauWyspKHDp0CFeuXMGgQYMwderURpdEfLUQHDp0KNatW/faQleWLQ1XrlxBTEwMjI2Nwefz0b17dwCSJfPGCtXm+ro1VgjTiGDZUfU8o+rnp0jkcbVFJBIhMTERCQkJsLS0hJ+fH3R0dMRF+evGCEiy/9bkUUl+kGdmZiI0NBTV1dXw8fFB7969JY6LKDbqY0vUkq6uLnx9feHn54fbt28jODgYDx8+bLDdq/2whEJhvb5iSUlJcpuAvbKyEqGhoQgLC0O/fv2wbNkycVELSDZfbmP9g5vr68Z1PzhCSOvIY3EIDQ0NuLm5Yf78+Xjx4gWCgoKQmZkpHlPQvn178Pl8ALX5MiEhAStWrJB5H/9X+/SeOnVKfCyRSISTJ09i165d6NixI5YvX16vqKVxCOqNClui9AYNGoSAgADo6elhx44dOHv2LF6+EPFqITh69OhmC926QR48Hg/m5uYwNzeXyvy5Dx8+RHBwMO7cuQM/Pz/4+PhAR0en3jaSDDhpbCBbcxOay2sidkKIdEmSD6RVxFlZWSEgIADW1tY4cOAAYmJiUF1dDTs7O4SFhQGozZc8Hq9FxXZr8+irx7WxscGaNWtQWFiI33//HadOncLYsWMxd+7cBi16XKwWRxQHdUUgKkMoFOLEiRM4c+YM7O3t4ePjAyMjowbbvdr3rbq6GpMmTZJZH1TGGJKSkhAXF4du3brB398fHTt2bHRb6g+r/FQ9z6j6+SmK8vJyjB8/Hh9++CH8/PwQGRmJEydONMgH0s4ZjDFcunQJR44cQceOHTF16lR4e3vD3Nwc9vb2uHv3Lg4dOiTeXlZdm8rLyzFy5EjxcTdu3AgPDw+IRCI8f/4cb7zxBn755ReJxyFQ9yvlQn1sJUQJWT2kpaUhLCwMPB4Pvr6+sLOza3b7tg7yaK4fXElJCcLDw5GWlobRo0dj3Lhx0NTUlGosNOuBYlH1PKPq56coAgMDMWbMGJw+fRopKSkNVtYCaj/7zs7OuHTpkvg+T09PHDx4sM05IT8/HwcPHsSLFy9w/fp1zJw5E9OmTQOfz8esWbPg6+sr8x/fdUX7pEmT8N///he///47Zs6ciXXr1uH48eMtmjlGURoIKF9LhgpbCVFCVh8lJSUICwtDenq6RAVlYxhjKCsrQ3l5OdavX4+MjIxGE1FTSTQ9PV18KU2SAru1FDmJqyNVzzOqfn6KQpJWx8DAQDx48ADz5s2Dl5cXwsLCkJCQ0GCxmdbmhOrqahw9ehRJSUlISUkBY0ycxzIzMyX68V2XRwHAwMCgRd0R6rpZnD17Fu3atQOPx8Pp06fF+2iqJVaRZ6SgfC2ZtuQZmhODqCQjIyPMnj0bZ8+eRVxcHDIzM5vtAtAYxhhu376NTZs2YcaMGfjf//6HqKgorFmzpl4iSk9Px48//gigth9cUFAQjh07hvj4eCQnJ4PH4yEnJ0dmv8xfPX5wcHCDbaiVgBDlUjfos64AamzQZ3p6Og4ePIg1a9YgODgYubm5SEpKwptvvvnanCAJbW1teHp6wtbWFsbGxtDV1QWfz4eFhYXE+6jLo0DtrAiSFraMMdy4cQOWlpZwdHQEn8/Hl19+iejo6GafE+CfcQiKSJJ8TdqGBo8RuZPXiFUej4fRo0dj0aJFKCsrQ3BwMK5du9bi/eTm5jY7gOPlWQf27t2LyspKnDt3Dvfu3cOKFStw5MgRjBkzBhMmTJDJOUsy6wENpiBEuUgy6NPOzg7Hjx/H5s2bsWzZMri5uUFfX1/qM6H069cPAQEBMDExwc6dO5GYmAiRSNSmfTanvLwcf/31F6KjozF48GAsWbIEpqamKjEQlmapkT3qikDk4uUWwxcvXiAwMBCnT59Gampqo33HpK2yshLR0dG4du0aHB0dMWXKlAYzEryqbv7FuhZbb2/vRi8d1V32unz5MoRCIfz8/DBz5kwsXbpUfJksMDAQrq6u8PPzk/rlJ0kuu9FgCvlR9Tyj6uenTJr67MvqUrxIJEJCQgISExNhbW0NX1/f174HWjqPbVZWFkJDQ1FVVYVp06ahb9++bY77ZVxfvVLkbhKKRK59bK9cuYKoqCh07NgR06dPR+fOnesFsmrVKvz2228tCkJeKCFz5+V+Ra6urnB0dBT/OzQ0FN9//73Mi1vGGK5cuYJDhw41WBihMXUJuaKiAn/99RfS09MbTURVVVU4dOgQUlNT6y0U8eo5JyQkiB8j78KS+nXJj6R5RllzKeVRUrcwQk1NDby9vZtdGEHSwlYkEuHUqVOIj4+HhYUF/P39YWJiIvXYKRcqB7kVtrGxsfDy8kLPnj1RXFyMsrIy/PXXXxg7diwA4PHjxzAzM4NQKGzZGcgJJWTuvFzIBQYGIiUlBYmJieK/u7q6YvDgwXJJMK8uZTtixIhG+31JkpDrlvYtf/YMnk5O6Ne5M5CfDxQUoCo/HydDQlD1+DG0ysrgaGeH7oaGeJqbi6e5ubA3N4dGZSVQXQ3U1NTe/r68x1C7VGQ1Y4C2Ntp16gQNXV1AX7/2ZmAAGBsD7drV3kxMgI4d/7l16QJ07Vp7MzJCeUUFtRLIiSR5RplzKeVR1dGW1suysjJERETg+vXruH79Oqqrq9GzZ0989dVXACDer62tLd566y3o6ek1mUeLioogEAiQnZ0NFxcXuLq6tnilx5fPxcrKCkBt6++r50VXr5SD3ArbUaNGYezYsfjyyy/BGMOmTZuwfv16HDx4EJMmTVLoZAxQQubSy7+SQ0JC8J///AdffPFFvfkZX10WVpZqamoQFxeHpKQk9OzZEz4+PjA0NKy3jUgkQlJSEn756Sfo5OfDsV07dCouhkZODuy0tNDL0BDCrCy0Ky2F7t+jfhWSgQHQo8c/N0tLwNq6/u013TKI5CTJM8qcSymPqo62tl4yxjBjxgxoaWlhzJgxMDY2xsWLF+vNyhAREYH9+/fjo48+arSwTU1NxYoVK/D8+XOMGDECv/76a6t+dL98Lvv378c333wDMzMz6OnpoVu3bvj555+lcs7SwHV3CGUgt8LWxMQEly9frjdt0b59+7BkyRLs27cPTk5OCpuMAUrIrSGtD+Cr/Yr+85//YNq0adDU1MTgwYPh7OyM06dPyz3B3Lt3D2FhYdDU1IS/uzusy8qA27eB27fBbt3Cg8REdCsrg1ZNzet3pqNT20Jqagp07vxP62n79kC7dvhl926sWL0aMDQE9PWxet06fLV5M6CtXXvT0gL+TvrLli1D8JYtgFAIVFfjg3ffxfcbNwLl5bW3sjKgpAQoKqq9vXgBPH8OPH1ae8vPBx4/rt3udTQ0ACsrwN4e6N0b6NsX6NMH6Nev9nyksOqaOpEkzyhzLqU8qjr8J0+GIChInDe+/uQTfLJsGVBYWJtTSkqA0tLaPFJWBlRWAlVVtf/9+wpT2t27sLK0xPPCQtSIRHheVARoaaH/4MGAjg6Yjg6OJyXBcfRodLa0BM/YGGjfHkIjIySnp2Pzrl0YOnEiVvznP4i7ehXHT51q1ffAq1cFXx7T8O9//xupqakAFKOPqyIU14pOboWtqakpDh8+jKFDh9a7/8CBA1i4cCG+++47rFixQiGTMUAJuTVk+QGUdYJpsigXiYB794CUFFQnJ+POX3+h86NH6FZd3eS+mLY2eNbWSC4ogE7Pnijs0AFnsrLw/qZN+G7/flzJz0e33r3x1ddfN3kOLXkupfa8l5YCeXnAgwe1t9xcIDsbyMysvd2/32zxW6KnhwwDAzy3sMDIgADovPFGbcFLLbxNkiTPKHMupTyqBBgDnj3753Oek1P72c/Nrc0Djx7V3kpKuI60gRItLRjZ2wPdutVeYTI3r71ZWAA2NrVXmBp5372cM11cXOp1dRs2bBiSk5PleBb/aOx76M0336TuEK8ht8LWw8MDHh4e+Oijjxr8bd++fZg3bx6EQqFMk/Gvv/6Kb7/9Fnl5eejfvz82b96MMWPGSPRYSsgtJ2l/JEW8tBIYGIjx7u7wGjgQl7ZsQWFcHFz19VF94QL0mihi83V0UGVvj87OztBzcMAvx46h99SpGDt3Lr7YuBEHDhzA6tWroauri6SkpBZNhN6SQr68vBz/93//h1OnTkFbWxsjRozApk2bpP+cMlb7BZeWVlvs/91ajVu3IEpPh0Zj6UFHBxg4EBg+HHByqr316QO0cAEMVSVJnuE6l1IeVRGFheLPK+7d++eWng4UF0u0ixpNTRRqaaHSyAhd+/WDZseOtX32TUxq+/EbGtbeDAwAXd3az7+OTu1VJg0NVFZX49PPPoOfry9GjxyJ6IgInE5IgIGGBnR5PNh07w6fiROhU1UFVlKCJxkZeHz3LoyEQhTn5qKLhgY6iETQKympbQWWRMeOgJ0d0LOn+FZoZgb/Tz9FfmkpqqursWHDBvj6+iIsLAxxcXHirgjy1lgjhbQW0FBlcitsw8LCkJiYiB9++KHRv+/btw9bt27FyZMnWxSEpA4cOIA5c+bg119/xejRoxEcHIzt27fj5s2bsLS0fO3j656o58+fN/lEvdz/53Xz9KnDtoGBgRg3bpz4A3jixIkGr7+Ghob4wzt16tQmt3s1BsYYmnv71W1bXl6OTz75RFw0N1YQivdbXQ12+TLY6dNI+vZbjOLxwHv0qOHO9fXx3MICxwoKwF+/vrZQGzAA4/l8eHl5oby8HJ6enrC3t8cHH3yAs2fPQk9PD+bm5qioqEDPnj2xYcMGTJ8+XTwnIY/Hg5eXF6Kjo197bjweTzxgraltV65cicePH6OiogL6+vro1q0bfvrppzbvV9Jt/adMgeCLL4CrV8G7fh1X//gDDkJh7SXKV7B27YARI8BGjwZv9GjwRo6s/TJE8++1l2PgaltAup+joqIidOjQodmEzGUupTyqHNvW/RBOT09Hb2trfPn229C9cwe869fBu34duH699mpMM1i3buBZW9f2qzc3B+vRA8zMrLY1tFu32q5G7dqJuxu1Jj8DEOf9OpMmTQKfz0deXh7Gjh0LZ2dnVFVVISoqCtevX8eQIUMwceJEfPzxx3B2dsaZM2eQcvkyDKqqEBYUBP3CQuDhQ7C6VuaXrjTxnj5t/pytrJDXqRPiHj9GXpcuEPbvj/d++QUGf69cJsm5STOP1n131m3r5eUlXvI4LS0N1tbWYIyJB7rVfb8pQm5U9DzaFKWax3bEiBEYMmQItmzZIr6vb9++8PHxaXSi5srKSlRWVor/XVRUBAsLC8THx8PIyKjB9iYmJvUmS05JSWnyxTE2NkavXr3E/75y5Qpqmvi1aWBgUG8uvmvXrqGqqqrRbfX09NC/f3/xv2/cuIGKiopGt9XR0cHAgQPF/75165Z46cJXaWlpwcHBQfzvu3fvoriJX/QaGhoYPHgwgNqicvny5UhPT4e5uTlWrlwJPT29etsPHTpU3JKbkZGB58+fY9WqVY3+An158EBmZiaeNpOkHBwcoKWlhcDAQDg4OMDBwQGJiYm4cOHCPy1dNTUwvHUL9jk50Dp9Gjhzpvby+0uYpibyu3fHVT09XOTx8MHevdBzdAS0tDBw4EAsXLhQfOnqwoULePfdd3Hq1Cmkp6fDxsYG5eXl6NixI1xdXRu8HzZt2gQnJye4uLggLS0NSUlJ2Lx5M548eYLs7GxUVFTg559/Rm5ubr3nz97eXjyVzdOnT5GZmdng/GfMmIF33nkH8+fPx+nTp/Hvf/8bJ0+eREZGRpPPmbW1NTp16oTy8nK8//77uHHjRpOvm6WlJbp06QIAKC4uxt27d5s8txs3buDy5cvY/MMPKLt5E3nR0TC8cQOGN27A4NYtaL664ISWFjB8OKpHj8Z9a2uUODqCvXJ8AOjatSvMzc0B1E6b1twCGl26dBEXXjU1Nbhy5UqT23bq1AnW1tYA6s9u0ZgOHTrA1tZW/O9Lly41ua0kOaKkpARubm4K26JJebQ+eeRRAEhLS0NhYWGj2wL4p1tKVRVyDx/G0f/+FyM0NWH74gV009Oh2UTrfU3XriiztESFlRUqLSz+uXXvDqanJ86jAJCdnY0nT540GcPAgQPF83vn5ubi8ePHTW7br18/cQPD/PnzMWDAAIwdOxYnT54U5+hLly4hNTUVFhYWYIxBW1sbI0eOFL9vGsuPgwYNgrGxMQCI82i957W0FDp5edDLyYFZWRn0c3KAO3fw4tw5tG/iSpxIVxeiAQOg5eQEDBuGwt69kaat3eRVpro8CgCFhYUNFuV5Wavy6ObNKC0tFa9sWff3l7/funfvDjMzMwC138M3b95sMgbKo/W1aEnd58+f488//8S8efMaHKiwsBB//PFHo3+ThqqqKly6dAmrV6+ud7+HhwfOnj3b6GM2btyIzz//XOqxqBN9fX3861//EifkiooKbNq0qV4iAv5ZTaV///5ITEwUf8heVlFRgVWrViEjIwN2dnZYvny5RDGkp6fjww8/xJMnT+AyZgwu7tmDLvv3o9358zC+fBmarxSyIhMTFA0ahBf9++P3u3dxqrwcplZWWLlyJa79/DOiMzPBHzYMUVFRGDZsGC5cuIDQ0FDx+ejq6sLFxQWPHz9GSEgIzM3N8cMPP8DQ0BC5ubn1jrVy5Ur8/PPPCA0NxcCBA/Hdd9/V+/vPP/8MJycnfPTRR0hMTMTPP/+MlStX4pNPPkFubi7s7Ozwf//3f42et5aWFlxcXADU/up/+b3cVMFcZ/Xq1XBzc8OSJUvEx23ssndzXj63Pn364H//+x/A44FZW+PF+PF4MX587YY1NdBPS4PR1aswunIF7a5dg9bDh0BSErSTktALgEhbGyUODigePhxFI0eirE8f8UA5dcRVLqU8qni0CgpgdOUKsHcvcPYskJIC88pKLHpluyItLfAcHFBub4/O48ZBY9AgoG9f5D5/3mwDgbwcPnwYERER0NHRQadOnaCpqYlhw4bh2bNniIiIgLGxMb766itYWlqK86ienl6L85LI0BAV9vaosLdHZ3t76P/dQPDx0qUYbGGBcd26IffoUYiuXMFIAwPop6VBs6wMGpcuAX8XWyYAHPX1Uda3L0ocHFDi4IDSgQMhbMO8ueXl5fj4449x/fr1ejm50Tz6ktzcXPFz4OLigtDQ0FbHQGq1qMX2v//9L65evYqDBw82+vfp06fDwcEBn332mdQCrPPw4UP06NEDZ86cwahRo8T3b9iwAbt27cKdO3caPKaplga6hNb6bVetWgV3d/d6XRN+/PFH8WWze/fuwd7eHhs2bGjQXWDVqlWYMGGC+LHHjx+vdyn25UtvdnZ2+PrvgVgfrVgBfqdOGPHkCcrCwmD4SisC69ABVzt2RJKeHgodHPBucDD0DAwaPa/y8nJ89tln4n6uGzZsaNCS+ejRIwgEArx48QKdO3dGVlYWDAwM4OHhgeHDhze51nljl6RevgwF1BaodnZ2GD9+PKZNm9bo81Bn5cqVcHd3h5+fH8LDwxEXFyfuirBq1SrxTBJ1q7fFxsbCwMAAPB4Pnp6eiIqKEl8W8/Lywl9//VXv+f3qq69g8PfzJNVLcwB4WVlAQgIQHw924gR4OTn1tmFdugAeHsDkyeBNnlzbZw7qcwmNq1xKeVT6276at17uKtXofjMzgYQE8BITgcRE8Bq5AsM6dMBtY2NojBiBnm+9heNPnyLm+nX88PdVsNZ2GWhu2/Lycnz66af1zuPV3NjUfl/tiuDl5YW9e/ciNDQUmZmZMDIygkAgwNOnT9GvXz/88ccf4lbZV7W2G0BZWVm9MQzi7yCRCEhLAy8lBbzLl4HkZLDkZPAaGTjH+vcHxowBXF3Bc3MDunWTOIbAwEC4u7uLc29j3fEaO7fGvlN/+OEHheheoOh5tEmsBRwcHNjx48eb/Pvx48eZo6NjS3YpsQcPHjAA7OzZs/Xu/+KLL1jv3r0l2kdhYSEDwAoLC2URolqYOnVqs/9uy2Pfe+89FhkZyRhjLHLbNvaVnR07b2rKKrW0GKsd5sQYwETa2oyNG8fYV18xlpzMAleu/OdxkZEsMDCwFWfGmEgkYufOnWPr169nW7ZsYY8fP2bJycns3LlzLDo6mq1du5bt3buXlZaWSrzPeuf0d2ySPodlZWXi7QMDA1lZWVm9x7y8b4FAUO+8GztuY/fJhUjE2N27jP36K2M+PowZG9d7PZmGBmNjxjD2zTeM3bkjn5hkSJI8w1UupTwqfa/9XD1+zNjevYwtWsSYtXX99z7ARBoaLKdzZxZtacn+mDCBlV+7xphI1Oznn5PzaMFj586dy77++mu2adMmlpaWxmbMmMG+++47dubMGfb222+zcePGsYKCAlmchmRqahi7fp2xbdsYW7CAsd69G7wuDGCsb1/GVq5kLCyMsRcvmt1la78b5f06K4u25JkWFbZGRkYsKyuryb9nZWUxY2PjFgchicrKSqapqclCQ0Pr3f/ee+8xFxcXifZBCbntpJn8Xn3sgrFjGfv2W8ZGj2bCVxLMMyMjxgICGIuMZKy4uN7j2lJs1yktLWV79+5la9euZYcOHWLV1dVMKBSy5ORklpyczIRCIbt9+zb7+uuv2Xfffcfu37/f7P7KysrYe++9xyZPnsxGjx7NJk2aJE5a0igwG3vfv3zejSVLaTxPUlFVxVhCAmOrVzM2cGDDL5N+/Rj77DPGLl2qLYqVjCR5hqtcSnlU+l79HE2bPJmx+HjG1qxhbPDghu9vLS3GRo5k7JNPGDt0iP3fsmXc/OB8RVvyQ12+mTx5MvP29maffvop27NnDystLWVCoZA5OzuL8+jDhw9Zv3792JdffslSUlKYqI2f8bqcWvdjv9WFYX4+Y6GhjAUGMuboyEQ8Xv0fIJqajI0ezdh//8vYhQuMCYX1Hs5Zw4GKkltha2JiwpKSkpr8e1JSEjMxMWlxEJJycnJiy5cvr3df37592erVqyV6PCXktmvLr8tGH3v/PmNff83YsGENvwCGD2fsiy8Yu3KFDRk8uMljtTWh3L9/n3333Xfs66+/Zrdv3xbf/2phy1jte2jnzp1s3bp1LC4uTnz/q+c5evRoJhAIGGOMRURE1ItJGr/QX3eMxihs4r1/n7Gff2ZswoTaL/2X3wN2drUF8OXLSlPkSpJnuMyllEel67333mOH//yTsT/+YLljxrAyHZ2GuczRkbEPP2Ts0CHGiorqPV5RfnC2NT88efKEBQUFsfXr17Nz586JC1ahUMhmzJjBvv/+eyYUCllkZCRbuXIlCwsLY2vXrmUhISGsoqKCs7ibsnrpUnZx9WrGli9nxWZmDV/Trl1rW3sFAsaKiqjlVcrkVti6ubmxTz75pMm/f/zxx8zNza3FQUhq//79TFtbm+3YsYPdvHmTrVq1ihkaGrLMzEyJHk8JWbpa80u5rKyMfbZ4MdvSvz/L6NatwSW5O+bm7Nf+/ZnPsGHiVqXIyEjm7+/fZMJqbUIRCoUsLi6OrVu3ju3cubPB+6Kxwrbu/oSEBPb555+zHTt2sBevXKJ6XWuqtLT0vNuaeKXWMtKcZ88Y272bMT8/xvT163+RvP229I8nA5LkGS5zKeVRKcnIYOyHH1jNmDFM+ErrHuvcmbFZsxj74w/GHj1qdjeyKsxa+nltbX4QiUQsKSmJjRw5kvXr148tWrSo3mOFQiE7ffo0mzFjBpsyZUq9fV+5coVt2LCBbd68meXm5rbq/AYOHFjvfmnl2lf3s2DsWMaCghjz9W3YnUpHh7EpUxjbupWxvDypHF/dya2wDQkJYVpaWuynn35iNTU14vtramrY//73P6atrc0OHjzY4iBa4pdffmFWVlZMR0eHDRkyhCUkJEj8WErI0tWihFxWxti+feyGlRUTamiIE4IQYGzsWMa2bKntiybevIw5ODg0eym9LZ4/f862b9/OPv/8c5aQkNBoy2tThW1dfAsWLGB9+/Zlo0aNYpcuXRL/7XX9X5WV3Ft8i4sZ27+fMX//2iL3l19kezwpkSTPcJ1LKY+20p07jH35ZeNdDAYNqu1Ck5RU24dTQrJq6ZPH57WiooKFhIQwJycn9umnn7LKysoGx2oujzLG2NOnT9nWrVvZ559/zk6fPl2va0JzxXnd+b333nssLCysxef5usL/1edvxYoV4u3fX7GCVcTEMPb++4zZ29d/H/B4tWMGfvyRsZwcCZ9J8iq5FbaMMfbpp58yHo/H2rVrxxwdHdngwYNZu3btmIaGRrMtEIpArROyDLz2EppIxNjZs4wtXsxYu3b1P/xOToxt3sxmu7s3uX9ZJeYbN26wjRs3su+//55lZ2c3uZ1IJGI5OTksJyenQT+wutjKysrYxx9/zEaMGMGioqJYVVUVe++999jBgwdZYGAgc3FxYaNHj1aJy1KcXjItLm7Qt1pRSZpnlDWXql0ezchgbONGxhwcGg56HDuWsc2ba7vTKJiWfl5b2sKbm5vLNm/ezDZs2MDGjBnT5LGay6N1ampqWGxsLFu7di37448/WPHfn/XmvgPqjlH3w2DgwIEt+mHwuu+XV39wvPPOO41vLxIxdvNm7Q+e4cMb/uAZPZqxn356bcs9qU+uhS1jjF24cIEFBgayKVOmsMmTJ7PAwEB2/vz51uxKrtQuIctYk4nh8ePaEe59+tT/gFtbs8NOTiwuKKjhY1htInnnnXfYkCFD2KBBg9jSpUvZihUrpNaSUVVVxSIjI9natWvZgQMH2rS/VxN379692X/+8x/2yy+/sMzMTIXoayXtrgMK20dXwbQkzyhjLlWLPPrkSW0x8sYbDQd+TZxYO5o+P5/rKJvV0s+rpNuLRCJ2+vRp9vnnn7Nt27axZ8+eSS03pKWlsQ0bNrCRI0ey/v37Mzs7O/bOO++Ic9fLebetx2xp4S/x9tnZjP3wQ21B++oPoQkTGPv99wb9rElDbckzLZrHtqysDP/3f/+H8PBwVFdXw93dHT/99BM6d+7csjnGOEJrnEtX3fyNaWlpsLezw9eTJkH399+BsDCgbgUYAwPgzTeBBQuAMWNQXllZb67Bl+d8DAwMhJubG3x9fREVFYVdu3bB3NxcKmto5+fnIyQkBM+fP8ekSZMwZMiQJuejlURjsXbs2BGOjo549uwZJk2ahKFDh7bpGG0V2Mga5W15Luu93q+8duQfkuQZZc6lKptHKyuBqCjgjz+Aw4eBuhXQeDxg7Fhg5kzAz08857Kik+TzWl5ejtWrVyM9PR15eXn1VouqW03yZSUlJQgLC0NGRgZGjx6NsWPHQlNTU6q5Yfny5dDV1UX79u2hoaGB1NRUWFpawt3dvV4Oa+sxW5ofW5VPHzwADh4E9u0DLlz45359fcDXF5gzB5gwocEKaC+/LnVzjqtbrm1TnmlJFfzRRx8xAwMDtmTJEvbee++xzp07Mz6f3+Jqmitq0dIgb8+f116K69Wr4YwGW7cy1oLnurFfxG293C0SidiFCxfYf//7X/bLL7+w/Pz8FrVkVlZWssrKygb3N9UHuKqqSjzn7f79+zntgqAoo63VjSR5Rplzqcrl0cuXa+cq7dixfg4bMqS25e3hQ64jlJmXWz39/f3rDdh9tQX03r177JtvvmHffvstS09Pb9FxmsqjjZk6dSoTiUTszJkzbP369WzgwIGsb9++Ur/6Je/BtywtrXaqsFe/K83NGfv009q5vv9GV8fk2BXB1taW7du3T/zv8+fPMy0trXqDHxSZyiVkLl2/ztjSpYwZGPzzATU2rp1rNiWlVbt87733JJ4JQRJlZWVs//79bO3atSw6OppVVVWJjyNJ0njdoIfm9nPz5k1xP15JR5tLW2PxyWVmAylRplhfJkmeUeZcqlJ5dPr0+kVGjx6108vduMF1ZHLx6tzXr/5YZ6y2/+vRo0fZ2rVr2Z9//slKSkpadIzX5dFXvfw9sHPnTubg4MBGjRrFrly50qLjtpTc8o1IxNj584ytWNHwx5SrK2N79jCfSZPqPUQdGyXkVthqa2s3mJJDT0+v2QE4ikSlEjIXhELGYmJq+wm9/GHs3792Vak29hsqKytjK1asYEOHDmUODg5sxYoVrU4umZmZ7Pvvv2dfffUVu3XrVr2/SdqS+bqE/Lpf8C9evGA7duxg69atY/Hx8RIldUlImoAbi0+ZWgKUKdaXSZJnlDmXqlQe/eab2qmapk9n7PDhFs1moApe9xkrKChgwcHBbP369ezs2bOtWkyhpYXtq98DAQEB4sVzQkNDWWVlpUyKUE7yTUUFY3/9xdjkybV9cP/+Ti3R02Pp06YxdueOUuU+aZJbYauhocHyX+kwb2RkxDIyMlp8YC6oVEKWp7IyxoKD6y87qKFRO9foyZMKNXG+UChkJ0+eZOvWrWO//fZbgzlmGWs6gb2aLEtKSlqUkCWJRxrvvbYkYFmPlJYmZe1KIUmeUeZcqlJ59MULxp4+bXYTZb1yIInmfpynpqayL7/8kv3444/swYMHrT5GSwvbptTF87///Y8tWrRI6kUo5/kmJ4exzz9nzMKiXsPRbQsLVrFvH2PV1fKNh2NtyTMaLeyPi/nz58PPz098q6ioQEBAQL37iIp4+hT4738BKytg2TLgzh3AxAT48EMgPR0QCAA3t9rBFW1QXl6OwMBAeHp6IjAwEOXl5a3aT2FhIXbt2oWEhAS4urpi3rx5MDExabDdV199hbi4OHh6eiIuLg4bN24EAHz00Udwc3NDdHQ03Nzc8OGHH2LTpk1YtWoVVq1a1aq4NDQ04Obmhrfeegvbt29H37590bt3b6xYsaLV55meng4vLy8AgJeXF9LS0iR+rJ2dHaKiogAAUVFRsLe3b3b71atXY/z48YiOjsb48eOxZs2aVsXcGi2NVZlQLlUQJiavHQzG5WdA1vT19bFx40bY2dkhLS0Nq1evxosXLxAWFoawsDD07dsXy5Ytg5mZGdehwsHBAcuWLYOOjg5OnTqFzp07gzHW4hzYFM7zjbk58J//APfvA9HRgKcnwOOhd04OdGfOBOzsgG++AZ49k29cSqhFsyIsWLBAou127tzZ6oBkSWVH80pbbi7w/ffA1q1AaWntfZaWwPvvA4sWAcbGEu1G0pGd0hi9f/v2bUREREBbWxv+/v6wsrJq0eMBYOjQofVGBffr1w9LliyBi4sLcnNzcfLkyVbPKhAYGIiRI0cCACIiIpCdnY0hQ4bgp59+atW+Wvt8tXQk8asjoxsbKd3csdoysldZZ2GQJM8ocy5Vtzza2s+Asoxsfzmf/P777/j999/h4eEBT09PDBo0qM37F4lESElJAQAMHjwYGhotak9roKamBnw+H/r6+vD09ISOjg7OnDnT5tlzWpNvZP4aZ2YCwcHA9u1AQUHtffr6tbMpvP8+0KeP0rzPWkpusyIoO5W6hCYLaWm1iyloa9df43zv3lZdBpH0kvmrl3yGDBnS7OW+ly8NrlixggkEArZ27Vq2b9++Nl0mHDRoUL147ezs6l1Ce3lC8MYuTTZ3ybLusXWzNPTq1YsNGDCgweVoSchzTfK2dHtQ1j6ybaXqeUbVz+9VrX0fK8v7v7FZCJ6+pntGS0irK8LLysrK2Ny5c1mfPn2Ys7Mzu8HRYD+5vcbl5Yzt3Fn7ffzy+JapU9lPvr4sMiJC9jHImdy6IhAVdecOMG8e0Lt37S/D6mrA1bV2LsfLl2vnb9TSavFuJb1kbmdnh7CwMAC1l4BsbGyavdxXd2lw586dEAqF2LRpE6ZOnYq33nqrTb9UnZ2dsWvXLnh6emLXrl3o3LkzEhMTxXHVXZpq6tLk6tWr4e7ujujoaLi6umLChAni7gZ158jj8fDo0SP07NkTnTt3xtatW3Hp0iUwyS+cQF9fH5s3b0Z0dDQ2b94s01/nTXXbkERbukwQoiha+xlQlve/hYUFPvzwQ8TGxoIxBjc3N3RU8Ll69fX1sWvXLly4cAFLlizBwYMHERcXB6FQKNc45PYa6+kB8+fXfh8nJAA+PrVdAGNisDIsDF6ffw4cOACvyZMV9n0mT1TYqrO7d4HZs4G+fWsnJRcKgcmTgTNngPh4YNKkNvWflbTP0ldffYXPP/9c/MWxe/fuZj+caWlpMDMzw9atWzFgwAAYGhpi+PDhbV4MYdOmTTA3NwcAmJubIyYmBteuXcPHH3+MEydOiL/Qmkpm6enpmDZtGgDAz88Pmpqa4qK37stx2LBh+Pe//w1ra2tERERg0KBBiIqKQkhICCoqKtoUvyy0pYjmvM8aIVLQ2s9Ac+9/aY0reFVL95ueng5LS0tcvHgRCQkJePbsGb7++mupxFKHx+OhS5cu6NKli9QXrDE2NsacOXPg7u6OM2fOYOfOnXj+/LlUj9Ecuec4Hg9wcaldBOnOHWDFClRpadUWvDNmoNTCAvPKygApvZ+UVYv62Co7desb1qS0tNpBYX/+CYhEtfdNmwb8+9/AsGFSO0xL+ixJ2m+0oqICvr6+aN++PWbNmoXq6mokJCRIZXUySTUVa2BgIFxdXeHn5ye+Py0t7bX98W7evInIyEjo6enB398fFhYWcjoT2VLWPrJtpep5RtXPT1qae/9Le1XAOpLuVygU4sSJEzhz5gzs7Ozg6+sLIyOjNh+fS7m5uRAIBCgrK4OXlxcGDBgg82MqQo4rz8lB/JtvYtTlyzCpW/Hz8OHahikl1pY8Q4WtOsnNrS1od+yobZ0FAC8vYN06YMgQTkOTJEHk5ORAIBCguLgYd+/exfPnzzlJJk3FWl5ejgkTJkBTUxODBw+Gs7MzTp8+LdEX1osXLyAQCPDgwQO4ubnB2dm5zYMsCDdUPc+o+vnJQ1sGZbZ1v8+fP0dISAjy8vLg7u6OUaNGcbr0dx1pDIKqqKhAdHQ0rl+/jiFDhmDSpEnQ0dFRqBhltt/SUuC334Bjx4CIiDbPVsQ1KmwlpGwJWWofooICYONG4JdfatdDB2p/za1fDwwfLt2gZUAkEuH06dOIj4+Hubk5/Pz80L59e6ns+3XPcc3f68VrSdjHuC2/4EUiEeLj43Hq1ClYW1vD19dXKd6npD5lyzMtpernJw9ctdheu3YN0dHRMDAwAJ/PR48ePdp8TElIkkcleU4k+U5kjCE1NRWHDh2CiYkJ+Hw+unXrJpXz4LqlXZ3QrAgSUrbRvG0ecVlaytiXXzLWrt0/oyjHjGHs1CnpBysjhYWF7Pfff2fr1q1jcXFxUhtVW6e551gWo3klkZGRwTZt2sS+/vprdufOHbkdl0iHsuWZllL185MHWc1s0tR+KysrWXh4OFu7di0LCQlhFRUVUjmeJCTNo5IskNCS78QnT56wLVu2sPXr17Nz5861atW01sSoSPtVZjQrgopq9YhLobB2dgN7e+Czz4CiIsDRsbbfTUIC4Owsu6Cl6O7duwgKCkJBQQHmzp2LcePGSf3yvCKOXLaxscHy5cthbm6OvXv34vDhw+IWD0KI8pPVzCaN7TcvLw/BwcG4fv06fHx84OfnB5FIJJPBa20hyUCsluTrzp07Y/HixRg2bBgOHz6M/fv3o6ysrNXxlZeX4/nz5wgNDQUAREZGSm2wGA20lS4qbBVYq97sR4/WFrFLlgB5eYC1NbBnD3DpUptnOZCXmpoaHD58GHv37oW5uTmWL18OGxsbmRxLUROKgYEBZs6cicmTJyM5ORnbt29HQd0E3YQQpSermRHqMMZw7tw5bN++Hdra2li2bBkcHR3B4/EUcjU1SaZVa2m+1tLSwuTJkzFz5kzk5ORgy5YtyMzMbFFcda+Ts7MzTE1NceLECbi6uuKbb75p0fSHzWnLtIqkIepjq8Ba1F/zxo3apW6PHq39d4cOtcvzLV8O6OqK96foK5QUFBQgJCQET548gYeHB5ycnGQ6sKG551jaK+a01qNHjxASEoLCwkJMmTJF/OVEFJOy5ZmWUvXzk5fW9KuUNIeXlpYiIiICd+/exRtvvIHx48fX69/a1CAzWXxHSDOPtmUMQ1FREUJDQ5GVlYUxY8bAzc1Noliaep2kNeCPNI4Gj0lIJRPy06fA2rVAUFBtFwRtbWDlSuBf/2qwBroid1BnMuzw31qKUtgCQFVVFQ4fPoyUlBQMHDgQU6dOhZ6eHmfxkKapZJ55iaqfn7y0ZmYESXL4/fv3ERoaCqFQCB8fH/Tq1atBwVpTU4NJkyY1OmWhtL8jFCmPvjwQuUePHvD393/tQOTGXqdly5Yp1PenKmpLnqGuCMqqpgb4+WegZ8/a2Q6EQsDXF7h5E/j++wZFLaCY/UmB2ila9u3bh4CAAISFheH27dswMTHhOqx6ZH3Z8HV0dHTg7e0Nf39/3L17F8HBwcjNzZVrDIQQ6WlNN6jmcnhJSQn8/PwwceJEHD16FPPnz0evXr0ANFwtkcfjNXrpm6vvCHnlVw0NDbi4uGDBggUoLi5GUFAQbt682exjXn6dwsLCkJubK7PuAlx/z6gKKmyVUWJi7byz774LPH8ODBwIxMUBoaG1A8aaoIj9SXNzcxEcHIyff/4Zc+bMQXJyMiZOnKgQfb5etmbNGoXokzZw4EAEBATAwMAAv/32G06fPt2i5XgJIYqhNf0qrayswOfz4enpCT6fD2trawC182B7e3tDX18fO3bswIoVK7Bhwwbx414tWDMzMxsdvMbVd4S8+/xaWFggICAAtra2+OuvvxAVFYXqusUNXvHy65SQkICkpCSZLWWuiH2flZI0p2dQdEo/Tc2DB4zNmvXP1F0dOzL266+MVVdL9HBZTTHTGiKRiJ06dYp9/vnnbNu2bczDw6Pe3xVhuhORSMTu37/P7t+/z6ZMmVLvb1zHV1NTw44dO8bWrl3Ldu3axYqKijiNh/xD6fPMa6j6+Smyd955h4WGhjLGGAsNDWUrVqxg169fZxs3bmT9+vVj2dnZ4m1fzlGSTpMli++Il/NoU1NucTXdlUgkYsnJyeyLL75gP//8M3v06JFcjtsUmvbrHzTdl6qrqQF+/BHo06d2hgMeD1i2DLh7t3ZwmISLB8hqipmWKi4uxu7duxEXF4dRo0ZhwYIF6NOnT5taCmRxCYfH48Ha2hrW1tawt7dXqNZuTU1NjB8/HnPmzEF+fj6CgoJw7949TmMihMhWVlYWfH19AdT29Tx//jwOHjwIOzs7uLm5ITU1FUDDHCVp67AsviNezqNNDXrlqqWYx+Nh6NChWLp0KTQ0NLBt2zZcvHiRs6tginhVVRnR4DGOvXYU6vnztcXr353v4eRU26d22DBuAm6je/fuITw8HDweD35+frC1tQXQ9jW3ZT0wThHWBG9KaWkpwsPDce/ePYwcORLu7u4Sr5RGpE8R84w0qfr5KbK6POfk5IS1a9fi6tWr+PnnnzF48GBUVFQobI56HUXIr9XV1YiNjcXFixfRp08fcdcOeVKE50FR0KwIElLEhNxkQVZYCHz6KbBlS23Hg/btga++AhYvBjQ1OYu3tdPB1NTUIC4uDklJSejZsyd8fHxgaGgotbhktfa6SCQCAE5H8kqC/T1n5fHjx2Fqago+n49OnTpxHZZaUsQ8I02qfn6KrKysDAsXLkRKSgp69OiB33//HZaWllyH9VrKkkcB4Pbt24iIiIC2tjb8/f1hZWXFdUhqiWZFUGINRqHeuwcIBEC/fsCvv9YWtXPnAnfu1HY/4LCoBVrXuf3p06fYsWMHLly4gIkTJ+Ltt9+WalELyOYSTt00NSkpKeLErKh4PB5GjhyJRYsWobKyEsHBwbhy5QrXYRFCpKSsrAyRkZHo06cPfvjhB8TGxipNUasseRQA+vTpg4CAAHTo0AG///474uPjlSJu8g8qbDn2ckEW+/vv2Hj7NsDnAw8f1k7lFRcH7NoFmJpyHGmtlk4Hc+XKFQQHB6OyshKLFi3CyJEjZbK4AK3cUsvMzAzLli1D3759ERYWhtDQUFRWVnIdFiGkDTIzMxEUFISsrCzMnDkTU6ZMoe5GMmRiYoJ58+bB1dUVCQkJ2LVrFwoLC7kOi0iIPhkc++qrr7Bm9WpkfvYZFt+5A/2qqtpFFj75BPjsM0DBJuGvK8Truk401TJaWVmJmJgYXL16FY6Ojpg8eTJ0/14BTRbqBj0QQFdXF76+vrCzs0N0dDRyc3PB5/NhZmbGdWiEkBYQiURISEhAYmIirKys4Ofnx3n3D2VYwVIaNDQ04ObmBhsbG4SGhiIoKAje3t7o06cP16GR16A+tlxLSwOWLgVOnqz9t5MTsGMHMGAAt3E1QZLO7Q8fPkRISAhKSkrg6emJQYMGcRRt2yjSijmt9ezZM4SEhODx48dwd3eXWYs5+YdC5hkpUvXzUxSFhYUQCATIycmBm5sbxowZw3kOKi8vx4QJE6CpqQlHR0eMGTMGp0+fbrZRQRXyaHl5OSIjI3Hr1i0MHz4cHh4e0NbW5josldaWPEMttlw7dKi2qDUwAL74AnjvPc770TanuZZRxhiSkpIQFxeHrl27Yvbs2ejYyApoRH46duyIRYsWIS4uDrGxscjIyICPjw+MjIy4Do0Q0oRbt24hIiICurq6WLBggcL0pV29ejU++OAD+Pn5iQc7K8oKlrKkr6+P6dOn49KlSzhy5Aiys7PB5/PRpUsXrkMjjVC+n06qZsUK4P33gWvXav+rwEVtc0pKSrBnzx7ExsZixIgRWLRoERW1CkJTUxMeHh6YPXs28vLyEBQUhPT0dK7DIoS8orq6GtHR0Thw4ABsbW0REBCgMEUtUDvGws/PD0DtGIuUlBS1mWuVx+Nh2LBhWLp0KUQiEbZu3YpLly7Ryo8KiApbrmlqAt9/D9jaKu060enp6QgKCkJeXh5mz54NDw8PaCppga7K7O3tsXz5cnTt2hW7d+/GsWPHIBQKuQ6LEAIgPz8f27ZtQ2pqKjw9PfHmm28qXN9VOzs7REZGAgBCQ0MhFArVbqCuqakpli5dCgcHB0RFReHgwYNK812tLqiPrQKR9SID0iYUCnHixAmcOXMGdnZ28PX1ValL3CKRCJmZmQAAa2trpewb1hjGGM6ePYu4uDh0794dfD4fHTp04DoslaHoeaatVP385I0xJr7E3bFjR/D5fJgqyCw4r2rNAgKqmkcB4ObNm4iMjISuri74fD4sLCy4Dkll0AINElL0hCyrRQZk4dmzZxAIBMjLy4O7uztGjRpFg5KUzIMHDxASEoKysjJ4enpi4MCBXIekEhQ9z7SVqp+fPJWXlyMqKgo3b96kQUlK6sWLFwgNDUVubi7c3Nzg7OysUsU7V2iBBhWhLOtEX7t2DcHBwSgrK8OiRYswevRoKmqVUI8ePRAQEIBevXpBIBAgPDwcVVVVXIdFiFrIzs5GUFAQMjIy8NZbb2Hq1KlU1Cqh9u3bY/78+RgzZgxOnjyJ3bt3o6ioiOuw1Bq12CoQRV8nuqqqCocOHUJqaioGDhwIT09Pmc5NS+SDMYYrV67g0KFDMDY2Bp/PR/fu3bkOS2kpep5pK1U/P1kTiUQ4deoU4uPjYWFhAX9/f5iYmHAdFpGCzMxMCAQCCIVCeHt7o3fv3lyHpLSoK4KEKCG3Xl5eHkJCQlBcXIypU6di0KBBKt9KqwrzL7ZEQUEBBAIB8vPzMWHCBIwYMULlX2NZUPU8o+rnJ0tFRUUIDQ1FVlYWXFxc4OrqqvJ5Rd3yaFlZGSIiInDnzh2MGDECEyZMaNEqceqyAMbrUFcEIjOMMZw7dw7bt2+Hjo4Oli1bBgcHByp4VFDnzp2xaNEiDB8+HEeOHMG+fftQWlrKdViEqITbt29jy5YtePbsGebNm4exY8eqfJGnjgwMDDBjxgxMnjwZycnJ2L59OwoKCiR+/OrVqzF+/HhER0dj/PjxWLNmjQyjVU20QAOp5+Vfi5aWlnByckJmZiZGjhwJd3d3Wp9cxWlpaWHSpEmwtbVFeHg4goKC4OfnBxsbG65DI0Qp1dTUIDY2FhcuXECfPn0wbdo0GBgYcB0WkSEej4cRI0bAysoKISEhCA4OxpQpU+Do6PjaRqH09HT8+OOPAGrnCg4ODpZHyCqFfi6Seup+Lf7000+oqKjAjh07MGvWLEycOJGKWjXSq1cvLF++HJ07d8Yff/yBuLg4mvOWkBZ68uQJtm3bhsuXL2PKlCl46623qKhVI926dcPSpUsxcOBAREREQCAQoKKiotnHKMsgckWmFIVtZmYmFi1aBBsbG+jr68POzg5r166lEdwykJaWBgMDA/zxxx9wc3ODoaEhevbsyXVYhAPGxsaYM2cOxo0bhzNnzmDnzp148eIF12GRVqI8Kj+MMVy+fBlbt26FSCTCkiVL4OTkpFBduBRtQSBFi0da/r+9Ow9q8s7/AP4OEeQseCCKyBUPPBAPEA9QVA4V5Yxrt9UOamFxux073U532/7Rbmdn3Nltp846q9G12lbb3bZJuFFBKlq1XkXUUpUCciheaAVROfP8/uhPtiggSsjz5Mn7NeMfhBA+eQbf+eSb72FjY4OYmBio1Wr89NNP2Lp1Ky5fvtzt/f/2t7+hoKAAS5cuRUFBgcUdgGEMZtHYXrhwAQaDAVu3bkVJSQk++ugjaDQavP3222KXJis///wzmpqasGPHDixYsAAuLi7w8/Pr198p1zCTCysrK4SGhmLNmjVobGyERqNBSUmJ2GXRM2COmkZTUxO0Wi0yMzMxefJkJCcnw83NTeyyHiO1uZxSq8fYJk2ahNTUVDg4OGDHjh04fPhwl8fx2tnZYePGjcjOzsbGjRstcuFYX5ntrgj/+Mc/sGXLFlRUVPT6Z7iat3slJSXIzMzEgAEDcOHCBVy/ft0kW45J+bQ1S1vN+yRNTU3IyspCSUkJpk2bhkWLFsHGxkbssiTHnHKGOWpcNTU1HR83L1u2DBMnThS7pG6Z6kCg3uaoOR1Q1Bft7e0oLCzE4cOH4ePjg/j4eDg5OYldluT0JWfMdtJkfX09Bg8e3ON9mpub0dzc3PE1N01+XEtLC/bu3YuioiJMmjQJS5cuha2trcl+v9QnynN/yf+xtbWFWq2GSqXCnj17UF1dDbVajeHDh4tdGj0j5qhxGAwGHDlyBAcOHMDIkSORlJQEFxcXscvq0cO5nA8HFfpzLmdvctSU9YhJqVRi4cKF8PHxgV6vh0ajQVxcHKf8GZFZjtiWl5dj2rRp+PDDD/Hyyy93e7/33nsPf/nLXx67nSMNv7h27Rq0Wi3q6+uxePFiTJ061eRzwKQ8Ykvdu3nzJrRaLW7duoXIyEgEBQVJav6gmMxlRJM5ahx3796FXq9HZWUlQkNDMW/ePCiVSsnvRyq1A4GkVo8p3Lt3D+np6fjpp5+489AjzPaAhu4C89dOnjyJwMDAjq9ra2sxb948zJs3D9u3b+/xZ7saaRg1apTFB7IgCDh58iTy8vIwZMgQqNVquLq6ilKLJYaZXLS1tSE/Px/Hjx/HuHHjEBsbyxXfMH1jyxwVT2lpKdLT06FUKh/bFo9v2qk3BEHA8ePHkZ+fj2HDhkGtVmPIkCFilyU6s21s6+rqnrhxsbe3d8dH47W1tZg/fz6Cg4PxySefPPWcR3MZSelPfT0VhehRFy9eREZGBgYMGICEhAR4e3uLXZKoTJ0zzFHTa2trw/79+3Hs2DGMHTsWcXFxj72ps5Q5o2Qcj57uGRAQIHZJojLbObZDhw7F0KFDe3XfK1euYP78+Zg+fTp27txp8Qt5nkVlZSX0ej1aW1vx29/+ludYP4HBYMCZM2cAAAEBAfyb68a4ceOQmpoKvV6PTz/91GKOCpUK5qhp1dXVQavV4ubNm1i0aFG3R09bypzRJ2GO9s6IESPwu9/9Drm5uUhLS0N5eTmio6MxcOBAsUszO2Yxx/bhx2aenp747LPPoFQqO773NAtXLHWkwWAw4ODBgzh06BC8vLyQkJBgUc//WXFXhKdjMBhw+PBhFBYWwsPDA4mJiRa5+E6qOcMc7RtBEHDmzBnk5ubCyckJarUaI0aM6Pb+nGb1C+bo0zt79ixycnLg4OCAxMREjBw5UuySTM5sR2x7Ky8vD2VlZSgrK4OHh0en75lBXy6q+vp66HQ6XL58GfPnz0dISAiDhfqFlZUV5s6dC29vb+h0OmzZsgUxMTGYMGGC2KURmKN90dzcjOzsbJw7dw5Tp07F4sWLn7jV3cP9SIme1uTJk+Hh4QGtVouPP/4Y4eHhmDVrFhfo9pJZjNgai6WNNPz444/IzMzEwIEDkZiYCE9PT7FLMiscaXh2Dx48QFZWFn788UcEBgYiKioK1tbWYpdlEnLPGbk/v0dduXIFWq0W9+/fx9KlS+Hv7y92SWaFOfrs2tvb8c033+DIkSMYPXo04uLi4OjoKHZZJiH7EVt6Oq2trdi3bx9OnTqFCRMmYNmyZRb5ERiJx87ODsuXL0dRUVGnPW+HDRsmdmlEvSIIAo4ePYqCggKMGDECL730EgYNGiR2WWRBlEolIiIi4OvrC71ejy1btiA+Pt5i52v3Ft86ycyNGzfw73//G8XFxVi2bBmWL1/OppZEoVAoMH36dKSkpAAAtm3bhpMnT/Jjb5K8xsZG7N69G/n5+Zg9ezbWrFnDppZEo1KpsG7dOgwfPhy7d+9GXl4e2tvbxS5LsjhiKxOCIOD777/H3r17MXjwYKSkpHB0jCRh2LBhSE5ORl5eHnJyclBRUYGYmBi+4SJJKisrQ1paGhQKBVatWgWVSiV2SURwdHTEypUrOz5FqKqqQmJi4hNPDrREbGxl4MGDB8jMzMT58+cRFBSEyMhIi5nP2N94hrdxWFtbIzo6Gr6+vsjMzIRGo0FCQgK8vLzELo0IwC/zGQsKCnD06FGMHj0a8fHxcHBwELssWWCOGodCocCcOXM6Fuhu3boV0dHRmDx5stilSQoXj5m56upq6HQ6tLS0ICYmBuPHjxe7JKIePdypo6amBmFhYQgNDZXVghI55syvyfH53b59G1qtFtevX0d4eDhmzpzJFegkac3NzcjJycHZs2cxZcoULFmy5Ik7dZgTLh6zQAaDAd9++y0KCwsxatQoi90zlMyPs7MzkpKScOjQIRQWFuLSpUvcW5lEc+bMGeTk5MDR0RFr166Fu7u72CURPdHAgQORkJAAlUqFnJwc1NTUPHFvZUvBEVsz1NDQAJ1Oh+rqasybNw9z586V1YgXWY6qqirodDq0trYiNjYWfn5+YpfUZ3LJme7I5fk1NzcjNzcXZ86cQUBAAJYsWcJTnsgs3bp1C1qtFjdu3EBERES3p+GZk77kDBtbM3PhwgVkZGTA2toaiYmJnKPYjwwGA86dOwcA8Pf355uHfnL//n1kZmbiwoULmDFjBiIjIzFggPl+mCSHnOmJHJ5fbW0ttFotGhsbER0djYCAALFLki3mqGm0tbWhoKAA3333HcaMGYO4uDizniPOqQgWoLW1Ffn5+Thx4gT8/PwQGxvLVeUm0NbWJnYJsmdvb48VK1bg1KlT2LdvH6qqqqBWq+Hq6ip2aSQzgiDgu+++Q0FBAdzc3LBy5UquKjcB5mj/GzBgAKKiouDr64v09HRoNBrEx8fD19dX7NJMjm+dzMDNmzexfft2FBUVITo6GitWrGBTS7KiUCgQFBSE5ORkGAwGbNu2DUVFRdzzloymsbERn3/+OfLy8hAcHIy1a9eyqSXZGTNmDFJTU+Hq6opdu3ahoKDA4va85YithAmCgKKiIuzduxcuLi5ITk6Gm5ub2GUR9Rs3NzckJydj3759yMzMRHl5OZYtWwZbW1uxSyMzVl5ejrS0NAiCgJUrV/LkJpI1JycnrFq1CkeOHME333yDS5cuITEx0WIOGeGIrUQ1NTVBq9UiKysLkydPRkpKCptasgg2NjYdp+aVl5dDo9GgpqZG7LLIDLW3tyM/Px+7du2Cm5sb1q1bx6aWLIJCoUBISAjWrFmDxsZGaDQa/PDDD2KXZRIcsZWgmpoa6HQ6NDU1Yfny5Zg4caLYJRGZ3MSJEzFy5EjodDrs3LkTYWFhCAkJ4eIT6pWff/4ZWq0WV69eRUREBGbPnm32K8WJnpaHhwdSU1ORnZ0NrVaLiooKLFq0SFZ73j6Kja2EGAwGHD58GIWFhRg5ciSSkpLg4uIidllEonFxcUFSUhIKCwtx4MABXLp0CfHx8Wa7Gp9M49y5c8jOzoa9vT3WrFkDDw8PsUsiEo2trS0SExOhUqmQm5uL6upqqNVqDB8+XOzS+gUbW4loaGhAWloaKisrERoairCwMI5MSYC9vb3YJVg8pVKJhQsXwtfXF3q9HhqNBnFxcRg7dqzYpZHEtLS0YM+ePTh9+jT8/f0RHR3N+dkSwBwVn0KhwNSpU+Hh4QGdToft27cjMjISQUFBsvskg/vYSkBpaSnS09OhVCqRkJAAHx8fsUsikqR79+4hIyMDpaWlCA4ORkREhOT2vJVqzhiLVJ/ftWvXoNVqUV9fjyVLlmDKlCmye8EmMoa2tjbk5+fj+PHjGDduHGJjYyX35oMHNPSS1AL5139cY8eORVxcnOT+uIikRhAEnDhxAnl5eXB1dYVarcbQoUPFLquD1HLG2KT2/KT+90AkVRcvXkRGRgYGDBiAhIQEeHt7i11SBza2vSSlQK6rq4NWq8XNmzcRGRmJGTNmcHSB6ClIdYROSjnTH6T0/O7fv4/09HSUlpZi5syZCA8Pl9wIPpGUNTQ0QK/Xo6qqCnPnzsW8efMkMQ2SjW0vSSGQBUFAcXExcnNz4ezsLOsJ3ObOYDCgpKQEwC8r9KXwn506k+KcSinkTH+SyvO7dOkS9Ho92tvbOedawpij0vfrheseHh5ISEgQfeE6j9Q1E01NTcjJycG5c+cwdepULF68WNZbbshBS0uL2CVQD2xsbBAbGwtfX19kZ2fj8uXLUKvVGDlypNilUT9pb2/HwYMH8e2338Lb2xsJCQlwcnISuyzqAXNU2qysrDB37lx4e3tDp9NBo9EgJiYGEyZMELu0Z8LG1kSuXLkCrVaL+/fvIzExEf7+/mKXRCQb/v7+Hat9P/74YyxcuJD7lsrQnTt3oNPpcOXKFSxYsABz5szhCCCRkXh6eiI1NRVZWVn46quvEBgYiKioKFhbW4td2lNhY9vPBEHA0aNHUVBQAHd3d7z00ksWc6wdkSkNGjQIq1evxoEDB7B//36Ul5cjISEBjo6OYpdGRlBSUoKsrCzY2tpi9erVGDVqlNglEcmOnZ0dli9fjqKiIuzdu7djz9thw4aJXVqvsbHtR42NjdDr9aioqEBISAjmz58PpVIpdllEsqVUKhEeHt6x5+2WLVsQHx/PY1TNWGtrK/bs2YOioiJMnDgRy5YtE30eNZGcKRQKTJ8+HZ6envj666+xbds2REVFITAw0Cw+BWNj20/KysqQlpYGhUKBVatWQaVSiV0SkcXw9fXFunXrkJ6ejt27d2PWrFkIDw/nG0szc/36dWi1Wty5cwcxMTGYOnWqWbywEsmBq6srkpOTkZeXh5ycHFRUVCAmJgZ2dnZil9YjNrZG1t7ejoKCAhw9ehSjR49GfHw8HBwcxC6LyOI4ODjghRdewLFjx7B//35UVVVBrVZj8ODBYpdGTyAIAk6ePIm8vDwMGTIEKSkpcHV1FbssIotjbW2N6Oho+Pr6IjMzExqNBgkJCfDy8hK7tG6xsTWiW7duQafT4fr164iKisLMmTM5umDm+JGneVMoFJg1axa8vLyg1Wqh0WiwdOlSTJ48WezSqBv3799HZmYmLly4gBkzZiAyMpJ705o55qj5Gz9+PNzd3aHX6/HJJ58gLCwMoaGhkly8yX1sjeTs2bPIzs6Gk5MT1Go1RowYYdTHJ6K+aW5uRm5uLs6cOYOAgAAsWbIEAwcONPrvkco+r/2lP59fVVUVdDodWltbERsbCz8/P6M+PhH1jcFgwKFDh3Dw4EF4enoiISEBzs7ORv89PKChl/ojkH/9YjllyhQsXry4X14sicg4zpw5g5ycHDg6OkKtVsPd3d2oj8/G9uk9+mKZmJgoy2tHJBf9/SaUjW0vGTuQa2trodVq0djYyI83iczI7du3odVqcf36dYSHhxt12hAb26dTX18PvV6P6upqSX+8SUSdPXjwABkZGf0ybYiNbS8ZK5AFQcB3332HgoICuLm5cUGKTBkMBpw/fx7AL/OL+GIrL48u9IyLizPKnrdsbHvv/PnzyMzMhI2NDRITE+Hp6WmkKkkqmKPyJggCTp06hX379mHIkCFQq9VGWejJI3VNqLGxEenp6SgrK8Ps2bOxcOFCbiEkY01NTWKXQP1EqVQiMjISvr6+SEtLg0ajQXx8PLfmM4HW1lbk5eXh5MmTGD9+vFlsIUTPjjkqXwqFAkFBQfD09IRWq8W2bduwaNEiTJs2TbTF82xsn0J5eTnS0tIgCAJWrlzJTd+JZGD06NFYt24d0tLSsGvXLsyZMwcLFizgG9Z+cuPGDWi1Wty+fRtLly7F9OnTuXsMkZlzc3NDSkoK9u7di6ysLFRUVIh2mAob215ob2/HN998gyNHjkClUiE+Pp7HdBLJiKOjI1auXNlx/HVlZSXUajWPvzYiQRA6jukcNGgQUlJSzOqYTiLqmbW1NZYtWwaVStWx521iYqLJj79mY/sEP//8M7RaLa5evYqIiAjMnj2bowtEMqRQKDBnzhx4e3t32vPW399f7NLM3oMHD5CVlYUff/wRgYGBiIqKgrW1tdhlEVE/mDBhAtzd3aHT6bBz506EhYUhJCTEZPOr2dj24Ny5c8jOzoa9vT3Wrl2LkSNHil0SEfWzkSNHIjU1FdnZ2dDpdKioqMDixYthY2Mjdmlmqbq6GjqdDs3NzVixYgXGjx8vdklE1M9cXFywevVqFBYW4sCBA7h06RLi4+NNsqCWjW0XWlpakJubi+LiYvj7+2Pp0qXcm5bIggwcOBAJCQlQqVTIyclBTU0NEhMTefDKUzAYDDh8+DAKCwvh4eGBxMTEftnInYikycrKCgsWLICPjw/0ej00Gg3i4uIwduzYfv29bGwfcfXqVWi1Wty9exdxcXEICAjg1AMLxlE6y6VQKDBlyhR4eHhAq9Vi+/btiIiIQHBwMDPhCRoaGqDX61FVVYW5c+di3rx53ObJgjFHLZuPjw/WrVuHjIwMfPHFFwgODkZERES/HZXNfWz/nyAIOH78OPLz8zFs2DCo1WoMGTJEpEqJSEra2tqwf/9+HDt2DGPHjkVsbCwcHBy6vK+l72N78eJFpKenw9raGgkJCfD29jZ9kUQkOYIg4MSJE8jLy4OrqyvUajWGDh3a5X15QEMvdXeh7t27h4yMDJSWlmLmzJkIDw/vt3cSRGS+SktLkZ6eDqVSiYSEBPj4+Dx2H0ttbNva2pCXl4cTJ07Az88PMTExsLe3F7FSIpKia9euQavVor6+HkuWLMGUKVMe+xSMjW0vdXWhLl26BL1ej/b2dpPM/SAi83b37l3o9XpUVlYiJCQEYWFhnfa8tcTGtq6uDlqtFnV1dYiMjERQUBCnaxBRt1paWrBnzx6cPn0a/v7+iI6O7rTnbV9y1OwmPTU3N3d098XFxc/8OA+P0/zss88wdOhQrFu3jk0tdfLwKMjz58/DYDCIXQ5JhJOTE1atWoUFCxbgyJEj2LlzJ+7cuSN2WU/FWDn6cG/arVu3oq2tDS+//DJmzJjBppY6MEepKzY2NoiNjYVarUZpaSm2bt2Ky5cvG+Wxza6xffPNN+Hu7t6nx7hz5w527tyJI0eOYMGCBVi1ahWcnJyMVCHJyf3793H//n2xyyCJsbKyQmhoKFavXo3GxkZoNBqUlJSIXVavGSNHm5qaoNPpkJmZCX9/f6SkpGD48OFGqpDkhDlK3Zk0aRJSU1Ph4OCAHTt24PDhw+jrRAKzamz37NmDvLw8fPDBB316nB07dqCxsRGrV69GaGgoV+sS0TMZNWoUUlNToVKp8PXXXyMzMxOtra1il9UjY+ZoWVkZli9fjpiYGK58J6JnMmjQIKxevRqzZ89GQUEBdu3ahcbGxmd+PLNZIXX9+nUkJycjPT291wsSmpub0dzc3PF1Q0MDgF+2nlixYoUoZxgTkbzY2tpCrVZDpVJhz549KC0tFbukbhkzRx0cHLBy5UoeO0xEfaZUKhEeHg5fX1/o9Xp8/PHHz/xYZjFUKQgCkpKSkJqaisDAwF7/3IYNG+Ds7Nzx7+F5xXFxcWxqichoFAoFpk2bhpSUFMl+AmTsHGVTS0TG5uvri3Xr1vVpWpOoCfzee+9BoVD0+O/UqVPYtGkTGhoa8NZbbz3V47/11luor6/v+FdTUwMAXNhARP3C1dUVSUlJJv2dYuXor3eCICIyFgcHB/zmN7955p8Xdbuvuro61NXV9Xgfb29vPP/888jKyurUkLa3t0OpVOLFF1/Ep59+2qvfJ/dteMi4DAYDTp8+DQCYOnWqZEfiSFpMnTPMUZIy5ig9i77kjKhzbIcOHdrtqRO/9s9//hN//etfO76ura1FVFQUvvzySwQHB/dniWTheFAHSR1zlKSOOUqmZBZ/bZ6enp2+dnR0BACoVCp4eHiIURJZACsrKwQEBIhdBpFRMEdJDMxRMjV+JkBEREREsmAWI7aP8vb27vMGvkRElow5SkRyZJaNLZEpGAwGlJWVAQBGjx7NRQ9ERE+JOUqmxsaWqAd3794VuwQiIrPGHCVT4lsnIiIiIpIFNrZEREREJAtsbImIiIhIFtjYEhEREZEssLElIiIiIlngrghEPeDWNEREfcMcJVNiY0vUDSsrK0ydOlXsMoiIzBZzlEyNb6OIiIiISBbY2BIRERGRLHAqAlE3DAYDKioqAAC+vr6cJ0ZE9JSYo2RqbGyJelBfXy92CUREZo05SqbEt05EREREJAtsbImIiIhIFtjYEhEREZEssLElIiIiIllgY0tEREREsmBRuyIIggAAaGhoELkSMgcGgwGNjY0Afvmb4TY11BsP8+Vh3sgNc5SeBnOUnkVfctSiGttbt24BAEaNGiVyJUQkd7du3YKzs7PYZRgdc5SITOVZctSiGtvBgwcDAKqrq2X5gvOsGhoaMGrUKNTU1OC5554TuxxJ4bXpGq9L9+rr6+Hp6dmRN3LDHO0a/090j9ema7wu3etLjlpUY/vwIxBnZ2f+EXXhueee43XpBq9N13hduifXj1yZoz3j/4nu8dp0jdele8+So/JMXiIiIiKyOGxsiYiIiEgWLKqxHThwIN59910MHDhQ7FIkhdele7w2XeN16Z7cr43cn9+z4nXpHq9N13hduteXa6MQ5LonDRERERFZFIsasSUiIiIi+WJjS0RERESywMaWiIiIiGSBjS0RERERyYLFN7bNzc2YMmUKFAoFiouLxS5HVJWVlVi7di18fHxgZ2cHlUqFd999Fy0tLWKXJorNmzfDx8cHtra2mD59Or799luxSxLdhg0bEBQUBCcnJwwbNgxxcXG4ePGi2GVJzoYNG6BQKPDaa6+JXYpJMEc7Y5b+D3P0cczR3nnWHLX4xvbNN9+Eu7u72GVIwoULF2AwGLB161aUlJTgo48+gkajwdtvvy12aSb35Zdf4rXXXsM777yD06dPIzQ0FIsXL0Z1dbXYpYnq4MGDeOWVV3Ds2DHk5+ejra0NkZGRuHfvntilScbJkyexbds2TJ48WexSTIY52hmz9BfM0a4xR5+sTzkqWLDc3FzBz89PKCkpEQAIp0+fFrskyfn73/8u+Pj4iF2Gyc2YMUNITU3tdJufn5/w5z//WaSKpOnGjRsCAOHgwYNilyIJd+/eFcaMGSPk5+cL8+bNE9avXy92Sf2OOdo7lpilzNHeYY521tcctdgR2+vXryM5ORm7du2Cvb292OVIVn19PQYPHix2GSbV0tKC77//HpGRkZ1uj4yMxNGjR0WqSprq6+sBwOL+RrrzyiuvIDo6GuHh4WKXYhLM0d6ztCxljvYec7SzvuboACPXYxYEQUBSUhJSU1MRGBiIyspKsUuSpPLycmzatAkffvih2KWYVF1dHdrb2+Hm5tbpdjc3N1y7dk2kqqRHEAS8/vrrCAkJwaRJk8QuR3T//e9/UVRUhJMnT4pdikkwR3vPErOUOdo7zNHOjJGjshqxfe+996BQKHr8d+rUKWzatAkNDQ146623xC7ZJHp7XX6ttrYWixYtwvLly/Hyyy+LVLm4FApFp68FQXjsNkv2hz/8AWfPnsV//vMfsUsRXU1NDdavX4/du3fD1tZW7HL6hDnaPWbp02OO9ow5+j/GylFZHalbV1eHurq6Hu/j7e2N559/HllZWZ3+c7W3t0OpVOLFF1/Ep59+2t+lmlRvr8vDP6Ta2lrMnz8fwcHB+OSTT2BlJav3P0/U0tICe3t7fP3114iPj++4ff369SguLsbBgwdFrE4aXn31VaSnp+PQoUPw8fERuxzRpaenIz4+HkqlsuO29vZ2KBQKWFlZobm5udP3pIw52j1mae8xR5+MOdqZsXJUVo1tb1VXV6OhoaHj69raWkRFRUGr1SI4OBgeHh4iVieuK1euYP78+Zg+fTp2795tNi/GxhYcHIzp06dj8+bNHbdNmDABsbGx2LBhg4iViUsQBLz66qtIS0tDYWEhxowZI3ZJknD37l1UVVV1um316tXw8/PDn/70J1l+xMgc7RmzlDnaHeZo14yVoxY5x9bT07PT146OjgAAlUpl0WFcW1uLsLAweHp64oMPPsDNmzc7vjd8+HARKzO9119/HatWrUJgYCBmzZqFbdu2obq6GqmpqWKXJqpXXnkFX3zxBTIyMuDk5NQxV87Z2Rl2dnYiVyceJyenx0LXwcEBQ4YMkWVTCzBHe8Is/QVztGvM0a4ZK0ctsrGlruXl5aGsrAxlZWWPvTBZ2sD+ihUrcOvWLbz//vu4evUqJk2ahNzcXHh5eYldmqi2bNkCAAgLC+t0+86dO5GUlGT6gogkiFn6C+Zo15ij/csipyIQERERkfxYzkx2IiIiIpI1NrZEREREJAtsbImIiIhIFtjYEhEREZEssLElIiIiIllgY0tEREREssDGloiIiIhkgY0tEREREckCG1siIiIikgU2tmRRkpKSoFAooFAoYG1tDV9fX7zxxhu4d+9ex310Oh3CwsLg7OwMR0dHTJ48Ge+//z5u374NALh69SpeeOEFjBs3DlZWVnjttddEejZEROJglpJUsbEli7No0SJcvXoVFRUV+Otf/4rNmzfjjTfeAAC88847WLFiBYKCgrBnzx788MMP+PDDD3HmzBns2rULANDc3AxXV1e88847CAgIEPOpEBGJhllKUqQQBEEQuwgiU0lKSsKdO3eQnp7ecVtycjKys7ORkZGB4OBgbNy4EevXr3/sZ+/cuQMXF5dOt4WFhWHKlCnYuHFj/xZORCQhzFKSKo7YksWzs7NDa2srPv/8czg6OuL3v/99l/d7NIiJiOh/mKUkBWxsyaKdOHECX3zxBRYuXIiffvoJvr6+sLa2FrssIiKzwiwlqWBjSxYnOzsbjo6OsLW1xaxZszB37lxs2rQJgiBAoVCIXR4RkVlglpIUDRC7ACJTmz9/PrZs2QJra2u4u7t3jCqMHTsWhw8fRmtrK0caiIiegFlKUsQRW7I4Dg4OGD16NLy8vDqF7gsvvIDGxkZs3ry5y5+7c+eOiSokIpI+ZilJEUdsif5fcHAw3nzzTfzxj3/ElStXEB8fD3d3d5SVlUGj0SAkJKRjhW9xcTEAoLGxETdv3kRxcTFsbGwwYcIEEZ8BEZH4mKUkJm73RRalqy1qHvXVV1/hX//6F06fPg2DwQCVSgW1Wo1XX321YzVvV/PHvLy8UFlZ2T+FExFJCLOUpIqNLRERERHJAufYEhEREZEssLElIiIiIllgY0tEREREssDGloiIiIhkgY0tEREREckCG1siIiIikgU2tkREREQkC2xsiYiIiEgW2NgSERERkSywsSUiIiIiWWBjS0RERESy8H8JgwjeEwtN2AAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(nrows=3, ncols=2, figsize=(8, 12))\n", + "axs = axs.ravel()\n", + "for num, (ds, (pc1, pc2, alpha, xfit, fit)) in enumerate(alpha_fits.items()):\n", + " ax = axs[num]\n", + " ax.axhline(0, color=\"k\", linestyle=\"--\", alpha=0.2)\n", + " ax.axvline(0, color=\"k\", linestyle=\"--\", alpha=0.2)\n", + "\n", + " # draw a line 45 degrees\n", + " x = np.linspace(-6, 6, 100)\n", + " y = x\n", + " ax.plot(x, y, color=\"k\", alpha=0.5, lw=1)\n", + " ax.plot(-x, y, color=\"k\", alpha=0.5, lw=1)\n", + "\n", + " ax.scatter(\n", + " pc1,\n", + " pc2,\n", + " s=8,\n", + " marker=\"o\",\n", + " c=\"w\",\n", + " edgecolors=\"k\",\n", + " linewidths=0.5,\n", + " )\n", + "\n", + " ax.plot(xfit, fit, c=\"r\", label=f\"$\\\\alpha=${alpha:.2f}\")\n", + "\n", + " ax.set_xlabel(\"PC1\")\n", + " ax.set_ylabel(\"PC2\")\n", + "\n", + " ax.set_title(ds.split(\".\")[3])\n", + "\n", + " ax.set_xlim(-4, 4)\n", + " ax.set_ylim(-5, 5)\n", + " ax.legend()\n", + "fig.subplots_adjust(hspace=0.3)" + ] + }, + { + "cell_type": "markdown", + "id": "f3cc1404-0030-4e7c-98bb-498c354301d2", + "metadata": { + "tags": [] + }, + "source": [ + "## Summary\n", + "In this notebook, we used the Rooki Python client to retrieve a subset of a CMIP6 dataset. The operations are executed remotely on a Rook subsetting service (using OGC API and xarray/clisops). The dataset is plotted and a provenance document is shown. We also showed that remote operators can be chained to be executed in a single workflow operation.\n", + "\n", + "### What's next?\n", + "\n", + "This service is used by the European Copernicus Climate Data Store. \n", + "\n", + "We need to figure out how this service can be used in the new ESGF: \n", + "* where will it be deployed? \n", + "* how can it be integrated in the ESGF search (STAC catalogs, ...)\n", + "* ???\n", + "\n", + "## Resources and references\n", + "- [Roocs on GitHub](https://github.com/roocs)\n", + "- [Copernicus Climate Data Store](https://cds.climate.copernicus.eu/)\n", + "- [STAC](https://stacspec.org/en)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 3935b275b143e6ca1a3495b3a80a3c1209cf5a96 Mon Sep 17 00:00:00 2001 From: DangoMelon Date: Fri, 14 Jun 2024 01:20:11 -0500 Subject: [PATCH 2/4] Add xeofs dependency to environment.yml --- environment.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/environment.yml b/environment.yml index 8603f91..ce231b0 100644 --- a/environment.yml +++ b/environment.yml @@ -16,6 +16,7 @@ dependencies: - globus-compute-endpoint - netCDF4 - xarray + - xeofs - cf_xarray - clisops - rooki From 648078dcdfc8e21541925b85f5833843d7bb8893 Mon Sep 17 00:00:00 2001 From: DangoMelon Date: Fri, 14 Jun 2024 13:54:55 -0500 Subject: [PATCH 3/4] Update notebook content --- notebooks/images/alpha_example.png | Bin 0 -> 76520 bytes notebooks/images/alpha_output.png | Bin 0 -> 119719 bytes notebooks/rooki_enso_nonlinear.ipynb | 312 ++++++++++++++++----------- 3 files changed, 181 insertions(+), 131 deletions(-) create mode 100644 notebooks/images/alpha_example.png create mode 100644 notebooks/images/alpha_output.png diff --git a/notebooks/images/alpha_example.png b/notebooks/images/alpha_example.png new file mode 100644 index 0000000000000000000000000000000000000000..6e7d3db4a8f4b585f334be993b3d6579dfbd7df4 GIT binary patch literal 76520 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 XV`V4vYPDt>{G)tCT_OFDsptO!bqwv2 literal 0 HcmV?d00001 diff --git a/notebooks/rooki_enso_nonlinear.ipynb b/notebooks/rooki_enso_nonlinear.ipynb index 7856d43..e443e80 100644 --- a/notebooks/rooki_enso_nonlinear.ipynb +++ b/notebooks/rooki_enso_nonlinear.ipynb @@ -1,5 +1,13 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "fd53a474", + "metadata": {}, + "source": [ + "---" + ] + }, { "cell_type": "markdown", "id": "931a4b84-bb67-44e4-aa91-30f3d8bcc529", @@ -7,7 +15,23 @@ "tags": [] }, "source": [ - "# Compute Demo: Use Rooki to access CMIP6 data" + "# Compute Demo: ENSO nonlinearity index with CMIP6 data" + ] + }, + { + "cell_type": "markdown", + "id": "6cff08e9", + "metadata": {}, + "source": [ + "
\"Alpha
" + ] + }, + { + "cell_type": "markdown", + "id": "cffd29c8", + "metadata": {}, + "source": [ + "---" ] }, { @@ -19,14 +43,14 @@ "source": [ "## Overview\n", "\n", - "Here we use intake-esfg with Rookie to subset and regrid CMIP6 data\n", + "In this demo we combine multiple multiple tools described in previous cookbooks to subset, regrid and process CMIP6 data. We will be computing a measure of ENSO nonlinearity by computing the EOFs of the pacific sea surface temperature anomalies. This measure is particularly useful for characterizing models by their ability to represent different ENSO extremes (Karamperidou et al., 2017).\n", "\n", - "**ROOK**: **R**emote **O**perations **O**n **K**limadaten\n", + "The process we are going to follow in this demo is:\n", "\n", - "* Rook: https://github.com/roocs/rook\n", - "* Rooki: https://github.com/roocs/rooki\n", - "* Clisops: https://github.com/roocs/clisops\n", - "* Rook Presentation: https://github.com/cehbrecht/talk-rook-status-kickoff-meeting-2022/blob/main/Rook_C3S2_380_2022-02-11.pdf" + "1. Find the CMIP6 data we need using intake-esgf\n", + "2. Subset the data and regrid it to a common grid using Rooki\n", + "3. Load the datasets into xarray and perform the computations\n", + "4. Plot the results\n" ] }, { @@ -40,12 +64,15 @@ "\n", "| Concepts | Importance | Notes |\n", "| --- | --- | --- |\n", - "| [Intro to Xarray](https://foundations.projectpythia.org/core/xarray/xarray-intro.html) | Necessary | |\n", - "| [Understanding of NetCDF](https://foundations.projectpythia.org/core/data-formats/netcdf-cf.html) | Helpful | Familiarity with metadata structure |\n", - "| [Knowing OGC services](https://ogcapi.ogc.org/processes/) | Helpful | Understanding of the service interfaces |\n", + "| [Intro to Xarray](https://foundations.projectpythia.org/core/xarray/xarray-intro.html) | Necessary | How to use xarray to work with NetCDF data |\n", + "| [Intro to Intake-ESGF](intro-search) | Necessary | How to configure a search and use output |\n", + "| [Intro to Rooki](rooki) | Helpful | How to initialize and run rooki |\n", + "| [Intro to EOFs](https://projectpythia.org/eofs-cookbook/notebooks/eof-intro.html) | Helpful | Understanding of EOFs |\n", "\n", "\n", - "- **Time to learn**: 15 minutes" + "\n", + "\n", + "- **Time to learn**: 20 minutes" ] }, { @@ -53,7 +80,7 @@ "id": "288086a4", "metadata": {}, "source": [ - "## Init Rooki" + "## Imports" ] }, { @@ -69,42 +96,14 @@ "\n", "os.environ[\"ROOK_URL\"] = \"http://rook.dkrz.de/wps\"\n", "\n", - "from rooki import rooki\n", - "import xarray as xr" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "0e9a82d3-aef2-4826-91e3-b3a6338a2157", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import numpy.polynomial.polynomial as poly\n", + "import xarray as xr\n", + "import xeofs as xe\n", "from intake_esgf import ESGFCatalog\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "f4cd53c1-e327-4cff-a845-d2a90c137c6e", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Perform a search() to populate the catalog.\n" - ] - } - ], - "source": [ - "cat = ESGFCatalog()\n", - "print(cat) # <-- nothing to see here yet" + "from rooki import operators as ops\n", + "from rooki import rooki" ] }, { @@ -114,27 +113,12 @@ "source": [ "## Retrieve subset of CMIP6 data\n", "\n", - "The CMIP6 dataset is identified by a dataset-id. An intake catalog as available to lookup the available datasets:\n", - "\n", - "https://nbviewer.org/github/roocs/rooki/blob/master/notebooks/demo/demo-intake-catalog.ipynb" + "The CMIP6 dataset is identified by a dataset-id. Using intake-esgf we can query the ESGF database for the variables and models we are interested in. For this demo we are interested in the tos (sea surface temperature) variable for the historical runs. Also, for sake of simplicity we will only query a subset of the models available." ] }, { "cell_type": "code", - "execution_count": 4, - "id": "65dee489-24d3-437d-a864-6eb1dabe8c99", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "def keep_ds_id(ds):\n", - " return ds[0].split(\"|\")[0]" - ] - }, - { - "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "id": "66b3b3c0-6aa0-465b-bc17-86ae2ce5f25b", "metadata": { "tags": [] @@ -143,7 +127,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "dd675893f78745e6a357beecca8d4b26", + "model_id": "2e14f0415b3142848615c8e9dfd26be9", "version_major": 2, "version_minor": 0 }, @@ -159,23 +143,24 @@ "output_type": "stream", "text": [ "Summary information for 11 results:\n", - "experiment_id [historical]\n", - "mip_era [CMIP6, nan]\n", "activity_drs [CMIP]\n", - "datetime_stop [nan, 2014-12-16T12:00:00Z, 2014-12-15T12:00:00Z]\n", - "table_id [Omon]\n", + "variable_id [tos]\n", + "member_id [r1i1p1f1, r1i1p1f2]\n", + "mip_era [CMIP6, nan]\n", + "source_id [FGOALS-g3, CAMS-CSM1-0, EC-Earth3-Veg, CMCC-C...\n", "grid_label [gn]\n", "datetime_start [1848-10-25T13:00:00Z, 1850-01-16T12:00:00Z, 1...\n", - "source_id [FGOALS-g3, CAMS-CSM1-0, EC-Earth3-Veg, CMCC-C...\n", - "member_id [r1i1p1f1, r1i1p1f2]\n", - "variable_id [tos]\n", + "datetime_stop [nan, 2014-12-16T12:00:00Z, 2014-12-15T12:00:00Z]\n", "institution_id [CAS, CAMS, EC-Earth-Consortium, CMCC, CNRM-CE...\n", + "experiment_id [historical]\n", + "table_id [Omon]\n", "project [CMIP6]\n", "dtype: object\n" ] } ], "source": [ + "cat = ESGFCatalog()\n", "cat.search(\n", " experiment_id=[\"historical\"],\n", " variable_id=[\"tos\"],\n", @@ -196,9 +181,28 @@ "print(cat)" ] }, + { + "cell_type": "markdown", + "id": "4aea426b", + "metadata": {}, + "source": [ + "Once the catalog has been queried, we have to do some manipulation in pandas to keep only the dataset_id. This has to be done because the same data has multiple locations online, and these get appended at the end of the dataset_id. Rookie only accepts the dataset_id without the online location, so we get rid of it in the next step." + ] + }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 3, + "id": "9482b7d7", + "metadata": {}, + "outputs": [], + "source": [ + "def keep_ds_id(ds):\n", + " return ds[0].split(\"|\")[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, "id": "46726e56-030d-4e54-a1a4-5e2f2ca11b43", "metadata": { "tags": [] @@ -220,7 +224,7 @@ " 'CMIP6.CMIP.EC-Earth-Consortium.EC-Earth3-Veg.historical.r1i1p1f1.Omon.tos.gn.v20211207']" ] }, - "execution_count": 6, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -231,24 +235,28 @@ ] }, { - "cell_type": "code", - "execution_count": 7, - "id": "d3192d1b-e738-4b54-bb0b-40b0af93037c", - "metadata": { - "tags": [] - }, - "outputs": [], + "cell_type": "markdown", + "id": "513d3941", + "metadata": {}, "source": [ - "from rooki import operators as ops" + "We are left with a list of dataset_ids that Rookie can accept as input for the next step." + ] + }, + { + "cell_type": "markdown", + "id": "674a3b8b", + "metadata": {}, + "source": [ + "## Subset and regrid the data\n", + "\n", + "We define a function that will do the subset and regridding for us for each of the dataset_ids we have. The function will take the dataset_id as input and then use Rookie functions to select 100 years of data for the tos variable in the Pacific Ocean region. We don't need high resolution data for this particular use, so 2.5 degree resolution is enough." ] }, { "cell_type": "code", - "execution_count": 8, - "id": "188dc7b7-5486-41a7-9c76-5eaea85183a2", - "metadata": { - "tags": [] - }, + "execution_count": 5, + "id": "30e8c66b", + "metadata": {}, "outputs": [], "source": [ "def get_pacific_ocean(dataset_id):\n", @@ -270,17 +278,9 @@ " return ds" ] }, - { - "cell_type": "markdown", - "id": "f822b3c8", - "metadata": {}, - "source": [ - "### Open Dataset with xarray" - ] - }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "id": "eacbecbd", "metadata": { "tags": [] @@ -290,24 +290,24 @@ "name": "stdout", "output_type": "stream", "text": [ - "resp.size_in_mb=47.618300437927246\n", - "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_eeycmnvc/tos_Omon_FGOALS-g3_historical_r1i1p1f1_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n", - "resp.size_in_mb=47.61820125579834\n", - "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_o3534mko/tos_Omon_CAMS-CSM1-0_historical_r1i1p1f1_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n", + "resp.size_in_mb=47.61813259124756\n", + "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_fq1_rikt/tos_Omon_FGOALS-g3_historical_r1i1p1f1_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n", + "resp.size_in_mb=47.61836910247803\n", + "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_78zekaf5/tos_Omon_CAMS-CSM1-0_historical_r1i1p1f1_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n", "resp.size_in_mb=47.622283935546875\n", - "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_o3979ci5/tos_Omon_CMCC-CM2-SR5_historical_r1i1p1f1_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n", - "resp.size_in_mb=47.6201171875\n", - "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_88m3g_jj/tos_Omon_CNRM-ESM2-1_historical_r1i1p1f2_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n", + "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_btxkrzn3/tos_Omon_CMCC-CM2-SR5_historical_r1i1p1f1_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n", + "resp.size_in_mb=47.62028503417969\n", + "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_guxi9kpa/tos_Omon_CNRM-ESM2-1_historical_r1i1p1f2_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n", "resp.size_in_mb=47.621718406677246\n", - "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_ikcleyfz/tos_Omon_CNRM-CM6-1_historical_r1i1p1f2_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n", + "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_qw22qb9h/tos_Omon_CNRM-CM6-1_historical_r1i1p1f2_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n", "resp.size_in_mb=47.61574363708496\n", - "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_kxuizmv6/tos_Omon_CESM2_historical_r1i1p1f1_gr_19000115-20000115_regrid-nearest_s2d-72x144_cells_grid.nc.\n", + "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_fusqog81/tos_Omon_CESM2_historical_r1i1p1f1_gr_19000115-20000115_regrid-nearest_s2d-72x144_cells_grid.nc.\n", "resp.size_in_mb=47.61813259124756\n", - "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_9xf8m5hh/tos_Omon_FGOALS-g3_historical_r1i1p1f1_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n", + "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_6d4b6nu0/tos_Omon_FGOALS-g3_historical_r1i1p1f1_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n", "resp.size_in_mb=47.622283935546875\n", - "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_f6f13xzj/tos_Omon_CMCC-CM2-SR5_historical_r1i1p1f1_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n", + "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_15dtyr8e/tos_Omon_CMCC-CM2-SR5_historical_r1i1p1f1_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n", "resp.size_in_mb=47.621886253356934\n", - "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_s7cmttjd/tos_Omon_CNRM-CM6-1_historical_r1i1p1f2_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n" + "Downloading to /var/folders/zr/06cgf3250qb0fzy5t_79rc340000gn/T/metalink_yugmj4nu/tos_Omon_CNRM-CM6-1_historical_r1i1p1f2_gr_19000116-20000116_regrid-nearest_s2d-72x144_cells_grid.nc.\n" ] } ], @@ -320,26 +320,48 @@ "id": "46301d38", "metadata": {}, "source": [ - "### Plot CMIP6 Dataset" + "## ENSO nonlinearity measure: `alpha` value" ] }, { - "cell_type": "code", - "execution_count": 10, - "id": "1ce6fe94-b836-4f7b-b808-6a78e87657f6", - "metadata": { - "tags": [] - }, - "outputs": [], + "cell_type": "markdown", + "id": "788b135d", + "metadata": {}, "source": [ - "import xeofs as xe\n", - "import numpy.polynomial.polynomial as poly\n", - "import numpy as np" + "This part of the demo is computation heavy. You can refer to Takahashi et al. (2011) and Karamperidou et al. (2017) for more details on the usefulness and computation of the `alpha` parameter.\n", + "\n", + "The `alpha` parameter is computed by doing a quadratic fit to the first two EOFs for the DJF season of the SST anomalies in the Pacific region. We are looking to obtain two EOFs modes that represent the Eastern and central pacific SST patterns, which is why we include a correction factor to account for the fact the sometimes the EOFs come with the opposite sign.\n", + "\n", + "The higher the value of `alpha`, the more nonlinear (or extreme) ENSO events can be represented by the model. Likewise, a model with lower `alpha` values will have a harder time representing extreme ENSO events, making it not suitable for climate studies of ENSO in a warming climate (Cai et al., 2018, 2021)." + ] + }, + { + "cell_type": "markdown", + "id": "99631cca", + "metadata": {}, + "source": [ + "We are looking to obtain data that can reproduce a figure similar to the one below (taken from Karamperiou et al., 2017):" + ] + }, + { + "cell_type": "markdown", + "id": "a4266bc6", + "metadata": {}, + "source": [ + "
\"Alpha
" + ] + }, + { + "cell_type": "markdown", + "id": "31e2e06a", + "metadata": {}, + "source": [ + "Each of the \"wings\" of this boomerang-shaped distribution represents a different ENSO extreme, with the left (right) wing representing the extreme central (eastern) pacific El Niño events. More details on Takahashi et al. (2011)." ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 7, "id": "f43be532-c565-45e7-84d8-21be6e4e351e", "metadata": { "tags": [] @@ -388,16 +410,20 @@ "\n", " alpha, xfit, fit = compute_alpha(pc1, pc2)\n", "\n", - " # Do a 45degree rotation\n", - " # eindex = (pcs.sel(mode=1) - pcs.sel(mode=2))/(2**(1/2))\n", - " # cindex = (pcs.sel(mode=1) + pcs.sel(mode=2))/(2**(1/2))\n", - "\n", " return pc1, pc2, alpha, xfit, fit" ] }, + { + "cell_type": "markdown", + "id": "2334677a", + "metadata": {}, + "source": [ + "Now we can compute the `alpha` parameter for each of the models we have selected." + ] + }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 8, "id": "140ee71c-01ad-4df5-a4af-d3f7f28c622a", "metadata": { "tags": [] @@ -411,9 +437,19 @@ " alpha_fits[key] = compute_index(item)" ] }, + { + "cell_type": "markdown", + "id": "b8714f85", + "metadata": {}, + "source": [ + "## Plot the results\n", + "\n", + "Finally, we can plot the results of the `alpha` parameter for each of the models we have selected. This will give us an idea of how well the models represent different ENSO extremes." + ] + }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 9, "id": "6b327ec5-f261-4ae8-9ee8-19fff28b62dc", "metadata": { "tags": [], @@ -422,7 +458,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -463,11 +499,19 @@ " ax.set_title(ds.split(\".\")[3])\n", "\n", " ax.set_xlim(-4, 4)\n", - " ax.set_ylim(-5, 5)\n", + " ax.set_ylim(-4, 4)\n", " ax.legend()\n", "fig.subplots_adjust(hspace=0.3)" ] }, + { + "cell_type": "markdown", + "id": "9f67612b", + "metadata": {}, + "source": [ + "From this example, we can see that from the subset of models we have selected, the `alpha` parameter is higher for CMCC-CM2-SR5 compared to the other models as the \"boomerang\" shape is better represented in this model. This indicates that this model is better at representing extreme ENSO events compared to the other models." + ] + }, { "cell_type": "markdown", "id": "f3cc1404-0030-4e7c-98bb-498c354301d2", @@ -476,7 +520,7 @@ }, "source": [ "## Summary\n", - "In this notebook, we used the Rooki Python client to retrieve a subset of a CMIP6 dataset. The operations are executed remotely on a Rook subsetting service (using OGC API and xarray/clisops). The dataset is plotted and a provenance document is shown. We also showed that remote operators can be chained to be executed in a single workflow operation.\n", + "In this notebook, we used intake-esgf with Rooki Python client to retrieve a subset of a CMIP6 dataset. The subset and regrid operations are executed remotely on a Rook subsetting service (using OGC API and xarray/clisops). The dataset is analyzed using xeofs to extract a measurement used in ENSO research. We also showed that remote operators can be chained to be executed in a single workflow operation.\n", "\n", "### What's next?\n", "\n", @@ -487,10 +531,16 @@ "* how can it be integrated in the ESGF search (STAC catalogs, ...)\n", "* ???\n", "\n", - "## Resources and references\n", + "## Resources\n", "- [Roocs on GitHub](https://github.com/roocs)\n", "- [Copernicus Climate Data Store](https://cds.climate.copernicus.eu/)\n", - "- [STAC](https://stacspec.org/en)" + "- [STAC](https://stacspec.org/en)\n", + "\n", + "## References\n", + "- Cai, W., Santoso, A., Collins, M., Dewitte, B., Karamperidou, C., Kug, J.-S., Lengaigne, M., McPhaden, M. J., Stuecker, M. F., Taschetto, A. S., Timmermann, A., Wu, L., Yeh, S.-W., Wang, G., Ng, B., Jia, F., Yang, Y., Ying, J., Zheng, X.-T., … Zhong, W. (2021). Changing El Niño–Southern Oscillation in a warming climate. Nature Reviews Earth & Environment, 2(9), 628–644. https://doi.org/10.1038/s43017-021-00199-z\n", + "- Cai, W., Wang, G., Dewitte, B., Wu, L., Santoso, A., Takahashi, K., Yang, Y., Carréric, A., & McPhaden, M. J. (2018). Increased variability of eastern Pacific El Niño under greenhouse warming. Nature, 564(7735), 201–206. https://doi.org/10.1038/s41586-018-0776-9\n", + "- Karamperidou, C., Jin, F.-F., & Conroy, J. L. (2017). The importance of ENSO nonlinearities in tropical pacific response to external forcing. Climate Dynamics, 49(7), 2695–2704. https://doi.org/10.1007/s00382-016-3475-y\n", + "- Takahashi, K., Montecinos, A., Goubanova, K., & Dewitte, B. (2011). ENSO regimes: Reinterpreting the canonical and Modoki El Niño. Geophysical Research Letters, 38(10). https://doi.org/10.1029/2011GL047364\n" ] } ], From 7c42b5f362e3eb6b7c7a35cafd338c2fa225c5fc Mon Sep 17 00:00:00 2001 From: DangoMelon Date: Fri, 14 Jun 2024 13:55:21 -0500 Subject: [PATCH 4/4] Add entry to _toc.yml --- _toc.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/_toc.yml b/_toc.yml index 834886b..9c7cdbf 100644 --- a/_toc.yml +++ b/_toc.yml @@ -16,3 +16,4 @@ parts: - file: notebooks/enso-globus-flow - file: notebooks/globus-compute-service-demo - file: notebooks/yearly-average-selection-globus + - file: notebooks/rooki_enso_nonlinear