diff --git a/README.md b/README.md
index f57fd7f..5463a69 100644
--- a/README.md
+++ b/README.md
@@ -24,23 +24,33 @@ cd solcast-api-python-sdk
 pip install .
 ```
 
-The vanilla version doesn't have any dependency. For full functionality,
-for example for getting the data into `DataFrames`, and for development, use the `[all]` tag:
+The base solcast sdk install requires only the python standard library.
+Pandas is the only optional dependency that adds functionality to the package.
 
 ```commandline
-pip install .[all] for the dev libs
+pip install solcast pandas
 ```
 
+The example notebooks use a variety of optional dependencies to showcase different
+ways in which the Solcast API may be used. To install these dependencies run
+
+```commandline
+pip install solcast[all]
+```
+
+
 ## Basic Usage
 
 ```python
 from solcast import live
 
-df = live.radiation_and_weather(
+res = live.radiation_and_weather(
     latitude=-33.856784,
     longitude=151.215297,
     output_parameters=['air_temp', 'dni', 'ghi']
-).to_pandas()
+)
+res.to_dict()
+res.to_pandas()  # requires optional pandas installation
 ```
 
 Don't forget to set your [account Api Key](https://toolkit.solcast.com.au/register) with:
@@ -57,6 +67,15 @@ They are executed on `unmetered locations` and as such won't consume your reques
 pytest tests
 ```
 
+## Docs
+
+From the directory run
+```bash
+mkdocs build
+mkdocs serve
+```
+In a browser navigate to `localhost:8000` to see the documentation.
+
 ### Formatters and Linters
 
 | Language | Formatter/Linter |
diff --git a/docs/api/pandafiableresponse.md b/docs/api/pandafiableresponse.md
new file mode 100644
index 0000000..a132926
--- /dev/null
+++ b/docs/api/pandafiableresponse.md
@@ -0,0 +1 @@
+::: solcast.api.PandafiableResponse
\ No newline at end of file
diff --git a/docs/index.md b/docs/index.md
index 4579a6d..fe5929a 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -1,21 +1,28 @@
 # Welcome to Solcast
-A simple Python SDK that wraps [Solcast's API](https://docs.solcast.com.au/). 
+A simple Python SDK that wraps [Solcast's API](https://docs.solcast.com.au/).
 
 ## Install
 From the directory run the following command:
-```bash 
+```bash
 pip install --user solcast
 ```
 !!! tip
 
-    for full functionality install **all**: `pip install --user solcast[all]`
+    for full functionality install **pandas**: `pip install --user solcast pandas`
+
+The example notebooks use a variety of optional dependencies to showcase different
+ways in which the Solcast API may be used. To install these dependencies run
+
+```commandline
+pip install --user solcast[all]
+```
 
 ## Usage
-!!! warning 
+!!! warning
 
     To access Solcast data you will need a [commercial API key](https://toolkit.solcast.com.au/register). If you have the API key already,
     you can use it with this library either as an environment variable called SOLCAST_API_KEY,
-    or you can pass it as an argument `api_key` when you call one of the library's methods. 
+    or you can pass it as an argument `api_key` when you call one of the library's methods.
 
 Fetching live radiation and weather data:
 
@@ -40,7 +47,7 @@ from solcast.unmetered_locations import UNMETERED_LOCATIONS
 sydney = UNMETERED_LOCATIONS['Sydney Opera House']
 
 res = forecast.rooftop_pv_power(
-    latitude=sydney['latitude'], 
+    latitude=sydney['latitude'],
     longitude=sydney['longitude'],
     period='PT5M',
     capacity=5,  # 5KW
@@ -49,22 +56,22 @@ res = forecast.rooftop_pv_power(
 )
 ```
 
-
-Where the data returned is a timeseries, the response can be converted to a Pandas DataFrame as follows.  This is available for all the modules apart from `pv_power_sites`.
+All response data can be extracted in Python dictionary format.
 
 ```python
-df = res.to_pandas()
+d = res.to_dict()
 ```
-!!! info
-    Pandas is not installed by default to keep the environment light. It is installed with the [all] tag
 
-For all the modules, data can be extracted in Python dictionary format.
+If pandas is installed, timeseries responses can be converted to a Pandas DataFrame using the ``.to_pandas()`` method.
+
 ```python
-df = res.to_dict()
+df = res.to_pandas()
 ```
+!!! info
+    Pandas is not installed by default to keep the environment light.
 
 
-Available modules are 
+Available modules are
 
 | Module           | API Docs                                 |
 |------------------|------------------------------------------|
@@ -76,14 +83,6 @@ Available modules are
 | `aggregations`   | [solcast.aggregations](aggregations.md)     |
 
 
-## Docs
-from the directory run
-```bash 
-mkdocs build
-mkdocs serve
-```
-In a browser navigate to `localhost:8000` to see the documentation.
-
 ## Contributing & License
 Any type of suggestion and code contribution is welcome as PRs and/or Issues.
 This repository is licensed under MIT (see LICENSE).
diff --git a/docs/notebooks/1.3 Getting Data - Make Concurrent Requests.ipynb b/docs/notebooks/1.3 Getting Data - Make Concurrent Requests.ipynb
index 308d5cf..5a3aa99 100644
--- a/docs/notebooks/1.3 Getting Data - Make Concurrent Requests.ipynb	
+++ b/docs/notebooks/1.3 Getting Data - Make Concurrent Requests.ipynb	
@@ -9,15 +9,6 @@
     "It is important to note that it is possible to exceed your rate limit as you increase the number of parallel downloads, which may cause some requests to fail!"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# ! pip install pandas matplotlib"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -82,7 +73,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -223,8 +214,8 @@
     "        df.append(res.to_pandas())\n",
     "    else:\n",
     "        # NOTE for production purposes you will need to deal with API failures, e.g. due rate-limiting!\n",
-    "        pass  \n",
-    "    \n",
+    "        pass\n",
+    "\n",
     "df = pd.concat(df)\n",
     "df"
    ]
diff --git a/docs/notebooks/1.4 Dust Soiling - HSU (Live, Forecast, Historic).ipynb b/docs/notebooks/1.4 Dust Soiling - HSU (Live, Forecast, Historic).ipynb
new file mode 100755
index 0000000..2d34158
--- /dev/null
+++ b/docs/notebooks/1.4 Dust Soiling - HSU (Live, Forecast, Historic).ipynb	
@@ -0,0 +1,921 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "42ec2f9b",
+   "metadata": {},
+   "source": [
+    "## Introduction\n",
+    "\n",
+    "The following examples shows how to retrieve HSU dust soiling loss using the Solcast Python SDK and visualize the data.\n",
+    "\n",
+    "- Live estimated actuals (near real-time and past 7 days)\n",
+    "- Forecast (near real-time and up to 7 days ahead)\n",
+    "- Historic (date-ranged queries; up to 31 days per request)\n",
+    "\n",
+    "All requests here use the SDK, returning convenient response objects that can be converted to pandas DataFrames."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2551a027",
+   "metadata": {},
+   "source": [
+    "## Model Background\n",
+    "\n",
+    "The Humboldt State University (HSU) soiling model reports a soiling ratio (equal to 1 − transmission loss) that evolves at each time step according to local particulate matter (PM) concentrations. Users of the Solcast soiling API can configure rainfall cleaning thresholds, panel tilt, and manual washing schedules. Solcast supplies the precipitation history and PM2.5/PM10 concentrations from our meteorological datasets so the model can be run without sourcing external environmental data. The result is a loss series that tracks changing atmospheric conditions and can feed forecasting or yield assessment workflows. See [Coello & Boyle, 2019 (IEEE J. Photovoltaics)](https://doi.org/10.1109/JPHOTOV.2019.2919628) for the original formulation."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a641f4b0",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "## Prerequisites\n",
+    "\n",
+    "### Dependencies\n",
+    "- Solcast API key with access to soiling endpoints.\n",
+    "- Python with `solcast`, `pandas`, `matplotlib` installed.\n",
+    "- Set environment variable `SOLCAST_API_KEY`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "26b4f5ff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "import pandas as pd\n",
+    "\n",
+    "from solcast import live as solcast_live\n",
+    "from solcast import forecast as solcast_forecast\n",
+    "from solcast import historic as solcast_historic\n",
+    "from solcast.unmetered_locations import UNMETERED_LOCATIONS"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a1aa2ab9",
+   "metadata": {},
+   "source": [
+    "### Configurations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79106465",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "API_BASE = os.environ.get(\"SOLCAST_API_BASE\", \"https://api.solcast.com.au\")\n",
+    "\n",
+    "API_KEY = os.environ.get(\"SOLCAST_API_KEY\", \"\")\n",
+    "\n",
+    "# Using unmetered location to avoid API key usage\n",
+    "sydney = UNMETERED_LOCATIONS['Sydney Opera House']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eef82fa5",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "## Live Estimated Actuals\n",
+    "\n",
+    "Endpoint: /data/live/soiling/hsu"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f1568457",
+   "metadata": {},
+   "source": [
+    "### SDK Parameters\n",
+    "\n",
+    "The following SDK function will be used:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "c1cda9bf",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Help on function soiling_hsu in module solcast.live:\n",
+      "\n",
+      "soiling_hsu(latitude: float, longitude: float, **kwargs) -> solcast.api.PandafiableResponse\n",
+      "    Get hourly soiling loss using the HSU model.\n",
+      "\n",
+      "    Returns a time series of estimated cumulative soiling / cleanliness state for the\n",
+      "    requested location based on Solcast's HSU model.\n",
+      "\n",
+      "    Args:\n",
+      "        latitude: Decimal degrees, between -90 and 90 (north positive).\n",
+      "        longitude: Decimal degrees, between -180 and 180 (east positive).\n",
+      "        **kwargs: Additional query parameters accepted by the endpoint (e.g. depo_veloc_pm10, initial_soiling).\n",
+      "\n",
+      "    Returns:\n",
+      "        PandafiableResponse: Response object; call `.to_pandas()` for a DataFrame.\n",
+      "\n",
+      "    See https://docs.solcast.com.au/ for full parameter details.\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "help(solcast_live.soiling_hsu)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fba54e07",
+   "metadata": {},
+   "source": [
+    "### Accessing Additional Parameters\n",
+    "\n",
+    "For this example, we will provide additional parameters as specified by the Solcast API docs. Following is a brief summary:\n",
+    "\n",
+    "- latitude\n",
+    "- longitude\n",
+    "- period: PT5M | PT10M | PT15M | PT20M | PT30M | PT60M (default PT30M)\n",
+    "- tilt: 0 to 90 (optional; tilt in degrees)\n",
+    "- initial_soiling: 0 to 0.3437 (fraction at request start)\n",
+    "- manual_wash_dates: list of ISO 8601 dates when cleaning occurs\n",
+    "- cleaning_threshold: rainfall (mm) in a rolling 24h window to clean (default 1.0)\n",
+    "- hours: for live and forecast, number of hours to retrieve (max 168)\n",
+    "\n",
+    "Tip: Use the SDK’s `.to_pandas()` for quick plotting.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "407cc217",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'latitude': -33.856784, 'longitude': 151.215297, 'manual_wash_dates': '[2022-10-26,2025-11-14,2025-11-26]', 'period': 'PT15M', 'initial_soiling': 0.1, 'cleaning_threshold': 1.0, 'hours': 168}\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "status code=200, url=https://api.solcast.com.au/data/live/soiling/hsu?latitude=-33.856784&longitude=151.215297&format=json&manual_wash_dates=%5B2022-10-26%2C2025-11-14%2C2025-11-26%5D&period=PT15M&initial_soiling=0.1&cleaning_threshold=1.0&hours=168, method=GET"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "live_params = {\n",
+    "    \"latitude\": sydney.get(\"latitude\"),\n",
+    "    \"longitude\": sydney.get(\"longitude\"),\n",
+    "    \"manual_wash_dates\": \"[2022-10-26,2025-11-14,2025-11-26]\",\n",
+    "    \"period\": \"PT15M\",\n",
+    "    \"initial_soiling\": 0.1,\n",
+    "    \"cleaning_threshold\": 1.0,\n",
+    "    \"hours\": 168,\n",
+    "}\n",
+    "print(live_params)\n",
+    "\n",
+    "live_resp = solcast_live.soiling_hsu(base_url=API_BASE, api_key=API_KEY, **live_params)\n",
+    "live_resp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "95f9aa5e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>hsu_loss_fraction</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>period_end</th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 15:15:00+11:00</th>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 15:00:00+11:00</th>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 14:45:00+11:00</th>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 14:30:00+11:00</th>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 14:15:00+11:00</th>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 14:00:00+11:00</th>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 13:45:00+11:00</th>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 13:30:00+11:00</th>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 13:15:00+11:00</th>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 13:00:00+11:00</th>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                           hsu_loss_fraction\n",
+       "period_end                                  \n",
+       "2025-12-26 15:15:00+11:00                0.0\n",
+       "2025-12-26 15:00:00+11:00                0.0\n",
+       "2025-12-26 14:45:00+11:00                0.0\n",
+       "2025-12-26 14:30:00+11:00                0.0\n",
+       "2025-12-26 14:15:00+11:00                0.0\n",
+       "2025-12-26 14:00:00+11:00                0.0\n",
+       "2025-12-26 13:45:00+11:00                0.0\n",
+       "2025-12-26 13:30:00+11:00                0.0\n",
+       "2025-12-26 13:15:00+11:00                0.0\n",
+       "2025-12-26 13:00:00+11:00                0.0"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "live_df = live_resp.to_pandas()\n",
+    "live_df = live_df.tz_convert('Australia/Sydney')\n",
+    "live_df.head(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "a35443e4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: xlabel='period_end'>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "live_df.plot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "345c7811",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "## Forecast\n",
+    "\n",
+    "Endpoint: /data/forecast/soiling/hsu"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "48b93466",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'latitude': -33.856784, 'longitude': 151.215297, 'hours': 72, 'period': 'PT15M', 'initial_soiling': 0.0, 'manual_wash_dates': '[2022-10-26,2025-11-14,2025-11-26]', 'cleaning_threshold': 1.0}\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "status code=200, url=https://api.solcast.com.au/data/forecast/soiling/hsu?latitude=-33.856784&longitude=151.215297&format=json&hours=72&period=PT15M&initial_soiling=0.0&manual_wash_dates=%5B2022-10-26%2C2025-11-14%2C2025-11-26%5D&cleaning_threshold=1.0, method=GET"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "fc_params = {\n",
+    "    \"latitude\": sydney.get(\"latitude\"),\n",
+    "    \"longitude\": sydney.get(\"longitude\"),\n",
+    "    \"hours\": 72,\n",
+    "    \"period\": \"PT15M\",\n",
+    "    \"initial_soiling\": 0.0,\n",
+    "    \"manual_wash_dates\": \"[2022-10-26,2025-11-14,2025-11-26]\",\n",
+    "    \"cleaning_threshold\": 1.0,\n",
+    "}\n",
+    "print(fc_params)\n",
+    "\n",
+    "fc_resp = solcast_forecast.soiling_hsu(base_url=API_BASE, api_key=API_KEY, **fc_params)\n",
+    "fc_resp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "4568eef7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>hsu_loss_fraction</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>period_end</th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 15:30:00+11:00</th>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 15:45:00+11:00</th>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 16:00:00+11:00</th>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 16:15:00+11:00</th>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 16:30:00+11:00</th>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 16:45:00+11:00</th>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 17:00:00+11:00</th>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 17:15:00+11:00</th>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 17:30:00+11:00</th>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 17:45:00+11:00</th>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                           hsu_loss_fraction\n",
+       "period_end                                  \n",
+       "2025-12-26 15:30:00+11:00                0.0\n",
+       "2025-12-26 15:45:00+11:00                0.0\n",
+       "2025-12-26 16:00:00+11:00                0.0\n",
+       "2025-12-26 16:15:00+11:00                0.0\n",
+       "2025-12-26 16:30:00+11:00                0.0\n",
+       "2025-12-26 16:45:00+11:00                0.0\n",
+       "2025-12-26 17:00:00+11:00                0.0\n",
+       "2025-12-26 17:15:00+11:00                0.0\n",
+       "2025-12-26 17:30:00+11:00                0.0\n",
+       "2025-12-26 17:45:00+11:00                0.0"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "fc_df = fc_resp.to_pandas()\n",
+    "fc_df = fc_df.tz_convert(\"Australia/Sydney\")\n",
+    "fc_df.head(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "9f18fc46",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: xlabel='period_end'>"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fc_df.plot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1014efa6",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "## Historic\n",
+    "\n",
+    "Endpoint: /data/historic/soiling/hsu"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "dd37e442",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'latitude': -33.856784, 'longitude': 151.215297, 'period': 'PT30M', 'start': '2025-10-25T14:45:00Z', 'duration': 'P30D', 'output_parameters': 'ghi,precipitation_rate,pm2.5,pm10'}\n",
+      "{'latitude': -33.856784, 'longitude': 151.215297, 'period': 'PT30M', 'start': '2025-10-25T14:45:00Z', 'duration': 'P30D', 'manual_wash_dates': '[2025-11-03]', 'cleaning_threshold': 2.0}\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "status code=200, url=https://api.solcast.com.au/data/historic/soiling/hsu?latitude=-33.856784&longitude=151.215297&start=2025-10-25T14%3A45%3A00Z&format=json&period=PT30M&manual_wash_dates=%5B2025-11-03%5D&cleaning_threshold=2.0&duration=P30D, method=GET"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "hist_base_params = {\n",
+    "    \"latitude\": sydney.get(\"latitude\"),\n",
+    "    \"longitude\": sydney.get(\"longitude\"),\n",
+    "    \"period\": \"PT30M\",\n",
+    "    \"start\": \"2025-10-25T14:45:00Z\",\n",
+    "    \"duration\": \"P30D\",\n",
+    "}\n",
+    "hist_params = hist_base_params | {\"output_parameters\": \"ghi,precipitation_rate,pm2.5,pm10\"}\n",
+    "soiling_params = hist_base_params | {\n",
+    "    \"manual_wash_dates\": \"[2025-11-03]\",\n",
+    "    \"cleaning_threshold\": 2.0,\n",
+    "}\n",
+    "print(hist_params)\n",
+    "hist_resp = solcast_historic.radiation_and_weather(base_url=API_BASE, api_key=API_KEY, **hist_params)\n",
+    "print(soiling_params)\n",
+    "soiling_resp = solcast_historic.soiling_hsu(base_url=API_BASE, api_key=API_KEY, **soiling_params)\n",
+    "soiling_resp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "8fcb0e02",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>ghi</th>\n",
+       "      <th>precipitation_rate</th>\n",
+       "      <th>pm10</th>\n",
+       "      <th>pm2.5</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>period_end</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 02:00:00+11:00</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>26.6</td>\n",
+       "      <td>10.6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 02:30:00+11:00</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>25.2</td>\n",
+       "      <td>10.3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 03:00:00+11:00</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>23.7</td>\n",
+       "      <td>10.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 03:30:00+11:00</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>22.2</td>\n",
+       "      <td>9.9</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 04:00:00+11:00</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>20.8</td>\n",
+       "      <td>9.7</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 04:30:00+11:00</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>19.3</td>\n",
+       "      <td>9.6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 05:00:00+11:00</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>18.2</td>\n",
+       "      <td>9.4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 05:30:00+11:00</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>17.4</td>\n",
+       "      <td>9.3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 06:00:00+11:00</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>16.9</td>\n",
+       "      <td>9.2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 06:30:00+11:00</th>\n",
+       "      <td>9</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>16.7</td>\n",
+       "      <td>9.1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                           ghi  precipitation_rate  pm10  pm2.5\n",
+       "period_end                                                     \n",
+       "2025-10-26 02:00:00+11:00    0                 0.0  26.6   10.6\n",
+       "2025-10-26 02:30:00+11:00    0                 0.0  25.2   10.3\n",
+       "2025-10-26 03:00:00+11:00    0                 0.0  23.7   10.1\n",
+       "2025-10-26 03:30:00+11:00    0                 0.0  22.2    9.9\n",
+       "2025-10-26 04:00:00+11:00    0                 0.0  20.8    9.7\n",
+       "2025-10-26 04:30:00+11:00    0                 0.0  19.3    9.6\n",
+       "2025-10-26 05:00:00+11:00    0                 0.0  18.2    9.4\n",
+       "2025-10-26 05:30:00+11:00    0                 0.0  17.4    9.3\n",
+       "2025-10-26 06:00:00+11:00    0                 0.0  16.9    9.2\n",
+       "2025-10-26 06:30:00+11:00    9                 0.0  16.7    9.1"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "hist_df = hist_resp.to_pandas()\n",
+    "hist_df = hist_df.tz_convert('Australia/Sydney')\n",
+    "hist_df.head(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "20204b7b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>hsu_loss_fraction</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>period_end</th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 02:00:00+11:00</th>\n",
+       "      <td>0.0066</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 02:30:00+11:00</th>\n",
+       "      <td>0.0066</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 03:00:00+11:00</th>\n",
+       "      <td>0.0066</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 03:30:00+11:00</th>\n",
+       "      <td>0.0066</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 04:00:00+11:00</th>\n",
+       "      <td>0.0066</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 04:30:00+11:00</th>\n",
+       "      <td>0.0066</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 05:00:00+11:00</th>\n",
+       "      <td>0.0066</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 05:30:00+11:00</th>\n",
+       "      <td>0.0066</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 06:00:00+11:00</th>\n",
+       "      <td>0.0067</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 06:30:00+11:00</th>\n",
+       "      <td>0.0067</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                           hsu_loss_fraction\n",
+       "period_end                                  \n",
+       "2025-10-26 02:00:00+11:00             0.0066\n",
+       "2025-10-26 02:30:00+11:00             0.0066\n",
+       "2025-10-26 03:00:00+11:00             0.0066\n",
+       "2025-10-26 03:30:00+11:00             0.0066\n",
+       "2025-10-26 04:00:00+11:00             0.0066\n",
+       "2025-10-26 04:30:00+11:00             0.0066\n",
+       "2025-10-26 05:00:00+11:00             0.0066\n",
+       "2025-10-26 05:30:00+11:00             0.0066\n",
+       "2025-10-26 06:00:00+11:00             0.0067\n",
+       "2025-10-26 06:30:00+11:00             0.0067"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "soiling_df = soiling_resp.to_pandas()\n",
+    "soiling_df = soiling_df.tz_convert('Australia/Sydney')\n",
+    "soiling_df.head(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "a2ae3d9e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "precipitation_accum_1D = hist_df['precipitation_rate'].rolling(window=\"1D\", closed=\"right\").sum().div(pd.Timedelta('PT60M') / hist_base_params[\"period\"]).rename(\"precipitation_accum_1D\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "0727f21d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hist_soiling = pd.concat([hist_df, precipitation_accum_1D, soiling_df], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "443cfbf9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x73209dd9b950>"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1QAAAQMCAYAAACRG9hJAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXmYHFW5/7/V60zPPpNkZpJMViAJS8IOkS1AJAKiqHhdUFZBBVTgIlx+CojLxesCiCJ6rwp4FQG5ihuyCmFJIBBISFiy78lkMpnMPtNr/f6oPlWna6q661Sdmp7ueT/PM8/0Ut2nuurUqXd/FVVVVRAEQRAEQRAEQRDCBIq9AwRBEARBEARBEKUKKVQEQRAEQRAEQRAuIYWKIAiCIAiCIAjCJaRQEQRBEARBEARBuIQUKoIgCIIgCIIgCJeQQkUQBEEQBEEQBOESUqgIgiAIgiAIgiBcQgoVQRAEQRAEQRCES0LF3oGxRCaTwe7du1FTUwNFUYq9OwRBEARBEARBFAlVVdHX14fJkycjELD3Q5FCxbF79260tbUVezcIgiAIgiAIghgj7NixA1OnTrV9nxQqjpqaGgDaQautrS3y3hAEQRAEQRAEUSx6e3vR1tam6wh2kELFwcL8amtrSaEiCIIgCIIgCKJgKhAVpSAIgiAIgiAIgnAJKVQEQRAEQeikMypUVS32bhAEQZQMpFARBEEQBAEAWLmtCyf857O48n9XFntXiHFAz2AS8VS62LtBEJ6hHCoXpNNpJJPJYu/GmCESieQtJUkQBEF4ZyiRRlpVUR3179b97b+9i87+BJ55dy+27R/A9KYq38YixjfLN+3HpQ+swLzWWvzpyx+gdjVESUMKlQCqqqK9vR3d3d3F3pUxRSAQwMyZMxGJRIq9KwRBEGXJW9sP4KJfr0B1RQgv3ng6wkH5RqzhZBrv7enTnz/3XgcuO3mm9HEI97yxtQud/XF86PDWYu+KZ3709DoMJzN4a3s3lm3aj5MOmuDLOMl0Bss37ceCqfWoi4V9GYMgSKESgClTkyZNQiwWI2sKjGbIe/bswbRp0+iYEOOKdEbFPc9tQEBR8NUzD/J1/i/b1InJdZWYMYE8BuOR/3lpM/riKfTFU9jXF8fk+krpY7yzuweJdEZ/vnFfv/QxCPe8tnk/PvXfrwIAfnf5CTj5YH8UkNEgmc7gnd09+vNXNnb6plB99Q9v4Z9r23HaIRPx4GXH+zIGQZBC5ZB0Oq0rU01NTcXenTHFxIkTsXv3bqRSKYTDZP0hxg8PLtuKnzy3AQBwxtxJOGJqnS/j/M+Lm/G9J97D5LoKvHjj6Qj54J0oRzIZFYFA6Rt5VFXFii0H9OddAwlfFKqtnYM5zzd1lL5C9cbWLtz4f2/j9o8chlMOnljs3fHEP9e2648fX7WrpBWq9Xv7MJw0lPd17X15tnZP33BSP25L1+/DzgODmNoQ82UsYnwzKnflF198Eeeddx4mT54MRVHw+OOP57yvqipuvfVWtLa2orKyEosXL8aGDRtytunq6sKFF16I2tpa1NfX4/LLL0d/f+5i//bbb+OUU05BRUUF2tra8IMf/EDab2A5U7EYXYhmWKhfOk2JpcT44vl1Hfrjv67e5ds4//vqNgDA7p5hvLJpv2/jlBPdgwmccMdzuPGx1aMynp9V8fb0DKOzP64/7xpI+DLOzgNDAIBDW7U+jJt89FDd8c/38Jn/fhVDCX/vGzf/aQ027xvA53+9wtdxRoOV2wyl+k3ucSmyed9AzvP39vT6Ms6qHd05z9/c3m25HVE8hpNp39cBVVVxxz/fw2Mrd/o2xqgoVAMDA1iwYAHuvfdey/d/8IMf4J577sEvfvELvPbaa6iqqsKSJUswPDysb3PhhRfinXfewTPPPIO///3vePHFF3HllVfq7/f29uKss87C9OnTsXLlSvzwhz/Et771Lfz3f/+31N9CIW0joWNCjEcyGRWruJvzO7v9EQi6BxPY3mV4Dt7Y2uXLOOXGP9bswb6+OB59w78bKOP//XkNTv6v57G7e8iX79+2P9dzdGDQH4VqV7c2zgdma1EYnf0JDCflCzr98RR+uXQzlm/en2OU8IOOPkMR7egdzrPl2CaTUXO8OFv3D/hybkaLHQe0ubZojuY13N0z7Eu1v7W7ctfljXv98YQR7kilMzj3npew5O4XfZ3P7+3pwy+XbsYNf1ztm/I+KgrV2Wefje9+97v42Mc+NuI9VVVx991345vf/CY++tGPYv78+fjtb3+L3bt3656s9957D08++SR+9atf4YQTTsDJJ5+Mn/70p3j44Yexe/duAMDvf/97JBIJ/OY3v8Fhhx2GT3/60/jqV7+KO++8czR+IkEQ44ydB4bQF0/pzzf4FB5lFgg27C39MKzRoCpiRLT3DftXlVVVVTz02nbs6h7C7X97x5cxmPDJ8NtDNa+1FhVhTTzo6I3n+4grXueMAju6BvNs6Y3BRAo9Q8a53+bjWH7T0RdHIp1BMKCgOhpCRh3p5SkldnRpc+2IKXWIhPybazuz104sEgRAeYFjjffb+7Bp3wC2dw3i5Q2dvo3D3wOWrt/nyxhFD8TfsmUL2tvbsXjxYv21uro6nHDCCVi+fDkAYPny5aivr8exxx6rb7N48WIEAgG89tpr+jannnpqTqW5JUuWYN26dThwoLRd434zY8YM3H333bbvb926FYqiYNWqVaO2TwQx1mE36pbaCgDAvr44un3wHDBhOpjNBSKBQJxdPnmOgFzl5n2f8kDMSodfClV71oPTWl+B5uy8bvfBq/PMu3v1x34dMwDY3597nLbvL12Fiq0Dk+srcEhzNQBgS2fpKlRs/WxrjOlrqB9zbUfWSMA8YaWshJYjfMSFX4oOAAxy3i+/1s+iK1Tt7VqyYHNzc87rzc3N+nvt7e2YNGlSzvuhUAiNjY0521h9Bz+GmXg8jt7e3pw/YiRtbW3Ys2cPDj/88GLvCkGMGZiAM6elBpNqotprXfIFdyZ4nHaIJhBs2z+ATMa/fJ1yoZ/zHv7r/Q7fcpy2ckL67u4hpLgqebLYlRUKo1lLvl8CAVNAJlZH0VyjCbl7fRByn37HuCdv99FrZD5OZk9fKcGU6qn1MbRmC5L4oYCMFnt6tH2fXFeJlrqKnNdkwtbP42Y0AvBnPhPu4XOCV+/s9m0cPkfLbGiRRdEVqmJyxx13oK6uTv9ra2sr9i6NSYLBIFpaWhAKUVFInp0HBvHwiu05yeLE+IGFR01tMAQCP27WTJg+ZnoDFAVIplXs90mgLid4heoHT67D39/e48s42/YbFu9kWvVFQWB5QAdnPRO9w6l8m7sikcro4XFN1VFMqtWMBLLn9EA8hU5OoPFLOQRG5pqxa6kUYfl5Uxoq0co8Oj2l+3v2Z++bE2uihodK8u9RVTVn/QSAA4PJks49KycSqQyWbTTC/N7f04dESr5BCgAGE7yHyh+ZregKVUtLCwBg7969Oa/v3btXf6+lpQUdHbmJq6lUCl1dXTnbWH0HP4aZm2++GT09Pfrfjh07vP+gMUhfXx8uvPBCVFVVobW1FXfddRcWLVqEa6+9Vt9mcHAQl112GWpqajBt2rScYh4U8mfNzX9ag//40xp86pfLi70rJUMqncFtf1mLv63eXexd8cwuXaGK+RoexRS3aY0xTKj2R8gtRwbiuUrHL5Zu8mUcs0KwyYeQIma0mTkhq1ANyc8JY8pHMKCgvjKMSTVGKKtMzAao/T4apJ5/P1duGEjIV0RHC6aETqqJ6gacdh9yjkaDZDqDA4NMeY/oHn7Zc613OIV4VkA/pLlG9/D6katFiNPeM4yBRBqRUABVkSAS6Qy27vcnJHOIu/bLNuRv5syZaGlpwXPPPae/1tvbi9deew0LFy4EACxcuBDd3d1YuXKlvs2//vUvZDIZnHDCCfo2L774ol7eHACeeeYZzJkzBw0NDZZjR6NR1NbW5vw5RVVVDCZSRfkTDV25/vrr8corr+Cvf/0rnnnmGbz00kt48803c7b58Y9/jGOPPRZvvfUWrrrqKnz5y1/GunXrhMYZTyTTGbyUTaDctG8AaQrBcsSjb+zEg8u34St/eKvYu+IZ5iWaUB3RLax+KDrMO9FaV8FZckmhKkS/SaFiSq9szMqNH14DpoTMyjZ19qPIBhujsSqCQEBBY5XWU1B2RUEmNNdEtYiH3uGUL1bpfX1xPLh8W85rfpdm9hO23jRVcwpViXqoDmR/S0ABGmIRNFZrue+yPe9sTtdEQ6gIBzlFlNbPsQBbWyZURdDWqLUk8qtSKu+h8ivCY1RiuPr7+7Fx40b9+ZYtW7Bq1So0NjZi2rRpuPbaa/Hd734XBx98MGbOnIlbbrkFkydPxvnnnw8AmDdvHj70oQ/hiiuuwC9+8Qskk0lcc801+PSnP43JkycDAD772c/i9ttvx+WXX46bbroJa9euxU9+8hPcddddvvymoWQah976lC/fXYh3v70EsYizU9fX14cHH3wQDz30EM4880wAwP33368fN8Y555yDq666CgBw00034a677sLzzz+POXPmyN35MsFcdnNfX1xfrAl73thmJKCqqlrSJfdZAYrGqgias+FRfig6TChoqo6iuTaKNbtIIHAC81BVRYIYSKR9U0J7zAqV5HOTzqi6RXXWRE2h8iPkj+UVNFVpwm1D9n/XgFzljSlUBzVXY/WObmRU4Pj/fBZPfPUUqc2KrfKlhko41It58iZUR3TjwN4S9bTs05X3KIIBRZ9zByQLumyuTcx6wJprK7Bt/yB5+McIXdl7aH0sgpa6Crzf3ofd3f6cG16hkj3PGKPioXrjjTdw1FFH4aijjgKgeUyOOuoo3HrrrQCAG2+8EV/5yldw5ZVX4rjjjkN/fz+efPJJVFQYAurvf/97zJ07F2eeeSbOOeccnHzyyTlhaXV1dXj66aexZcsWHHPMMfj3f/933HrrrTm9qsYjmzdvRjKZxPHHH6+/VldXN0JRmj9/vv5YURTLMEvCwFxdifVvIfLD5zCwkA8/uO+FTbjukVW+Fm/gbwZ6eJTk8CXNK63dCHhBqpT76YwWA3HtuH30qCkA/Kv0x5Sbhpjm0ZGdWN81kEBGBRQFmNGUVah8CPnr0j0gmnCrC7myPVTZa2RSTRSN2TG6B5P4wZPvSx2HP0ZV2ZLZQ0l/8jNGA0Phjernxs/8Mz9hv2VCdq41VmkKj+zf06krodr3N8bYfCvN41Zu8EbJyfWsMIk/6zRvTBlIpH0pUjQqHqpFixbl3XlFUfDtb38b3/72t223aWxsxEMPPZR3nPnz5+Oll15yvZ8iVIaDePfbS0ZlLKuxZRMOh3OeK4qCTKZ0bz5+s9OU3LyrexjHTC/SzpQQmzlFtKNvWBeoZPNfWeHsk8dOxQdmT/BljANZy31jVQQHfLKwMsEjGgqgOhpCU1Yw6CKBoCAs5O/gSVreUc+QloxeIXn9ZB6qOS01eHVzl3Tr9/5sAnV9ZVi/Xvp88FAx4aa+Muuhivkzpzv7DCG3sSqi5wbJ/k3dnMHmPz9+BL728CrES9lDNcA81RE0ZRWQ/njKlzntN2blnYWXyl7XmIdqQg3zurIwVv+MeYRzmPe7PhZGa53mnfbL8DVoyp+MpzLSr5ui51CVKoqiIBYJFeVPJExq1qxZCIfDeP311/XXenp6sH79ej8Oy7hhpymc5BUfG9KVC92DiZykYz9KjJvxq2JQIpXRBfaGWNgIj5IsEPAWVkVR0Jj1ghyQHIZVjrAbaHNtBSJB7VbnR+w884Qc0lwDQL6HqneIzbMIaiu08z+UTEuf2z3Zceqyc6zRpzndPWQYIuoqDUOebHsx86ydO78VUxs0Ya1UQ/4yXNhnU1UEtZUhhLJ96UrRS9XNefcBzkMluZy14QmL5own2+tKuIPNg4ZYRPe6+uF9B3JD/gB/8ilJoSpzampqcPHFF+PrX/86nn/+ebzzzju4/PLLEQgESjp/pdgwD9Unj5kKAPjr6t1UmKIA6/fmNqS98bHVvo8ZCvizxLEbQUABaisMz4FsRcccGtNQ4qE+o0kyrV2P4WDAUA586D/CPFSsYIRsjw4TMGoqw6iuMIJKZBem6B7S9pspOWyu9QwlpfbWYp6jusqwriACQEZyCA47Dw2xsG6JLtWiFPFUBuz2Ul2hGVUbS3gtYEo1m2vstwwk0lJLmh8wKW4sLLebPFRjAnZ+GqoiiIa1e3XcJyOo+dofTpFCRbjgzjvvxMKFC/HhD38YixcvxkknnYR58+bl5KiVGxs7+vD5X7+W04VbJizB/bwFk1ERDmAomfat3Ge5YI6NHvBJuOnoMzwEwYA/RoMuzrKmVUTTbtj98RTiEhfqLu6GAxiCR7lYWHd0DeLN7Qd8+e5UNmQ5FDTOz34f+o/0ZhWbGVmFqnsoKdW4whS22ooQggEF1dnqeLJD5HpMQm599r+qyh2LH6eGUxBl26NYWFdjLKKHyZeqh4rf74qQ9luMOV16awGbA2yO1URDYPbdXomGAqa4MUWKhbOWy/pZ6jADZEMsrM9rv3qEjYaHijq1jgNqamrw+9//Xn8+MDCA22+/XS/YsXXr1hGf4XtOzZgxw5cEPj/58u/exIaOfry0oRNbv3+u9O9nN7FJtVEc0lyDt3f2YH17H2ZPrJY+VrnALManHDwBL23oRCKVQTyVRjQkL445k1Fx/PeMFgyhoE8K1QCzfGo3aibspjMqDgwk0VIn5zf1mgQPltdSilZpK075wfMAgOdvWISZWYVEFqmshyoUUPRcDdnHjQ/FYte+qmoCGwsz8goTMGuzc6AiHNRyZyRbWM1zLRQMoDIcxFAyjb7hlK7Ue4UJufWxSE4Og+x7DBOa62IRVGaLUsRLtCgFEzIjoQACWSORNr/6fO3j5Rc9g7nKeyCgoCYaQu9wCr1DKUyqkTOOEVoYzvlPHqqxwQGuKIXfHqqkycs+7MNaQB6qccBbb72FP/zhD9i0aRPefPNNXHjhhQCAj370o0XeM//Y0NFfeCOXpDOqvhA0VUX13Ak/xywHurI3sakNMf21fslWdrMl3S8PFbshMyuxoii6siPTC9I9aB0ac2AwUXJGDjO8J+99UxsCGaQyTKEyQv72Sw756xpMIJlWoShAS12FLrDJDPtjOVQsPK4yot22ZVtYzXMNgO5Bkuk16OGEXD7sXHbIHxPMKsNB3fqdSGekhi+OFsxDVREyRDaW6+ZXzomfGEo1P9e0xzJDWdmc1kP+9KqS5WGQKnUOcOfHbw9VyuQC98NbTQrVOOFHP/oRFixYgMWLF2NgYAAvvfQSJkzwp/rZWEN2SJEmzGpljBtiYbRm+091lqClcDRhQubE6ghiWYuxufmqV8w9gQI+5QkaHirDal9XmRU+h3wIj9JzALT/ybQq/diNNny/ET9UQxZ2lxvyJ1eQYqG/TVVRLVcrJn8cw0OlzS+/wtfMIX/amOGcfZA5Tn1lGLy9oz8u9/fo5z+g6B4qABj2yQLuJ0zI5H8HU7D96EnmN8ZcM9ZPY67J+z1MoWow5VBRlb+xAZ/n6LeHyhyG7YfiRiF/44CjjjoKK1euLPZuFI2P/3yZ1LA/ZuVuiEUQCgY4zwRZvfLBlJCGqgiqoyEMJtLySyUP5Z4Dv7w47EbQGLMSCOTnANTp4V4BhIMKkmkVfcMp3apbivCVMv3IaWAhHqGAoh8/mecGAO56RquW2lKX7XNTFcHmzgHJHqrcOcAUKtkCgTm0EDA8VLKu00xGzVHceIOH7CIbKU6hjnKenaFEWs9DKxXYueZDJGt1A07pKQfMQ2TlDZXroWKtAMLZ8bKV5Ia1PEe/IhiIwqiqEenTEIvo68Joeaj8GIc8VAQhiN4PxFwogBSqvDCFqrEqolcrk+1lMcfG+1V4kVk4+bwSI2TFnwR+QAst9GOcYpDT5NmHayfNhfzp1nyJwudQIo3n3teanzNvG/NYyiw1bhSl0H5DVK9YJ9eSy8Jv+UIRsudafyKlX5O1Jg+V7PnMQvuCAQWKoqAiawH3S2DzE5bvwfegNDxUpadQMS8UUwoB7vdI8vAnUhm98JE5h0pVS1MRLSeGkmndG9VQFdGvT/88VLnfSyF/Y4BSz1vwg7F2TMzJh7LhFQP+f7kUCvALPgGVCWqyc6i6h8wKlU8eqkEjVIHhh4W1x2Rh9WucYsCH3XT50FeLlU0PBRXpnhYgtwHlJR+YAcAQEGWOY/Yc+RHyl86ouvDJe29kzzV2vUeCAVSEg/jY0VP19wYkG1f4HDrAv1DJ0YDly0VzPFRyFZDRhM0Dvmx+reS5xn8Pu9+EgwHUZOc3VforLmz9jwQDqIoE9eJUvnmouCJF2jhUlKJohMPaBTk4OFhgy/FHIqEtTMHg2OjW7rcF0kh0HVkogLBHD/mLRfSbmvQcKtM5yPjkouJDFRi1PgjtRg6Vf2FYxYIXbP24dphFMhRQfAnH3J1VqIIBBV9eNBuAISDKVHaNohS5OVQy17mBhDGX+F5Xsuc0u97ZGEe21eP/vvwBAFpZY5nXK/NQsrCuKp/KzY8G7FqpDBsiW60PBUNGg1Q6o/8eXnmXfY2y81wVCeaE9tVXUR7VWEAP+8wWp+FzqPww0jPjKlt7/DCslFYgcREJBoOor69HR4cW4hGLxagxLoBMJoN9+/YhFoshFBob08nsMm6UVO6XoVuMK3IVqq4BrfIazYuR8PHSjdkcKsCH5qSjFPLXlydkReZv6rOw5NZE/Q/1SaUzuO7R1Th2egMuznpfZMMrBH54d3WLZDDgixLKFKpTDp6AcFATBnQhV6LXYISHKiJfoeI9R3wbgxrJoZLs+POC9GGTa/XHAwl5eYHMQxXOtk7QrqGhkvTsWudQlWbIH29Eq66w8obKVd7N86m+MoIdGKJKf0XGHGLM1h1V1apxymynAhjrQVUkhO7BJIapD1VxaWlpAQBdqSI0AoEApk2bNmYUCbNCJTsB2ZzXwldeGyjBhOfRoD+e0kOwGmIRrhyzv1X+/ApH7dcFQ4sS0xKF6T6TRT9nHB8t7X9/ew/+tno3/rZ6t28KFV/224+KhSmuypsfOVRMoZpcX6m/5oeQ22vKoarQc6gkKlQW80wb0ycPFbdGRkMBhAIKUhkVA/G0NIWKeSiZd6KUPbt6lT+rHKoSC/ljx18rsMN73HxS3k1z2s9eVM++uxc3PLYaP7xgAT54aLP07y8ndIU3uxZUcN7XeEq+QsU81mwdoCp/RUZRFLS2tmLSpElIJkvLKuQnkUgEgcDYiR6Nmy4U6dWwhnItxhXhgN7UdSCeIoXKAtYRvTIcRGUkiIk1WlW0jt7hfB8Txiwspf1SqCwVnayHKi5nbYin0khkjQO5eS3yPWFm/KxY+dBr2zGpJpoTciE7lw4AUizkL6hw3kN547DCE3wDXz+q4jGlmq/0CMgNWbHyHAHy53S/hZCrKAqqoiH0DCXRH08CqJAylpEzoR2vmlEo4vB+ey8eXLYNXzvzYLTUyfkdgJHvwXuo9DYNJeqh4o1RgH8eKvOcZoVjzPm2XlFVFV/47RsAtOqfpFDlx3wPjQQDUBTNQzWcTOdEZciArQdMbvPDiEeSnwuCwaDv+UI7DwyiIRbR474J55g9VPIVqlwBR1EUVEWC6B1OoT+eAi2jI+kazC3k0VyrCRt7e+X27jIvkn6F/FndrKULBNz35OYayLe0r9/bh+/94z1c98FDcGRbvW+FXV7dvB//789rAAAfnt+qv+6vhyqAykrNSzGUTCOZzuRYxt3Cjn8Nf25kW9njKTCbQI0ph0qmQmUnfMoXcrXjUmMap1pXqOT9ppQph8qP68bMeT99Gcm0ik37+vHoFxdK+94hq5A/bq6VUqi5EYpnrbzLy6FKWo7D5rjsIih82PLkennKdLliNuIoitbeYDiZQdyHghHMQzWh2r+c97HjViB0Nu/rx8n/9Tw+eOfSYu9KScIUKnZ/kV3NxaoBZpVPi3S5oDfwyyYE6wpVn1wPlflm7EeVP1VVLYUCQyCQa2E1J1X74aG6/tFVWLp+H86/9xUAQNKn0rVPv7NXf8wbOmR729IZVVdEQgElR1GQJVD3DdvPAVljMMUsGgrowrQfRSmsPEeA/DltF4ZVFdV+k8z1k2/sDPiT42iGhTW/s6tH6vcaOVRciFz2/pNRoVdoLAX6bbyhshXeQkYC2UYcKnIhhrF+GnIUC/OLp+TPZ2ZgaarSIgr8OF+kUI1Bnn1PEzp292jC5vb9g7jk/hVYtqmzmLtVMrCQP1ZqOpHOjOiS7QW9LwxXkKDKp6p15QJf4Q8Ammu1RW1vj1yFynz8/cihGk4a8ynHcyS97O/o5LUARrNqRtIn194b27r0xwPx3BwqmecqxfUcCQUVhIIBxLLFHGR5j/otBIJayWFYVs12jaIU8pReO8+R7qHysSgF4M/6meKqPAL+5DjaIfvyYUZCPq8kGgroBTdKqadSn62i408OldlDVRXxx1PZwzWVf/a9Djz6+g6p319usDWHnwdGrzg/PFTadzZlPVQ9pFCNDxIm6/C3//4uXli3D5/9n9eKtEelBbv58B4kmRYPJuRYe6hKx1I4mvSZBEOWX9DRF5daKtl8k8z44Ghh+SSKAl1IB3iBYHQsrDIFglZTvocfIX+JVAZv7zQs93wBkYwqN4SNxcsDRg6N7DyqXouQIuljDI0UCtl8kJnnppeYNnsNfPK6mo0EfoRhpU05VKPhoWKokKtRsesxEjJENkVRpDb3VVUVf397NzZ29Hv+rnyw4z96BVByc3HYuLKjSQ6Yeund+H9vS/3+csOqkThbB/woGJLSQ/6Yh4pC/sYFZoWqlKxPYwErhUqmxaPHVHULAKp9CFkpJ8wVfSZUR6Eo2iLXJXFhMxc38KMoBR+ywuct+NUEtdqUnOtHyF8rV6luOJnOCfmT5Tna0NGX89wsBMosTPHQa9v1xyzky6iO6J8HkQ8nSklQSgdM1w0AzG3Vyoyv3dUj7dzYKTp+zWmrHCpA7vqZNOVQjWaVP9nLDlOowoHcPCmZzX2fX9eBax56C4t9TjWwmwNGAZSUlIgSO8XNrx6IsotclDtWnsq2xhgAYMcB+f1eMyMUKvJQjQvi6VxhZkqDIezILJVbrjBvVEU4iEiQuZDlHDdVVXUFN8dDFaGQv3yYF89wMKDHMrdLDPszC35+hPyZlUMGU7DjqcwIo4jMcfwQDGs5oaOzP57joUqm5RxDs1HDXOK+T+K1870n3tMfh/SiBHIVUXZ+ai1yqPj3vcAa7vKeo3mtNQgHFXQNJLDzwJDnMQBrxQ3IndMyvPx2vYGMkD959zdzDtVohmXLXnYSqWxPrVCuyGb0PfM+p1/fesDzdzihkPLOb+NpHDvlnRk9JCvW1NdKDKu8zelZhWp7l3yFinmoJtZkqzwOJqTLB6RQjUF4YSyVUXMq+2za5687vhxgFWKi4aD0EsP98ZQeH8/nNfhVOahcsFo8W+qypdMlFaZIZ9QRydnpjPxzYpfAzz+XIbTrFlafcw2AXKUplVZzcqhSkuImzQVCzAqhH6XTAeheRJk5NLmFSYx1IBIK6GuODIWXhRDHInzfpmBOyKwM7MJLc+e0999jlz9TrSs78uY08xAyhZqF58oMLbXDr5A/c3VKmX3P/CpEY8Yut6kiHNRDGmWsbXbVBJliLdOAA/gTplbOWK05bT4qVMzAMrG6AsFs37v1e+XK06RQjUF4hSqeymAwYVz4O31whZYbRgKvURlLloeKWdUj3HcDXA4VeRAtsVo8m2s0obC9R65QyHPtI2/hsNuewkZTuJkX7ITCIFdNTqbwObK8sHwPVSrHI5XJEa5keajscuVY1KTfxgiZ+SaDifSIRpHmccweOHfjMA9VbpuOcDYvSFYVS7sCKMGA1hICkKPw9tuEYRlV/nzwUGWPFVNKB0dhjZZdlELPoQqaQv4kzrV8eZP7++NYsaXL9n0R7HKbtNfknSO7Oe2X8bN7iDxUIlgp1lMbNIWKNU2XhaqquocqFg3ig/O05jbf+PMaqV4qUqjGIHxozHAynbO4+KG5lxssNCUaCugXqyzrkbkHFSNGOVR5sSqV25y1srdLau5rpVAxZeD+V7ZKGQOwz20C5Obp2JeyzlrzEylpBT14pSmRziDBCVcycoEA+3w2FpLjV2VBfRz93MjwHGnfEVCMMubmcWR6qMzFIlheUEqSsmvnoQKAmG4skqBQ2YQW+hGOp+dQBXM9VIOjsEbLbtdg56GqkRi+luDmklnIXHL3S/i3Xy7HC+s6PI9jt64BxjmSMdfsm1X7E/o5Grl55YSVh59V4DsgubE8f2sJBRTcsOQQAMAb2w5IlalJoRqD8GEPZg/Vji65mns5wpeYnZZ1IW/bL+eisepBBRg5VIMSbgTlSJ9F3HxDTHaZXO17mqoiOOXgCTnvmYVeL9gJhYBcYbpQrpaqakqVDMw5U3xjxZQkRcdOxmRhS7IUNztk5lAxT3QsEhrRUFVmGJaeQxXJnb9MoZLVDsKq4haDjS3Da2AbLutHlT/dQ8VyqLK/YzRC/mTnUGWVHbNCxbxuMiIj+DUgYboWO/u1KIJn3t0Lr/TZlOgHOA+VBE+lXcifHl4qWQEiY6oYVgpvY5WmUMmsYPq/r27DNQ+9qT8PBBQcNKkGk2qiOfshA1KoxiD8CY4n0zlhELsku0LLjd+9ug3/el+zolWEA5jeVAUA2NY1IOX7jQp/uYt0NBv7HR+lOPRSw8pDVSG5iR8vFJqF3AofFCoraz6ztslMqjYLn9FQQC+2IutmwCtNyXQmR+iUVULdTvhnxglZoYV2IRwyc6iY8BSLjJxXMnPcjHFsPFSS8tvyhWHpQruEOW0XLiu7qI+qqiMUqsqIPGF9tGEhuOaiFDKry/LX+XDCel7J0N/tGvsCxvUkZf20mdPMG5pIyym0Ami57c++p8kdE7OCutkIQuRi1YeqMdunsm84JaWwEwDc8vha/HNtu/6crQd+GHFIoRqD8Namh17bnlPZz48O0uXC61u78M3H1+qx3tFQENObsh6qTjkeKqseVNpY5aFQ9Qwlce/zG7FdkkePYWUtNPLb5BwzPmbeVF1YLxQgexwzesiKVOEzd64pimJY2yXdDHI8VKkM9vcbeW2ywsqswqCCAUUXcGR5W+wUMyM/w/sxY4UNzKF4AFd5TYKyy7xCZuEzJNlDlW9O63PNoxeEL+RhV9BFlnDDHxeWQ8UE3EQ640ufNT+xy6GqkigU8ueXL9zRkROSLaGcuc0cAIzfI+MatfO68teSLC/VeT99WX98w1laONlQMu1LldlyIJnO6Pd9/vzUVYZ1Y5FfVRODgdyqnzLCSxmkUI1BeCHpVy9vyTnhyRRdoHZsMjUkrIwEDIVKUpwsW4DNghRTDuI+dPgeTb73j3fxw6fW4cM/fUnq97IbPn/cjK7ocowEehGHaBgBXz1U1tX3AMPSLiMEx66PCiA31AcYGe7DK9R+VfkDNAU0HJTrbTGHKxljyTtmbD5bhZLWSFQOmAISi1qH/MkKx8zndZUltA8m0nooXI252arkxuj8cWE5VJWcx2A0ClPIxC6HSmZ+G+9R5RWqE+94Tn8s4xLN56GStX4OJ9P6OmBVaMUwfMmZB/x8Yh6qjFr6Bla/4NcSXiYIBBQ9FUBm2B+PUaSGeUPlrQWkUI1BzIs9X1DBTlggRpbDPfvwVj3kb/v+ASnWIjaGOdQnGmYeqtK6UZthvUhkWNd5mPs+wgkEUckVGHkFxKxQmZ97IV++SUyi5yhfrpZsDxXvhersT+SUFJZX5W/ka1WRkH6DkzWOnXe1WuIxY2u0ufoewCtuMsZhOVRmD1W2yp8khcoweIz8PVWSquOx+RwMKCM8xrKLUqRyPFTatR8JBvTHpdbP0S6HqlpidUQ+fJg/PvwUk1Fswy63CZBX3ImfR+ZrBzCUuT6JZfoZrHEsIO/eVm6wuVYRDoyY0w3ZsL8unxQqFr1i5OuRh6qsMbu7+3OEG1Ko7OBDxyrCARw+pQ5TGyqhKJrFq7Pf+wUazy6QZst0NFQeHiqZnhyeZGakhVV2yB+v6JhD/mReN/ms+bql3ccEfsBfD9VGk6dXVsifVZW/qijnoZJwjuKpNM65x9q7GpOYpzPIFaUwIzMMq2CVPwkKVSKVMUoKh/2rvKZ72yLBETmOTDGQpVCluTnLjpWiKLqXSmaYz2hg56GSmXvGyx12vbq8hphmMmrea0eWkMvnOAbNNwNuHD9639VVhnXDYal5QkcLo2T6yJxNplDJaAVgJhRQ9LXHj8qipFCNQfJdhKRQ2cNbg5hHIhoKYnJdJQBg237vhSnYjabC7KEKlYeHqlJirhEPE8pDXA5ARUhu02V9kY6O9FDJvG7y51DJD/eyrLym57XIyqEyBKW9pjL2SUmheFYe4qoo56GSoBw89Y59FTJZuUDad9gXpTA8YfJCC/2s8sd7Iyotfo+e1+Lx9wwlrL37/BgD8ZSUSAI+fDTECdRMASk1DxUzNkRC1jlUMtYB3jhj51nxqogOc/dHq3kgy1Bk1RCbp1pi6XSzIag6GtI9sKRQWZPPKFlbyYoHeVeozGsJr1xXSQ4zBkihGnOkM2reuFtZYTHlCL9Y87edSbWaC16GC1lXqEI2HqoSj5m2uwF5gW+qZ+2hklTlj0t2DphWtoTE60YvZW2ZAyBP0WGKm1XIiqG4yco5MeatWRmU5qGyuDRikaCe4yLDQ7Wt095oIlP4zGdl98MT5qeHajCp7WcooCASGikSyPJQGcqhvVcvVeD+5xSmaAY5izRghJSVWs+gpE3In0yhkPcK2SkCXo8bv59W+Yey1s+hpL3BA+A8VBKu0W6T4F8VDenh7LIq1ZUbzMAZtVhvZDZgN6+PvHFFD5elohTlS6GFhC5Qe/hyyLyHgi3cMjwhQ9lysmZLrpFDVdrnx4+QP94IEA6MVKhkHTOjr8XIohQyexwxS72loiNJwOENK5YWfYmKG5B7jszClJ9FKaoiIYQlNqnN12NIanhUnpyjaomFAvptxjGq/Hk/N+x8W3mntLElFaVI2o/DX0tSSoBzChVPa7aZ+I4DcquY+k3CJuRPVqhkJqPmXDs/fnodeoeTI9ZNr+Mwz2BlOIiARSieEYblbf0czOMNBeQqVGZDbTQUMNY0SWtnuZGyuT4Bro+fhPYW5nuKlYeKQv7KmEIuYgr5s6dniFvYuOu0UqInhHnBzNY15rEq9SRU/gYkq+RrTvhNcKSiK+uYMeWiOhr0NeQv381aVl8YXlGy8oTJUtwY/PExKwJ+lk2PRUMIBVnInwTlwHTcF89r1h+z4ziczHgOlRvIo4TIrCBmhBb656HKF4rHv+41DCvfOMGAoq8HMo4by6EKmQS2gyfVABhZEXasY1vlT1JD+eFUOqcZ8fvtfbjjifdHFMHymnPEvKFWhgj+de85VA4VKgmeSt5rN3tiFRRFMdY0iiiyhBmCzNcnwLed8O6h+um/NuQ8D+Z4qKgPVdlDCpV7+CRG/jJl+U4y4uaHs99hrlJVLh4qXlGUV/CAq7jF51BJLps+wIVhjSxKIe/GxoQXa2FajneCzVVFsQ6LqJKcXM8rTeZcGVlWVislpoovmy7DQ2Was//9+WP0x7xw5VUA1UPx8iTWe71RJ1IZfd6alWp2Hcmo8pcvfBHgqvxJKJuebxypeS02AtvsSdUAgA2lplBZVEkFjHmRTKue8netjvmb2w6MiIjxmhPEFB07b6i09TNpbYhg+JFDNbEmiie+dgoA4/qUGRlRTrC1Pr+HyrtC9fMXNuU8D3IRMjKLBzFIoRpjsJM7qSaKz504bcT7ZPGwhy8vr1iG/Hlf3PQcqhFV/rIKVYl7qHiFp0+ChQjINQJYhfzJqvLHh2GZPVSJdAb//eImPLxiu+dx7Erns7EB74KHLnyGR1ZE08aWezPI56GSVjbd4msqI0G9KIUM4cMc8seHFUVDAf0G7v382OdoxPRcLa/Cp3EezOMwwUCGh2ogz28B+AaY/h0zQG4YFlPeQyYFZGq9VqDIXHhlrKPnUJmLUnDH0otnz6rgSF1leISBUJahyKqaJCCvH1khD1VMUisAwJhrDbGwnksdlnh9liPpfCF/eg6VR6+rhSwW8jnkT34GOuEJJqxVRUOWSZvUh8qeXIXKeF1qDlWhsukl7qHivQh9wym01nn/Tt4alSPgMg9VSusob6U4iJDjoTIt1Nv2D+Ch1zRl6t+ObbOM33cC7zWwLjEtrwkqYAjnZmRWrANyFaoROVTS+lCN/B7tutHGk1JgIc9xVxQFVZEgeodT6I+n0Gy7ZWHyVRGTldfChNdIaGSvFmb3kFnlz1b4lFRRsnCulpxwWcA+R4MZvvzIRZYVIm31vXY5VKFgANFQAPFUBgPxFBqrIq7GsFKU6mJhSw+Vl7VaV6ptQv5kFUApNKdl5qCyfL0QZyxk844iiqzJn0Mlp8qfVQGVoEVRCpmVGMlDNcZgN5PKcNBaoUpl8PKGztHerZKAvwBzilJEJOZQZb0pdh6qVEYtaTc/742Q7f0wh9+wY6iqcgwFehPUaHBEyB8fDupFsS5UYlqWhbWQNV+2h4pXZkZU+fOxKAWvLEhRqArcHKWVAM+TCyIrr4X9FqvSwjI9VIaiUyjkz99CATKLhqRscqhYFUM/DJPmcyGr6TL/vWaFCpBTBMXquqmvDOthhHyZfi9Gw4JzQNL1WcggJTMHNaUru8ZcY49lGDzKEXYvCJnL8UJelT+rCBs+AkfmesMghWqMwQTaSCigl94Ecj0un/v1a6O9W2OeVDqDPu7C4G+juodKRg6VTaWqKJdTVcpeRL5qmCzLjVXJdCC39LyMsD89Pj88sg8V72XxJHhkBelw0N8S07qQa1N10U8PlVlgkhXyZ9XYNxoK6EKvDGtuIWVZXglw+/MjO6/FSvgMBeQJbENMebeZa/K8BvZl0wG5SeLMCGC2gEd89FCZPbmy+rfx14U5hwqQkwti9dnKSFBfCxpiRgNWL2uOsa7Zed5lefjzz2mZHiorbwsVpciPsxwqb+emkIeKcqjGAXz1E/5mbbcwEBrmeFvFwkMlp2x6/pA/QF5OUDFI5vFUuP5OCwsee85Ok4yGyEOch8ocksILAV4U68KKjhGb7yUEyKk1X0ZRClVV8974ZXlcrWR/XqGSEVrIz9kbPzRnxPuyhHbDG2rfiwzwZmlnn7X0UPlQyMNvr0G+yoj8ODIsxrph0qSAsHXaD4XKrEDJEqaTKd5DZZVP6b06IpsDsydWGeOmDW9UZSSoR2F4UUL4KAIr+GI7fq6fcj1UI/P19DWNyqZbouc45s2h8uahslpHQpZV/ijkr2xJ6cm0Sk5YmZ3rmtDoHsztBeF3DpW5yl8woOg3u1IunZ7mq71J9n6YE8QVRZFmaef7qMQiIZgNubwA7eV3GbH5NqEk2Ru419AYI6QsvyXXq5ALFD72SUlhK1YhUJFQQJ8XMoQPdn7+fNUHcNWig0a8b1QR8y98jeW1AN6UA6YsWykgo9qHSpKQWzCvxZcwrNyFwE8PVdrsoZI0Bh/xYGXRl2EkYGt0a10lvrxotjZuKqMfp0gwkGMscotTRSejestH1gut2K2fUj1UViF/rNAOeaisyJdDVVNhzDMvUQtWIX+8TF3FhcrKyn8khWqMYcR+B1AZMU6PnUWc0OgxJTBahfwNexSiVFW17QsDAFMbYgCAVTu6PY1TTHJyaSSX5A5bLJ5GhTdvCxrfR8Wqyl9/jkLlPdegUG4T4DUEJ78nTFYYFlA4D0dW5UrLHKpgQI9rl2HRZ0o1uymbkdXnpmCpcQnC53CeapJ6TosEQSBf1UogV8j14n032g1YH7MKvfWE9/mW0I041iF/cR/Css0eKlmh3+y6CQYUy2IQMjx7THEKBxVMqI4C0JQsptREQ0HOE+Z9/bQL+eMjcbyMU7i3mhzDCmCsW3xJbmNNIw+VFWmbkFwgd+22CttzilWVQL5oC7sXqKo84zEpVGMMXnPnhSnzjYHIpdukUC0+1KjhVSEp5K8/ntIXz4bYyGpKH8yO+fz7HZ7GKSa8l0CG94P/zrBFzpGsGw9TQBRFy80yK1S8tdPL4pnPawDkXrdyPGGFQwu90tEbz/u+rJAIK09YJBQwSgxLKUziTNHxGlZWqGhIlYRKf0yh4sOJGUFFXmPfQopOjpArwRhRZXPMZFZK1Y04Zg9V0PBQya7KZzYKvbh+n5Tv1UtM21TWk5FPmeSOVyS7Jud4qEIBoziJp3Utf8hfIKBIDWG0XwfkGFYAQzngDYYhKpuel3weqlAwoK8RXir9WSljvEJVGTaKV8lKbyCFaoyR5tzHfFEKq2RUwoBdeLMmVuHbHz0M3zhnnv6erJA/VpY9GgpYCtQzmrT4c7NyV0qkffBQJVL28dKyQv74JORAQEG+qr4yFB27xHqAK/8swxNmV6VKgrWYsWlf/iansuaBlfwaDQUNpdrjHEilDQHQz/4z6Yyqe2psQzIlVPpjioU5vBgwcqjMYWZuKOR15YVcTzlhBcbRe/lJ8FDZ5W3yhWRkFw8yr2Fff+xtdA0kbLYW/16LgmgA5FQr049XKKAfoxVbu/DyBk0p5O95njzvBcJLAeMa9fJ7HFdJleih4o3eRl4oeaisyJdDBXCFKTzkUfVbKFRNnEKltdGQW+mPpPQxRjJNHio3MGVnbksNLlo4I0fQkVXl70A2T8vKOwXwAkHpLqL5+hG5xYgxt/JQyamGZFZA7Ky52rYSQlYcCASeQmOShapUaWPEUxnPN207hYpdN7Ksdyw8jVcQcnKoPP4Ovqmvk3wg1+Nwny2cD+TdQ1Vh4aEykt5l9O7K7zkCZAm5+cuzs0qpcQlFfez6NkV5hUryOm3lZZehUOkhf7YeKu9zjc+VYsesayCBB5dv014PBaR4wozGvvZzjY3D8kjd4LTnmZQcKoscYSavkYfKGqOxr7UKohem8FDpz+rcNmXDWRky8zYBUqjGHIbmHshJoLOq108YsByqusrwiPdYLprXYhEHskpbfWzkGACf8FzCRSl8qPKXsrDgMWR7qJhQmK9xr4yQFTtBGpCzSA/G81vz+caYgx7n9ZbOAQDAgqm5XZzZPJelWGd0hYrzvIcCeqiM1zw6JqyFAoqtR19GMQ82TkDJFdCtxvEyB5gXLGrlocreD2SUTR9M5ld0AGMeehFyC107egU+CVb9QiF/gHyFyiq/zCqkSZR84VGAnJC/BOfRszJ8RUNBKZEegwWKRQCQEjI9WCCSgBkIkmnV8zxIWXhbqChFfqyOGY/e3NeDh8rKaGZufC2raTmDpPQxBl/lr5JC/hzDPFR1lSO9RxXSQv7Gg4fKvyp/1h4qFu4lJ4eK3SjziTFSyqbnU6gkVJAqZM2PBI1y415z3dp7hgEA86fW57zOjBOywiFYlT/zuqZ7KT0qB3pT9MjIsvkMPRxTQthSLBKyH0eCJ4yFvlnlUMn0UDkxEughfz5WeNPXTwkeKruQvwBXjVV2yJ/V/UVGXEmmgEIlo5E0v0Zb9deLhg0DrxfD5ECBOQDIyQ8tHPIXHLGtW1KcEZyh99ajsumW6B4qm8grVrnSKmzPKVb3xSazQsXWNUmFl8aElP6tb30LiqLk/M2dO1d/f3h4GFdffTWamppQXV2NT3ziE9i7d2/Od2zfvh3nnnsuYrEYJk2ahK9//etIpeQ17BotmPuYQv7EyOuhkhXylw3faKgq5KEq3UXUDw+VnvBs4WUNS6ryZ76B5vs2L14DJwJBTC984MELopdNtx5HUbjkbY8CQXuvplAdPqU253VmOJBlvWNTy+yhklUCvJDArr3nPXSNXRd+eynze6i0Y2ZVil4UJ0aCSqkKlY2RQGYOlU0zcSC3MIVMrBQNGQpvWi2kULF1wEtRCqP4hJXxNhoMSPFQOclBjUk0SNldo7zi6DWPKmWhvIfIQ5WXVIFCK0aBGu/rDc8ID1XEe8QCz5hQqADgsMMOw549e/S/l19+WX/vuuuuw9/+9jf88Y9/xNKlS7F79258/OMf199Pp9M499xzkUgksGzZMjz44IN44IEHcOuttxbjp3iCd4XyuQbmHj5ELj1DmrJjFY7HhAGvDXe7h+y9YIDcKlXFgs8DkNG3CzByqKyMAkHd0i7JQ5UVZPkb2awJVTnbDkoJW8ojEOgKvIzywk6Edm8Kz96sQjWvtTanmAe7lmRX+eMVqmhIXtn0oWR+gR3g8zO8KLtZoTBP2JLuofJwbpgwYZVDFZTqoSqc16KH/LkUPnNbThQqSiHBQ5Wy7n0H+Gf4sjo2Mnqr6UUpbL2hTCj04qEyGiEX9lDJKJ2fR3n3GPKnzTUHa4FeaMXb+snnvTPCeuPt0pUF/CRf2XSAb6HgvRcZzwRTDpUM5Z1nzEjpoVAILS0t+t+ECRMAAD09Pfj1r3+NO++8E2eccQaOOeYY3H///Vi2bBleffVVAMDTTz+Nd999F7/73e9w5JFH4uyzz8Z3vvMd3HvvvUgkvCeFjiZ6DlUwkBNnnEpn8LvLT9Cfy7BMlhNGyJ+9hyqR9pbAb1jXrG8G5eahkqUYJi06yTNkWfLMOVS8IHNIc03OtjJC/nwPj4oXFghkeA0SqQw6+7U1ckp9ZU44q5FDJavKHwv5M+ZBNBTgepF5VaqdhK55DyfSQwvzKSBc00i3MMG1wmIcPxr75p1rYW/HLZ7K6B5KO2FapkHKLuQP4D1h/of8yfBQsFNs66GSkUOl96EK2Hr1DMPk6KyfbtfpRDqj38ccFQ/y6KFKW3hD2Zomqyl6uVEoh0rGWuDMQyUnHYQxZhSqDRs2YPLkyZg1axYuvPBCbN++HQCwcuVKJJNJLF68WN927ty5mDZtGpYvXw4AWL58OY444gg0Nxu9h5YsWYLe3l688847tmPG43H09vbm/BXiwWVb8b+vbnP7MwuiV4wJKDmCe388hSO4pHGKzc2FVeCz8lDxAsmwhAt0NMr+Fgve4i1LMWRzOmIh3OiWPGnhXlkPFfc7JtbkWqW8eFwK9YcCJIVHsSp/NiF//D54URA7+7UeVKGAgsaqSI6SUJ9VrqR5qNSRQk4kFODmgJyiFE6ENRnNSe3CMQFDsfdybow+VPYhf3L7UBWuvOZWueavBTtPWFRiY192XKzC10ZVoZIY8lfQQyUh5M8+hyqIiuzrcgxS+QxF3n4Pv3/5w3IleagyhszGYF53GUVjypFMgRwq5qHylK9ncV7N88GoyFtGCtUJJ5yABx54AE8++STuu+8+bNmyBaeccgr6+vrQ3t6OSCSC+vr6nM80Nzejvb0dANDe3p6jTLH32Xt23HHHHairq9P/2tra8u7nUCKN2/76Dm55fC06smEysuEr+vAJz71DyRxrG8Xm5sLK0zZVRUe8Fw0F9FAmLzcDdsOssFmkZbipiw2v2MhSqJK6kSCPYOhxPg+YhFy+P0+DySolpxyvk4poEgSPvGFY8pK3q6JagQU+LLM+6+2V1YdKz6EK5SpUgYAc4WPUz40DodCL9dvoQ5XPQyUh5C/pXBF1O9fYPOPL5JuRWZQioYf8WXioRjOHSkLIVzpPyDTA51B5L5seDinWXr1gQL/veRFynRg9vBZ0YddcxMbbxpDloUpZRGDoRSko5M+Sgh6qsDwP1WGTjdxgcxEhwygp5x5nf0cYRc4++2z98fz583HCCSdg+vTpePTRR1FZWenbuDfffDOuv/56/Xlvb29epYq3nL3f3odJtRXS98nKfQwAvcOpHIGUFCqDdEbV85vMLl1Au4gqw0EMJtJybgY2Qm4kmA0tLGWFKs2H/Mmq8mdfNj0sqaP8YDw3t4n/PnNlH0/hXlwDYTuk9KFyEPInQ5BiYWXMM8WvOzXZXiBei7kwmFUymhPyF9QTk2WXzrdChkWyUC4Qvw9erN96H6o8ZdO9XjeJVEa/PvN6XT2G/DkRpGWWTc9XWTQicRwe6xwqCR4qFvJn46GSkVivF6UI2hSlCHkvSpFMZ/Rj7mfIn57nmseDDMjrRWXVpJaKUuSnUB8qZlzxFl6qndd850CGUZJnTHiozNTX1+OQQw7Bxo0b0dLSgkQige7u7pxt9u7di5aWFgBAS0vLiKp/7DnbxopoNIra2tqcv3zwC/C69j6Rn+QYu54TfcO5HioK+TPoHkwgGxVh2yNKSoUivV9LoZCV0j03OSF/kgSO/I195YQu6R6q7Lnhc0vMSraMHkR+CgSAszAsGeMMmYR2XijQvX2SwlaskusjoYBRsU6V5aFycsxkVBDLo+xKKP3MPDX5yqZ7zaXNDY9y4NnzGPKXzxAh00OVL+Qv6ldRCp9yqPTrpmAOlfeiFLY5VCHvRSkGHc41ryF/eoGiPHON3wev4V56BAYnn4UlFVsqVwp5qNhc87IWsPlz1emzAQBLDmsesY2MCpk8Y1Kh6u/vx6ZNm9Da2opjjjkG4XAYzz33nP7+unXrsH37dixcuBAAsHDhQqxZswYdHR36Ns888wxqa2tx6KGHStsvvgrVjgOD0r6Xh8+hMo+tKIq0EKlygoX71VWGbV38FR4rB2mfZUKufW8gQLsBlmp1H36/5YX8sZt1nip/Ho+XuWFkXg+VhJC/fI0pZRSlMCrJ+RvyZ3hBtHH4/AlmhEhlVL2ghBfYKeELx0SCAV3BkhXy56goRTLt+jcxr1PecxP2LuTqVf4sPFQBSTlU7FoIBRTL3BmG17zAAdP1aYXMHNS8IX8+5bpaKVQyDJ/M0GDnoeJzqNzO6QRXNj1t8R28h8qt1yCn8XaeuebVUOTEsALI6RcIWDeR1nvrkZxmSdqiMiKP7qFyeY1mMkalx5MOmoDXv7EY9114zIjtyjLk74YbbsB5552H6dOnY/fu3bjtttsQDAbxmc98BnV1dbj88stx/fXXo7GxEbW1tfjKV76ChQsX4sQTTwQAnHXWWTj00EPx+c9/Hj/4wQ/Q3t6Ob37zm7j66qsRjY7MqXFLkhMwZbjyrSjUFT0UUJDOqBSby7Ffz5+yLmcOGIurN2t+bniUGT6UKZHOlGSpez+KUhgWPIs+VJJCI4zGviO9KuaiFJ48VA7yTSo5od0NOWFYYX/7tbDrgSlUvCGHtyKnMqqlQiwCEwwbYhH86qJjEQoqJg+Vp6/nQv4KHzNV1SzthYQuKwaceMIkVF4bduChkpd3Vsian/09HoVpJyF/Mjz8+bzilRLKf1sxbHGu06PooUplVCTSGcv5Ugg+RHJmUxWOn9mIFVu69PcjoaCu2LuN8hhw4HUHvK9rRg+//OJtTEKvOMDa20Jl0/NTSM6NevRQ8XO0KhKynXOy8ugYY0Li27lzJz7zmc9gzpw5+Ld/+zc0NTXh1VdfxcSJEwEAd911Fz784Q/jE5/4BE499VS0tLTgT3/6k/75YDCIv//97wgGg1i4cCE+97nP4aKLLsK3v/1tqfvJh0D5VbbcnEP10BUnYEp9Je6/9Lic16l6jEH3IGu4m0ehktDlfahA7gQfXlKqeVRpHxQq3YJnsXjKqlZmtubz33fQpOqcsD8pXkpHPXtcCgTc/vndbJVVvWS/h1d6+bGllH/Wq5UBiw9txqI5kwAAbMjRUA748+a1Yl1+xU1CyF8eD5Ws/m1OFB3+fc9eg3whf5JCpnsGk/jdq1qVYCuFSnapZIZ1lT8JRSn0xr7W7/OhbW6NRXyZ+UBAwaNfXIgfXjBffz+aE/LnTanOd90A3oVcpiDlm2vafkjyUFn0VGKPqWy6NexeYF823ZuHiinvimK9fjJkhM3zjAkP1cMPP5z3/YqKCtx777249957bbeZPn06nnjiCdm7lgMvYPql0JibxH1g9gS88h9n6O+HJJWZLid6h7WLp7YiXx8VeTlUVlW3AE0YDWY9iKWaR5VblEKShyqPtVhW2XS2r8w6y1+fiqLgxRtPx2+Xb8UPnlzn6QY6GC8sgBqluV0Knw7DsGSUSzYXPuCNArxAksxkUAlxyzePnaVdVsifE+UgENAK1Awl0xhMpNHkYhyRohR+96F6dXMXrv79m/jO+YdbFuQphJN8MIDPa/FmJMjnNWBCFAuZduvhv3/ZFv2xlVdVvxdICvNhDFlY06UUpdBlAuvjEcqWOk+kMhhIpPIaFu1IpkbmnNVw91M+h8rtPdRJSC7/vvuiFE7H8d4rDsgf8ifDQ1mOFPJQec2hYvfpqkhoRGU/nkpJSjVjTHioSgU+zM4vhSpt0dOAR28YRxeqTn9WoaqusC5IARilzj2F/DlYqP0qyTsaZLIhI4xURsXaXT3Yn+1V5BarsrIMWfOZHe+IHruee/yroyF87KgpANwrIKqq6iFP+RP4tfdGT/CQUUmOeaj4kD9jfBmCAVsyzbkgsotSFFIOvOa4DTipwCihKAWzzubrQwUA/1izB9/9+7uuxnDicQW899VyEu7Fh6p56RfI76OVEce4F8hdo60qOkopSqHnUNlv4/X8JCyqIlZHjfspn0PlVsh1GvLnVch1kq8H8H2ovHkn3tndA4CKUohQSM71mk854MDoBcgxSvKQQiUAL/RZJW7KoFD1EyM2lxQqRn/2RladZwGt9Bj/DTjMA5DYnDIfT73Tjmfe3Vt4QwGsjs2Hf/oyFn7/X56+lw8nMWPkgkjyUIXtQ2JZPlIqo7pSeBPpjP69ThruerXmF/YaeK9QxBQqPeSPs4JXhIN6/zYpyfU+e6ic3kS9VkUzcjQKF6VIpDKu8yjieTxUZsvu+y6rzjq15nsNLxWp8gd4C82OcmNY3UVlRCtYwVp38MjIdc4UsOYD3sPkjD5UnEJl8lBVegyVdBryx973Gl7quMqfB4PUW9sPYOt+rUCZVdn0BMlplqQKeF29VpQcrXXNDClUAnT0Gc18/fJQ6RPNJtyBWUGobLoBU6hqHIT8ub1R896JvHkAev8E/85PfzyFL/7vSlzx2zekuaoB+xuLV2+b3ofKYvHU57PHG09ct+bbl/rmLaNubtY5JabzzAHPFdHiDhUDKV5XpoiOLEoRDipGnzCpOVT+eKgch/p47KnkJEeDV7jdFHJQVdWxhwoA+uIjhXknOC9K4X8fqkBAkdJ/hs/VZOHgPDLyaa04kM3l/fyJ0/XXZMgJaZvrhsfwtri7H1gZvXgDZTQU1Btyuz1uTueaV0ORk/BS7X3vwvRfVu3WHyumdhBAbiEzwsDoQ2X9vncPlTOjpKxeZAxSqBzSM5jENQ+9pT/3evO3o6CHSqKAA2g37rd3dqNn0N0NeSzQN+zAQ+VR+IynMnqvq3w3BLaQym4aycPf0LxWKOIx4o695cqYYRb6cMjCQyWpyp8e8heyb3gaCQV0gcGNVZLdeCPBQN78Ds8J/CyssEBjypjHvBbACCuzUg7CoYCRsykxdMm8tAUDcjxUjkP+PApSejXBPOtNJGhUL3QTUpRIG+tN1DKHKnf+9VkoDk4YdFC1kn/fayGPQmFYXi3TQK4g3m1xX5NR8ZXBC3xsrAtPnIYz52oFV2QUJUg78FBVevRQMYWKV975+2kkFEBFxIjycFOe3bhu/DUUOa8m6L0BO8+2/QP6Y5ktAIrJ8+s68OOn10kvwmbkUBVq7Os2h8rhXPNoXDNDCpVDVmztynnuV8hdwRwqyeU4X93chY/87BV85N6XpXxfMXAS8uc1oTan8lpeD5W3OHMn8HNPppWVF3ryFUMQhS2eYSsPleyQv+x+z22psdyOnTs3C6iTZruA99BC3Zqfp2Q6IKfflbkohQpjbvFKgYxcACaDmQVDeX2oxDx7npWDPOMoiuJpHL4gTL4qf4x+twoVEzwKhZd67OOnn5sCYVjst3pZ1/qGk5aPGbJC/l7asA9zvvkkfvPyFmQyql5ttjEW0fO0ZNyn9T5UeRQqrxXrkhaFFapzIj5U/R6qqu4KFhmVHp2ta4m0u3BZY/30P39mK6dEHTGlTn88GobV0eDS+1/HT/+1EU++0y71ewtV+WP3WLfrgFMPFR/GKkNpJIXKAfFUGlf89o2c13z3UNlkoOpJ/JIsBs++p+XhbNvvT6Pi0YDdNJ2E/LlWqJLOvBN6UQofFtI1O3vww6fe1xVIQJ5lRfsuJlwFLcOM3JLQ+1BZ5VDJmc/xZG541E1nz8UXT52Fv3/l5JztmFfBjfXTabEIXuFyI+AI9waSmEPFL2vhYMDoEybR0m6uuiSvD5XDkCKPVsnRKH7Bzoui5FZeY5ivJbfnR3SuxVMZV4qv83PjPRyPXx+/eNrskWNIypu47pFVAIBv//1d9A4n9flbH4voYYcyQv5SBZqgAt5DMq2KUvAKSTyVyTEkujEYulo/XcyDAYfeUOap9pJDtevAEADgkg/MwFmHtuiv6x4qHw2ro0l7z3DhjQQoNKdZ8/fe4aSv3lD2vqq6L9HOMybKpo91+AZ3DN9zqGxcobIbxk2oNpqeDifTtiXBxzLMOutnDhW7GeTraQBwRSkkx+erqorzfvZy9ruNcy83h8oQFPvjKfBp7qqq5i0/mo9Unsa+TDD0ej0xgYBZBmsrwrj5nHkjtjPi8/1TdFhoYTKtdWuvj4mO49TTIqNsem7hA/4sBAOKbkGUklxvU60sKL1surO4ebehPk7Pj2YBj7saJ540PK5W110+4VoEJ42qtfeNYzqUTOeNBrDCqRLqNZIAMO4H3zn/cBw0qXrE+/JyqIxzcCAb7lcVCSISMoxuMqrxGtdN4Rwqt3M6aaFQ8cVj2hpiCAcDCAUUpDIqhpJp1MG+qq4VzBtaKJQ5wo0zGE+jNk/1XisK9Ytk6B4qD2HzrBDJJ4+dmnO8omXgoeIVGa9N3c2kC6S21Fdqpf/ZPbRQPpwZx+sNV1l0MJEuuH0hyEPlAKvSq1YWwTe3H8DqHd2extIb+9qG/MlbqDUh2Xi+o6s0vVRGyJ/9wus1bn446ewC9ctDtX5vv/64h6smJdVDxcUdm63iXn4PMxJE8lT58yKwq6o6og+VHV7i851WqQK8hhaKeUC8lE1nuTd2N6ywpBw3gCtKYQ75Y419PXj9VVXVleRCOYBe5kA6o+pKaKGbvJ6r5UJwN5r6Wv8WK+HaTciKEcZaSNEJ6PcKN0YcJ5URtXG851CxOd0Ys+7HJENpA5Bz72ThfvXZMdm6JsPwyb7CfN3wePVWJ01tJxhPXXsq/nDFiWhr1KxCXpr76vl6BUL+FEXxVDpdtO2EFw9Vb/ZebFb62H2oFNunMPiwTjsDv1usmiHzVIQD+ly0qp5ZCCOUOf8cYH0Jtc94l6VIoXKA1UVhDvkbTqbx8Z8vw0fvfcWT1yBZYKKFg/Isxpc98Dq+/8/39efbS1Sh0otS5PFQyWpKWMg7wRLIZbv6+YRXfubJSqgFDA9VZWRkDpWXG0NSt0ZZeai8C+zJtMol8Odf0rx4dZzOAX6c0QgtHHSZJA4A+we0HmOsKaz5a2TmULGvsK3y58FDFU9l9JArxxXr3AiF3NruuJqgixv1MOehssLq/sCqzIngdK4piqKHgLmZ004qIwKScqji+e8HsopS8GeACZ9s//VcZ4lV/vJ5qLx6q/UcKlPhoDktNVg4u0l/7uU+6rQKJ7+Nm9/jvMKb9v5w0l0Y63AyrZ/32spchSqiF6UoXYWKD5112WPblkKFVhRFQV1MO6bdLtY1XpYphF7pL+ldliKFygFWF4X5AuRvALu7h1yPlS6QQ6UXPZBwoT6/bl/O8x4XloCxgLM+VOxG4LKvgYOS6YB/rn7+BsYnoMvspZKbQ5X7Oz0pVKl8OVTeBQ++kpJVvgmPF6uk0z5H/DaurPmCISuq6t6i3zWg3awmVDNrfu558KfKn0mhYiF/HjxUOSXtneY2uTBGsHECir2yo4/joSRvIQ+V1bW0f0Bc8BARcis9CO1OwzFleI96sgJYXaV1xIKskD9+GptD5pjxSI4hwt+iFKqqWuZQWeFF4R1wGPIHeGuO7nT95N93c9x6s7nbigLUmGQPPVKllBUqTs6QrRg6iSipz16/bipQDzqMVgDk9qIihcoBlh4q00u8QNjRG3c9VuGGZ94teHa4Lb1bTFRVddaHilWNcd3bwlmFN90yJfn88Bc7bzmSWjadE3oqTL/TU8hfxv5mLaNqJX99FhRyJYT8OVKoPJTmdlyhKOxNIACA/f3ZymRV1uFRepsGCZZ2Va9Wlvs6C2VSVbj2tDFlNxoKFMwv8nID5c9NoZxCb0Up8nuorHIPOvvF7ztG5TV/vQbM+uu0KIWX9ZOFCDXErBUqfQ3wqlBxPqqUqUqeDEMRgxlZ84b8RVkJcPHfxKcPFKru6qW4k9N8PX4bNxEYTr2u/FrhZk73DmXljmhoxLnRc6lLuGw6Lw/Kljd1hSpPREk981C5MPSz66BQYRJATi4dgxQqB1hdFGbLE2/B3e2hIgobyy4JUKaHyky/xPCxfPzsXxtwyg/+JaVyDO+ud+ah8lblz8kiDcg/P/yCz5cCllqUgmsoWyEz5M+iJC8j5iHXiBHnelAVFnIlhPwVyAEAvPW3cKq4BQKKbmBxM048ldav+aZscRqzPhOSFGKcSGXw7HsdACyq/HHP3RamEFF2vZRLdtp0WdvG/ThGOXubHCoLgxtTjkVw6jnStvHidc3mH/qcQxVPpfXjXV8gh8qrRZqfxglTY1xZ/fWAwgn8gDcPFX9tF/Lwe8qhElk/PRi+nOag8q0N3ChuzENlDvcDjOOYTKvSezj5STyVxsptB5DOqDnNwlkDeGnjmKryWlGXLUxh1UuuEO48VBTyNypYhvyZrhF+UXIb8qeqKvZklYyW2grLbWQ1jLMSXEbLQ/Wjp9djR9cQ7n9li+fvYhe9ouQXcmTlUBWqgqiH/ElWqPjCA30+lU1nIZ91leERlmQvv4cZH6zClJjQ0z0kLgwydGuXg0BvGaF4hYRCwNsi7bTfFeBNaGfhfuGggtqsd9e8KhjJ9d6Egj+9uVN/bM4F4a27C7//L6xr74MoToUowNu5YeuHk6pTMvpQVdiExFgJ1/vdeKiSzhVET549ZjEuIEwzA4HbdZoJXwGLMCxGpSQPFR+6yq6PkNlDJaMohU2oLI+Xxr687FIo5K/Sg8I74LDZKuAtvNRpFU7Am3Gll7tfmuGbcZdSpb/v/eM9fOK+ZbjvhY2+pRYAzkL+aiu1c9Nr0UuuEE4biQNy2o8wSKFygHXIX66Awbv23YReAFoM/GAiDUUBpjRUWm4jowoSYP2brJogyoa/wcjo5cUu+upo/hAcr4nITi3gfnkQc0L+hv1RqFjp3/pYeIQg5+X3JFP2jX1Z4qmX/L2Eg/ABhhehUKwohXuhzWnICr+NG6GdeTTqYxH92jGH3IUk9aHi10TzZcqH6O3ri+Prj60W/n6R/DYZHipnIXLuw7CYB8BuTluFf7kRpt3MNdE1NJMtsw0Uvna8eEAAozBHfSxiGyLHzl3CZU8tK5hSwjwTUotSZKxDZXmq9HMjvg4wgT+gFC7HX+HhPioU8se8iILzgK/CKRKa7cZD1WNT4Q/I9fSVUmGK3y7fBkAzeo9KyF8eD1W1HsbqJt85a/jy2ShphhQqB1h5g8wLMa8ouLXms7LlLbUVtpq7LA+VldVkNEL+dnHeO74UuFv0/KlCJYw9unWH9HAFZzlUsq1SuSF/nLdKkhLcM5TE31bvBgA0xCIjPVQefk8ykxsOw8Ose27c+gx2LRQqmQ54FKaZ8OkgZEWG4iYShuUlNIa/dmw9VB6T6xurjH53ZoOT2WPlxlM+WhXE2GecWNl1IddF9Sgjh8q5h8pVvknc+Vxz2xCZb5hZ6Px4jSQ4MGAYhezg13BZgmIyneuFl9puwEFRChk5VIW8UwD0UHA3TVCF1rWoOwWRnzdOxvHkocquU8yTwhMOKrrhqJQKU/CKIO8Zkq1QFQppBowoADdzWu955nMosxlSqBxgVQLbrFDxiZ1uL6Cd2a7bbQ32nUCNxrF+eKj8V6i27jdKsy9dvw/Pr+vw9H39DkqmA3x1N285VAXLpvtUlIIXmPmbhptSyVbcyHkFGqrCIxoYewr5M4XD8Hip5MPgc6gKMRrV93LH8ddr4CXUxyq00Ow0liUY8gqZuT2D2XHpZq658R5663HjXKl2IxDo+Rk265qVcO0lPMrJcatyWbWQ36+CZdND3iIwerKhw/U2Ff6A3ObsXkKZcqv85Sol7PwkJVT5cxLy5ymHyqYHlRVeIj0GhfIP3V077PcrCkbcw/KO46bKX56QP0VR9ONZSoUpZk6o0h/zOZkyFapUOqN7bv3yULmL8iAP1ahgnUNlDvkztom7tOYzb4tVkiOjQg8p83byrZLM+0dBoTL3FPj1S97yqPoclEzn30+kMq4S7J1Ww/KrbLpd6IObRHQrnnpnr/64PhaRWzY9be+hYjlUffGU63yDhIPwAcZohfwZlYP8Vdy8CFJOvDqyilLwAtgFx7TlvGf2ULm5dkSaLnsrTCJwbqLuxzlgahRrxspD5SUnzM+Qv0GuB1W+SnUAUBnxZpBildfy3UMVxWjm6aUXFa/gsGMfMeVQyQgpdOKhqvRgMNQLajhZP12GZKqqqt/DhPr4CY6je1zDwYIFigDuGnVj9MgT8gdw0Sol5KHilVC+FsCrm7ukhcfy63u+MH12b+v30OLESSQBhfyNMmwCXPKBGbjpQ3MBjMyhkuGhGnIgsPnqoRqFkD/zQpyv1LkTDA+V/Q0UyE0id2PxcBpSZJRN968oBU+Xi94zPP3xFNbu6sl5rTEWGSGwyajyZ9XYl7fA97pU6JlxwYmHygjx8Ff45JvuijLaIX982MXHj54CAJjbUgNAXvlnNtbiec04sq0+5z2zoOhGeRsQ8LSMdjimm7l2YICVs7de16yEa1FhOpnO6NemoznNQv5EhVyBwhdeQ/70oiGFWg5E3CkGPLy8zqI7/Aj5SznqQ+W+kXjChYdK9NqJpzK699uJ0aMy7O7aMYxezuQKTx6qPFX+AH8rMvsFP1tZxBQAtPcO47pHVkkZg5eN8s25mBcPlUAos8yQP2/S7DiBWctqKkI4fmYDAAsPlYQcKhaXbC5ZzaMn7fqQQ7W7ewiqqjqy7LjFvOB7KTEPOM+hCgcDiIQCSKQy6I+nbC2/dgw5iPkF/FtE7QQMrwrVhf/zKlbvzFWoGmIRmOVnGX2oIiGLxr7BAGqiIfTFU+jsj9v2Q8pHvEDPHp5Sym3yPeTPQkH8yILJmNYYw8HNTKGSU5SCCa4zJ4wMZ1YULd+ALaleQv6ceY48hPwJVCrzYvk0CsTYeahGznVhzxEfiuenh0rAs2uE/Lm7vzmtxlopoXQ6b7FnCtWIkD+JVf7MnlwevbhCIiV8D9cjCCzWZzNu24/wQrGTgi5VLvv4DQp4JgCvVf6y3lAbo7BfFX/9hL/uVmztynlv+eb9csbIyq6hgGKZBsBwG/KXTGd0ecXviAUz5KFyQJyz4LD+H2bLEy9wuFaosoJhvptBVJIHxLyPkVAAPUNJbOkc8PS9hWBC3JyswLZ5X7/rZp4AHDX1ZVR7CMFxKkxHRqEPFc+BwYSnPhdmZWpuSw1qK0NQTeUJpORQ2TSrPnRyLQBgxZYuy/cLwRZPJ0UpvCg6Ij2IKl16wlRVFSz76766lxFaaMxpRVFw1LQG/VqR0XgZ4HIQ7foqcQKgm7km1E8p62lJplVhgXdAQDnwYvlkodENNgqV1aUkKniwYxYMKILeCUGvQdy5sluhe45cRnk49CJ7Lc8O5M5TVhworHuoDM+ul/xQwFnIHxMcVVX82IkUpfCqVFeEAwXDPgFu/RTOoXIWms+QUeWvzqYAil89Kf0k39zxIqfxxB3IuYD7ohSjZSiyghQqB/BlmdmN31zym78xu7XmDzuIMWZCo2wP1RFT6gAAb5sEbNkMZyft0dPrEQkG0DecynEti9LHlU0vBLtw3FQzNM5N/ktGVhVGM3Y3lozqrpO4FTOaYvj7V06GoigjihN4UagSpgpYZk4+aAIA4FWXFjC2QDsrSsE8Oj7nm7i0gMdTGd07OFrha/nGkRW6pAtUNmPxQpYbb5hI2XT+94pbwEVytdwXpWCe5wabkD9LD5Wo14A7Zk48Gm6Ttw2vQeFjxqIzXIf8OQz9lNGLiheUe3WFinmotP//er8DC779NL7793ddj8Nu1fkUEV6BEF3bzCXf8+E2JJPNGSf3acB92XQ215yO48XIahSOsb5GWaXJjj5vUTijiZVn+MefXABAXosWJyXTAaCa87qKwOZAOKg4kgmM/EOq8jcq8E3I2H1sZNl0GR4qJyF/cjxUSW4f//Xvp2F6oxaKs7fX34ufLcS1FWEc0lINACNyeETozzb2LVTlD/BaNYb1nymOhypfefRelwqV2bM1a2K17oI3W6PcKvCqqureDTsL6IxsZaGOPnf924yy6f5ZWAHBohSuQ1aM7cXiv8V/j64g5rEUyqpWJuKhcvX9AiF/kVBA9yCI52iIF6VwI7SzNgK2HiqLw+XWQ+VEOQS8KFTOx/Ga21RonjGYl3LYpZC4o2swp3deZ7Y4EFN0zQV4fvWy++JLK7dpnvt810ggYBTaEPXqJAqszzxuw6MGLLzh+cdx53nXG0g7Vdwi7mUCvSiFTQ7V7ImafLOxw3t7mNHC6rqbNVG7Pw8l01K8VE7v11Uu5TWjgbSzOeAl7NMMKVQO4CcAEzDMHio5IX/ZcfKG/MnJ0WGL6NyWGsyaWK3nrtzxz/exctsBT9+dDz4XacHUegDASxs7XX+fiIfK7QUKAEMOmwWy8+M1bjqRymDVjm5dcc9XsMFt/zCzZ2tao5HfYl423VjZAW2RYpeG3QLHys66VQydWrwAjwqIUMlsd4s0E9j5tSYfMS9FNhx5qLLVyjx6qIYLKDxOfms+9EaODm+ibnNoBoT6NrkPJ+ovUL3UyqMkaiTQQ1gd5pu4DWMV8R56bezr1OhR4cFDNZhI4ZQfPJ/z2r6sMYjlIdmFN4vy3p5ePSy7UKicbsQR7HvGjKtWVVjNsAgN0fMjEvapjePRG+pwHLeGL4AL+bNRqA5u1hSqDaWkUJnklo8fNUXPp1VVOYZivcdeoZC/7HojKt/0x90aishDNSrwfW7sql7xZdPdhvwxoT2fdY0JjV77Auhu/uz3NXDFAL7+x9WWn/HKcDKN9mwRispIEB86vAUA8OTadteWD1blz0kOFRO2+l0oB05DSWSVSv3PJ97D+fe+gtn/7wms3dWTd1FxI7ABwH5Tg9U2TqGaWB3Nec/tGCx0qSIcsL3J1UpSqERC/gYTaaHcM1VVBUuxurOwCofG+Bzyx46X1wqghYoFeNSnDKukw5uo23LJrEmvo8a+2THiqYxQyeFMRtXntDMlRJv3ooVJRDxH2nYu82fizpVdr32onHoq2W9x03vRqlWFrlAFcotSeOVprp1FT4Geg4a3Rez8iORQuW3u3C/qNXAZijcgYPTitxMN91JV1WjsaxPyN2uCplBt2+9vXrosMhl1hNzykSMn58ijMrw4oh6q4aTY+jkgUDgI8BY2b4YUKgfwyeis94SvIX95FCovljWeRCrXzd/EKVQyYkmtOPsnL+HZ97RGvrFIEMdM1yomdg0kXDfcNfpQ5S+brm3j3mLsNJREVjO/B5Zt1R9f8Itlebd1e772myoEnnrwBP3x5afMxHkLJuuN/tx6wTqzSltTVdQ2T0P3ULkumy5elAIQC2PUwh20x2Jlf90JHk69Bl5CGHXhM8+cnpBVrDtdhmPqYxUK+TMJoKJFMMS9Le6skgNxZ+sAkDvXRMbh56WT8FIm0Al7qARKzfPbuQ/3cpLfljUYulw/nVZjnVxfCUAL3RPFam1n47L7qRNvjxPW7jbC4TcXKBjl1tKeSGv7LpJvIl6UwvkcANyXTRcVpvU+fi4KHzAZsLbS+n4woUZbO7sk9Yq04p7nNuDe5zdK+S4r71NjVUQrWuMxtzFnHKceKu4cisg4bkP+qCjFKKFbIirDRsgfp1Ct3NaVUx3PrVvUUKjsTwuLqT/gsVx2IqsAMgWAL1ft1LojCn+MKsJBxCIh/be+vaPb1XcafagceKg8FCRwGkrC+oTJbOxbyFrrxuMG5OYsHdlWr7v2AW0O/PQzR+GCY6YC8OIF0+bphGr7cuis7Gy/y+a+Qo19XVrbmKKjKGLCtGtrvsNrsNLTnC6c1zAxKxTs63evUN3y+Fqsyl7fdteP1xDTQcGQPz1u3mXSu5NxoqGA7nkTmWv8nKlwYCRgHt5EWqxpuTHXnCrvbsNYnZ8bZhRxK9w4LZ8/vUnzxm/dL65Q5VtvWeGdfOWgReDbYpjTDMy4LYKSTOXKAk7GEI2QGRD0hrr1vA8IeEMBrteR4PrJwv3CQcX2ftCYldW6CngW3dLeM4w7n1mPHz61Dq94SJtgWJ1TJm+6jbiwgh2P6gJKbzQU1A0TIvIHO5dOozz0ohQS+rCSQuWAPq6aC1OoWG+IN7Z24RP3LcdPntugb59waV1z4qFigulAIu1Jo9Y9VFkhlLcWFLLuucFs1WOLEPNOfPZXr7n6PYVyDXi85FCxc1OwsW/Qe8jfpn3OYq6ZIuJ2IWjv0aornnrIRDx0xQmW21S7vOEw9g9ogni+/lJ8Uq+bEByRxr5uk7f1HIBw0FHZXz6URCScdUBAYAfch2FpY7EE7sLrTacHK+v/vrpNfzy1YWQfKmBkjlZfXCz8UzTkr9KDZRpwZmlXFMWVEsKswNGQsxLTfA6HyDi650gwvNRtDyKRHCqtEax4GPiww0iC6U2a5317l3g41mCe9Zat/+bG6IC7ewJf+OLWDx+Wd1ujCIrYGto9pF3bjqqKuvS8Dwp73g2vgcg8EM6hcqm48RX+7CIvGrNr53AyI8X7YWY75119/v0Oz99n9gpPqa9ES10FAPdVa61Yk80JPLS1tuC2boqG9Avm67ld16wghcoBRgM3TqHKeqj+782dI7Z3453YtK8fr2/VikHkuxlUR0O6Jb7Tg9XYXCp1Opc/41YhzIfZalapJx8bx8rN7xHpQ1UVdWnBS2f0OPNCN2q9CqNLhSqdUXH179+0fK+ltiL3eXaxc5v0/p9PvA9AW9jsvBRe8s4AI6ywyZSTxRMOBvRFrcdFHpVIyB/AWT8FBA9RRYcJDhnBRF4R4RPwFv/dWyCpGjBC/va5DPkzC0NtDZWW25lzUkVDTEXCygBekHKX4yZarUzkGnXSj9A8BhPgRX6PkUPlbxiWmyp/gLs11GkkwdTsPNzlomVHvrmpe6gsFCo3QjVbD//x1ZMxp6Um77ZuPVTv7O4FoBWoKoTbcvPCHqrs+pnKqELylOscKsH1RpcJ86ydVZGgLl8xw6JM+HBVGWkabN2pjoaw9OuL8Oz1p+khrDLzjFbv7AYALGirL7httQv5w23IXzI9ModMFFKoCpBMZ4xS35UhvXRpMq1iY0cfNu0baeFyc1J+/PQ6/XE0T8ifoiiGkONBoUroifza75kxoQrfOGceAOCAx0aEVpgXLLb493LlwN0sCv0uqvyJCmv8zaNgUYqgtyp/7+7uxfvtfZbvTa6vAG8Ma84qWG7ym/576Sb9cWtdhe12XvLOAKNkbL4xAD6PyoVCpcdkO1vO3NwchENJOGFYRJBiAoHzohTuS74WqlIFAJNYHsBAXCgxmGEWiu1CoczfLTrfmKfJ7+MmmgvipnS6Uy8LIxRQXIVIOQn55DHCvTJCBV1E8tv4liFe8gILHTs25we4XBin5LtPMQHUqueeaPU9wLhG7Qof8Bjln8XGYR6DI7JVd/PBjqt4KLOgh8rl+jkomkPlsspfT4GS6YAmq7E+cgcG5MtUfP9OGYoOKxjWUBXG9KaqHFlHRt82BjNisKId+dDPj8D9YFAgagnIlem8ehJJoSoAH4JUHQ3lhGAsvvNFrNjSNeIzGVU8qZo35BaqtqOH4XhIFNcVKm6sjx09BQBwYDDhuYogoIVKLvrh8zjs1ifxL5NLmi1E/O8WDfcaTqZ165UTD5XbPlTsIgsohePMox49VMxLd9jkWjxw6XE579XHIjk3mlYPHqpd3Ua/sXzCh5cwSVVV8fIGLbb7hJlNebd1q+wChkfYSQ4AwAkeIlYvgQp/gKY4sP0RydMxPFRiIX9uSr46UajqszH0GdUwXojAn88vnjrLdruUqc+VyFrAV2AUL0rh/NykM6puxRUtzy5y/egFPBwqbaFgwFXVwgHh0BjjN4sIViIeqlCQ6xHm4h7EDDKF7gf8+6KGPN4DNGtiFb7/8SP052HdQzVyLRIVeoeTaf0+XRcrrFDFXEZg7OxmAm5VwW1ZrnIinRGSEUQ9VDnrp4tcVzdV/kRCC/UeVAXmWWNV1iDlQx7Vrm7DQyVDodrYoRlyD5k00lPJ+rZ5VTgyGVVv15IvDYDhRi7oF2htAZj6ErowevCQQlUAduFURYIIBQOWrnwrRMP+WuuMUJhCmjXzUJmrtDkllc7g8VW7AADNnOegqSqCpqoIVFXrf+GVf73fga37BzGQSOO2v76T895BkzTrxClcZbl8zWut4C8yJwu1274GfH6GXbw0g90E0hnVVYGFA9mFt7EqgqOmNeS8V1uRq9CzEEA3FRL57u1nHdZsu50XRWdffxwdfXEEFODYGQ15t/XSsDqu928T9VCJVw4SKdhiVMQSt675XfI1mc7on8mnUEVCAT3E2I33kB23gALcnPWAW2F2EogIhcPJjNHrzEdFlN/WuYdK3KLPtnUa8hcKKEZitYvf41Q5rAgHdA+5UNUtQa8eU+K7BYXQgXhKV8Sba/N7xKMhIxxL1FDAK8f3X3IcpjUZ4fL5PFSiwiiTPQIKUO2oybe4NzSeMpS2fN4WRnUkpM8BEaOHqGcXcLe2ibadYNenqoodNz2HqsAxa4gxD5V8hYrPa5WRo7V+rxZNwhenYsgK+esbTuke4XoHRgI3OdwDuodKYK6F3RkjzJBCVQDzheMkSRgQD/liF3NrXQXmFUjWq/FYjOC3y7fpcdNHtRmCrqIoelzrapdV93jylaRlwsKP/22B/pqoh4oP93NyXlz3thAI9+ILI7jJpWNVnRpiEdSYxqurDOcoHGxOupkHm7Ohqo99aaEuwFjh1qsHAJ19hnJYSDg0+s+IL2huc6iErOyCIWX8OGKFAgRDCyPueh3xuWo1BcKJ2HrjpmAI+8yEPDl0VvQLFKUQrcAIuGu8zHuqnVSU5McRMXoYIX/OxggFA65K/xr5Js6OmaIouodcLAxLbE436pVsxRT4PdmQpZpoqOCcBgxvi1sD2+dPnI7pTVV6g3rAyDW08lCJrqF8WJmzQjji3lBegHSytgUCin5fEjGwiIZMA+4K7ogq7xWhoGEkEBCmWQ5VPmMU/74bYxRjMJHC/766bUR+MZ9z7rUpraqqeGWTFk0yr3WkQuVFDuBhBuNYJOjIYMTOo0gOVb+goUgbR44HjhSqAvSZmrcFC3goGKIhX8yKffnJMwtuq5f6dKlNP/ue0SyQ9YJisJsD687uBaa0mfn4UVP0x5NqKrAk6yER7UPUJ9DUF+CLUggqbgJeA17QcpNH1Z3NX2uIaTdR/ljVVoZzlDS3i1wmo+oeqik2RQIYvDAtWnWLLfhOhGm2uLrpP5MQaOwLuGuAaYSSOLd6uUkSN7yhYsohIHZTZTfnmopQwSakTDh146U0rIVirRhcWb8dVmAE3FX34hPeC3mqR47jX8hfOOjSQyVYGVHbJ3FFVNxDpc030TAplgPSUiBfk8HmpGhkhNnowQturM2AdQ6V2NrW7SAkl6fKxblhRslYJOi4GTFbD0SuUdFiOwBczmkxxS0QULgKduLrZ6HcNvZ+j4e89C/97k3c8vhafPPxtbjrmfV4v12Tq/iUD6+eo/f29GHzvgFUhAM4c97IiJVqD5EqPOyabshjxOUxQpn9Xdf0cFmPiikpVAXoHcqNyXa66IhWxRKpTuO1lDXbt6sWzdZvAIwFbXUAgD+/tct1ZS8G35SQMbelBj+4YH7Oa8YCLbbosNLKzt373iySTsYJBY3eM24UKn3BycYX37Bkjv5ebUUYh03WvJefOHqq69/TM5TUqxY2VeVXdtjNPJVRhRdtMYXKfcjfsMPO6ww3DTCNcrwurF5C1QTFBAK+15GIdc1J/hTDUKpdhPy5sBYCokpodu0UGMNb2Ke/YUuiRSnCgYArBVGvWCgQGuOu+IWgh6rKXa/FPdk2EOIKldv7gXHcnvjqKfjmufPw4fmTAWjnxIyo9Xtvr6YgNtc4+z0xFwZDpzlnPCwyolegIiu7zsQ8/G68ri4MXy4M1EbkUv7fw3Lflm3a76oNAAC8uH4fAOBvq3fjJ89twMW/WQFVVdHJXR9ei0VsyOZPzZ9Sb3mOqj1EKfB06/KNMyOBG6OxG2+o276RZkihKoA55M+pQrVdsAO7Ec/u3A3qxv2aSmewdb8W7vXZE6aNeJ8PX7j72fXC38/oGUxiR5d2g+PzpOa21Iyo9OU2pEikqS/g3qMjKhSy0DM3hSmYEMGECn7MinAA9372aHx9yRx85/zDXJeBZ9UhG2Lhgl6dyrDRXE+0pDlr6tuUp6kvI6qX0Rdf0EQqPQLu8lr6XSzS7qoJiilubnsduVOo3BSlEA+V1D4nEE7kQVhz0x9KLGxJ3MLK5mXUoUJVFwsbv0fEkitYKABwJ3iIKqLMmHRA0EPFGpUXyp9iuA35s8qfOXRyLb5wyix9PQ1aeagEhTVRj5sbZVekjyODFWIQCvkTLGcOiK+fqqq68oi78SL3OvRQsfV1+eb9+Nvbexx/P2O/RSXnvb1x9MVTOQZbrx6q7dkG13w+II/hofJWrbBrgEXgiHmohEL+BPOQAaPohtfjSApVAYyQv6yHymGoh7hC5dwq6ca1z9jbF0cyrSIcVDC5bmS4V0NVBLMnsqaH4l3kGev2ahaPKfWVuOQDM/TXW+tHjunaQ6WH/DkMieAsUSLWIuMCdV41BnCnUG3p1JTdiVmvDn9jUBQFMyZU4erTD0IsEtLngaiCyDyPZu+kFYqi6DcFUYVKyEPFcqhcHDORXmQAUBkWz2sRMXgwXOVQCZYXBtyFxjjpQcVwGxoFGMquqIfKTd8REau0US5Z3EPl1HMEGOdRTHHLOBrnOx89DEdPq8fViw7iequJW/Odhhby2zo9bql0Rl8HnSpuRg6VmELVPZhrjCoEu6eLFqXg+1LaEbbsQyU2DssJK9RygmEYCQQqoulGSWf3UMBdyJ9osR1A3AAaTxnFaUS81TEXeY5ODVJ8FcD/Xb7V8fczOmyihMz56V49K9uy38f3I+Vh99bfvbrdU9hft2jInwvngWixHYBC/kYNI+TPvijFpSfN0B8zD9a2/YIKlYAF3I1rn6EL09VR23yDb31E68je0es+5I8pYzMnVGE6Z/VYYNHroj67KHULxhnrgrTDC4dV3ElwFc6cIGr1iuoKldgit6t7CO+39yGgACfO0sqM8x5Rs3fUbcifiEIFGJZYUYVqn4BCxSr0ufFQiSrWhpV97IURiIZHAe6St8U8VCyx2k1RCvGQIkBsTrvxtBhNat2cG3HLp4iw1u8wlPnzC2fgT1edlPVQsX4tLopFCBw3UWMer+A5NRIwD1WX4P1A1PrtNi/ESbiXVSSLaDVWUQ+VG0MrC5t3eg8FjN8tEvLnxkMlen54eUjE6OGm1xFbCwtV+ePfd6ro89ilXVz2wOsAgGlZBag/nvKUosHktUIeKgD40VPrLLdxQteAmNFDN4KLGAlcrGsU8jdKGBeO9clprIrgug8egppoCE1VEVy1aDYAI/7ZKSKxv148VB3Z/conTE/KxmzzpbVFYRaUqQ2VmNpgXKRHTK0bsW2jyxAP0XCFWCSk5+rs73c+lhHu5WyRZh4q0Ryqtbu0nLNDJ9fqQgWP+cbqNoSRV6qd4NZDJRLyZ1T5Eztm6Ywq7KFy4zUQLRYB5PY4ER/H30IBLElaJOTPjWWyQ1B5Z/QLeMPchHjoDXdFhM/hXOOas3HElXcnTUPNuAlfE+3dBRi/x+k4TGkLBRTHfeIa9Waobj1Uzo6bbigQXNecFCSwamAter/Wc8IchjC6sbL3CxZ2AozfLRLy58bDL2ow5KN8nKZmAO48VE77UPEygNPiIjx8Jb9TD5mIQ5qrAWhhfwBw0kFGf8erH3pT+PsZTC5stYhaAnLTKsw9RUU4kL3vOCmZDrjrg+km7NPNvdoKUqgKoFujLBbPWz58KP7x1ZNRWxHGv25YhBe+vghHZsuOi1oLhgQsOEYpSRceqv7CAs6k7HsHBpPCXhYG6+Ld1hhDRTiIBy87Hv/9+WMwxSLkT7dICpbJdZNQy4ow7B9wfn5EhVy3IX9sUTOHYt534dG45vSDsOiQiTmvG9abNDICJbOdzAEeryF/ThS3CpceKv4acKxQufBOuCmu4CrfxE1StYvQQhEPFdvGTS8VplBNKjDXmGDCBASRvMBBPUxS/NyIhC31CebqaeOI5wD0OCzJzFMdFQvDUlVVn5ciyrtoxUd+PjutjMjaOHQJzjdW0CdfG4jccdyta07CZcOWfajE7teuPVRCxRXE17VawZzKRCqjF0ES8VCJGnJEm68z3IT/Og2ZZv02te8Xl6WYHPmxo6bgt5cdjz9fdVJOTvoZc42KfCu2dLk2gheKWuHXvO1dg3h4xXZX45hzxAthGI2dHbt0RtVzXd0U2yEPlc+weGneKvnyTafjqWtPxeUnz9Q1+ok1UdRUhPXwpk6LZMJ8iAhSbJK56T1gXDj2i3R9LKxbEz927zJXYVg7DhgeKgA47ZCJOOuwFsttG/UbqNgxEy1KARjeEpGbta5Q+VyUwi6p+uwjWnHDkjkjBBJ+kRPJnRAO+XNpyXVTNl30mDGvgdaA1mmz1axA4MLq5SZkRSzXQLyIg5vQTxEvCMvhYDkdIuzrK+wRB4B/Xnsq7vnMUbjilFkABM+Nrhg4v4G6KQUv2qaB31Yk/0xE2XU7TiKdQSprhBERPPQwLIdzWrSMNWDcD0Qb+4oKa+z4dgusa6qqOgr3svKQiAjU6YyKvdl12s5rYMaNYUX0mAHiVf7cNMQGxNdP0fu0sU9iQnsyndHXp0LX6FHTGvChrNwjqrgDI+/VVdEQrjn9IADa8Tl9zkT8x9lz9e1//vwm4TEG4il9DbVbp8Mmj+t//GkNXtqwT3isA4JGD3EvpbGdyD1UVuNiUqgKYBUvPbUhhjktI5ufAcaE7OyPOy58kExn9FAnJzdrL32oWEPXfAKOoii64vHunt6cvlVO2amH/FnH5PI0VhuNHN0UixC5cNiNQyTkr09wHL0KkuACysJEC1nzGRVho2S2iEtcVKFiCpFdgqwVmYwqFvKnl00Xm9PmojFOYAKBiJDLFlqhaliCTR1VVXUVhlXrs9DOBLr39vQKeUIB3kOV38o+pb4SH1kwWVd03IR4uLGy98ed91czQkudKzrGHBBXdt0oVKKheIDhsfVjHDee3UY9h0pQodJ7+Dn1UDHFTWwdYA208xel8Bby19kfRzqjIhhQHK/TfMNyp02+DaOXc4WqRq/y52wOsLkSCQVGCOb5EA1p19snCBi9APEqf+y+FgwojubaBcdMBSAuDwDQKzLzhUlOmNWE31xyLP5yzUkIBQP40mmzce78VgDAA8u24uUNnUJjsDkQiwRt729WhWtueuxtYWM7U6gaRYtSODw3bA4EA4rjNiraOO6dFDykUBXAaXlMBhMek2nVsUWC387JzbpKD1cRU0C6BxP451qtdOdph0zIu+1VWSsIIF5gI5HKoD2rHLQ1FrausYsrkc4IxTGbmy47wQj5c36z7hGM+3UbIida9ldRFFfeCRYWMLHa2TjsHG4XmAe9w0ndAu5MoXLX2Fe0IAXgzuOmN/YVUnTYOM7OzXDSqFIlori5mW8iQvvkepZTGcfPX9joeAwA2JeN9Z9U60wodJOv5aYoBZsvaYH+am4KbLgxrohUYGSIlrZnAkokFLDM97GDzUunRgKjf5vz64aFgA8nM45DcIaTaX1ONzn0ttS78FCxMcJBRTcCWWFV8ElEWGPe4Ek1Ucf5QLzS6rQvEbsPOokiYNQKVuUddOFBBsSLUriZa4C4gZopII1VEUeNxOtchpaqqopVO7S86vmmYl5nzG3G7IlGOOFJsw157lcvbxYax4mB9ai2ehw+pTbntd09w9jY0S80lvscKmfnRr9PC4QYs+0B8lD5jmhVkmgoqN8IneZR9XAJjk4Wz8n1lYiEAugdTuHdPb2OxgA0xSiZVtFSW4Fjpjfm3fbC46dhbtYLt669z/EYgJZMm1G1andO8mcqI0GuWIRzL4i3kD/n4xwQLPXpNjZ/r6DwCXCd2AXGEvVQsUpCLIxTZIzaipCjUDy3RSlcCbmVLkLxXAntYp4jdjNQFON4OMFNFcZugRsbH3L0o6ed96brG07q3l2nRgI3BgI3ym5FOIBQdq11Og9Ei58AhlIkksDvxkPFcqhEE/iFhVzBUuMsd0ykNHtVJKiHnDv1UrF8o1gk6FhY09dpAU8YW9caqyKOBTaWTyUirO06INakGMht8u20Yh37PU0iClWlmKHITZEVQHyusf0RkQcAcQ+VSPVawF1oKQC09w6jsz+OUEDBYZNr8277iWOm6J6wlzd0CqU08Mq7HYqi4FvnHTbidZHia10DCX2+WeXSWyHqpcxX8yAfFPI3Cqiqqk9MJ1Z2BhNUnSpUTLipE9DaT5+jFSh4YZ3zONZOgWIEgYCCG86aAwBYv1dMoWINfac2VDq+6TCBq10gT0M0FA9wF/InInxq27nLAWD5JoXCo3hYqEaXw98zlEjrVqJmh4pbW1ahEulLxjyUTgUCt2XTd/eIHzM3VarcVJITDfdiN/RYOOjI8smoExRwVFXFzqxy7CQ/oyoa0ssQCxj9sKtbWwfqY2HhcNlEKuNYwHFTGVFRFGGF101RCjYH+uMpR+GSqqq68lCJ9gpjuTPCQq6gwtvFWfOdoiiKvn2HQ4GNzbXJ9c7vOWw9FxF02ThOBUIAmDVB8ySIJLyze+5BnBeiEG6afHf2Mw+Vm5A/Z8eN3WtFy4brc9rhXOvMGklZFIpTRKv8dfaJhUmyudI9mMSdTzsvOb6pQwv3m94U0yM47IiGgvjRJxdgXmstUhlVKL+JpYHMaKrKux2/HrF1eq9Aa52V2w4A0Ap1WFUxtkKvxuowjHW/i/kMUMjfqNA7lNLDlkQWA3Yy9zn0tri5gR42WSs/vi0bY+sEkZwWADikWfNQbd43gFTaueeACWttNk3irGCV7UQS3914J1g4iEjIn2gipZsQrGQ6o9/cnCo6gGFZdFq1kClFtRUhx7+nLZsH1zec0sMfC7FHr1DlTPBgArtoCXhWnn+awFxjQuRwMuOoimUildHL34oI7aLhXn0uPK7aOGLzrXswqQsPrGhMIVbeshgAoKrOC7owK7uI8FlTEdavZ/b5Qoiua4xqwVwQN+Gl7LeoqjPBsHvQCJV1asDhx3HqbWP3Jqf5muZxnCpUbE0TFXJZ70LW6LwQvELllLpKbb70DCUd39/0Oe0gN5gxc4ImqIpYv5lCZZerbUdMIOcknVH1SA13IX8OlWpmlBZUqAxvtbN1rcutMC3Y15PNaadtR/hQzHv+tdHxOs3ypwopOjzHTm8AALyz23nk0pZOLWxv5sT84/BK0BlzJwEQ81C9sbULAHDcjAbHn+ENmE6MRSzCScTjCpCHypZ7770XM2bMQEVFBU444QSsWLHC9XcxIbU66ixsicEq6ImG/IkoVCyvhXmDnCDqqp7aUInKcBCJdAZbBfJnWGhYm8BNpzWbp8FujE5wE4IjWuUvnkrrF1mDYA6VSLIz8x6GHCa6MthNqtOhh4op4DMmOF+kKyNBfc449VLtZQqVQ+WQFS/Z0jkglBfI8rqmOcjVY9REQ7qnxYlQwPrBREMBQSFXLNeAzX2nfWcYomFl7PqcVBMtaPlkxCIhXTFyGjfvRsgFjHXDaYjpnl53x60mKnZ+mGIs4qGKhoxwZieK9e7sXGuqijg+N4CxBsY55T8fnS77g+mhhQ6F6f0uBHYAmJX1zDDreSF26sq78znQWBVBLBKEqoorbk6MBKccPAGxSBCfOq4NgJaD6HRtW5dVqJhR0ynMWOTk/tbeO4yMqoUkCilUnNfViSLKlDZRDxVTWDp64468u/tdRBMBhqHUaWVmdj+YJLDe8Aa/rQ7nGttuuoBCxfKc1uzscfyZzdlxmCfVjgnVUdz5bwvwPxcdq8sPIoWq3sh6qI4tkG7CEw0FdRlnd3dh5W2/W+XdRcsBK8pKoXrkkUdw/fXX47bbbsObb76JBQsWYMmSJejocNeIzO0FyiwkToVcNwrVVEGhA+Ddoc4Wz0BA0RvJsaazTuBD/pzCblC7HSpUqqoaOVRR58etkRWlcLh4Mo9MQHEel+smlETPn6qJCoV7NQmW6d+2X9yjo22fVeAdC7liHqpZE6sQUDRvgUgYAbPiidx0AgEF1RHn3iPDKu08nAjgcrUchnvx44jAxnHqCWNzQOT6BIyeKpv2OVOomJAqYlgBxIxFqqpib482X0TyTQAxr04ildGNCU4K7fCIeBD3ZIWGVgHFANCUd9b/jgl8+dgn0COOhxmV9vYOO5rT+/qy95wasXvo7Ky13Olc25RV8gsJhTzBgIJDWzUB1KlFn603Tq6dBy49Hm/e8kEsnN2EWCSIzv441ji4jw4n07owPVfQQzU9u647MYBu62S/JSbUCLe2IqTnH7Y78FDs1/PQxeZaa30FggEF8VTGkeBuFItw5w11WnyLKfmzCnh0eH76maP0x1sdRhVtyM7pmROcr59HT9O8P69v7XKUPpFKZ3Rv6MHNha+djx89FR88tFmPKGLerUIMJ9N4e2c3AOC4Gc4VKsC41nY6kD30qpWChqJKwWqCdojFloxx7rzzTlxxxRW49NJLAQC/+MUv8I9//AO/+c1v8B//8R+Ov6d3OAlEktiwV5sswpaV7Mnc2NHnyGrMBA8WguAEJqTsPDCEzfv6HU0gdnMScYmfOLsJq3f24M9v7cJph0xE0KJhoZn3soUyREL+2LbLN+1Hz2ASSgFVf/v+QaQyKiJBMa+Bbu3oGUbPULJgTsimfezchB0rOiyf5709vXhvT68jAfn97DGbKGhlZ+dy874BR3NtRdbtPkfQ8tnWGMOb27uxemc3TuYaC9rxblZAmerQO1ERDmJGUxU2dw7gkvtX4A9XnFhwrg3EU/rNYF5r/qRdM7WVYfTFU9i6f6DgtcOuGyctAHjqKsNQFC3ca0NHf0Ehmd1oRULkAKA+u27s6RlG92Ci4DxdsUWbA4cWSHQ2c9Ckaixdvw8rtx3Qy/TmY9WObgDAEVPFxmFr29pdPQXndFd/AomslVwkjw4wDGUb9hZep9e39yGVUVEdDQmfn6kNlejoi+OtHd2Y1pR/DjHPhNPeQ4xgQMGc5hqs2dWDldsOFMxRWJ+9t4l6qGZOqEI0FMBAIo13dvdiegFhb3Mnu+eIjcPm5sptBxyt0yw/4xBBBeTwKXV4Y9sBLN+0H2fMm5R3WzUDvLJRK0k9f2pdwe8OBhQEA5qgtmjORDyxph3/eHtPweiANTt7kFE1w5yb8wM4m9NvZa/P6QXmpJlQMIBDmmvw7p5erNx2oGAeHpNvGqvE8vXCwQCm1Fdie9cg3m/vLVh0hq2fogZwZlzsGUpi54HBgr+HKQazBKI8FrTV49PHteHh13fgzW0HcPrc/HMtk1H1uXbUNOchcgc31+D4GY1YsbULD63Yji+cMjPv9u/v6cNwMoOqSBAzBYySR2dDC1ds6cLe3uGCRWfe2t6NZFrFxJqosEFqakMMq3f2YPXObpw4uynvtkzZFfVQsTXdTp52Gv1RNgpVIpHAypUrcfPNN+uvBQIBLF68GMuXL7f8TDweRzxuWD56ezUh8AN3/AuBqLHILDCVrCwE6xnw7HsdmP+tpx1/7ogphRdpRnNtFHNbavB+ex/O+PFSof1b0FbveNvF85rxy6WbsXT9Phz1nWeExhGxri05tAW3hd/B5s4BLPi282N24uwmodCYCdVaGdp0RsWC252Ps7DAhcxzzPQGzGmuwbq9fTj7Jy85/hyglScVgQn5S9fvE5prpx4yUWicuS21+At245dLN+OXS52VZVUU4LQ5zsf53InT8e2/v4v32/uE5trMCVXC3okTZjXiT2/uwmUPvOH4M6IenWgoiIWzmrBs034suftFx58TDZGb01KDCdURdPYncOS3nR+3E2Y6n9MAdG/1Yyt34rGVOx1/TnT9XDRnEn718hb8ceVO/NHhOBOqI7qHxvE4h0zCE2vacc+/NuKefzkrB39Ic7WQlxIATjl4It7c3o1bHl+LWx5f6+gzkwXnM6CF+6zZ1YPrH13t+DOiAnsoGMBhk2vx5vZunPezl30b5+hpDagIB9DRFxdap0UNRYvnNeOBZVvxyBs78MgbOxx9pjIcFDbgnHVoC55Y045fvrgZv3zR2fp5SHON8FxjeTC/Xb4Nv12+zdFnpgtGKwCaQvnunl587eFVjj8jaiQANGVne9cgLrn/dcefmSw4TiwSwqSaKDr64jj5v553/LlZAgVDAOD4mY14+PUdeHD5Njzo8NxUR0PCc+2CY6ZixdYu3PPcBtzz3AZHn5nXWisUGTN7YhVaaivQ3juME/7zOcefO25Gg/CcZvfde5/fhHsdNi4WNX621FXklaczcWfey7IJ+evs7EQ6nUZzc3PO683NzWhvb7f8zB133IG6ujr9r62tbcQ2k+sqcNWi2UL7cvbhrTjpIDFhZcHUOr3spRMURcE3zz1UqIABAHxkwWQhl+txMxpx3eJDhLxAigJcc/pBQgtOXSyM//z44UL5UJFQAJ87YZrj7QHNtfv1JXOEhK+aaAhXLTqo8IZZggEFP//c0VgwtU4PjXCCm7l25rxJOG/BZKHPHDu9QUh5B4CLFk7HBwSUSgC44OipjstlA8BlJ8/Ezy88WsgjHFCAzxw/8rotxFWLZguF2FaEA1hcwIJtxZWnzhJqMFhXGcYpDjyAPJFQAFctOggCUw1TGypx6sFiSvVHFkwRXteOn9EolFQNAB+Y3YQTZzlfo8JBBZ85XmwdAICzj2jRLfpOiEWCrsY5/6gpwl70c+eLXdMAcO4Rk/XiLk44YkodTp8jPqc/dvRUoRCx0+dMxOGTxdabinAQnz7O+bEOKMA5R7QI3w/dzLVLT5oh1KAW0NZpkbnWWBXB5Sfn9y5YcerBE4XWz7bGSnzyWPH188PzJ+ftw2Vm8bxJOOuw5sIbmjj7iBbH99BgQMElH5ghXMgD0OQip4QCCj5/4nThyCVN9nLubaoMB3Ht4oOFrjVAfF1rrIrgilNnCY2hKAq+97HDHeeVA1oO8sePci7jMs45olUoKuC8BZNxpot79ZcXzRY+p2YUVSQDfAyze/duTJkyBcuWLcPChQv112+88UYsXboUr7322ojPWHmo2trasG//AdTWalaBUEAR0tx5kukMnB7dcFAR1twZqbTRELQQolZcHqe/R1EgfMNhZDKqXuWqEAEFQk0pedIZ1XE3eS10w925Efk9pTDXnCS8M9zONZFjRnPNQGQdGOtzTVVVJNP+HzORcbwcM5G55uX6FJlrXu4FTueal+sTcD7XvFyfNNf8nWte54DTueZlDgA019wwWvdQwNk88DrXAOt50Nvbi4lNDejp6dF1AyvKJuRvwoQJCAaD2Lt3b87re/fuRUtLi+VnotEootGRFq1IKODpZsPwemKd4mWSijAavycQUBBxeXGL4GWxEmG0fs9ozTUZ10UhRuuYldtcK6d1QFEUREL+H7PRGofmmjtorolDc80dNNfEGa25BhR3HjiVe8om5C8SieCYY47Bc88Z8ZyZTAbPPfdcjseKIAiCIAiCIAhCFmXjoQKA66+/HhdffDGOPfZYHH/88bj77rsxMDCgV/0jCIIgCIIgCIKQSVkpVJ/61Kewb98+3HrrrWhvb8eRRx6JJ598ckShCjtYOhmr9kcQBEEQBEEQxPiE6QSFSk6UTVEKGWzevBmzZ4tVWSMIgiAIgiAIonzZtGkTZs2yr4hYVh4qrzQ2auVTt2/fjro6sTKvTjnuuOPw+uvOeyqM1TFoHHewSpI7duzIWy1GBjTXaJxyGqecfguNM7bHKaffQuOM7XHK6beU6zjPPvsspk2bpusIdpBCxREIaDU66urqfBN2g8Gg74L0aIxB43ijtra2LOZBuZ0bGmfsjlNOv4XGGdvjlNNvoXHG9jjl9FvKdRzmYGE6gh1lU+WvVLj66qvLYgwaZ+xDc43GKadxyum30Dhje5xy+i00ztgep5x+y3gfh3KoOHp7e1FXV1eweRdBuIXmGEEQBEEQRGngVG4jDxVHNBrFbbfdZtnslyBkQHOMIAiCIAiiNHAqt5GHiiAIgiAIgiAIwiXkoSIIgiAIgiAIgnAJKVQEQRAEQRAEQRAuIYWKIAiCIAiCIAjCJaRQEQRBEARBEARBuIQUKoIgCIIgCIIgCJeQQkUQBEEQBEEQBOESUqgIgiAIgiAIgiBcQgoVQRAEQRAEQRCES0ihIgiCIAiCIAiCcAkpVARBEARBEARBEC4hhYogCIIgCIIgCMIlpFARBEEQBEEQBEG4hBQqgiAIgiAIgiAIl5BCRRAEQRAEQRAE4RJSqAiCIAiCIAiCIFxCChVBEARBEARBEIRLSKEiCIIgCIIgCIJwCSlUBEEQBEEQBEEQLgkVewfGEplMBrt370ZNTQ0URSn27hAEQRAEQRAEUSRUVUVfXx8mT56MQMDeD0UKFcfu3bvR1tZW7N0gCIIgCIIgCGKMsGPHDkydOtX2fVKoOGpqagBoB622trbIe0MQBEEQBEEQRLHo7e1FW1ubriPYUTYK1X333Yf77rsPW7duBQAcdthhuPXWW3H22Wc7/g4W5ldbW0sKFUEQBEEQBEEQBVOByqYoxdSpU/H9738fK1euxBtvvIEzzjgDH/3oR/HOO+8Ue9cIgiAIgiAIgihTFFVV1WLvhF80Njbihz/8IS6//HJH2/f29qKurg49PT3koSIIgiAIgiCIcYxT3aBsQv540uk0/vjHP2JgYAALFy603S4ejyMej+vPe3t7R2P3CIIgCIIgCKL8Wf5zoONd4LSbgPryLfxWVgrVmjVrsHDhQgwPD6O6uhp//vOfceihh9puf8cdd+D2228XHiedTiOZTHrZVYLwlXA4jGAwWOzdIAiCIAhivDLYBTx1s/a4dgpw+s3F3R8fKauQv0Qige3bt6OnpwePPfYYfvWrX2Hp0qW2SpWVh6qtrc3WraeqKtrb29Hd3e3XTyAIadTX16OlpYV6qhEEQRAEMfr07gbunKc9/sBXgbO+U9z9ccG4DPmLRCI46KCDAADHHHMMXn/9dfzkJz/BL3/5S8vto9EootGo4+9nytSkSZMQi8VIUCXGJKqqYnBwEB0dHQCA1tbWIu8RQRAEQRDjDjVj/bgMKSuFykwmk8nxQHkhnU7rylRTU5OU7yQIv6isrAQAdHR0YNKkSRT+RxAEQRDE6JKjUJVNQJwlZaNQ3XzzzTj77LMxbdo09PX14aGHHsILL7yAp556Ssr3s5ypWCwm5fsIwm/YXE0mk6RQEQRBEAQxuvBKlJou3n6MAmWjUHV0dOCiiy7Cnj17UFdXh/nz5+Opp57CBz/4QanjUJgfUSrQXCUIgiAIomhQyF/p8etf/7rYu0AQBEEQBEEQBJCrRGXK20MVKPYOEOXHCy+8AEVRhKohfutb38KRRx7p2z4pioLHH3/ct+8nCIIgCIIgOHJC/srbQ0UKFSGdD3zgA3ropVNuuOEGPPfcc/rzSy65BOeff77w2HaK2Z49e3D22WcLf99o47diSRAEQRAEMSrkhPyVt4eqbEL+CDkkEglEIhFP3xGJRNDS0iL0merqalRXV3saNx+i+yMbGceVIAiCIAiiZBhHOVTkoSpzFi1ahGuuuQbXXHMN6urqMGHCBNxyyy1g/ZxnzJiB73znO7joootQW1uLK6+8EgDw8ssv45RTTkFlZSXa2trw1a9+FQMDA/r3xuNx3HTTTWhra0M0GsVBBx2k57GZQ/4eeOAB1NfX4/HHH8fBBx+MiooKLFmyBDt27NC/j/fMfOtb38KDDz6Iv/zlL1AUBYqi4IUXXgAA3HTTTTjkkEMQi8Uwa9Ys3HLLLXoFxgceeAC33347Vq9erX/ugQceADAy5G/NmjU444wzUFlZiaamJlx55ZXo7+/X32cesh/96EdobW1FU1MTrr76an2sQtgdV7f7393djS984QuYOHEiamtrccYZZ2D16tWO9oUgCIIgCGLUycmhKm+FijxUblFVIDlYnLHDMUCggtuDDz6Iyy+/HCtWrMAbb7yBK6+8EtOmTcMVV1wBAPjRj36EW2+9FbfddhsAYNOmTfjQhz6E7373u/jNb36Dffv26UrZ/fffDwC46KKLsHz5ctxzzz1YsGABtmzZgs7OTtt9GBwcxPe+9z389re/RSQSwVVXXYVPf/rTeOWVV0Zse8MNN+C9995Db2+vPl5jYyMAoKamBg888AAmT56MNWvW4IorrkBNTQ1uvPFGfOpTn8LatWvx5JNP4tlnnwUAy7DDgYEBLFmyBAsXLsTrr7+Ojo4OfOELX8A111yjKzAA8Pzzz6O1tRXPP/88Nm7ciE996lM48sgj9eNWCPNx9bL/n/zkJ1FZWYl//vOfqKurwy9/+UuceeaZWL9+vX5sCIIgCIIgxgzjyENFCpVbkoPAf04uztj/bzcQqXK8eVtbG+666y4oioI5c+ZgzZo1uOuuu3TF4IwzzsC///u/69t/4QtfwIUXXohrr70WAHDwwQfjnnvuwWmnnYb77rsP27dvx6OPPopnnnkGixcvBgDMmjUr7z4kk0n87Gc/wwknnABAU/LmzZuHFStW4Pjjj8/Ztrq6GpWVlYjH4yNC9b75zW/qj2fMmIEbbrgBDz/8MG688UZUVlaiuroaoVAob4jfQw89hOHhYfz2t79FVZV2HH/2s5/hvPPOw3/913+hubkZANDQ0ICf/exnCAaDmDt3Ls4991w899xzjhUq83F1u/8vv/wyVqxYgY6ODkSjUQCasvb444/jscce071fBEEQBEEQYwbKoSLKiRNPPDGnJ9HChQvx4x//GOm0NrmPPfbYnO1Xr16Nt99+G7///e/111RVRSaTwZYtW7BmzRoEg0GcdtppjvchFArhuOOO05/PnTsX9fX1eO+990YoVPl45JFHcM8992DTpk3o7+9HKpVCbW2t488DwHvvvYcFCxboyhQAnHTSSchkMli3bp2uUB122GE5DXFbW1uxZs0ax+OYj6vb/V+9ejX6+/vR1NSU8/rQ0BA2bdrkeH8IgiAIgiBGDfJQEQUJxzRPUbHGlgivWABAf38/vvjFL+KrX/3qiG2nTZuGjRs3Sh3fKcuXL8eFF16I22+/HUuWLEFdXR0efvhh/PjHP/ZlvHA4nPNcURRkBGKAzcfV7f739/ejtbVVzyPjqa+vd7w/BEEQBEEQo8Y46kNFCpVbFEUo7K6YvPbaaznPX331VRx88ME53heeo48+Gu+++y4OOuggy/ePOOIIZDIZLF26VA/5K0QqlcIbb7yhe6PWrVuH7u5uzJs3z3L7SCSie9AYy5Ytw/Tp0/GNb3xDf23btm0FP2dm3rx5eOCBBzAwMKArPa+88goCgQDmzJnj6Pe4we3+H3300Whvb0coFMKMGTN82z+CIAiCIAhpUB8qopzYvn07rr/+eqxbtw5/+MMf8NOf/hRf+9rXbLe/6aabsGzZMlxzzTVYtWoVNmzYgL/85S+45pprAGi5PxdffDEuu+wyPP7449iyZQteeOEFPProo7bfGQ6H8ZWvfAWvvfYaVq5ciUsuuQQnnniibbjfjBkz8Pbbb2PdunXo7OxEMpnEwQcfjO3bt+Phhx/Gpk2bcM899+DPf/7ziM9t2bIFq1atQmdnJ+Lx+IjvvvDCC1FRUYGLL74Ya9euxfPPP4+vfOUr+PznP6+H+/mB2/1fvHgxFi5ciPPPPx9PP/00tm7dimXLluEb3/gG3njjDd/2lyAIgiAIwj2kUBFlxEUXXYShoSEcf/zxuPrqq/G1r30tbyGD+fPnY+nSpVi/fj1OOeUUHHXUUbj11lsxebJRhOO+++7DBRdcgKuuugpz587FFVdckVNW3UwsFsNNN92Ez372szjppJNQXV2NRx55xHb7K664AnPmzMGxxx6LiRMn4pVXXsFHPvIRXHfddbjmmmtw5JFHYtmyZbjllltyPveJT3wCH/rQh3D66adj4sSJ+MMf/mC5L0899RS6urpw3HHH4YILLsCZZ56Jn/3sZ/kOo2fc7r+iKHjiiSdw6qmn4tJLL8UhhxyCT3/609i2bZuvCiBBEARBEIRrxlEOlaKqvD9ufNPb24u6ujr09PSMKBQwPDyMLVu2YObMmaioqCjSHoqzaNEiHHnkkbj77ruLtg8PPPAArr32Wr0vFTE6lOqcJQiCIAiiDNj+KvCbJdrjQz4EfNbekD5Wyacb8JCHiiAIgiAIgiAIuYyjohSkUBGEIC+99BKqq6tt/wiCIAiCIMY94yjkj6r8lTlWpbZHm0suuQSXXHJJsXdDGsceeyxWrVpV7N0gCIIgCIIYu1BjX4Ig7KisrLQtKU8QBEEQBEFgXHmoKOSPIAiCIAiCIAi55ORQkUJFcFBRRKJUoLlKEARBEETRIA8VYSYcDgMABgcHi7wnBOEMNlfZ3CUIgiAIghg1eMMu5VARABAMBlFfX4+Ojg4AWnNYRVGKvFcEMRJVVTE4OIiOjg7U19cjGAwWe5cIgiAIghhvjCMPFSlUArS0tACArlQRxFimvr5en7MEQRAEQRCjyjjqQ0UKlQCKoqC1tRWTJk1CMpks9u4QhC3hcJg8UwRBEARBFI+ckD/yUBEmgsEgCasEQRAEQRAEYcc46kNFRSkIgiAIgiAIgpBLjkJV3pWHSaEiCIIgCIIgCEIuvEK1dy3wpy8Ce1YXb398hBQqgiAIgiAIgiDkYs6bevth4JnbirMvPkMKFUEQBEEQBEEQcrEqRDGwb/T3YxQghYogCIIgCIIgCLlY5U2VaS4VKVQEQRAEQRAEQcilzEul85SNQnXHHXfguOOOQ01NDSZNmoTzzz8f69atK/ZuEQRBEARBEMT4w0qhUpTR349RoGwUqqVLl+Lqq6/Gq6++imeeeQbJZBJnnXUWBgYGir1rBEEQBEEQBDG+sFKoyjTkr2wa+z755JM5zx944AFMmjQJK1euxKmnnlqkvSIIgiAIgiCIcYhlyB8pVCVFT08PAKCxsdF2m3g8jng8rj/v7e31fb8IgiAIgiAIouyxUqgyqdHfj1GgbEL+eDKZDK699lqcdNJJOPzww223u+OOO1BXV6f/tbW1jeJeEgRBEARBEES5YuGNSidHfzdGgbJUqK6++mqsXbsWDz/8cN7tbr75ZvT09Oh/O3bsGKU9JAiCIAiCIIgyxspDVaYKVdmF/F1zzTX4+9//jhdffBFTp07Nu200GkU0Gh2lPSMIgiAIgiCIcYKlQpUY/f0YBcpGoVJVFV/5ylfw5z//GS+88AJmzpxZ7F0iCIIgCIIgiPGJVUU/UqjGNldffTUeeugh/OUvf0FNTQ3a29sBAHV1daisrCzy3hEEQRAEQRDEOIKKUpQe9913H3p6erBo0SK0trbqf4888kixd40gCIIgCIIgxhcU8ld6qGXaKIwgCIIgCIIgSg47hUpVAUUZ/f3xkbLxUBEEQRAEQRAEMUawbOyLsgz7I4WKIAiCIAiCIAi52ClUZVg6nRQqgiAIgiAIgiDkYqtQlV8eFSlUBEEQBEEQBEHIhTxUBEEQBEEQBEEQLiEPFUEQBEEQBEEQhEvsCnBnyENFEARBEARBEASRHwr5IwiCIAiCIAiCcAmF/BEEQRAEQRAEQbjETqHa8tLo7scoQAoVQRAEQRAEQRBysVOo1jw6uvsxCoSKvQMEQRAEQRAEQZQZTKGafhKw4DNA9zbgxR8CgfJTP8hDRRAEQRAEQRCEXJhC1XokcPTngclHac8z6aLtkl+QQkUQBEEQBEEQhFyYQqUo2f/B7OukUBEEQRAEQRAEQeRHV6iy6kYgq1CRh4ogCIIgCIIgCKIAarazL1Oo2H+7YhUlDClUBEEQBEEQBEHIhTxUBEEQBEEQBEEQLjErVOShIgiCIAiCIAiCcAoL+aOiFARBEARBEARBEGJQyB9BEARBEARBEIRLRoT8kYeKIAiCIAiCIAjCGSM8VNn/GcqhIgiCIAiCIAiCyA819iUIgiAIgiAIgnAJ5VARBEEQBEEQBEG4ZERjX/JQEQRBEIQ/bH8V+L8rgPVPFXtPCIIgCBmoKrDq99pj6kNFEARBED7z+FXAmkeBRy8u9p4QBEEQMmhfYzyOTdD+6yF/pFARBEEQhFy6Nmn/U0PF3Q+CIAhCDmxdB4AjLtD+6x4qCvkjCIIgCIIgCIKwp2uL9n/+p4BQVHtMRSkIgiAIgiAIgiAKkEkDz92uPW6YYbxORSlKgxdffBHnnXceJk+eDEVR8Pjjjxd7lwiCIIh8JLkwv1BF8faDIAiCkMPON4zHzYcZj8lDVRoMDAxgwYIFuPfee4u9KwRBEIQThrqNx6RQEQRBlD6JfuPx3A8bj8vYQxUq9g7I5Oyzz8bZZ59d7N0gCIIgnDJ0wHjMepYQBEEQpUs6qf2ffLThlQJyH2cyQKB8/DplpVCJEo/HEY/H9ee9vb1F3JtxzJv/C2xbBpx8HTDxkGLvDUEQo8k7fzYel2FvEoIgiHFHOqH9D0ZyX1c4BUrNoJwC5crnl7jgjjvuQF1dnf7X1tZW7F0af6RTwF+vAVY/BLx8V7H3hiCI0WbtY8bjMgwDIQiCGHdksh6qYDj39RyFqrzW+3GtUN18883o6enR/3bs2FHsXRp/MCsGAAz3FG8/CIIoDvwNtgwTlQmCIMYdLOTP7KHKCfkrr/V+XIf8RaNRRKPRYu/G+CaT4p5Q/gRBjDv4NaDMLJYEQRDjEj3kz+yh4hSqMlvvx7WHihgD5ChUBEGMO3grZZlZLAmCIMYldgoVeahKg/7+fmzcuFF/vmXLFqxatQqNjY2YNm1aEfeMsIW5hYGyu7gIgnBAznWvapX+FKVou0MQBEF4JJ01lo8oSsF7qMqrCFFZKVRvvPEGTj/9dP359ddfDwC4+OKL8cADDxRpr4i8ZJLWjwmCGB+YvdSZNBAsq1sTQRDE+MKuyh95qEqDRYsWQaU+JqUF76FKk0JFEOMOs0KlplFmtyaCIIjxBVOoAqa1XFEAKNCiEcpLoaIcKqK48MIUX/GPIIjxgdlKWWZhIARBEGOe3W8Bf7pS6wvY3wH87VrgxR+5/z67Kn+AUdm1zNZ6MgMSxYU8VAQxvrEK+SMIgiBGj2dvBzY/D7z9CHDWd4GV92uvH/4JoHGm+Pdl8ihUgSCQTpfdWk8eKqK4ZEihIohxjWXIH0EQBDFqpOLG464txuN4r7vvs6vyBxiFKcpsrSeFiiguaQr5I4hxjfmmWmZWS4IgiDEP32C9c73xmFe0RNBD/iwUKlaYoszWegr5I0aX5DDw3O1A3x7t+T7uwiWFiiDGF6pq4aEqr7h6giCIMQ8vf219yXicHPL2fZY5VMxDVV5rPSlUxOiy6Tng1Z9bv0dNfglifGF1Qy0zqyVBEMSYx65tTWrY3ffl9VBlvWFlttZTyB8xugzs0/43Hw5MW5j7HnmoCGJ8YWVEKbO4eoIgiDGPXQ67Z4Uqn4eqvNZ6UqiI0WXogPa/ZT4w+ajc90ihIojxhZVCVWZWS4IgiDGPnfyVdKtQsT5U4yeHihQqYnQZ6tb+V9YDoYrc96jKH0GML3iFqkx7kxAEQYx5bD1UXnOorKr8ledaTwoVMboMd2v/K+qBcGXue6RQEcT4grdQBqPa/zILAyEIghjz2CpULqv8MWMZhfwRhE/keKiiue+lE1rVL4Igxgc5ClX2xpspL6slQRDEmMc25M+HKn96UYryWutJoSJGF95DFTJ5qKCWXUwtQRB5YFbMQMi4yZaZ1ZIgCGLMY6dQee5DZVFMvEw9VFQ2nXBGx/vAK3cD0z8AHH2Rs8/sWgm89ktg0qFA5wYgOQDsWa29V9lgXT0mnbC+AAmCKD94hUopz0RlgiCIMQ9bi5VgrqLjJocqOWT0srL0UJXnWk+SK+GMF38IrH0MWP0H4PALgEis8Gee+gawfbn1e/XTDG8Vj10vBIIgyg/+Jh4oT6slQRDEmId5qCpqjWrMgLsqf+ueMB5XN498nzxUxLjmwFbjcfd2YNJcB5/Zlvt8/qeAKccCjTO1z3euH/kZKkxBEOMHZqEkDxVBEERxUFVDoYqaFCo3faj2b9b+V00Eph438n3yUBHjGl6hOrClsEKVTgEDHbmvHflZYNYi47m5bDpAvagIYjzBLJQB8lARBEEUBV6xidbmvudGoTqwRft//BcBRRn5fpl6qKgoBZGfra8Aj10GDHYary39L2DpDzWrhqpq4YB/vET7+/OXtHyrtx8Z2bSzYWbu87CFQrVjhexfQBDEWCUnhyp746VKn87IpIFnbgOeuBGI9xV7bwiCKFV4Q3a0Jve91X8Qq8Y31A2s+r32uGGG9TZsrd/4nPPvLQHIQ0Xk55lbtOISPLvf0v4O+5j2/F/fzX0/EALa1+S+FqoAaqeMfM3M678CDjvf0y4TBFEiUFEK9+x4TSsUBABtxwNHXFDU3SEIokTJp1ABmgzYZhG6Z8WaPxqPmw+z3oat++/9DfjQHc6+twQghYrIz/5N2v/TbgIOWaJ5n569DRjYp/0xqiZq4Xxr/ggMdALxXu31D30fCMeAyUeOrN5npVD17fHjVxAEMRbJKZtenmEgvjHcyz3uKd5+EARR2vDRRFYKFS/rFYLJjJMOA5oPtd5m0X8Aj15kHQ5YwlDIH2HP0AGjEt9JXwOmHAMcdaFWoY+9z5IX66cBcz888vWZpwHHXAy0Lhj5/WGuD9Wcc7T/3dvJQk0Q4wW9KEWAPFSi8LkNbnvFEARBMA9VIJQrl004RPvPF6koBMufOu5y+20aZ2n/y2zdIoWKsOf1X2n/q5uBSJXxekW99n+4O7dRb2X29aEDhsW0ssH++0NR43H9dCAQ1i7stf9nvN7XDvz1q8CLP6LcCsLgzf8F/vxlYN+6Yu8J4YYV/wM8fjWwf6P2nDxU4uQoVC56xRDe6N8H/O1aI5+YIGSy+y3gT1cCax7zfyymUAUjuZFDrOS5VYsbK/r2Auuf1B7b5U8BQCirtLkpyT6GoZA/wp63fqf9j03IfV1XnLpzX2OKVs9OQM3kbmsFr2zVtACxJqC/HVj2U2D+v2mvr3wQePNB7fG884CJc4R/BlFmpJPAX6/RHqsZ4OO/LO7+EGIM9wJP3KA9bn9b+085VOIkOSWqzASTkuDth4GV92uPD/sYMOGg4u4PUV48fYvWHPftR4DDP+FveBxrVxMMA7Wtxut6NFK3s+9Z/ZDxeNI8++2YMb3MDEGkUBH2sBj9s76d+zrvoeJfY8pTckD7H4zmuo/NRGuAy5/RrNSHfhRomg088jlNIWN0bTIe799EChWRmy+S6C/efhDuiHO5PyyUJBDSwv4AwxhD5IcPl3FT2pjwBp9X4tSCTxBO6eb6ePbv1YzOfqErVBGt1Hl1ixbux7xNTuc3U7xajgBqJ9tvx+TCdEKrIBgoj2A5UqgIazIZ4yKaZKrUUshDZd4uH23Ha3+A0aNqqEsTmivqgK4txrYHtoz4ODEO8dp0kCguiQHjMVOOA0HyUInCW3fpOhh9+HWIDDuETDJpoJcr0HVgq88KFcuhCgPRai1XHgB2vKr9d5pDxdb2Qz6Ufzs+rDA1DERizvd1DEMKlRtWPwJs+hfwga8ALYf7O9aK/wG2vaJNwA981b5qiixe+yWw523ghC/ah+2xUL31/8x9LVoLKAHuc3nyp6yI1mjhhYOdwGOXaxf23neM95/6f8AJXy4ba4ZrOjcCL/1YK2N67GXF3pvRh1fkE4NF241xz8t3A12btYpN+ayRZniFinmrAiEArA8VeagcQR6q4uLHOvTm/2r3+5OuBSbNlfOdROmx9v+ATNJ4/sytxhpbPx0481Yj55Sx4dls/6dsPt+887RQwbzj/EnzQrG1JBjOfZ/JcGv+CHz03ty8dyuS2esgXEBBIoWKAKAln/75Su3xYCfwuf/Lv70XhrqBJ74O/QIBgI/9wr/xBruAf96YHTtrkQhVjAzbq5+u/e/ezr02TVN06qdp1hT2migthwObXwA2PmP9/u63gKnHiH9vOfHynVqs8uqHgPmfLpvFyDF8+EFywHYzwke6t2vtEwCgrg047evOP5u0ED6VINfYlzxUjqAcquLCr0MJCesQnxuaSQOf+B/v30mUJst+mvt8x2u5z2efAcw6Lfe1p/4f0MkVadrwLHDYx/PnXj12ae5z87ZM1gOA9U8Bh34k/36z6yBSnX+7YEgzomVSZWUMIoVKFH7h7PI5BG1wP3KUKZFeAK7Hy8Ka+ZrD+ACtxPkFvwEGsttXNQFzztUef/ZRYPNSTblipdBF+Oi9msWE78zdcjhw/9naY7+PQSnAFFZAU3zHm0KVYxkmhaoo8Neh6DVpdc4C3K2IQv6cQVX+igu/Dskw7PC5oZSTNb5heeQfvVfz2DODyZu/Bfau0XLLzQoVW4dPuUGLYEn0aa9VT7IeI50a+dqH/iv3+YyTgWgdEO/JzWe3Q1eoHMgkoUptH5Pls3aRQiUKH0vav1fzWPlVfcVcWUWkF4Cr8fjf1q79t8qDCobsXckT53grHFE3FTjuCyNfn3U6sPl5/49BKWBWqOqmFG1XikJO7gKF/BUF/hyIXpOWChUXvkIeKmdQH6riIttDxV9HfNNmYnwx3KPlkQNasS6+0e7+jVmFymTM53Pej78CWP0w0LtT285OobJqBj7z1NznigKc+CVg6X85cyCw6AO+zY4doaimUJXR2kUKlSg5i2g/8MdLgGMu0cJeXvoxMPXY/A3NhMYyCSq7VgKPXWbkGMz9MHDEBdrjVAJ49luaMLL4W/mr69lhVRpTNA/KL9h+uLHcpVPAc7drlpDFt1l3Avcblne38Gqgdb722v5N2pyZcrS1EmnFzjeA3l3G83KzZO56E3jtF8AhS+yV9pd+ZDy2EmT69gLPf0/Lz2mYAZxxK+XdyYZfKwrNwXgf8OztWoh0dTPQZFFeOhAy1rVMkXKohnuA576trQ9n3DIyR2GswYf5lZGVd8yybRnwxv1aBbOOd7UeiQw7w876p7X8k6MvAqomAq/cDUz/gPbcjMg1RZQn7zyezYOClk9ullUaZ2r/l90DnP4NIJzNRUr0GetnRb22Xe9O4JlbgEPPBxZeNXIsqzlm5Vli/aTWP6XJu5Eq4NQbgYbpI7dlxVnCDhQqJqOavetjQV5zSdkpVPfeey9++MMfor29HQsWLMBPf/pTHH/88fIGMCsd7z4OdG7QhGKW13LEBVqFOlljxZqMcDy+6e36p7UY2UAA2PA08Oq92uttxxdORrTC6gJzkwflB1aVBZ2y9UVtAQKA1gXA0Z+XtVfOSKeMvLuhLuDCP2qPX/mJtniu+r12vpwory/+KPe5m+Mxlnn6m1pS9tuPWMd/9+7RPMOM5MBIL/GbvzV6lwHAQR8EZpzk736PN/i1otAcfOdx4HUuH2SqxXocrjQ8LsXyUK39P6OZ+ewzgZmnFGc/nEIeqtHlr18F9m8A1jw68j27Kn+PXaq9t3MFMOVYYO1jwOo/AIdfMFJ4FbmmiPJDVYG/fc2YB82HjdymmSuCtv6fWv8zwJgvoQpNyWo+XOthteM17e+wj+X2l+I/w5hhs96xMfvbgXf+rD2uqAeWfG/ktsyw4Cjkj/WiMq1dxZbXPFBWZttHHnkE119/PW677Ta8+eabWLBgAZYsWYKOjg55g7DJXtkInP5N7XHXJq3aFUNWbhUby9xx+sxbtSTu5IAhXOb0a9oMV7ALrHEWcPYPgQ/fBZxlcdEUA6veV07Zzx0bJ3HAsuE9St07uH3hzhMfxpcPvjcFUH6WTL7QiVVuTpdpbmdSRslXxv6Nps8U4ZyXOyLWdPPxZ818eT70/eKXTS/2OiEK5VCNLvs35D4/+mIjRMqq0EoqYShaB7bmrvH8OscgD9X4ZuiAcd7P+RFw/s9HbjPjZE32BHLXK/Y5Jict+g/gvHuAqmy4n/m+CRgRUJFqTdb72C+t96t1vpYbf/YPgSM+OXJsHj2HyknIX9ZDZfaul9o6zFFWCtWdd96JK664ApdeeikOPfRQ/OIXv0AsFsNvfvMbeYOwRW/qscBJX9PKhKeGge2vGts4FY6djmVWqE66Tss1AozeTDL6NbGLcsYpwAlXaiW5qye6+y7ZePFQ8efD70IiluNzY3Zv1yxRgPh+qarxmSnZSoflZMnMpIE+rveG1TFhx5K3ppnD/tgxijXZfw/hDRFrOjv+TBAwV3WKNWnhIyzErlgeqmKvE6JQlb/Rwyrf5NhLtdxewDr0uGdH7vPdbxmPre7R/DWVGqYwzvEGW3NqWrU8KCbj8SgKcOKXtcf8HGJrMJOTKuuBYy422uxYzTf2mclHabJevlzsQ5ZoMuGCT2e/b6v1dqw4i6OQv2y4ovl+UGrrMEfZhPwlEgmsXLkSN998s/5aIBDA4sWLsXz5csvPxONxxOOGu7G3N5sI+ucvAbGI9UDM+l3ZAIQi2qTv3p4rBLz0Yy0U0CusB1MN56oNVWohfo0zNW/FM7dpFwKv0G18Vot1FaV9rfZ/rORN8bB92rJU/LftfMN4vPUld8fGC7xXKjkAPPp5LWeEVfIBtFLo7/01//ekk5olVAlocfy7VgJv/Q7Y9Ub+z5UKqYTmcWI8c8vI/kb71mv/mw4CdqwA0nHg8auMxRkA2tdo/2edroXYrH2MmkLLhhcOB/fnv6a2vqT9n32Gdi7MMCuqkrXvvf5rLd9wtNn2ivF47Z9GeoPHGnvXGo97d43+ujaeiFuE9DXMBCKva483W9yX+Kq5QK6MsPS/tLBmHra2MR67XJMxiPEBy8lrmJl/O2Zg3/CMMedYE2Cz7NYwE8ALwPKfa3IhD1NcRNJT2L51bbJeb+J92n9HHqrsPfvlu7U8Q0ax5TUrBhOFt0EZKVSdnZ1Ip9Nobm7Oeb25uRnvv/++5WfuuOMO3H777SPfeP/vQLRA5T6WW9R8xEj3ffvb1mEtbqmfro3Xvd0oldmc7de0cwWw07R9/14j1tXVeGMkb4qH9UPo2+Pttw3u9/Z5Gbz3t5Gvta8xFIFCTJgDNB2sPd73nvZXjph7b/A0H6YpWwe25DaYZgSjWs+MtY9p141ViA0hBzXt7Jo64pPWChXrK1eV9YbvWaX9FZOe7dpfqZAcLP66Np6ITdC8AMzg07sTeMd8I87D7rdyjRJWrPuH690jShir3Cmr963kPLPs1pLNf+p4R/uzgu81VYj6aUC0Viv4ZLfehCqdGeWZo8BKhmWMBXkNAOJq4W0AKKqqOttyjLN7925MmTIFy5Ytw8KFC/XXb7zxRixduhSvvTZSOLPyULW1taHnubtRW5WnSl4kBsz7CFBRq1kV3v+HFq405Wigc721NcstFbValZaeHcDWl7XeTjXNmrv2vb/mhnrUT9PCZry4SSvqtFKdvMV/LKCqmiLCV1YSobZVs5p0biy8rR+EK7WFcNdKI+QPyM6ZDYZlpxCKonleaicD7/7F+edKBUXRwmn3vG2faF9RBxx2vmZh27zUepvJRwJTj9Oukb691tsQ3og1ah76PQ6MRxMO0jxUG57V4vkr6jQv4961wLzztO8a2A+8/zfNU1ksJh6ilax2u86MNnVTtHXN7N0g5BMIaIUldr8FTDsRmDRPKzj03l+BgU7rzwRDwOSjtSiCTEYzHnS8b19mPVKlfe/OMok6IMQIRY31MB/rnx4ZdhcMAXPPy03TSMW1okBWIauAJufN+4h1exw7dr8F7Hjd/v0pR2v38EL079PWe6t+WMWW10z0Dgyh7sxr0dPTg9raWtvtykahSiQSiMVieOyxx3D++efrr1988cXo7u7GX/7yl4Lf0dvbi7q6uoIHjSAIgiAIgiCI8sapblA2RSkikQiOOeYYPPfcc/prmUwGzz33XI7HiiAIgiAIgiAIQhZlk0MFANdffz0uvvhiHHvssTj++ONx9913Y2BgAJdeemmxd40gCIIgCIIgiDKkrBSqT33qU9i3bx9uvfVWtLe348gjj8STTz45olCFHSz6Ua/2RxAEQRAEQRDEuITpBIUypMomh0oGmzdvxuzZs4u9GwRBEARBEARBjBE2bdqEWbNm2b5fVh4qrzQ2apVVtm/fjro6gdr8Ahx33HF4/fU8FVJKZAwaxx2skuSOHTt8L3xCc43GKadxyum30Dhje5xy+i00ztgep5x+S7mO8+yzz2LatGm6jmAHKVQcgYBWo6Ours43YTcYDPouSI/GGDSON2pra8tiHpTbuaFxxu445fRbaJyxPU45/RYaZ2yPU06/pVzHYQ4WpiPYUTZV/kqFq6++uizGoHHGPjTXaJxyGqecfguNM7bHKaffQuOM7XHK6beM93Eoh4qD+lARfkNzjCAIgiAIojQYd32oZBCNRnHbbbchGo0We1eIMoXmGEEQBEEQRGngVG4jDxVBEARBEARBEIRLyENFEARBEARBEAThElKoCIIgCIIgCIIgXEIKFUEQBEEQBEEQhEtIoSIIgiAIgiAIgnAJKVQEQRAEQRAEQRAuIYWKIAiCIAiCIAjCJaRQEQRBEARBEARBuIQUKoIgCIIgCIIgCJeQQkUQBEEQBEEQBOESUqgIgiAIgiAIgiBcQgoVQRAEQRAEQRCES0ihIgiCIAiCIAiCcAkpVARBEARBEARBEC4hhYogCIIgCIIgCMIlpFARBEEQBEEQBEG4hBQqgiAIgiAIgiAIl5BCRRAEQRAEQRAE4RJSqAiCIAiCIAiCIFxCChVBEARBEARBEIRLQsXegbFEJpPB7t27UVNTA0VRir07BEEQBEEQBEEUCVVV0dfXh8mTJyMQsPdDkULFsXv3brS1tRV7NwiCIAiCIAiCGCPs2LEDU6dOtX2fFCqOmpoaANpBq62tLfLeEARBEARBEARRLHp7e9HW1qbrCHaQQsXBwvxqa2tJoSIIgiAIgiAIomAqEBWlIAiCIAiCIAiCcAkpVCVIIp3Auq51SKQTxd4VgiAIgiAIghjXkEJVgvzkzZ/ggr9dgEufurTYu0IQBEEQBEEQ4xrKoSpBXtr1EgDg7X1vI56OIxqMFnmPCIIgCIIgCL9Ip9NIJpPF3o2yIxwOIxgMev4eUqhKkJ54j/54T/8ezKibUbydIQiCIAiCIHxBVVW0t7eju7u72LtSttTX16OlpcVTD1pSqEqModQQuoa79Oe7+neRQkUQBEEQBFGGMGVq0qRJiMVinoR+IhdVVTE4OIiOjg4AQGtrq+vvIoWqxNjTvyfn+a7+XUXaE4IgCIIgCMIv0um0rkw1NTUVe3fKksrKSgBAR0cHJk2a5Dr8j4pSlBj7h/fnPN/dv7tIe0IQBEEQBEH4BcuZisViRd6T8oYdXy85aqRQlRi9id6c56RQEQRBEARBlC8U5ucvMo4vKVQlRl+iL+f5rgEK+SMIgiAIgiCIYkEKVYnBFKoZtTMAkIeKIAiCIAiCKH+Gh4dxySWX4IgjjkAoFML5559vud0LL7yAo48+GtFoFAcddBAeeOAB3/eNFKoSgylUcxrnAAA6hzoxnBou5i4RBEEQBEEQhK+k02lUVlbiq1/9KhYvXmy5zZYtW3Duuefi9NNPx6pVq3DttdfiC1/4Ap566ilf940UqhKDKVRTq6ciFtKS6PYM7Mn3EYIgCIIgCIIYNRYtWoRrrrkG11xzDerq6jBhwgTccsstUFUVADBjxgx897vfxUUXXYTq6mpMnz4df/3rX7Fv3z589KMfRXV1NebPn4833nhD/86qqircd999uOKKK9DS0mI57i9+8QvMnDkTP/7xjzFv3jxcc801uOCCC3DXXXf5+ntJoSoxWFGK2mgtJldPBkBhfwRBEARBEOWOqqoYTA4W5Y8pQiI8+OCDCIVCWLFiBX7yk5/gzjvvxK9+9Sv9/bvuugsnnXQS3nrrLZx77rn4/Oc/j4suugif+9zn8Oabb2L27Nm46KKLhMZevnz5CO/VkiVLsHz5cuH9F4H6UJUYzENVE6nBlOop2Ni9kXpREQRBEARBlDlDqSGc8NAJRRn7tc++hlhYrHx7W1sb7rrrLiiKgjlz5mDNmjW46667cMUVVwAAzjnnHHzxi18EANx666247777cNxxx+GTn/wkAOCmm27CwoULsXfvXluPlJn29nY0NzfnvNbc3Ize3l4MDQ3pfadkQx6qEkNXqMI15KEiCIIgCIIgxiQnnnhiTknyhQsXYsOGDUin0wCA+fPn6+8xJeiII44Y8VpHR8do7K4nyENVYgymBgEAsXAMU6qnACCFiiAIgiAIotypDFXitc++VrSxZRMOh/XHTPGyei2TyTj+zpaWFuzduzfntb1796K2ttY37xRAClXJMZQaAqBNbKZQUS8qgiAIgiCI8kZRFOGwu2Ly2mu5yt+rr76Kgw8+GMFg0LcxFy5ciCeeeCLntWeeeQYLFy70bUyAQv5KDlYivTJUSSF/BEEQBEEQxJhk+/btuP7667Fu3Tr84Q9/wE9/+lN87Wtf8/Sd7777LlatWoWuri709PRg1apVWLVqlf7+l770JWzevBk33ngj3n//ffz85z/Ho48+iuuuu87jr8kPeahKDOahqghWYGJsIgCjF1VFqKKYu0YQBEEQBEEQAICLLroIQ0NDOP744xEMBvG1r30NV155pafvPOecc7Bt2zb9+VFHHQUAeiXAmTNn4h//+Aeuu+46/OQnP8HUqVPxq1/9CkuWLPE0biFIoSox9JC/cCVqI7WojdSiN9GLLT1bMK9pXpH3jiAIgiAIgiC0fKi7774b991334j3tm7dOuI1c3n0GTNmjHjN6nNmFi1ahLfeektoX71SMiF/M2bMgKIoI/6uvvpqANrBM7/3pS99qch7LZd0Jo14Og5AC/lTFAXzGjUl6v2u94u5awRBEARBEAQxLikZher111/Hnj179L9nnnkGAPRa9QBwxRVX5Gzzgx/8oFi76wtMmQK0kD8AmNs4FwDw7v53i7JPBEEQBEEQBDGeKZmQv4kTJ+Y8//73v4/Zs2fjtNNO01+LxWKOG3+VIqxkOgA9X4qF+ZGHiiAIgiAIghgLvPDCC8XehVGlZDxUPIlEAr/73e9w2WWX5TQM+/3vf48JEybg8MMPx80334zBwcE83wLE43H09vbm/I1l+JLpAUU7dSzkb92BdUhn0kXbN4IgCIIgCIIYj5SMh4rn8ccfR3d3Ny655BL9tc9+9rOYPn06Jk+ejLfffhs33XQT1q1bhz/96U+233PHHXfg9ttvH4U9lgNfMp0xvXY6KkOVGEoNYXPPZhzccHCxdo8gCIIgCIIgxh0lqVD9+te/xtlnn43Jkyfrr/FlGI844gi0trbizDPPxKZNmzB79mzL77n55ptx/fXX6897e3vR1tbm3457hC+ZzggGgjh60tF4ZfcrWLZ7GSlUBEEQBEEQZYS50h0hFxnHt+RC/rZt24Znn30WX/jCF/Jud8IJJwAANm7caLtNNBpFbW1tzt9Yhg/54zlpykkAgJd3vTzq+0QQBEEQBEHIJxwOA0DBFBbCG+z4suPthpLzUN1///2YNGkSzj333Lzbsa7Jra2to7BXo4OdQnXylJPxg9d/gJV7V2IwOYhYOFaM3SMIgiAIgiAkEQwGUV9fj46ODgBa8TW+dgDhDVVVMTg4iI6ODtTX1yMYDLr+rpJSqDKZDO6//35cfPHFCIWMXd+0aRMeeughnHPOOWhqasLbb7+N6667Dqeeeirmz59fxD2Wi55DFc5VqGbUzsCU6inY1b8Lr7e/jtPaTrP6OEEQBEEQBFFCsOrVTKki5FNfX++5SnhJKVTPPvsstm/fjssuuyzn9UgkgmeffRZ33303BgYG0NbWhk984hP45je/WaQ99QerHCoAUBQFJ085GY+sewQv73qZFCqCIAiCIIgyQFEUtLa2YtKkSUgmk8XenbIjHA578kwxSkqhOuussywTx9ra2rB06dIi7NHowvpQmUP+AOCkySfpCpWqquQSJgiCIAiCKBOCwaAUwZ/wh//P3nnHNXV+Yfy5WRD2kiW4wL33nrWOqq2j01lra7XaOlrb2vWz07a2tXZph9VOtctZ995bXEUEBEH2XtnJ/f1xcy8JJBAgEALn+/nwAZI73sz7Pu855zlOZ0rRmLFWQwUAfUL6QCKS4F7xPSQVJdX10AiCIAiCIAiiUUKCyonga6hcJa7l7nOXuqNnYE8A5PZHEARBEARBEHUFCSongo9QuUksu/iRfTpBEARBEARB1C0kqJyIilL+AM4+HQAupF8QolkEQRAEQRAEQdQeJKicCME23YqgivSJRKBbINR6NS5lXKrLoREEQRAEQRBEo4QElRMh2KZbqKECOGvNwU0HA6C0P4IgCIIgCIKoC0hQORGVpfwBVEdFEARBEARBEHUJCSonwhZB1TekL8SMGImFiUguSq6roREEQRAEQRBEo4QElRNhi6Dyknmha5OuAIBTKafqZFwEQRAEQRAE0VghQeVEVFZDxTMgdAAA4Hz6+VofE0EQBEEQBEE0ZkhQORGV9aHi6RPSBwBwMf0iDKyh1sdFEARBEARBEI0VElROhC0pfwDQyb8T5BI58tR5iMuPq4uhEQRBEARBEESjhASVE8H3oaos5U8qlqJ7YHcAXJNfgiAIgiAIgiBqBxJUToLeoIfGoAFQeYQKAHoE9gAA3Mi+UavjIgiCIAiCIIjGDAkqJ4FP9wNsE1Rt/doCAGLzYmttTARBEARBEATR2CFB5SSo9Fy6HwMGLmKXSrdv7dsaABBfEA+tQVurYyMIgiAIgiCIxgoJKidBqS21TGcYptLtQ91D4S51h86gw92Cu7U9PIIgCIIgCIJolJCgchIUOgUA29L9AIBhGET6RAIAYvMp7Y8gCIIgCIIgagMSVE6CrZbpprTxbQMAuJ13u1bGRBAEQRAEQRCNHRJUTgJfQ1UVQcVHqOLz42tlTARBEARBEATR2CFB5STwNVRVEVQtvFsAABILE2thRARBEARBEARBkKByEqqT8tfKuxUAILkwmZz+CIIgCIIgCKIWcBpBtWLFCjAMY/bTrl074X6VSoUFCxbA398fHh4emDJlCjIyMhw4YvtSVVMKAAh0C4RcIoeO1SGlKKW2hkYQBEEQBEEQjRanEVQA0LFjR6SlpQk/J0+eFO5bsmQJdu7ciT///BPHjh1DamoqJk+e7MDR2pcSbQkAwE3qZvM+IkaE5l7NAVDaH0EQBEEQBEHUBhJHD6AqSCQSBAcHl7u9oKAA69evx++//44RI0YAADZs2ID27dvj7Nmz6NevX10P1e4otFyEyl3qXqX9Wnq1xK3cW0goSMCw8GG1MDKCIAiCIAiCaLw4VYQqNjYWoaGhaNWqFaZNm4akpCQAwKVLl6DVajFy5Ehh23bt2qFZs2Y4c+aM1eOp1WoUFhaa/dRX+AiVu6RqgoqMKQiCIAiCIAii9nAaQdW3b19s3LgRe/fuxdq1a5GQkIDBgwejqKgI6enpkMlk8PHxMdsnKCgI6enpVo+5cuVKeHt7Cz/h4eG1/CiqT4nOKKiqGKFq4dUCAJBYkGjnEREEQRAEQRAE4TQpf2PHjhX+7tKlC/r27YvmzZvjjz/+gFxuu1GDKcuXL8fSpUuF/wsLC+utqKpODRVAESqCIAiCIAiCqE2cJkJVFh8fH7Rp0wZxcXEIDg6GRqNBfn6+2TYZGRkWa654XFxc4OXlZfZTX+FrqDykHlXaj49Q5apyUaAusPewCIIgCIIgCKJR47SCqri4GPHx8QgJCUHPnj0hlUpx6NAh4f6YmBgkJSWhf//+Dhyl/RBqqKqY8ucmdUOQWxAAIKEgwe7jIgiCIAiCIIjGjNMIqpdeegnHjh1DYmIiTp8+jUmTJkEsFuOJJ56At7c35syZg6VLl+LIkSO4dOkSZs+ejf79+zcIhz+g+il/AKX9EQRBEARBEERt4TQ1VPfu3cMTTzyBnJwcNGnSBIMGDcLZs2fRpEkTAMDq1ashEokwZcoUqNVqjB49Gt98842DR20/+Ma+VY1QAZx1+rm0cxShIgiCIAiCIAg74zSCavPmzRXe7+rqiq+//hpff/11HY2obqluyh9gEqEipz+CIAiCIAiCsCtOk/LX2CnSFAGouikFAET4RAAAYvJi7DomgiAIgiAIgmjskKByAtR6NdR6NQDAy6XqToSd/DtBxIiQUpyCLEWWvYdHEARBEARBEI0WElROAB+dYsBUK0LlIfNApE8kAOBq1lW7jo0gCIIgCIIgGjMkqJyAQk0hAE4YiZjqvWTdmnQDAERlRtlpVARBEARBEARBkKByAgrVnKDyklW/8XC3wG4AgCtZV+wxJIIgCIIgCIIgQILKKeBT/moiqHoG9QQA3Mi+gQJ1gV3GZS9YloXeoHf0MAiCIAiCIAiiypCgcgL4lL+aCKpQj1BEeEfAwBpwJvWMvYZWY65mXcXIv0Zi/NbxSC5MdvRwao3onGhM+3caHt7xMPYl7nP0cAiCIAiCIAg7QYKqjlHqlHjj5Bt44J8HsDZqLViWrXQfPkLlKfOs0bkHhw0GABy/d7xGx7EXeoMeb5x8A5mKTNwrvoePLnzk6CHVCjnKHMw7OA/Xsq8hJi8GLx17CS8ff7neRQoJgiAIgiCIqkOCqo758caP2B6/HclFyfjm6jf44NwHlYqqPFUeAMDbxbtG5x4SNgQAcDLlJAysoUbHsgdRWVFILEwU/j9+73iDi1IZWAPePPUmclW5aOHVAtPbT4eYEWNPwh48uO1BvHD4Bbx/9n3kKHMcPVSCIAiCIAiiGpCgqkMUWgU23doEAOgR2AMMGGyO2Yw/b/9Z4X45Km6yHSAPqNH5uwV2g4fUA3nqPNzIvlGjY9mDo8lHAQDjW43HoKaDwILFpphNDh2Tvfkz5k+cSDkBmUiGT4Z+glf6vIJfxv6CFl4tkKvKxZHkI9gcsxnLji+zKVpJEARBEARB1C9IUNUh/8T+gwJ1AZp5NsOPo3/Ekp5LAAA/XP+hwsl0tjIbQM0FlVQkRf/Q/gCAEyknanQse8ALqmHhwzC13VQAwLbYbVBoFY4blB3RGXT44cYPAIAlPZegrV9bAEDnJp3x54Q/sXrYaizusRgiRoQL6RdwO++2I4dLEARBEARBVAMSVHWE1qDFz//9DACY1XEWxCIxprafCrlEjrSSNMTlx1ndlxdU/nL/Go9jcFOujurEPccKqoSCBCQWJkIikmBg6EAMbDoQzb2ao0hbhJ3xOx06NntxKeMS0kvS4ePig0faPmJ2n6vEFSObj8ScznMwIHQAAOBs2llHDJMgCIIgCIKoASSo6og9CXuQVpIGf1d/PBT5EADAReyCHkE9AACnU09b3Zevr6lphAooNaa4mXNTEGqOgI9O9Q3uKzQsfqLdEwBQaQqks3Ak+QgAYHj4cLiIXaxu1y+kHwDgYsbFOhkXQRAEQRAEYT9IUNUBGr0G30R9AwCY0WGG2eS6fwiXgncmzbKVOcuyQg2Vv2vNI1QB8gB08O8AgDOncAQsy2JPwh4AXLofz/hW4yERSRCTF4O4POsRO2chKjMKAIQIlDX41yM2L7a2h0QQBEEQBEHYGRJUtYzeoMcnFz9BSnEKAuWBmNp+qtn9fE3TpfRL0Bq05fbPVmZDqVNCxIgQ7B5slzHxaX+1bZ9+JvUMpv07De+ffd/MVTAqKwrRudGQiWQY02KMcLu3izcGNR0EANidsLtWx1bbaPVaoSaqY0DHCrdt7dMaAJBSnIISbUmtj40gCIIgCIKwHySoapECdQEWHFogOPst7rkYconcbJvWPq3hKfWESq/Cnfw75Y6RUJAAAGjq0RQyscwu4+Lt08+knrEo4uxBjjIHLx59Edeyr2FzzGasvrQaAOd0+PH5jwEAEyImwMfVx2y/ca3GAeAElTO73sXlx0Fr0MJL5oUwj7AKt/Vx9UETeRMAQHx+fF0MjyAIgiAIgrATJKhqCbVejWcPPItTqacgl8ixasgqTIiYUG47hmEE97dbubfK3c/3aWrp3dJuY+vo3xG+Lr4o1hYLaWn2Zkf8DhRpi4T/N97ciGf2P4MJWyfgRs4NeMo8Ma/rvHL7DQ0bCjeJG1KKUxCVVTtjqwtu5twEALT3bw+GYSrdvrlXcwBAUlFSrY6LIAiCIAiCsC8kqGqJnfE7cTPnJrxdvPHL2F8wpuUYq9u282sHwLKg4iNULbxa2G1sYpEYA5sOBFB7bn/7EvcBAN7s9yYW91gMgHOxy1RmItQ9FGtHrrWYwiiXyDGy+UgAwL93/q2VsdUF/+X8B4ATr7bQzKsZADS4xsYEQRAEQRANHRJUtcTW2K0AgKc7PS1EoKzBC6ro3Ohy9yUUcoLKnhEqoDTtrzb6URVqCoXHMix8GOZ0noPN4zfjqU5P4b2B72HnpJ3o2qSr1f0faPkAAGB/4n7oDXq7j68u4CNUvOFEZYR7hgOgCBVBEARBEISzIXH0ABoimYpMXMu+BgAYHzG+0u15QRWTGwMDa4CIKdW5iQWJAOwvqAaEDoCIESEuPw6pxakI9Qi127EvpV+CgTWghVcLBLoFAuAiNbZGa/qG9IWXzAt56jxcybyCXsG97Da2ukCj15QaUtgaofLkIlQkqAiCIAiCIJwLilDVArx7XueAzjb1jmrl0woykQzF2mKkFKUIt6t0KqQWpwKwb8ofwDnq8VEie6f9nU8/DwDoHdy7WvtLRBLBTn3XnV32GladEZsfC51BBy+ZF5p6NLVpH0r5IwiCIAiCcE5IUNUCx5KPATDvsVQRUpEUkb6RAMzT/u4W3gULFl4yL/i5+tl9nNVN+zuZchIvHn1ReJxluZB+AQDQJ7hPtcc2ufVkAFwdVXpJerWP4wj4+qkO/h1sMqQASiNUeeo8FGoKa21sBEEQBEEQhH1xGkG1cuVK9O7dG56enggMDMTEiRMRExNjts2wYcPAMIzZz7x55Z3kahOlTomzaWcBcI51ttLerz0Ac2MKvn6qhXcLmyfmVYHvR3Uu7RxUOpVN+yQVJuGFwy9g/939WHRkkZDaxpOvykdMHve61CRVr0dgD3QP7A6VXoUXj71ol/5MLMuiSFNU+YY1pKqGFADgJnUTopkUpSIIgiAIgnAenEZQHTt2DAsWLMDZs2dx4MABaLVajBo1CiUl5hPtZ555BmlpacLPxx9/XKfjPJd2Diq9CiHuIWjj28bm/XjzAr72CjCpn/Kyb/0UTxvfNghyC4JKr8L+u/tt2mdLzBahd5We1WP99fVm9/PpfhHeETalO1qDYRisGLACXjIvXMu6hik7pghCpTpoDVq8cPgFDNg0AK+eeLVWo143s6tmSMFDdVQEQRAEQRDOh9MIqr179+LJJ59Ex44d0bVrV2zcuBFJSUm4dOmS2XZubm4IDg4Wfry8vKp8LrVeXe1xHk0+CoCLTlUlqtQtsBsA4FrWNUGw8NGfVj6tqj2eimAYBo+3exwA8PWVr6HQKircnmVZHE46DACY22UuAM4ePaW4tO7rYNJBABBs2WtCK+9W+GbkNwiUByKlOAWP73ocK06vQHROdJWb/h66ewhH7x0FwKURTt4xGTG5MRXvVA2KNcVChK4iJ0NLCE5/hSSoCIIgCIIgnAWnEVRlKSgoAAD4+ZnXFv32228ICAhAp06dsHz5cigU1kWCWq1GYWGh2Q8AXMm4Uq0x6Qw6HLtXtfopnkifSHi7eEOpUwrnv559HQDQyb9TtcZjC1PbTYWviy9SS1IxecdknE/jIkxZiiwkFSaZCZfY/FjcK74HF7EL5nSag/4h/aFn9fjp5k8AuHS/I0lHAACjW4y2y/i6NumKPx/8E/c3vx8sWPwd+zce3fUontz7JLIUWTYfZ0f8DgCc0Gvn1w5FmiI8d/A5u6cARmVFwcAaEOYRhiD3oCrtyxtTUISKIDguZVzCrju7qryAQhAEQRB1iVMKKoPBgMWLF2PgwIHo1KlUbEydOhW//vorjhw5guXLl+OXX37B9OnTrR5n5cqV8Pb2Fn7Cw7kIwanUUzaP5VbuLcw7MA8rz63E7oTdyFZmw8fFp8oOdyJGhJHNuIa2f8f+jfSSdKSXpIMBg44BttfiVBU3qRs+HPwhAt24KNCc/XMw4o8RGPHnCIzbOg5Lji4RIleHkg4BAPqH9Ieb1A1PdX4KANdzKyY3BivOrIBKr0J7v/boHNDZbmP0c/XDZ8M+w/pR63F/8/shZsS4nHkZj//7uE1RJgNrQFRmFADghe4vYP3o9Wjm2QyZykxsvrXZbuMEgMsZlwEAPYJ6VHlfwemviGqoCOL4veN4cu+TWH5iOW5k33D0cAiCIAjCKk4pqBYsWIAbN25g82bzyfDcuXMxevRodO7cGdOmTcPPP/+MrVu3Ij4+3uJxli9fjoKCAuEnOZmbyJ5OOW3TiqhKp8ILh1/AqdRT+P3W73j95OsAOIc6mVhW5cf1SNtHAAC7E3bjiX+fAAB0btIZ7lL3Kh+rKgxoOgDbH9qOR9s8CgYMspRZYMClKx5KOoQXDr8AvUEvRJ9GNBsBAOgb3Bcd/TtCpVfh4Z0P41DSIYgYEZb2WlorJhp9Qvrgs2GfYfvE7Wjl3QqZikzMPTBXqDWzxp38OyjSFkEukaONbxt4ybwwrytnVvLLf79UmupYFS5lcCmoPYN6VnlfoYaKUv4IAt9f+1742zStmCAIgiDqG04nqBYuXIhdu3bhyJEjCAsLq3Dbvn37AgDi4uIs3u/i4gIvLy+zHwBIKUnB3cK7lY5l552dSCtJAwDBgKGVdyuhvqiqdPTviBkdZgAAspXZAICxLcZW61hVxUPmgTf7v4ndk3fjx9E/4tQTp/DL2F/gJnHDufRzWHJ0CaJzoyFiRBgazrkXMgyDtwe8jSbyJgCALk264Pv7v0e/kH61OtbmXs3xywO/oL1fe+SqcjH3wNwKrcajsqIAAJ0COkEi4npZj205FmEeYchT52Fr3Fa7jCtflY+rWVcBAL2Dqt6Di6+hylHloFhTbJcxEc5HkabIriLfGSnSFAmfJYD7TBBEfcTAGhw9BIIg6gFOI6hYlsXChQuxdetWHD58GC1bVu58FxUVBQAICQmp8vn45rwVsS12GwDgpV4vYffk3Vg/aj3+mPBHjSJKy3otw9sD3oabxA09Anvg4TYPV/tY1SHMMwy9g3vDU+aJboHdsGLACgDAkWRjdCp8hFlPrLZ+bbF3yl7sn7Ifv479FX1Cqt97qip4ybywduRahHuGI60kDeuurrO6LT8x69akm3CbRCTB7E6zAQA/3fxJMAKpCUeSj0DP6tHGtw3CvcKrvL+nzFN4bhty2l9SYRKuZl2tkflLQyW5KBlj/xmLR3c92qhF1fWs62BRmiWQoyRBRdQvWJbFwkMLMeqvUeXahxAE0fhwGkG1YMEC/Prrr/j999/h6emJ9PR0pKenQ6lUAgDi4+Px7rvv4tKlS0hMTMSOHTswc+ZMDBkyBF26dKny+SprdlugLhBMI8a2HAu5RI4+IX3gInap+oMzgWEYTG49GSceP4ENYzbAVeJao+PVlLEtx2JOpzkAgEB5IJ7v8Xy5bWRiGUI8Qmolza8i/OX+eL0vl2a5KXqTVRHC10/xToo8D0Y8CD9XP6SVpGFvwt4aj4d3OLy/+f3VPgYfpUooSKjxeOojP938CeO2jsP03dPR77d+GP7HcHx79VtHD6ve8MP1H1CgLsDdwrv4O/ZvRw/HYVzIuGD2P0WoiPrGjewbOHbvGDIUGfjs4meOHg5BEA7GaQTV2rVrUVBQgGHDhiEkJET42bJlCwBAJpPh4MGDGDVqFNq1a4cXX3wRU6ZMwc6dO6t1vosZFytcIT6ffh4sWER4RyDQLbBa56gImVgGEVM/Xp7FPRfj+GPHsf/h/WjlXTsW7tVlYNOB6BfSDzpWh79vl5+A5qnykFiYCADoEmAurF0lrkKK5XfXvqtRlCpPlYfTqacB1ExQdQrgTFb4NMWGRFxeHD67xE083CRu0LE6ZCuz8VXUV9ifaFsftIaEQqvAgbsHkK/KF267llXah8405a2xwWcI9ArimoPXhwhVgboAqy6swtbYreQ62MgxsAasubJG+P9a9jVK/SOIRk79mLHbAMuyFn+efPJJAEB4eDiOHTuGnJwcqFQqxMbG4uOPP65WH6qmHk2hM+hwJu2M1W3Opp4FAPQLrd16ofqCr6svxCKxo4dhkcfbcr20tsZthVZvLor4CWpL75bwcfUpt+9jbR+Dn6sfEgsT8cG5D6o9Ufr3zr/QGXTo4N8BET4R1ToGAPQI5NwBeXMLa2y8sRGDNw/GF5e/sGnMZZ8XR7AjfgcMrAFDw4bi7NSz2D1pN8a1GgcA2Hhzo2MHV8foDXo8te8pLD26FOO3jccXl79AtjIbdwruCNvURp80Z+B23m3czrsNCSPBgxEPAgByVbkOHZNCq8CCQwvw838/463Tb9mt7pJwTn6P/h3n0s4Ji55FmqJKzZEIgmjYOI2gqksGhA4AAJy4Zz3t72yaUVDVsgEDUTlDwocgQB6AXFWu0LyXx1L9lCmeMk/8r///wIDBX7f/wqcXP62yqGJZVphgTYycWNXhm8HbrcfmxaJAXWBxm5TiFHx66VPkq/Px/fXvsevOLqvHy1PlYdq/09B/U3/8fPPnOllZL9GWICozqlzEj6/DezDiQTAMg3CvcLzU6yWIGTGuZ183ExMNnZMpJ3Ez5yYALvLx/fXvMfyP4TCwBogZbuHibuFdKHVKRw6zTtDoNdibsBe77+yGSqcS3P2GNxuOph5NAcCh9WQG1oAXj71oFjFcc3mN3XvYEc6BWq/Gd9e+AwAs77McA0O5JvaLjizC6dTTFKkiiEYKCSoLCIIq5YTFCWhqcSqSipIgZsRCSgrhOKQiKSZFTgIA/HX7L7P7+NS5svVTpoxoNgJv9n8TAPDTfz/htZOvYWf8Tuy6s0v42XJrC7bHbbc4sYvOjcbtvNuQiWR4oOUDNXosAfIANPdqDhYsrmRabjB98O5Bs//XXF5TzuBBZ9Dhz9t/YsQfI3At+xrUejVWXVyFb6/Vbr1SgboAj+96HDP2zMD8A/OFyUWhplBIvTTt0RYgD8CgpoMAANvjttfq2BzNpYxLwiR8X+I+AFxj7ZWDVyLMo9SxdHan2fCQeoAFi9TiVIeMtS55+fjLWHZ8GV458Qr6/94fexP3ggGDZzo/AzepGwBAoXOcoNoSswUnU07CVeyKn8b8hBZeLZCrysU3Ud84bEyE4ziXdg556jwEygPxcJuHMbvTbIgZMRILE/HsgWcxeftkq9/dRMNGo9cgJjcGKp3K0UMhHAAJKgv0COoBuUSOTEWmRXMKvvFv54DO8JB51PXwCAtMbj0ZAHA69TTuFd0DwPUJu5ppjFBVIKgA4JE2j+Ct/m8BAHbd2YXXTr6G5SeWCz/vnXsPb5x6AxO3T0RacZrZvhtvbAQA3NfsPni7eNf4sfBRzx3xOyzev/8uV2/0Uq+XEOgWiAxFhpmQZFkWr514De+ceQc6VgcGDIaHDwcAfBP1DU6nnK7xGK2x/sZ6QTidSz8nNIOOzokGwKXT+rr6mu3zUORDADhBZQ+3xfrImdQzeHLvk5i1dxYMrEEwXRgWPgzjW43H3w/+jUU9FuGJdk9gTqc5QmSmofdfSi5KFt4jvi6+0LE6iBkxlvVehvb+7eEmcaygSipMwupLqwEAS3ouQY+gHnilzysAgF+jf8VH5z9yyLiIukWhVaBAXYBCTaEQnRrebDgkIgn6hvTFpnGb8HCbh+Ep9UR8QTxm752Nw0mHHTxqoi7JVGTioW0P4eGdD+OBfx5AXJ7ldj11gYE1IFuZjcSCROgN+kq31xq0+PW/X3Hw7kGqD60BJKgs4CJ2waNtHgUAvHnqTWyN3WqW3vHvnX8BQOjHRDieMM8wIbL4T+w/ALiIgMagQZBbEFp6VW6z/0ibR/Dd/d9hUuQk9A/pb/YzqOkgBLkFIa0kDfMOzhP6RB1LPoY9iXsgYkR4stOTdnksj7bl3nuHkg6Vi1BkKjKFurCxLcdibmeu59kXl78Qeqcdv3ccexL3AOAaDK8evhpfjPgCU1pPAQsWr5x4pZwotAcZJRnYFL0JAATzksNJh6HRa4TV/K5Nupbbb1j4MATIA5CjyhGaRzc0eJOF2LxYbIvbhvSSdEhEEuH5cJO64enOT+O1vq/BQ+YhCCp+caChwqdV9w3ui0OPHsJfE/7CoUcOCWYxQoTKASl/eoMeb5x6A0qdEn2D++Lxdlyt5qCmg/Bc1+cAcKKqoYteZ0aj1yCjJAPpJem4nnUdcXlxVZowavQanEw5ifv+vA+DNg/CsC3DcDXrKkSMCI+0eUTYrr1/e/yv//+w9+G9GNV8FPSsHmsur6HJaT0mW5mNzbc2Cz0/a8onFz/BvWLu+zpLmYWlx5ZCo9fY5di2oDPo8PKxl9H9l+7o+WtPDP9jOCZsm4CHdz5s1qfTwBrMFi61Bi2WHVuGjy58hCVHl+CPmD9qNA6VTuXwmldHIXH0AOorz3Z9FidSTuBOwR28dfotrDy/Ej2CekDMiHEp4xLEjBjjW4139DAJEx5u8zBOp57Gplub0DOop9CbakjYEJst3fuH9kf/0P4W70svScf03dNxp+AO3jz1JnoE9RBc66a2m4oO/h3s8jja+LZB3+C+OJd+DptvbcbSXkuF+/gJaOeAzgh041JO9ibuxcWMi1h2bBl+feBX/PTfTwCA2R1nm+27vO9yROdG47+c//DxhY+xevhqs/MmFCTgyytfooVXCzzf/fkq2+B/ceULqPQqdA/sjhe6v4DZ+2Zj151duJF9Q4haWaox41M2v7/+PX64/gOGhw+HVCwFwJmKvHz8ZTzW9jE092qOQLdAwQnRmYjPjxf+5u3QOwd0FgRDWZp6No4IFV9H1iOoB6QiKdr6tTW7Xy6RA+Au+lqDFlKRtM7G9st/v+BK5hW4S93xzsB3zFxX53ebj1Opp3A16ypO3DshiC17EZsXi08ufoIxLcZgUutJdj12Q0dr0CKpMAkpxSlYfmJ5uabv7f3aY9XQVWju1Vy4jWVZrL26FpcyLmFRj0VQ6BTYFb8LexL2QGPQmB27pXdLzOsyr9x7FeD6I64YsEKYO8Tmx6KNb5vae7CEGSzLYm/iXqSXpGNy68lWM0ZUOhWm756OlOIU/Pzfz9gyfgs8ZZ5VPl9SYRLePvM2NHqNUF7w7f3f4vWTrwvX0/ld51v9nrcnu+7sEhZSTYnLj8O3V7/Fst7LsDdhL9479x5UOhW6NumK7oHdEZUVhXNp54TtV19ejeMpx5GlyMKCbguqFDjIUmRh6u6pKFQX4uexP1v8jNSUs2lnsTdhL5b2WgovWdVN52oTilBZwVPmid8e+A2LeixCc6/mUOqUOJVySlhpntZ+GoLdgx08SsKU4eHD0aVJFxRrizHv4DxEZUWBAYMn2j1hl+MHuwfjk6GfQMyIcTDpID6+8DF0Bh1GtxiNRT0W2eUcPNM7TAcA/BX7F3QGnXA7n4I6OGwwAEAsEuPDwR/C18UX0bnRmPrvVFxIvwARI8LU9lPNjukidsH7A98HAwYHkw4ivSTd7P5PLn6CA3cP4Pvr3wsW8Lby7dVvhRTFpT2Xontgd7TwagEASCxMhKfME0t7LrVq4vJEuyfgJfNCdG40Vl8uFXovHH4BKcUp+OzSZ1h0ZBGe+PcJHE0+WqWxORqWZRGdGy38z0cYK6q/5GuqGrygyuYEVUf/jhbv51P+ANSpQUd8fjy+vPIlAODl3i8j1CO03DYDm3JmBHw/QnuhN+ix5OgSnE49jbdOv4VbubfsevyGTHpJOiZum4iJ2ydiwaEFgpiSiCTwd/WHXCJHdG40pu2eZuakuj1+O9ZeXYvz6ecxbfc0PLP/GWyP3y6IqZ5BPbHtoW34d9K/2P7QdjzQynqtrKfME90DuwMALqRfsLodYX+2xW3Dy8dfxmeXPsP8g/OtRgj/vfOv8N2aXJSMr6O+rvK5WJbF0qNLcT79vCCmJrSagAGhAzC/63wAnHvtsD+GYU9CeaFjT4o0RdhwYwMAbtFy45iNODf1HD4f/jkA4Of/fsbSo0ux7PgyFKgLoNarcT79PL699q0gplYOXokuAV1Qoi3B8XvHEZ0bjRePvSgsetnCu2ffRXpJOhQ6BdZeXWv3x5mjzMEz+5/B37F/45f/frH78WsKCaoK8JB54OnOT2PHxB34c8KfeLXPq5jZYSaW91mOJT2XOHp4RBkkIgm+ue8bPBjxIALdAiFhJFjcczFa+7a22zm6BXbDh4M/RFOPpvCUemJxj8VYNWSV3RswD246GCJGhCJNEfLV+QC49JMzqZyV/5CwIcK2Qe5BeG/QewCAmDzOantK6ykWBX+kbyS6NOH6cZmKpqjMKGGxAADeOPVGpdbtPBtubMBXUV8B4Oq6ugV2g1gkxgeDPkB7v/bo5N8Ja0euxexOs61GvZq4NcG7A98FwEUGtsZuRaYi02JD16+ufGXTuOoLGYoM4TU0pVdwBYLKs+ELqmxlNuILuMhd5yadLW4jFUshEXGJFHWV9qcz6PD6ydehMWgwuOlgwfCmLK19uO8V0+ijPTidelpI3wWArbFk0W4rn1z8BElFScL/A0MH4vL0y7gy4wqOPnYUuyfvRif/TihQF+CZ/c/gj5g/oNVrhWwGU3oG9RQmphtGb0CETwSaeTWzKXLfN6QvAODA3QP2e3BEpfx440fh7+vZ1wU3ZlNYlsWv0b8CgODQuDV2q5DGbyvH7x0XrrdLei7B1/d9jXcGvgOAu/7O6jALXjIvKHVKvHz85RrX1OWp8pCnyit3+/a47Xh4x8O4U3AHfq5+WNpzKXoG9YSb1A2Dmg4SFqUO3D0ABgzmdpmLrQ9uxZv93sSkyEkYHj4c7w58F+NbjcfbA96Gi9hFOLZar8a0f6dh1p5ZOJVyqsLxHU0+Kjj5Alwv15o6XhpYA/6+/Tce3/U41l1dZ/Z67knYU+9SainlzwZEjAjt/NqhnV87Rw+FqARvF2+8P+h9ANwXZ1XT1mxhTMsxGN1iNADUyvEBLvLk4+KDXFUucpQ5CJAHYP/d/VDoFAiQB6C9X3uz7YeEDcFXI77CtrhtiPCJwDNdnrF67P6h/XE16yrOp5/H5NaTUagpxKIji4Tj3Mi+gWxlNubsm4N196+zGlViWRbrb6zHmstcg8vnuz+PWR1nCfd3btIZf0ywPR97RLMRmNd1HtZdXYd3zryDR9pyNQqh7qF4rttziPSNxPR/pyMmLwb3iu4JoqO+czvvdrnbJIzEqpU/ALMaqtp6H9c1BtaAPQl7cCH9AoaHD0eBhmsL0N6vPfxc/azu5yZxQ6GmsM6MKbbHbcfNnJvwlHlixYAVVp97vt/cnYI7MLAGuzVi501nQt1DkVqSWuVocWMlR5kjCJgNozdAIpKgS5MuZq9LgDwAP475Ea+deA0Hkw7i3bPv4sPzH0Jr0CJAHoB3B76L7699jz4hffBc1+eq/bl7oOUDWHN5DS5lXMKd/Dto5dPKLo+RsE5yUTISCxMhYSR4oNUD2BG/Az//93O5FP5z6ecQlx8HuUSOj4d+jBm7Z+BOwR3siN9RLqvDGgXqAnx4/kMAnCvrU52eMrtfLBLjpd4vYUnPJXjv3Hv46/ZfeP/c+2jp3RItvSuv5zbl9+jfsf7GemQqMuEmccNfE/5CuFc4AGBt1Fp8c5WrTw51D8Xq4avNTJ9cxC54re9rePvM2+japCte7fOqkIYX6Rsp1GvzRPpGYuuDW6HQKRDqESqUOFzOvIzFRxZjfrf5iPCOQI+gHuVSJP+8/ScAYHr76fg79m8UqAuQUJBQo76cK8+txOaYzQBQLlJ2t/AuonOj7VZqYQ8oQkU0WGpzEsowTK1PcvlJZq4qFyzL4odrPwDg6rUsTd6Ghg/F6uGrsbD7QrNVprJ0DuCiAXzj2B1xO5CrykW4Zzg+GPQBNo/bjGHhw6Bn9Vh+YjlylOWjRBq9Bi8ee1EQU3O7zMXcLnNr9oABPNf1OYxpMQY6VodNtzYJj+uhyIfQ0b8jugZyJg6VrZbVJ/jn2fRC2tq3dYV59XyKWbG2uFwNSF2Tr8rHrD2zMObvMbiYfrHK+ycUJGD99fWYvns6Xj3xKv6O/RsLDy/E6ydfBwDBgdIa/POk1NZ+yp9WrxVc3OZ1mYdAt0Cr24Z7hkMukUOpU9otLc/AGnAy5SQAYEkvLgsisTDRak86opS9iXthYA3o6N8RvYJ7oVtgN4vfk3KJHJ8O+xQv9XoJEkYiFOi/0P0FDGo6CD+N/QkLui2o0fd7sHswhoZxtSdbYrbYvN/xe8fx4tEXcTnjcrXP3Vjh3Wu7BnbFs12eBQMGJ1NO4k5+aX/DbGU2Vl1YBYBLjfOSeeGxto8BADbHbLY54vFr9K+4V3wPoe6heKaz9cVLsUiMl3u/jBZeLZCpyMTjux6v0nfo79G/Y+X5lchUZALg3E433NwAlmXx5ZUvBTE1s8NM/PXgXxbFxUORD+Hs1LPYMGaDTTVN4V7haOvXFp4yT2watwlrhq9Be7/2UOlVWH1pNRYeXoj7/rwPv0X/JjxfCq0CZ1O56NGU1lOE4EPZ78WY3BgsP7HcplTYv2//jc0xm8GAsbr4uPvO7kqPU5eQoCKIegq/0pSnysOZtDOIL4iHm8StxgXwfJF0QkEC1Hq1UMg6o8MMeLt4I8QjBB8P+RiRPpHIVmZbtIb+986/wmrwK71fwfPdn6/RmHgYhsG7A98V0hIBcyMLvmfVydSTdjlfXcBfVCZGToSE4ZIC7m9+f4X7yCVyBLkFAUCdNDxmWRZfXfkKb556E/mqfBhYAwysAWq9GnMPzMXlzMtIKU7BG6fegFZvu7X9lltbMHH7RHx++XNcz74OuUSOPsF9hPvdJG7lVknLUpfW6bsTdiO1JBUB8oBKxyURSYTo7Y83fkR6STpuZN/A6kursfvO7mqlu5xPP49sZTY8ZZ4YET4CzTybASi/OkuYY2AN2HyLW8l+MOLBSrcXMSLM6jgLvzzwCx5t8yjeHfiu3c0/Hm/LfU9vjdtqkyA+dPcQFhxagP1392Ph4YUW07sI6/DXhIGhA9HMq5mwUPNLNFdrozVo8dzB53A77zb8XP0wp9McANz7xU3ihoSCBJxLP2f54CawLItd8bsAAM/3eL5SMwu5RI61I9eiW5NuUOgUmL1vNvr/3h9j/h6DCVsnICozSthWrVfjVMopbLq1CcuOLcPK8ysBcDX7Hw7mImInU05izeU1wsLPS71ewrLeyyoch0wsq/RxWcJN6oYRzUbgx9E/4smOT2J4+HCEe4ZDqVPiw/MfYtnxZSjRluBmzk1oDBoEygMR4RMhpEPH5sUKx8pUZGLW3lnYdWcXFh9ZjHxVvtXz3sm/I0QAF3ZfiJ/H/mwmFp/t8iwALu3PFlv4uoJS/giinmIaofo3gbPqnxg5sVpuRKYEuQXB18UXeeo8nLx3EtezuKL6EeEjhG3kEjneG/Qepv47FXsS92Bcq3Fmbj/b47kmvM91e04w0LAXrhJXfHPfN9h0axOC3ILMvkgHhA7AmstrcC7tHFQ6ld1r12oDPuWvnW87bJmwBYeTDpulRlqjrV9bZCgycCv3llDkXlucTj0tNH3eHrcdMrEMMrEMzTybITo3GhKRBDqDDinFKfg79m+bRP21rGv44PwHMLAG9AvphyFhQ3B/8/sR7B6M/Yn7sTdxL2Z2mAl/uX+FxxEEVS3XULEsi9+ifwPApa3Y8t6aGDkRR5KPYF/iPqFZM88/cf9g1ZBV5fquVcTO+J0AgDEtxkAmlqGNbxskFSUhoSBBaAtBcO+FL698icNJh6Fn9VDqlCjUFMJd6i70tbOFTgGdas01tH9of0T6RCIuPw5/3v4TT3d+2uq2mYpMrLq4Svi/SFOErXFby6WSEZZR6VSCuQJvFjOjwwwcTj6MnfE78UL3F3A0+Siic6Ph7eKNDaM3IMidW7DykHlgQsQEbInZgs23NltNcee5mnUV94rvQS6Rm10zKyLMMwzfj/oer518DQfuHkCxthjFWq5ma9GRRdgxcQeKNEWYd3CeWf0kACzotgDPdnkWSp0SYkaMtJI0rL+xHgC3mGnv668lPGQeeLHXiwBKvyc/vfgp9iXuQ0xujLAA2qVJFzAMIyzamqa7f3XlK5RoSwAAhZpCDN4yGI+3fRyv93vd7FwavQYvH38ZKr0KA0IH4OnOT4NhGLza51XM2TcHo1uMxtwuc/H7rd+RqczExYyLQs2io6EIFUHUU3hBFZXFGUYwYGzO8a4IhmEwoCk3OVt8dDFYsGjv1164wPB09O+IWR24if97594TXNYUWgWuZnENk8e3rJ3WAd4u3pjXdV65VeN2fu0Q4h4CpU5pZqJRX1Hr1UKRfGvf1mjj2wbzus6zacWwrS+XnsGnDNYmB5MOCn+zYKHWq1GkKcLNnJsQM2J8MfwLvNb3NQDAt9e+rdRxT2fQ4d2z78LAGvBAywfw3f3fYUaHGYJRyqgWo/DZsM8qbbgNQGieXtupj1FZUYjOjYaL2AVTWk+xaZ8RzUZg3ch16BLA1eqIGBG6B3aHXCLHubRzeOnYSzavoBZqCoWoLx9l4dNEEwoSqvGI6g/2Kh7nJ3MTtk3Ar9G/IrUkFRmKDOG98XDrh+EudbfLuWoKwzB4suOTAIDvr31fbqLME50Tjcd3PY6U4hQEugVieZ/lADizn72Je3Hw7kGo9eq6GrZTci7tHJQ6JYLcgoT64p5BPdHBvwPUejV+i/4NP1znUuaf7vR0uZo2Ppp4JPlIOffbsuy6w0WnRjYbWSU7dFeJKz4b9hkOP3IY2x7ahvcHvQ8RI0KuKhdz9s3BzD0zcbfwLvxc/TAifASmtJ6CP8b/gXld54FhGLhJ3dAjqIdwvPld59eJmCoLwzCY3mE6NozZgCC3ICQWJgoOv3xfRd4ILDY/FlGZUXh6/9PYGseZ6/CpsACXZlm2D9iO+B2IyYuBr4sv3hv4npC22z2wO048fgLvD3ofMrEMo5qPAlC/jF9IUBFEPcXflVu5578wBjUdZNY7pSaMaTHG7P+H2zxscbv53eajqUdTpJekCw5KF9IvQGfQIdg9uM6NIUSMCGNbjgXApWfVd5IKk2BgDfCQeiBAHlClffli3rqYTPP25R8N/gh/jP8DOybuwLsD38WTHZ/EhjEbMDhsMB5u/TCaejRFtjIbv0f/XuHxtsRswa3cW/CSeeGVPq/UqB6Fj2BZquWzJ3x0alyrcfBx9bF5v4FNB+K3cb/h3NRzOD/tPH4e+zN+GfsL5BI5zqefx8abG206zs83f4ZSp0SkT6QwMalNQaU36BGfH19jJ67K+Drqa/T5rQ+m/ju1xqmL7597Hx+e/xCZikyEuofi82Gf45exv2Bqu6mY3Wk2nu9hn9RjezG+1Xj0CuoFhU6BJUeX4Pfo3/H2mbeFxSCFVoFFRxYhS5mFSJ9IbByzEY+0fQSRPpHIV+dj2bFlWHJ0Cabvno7EgsRqjyNbmY0Ddw/gv5z/av31tgcsy+Js2lncyL5h0/aHkzkHvRHNRgjfNQzDYGaHmQC4RaCkoiT4u/oLZkemRPpGondwbxhYQ4WNbVU6lRCJrm4f0iZuTRDhE4EHIx7Ej6O5a2pMXgyylFlo7dsaf034C2tGrMGKASvQ3t/cfOq1Pq+hpXdLPNrmUbvULNeEboHd8MeEP9A/hDP9kEvkeDCSWwiK9I0EwLUxmLFnhhA9fKztY3h7wNto5V0qaPnemgCXuvvTTa6P5tOdn0YTtyZm53SXugsCi0/pPHHvRL1x+yNBRRD1FD5ixF8AeSFhD4aGDcUznZ9BoDwQj7Z5FJNbT7a4nVwiF0L9P1z7AZ9e/BSfX/4cALdC5wj3uXGtxgHgCrhre5JdU/iGxi29W1b5ueLFs6kNdLnjFyRi151dUOlU1R5jsaZYyHXvHtgd7f3bo6V3S0yMnIgXe70opBtKxVI81+05AMD3179HliLL4vGyldmCtf2iHosqdPCzhQDXAOG4FXH83nEsOrwIn1/6vMqTxvSSdBy8y0XpprarXhTYVeIqmMG09WtrFtGz5PRoSrYyGz//9zMALo2Wf6/UlqBS69VYfGQxJm6fiIWHFtplQlKoKcShpEP4+ebP2Bm/E1GZUfgj5g+su7oOKr0K17OvY9q/0/DVla/MeuvZSlRmFLbEbIGIEWFxj8XY+tBW3Nf8PnQL7IblfZdjac+lFZrxOAK+T6Cfqx9i82Kx8vxK/HX7Lyw4tAA3c27i1+hfkVaShqYeTfHT2J8Q7hkOqUiKT4d+ihZeLYRG1rdyb+GZA89U63nbdWcXRv81GkuPLsVjux7DlB1TaiTO6oJNtzbhmf3P4Il/nyhXw6vVa3E777bQUkKtV+NIEmfXPaKZeQreqBajhJ5+ALC452KrEUw+SvV37N/Q6DUWt/nz9p/IV+cjxD0EfUL6WNymKvQM6okV/Vcg1D0UI8JHYMPoDeVEhCmRvpHYMXEH3uz/ptBOwpH4ufph7ci1+GjwR/hx9I/Cd72XzMusbcuA0AH47YHf8Hrf1+Ev98fWh7YKtdHJRcnCdjvid3B9K6WemNKm4iyB3sG9IRPJkFqSWmGdcbYy2+bvNwNrwPrr63H/X/fjn9h/bNrHFMe/IgRBWIQ3JQAAqUiKYeHD7HZshmHwQo8X8EKPFyrddmSzkRjfajx23dklrLa7il3t1jC5qrTxbYPOAZ1xPfs6fvnvFyzuudgh47AFfuLCNzmuCs28OEOCbGU2SrQl5SYCcXlxmLFnBoq1xdgZuhPrRq6rsmgzsAasu7oOOlaHCO+ISpuVj2s5Dptvbcb17OtYdXEVPh7ysdn9OoMO75x5B8XaYnT072hz6lxF8JE9Sz3JeC5nXOaEAVggmXNJrMxUgod3zNKzevQM6mmTE5YtPBTxEHbd2YVzaefw3MHn8NsDv5VLq+X56spXUOqU6BLQBSObjRRu5983WcosFGmKalw/CXDvyWXHlwlmKSdSTuBU6inB8MUSMbkxePPUm8hQZKBHYA8s6LYAoR6hOJ16Gj2CenDHPLYMmcpMi/tPaDUBar0a++/ux7fXvoWIEQni3Fb45qsTIydiTuc5VdrXkQS5B+Hb+7/FZxc/Q746H9nKbGQps/Dt1W9xMYNzfHu++/PwknkJ+7TyaYUdE7k0qkxFJiZun4j0knTczrtdJZvoxIJEvHnqTegMOjTzbIZsZTbi8uPw1L6n8MsDvwjtGWoTlmWxI34H9iTswdT2U816KFpCqVMKfQ0BzlHPTeqGOZ3m4L+c//DmqTdxr/geAM6AoolbE+Sp8xDkFoSeQT3NjiUVSfHt/d/im6vfoJN/pwoNS4Y3G45AeSAylZk4nHy4XBaHQqsQ0gbndplrN0Ezpc2USsVDfUYsEltsdN07qDd23uFqQt8f9L5ZhoaIESHSh4tiJRclI70kHYeSDuHzS58DAJ7q/FSlqbtuUjf0DumNUymncOzesXL27LmqXHx47kPsSdyDMS3G4OMhH1d4fcxWZuP1k68LbSpWnF6BwU0HVyhwy0IRKoKop5Rd4bHHZKo6MAyD9we9j1VDVmFy68mY1n4aNo3bJEz4HQFf4L05ZrNZbY1WrxV6N1UFhVaBqMwouxsf8BGqFt4tqryvl8wLvi6coYHpKh7ATVL+d+Z/QmHz6dTTWH9jfZUc+LKV2Zh/cD5++o9LsZjZcWalgkwsEuP1fq9DxIiwJ2EPjiYfFe7LUeZg7oG5OJJ8BFKRFG/2fxNikdjm8ViDT/nbdWcXfrzxY7nXSKVT4Y1Tb3BiysjfsX/bdGytQYu3z7yNHfE7wIDBC90rX2CwFYZhhEhDhiIDU/+davZ88VxMvyiMd2mvpWavgYfMA4Fyzrq9plGFPFUevrj8BR7d9Shu5d6Cr4uvMKl54fALGP7HcGHCaIrOoMNLx15CdG40clW5OJh0EA/vfBij/h6FJUeXYOiWoZi1dxYylZnwdfHFyGYj0SOwB3xdfOEudcf09tPxzsB38OmwT/FG3zcAAD//93OVoqqHkw7jbNpZSBiJw1OdqkM7v3b4btR3+GPCH1g5mHNuO5J8BEWaIkR4R5SbvAOlrTmC3IOEKHFV7NQzFZl48diL0Bl0GNh0IHZO2ol/J/+LSJ9IZCmzsOL0ilpNlSrSFOHX/37FIzsfwRun3sCp1FNYdGQRUotTK9xvT8IeFGmKEOYRJrzW3137DgM2DcDsfbNxr/geJIwEYkaMU6mnsC1uGwDumsBH9Exp5tUMHw7+ENM7TK+wV5xUJBWEwZnUM+Xu/yPmD+SqctHUo2mVjE8aK0t7LUWvoF5Y2G2hxXR3PnK4N3EvJmydgA/PfwiVXoW+wX0xu+Nsm84xLGwYd4yEvcJtGr0GH5z7AOP/GS84GO9N3GvRqj1flY+d8Tux7NgyjPtnHE6nnoarmDMjYsHiRAqXjpiQb1uGAEWoCKKeYhqhGtVilANHwq0ojWk5BmNalr/wO4Jh4cMEB61N0ZvwbNdnodKpMHnHZCQXJWN5n+U2G3icTjmNV068gnx1PuQSOeZ2mYs5nebYJZ2RT9WqajNHnlCPUOSp85BWnGbWWPx8+nlcy7oGV7ErxrUah79j/8aay2vw751/8f6g9ytcxVZoFfg34V98E/UNspXZcBW7Ynnf5ZgUaZttdEf/jpjabip+jf4VS44uwZxOc9DOrx0+PP8hMhQZcJO4YeXglejo37Faj7kspi6Aqy+txqWMS/hqxFfC67P51mYkFyUj0C0QG0ZvwPit4/Ffzn9IL0mvMOKmN3B91vYl7gMDBm/0e8Os6NseeLt4Y+3ItZh/cD4SCxPx/OHnMbjpYHw45EN4ybxQoi3B22feBsD1bym7wg5w751MZSYSChPQuUlnm899OeMyNt/aDB2rQ4m2BFcyrwhmIr2De2PloJWQS+V4bOdjuFd8D9nKbKy5vAaDmw42i9L9dfsvJBYmwkPqgY+HfIwfb/yIixkXy1mB9wvphzXD1wiF+vxk3fRz9GjbR/Hd9e+QqcjE5czLGBA6ACqdCnsSuInP+Ijx5SbFp1NP4+XjLwPg7KPrIqpSm3QP7A6ZSAaNgUsrm9dtXqULD50DOuNEygnE5pfaUJdoS3A9+zrEjBjt/doL5i0A99y/cvwVwSL8f/3+BxEjQoA8AJ8P/xyTt0/G2bSz2BG/w67iIF+Vj0NJh3D03lFcSL8guLpJGAl0rA46gw7fX/8e/+v/P4v7sywr9B98rO1jmNVxFgLlgfj22rfIUnIpxpNbT8ayXsuQpwCqLAEAAQAASURBVM7DTzd/QnRONIaEDRH6SdWE3sG9sfHmRqHmh6dYUyzUEM/rOs+icCPMCZAHYMOYDVbvN60HV+lVaOfXDg+0fACPtX3M5oW4MS3G4KMLHyE6NxpHk4+iX0g/LD66WOhTKRg75cVg5fmVeLbrs/B18UWf4D7YcHMDvrz8JXRsaRptpE8kVg1ZhQNJB/BN1Df44vIXOH7vOA7E2GZ8QYKKIOopblI3dGnSBVmKLLum+zUERIwIT3d+Gq+eeBW/Rv+KhyIfwo3sG0Ik5/dbv+OJdk9UKooUWgXeOPUG8tX5ALh0kzWX1+B27m28M/AdM+tslmWxLW4b10+j46xKbbVZlq1Ryh/ARSlv5txEWkmacFuBukDo0TExciJe6/sa2vq1xdqotYjLj8Njux7Dkp5LzCyXkwqTsC1uGy6kX8CNnBtCLQZ/AeGLiG1lac+lyFBk4MDdA4LdOv841wxfU85FqyZ0CuiEph5N4S51x52COzh+7ziOJB/BiGYjEJUZhTVXuObSC7otQDOvZuge2B2XMy/jcNJhq6JapVPhrdNvYV/iPkhEEnw69NNy9Rf2IswzDH9O+BPfRH2DX6J/wYmUE3ju4HPoE9wH+xL3IakoCU3kTbC011KL+zfzaoZz6eeQVGi9lq4sLMvi7TNvl6staO/XHvO6zsOw8GHCav3v437Hzvidgm337oTdgqC6lHEJn1z8BADXD2Zw2GD0D+2P8+nnIRPJEOYZhu+ufQetQYtX+7xq5npm6bPHMAwGhA7AtrhtePbAswjzCBPStwBOPH005COIGBHu5N/BmstrcOzeMehZPQY3HVzvTCeqg0wsw8u9X8bK8ysxqsUojG4+utJ9ePOfe0X3UKgpxCcXPsHexL2CQBYzYgwNG4ph4cMwrtU4XM26iosZF+EidsGPo39EiEeIcKzmXs0xv9t8rLm8Bh9f+BiDmg6qtHVBZeSp8rDqwirsurPLLFIc4R2BKW2mYFyrcUgsSMSsvbOwLXYbZrSfYfE74lLGJdzKvQUXsQsmtZ4EhmHwWLvHMKrFKBxOOowInwjBGdRD5oE3+r1Ro3GXhY8EphSnIF+VL5jTfHLxE+Sp89Dcq3m1zSgIcyJ8IsCAEd4vv4z9pcptUHxcfTCl9RRsidmCRUcWwcfFB7mqXMglcrw94G2MbjEaUZlRmLV3FuLy47Ds2DIA3HXKtL55cNPBGBI2BL2CekEsEsPLxQsbbmxAjioHh5IOmb2nK4Jh64s9Rj2gsLAQ3t7eKCgogJeXV+U7EEQtozfooWN19a7Yuj6gM+gwafskJBYmwsfFBwwY5KlLm2HO6jALS3ouqXC165/Yf/C/0/9DqHsotj60FTvid+Cj8x9Bx+rQpUkXfDb0M6Hu5aebPwmTy3Z+7fB639crtP1OL0nH/X/dDwkjwdlpZ6v1Gn54/kP8Fv0bZneajaU9l0Kj12Dugbm4lHEJfq5+2PrQVqEQOKU4BStOr8DZtLOQiWQ49MghxBfE47fo33Ao6ZCZUUO4ZzgmRk7EjA4zIJfIqzwugJu0703ci++ufQeNXoNBTQfh+e7Pm62U2wuWZcEwDL64/AW+v/49Wni1wKqhq/D0/qdRoC7A/c3vx6dDPwXDMMLrNDB0INbdv67csbKV2Vh0eBGuZV+DmBFj5eCVdjV8qYirWVfx5N4nzcwFgtyC8Nmwz8yaWZuy8cZGfHrpU4xtObZczZo1buXewiM7H4Gr2BVLey2FVCRFR/+OaOfXzuoiw4G7B7D06FJ4u3hj1ZBV2H93P7bFbYPOoMOw8GFYM3xNhSlTtnIx/SJm7zNP6eH7nAGc5XIn/074986/QhRnTIsxgl1yQ8FSXaQ1ojKjMGPPDMhEMoR7hiO+IB4A0ETeBFKRFKklpWl07f3aw03qhksZl/BIm0fwVv+3yh1Pa9DiiV1PICYvBuNbjRfSEKuDzqDDjN0zcCOHc+SL8I7A+Ijx6BPcB50COpm9Z54/9DyO3juKILcgfD78c7MeYFqDFo/vehy3827j4TYPW41i1Tbj/hmHpKIkfHf/d+gV1AtfXPkCG29uBAMG60evR+/g3g4ZV0NkT8IefBP1Dd4d+K5NLTQsodAqsOLMCiHK7ePig8+GfWb2Oq2+tBp7EvbAU+ZpZhD0XNfnML/bfIvHvZJ5BX/d/gvB7sEY4DsAvVr2qlQbkKAygQQVQTgXyUXJeOnYS/gv5z8AnFnGxMiJ2ByzGQBXe/bxkI/h7eJdbl9TQba051LM7sRN8i6kX8CiI4tQpCniemEMeg/uUnc8e+BZs34wcokcm8dtthqNOXT3EBYfXYx2fu3w54Q/q/X4TCfTHw3+CK+ffB077+yEh9QDG8dsLGegwLIsJu+YjLj8OAS7B5v1VBnUdBBGNR+FXsG9EOYR5hCHxppSrCnGuK3jkKvKFW7rHNAZP4z6QYiO8GLCXeqOU4+fMhPUp1JO4d2z7yKlOAXeLt5YPWx1nU+QrmVdw874ndCzerTza4fRLUZbfH/yHEo6hMVHFqOTfydsGr9JELKnU0+juVdz9ArqhY4BHc3SkP6I+QPvnn0XA0IH4Nv7v7V6bFP0Bj0m7ZhUzlFwaNhQrBq6qtrC2xIbbmxAdG40RjUfhW6B3eDn6ocDdw/gf6f/J6SJAdx7dlGPRWbpro2RbGU2hv8xXPg/UB6ID4d8iJ5BPSFiRLiVewtHko/gt+jfhFRMMSPGPw/+Y/X76XrWdUzbPQ0sWLzU6yWbmo1bYved3XjlxCvwlHpi3f3rrC4MANwi08w9M5FWkob2fu2xZfwW4Xvo+2vf44srX8DHxQfbJ26vsTtodXnp2EvYl7gPEd4RYBgGcflxADj3zfldLU++CccTmxeLTEUmugd2r7A/2M2cm4jKjEK3wG42p6Xbqg0o5Y8gCKcl3DMcv4z9BZtubUJ8fjwmRk5E98Du6ODfASvPr8Tp1NN4bNdjWD96fbnai39i/0FiYSJ8XXzxSJvS3iS9g3tj07hNWHZsGaJzo7Hg0ALhvmFhw/BKn1ew7Ngy3Mi5gY8vfIwvR3wJqbh8Tv3VbK75cU1qiUI9QgEAd/Lv4P1z72PnnZ0QM2J8OvRTi250DMNgYOhAxOXHCWJqUuQkPN7u8Sq5g9VXPGQeWNxjMd46za26R/pEYu3ItWYX0NY+reEh9UCxthg3cm6ga5OuKNGWYNWFVYL5Q7hnOL6575tqmYXUlC5NulQ46SwLny56I+cGDtw9gH2J+4ReODweUg8s671MaH/Ar8JWxbFQLBLjyxFf4v2z7yM6Nxod/TvimS7PWKzrqin84oUpo1uMRr+QftidsBuZikx0bdIVQ8OGOqXwtzd8T0Keb+//1ixNt51fO7Tza4cBoQMw/8B8FGmLsKjHogpTbzs36YwXeryANZfX4JOLnyAmNwav9HmlQnFvyr2ie7iRfQNfXPkCADCjw4xK39fB7sH4eezPGPvPWETnRiM2PxZtfNsgoyQD665y0eSXe7/sMDEFAIObDsa+xH1CFNBL5oV3BryD+5rf57AxEZXT2re10FC4Ijr6d7RbfW9ZKEJlAkWoCKLhEJMbg0VHFiGlOAWtvFvh57E/w9vFGyzLYl/iPrx+8nVoDBq82udVTGs/rdz+Gr0Gqy+txqZbm6Bn9WYr9fH58Xh4x8PQsTp4ybwwOGwwHmj5ALoFdoOXzAssy2L81vFIKkrCx0M+rnZKGZ82aMpb/d8yE4BluZN/B1N3T0WJtgSv9X3NYfb2tcmF9AtILU7FyOYjLaZNvXL8FexO2I1eQb0wNGwoNsdsRkpxChgwmNp+KuZ3nW/zxNHRsCyL+/+6HxmKDOE2MSPGgxEPokBdgIsZFwWny6U9l2Jmh5l44t8nEJ0bjQ8Hfyj0bSOcmx+u/4A1l9fgwYgH8f6g961uV6wphp7V2/T+ZlkW666uw7pr62BgDfBx8cGkyEmY322+1Yik1qDFzzd/xhdXvhDSiP1c/fD3g3/b3Lz86X1P41z6OazovwIPRj6IFw6/gJMpJ9EjsAc2jtnoUBGt0qnwyM5HkKPKwYwOMzCt/TQzS3ui8WGrNmhwgurrr7/GqlWrkJ6ejq5du+LLL79Enz62NWAjQUUQDYv0knRM2z0NmYpMtPBqgWZezRCfHy80hbyv2X34ZOgnFfYUKdGWQKlTlpssHEo6hHfPvFuuP1JTj6bIU+VBoVNALpHj6KNHK0xBqIwxf49BSnEKfFx88N7A9zA0fGil+6QVpyFDkVHtvHRn53rWdUzfM92sbizUPRTvDXrPKWsgvrv2Hb688iVaerdEC68WeKrTU8Jrqzfo8eH5D4U01wB5ALKV2RAzYhx85KDNk1yifqM36HEq9RR6B/e2a/olwNVovXnqTaFQv0uTLvh6xNeCKQPAia8TKSfw0fmPhGbjkT6R6BbYzarJhDU+u/QZNtzYgAdaPgCFToGjyUfhKnbFxjEb0TGgdqIHVUFr0EIEkV3aPhDOT6MUVFu2bMHMmTOxbt069O3bF59//jn+/PNPxMTEIDAwsNL9SVARRMMjJjcGT+17yqxflVwix7T20/Bct+dqZIGrNWhxI/sGdsbvxIG7BwS3QJ6a1CbwHE0+imP3juHZLs9W2niXKOVC+gX8eftP6Aw6dG3SFVNaT6kVw4y6wMAaUKAu4MxXLKzesyyLv2P/xicXPxFqkEY2G4nVw1fX9VAJJ0Wj1+DYvWNYcXoFCjWFCPMIwxPtnkAzr2a4kX0DuxN2Cy6qfq5+mNd1Hh5v+3i1okmHkw5j0ZFFwv9SkRSrh622abGIIOqaRimo+vbti969e+Orr7gu2waDAeHh4Xj++efx6quvVro/CSqCaJjkqnJx8O5BsCyLpp5N0T2wu80OW1UhW5kt2Fu7Sd3Q1rct1YAQdUaOMgcXMi7AReSC/qH9q2xDTBDx+fGYf3C+WasGHhexCx5v+zjmd5tfo+9PnUGHidsn4m7hXaE3VtcmXWsybIKoNRqdoNJoNHBzc8Nff/2FiRMnCrfPmjUL+fn52L59e6XHIEFFEARBEERjpkBdgH9i/8GF9AvIUGSgtW9r9Avph1HNR9UofdmUlOIURGVGYUDoAPi6+trlmARRGzQ6l7/s7Gzo9XoEBQWZ3R4UFIRbt25Z3EetVkOtLrVBLiwstLgdQRAEQRBEY8DbxRuzO8226MZoL5p6NC3nvEoQzkzNu/Q5MStXroS3t7fwEx4e7ughEQRBEARBEAThRDQYQRUQEACxWIyMjAyz2zMyMhAcbLmQe/ny5SgoKBB+kpOT62KoBEEQBEEQBEE0EBqMoJLJZOjZsycOHTok3GYwGHDo0CH079/f4j4uLi7w8vIy+yEIgiAIgiAIgrCVBlNDBQBLly7FrFmz0KtXL/Tp0weff/45SkpKMHu2bXnAvD8H1VIRBEEQBEEQROOG1wSVefg1KEH12GOPISsrC2+99RbS09PRrVs37N27t5xRhTVycrgGnVRLRRAEQRAEQRAEwGkEb29vq/c3GNt0e5Cfnw9fX18kJSVV+KTVhN69e+PChQu1cuy6PAedp3oUFhYiPDwcycnJtZ5iSu81Ok9DOk9Deix0nvp9nob0WOg89fs8DemxNNTzHDx4EM2aNUNeXh58fHysbtugIlQ1RSTiSsq8vb1rbbIrFotrfSJdF+eg89SMuqjZo/canachnachPRY6T/0+T0N6LHSe+n2ehvRYGup5+AALrxGs0WBMKZyFBQsWNIhz0HnqP/Reo/M0pPM0pMdC56nf52lIj4XOU7/P05AeS2M/D6X8mWBrN2SCqC70HiMIgiAIgnAObJ23UYTKBBcXF/zvf/+Di4uLo4dCNFDoPUYQBEEQBOEc2DpvowgVQRAEQRAEQRBENaEIFUEQBEEQBEEQRDUhQUUQBEEQBEEQBFFNSFARBEEQBEEQBEFUExJUBEEQBEEQBEEQ1YQEFUEQBEEQBEEQRDUhQUUQBEEQBEEQBFFNSFARBEEQBEEQBEFUExJUBEEQBEEQBEEQ1YQEFUEQBEEQBEEQRDUhQUUQBEEQBEEQBFFNSFARBEEQBEEQBEFUExJUBEEQBEEQBEEQ1YQEFUEQBEEQBEEQRDUhQUUQBEEQBEEQBFFNSFARBEEQBEEQBEFUExJUBEEQBEEQBEEQ1YQEFUEQBEEQBEEQRDUhQUUQBEEQBEEQBFFNJI4eQH3CYDAgNTUVnp6eYBjG0cMhCIIgCIIgCMJBsCyLoqIihIaGQiSyHociQWVCamoqwsPDHT0MgiAIgiAIgiDqCcnJyQgLC7N6PwkqEzw9PQFwT5qXl5eDR0MQBEEQBEEQhKMoLCxEeHi4oBGsQYLKBD7Nz8vLiwQVQRAEQRAEQRCVlgKRKQVBEARBEARBEEQ1IUFFEARBEARBEARRTUhQEQRB1BNYgwEpS19ExserHD0UgiAIgiBshGqoCIIg6gmq69dRuHs3AKDJ4kUQyWQOHhFBEARR1xgMBmg0GkcPo1EglUohFotrfBwSVARBEPUEbVq68LcuIwMyauNAEATRqNBoNEhISIDBYHD0UBoNPj4+CA4OrlEPWhJUBEEQ9QRNYqLwtzY1jQQVQRBEI4JlWaSlpUEsFiM8PLzCRrJEzWFZFgqFApmZmQCAkJCQah+LBBVBEHWGQaNB+v9WwLVjR/hNn+bo4dQ7NHfvCn/r0tMcOBKCIAiirtHpdFAoFAgNDYWbm5ujh9MokMvlAIDMzEwEBgZWO/2PBBVBEHVG0YEDKNi6FQVbtwIGPfxmznT0kOoV+sJC4W/T9D+CIAii4aPX6wEAMqqfrVN48arVaqstqCiWSBBEnVF8+Ijwd8YHK5Gx8kMYSkocOKL6hUFR+lzoiwor2JIgCIJoqNSkloeoOvZ4vp1GUK1cuRK9e/eGp6cnAgMDMXHiRMTExJhto1KpsGDBAvj7+8PDwwNTpkxBRkaGg0ZMEERZlFFRAACXdu0AALk//YTs77534IjqF6xCWfq3UuXAkRAEQRAEYStOI6iOHTuGBQsW4OzZszhw4AC0Wi1GjRqFEpPV7SVLlmDnzp34888/cezYMaSmpmLy5MkOHDVBEDz6oiJoU1IAAM02/Ah5z54AAMXZs44cVr3CoFCU/q0iQUUQBEEQzoDTCKq9e/fiySefRMeOHdG1a1ds3LgRSUlJuHTpEgCgoKAA69evx2effYYRI0agZ8+e2LBhA06fPo2zNGEjCIejvn0bACAJCYHE1xehH64EACj/+w8GtdqRQ6s3mAkqpaKCLQmCIAii4XL06FE89NBDCAkJgbu7O7p164bffvut0v0Yhin3s3nz5lofr9OaUhQUFAAA/Pz8AACXLl2CVqvFyJEjhW3atWuHZs2a4cyZM+jXr1+5Y6jVaqhNJnKFhVSzQBC1hTadM1ngrcClYWEQeXrCUFQEbXIyXCIjHTm8eoGpoKKUP4IgCKKxcvr0aXTp0gWvvPIKgoKCsGvXLsycORPe3t4YP358hftu2LABY8aMEf738fGp5dE6UYTKFIPBgMWLF2PgwIHo1KkTACA9PR0ymazckxYUFIT0dMtuWStXroS3t7fwE+4EPV/0RUVgqdkb4YQYjAsWYm8vANwqkjQ8DACgSU522LjqE5TyZw5rMEBfXOzoYRAEQRAVMGzYMCxcuBALFy6Et7c3AgIC8Oabb4JlWQBAixYt8N5772HmzJnw8PBA8+bNsWPHDmRlZeGhhx6Ch4cHunTpgosXLwrHfO211/Duu+9iwIABiIiIwKJFizBmzBj8888/lY6Hb9TL/7i6utbaY+dxSkG1YMEC3Lhxo8YhvOXLl6OgoED4Sa7nkzp1QgJuDxiI1JdfcfRQCKLK6As4QSXy9BJukzXlBJX2XopDxlSfYPV6sCYRc1aprGDrxkHy3Gdxu1dvaNOoJxdBEI0PlmVhUCgc8sOLIVv56aefIJFIcP78eaxZswafffYZfvjhB+H+1atXY+DAgbhy5QrGjRuHGTNmYObMmZg+fTouX76MiIgIzJw5s8LzFhQUCJlpFbFgwQIEBASgT58++PHHH6v8WKqD06X8LVy4ELt27cLx48cRFhYm3B4cHAyNRoP8/HyzKFVGRgaCg4MtHsvFxQUuLi61PWS7UbB9O6DVonDXLoSu+phsNQmngu+xJPYqFVRSY1RYe69+L2bUBYYyAooiVEDJyZMAgMJ//4X/0087eDQEQRB1C6tUIqZHT4ecu+3lS2Cq0Fw4PDwcq1evBsMwaNu2La5fv47Vq1fjmWeeAQA88MADePbZZwEAb731FtauXYvevXvjkUceAQC88sor6N+/v9V5+x9//IELFy7g22+/rXAc77zzDkaMGAE3Nzfs378fzz33HIqLi/HCCy/Y/Fiqg9NEqFiWxcKFC7F161YcPnwYLVu2NLu/Z8+ekEqlOHTokHBbTEwMkpKS0L9//7oebq0gMVHlusxMB46EIKqOocg85Q8ApCEhAABtOrU3MJSYm1CUFViNDVanE/4W10H+O0EQBFF9+vXrZ7bQ379/f8TGxgrNirt06SLcFxQUBADo3LlzudsyLcxvjxw5gtmzZ+P7779Hx44dKxzHm2++iYEDB6J79+545ZVX8PLLL2PVqlXVf2A24jQRqgULFuD333/H9u3b4enpKdRFeXt7Qy6Xw9vbG3PmzMHSpUvh5+cHLy8vPP/88+jfv79FQwpnxKAqTQdSx8RAanzzEYQzIKT8mUSoJAH+AABdTrZDxlSfMG3qC1DKny4nR/hb5OHhwJEQBEE4BkYuR9vLlxx2bnsilUpLj20UXpZuM5TxCTh27BgmTJiA1atXY+bMmVU+b9++ffHuu+9CrVbXalaa0wiqtWvXAuAK30zZsGEDnnzySQBcfqZIJMKUKVOgVqsxevRofPPNN3U80trDUFgg/K25m+TAkRBE1bGU8icJCODuyyJBZSg2F1SNPeVPZ9KUndVqHTgSgiAIx8AwTJXS7hzJuXPnzP4/e/YsWrduDbFYXO1jHj16FOPHj8dHH32EuXPnVusYUVFR8PX1rfUSH6cRVLYUlLm6uuLrr7/G119/XQcjqnv4FX6Aak4I50NvXBAwFVRio6DSZZOg4qN0Yn9/6HNySFCZpH2wGo0DR1KK+s4dSAKDIPZwd/RQCIIg6hVJSUlYunQpnn32WVy+fBlffvklPv3002of78iRIxg/fjwWLVqEKVOmCJlpMplMMKbYunUrli9fjlu3bgEAdu7ciYyMDPTr1w+urq44cOAAPvjgA7z00ks1f4CV4DSCiuAs03k05IpGOBl8BEbk6SncxkeoDCUlMCiVENk5xcCZ0BtFpSwsDMqcHECrBavVgjFJiWhM6HJyhb/rg6BSXL6Mu1OnwX3QIDT74XtHD4cgCKJeMXPmTCiVSvTp0wdisRiLFi2qdlQJ4FwDFQoFVq5ciZUrVwq3Dx06FEePHgXAuf7FxMQI90mlUnz99ddYsmQJWJZFZGQkPvvsM8EYozYhQeVEmKb8aeu5xTtBlIWvCTIVTSIPDzAuLmDVauhyciAzce5s6OgLC5H/51/wemAspCEh0GVzNUPSsDAor14FABjUaogbqaDiTUwA7nlwNHm//gqAcx5kWZZcVgmCIEyQSqX4/PPPhRIdUxITE8vdVjbzrEWLFma3bdy4ERs3bqzwnE8++aRQ9gMAY8aMMWvoW5eQoHIizFL+MsgVjXAu+BQ2xqTBHsMwEPv6QpeeDn1ePtCIBFXuL78g+8uvkLlqFUQeHjAYG9hKQ0OEbRpz7ZC+sDQiz2oc/zywhtILvS49XXCoJAiCIAinsU0nAIOi1FbZUFDQ6GssCOeCf7+WTesTG1MA9SYR2MaA8tJl4W9eTAHGNEgJt9ZVH4SEo9CbRKjqQ8qfJumu8Lc6NtaBIyEIgiDqGxShciLKTip0WVmQGRujEkR9htVqAWO0RWQSoQIAkbEvlaGwsNx+DRl1YgIAIOTDlWA1GmS89z5YjQYubduBkUrB6nSNOkJlMInIsw5O+WP1emji4oX/Teu7CIIgGjt8TVNjhiJUTkQ5QUVpf4STYBpNLWsBK/byBmCe0trQMSiV0KWmAQA8hw2D76OPos35c2i59R+49e0jGFHUh8iMozA14XH086C5m2Q2Bn1+vuMGQ9QblDdu4vagwcj96SdHD4UgCAdDgsqJ4C/oYqNdpM5CN2mCqI8Y+Ca1IlE51zreRl3fiCJUfISDkckg8uYEpcjVFa7t23N9R3hB1ZgjVCbvB4PGsRGqsil+JKgIALg7bRr02dnIWPmho4dCNDBsaRVE2A97PN8kqJwIg1FQ8Wl+2rQ0Rw6HIGyG5eunXF3LuaOJ+ZS/osYjqPR5nKAS+/lZdIsjQVW/IlQkqIiysCzr8FRUouHBN8HVNOLsBEegMHoUSGvgqks1VE4EP6mQtWoF5dWr0Ny75+AREYRtGJRGhz8LfaZEfISqEaX86XM5QSUxRpvLwshkAABW23gvqqYRS0ebc/CCStq0KbQpKdAXNC4DFaI8pkYyAGcaJSqTzkwQVUUikcDNzQ1ZWVmQSqUQiSjuUZuwLAuFQoHMzEz4+PgIgrY6kKByEli9HtDrAQAuEa0AANpkElSEc8Cqyveg4hF7Nt6UP7E1QSXUUDXeCJVpyp+jIwG8oHLr3RsFKSkUoSLKpdxr7t2Da5s2DhoN0VBgGAYhISFISEjA3bt3K9+BsAs+Pj4IDg6u0TFIUDkJpikvslZGQUURKsJJ4CNUIrlrufuElL9GZJtemvLna/H+xp7yZ1Crzb7zHJnyx2o00BgnNm69e6Fg2zYSVEQ5QaW+dYsEFWEXZDIZWrduTWl/dYRUKq1RZIqHBJWTYDqhcOEFVUoKWL0ejB3eCARhL5TXb6Bg+3Z4jrof7n36AAAMSi4/mXGllD+gNEIl8a0kQtVIU/7KWug7UlBp7t4F9HqI3N3h0qYtAKqhIgBtGZddxeXL8H7wQQeNhmhoiEQiuLqWX4Ak6i+UnOkkmE4opGFhgEQCVqslpz+i3pH22nLk/forUl5YJNxmakpRFrHR5a4xpfzxTYzFvj4W7y+toWqcEaqy7wVHuvyp4+8AAGQREcLrRYKK0KakAABExsbkirPnHDkcgiAcDAkqJ4EXVIxMBkYigTQ0FACl/RH1C1avhzo2DgA36eTt0g0K7jfjZqGGyqtxNPbVJCUJTp2GIq6gnZ+MlaWxp/yVFVSOrCVT3+Ea+rq0aiWIf1alMuutRjQ+VNHRAAC/WbMAqRSaxESo79xx8KgIgnAUJKicBIOJoAIAWVhTAICGjCmIeoSmTBGtJjERAARXNL6JrylCyl9REViDoXYH6CBKzp1H/KjRSH5mLoBSi3heTJalsZtSGEws0wEAOp1jBgJAcycBACCLaAWRhwcg4TLlKUrVuFHd/A8A4NanN9z79wMA5P32uyOHRBCEAyFB5STwEyvGxQUAIA0z9qK6l+ywMRFEWTRlVmg1CdxkVJ+XB8ByipsgKgwGGEpKanV8jiL/zz8BAIpzXFqQvpATDCIPD4vbN/YaKv754XGk0BYiVBERYBimNEWVBFWjRZebC52xD6Rrhw5clApA3m+/oeTMGUcOjSAIB0GCyklgy0SopOFhAEC9qIh6hS472/z/rCwAgD6fE1QS3/KudiJXV+F93VCNKcraxettjVA10pQ/PoInCE5jy4i6hjUYhAgVbwYk9vHhhpTfeFwpCXP46JSseXOIPTzgPmAAvCdNAgBkr13nyKERBOEgSFA5CfxKNSPjJlqyME5QUS8qoj6hyyojqIyr+PxqPj8ZLYuogVuni0xqx1i9vvIaqsZuSmEU1mKjAHdUhEqbmgZWpQIjlXJmQECdRagMJSUNNgXW2VH9xwkq144dAXC9g5q88DwgkUBx/jyU1687cngEQTgAElROAh+hEvERKmPKn4ZS/ohKYHU65P7+O7LXrat1J72yESqDsXZKJ6T8We671NDTqBiZi/C3PjcXemONEEWoLMPX3En4xscOqqHSGNP9ZC2agzHWTvHvYT7qWhsoLl5ETK/eyPryy1o7B1F9VDdvAgBcO3YQbpOGhMB73DgAQM76Hx0yLoIgHAcJKidBSPmTGk0pjCl/+qxswUmNICyRteYLZLzzLrI+X4N7z78AlmVr7Vy6HE5QyVq0AFCaFqXPywdgPUIl8Q8w7p9Ta2NzJKaOcJp79wCjUBJ5VOLy10gbOwoRTaOgclSkRrBMbxUh3CYxNmPW5ebW2nkzP1sNsCxy1q6jKFU9pGyEisfvqacAAEX799fq+4MgiPoHCSonoWwNlcjbW6gv4PthEERZWL1eMEQAOFME3hihNtAbU/5kkdwEVF9QAHVcHDTx3Eq/xN/f4n6SAKOgym6ggkpRarYhOCGKRBC5u1ncniJURldIo3hxVA2VRjCkaCXcJjY2Y9bn1N6E2dTlUB0TU2vnIaqOvrhYaFfi2r692X2ubdvApV07wGBA8dFjjhheo6dw7z4kP7dAyIqwhjo+HknPzIXyxs06GhnR0CFB5SQY1FxjS15QMQwDabgx7S+Z0v4IyyivXYM+Px9ib2/4PPIIAKBgx85aOx+f8ufSqlRQ5f/9DwBA3qMHZJGRFveTBPgb98+qtbE5EoNCIfytz+Uu9CI3NzAMY3F7ElTmKX/1KkLlbxRUebUjqFiWNWs/wBu7EPUDXXo6AG5Rk09VNsVj8CAAgPLq1TodF8F9z6YsXoziw4eR88MPFW6bsngxSk6cQPLcuXU0OqKhQ4LKSRBs042CCijtRaW9RxEqwjL86ra8Wzd4GfP7i48cqZUJKsuywuTPpTUnnPQFBVBevgwA8H3sUasCQmyMUOkbaoTKxA6eFwtlnf9MIVOKfACA2I8T2qzeUTVUnKAyi1AZRZ4ut3ZqqAwlJWapnvpKVtqJukWXmQkAkAY2sXg/n+6sJQfeOkdx8WLp3+cvWN3OrAF9bq7dyiZKzp5FydnaywAh6jckqJyEsil/gIkxhbF5KkGUhe8DJWvZEm49ewBSKfR5ecIqqz0xFBYK71OX1q0BANq0NCiN9QbyHj2s7ivUUJUxtWgomEWojGKBcatAUDX2GiohQsWn/NV9hEqXlyfUcvGTZKBUUOlrqd5PX6b2pqEatTgrWqOgkjQJtHg/GUY5Dq3JdU0dF2e1XrjsdUaTVPPXSpOYiKSn5iBp9mwUHTlS4+MRzgcJKifBkqBybd8OQGmBLEGURW0iqBipFDJjmqja2FvHnvAXKZGXF2QtWwIMw7mzabUQNwkQbKctIQnkJifaWhB69QFTQWUwOi2K5JbrpwCAcTFGqNSNT1CxLAtDPl9DZXT5c0ANFb9QJQkJMYsm8nWA2tTUWon0ljVmqawWhKhbdJlcFJ7/zioLbxilTU0D66Dav8YK/9oAAKtUWl2MMN0OALRpqTU+d86GjYDBALAssj5bXavmT0T9hASVk1AqqKTCba6dOgEAVNHRYB1kK0zUX1iWhfoWl/LHpyzJWrUEUBq5sid8up8kIAAiFxczAeXWvYfVdD/AZBKSktIgL0RmKX9GsSBysy6oRC6uAABWrbK6TUPFUFAgpDryk1ZH1FBpk5IAcM1bTeH/N5SUIHbgILu/X8um+FGEqn6hy8gAYF1QSYKCALEY0GobbMS9vsKnY/JYK4coW5dY04wNfUEBCrZuFf5Xx8ZCRWYXjQ4SVE5CaWNfkxqqFi0gcncHq1JBbXRRIwgebUoqd4GRSAR7Xxdj6pJp0bu9EARVE662QNayhXCfW98+Fe4rDQkBRCKwKhX0DXASYpbyJ0SoKkj5c+H6VhlU6todWD2ET6kS+/gIz5EjVvo1d42Cqlkzs9tNXzd9Xp4QcbQX5VL+jC0HiPqBJpl7X0ibNrV4PyMWC+6UtZUWSlimnKBKtRx5KiuotKlpNTqv4tJlsBoNZC1awPP++wEAxUcO1+iYhPNBgqqO0WZmIumZuUhZ+mKVeu6UbewLAIxIJEyUVTdu2HeghNOTu3EjAM7al58ESoJDAJS/8NgDIRXGKKjc+/YT7vMcPrzCfRmZDJLgIACAJrnhFXMbSkxrqPgIlXVBJXLlBBWrbnyCyiylSiTmbnSIoOIWHWTNm5W7L+i15cLf9v4s8WYX/OIZmVLULzQJiQDMF4zKIjGaqehq0VqfKA//WWSM0X+rgqqMm6w2vWaCSnmFM16S9+oJ94EDuNtoTtboIEFVx+SsW4eSEydQuHs30l573eb9yjb25XHtzKX9Ka9es98gCaeH1WiE/lN+T84SbpcYnalqRVAZI0u8oPJ7chYCnpuPoOWvQhoaWun+fPRMHRsr3FZ0+DByf/rJqdMAWYMBrKK8oGIqjFBxKX+GRpjyx783JYGBYMTcJcoRKX8aY8qftFl5QeU3c6Zwu9bOnyW+BxX/mTEUF9v1+ET1MajVgnufS6tWVrcTrPVzKUJVl+iNnx3XDlx/sMoiVPxnrLo95YpPnETWN99Aee06AEDetStcIrgWC5paqFMmOM+AzDVrzLI+6gsSRw+gMcEaDCjY9a/wf/HJk9AXFFjsZVEWAy+ojKlAPG69eyN3/Y8oPnECLMtWWKdCNB5U0dFg1WqIfXzg9cADwu1SY95/rQiqMil/jFiMJi+8YPP+rl27ouT0GSgvX4bvY48CAO49twAA4NKmDdz797fziOsGtowlb5VMKRphyp8u06RGxZERKis1VDyysDBok5LKFbjXFEMJJ6AkQUHQJCaa1d8RjkVz9y7AshB5ekJspUk5AIj9G3aj8voKvxjh2rYdlBcvQZtirYbK2C+xbVtoU1Ohy626oFLevInkZ54xu80lIkJIEdampMCgVkNUZs5G1IyEyVMAAIxYgiYLFzh4NOZQhKoOUcfGwVBYCMbNDbJWrQC9HiWnT9u0ryWXPwBw79cPjFwOXVoa1NHRdh8z4ZzwEUt5t25mIltw08vKsvuqf6mgCqjW/m5GW3XFlSsASptZA1yOurOitzIhrqiGSuTaeE0phAhVUCAYiVFQGQx1GqXU5eXBYIwk8s6YZZEEcSmq9l6c0Bfzgor7rOoVJKjqC6Xpfi0rXLyUCL3KSFDVFSzLCp8dl7ZtAFQeoXJp1xZA9WrdCrZtL3ebrGVLiP39IfL0BMo06G4s6PPz68StV1UP57skqOqQkjOceJJ37QL3AVyera0TRUuNfQFu4sXn7BYdoiJIgkN9hzMpcWnb1ux2ibGBLrRau7uHlY1QVRV5164Aw3Cr/tnZZuYUfINVZ4S1kppQUQ1Vacpf47NN1wqNUwMBkcklqg6jVPzEWRIcbFX4lqZ12bdOxlDMCSipUbCZ1t8RFcMaDFWqTa4qmgRjo+eWLSvcjo9eVTeVjKg6rFrNtekA4Gq87lmPUGUZt+Naz+hyc6u8YFN89KjZ/4yrKyS+vmAYptRNtxGm/d2dMQNxw4ZDa3TDtCemje4rcsl1FCSo6giWZZH3+yYAgOf998OtR3cAgPKyrYKqvG06j+d9IwEABdu2kX06AcB64TQjk0Hk4QGgtJbHHrAsW6mdcGWIvbzgEhkJgItSmU6MqpOSUV+wlutdUQ2VYEqhaowRqlJTCkYsFm6vyzoqdRxXx8e/Hy0hcncHYP31rS58zZQkkBNUrELhkBoyZyR53jzEDhyEzM9W18rx1fGcoJJVIqh4sU0RqrqDT/cDw0AWESncpi9Tg8iyrFDvy0eyoNNVya1Tm5EJbXIyIBIh+H9vwbVTJwQue0m436WFUVAlNi5BZSgpgTo2DgBQfPSY3Y+vTSs1D2FE9U++1L8RNVC0yclcXxOpFD4TJ0LerRsAQHX7tllqkzWspfwBgNeY0RD7+kKbkoLCffvsOm6ibsj4eBUSH3vcbpMzPqJjqXBa5OUJwOQCZAf0+flCrYctBhTWkBvT/pSXr5j1cHHmOhJrYxcbha0lBNv0RunyV2pKIdRQAXUaoVLHcZOCCgWVcYXU7oLK+H4xXZiojwXY9Q2DUomS4ycAAAU7dtj9+KzBgJKzZwCU9oC0BkWo6h59ESecRB4eEHu4Q+TlBQDQpZk7+Onz8wFjpEPatKmwwFiVRTve1c+lbVv4PvEEWv71J/ymTRPu5wV3bfR7rM9oTPp+mZpL2QtTe3tdfv1zPyVBZSeUN27i3guLoElMtHi/whiJknfoAJGbGyQhIRD7+QE6HdS3blV6fEu26TwiuRy+07kPc+Ynn9ZJ/iphP1iDAbk//gjl1aso3Fs1QWzQaKCOjzfr02NQKoWUhrI9dABA7MldaPSF9hNUvPOVpEkTof6nOphGbvnCYcC5nc6sTYZFFQoqYw1VA4tQ6QsLK+wpxRoMpamjJi5/AMDq6y5KoxEEVYTVbYQIlZ3FvhCh8vfjGsTWwjkaIqYTOF1Ojll6kD1QXb8OfVY2RO7ucOvTu8JtJf68bTpFqOoK3sxF5Ml9r0pDuBYhZedDOtM+dzIZxNVI3eWFkmv79hbv5wWV2pgpUteUnD2LpDlPI3HadGR+8olN++gLCwXzs+qivZcs/K1Jsn/9mFk/x1wSVA2WpJkzUbR/P1KWvWzx/sKduwAAbn24BqcMw5Ranl+vvF8Bq+FWqi1FqADAb8YMyFq0gC4tDQkTJ6HoMNVTOQumXdp5hzNbSZo5C3fGjUf6ireF2/iwuMjdHSILDpL8BcdQbH9BJbVSwG8r8p69AHA9PFS3SotOnVpQWTOlqEBQmfahcmbLeFNKTp9G7JChSJg0GTorvZX0OTlcJIphIPH3N0v5g77u0pnVccYaRAdEqHgTE5GnZ62JtoaIKiam9B+tVnBptAcl588j8bHHAQDuQwZbXNg0hTel0OfkNJjPb32Hz7gQe3AZGNLgYADlm/byRhWSUE5wlfYMs1388ot91uqFXYQaqjt1/vorLl5E8rPzUHLqFJSXLiHnh/VmkSNLaJKSEDt0GO7Nm1+j8WqSSwUVXwtqT0xNmupj02wSVHaCv6iq/vuv3H3alBSUnDoFiETwMdpBA4C8IyeobGnKa6gg5Q/g6k+arf8B4iYB0OfnI2Xpi5Qm4iSoTdIC+PxjW9AkJkIZFQUAKNi+XXiPaFO4C4a0aVOLTlSlESrbc8YrHQvfBDU8rEbHkYU1hUvrSECvR/6mzcLt1pzynAFrn0Oxp6fVfUzbI7A1XDWsL2R8vAqsSgX17dtIfnaeRZHAG1KIA/zBSCRChAaouxoqfWGhsIotq0BQ8c1DaytCJXL3IEFVBbRlHNWq8l1aEapbt5D01Bzhf8+RIyvdR2wUVKxW69SLQc6EacofAEhCOEGlyygToTIuYEqNTe7516oqESpefAkmT2WQNm8OiEQwFBebmSvVNplr1uDu9Blg1Wq4DxkMaRh3PebNVKxRsG07WKUSJadPQ2l02a0OWhPhZq+SAlarReHefTAoFDAoSwWVtUU5R0KCys6YragaKTp8BABnCy0LK51w8nnYyhvXKz2uNZc/U6RNm6LlH39w26tUKDlzxvaBEw5Da7KSWpWc64Ldu4W/WY0GykuXuOMZnY2s1TKJa6GGSnWLWx12adOmxsfyGD6i3G2sQlFhqlh9pjopf6a9SxpC2l/R0aNmqc2qa9eQ+/PP5bbTCQ5/nCGDI1z+1PFcdEoSHFxhnZu4FkwpWK1WeL1F7m4QudeOaGuIaJLvmf3P18HVlOKjRwGdDpImTRC8YgW8xo6tdB+RXC5EMOvjSnpDhM+44DMwhMhTGaGkTTMKqhA+QmU0EKlKhIpvYh9guReZSCYTxAx/baxtWI0Geb/8CgBw6dAeYWvWCCmJFc0rWJZF0YH9wv8lZ89WewxakwhVWTOQ6pLz4wakLF6M1OWvwaAq7enIKpX1LmhAgsoOmBWOS8r3Si46fAgA4DHCfKIoN6b8aeLvCB2+rSGYUkgrTjWQhoTAd8YM7rxko+4UmNqXa+7ds76hCZqkJORu2Gh2G1+nx6c0WBNUImNKRGXvuarAT5ZdjDa0NcHzvtLPiekCgrNOKvlxl3X1418Hi0ilgphwdmOKnPU/4t68+QAA94EDEfL+ewCAwgMHym1r6vAHcKnR/PNQVzVU/OfHdPHLEkwtpPyZRo3FXl4QudWOk2BDhJ/MufXi0obtJaj4CbHfk7Pg+/hjNruLiY3RC2d2KHUm+JpgsReX5i7URpUxBhGuj8YIlrXtKjyXIKis91x06829D4uP2d/tzhKKK1EwFBeDcXNDy7/+gkguN6nl4gQVazAg6+uvkfvbb0LEX3H2rFk0V10DAahJKZ2/2Csym/XVVwCAon37oCvTV0xXz+qoSFDZAdMaGFajMVtJ1xcWQnHhIgDAc8Rws/0kTZpwqxgsC2XU1QrPUZHLX1n4CWnxkSNkt+sEmJpDGAoLbbIzz/3lVxiKiuDSoT2CXlsOgHPGA0wiVE2bWtxXcPmzkymFvqhISPlzbde2kq0rx7VzZ3hPngzXrl0Qvm6t8J531tQZfjIs9vExu13sWYEpBcMIaX+sEwsqg0olXBDl3boh5IP34TF8OMAwUP8XbWaDC5Rx+DMiRP3rqIaK/z6XGFewrSGuhXQ8/rMv8vICIxYLkcqGEKWsbTTG7z2PYUO5/+3Qu45lWahu3gRQ9cUiIfJRhylfjRl9IffZ4VOphec/z1wo8eYlvNiwFsmqCP41FftbF1Se990HgFtQr4s6Ko2x96R7376C6OdFI2/0U3TwILK//AoZ776HuPtGoujwYRQZF7aEiFpM5SZplmBZFtpkc0FV0/mnNjVVcGQEyvdt1deztgQkqOyA3jSXU6czW00sPn4C0Okgi4iArEWLcvvKeVezSvJWK+pDVRa3nj3ByOXQ5+VBY0xfIeov+iLzWiZbolR8ep//nDlw6805TimjosDq9aUrcE2tpPzZOUKljIoCWBbS8PAKV+xshRGJEPrB+2i5ZQvcBwwo7ZvlrIKqxLKgqijlD0CDmEyXnDkDVqmEJDgYzTf9DmlQECR+fpB35773io4cMdtea6x3kASaFHsbBVVdLQ7xRezSSgSVaYTKXhMmfb5xUmg0k2GMjpkGlfOK6rpAX1gIg1GMuvXrD4D7HlXfSUDhvv3Cd2JVMKhUSJr9FLTJyWDkcsi7dK7S/oJ1OkWo6gR+gVDkzdUIi/345790fsZqNFDzLUWMArk0QmXb5NygVJa2Nmhi/Xrn3r8/GFdX6FLToI6OtrqdveBTXqUmdcxiX74+jHsO8jdvEe7TpaXh3nMLhP6oAc89BwDQJiWjcP9+3Jk4qdz3c0XosrLMF/9YtsaR9bLnLztPrm/RXxJUdkBnkrIFcB84nmKj217Z6BSPm7HvjuJKxQ1+qxKhYqRSyLt04Y57ufoFhkTdYCgyFwqVXfwNSqXgaOXWowdcWreGyM3N2FQvttIaKqEuQ2mfNCL+S463PLc3vPBw2giV8eIrNnFcZNzcLNZbmtIQJtOKs+cAAB5Dh5oZpPBR9IJt25H66nKh3pMvajaNrgopVnVUQ8XbLPOru9bg0/FgMNhN9OoL8gGUiu9St0fnFdW1BWswQHP3LnQ5OYLLqNjfnzO1AVd3eeeBB5CyaBHiRtyHxKnTkP7uezZN8liWReqyZVAY60n8pk+H2NjXyFaqU5tDVB9+YZI3XZL4+XK3mzz/6jt3AK0WIk9PYcFRsLi3cXLOv56MTFZxHaxcDo8hQwAAeZs2VeWhVAv+MyALK3XalZiIRX1REUrOnwcANNu4Ae5DBpduFxIC7wnjOddClkXKC4ugvnULOd9+V4Xzc9/dktAQLmUdNb9m8wvHvDlPWeqbdToJKjugz8s3+581CipWo0Hx8eMAytdP8ci7GxuZXr1WYd8MoQ+VSbF6RfCNg5XXr9m0PeE4DGUiVHx43hqahARAr4fYxwfSkBAwEglcuxoF9KVLwv7WUv74iTqrtM8kjRft/HvZ3oh9fQA470ovP4HjJ1hAxU19eYQIlcaJBRUvtnv1NLudNx5RXbuGgm3bkDT7KbAaTemkwNR+n49Q1VENFd8IVBJcmaCSC/Vd9urpxqf8lUaouLo7ZxbVtUXa8uWIHz0GsUOGIuPjVQAAaVhTiFxcIAkKKre98vJl5P32G+4tWlypwU3J6dMoOnAQjFSK0FWr0GTJ4iqPTxxAzX3rEkOBUVAZU9oF976CArA6Ll1YZaz1dW3bVljgqarLn9AnLyDAoouuKb7GZr9F+w/Uetofb1luFqES0h7zuLmoMVvKvV8/hH/7LQKXLYNb374IeXsFGKkULu3M01rVcXE2j5vvQSULCy9Nh65hFozqPy6y5zl2jMX7KeWvAaK3EqEqOnwEhuJiiP39hYhRWVxaR0Ls7w9WoYDi4kWr56hKhAoAXNtzH4yaFBgSdQM/GeMjSnwdiTV4FzKZSdNR1/YdAABFBw4CLAuRm5vwZVoWkZyPUCkt3l8VWJ0OymucaOfTuOyNxJinrsuuX1+etiKkh5hEPMqm/1mCr6EyOGnKH6vTQWVMdeEXeHhcWrUs17Os5PwFoaZKamIIIUTyDHUUocoyOg1amJSbwohEJulC9qmTMZQRVBShsowmKQkFO3Zy/+j1QiSJX52XmojhyCOHEf7dtwhesQKMXI6SEycsGgVoU1KQ//ffUFy+grTX3wAA+Dz2GLwnjLfZiMKU6tTmENWHT2EXGSNUphkBvNkLPx8yFQ58hEqfny8IrwrPY4xQiStI9+ORd+8GSKXQFxSUM1SwJwalUqgNc2ndWridnwMYCgtRtHcfgNJsKYZh4D/nKTT/aaMQSStbA20oLhYWmCpDc6805VDkyZcVVD9CpS8uhiYxkRvzcMsZXmXn3o6GBJUd0JfxwzcolWBZFjk//ggA8Hn0EavpPYxIJBTRFh+17gZj0FZum26Kq/ELQx0ba9OXBOE4+FUcXiDxTmfW4AWVS0Rpjxz+i1CYWLRsaXX1TORmXPW2g6BS3YoBq1BA5OkppNrYG74uy1mLu/kIlWkKpi3pQ0Ik0UlNKbTp6YBWC0Ymsxgt9Rx1v9n/irNnAL0ejExm3jBTiFDVvqBidTrojcLd1BjDGoLYt1NaV7kIlQuf9kmCypTCvfsAloX7gAFmCzl824ag5a9C5OUFj5H3QRoSAo8hQ+D7+GPwefhhAEDRwUPljpn83AKkvf4G7k6dCl16OmQREWiycEG1xyipYm0OUTP4TA+xsYaKkUhK+7gZBRVvuGAqHMQ+PgDDACxr0wRdsEyvwJCCRySTCddFpdHcpDZQXr8uWPubfteKvb2FKDpvPuE5arTV41gyXlFer7xPKmDS8iIoWLCuN5SUF1TalBSbvst552BJcLBg/87DZw+ULbdxNCSo7EDZDyGrVEJ58SJU166BkcngZwz7WsPdWETL216XhTUYBKcTWwWVtFkzMG5uYNVqwYGNcCzWiur5lTWXSG5lqbIIlUYQVK2E28p+EfIORpYQGe27WTtYMSuN71l5t27VWsW1Bb7Xh85OUYC6xpKggrR8e4Wy1CdTCtZgqHLKCt9fTRoWZvG94T97NnweeUTox8f365NFRphtX5c1VLqcHIBlAbHYaoTXFEHsZ9nnvSmYUviUiVDZKT23oVBsLFb3HHU//J8ubbrrMXwYAO77qPXJEwj78kuz/Tzv55ryFu7da3bdVickQB1jns0R+tFHNkWSrcGbIlANVd3AZ3qITBqm8wYV+sJCsCxbGqEyuV4yYrHwOutsSM/kMyVsNWBy7cBlj6j++8+m7atDwT9bAQBuffuaLaQyIpHZwpC8V0+hXY8lLLn0qm7YJqj40hexry/E7kZBVSblr/jUKcTdNxLp77xbqckQn+7n2r49t8Bm8rh4w6Cy5TaOhgSVHbCU8pdj7BHkPWlSpR88vphfFR1tMWpgWltlq6BiRCK4GkO/KpOGmkTdwxoMuDt9BuJH3l9O3LIGg5COwAukymqo1PGcS5EsojTlz6VVSzDSUgdIF5N0wLKU1mXUfJJWco4zHXDrWTv1U0BpP5e67DhvT4SUPxsm6KYIKX9qjd3HVBX0+flIfORRxI8ZUyWnRd51SlYmtY9HEhCAkHffgdf4cdz2Rvct17KrpHVYQyXYtjdpYtMCgVDQbiexbzVCRSl/AgaVCkrjJM994EB4DB8O74enwHfqVLN0J5FMVi5K79a7N1zatAGrUJj1aVScO2+2nTQ8HK4dO9RonNWJULEaDfL/2WrWj4ywDf45M43+8z2p9AWF0GVmcdlEIlG5bAohddeGmhxdNl9DZbmpb1nkHTsCAFQ3a0dQFR0+jIJt2wAAvtOmlrvfxWSe4P/UUxUeSxYRAe9Jk+D98BQE/+8tAIDiwgWbxsFnaol9fa2m/OVv+cP4ewtudeiI9HfesXo8XoC6dugARioVahKBUsOgstlhjsZpBNXx48cxYcIEhIaGgmEYbDO+gXhYlsVbb72FkJAQyOVyjBw5ErHGnNLapqyTiS4rC8UnTgAA/KZXHJ0CAEloKFdEq9NBee16ufv5+inAdkEFlOYJUx2VYyk+ehSKixehTU1F2ooVZvfp8/IAnQ5gGMhacYKqoospq9EIosz0i5KRSoX9AcB94CCrx7BXyp9BpULJ6dMAIORg1wZS4wqb6vZtp+yrxkeorDkVWYOpJ/UzOevXQ3XzJrR3k5D/518276dNNkaorAgqnrKCq+wqqSBs6qCGSpeRAcC2dD+g1DY569PPkLd5M/L//gdx949C+nvvVytFkV+cEwmmFHyU0jnTPmsD5bVrgFYLcZMAIfoZ+t57CH7rzUpNAhiGgcdQ7rvK1FmXbwLs99RTCPvmG4R/u67SY1WGsBBUUFCh4ZQpOT9uQNprr+He8y/U6NyNDVajEczAxCYRKv5vfWEB1MZ0P1nLlhAZ06l5hHo3GyJUQg1VVSNUN2/a3ZiCZVlkf/U1AMB3+nS4WapjlpSWm3gMHlz+fhMYhkHoyg8Q+t57XL9AcG1RYocOE+zmrcF/d4l9fYQei+XmxmUEK2/Zbgm+/ta1A5fuJw0qrYvkewRSDVU1KSkpQdeuXfH1119bvP/jjz/GF198gXXr1uHcuXNwd3fH6NGjoarGKnxVV4f0ZfJEiw4dBrRayFq0MFsxswbDMCb9qMqn/ZkJKmnlfah4+IlJdRu11RSWZZGxahXy//7HIeevL+T8sF74W3HmrFkuNb8iLvb3FyIYhgoa+2qSkgC9HiJ393JOVh6DOREli4iocHWVT/mzGA3VaMzebxUh9BgKCYFLmRxne+LWrx9Enp7Q3k3C3Zkzoatnq1KVwT/PfGTQVkT1pH6m6MBB4e+Ss2ds3k+TZHR9alaxoJL3MI9uug8YYL6BhEuPrIsaKq3QWLhJJVtyuHYuNRtKX/E20l5/HdrkZOT9+ivy//ijyucvG6ESUYSqHHx6k3u//tUSPbwbqeLMWeE9xQsql8hIeI4YDheTxanqYlq/Yut3VvZ3nE214tw5wb6fqBzTyLmllD9DYSFUxoVl17bl09qqFKHKsr2GCgBc2rYFxGLoc3OFBZvqwOr1MJSpp1WcPQvVf/+BcXVFwILnLO4XMHcuwDDwmzWrSvNHaXAw5EZ3Vl1GhmDUYg0hQuXjAxHf67K4NOWPNRig/q98Py5LItOgVgufSV6QSoJL5zu8CRdFqKrJ2LFj8d5772HSpEnl7mNZFp9//jneeOMNPPTQQ+jSpQt+/vlnpKamlotk2QIfXbIVoc+MccWi5ORJABYmBhUg79IVQGneqCl8UTojlVbpAsLnCTsqQqU4dx65639E2uuv10mn8PqI4vIVKC9fBiOVwq1PHwBA7k8/CffrTCZwImOqgkGhsGokoo4zOvxFRJR7LzRZuhQtt29Hyz+2VJiuxJsdQKs1WznVZmbizoQHETdqtE2TeKHH2vDhNV7NrQixhweaLFoEAFBevISCf5xHoLMmPYr4yCBQ2ly5IhgXx0cntBmZgtMSwDV9tBXNPd7Gt2JBJfH1hfvAgQC497Us0jwdp05rqPjCahsjVF6jRyFi/z54T55c7r7CffurfP5SQeUDgCJUZWF1OhTu555X36lPVOsY7v36QuTtDW1KCoqM32GCoLKjsQ4jElXJkltfVGRW16qqg2awDQXedELk4WFmAGaa8sebHJS1BgeqFqHia+IqauprisjVVcgmqU4dlS4vDxmrViF2yFDEDRtutuCfv5VbXPCeNBESX1+L+7v17InWp04icNlLVT5301WrOEEIQHnjhtXFVpZlBYMIia9vae9Ik5Q/TeJdiz3gDBYCGOrbsUJrGN6AQmRspA5AqAPTFxTUq6wVpxFUFZGQkID09HSMHDlSuM3b2xt9+/bFmTO2r6jy5G3aXCUBYCg21kjwIWDjvmVXXitCGsY5s1halaqqZToP73iky8x0yKq+aYPaiuqCDGo1UpYuReJjjze4VbkC4xee14QJQi+T4sNHhNeUXxGXNgk0S1XQW+nfoL7DG1KUr5FiRCK4tm1TaWqZ6ReTqXDK37yZa5SZnl7pxZw1GFB05CgAwOM+yz3W7Inf9GnwvJ9zhXOmZtWmDn0iV1cEr1gBWcuWCHx5WaX7CoYEddyHimVZlJw/j6KjR4U0GV6Ea+/ds+kCxrKsIL6s1VCZEvrxRwhd9TGaff9deXFepzVUxvqIwIot002RNWuGkPffQ7ONGxHy4Uo0My6YKC5cEJps24ogqARTCt7pkSJUgImrqJcX5F27VusYIjc3+D7xOAAgd/2P0OXlCfWZ9ohMmSI097Wh5UNZUwxe5BGVw4sMkZf5QhVfT6UvLITK+PzyLWXMtqtSDRUfobKthgoAXI11VEorxmMVkfHBSuSu/5FrzpuXB1U0953M6nQoPsb1OfUeN67CY0j8/MBIKjdCKos0JAQtt23lFnu1Wqtpf4YShWCcJvb1tZjyZ01MWnLvNaufMl4PTBd/eVMKGAwWBZmjaBCCKt04CQ8qkwIVFBQk3GcJtVqNwsJCsx8AUEdHQ2EstrcF/k1jZvULQN6ls83HkIYYexBZ8Pw3VFNQiT3cIW3WDECpBWVdwjd6A0odvyyRv2ULCnfvgfLqVWR8+FFdDK3O4J0bPUfeB3nXrhA3CYChuBhx941E0rPPouQ4Fw2VBAaa27xaSftTG79MTR3+qgojkwmpKAZFadqf5m7pa1TZ+0V96xb02dkQubvDvXfvao+lKvjNng0AUF67WifnswemgpVxdYXv448hYs9um0RGqWV23Qgqg1IJfUEBcr7/AUkzZ+HevPnIXMU1TPUYNgyQSMBqtTalrejz84XvRdOeUtaQ+PvDe8IEcydEI3VaQyVEjG2LUPEwDAP3fn3hM3Ei3Pv2gVv/foBeX6V0Z1avFyYHvOtYXb8H6jvKq1EAAHnXrjVyFfWbNg0QiaCMikLJcW5SKg0NrXKdY2XwxgW2TNT5iTKPhgSVzfAOf2JP83YUfIRQm5ICTUICAAgRF1NsjVAZSkqEWi1bXf4AwH0QF4HnFyFtRV9UhMKdO81u4+dVqlsxMBQUQOTpWWs9IAHuu41Pk0yYOAmZn60ul35tKDTOV6RSiORyiyl/Kiu28ZYcUksFVWkpgYuJczEjkwmf1fpUAtAgBFV1WblyJby9vYWfcJNJTs5339kUpWINhlIXLxNBxcjlNk0keHjXEl12drmwKqupmmW6KfwHQeWAtD/TVKGKrNtLzpwV/i4+dszhNSP2Qp+fL1icy7t3ByMSocnC5wFwEbuSY8eF3hAuxno3U5vXsiguXBC2d6uBiGEYptQ6XVkagjeNDiqvXqvwGPxr69KuXbXel9VB1rIFAECfle007xH+4svIZFWeAJame9X+Y2VZFomPP4Hbffsh67PPhNvVsdykTt61K6RNObGjsSHtT5vMbSMJDCxXAF5l6rCGytTlryZ4GrMlrE0iLGH6meej1aI6fA84Axqjw6kle+eqIGnSRKhbzvryKwCArBb66ImrkErGZx/wLS/4zx5ROUIPqjL9/fh5VcmJE4DBALGfn8XPtthGR0Y+msLI5VUS3x6DBwMSCTTx8WbzosoQejEFBcF7CpdWzDfQFVqWdO9mtc+pvfAcNUr4O+e77zjbc5P5sVD2YnxOLKX88SLJrW9fs2NbckgVUnBNHF/958yBzyOPoNmPXE262JjiWJ+s0xuEoAo25lhmlFk5zcjIEO6zxPLly1FQUCD8JBsnARCLUXL6DPK3bKn03AaFUkjxMy2+dmnVqkoTKLGfHzcxZVkhDYynuil/QOlEXX2r7vOxTVcOTKMfprAsC+WV0hQuVqk0+9+ZURgfh6xlSyG/2fexR9Fyx3aEfvqJWfGsmzE91DTn2xRWp0PqK68C4CYDrp1tj35aguGd/kxymrVppSmahXv2CA2ELSFYYoeVb9haW4h9fMAYhaDOSVJDeeHHj7sqiATb9NqfTOtzc81SjmTNmwsNIhk3N3hPfAiycC7azbv3VQQvuqSVGFLYAv89WqeCqooRqrLwjShVMbYvZPFpZ2Jvb6F4vNQ23XkjVNq0NMSNuA8ZH31c42OpE4wtI1rWPDXPe8KDALg0VgCWHdJqiKQKqWRa43eqxwjOXU195069qg+pz/DXS1E5QcWlhvHXOdd2bS3W+/I1k2XnXmUR0v2qEJ0COKHn3odbBOX77dmCYKTRoYOQjsq/T4SWJVUoLakuPg9PgfuQwZCEcs9n/pYtyPv5Z+F+XlDxIlPkzpUV8M87azAIgsp/7jNw7VJq5sOXzJiiSeIW4GUtmgu3idzdEfLuO4I3gSCo6pHTX4MQVC1btkRwcDAOHSrtfl5YWIhz586hf//+VvdzcXGBl5eX2Q8ABMyfDwDIXrvOai0Lj9AJWiKBrEWL0mNHVm21i2EY4SJetrFrTQSVq7EA0xERKtMPisZKyp8+P1/4QHgMGwag9hrgFZ86hbszZ1Vq/2kvlMZaH34llMe1TRt4jxvHFYmKRHDt2FGod+NXpvkVN56Sc+eEmrSwL7+ocRNdPjWCT5Vg9XroMrj3nax5c7BqNZLmPG3V8ZKfhEjDaj5hthWGYSA1LpA4S62dYEhRjSgNP5lm66APFZ8OA3CWtE2/WIMWmzchaPmraP7jekh8fYUFI9siVNznnRdhNYJffa3lyaVBoxG+i2x1+bOGSxtuIUuXni7URVWG1oKYawgRqpwNG6BNTUXuhg0Wi9KrgiYhEUBptLomeD/0IBiTelKPEfavBa1KhIr/TnUfMACMVApWpRJuIypGqD0sI6gkwSFm/7uU7XFXZjtdRoZVQyig6k19TfEYzr2/ig4fqmTLUpTXuUwRl3ZthbpOXXZ2nbUs4RHJ5Wj23XdoffgwgpZzC7vZ330vLPToywoquVFQGTNgNAkJMBQVgXF1hXufPmj5xxZ4jh0DoHx9qEGhgN6YBihrZv36wadF1yenP6cRVMXFxYiKikJUVBQAzogiKioKSUlJYBgGixcvxnvvvYcdO3bg+vXrmDlzJkJDQzFx4sQqn8t32lRIQkKgy8jAvfnPQZuSAm1GpmV7R2OdgNjdvbRQDoCsgsaq1uA/pGWL9FhtzQWV+s4dm+2w7YVpQSK/4lAWvmZMHBAg5AFXpQFewa5/kb1unU0reWmvvQ7F+fNImDylTlwHS06dAgC49exl8X7fRx9F28uX0OKvP4WQPR8qL9tAlReZXg+MhbxbtxqPrbRYl7sQaRISAL0ejKsrmv/+G6RNm0KXni4UvZaFL7avSlqrPeA/Y9rU8rWG9RFDDQSVqA77UPGLDG59+yLy4AG4tm0LSZMm8Js1S3i/SY3iSGNLhMq4iioNr/n7o64iVHreOEcqFS7W1UXs4S6kFllbTCpLqSFGqaDizUCcOUJl+n1edMT21fmysBqNEJmWNW9eydaVI3J1RZOFCwEA3pMmwdW4qGVP+Bqqyho/swaD8J0qa95CaNqePP85FB2yfQJeEfriEqdJla4qvIui2M/c6U4aFCjUCwPWU0UlAf5carHBUKGBVlWb+priaYw8Ki9fgdaGOlRWpxNqrN379y8VEAUFUEZd5VqWBAbWassSS/hOnQpJYCD0OTmCqCsXoTJmwLDGGm0+mibv3FmIvouMbUTK1ofy1w6Rt7fQPsISYl8fABShqhYXL15E9+7d0d046V66dCm6d++Ot97iujm//PLLeP755zF37lz07t0bxcXF2Lt3L1yrM5GRyRD+9VcQeXhAcfEi4u4bibihQ3F32vRyE11eNIjc3YVmY4B5AZ2t8Dac5QSVUQiJqiGoJKGhlTq01BamgkqbeNeiiNEaBZU0OFhwwrG17oA1GJD60kvI+nxNucJNS/ArGaxKhfy/bG9QWh20aWmcCDJpJGkJkaurWQqCYEpRYr6Sy1vfW1thqyqm/TmAUvMMeZcukPj7w3PkfcbbL1ncX7COreFKflWRhPARKicRVHwNVTVS/hiZMeWvDgwJ+OinS0SE1Xx8PkLFp5xUeLwkO0ao+MaUFawc2wN+IiVpEmCXNgC8IZDNgspCU+FS63znnQib1s/mbvyp2otZQv2KVCqk+9QUv9lPImLvHoR88L5djlcWXlTr0iqOqGtTUzkXM6kU0uAguLblxJ0mPh73Fiy0Ocppjfxt2xA7cCDihg6D4pLl73RnRp/PXdt5V0UeRio1q5ni5xhlYcRiSI2mZloLxmDCearY1NcUadOmcOvVCzAYkPnpp5V+DlTR0dDn50Pk5QW3Hj0E5099fr7Qr9StV89abVliCUYqFeYHxcb0RX6+UhqhKi0pMCgUyP76G268JvVT1mqES7MbKs5+EQRmPkWoqsywYcPAsmy5n40bNwLg0oHeeecdpKenQ6VS4eDBg2hTgxUn1w4dEL72Gy5n1FgUrbx8GSlLl5ptJ9h1enubhYFlFmytK0NstOHUl7FYrUnKH8Mwwsqbqo6d/vgwMGD8YBnTJxUXLwqrClrjhUYaEiI0o9XcvVtOuFrCdCWp6ODBCrY0No8zsQ3NWfdthaH9msKvxMq7d6+SvWqpoDLPK+Zfu5oWY/MItVrGlD/F+QsAIEQJ5T16mt1eFtMmfnVJRW6Y9REh5c84Ma4KdWlKYTC+D3ihbQk+vVOTXHnKH79NZU19bYFfSDK1za0NtIKgss8iAZ+uorXh+QIs128JE5NaiFAVHTyIOxMnVVgrWVMMGo1QGwYAquvXobhg+TulMkyfH3tNIhmGgaxFi1qblMqMdS+ahIQKrzdCj6SICDASCVzamUcdig5WP0plUKuR8e57YNVq6AsKkDxvfoWiwRnR5fLXo/JC23sy17tUEhJSYSmGsFhXwXMjLLrY2NS3LAELFwIiEQp37ERMz164M2GCYDJRFl74uvXoAUYiEaI1+oIClJw/D6C0SXVd4zGCE1RFR4+YGbPx8xdGSPlTovjUKehzciAJDITfk08Kx7DWtJyvt68o3Q+AyfNBtulOgVvv3mh9+DDa37iOFn//xZlVHD9hNqHgX0yxlxcYkQjh365D6EcfVi9CFWBczbISoaqumxrfyK4uG/yyer1Zk0KAuyAWnzyFu9NnIOHhR6AvLBRyxCUhwZD4+gpFj2obmhqaTlQqy1HX5+YK4xF5eHBNHfdXvfGmrZQYU+U8hg+r0n6WBJVBpSq1fLXQlLA6mKb8sVotio3WwR5DBgPgml8KrkRlHBpZli2tNbHTSrGtSIWLnnPUUBmUNTClqMN0L97etqKGwzJj+p6hoKDCFXODWi1EWypr6msTxhSR2hZUOrsLKttrzgDTaH1p+w8+QgWt1u4LQPcWPg/1rVtIWVZ5T7TqwqfoMa6u8Hn8MQBAzg8/VOtY2gz7GIbUJdLQUDByOVittsL3gdJYysC78rr3M3dCszXKaQnF2bMwlJRA5OUFl/btYSgqQsGuXdU+Xn1EWOCzcD0KePZZNFm6FC1+/aXCY9iyWFe6AGzd7Kwi3Pv1RfDbKwAArEIBdWwcsteuFe43qFTIXvctkp9bgJxvvwNQ2s+UFxCsQgGF0RnZY/Cgao2jprj16Q2Ruzv0WdlQXLholqnF/eYEFatWC87EXmPHQOxR6oxorWk5n1JemaFR6aIwCSqnQ96xI9x6cqv2xSa9BPgaFH6C6jF0KLwfeqha5xDyrcsIqur2oeLhoxrK69ertX91MBUE0ubcSoMuMxOFu3cD4Apwiw4cgPLqVeMYuRU51w5clEppQ9qf6cpOZZ3o+QmeuEkA/GY/CQDI+WF9rdRSsSwrPNfuffpUaV/BHcfk+VPHxnGWrz4+dptM8A0QDYWFUFy6DENhIcS+vkK9jNjbm0tPQHlXIlahEES+vVJvbEWooXKSlD++/qlGphR1EaEyGsiIjA0ZLSFyc4PYmJZc0eSQXyQRubvb5f0hRKhquQbU3oJKqDmzUj9aFr6/jKnRi+n7xp6pn6bfe+rbsXY7blmECWhwMPyNfeRKTpy02MyzMuzlwFiXMCKR4M6mjrdsg65NS0Pur78BKM0QcG3fHk1Xl7YvsDXKaQm+zsVrzBj4PvZ/9u47vql6/QP452QnTZvuRVvKpuw9RGSIMhRFURzcKzjAPS56XdeBiuJ1IuIegP5EcYJeFWSr7L0pUFra0r2btNnn98fJOUnaJE3SjLY879eLl7Y5OeebNj05z/k+3+eZBcD5Gqat4rOQvMEHVJLY5ucbkUKB+PnzhKql7ggFjzzcrOM/dyQeqke3JObGG5Hy6mKhIEr9xk3ca7VakXfzLShfsgTazZthqa6GOCFeuJ4URUY6rQeTZWY6FUILJZFMhqirrwYAVH35RfM1VA43EOt/XwfAXpRD2IfC9QyVvSF8CzNUfApkbY0/LyEoKKDygcp216jxmD0wsQopf+5TZbwlFKWoDOwMVcTo0VwTw/37oc8+3bpBeom/Y8HIZJB14u5sm4pLoN26Vdim+D/PCCXSVbZKeEp+HZUXlf4cZ07MLQRUQuM/jQYxt94KRqGA/sQJnwpgeMtcWsoFeGKxyyaCnoj5/g2OAVUO35PBdclXfziWZ9du2QyAq7LouH4m0lb1Srt5s9Nzzba+D4xc7nTiDAWhGlNRcUgKi7SWfYaqNUUpgj9Dxafj8u8/d7wpnc7fTZdmZATk/cpIQxtQSQN0wS6sOfNihoplWRgLbUUJHAp5MA6pooEsTuLUnNlsDtrfklC8JjUFss6duTUsLAvttm0+76s9BlSAveKvu0a9VV98CVavh3LQIETbeg0BQNTUqei09B3uuRf8r/bXYKs2qxo+DBFjuAazjUePhrRAhaWuDvWbNnldBt5UUoKz48bjzOhLYDiX2+L2Zg8zVN5qKeWPZVmYbcWQHAuQ+SN6xgz02rUTjFQKa20tTIWF0G7dJqR+AoCiXz9kfPopV1gDXHDuWMVQNdx1satQibn1FgDON0j4G8KMXA7Yzv2syQRRZCRUQ53TE+03DJvOUNkCqs4tBFS2n4WVUv7aJ6FinkNQYk/5c1+NxFt8QGUpbxpQ+d/YF+AWQ/K9LerW/d6KEXrP4lisw/YBWL9xo8uZJGmnTpDaqjYJM1SHDrd4DMcURmtdnccLLgvf+C8yCpKYGK7RHpoHC4HAB4Pybt18nplwlfInXJQEoGIaT8g/rq5Ggy3dhP+w5fHFNBoPHXJKO+PT/UI9OwXYUy0c1+S1ZayeK0rBVzTyRSh7EAl/r5HuU/4A+0JhjzNUQo+ywLxfmRCtoQpUU18evwbAXFYmFCdxx1JZyTWBZhhIUlOF7zMikf31B/ACWLdjp9PXTYvgBAqfqszfSVfZZuwNp32/sWcPqEJbCKe1+Iq/rhr1siyLut+5z+S4eXcJFdCE59r+3twVdWoJazRCb0ufVw4eDGlaGjfLbDJBH8KMleLnn0fh/Q+g8hPv0j3r/vc/mMvKYKmpEW74uWPV64V0fnGTohS+aCn7wVpfL5T9l7ZihorHyGRCCr/+6FFo/+RuMsT84x/IOnUSXb7/TkgB5TmuWQ7X+imevGdPSNPSwBoMqP3pJwD2G3IMwzjdbJX36NHsve2qii1rMgkFkqQtzVA5rClrKyig8gH/5jbk5Agf7vaUP88XIt4QCzNUlc5dqG21/FszGxB1xRUA7FVZgk1IIVKrIbWti9LaCjWoL78cSlv6pCQpCd1+/024k60cOhSQSmHKz2+xKqE+27nIhtlDx2xh0b0tpYnvOdKaMr5ux3WMS1d0V1HIE5cBVXFg7oo5ktoa8hrz8oSUH0WW8/osaUYGxHFxYE0m6I8dE75vqbaVqA1xQQqA+xvgj9se1lEJM1QK34tShLIHER+cilqYoeLz2o2F7gMq/g5jIJr6AhA+iK1Bn6GyNe0MUEAljo4WGo22VMhDWEuanNysmmswSqc37YVjDVLajDGPD6i4NcVSW7Doz9+uuZwLqAI1gxgq/AyV4cxpGM7lonTxYuGzzXD6NMwlJWCUymY3tACuKTxEIlhqa4Wy+r4wFRcDZjMYhQLSTp3AMAyUAwYCAPQnQ1ekik/7Kn/7ba+2d2zX0VIPTaEPkUTS4vnLE/7z1V1FRv5zWKzRQOTQv6w1lP37AQAajx1H48FDALj1Se7IHNbmq5r0tww1hmGQ8OADTt9z7Pvl2OPNVd844YahwwyVqahIaN/S0o0TEa2hat8kKSncAmmzWZjiFFL+ogKQ8merBscaDE4lx4ViCq34I1aPGweIxTBkZ7utKhNIfClLcXS00OSSpxwwAJ2/WInMb75G17VrnGbexGq1sO5I9/ffbvdvrqoSpt/553vqRu84QwUA6vHjAJEIhpMnhTsigcLPUPGzbb5wFVCZ+Ts2qZ5zwH0hdF0vKgLb2AhGLm/W24VhGCgHDwIANB4+Inyf7wHFl5kNNb5wiak4sL+3YLC2ZobKiwtpw7lzqP3fr61O2RL66bWU8sdXrvMwQ2W0pajKMlrfKwhwmKFqZ2uoAIcZhhYCKqOHWT1RgEunW/V66LbvcPpesO7yGnK4wIG/EJR6UUnNHVeNj9sD/saa4cxZ5M2ahaqVXyD/zrvAGo1CipeyXz+X2QwihUL42RmyfQ+AjEID9k7CTUu57eK2abGhYGn6u/amn5xjEQ5DC9WJ7QUpoluVYswHVJbqapczyqYLts/hFtZi+ULRlwuoan/+GYbsbIBhoBrifubJsRiGNAC92Foravp0p79Hx3Rlpxkq2/WGI1c3DI1Cu430Fn+X/Boqa3190HsUeosCKh8wIpG9V5Tt5B7IlD+RUilcUDsu2rUGIKASR0cLRTW86dnUWo6N9pqW+lb07gVGLIZy0CCXsxx8bjCf++0KXxVJ1r2bUJqW/524Yq23pTTZZhIlMTFQ9u/PHceLMr6GnBwh9a4lfB+t1sxQWXQOPbz4E7lDKlBriePinNK7lAMGgHEoK89T2JoGOn6YC4vnA1HBzQ9Sfh1VSdufoWJtM1QiP9ZQOfYgchcwFdx7L4oeewy1P/zg/xhZ1vuUP9uHOJ/K1WxfFouQrqscOMDvMTkKRcofazYLPWYCecEu9bLSn70gRfOASgisA1SUQrdzJ9cUNCUF8h7c7EkgAipLfT1KX3sdZyZORNETT8JYUADjuXMAw0DRhzuP8L0a/QmoXDU+bg+kiYnC75W/cWEuLoYhNw+Gs1zJej4t0BV+qUHTINgb9vRb+7mavxAPVUCltTWn5Zkr3N/4BLhziOP1jzE/3+PaK75kuiTG/3Q/gLspzs+qmFx8tgip950C9zms6McFVHxrAfXlE53a7zQVN38+ZJ07I/6hB0Pef8oVRiRymll1vCZwDKgcC+0Iz3Vxw5DPhOHPS56IHT6r3M1ScQXCjrWYch0oFFD5SJrAncz5TtdCg1M/Ome7IhSmKLUHB0LTNFXrCgBE33gDAKBq1aqgR/TCSS42DtKMDCEYYJRKKAZ4vtDic4Mb9uxxm+aj+3s7AEA1eLBX1XmazlAB9nKkDQfdB24AV+Xu3DXXIvfGWbBodR63NZWVcXe6GcavnlH8BS2/0JJlWXvKXwBP5AzDOOVn8ymQTfEf5o5pF453PcNByHW/0A5mqAx8yp8fZdP5ggQs6zKYMOTmwmTr2VH1heeSwJ6wjY1C01yRh7LpACDryl34mcvLXV6E60+egrWhAaKICMh79PB7TI7sM1TBC6jMlVUAywJicavWYTTFz9K1VOlP+JtysU7S1VqD1uDTviMnTIBYEw0gMAFV8dNPo+rzz2EuKkbt2rXIueJKAIBy0CAh+0KYBaio8GnG0drQIGSDtLeACuAK/jRlzM0VUv/k3dxfQEZN56qp1fz4o88z0UKBGIdAXRbigIpfI8Yzl3q+EWauqAQcrk9Yg0FIx3XFU8l0XzAMI1xLuCqdbgpGpkiP7k4z4tHXXedxe2lyMrqtX4eE++4L2BhaK+KSS4T/d/wdOP6/q5vBrpqW89di3qwPY6RSe0aPm4Cq7tffkHfjjSh5OTiNu5uigMpHEluaE3+3jL+T4kvzVk/4xbsGh4pAfHTNtDJvN2rKFIgiI2Epr0DjkSMtP6EVhI7isTFgRCKkffABoq66CukffNBi7yLV4EGQJCXBUlXlcjbNotWhZs0aAEDk5CnCGi1PpbSbrqECuC7jALdA290HVcP+/bjwr38BFgssVVWo/eF7j2Pny8DLunb1a0aR7/Ruqa0Fa7Fwi9WNRoBhAr52wLFredS0qS634dMWDWfPCsUo+A/iljqZBwt/QdDSGru2QJih8mMNFeOQAuQq3avxwAHh/83VnqtcesLP7DIqlVClyR2xOkIoGcynczni10mqRo9yqhjZGvwaqmCm/NkbdsaBEQXuY1G4eHXxs3IkzCS4+JuyrzVofUDFWq2o38qvZZ0IEV96uKZ1AZVFq4N2K7eoXt6ju9MCdMc2IuLoaKH6ly9BHH/OEUdHO92Zbi8SH12AmFtvQcS4y4T1w8bcc0LlP3m35ilRvAjbedpaX+9z8RChLUmWvVEwf41hunAh6Gm0+hMn0LBrF3ejwpbdY3KsMOkCH3BJkpKE9DqThzWbwppeFyXTfSXcrHNxc1YIqAJ5Y1MkQuTUKQC4GbKI0aMDtu9QiZo2FbG3346Ul192mjVzvDnkqm9X07LpVqMRjftszYyHthxQAfbq2u7OJWWvvQYAqP3e/wwOX1BA5SP+7pi5tBRWoxFW2y9S7GGa1hdCE16HFKtApPwB3IWJ+jKuclvtmrWt2ldL+As8PkBQ9OqJTm++0axhoSuMTIbY2/4JACh7861mwZ/u77/ANjRA2jkDEWMusZfS9jRDxTcudZihihg1CoytAIYxJ6fZc1irFcXPPQ/WYBDW7VSuWOlxdq/mm9UAAPWlzRcYe0NIgbQ1z+VP4pLERL+rPLoTc8vNUPTvj4QFC9yuh5KmpHAzDRYLtH/+CXNVFQy2xcz+rBELBD4dwF0Z4raEvwhm/OlDJZMJF5+uLqb5jvIAYKmo9Lvxq72hbLJXaSTybtwslfGc898Ma7Gg1nYDJHKC6xlPf4RiDVWgK/zx+FQ3/cmTHmcX+KIU0k6uUv4CVz6/8fBhWMorIFKrETF8uL1Slu1mib90f/8N1mSCrHNndPn5Z3R6+y1I09KgGj4cmhn2gIoRiYRZeIsPVTqFaoEOi/LbE5FSieTnnkPGRx8JFWYNZ87YS0R3c5/yxygUgC0d26r1/mdWu3YtGvdzF6hKhwIGkoQE7lrCag3qemrWakXZO1zZ96gpU6CyzTqYSzwHVHzAJUlKElLIHIu6mIqKcPbKySh65hkuPZD/241t/U1tiUNhsGbjElL+ApuZkfivfyFt2bvIXP1NwIpdhBIjFiPpicedSv4DgDjC3sTX1ay/Y9n0ut9/R/aAgbA2NECSmAi5ww0ATxzbv7jieK3WUiAfCBRQ+Yi/C2KpqRZmYSCRCB9MrcWniTmmWAUqoAKAGFu3+tqffvKruaK3LLaUP7GfJ7noWbMgjouDpaoKebNuQsG990H719/QZ2ej4n2us3jk5ZO4aXrbXSVPHw78jKI4zv6HLYqIENZr6Xbvbvacyk8+hTEnByK1Gl2++w4ijQbm4mJh/VazY1RVQbeTK0cc849/+P6iATASiRBUmSsr7QUgArh+iieJj0eX775F/Px5HrdTX26riLh5C5e+wbKQ98kKaNVBXwh9XQoKQlJSvDWEsul+VOhkGMaeFuEimHBcuA2WdXkR4A2h+aqXv0+Z7W46v/6Dp9u+Hab8fIg1GkTZ7roGAiOzzVC1sIaKZVnurrsfBTqCUZAC4IJPRiaDtb7ebWEK1mgU1mzIXKX8BXCGqvqrVQAA9cQJYGQy4YaXN58FVf/3FXJvuNFleqnQy+7yy8EwDCInTUL3jRvQ+csvmhVb4PvH+DJD1XiUW1vRXgMqR/zdet2evYDVClFkpMf3HcMwwqycLxXNan/9Vfh/xwawDMPY11HlBS/tr3btz9Bt+xOQSBA3fx4kybbsnpZS/mzLHaRJSZBlNp/hLV/2Hkz5+aj9/geUvfYa9LYS/N6su2kJn6bm6gaDPeUvsJ/FIqUSkZMmQd4B3tuOHFO+Xc36i9W2egGlpbjwrwXC9zXXXuv1+jBPpdONeXn2a3QAxtw8r/bZGhRQ+UhsW2Ng0WqFxZWS2NiApYnIe9lmqM6cEaJrIaBStj6gUg4bBsWAAWCNRlR99VWr9+cKa7UKJc39vegWR0YiY/nnwiyIdssWFMybh9xrZ8Bw+jTE8fGI/cdsAA53gY8fd3vRxV/MNK2ipRzCpV80NimAYa6sRMWHHwIAEh97FJK4OGF2r95N76r6DRsBqxXyrKxWpcPxd3MsVdVBO4n7gm/wW79uHUpfWgQAiL7uek9PCSpxfDx3IrVauUXvAeJt00lf2Mum+z5DBXiu8NZ0DYSnoiye8NUSJS7SMlzh13sYmsxQ1W/kSnFHTpsa0Dut3s5QlSx8AWcvn4TiZ5/1+RjCTHByYCtXMlKp0NybL1bT7NjFxYDVCkahcJnpwL93mjbA9JW1oQH1GzYAAGJvmwPAoUiEh3RpgCtkUbpoEfTHjqH0lVdQ36T9hm4Xd0OKP0d6whcGcrfuoSlzZSWqV3GBoLKF9bftAZ/lwhcikHfr1uIFpPAz82VWz9YQN2PF8mb7D/Y6KtZqReVnXM+phAcegKJXL0iTbGudSz2fp8wOM1T8Ol/+ekK3Ywdqf/xR2Lbqy/+Dzlb0Qt6kZ5M/hICKL8VuY21sFApthfOzuD3RzJiB2DlzkPb++y4fF7tYJhN/371IeOhBr48h3Jypax5QNW0ezrddaIm5uhqlr7/uV/VnCqh8JBQNqNcKv6CAltntnAFGoQCr1wsnO6EPVQvrG7zBMAzi7rwTAFD9f1/BWOhd5Tpf6I8e5dJKIiJa1StB0bMnMn/4Hp3eehPKwYOFHhOiyEhkfPqJcGKTdekCkUYDVq8XSpY7smh1wgmyaRUtPldXt2e30wV10RNPgm1shLxPFqJv4mb1Im3NkbUbnXu4ANwHSNXKlQAAzfTpfr9mwGEWtLrKIaAKz2wQwFUikjg0MpR17YroG2aGbTwMw0BmuxtpCFDaX+Vnn+H0iJHC7zBQ+FkFf8qmA+4rvLEsC5Pt/CBUBvUzpYHvQ+ZtI15+vYfRYYbKqtOhbv16ANzMcSB5s4bKkJuLmtVcum3t9z94XZGTx6eUBeMuMX9TyNW5CXAsFZzm8sJaCKpbWZRCu307WIMB0vR0KPpyYxIqZhZ5DqjqfvvN6evKT+0NWk1lZdx7TyQS+up4Ivaxf0z95s1gDQbIe3QP63knUJoW1ZB5WD/F41PVvU2TtBoMwt+A3EU6oTDzcz7Pq/35qvanNTCe5bI7YmbfCsBh/XkL1VnNZXxAlSjcYOZTZmtt70PNjBmIuPRSwOEzW9GzZ6vHLY6JBtB8hor/HBap1QFpkXMxYCQSJD31pHDd1JRIrebaENmkf/wREh56qFkDYE+E0ukuziUN+/Y5fe3tDccLCxag6rPPnWbNvEUBlY9EtmlKa329Pe/dywsRbzBiMeS2EwPffyGQKX8AEDnpcsizsmCtr0fpokUB2aej+k3cDE7EZWNbve6HYRhETZuGzK9XoefePUj74H10+eF7ofocYCvdaWuG17REK2Dvi+NqQbNy6FCIIiJgKa8QSnbqduzgemBJpUhdvFi4yIkYOxaMVArj+fPIvX6mU68o7dZtMJ47B5FajehZN7bqNUviuQBdn51tX98SxrtijEiEpKefgkilQvSNN6DzV//XqibTgSDMkpxpfUBV99tvKHv9DVi1WpQufhV169a3ep88VgiofC9KATiun3G+mLZUVnLnBZFIKC7C9zLyhdVgEPq9OVZr8oRf72EqKhLOTXW//w5rbS1knTsjYvQon8fhiciLsunaJrPG+pMnfTpGMNfo8MGLuxkq/j0sc1PpLVBl04XqfhMnCOc0e0Efzxe52u1cVdWUl18GGAaNBw6gbv0fOHfd9Sh/8y0AXKAtclg34Y79rrJ3ARVf0TVy6lSXrR3am6YBlacKfzy+mJK3M1SmwkKAZSGKiHA56ynrnAkgODNUjcePo/g//wEAxN4+V/jMldpmf1tay2JySPlTZPUGI5PBUl4Bw+nT0G7ZCgDQXDMdyQsXCjdZo6ZP9+q91xI+3b7pDJXQrLxTpzZRrrwjYBgGIofgiS8h7ws+uG1aVIdlWaHtDl/N2ZuAirVa0bBzFwB7QRefxuPzMy5yQi6zTitcwAS6fLQwzW1bR8XqAhtQMWIxOr35BsAw0G7dGrC7/Dw+nz5y4uUB3S/DMIicMEFoLupIbVsEX7/F+cLKXFGBC/9+HACgcNEXRySTIcK2SLjmp59g0WpRcN/9ALgSpo6lxcVqNRIeeRgAd7e5fpN9pqrys88AcIUeWmqO2pKoK6/gxvPtd0KqYrjTDKKuvBI99+9DyksvtVilMRT4/GyDLX++NfiKkfxi46ov/S9B3pS9KIV/Aai79TNCOeSUFMh7cj8Ld72hPKn75RdYdTpIUlK8/kCTxMQI6RoNe/eCNZlQ98cfAADNjGsDVt2Px9+Uadi7F0VPPOkyFaPBVh2K57gGtSVWo9FeuTIoM1RcP7rG4ydcru8y5PCV3lwXJuDXILVmhsqq1wtBp9qhYAhfJtpSVeW2V4tVpxNmsNQTJwhpdxcefhiGkydRu5YrcMQ3KW2J2FaZy9uUPz44Vg32P9uhLRGp1WAcm54GYYZKWI6QlOQyAJAFaQ2VpaYGebO4jA55796Iv/de4TE+y8FcWupxnaOQ8peYBJFSKVS+K/vvf2GprIRIrYZq2DDI0joh87tvEXfXnUh6/N8BGb/EzRoqEz+L3Aaa6XYk/A05wF7AzBf878tc5bx+2HDqFCyVlWAUCqgnjAdgbwzuiXbrVqevzVW+Vc+lgMpHfJ8Wa73Wvi4nwOWj5b3tecNWo9E+Q9XKC3WnY3TtishJXGqOP2lODQcOovqb1c1OjMb8fO6Oq1gM9WVjAzJWb6jHjwMYBoYTJ4ULLkt9PfLnzYcpPx/STp2Q8uJLLp/LT0nXfP0NTg8bDlavhyQ1BUlPPdls27g770TUNVxKH//H13DwIFdNSSpFzD/+2erXEnnllRBrNLBUVQkBQ7gDKgBt6s6cULwl2/sLZ3cMtovvxEe5Kf7Ggwd9PpG6wzbyRSn8W0MlrJ9pUnyDvxCSdc4QutD7E1DV/LQGABA7+1af1oHyxyy4+x6c6j9AWMcQecUVPo+hJY4pf7Vr1zqlm/H4i2715dxNHF9uEjXs3g3WaIQkISHgFbwAcAGvVAprba3L3mn8WN0tqg/EDFXtTz/BUlsLaadOQrsIABBpNMJdXqciJ47jy8sDwK0vkcTEIO7u+S638zYg549nLq9AxcefcH0R3cw+WrQ64WJW7pCV0J4xDON0U0o5cGCLz7GvO/MuoLJU2duWuMKn/JmLiwNW2IdlWa6qn23td/KzzzidUySJiQDDgDUYnIoFNN0HP4PFz2hprpsBgGtvAnDr9PibLPIuXZD42GMBW3bhbg0VX1GVAqq2Rai6bSsqxOPXikaMGSP0AvRmTVTdr86pzb6m0VNA5SOxQ8qfvWleYAMqvmeE/shRIWhjVKpWN65rKmY2V9ShfsNGn0ou67NP4/ytt6Jk4UIhHYNXu/ZnAIBq2LCAVT70hiQ2Vpjarf35F9T98QdOj74EhpMnIY6LQ8bnn0Ga5LqPk3ri5U5VkAAg6bHH3Ka1aa7mGi3yfXhqvv2O+/706W6P4QtGInFuBCkSOXUgJ/YFyObi4laVfDZXV3OpAAwD9bhxXLlWqxXabX8GZJytnqHi092azlDZCkLIMjOFZrv67Gyf/o7NFRVotDVSjJo2zadxRU6Z3Ox7CY88LFRgDKSmacN16/9wupFjrq4W1mXws7smH8pB8zPN6okTA9qDiieSyaCwzag2Hjzg9BjLssJaNHc/O6Gxr971DFJLWIsFlctXAABi5851SptjGEZYN5Z77QxhtskRXx2Ln72LnDgRKS8vgqxLFyj69hW2Uw4a5NV4+OIE1atWofytt1D64ksoXbzY5baGU1ygLElMbBMz44Gisa0Fk2Zk2FtleMAXw/K2bDp/Q0gS4/quvzgmRkiR8+VvxZPqVatQ8/U3AIC0D96HauhQp8dFMplww8LdzR+rVgvWdgOZX3MVOWmSsHYdcN+EPhBE/EygVut0jhFmsDs3z44h/lP07w8A0LTQ0NgdIaAqswdUVqMR1bb2NVHTpgrXdsbcvBYrwPKfhzxfb6y2/4TkEBOKUjQ0CBXG+JSbQFH278814K2uRp2t9KksCLm7qmFDIdJoYKmpQePRo16nVNSts3c+r9+0Eeqxl8JSXw/t5s2oWr4cABBz06yAjtUbMTfNQuP+/aj85BNYjUbAbBYKWHi6syRWR6Dr77+h/vffYczPR/SsWR6nn4XmfyUlYM1moZmpYwPL1op/8AH7xY3V2qz08MVOHBkJaadOMF24AH32aUSMHOHXfvi735LkZIgiIhA5cSIMJ09Cu3kTom13Rv3Fsqx9DVUrZ6isBueCDMK6m+7doejdC+LoaFhqatBw4AAiRnj3s6j+ZjVgtUIxYIDPM6Axt94KcZQGjFgEY34+ZBkZiJzqujl0azUNqCyVlbBUVQnN1A222Slp5wxhFsPbi0SWZe1riy4P3oVaxKWXQn/iBLRbtjgVrTEXF3NrMSUSt+coe2Nf32YSWIsFhjNnUL9ho1DOvmmvGIALlPj1AkVPPNnsPMav/XIsgxw9cyaiZ86EtaEBVV98CXFcLJT9+sIbrtIqq1d9DUlSMuKbzH412C5wvA3W2ov4efMgjtJwmRVeYGznD75qaEuEtiVxrj/HuNLpGTCcOAnj+Xy36abeshoMQjuTxH8/hsgJrgsRyLp0gamwEIZzuVANH97scX5GQBQVJdzQZCQSRE2ZgprvuBuX6nEtV5L0l7AOy2IBq9cLqZnCzXMXyw2I/9LeWYK6dev9vl6UJPKl+O0zSQ27dnGfDwkJiJo8mbvJyDCw1tU5fW40ZTh3jpvFEomg6NuXK65GKX/BJWpS1EAcGxvw3iWMVCrkffInqWDMUDASCZS2dUW+LOJ2LDFe98v/cGHBApy5ZAyKnngS1oYGqEaNQuSVVwZ8vC2JmjYNqmHDuAsUkwnq8ePR489tTl3i3eGLX8Tfc0+Lubx8qWFrbS1q1/4MS00NxNHRXnf39oYsLQ0J//oXAAjrtogzV02wfcX3buIbOqr5So5/b291KgzrsCbF34DYXVEKIU2se3cwEgkibOm1fB80b9TbqvLx7Qd8GhfDQDP9auFvJmratKClhLIm+6wbP+vt2NSYP3cpemcJjXEtNTWwaLUt7lt/7DjMZWVgVCqhuEcwRF7BpVfXb9zk1POJ76Ejy+zstrqVfYbKtzVUpS+/gtwZ16HivfcAcL3xXK3DVQzo7/R109Q//q6tq4qtIpUK8ffcjZgbvS/E4xhQKQYMEDILKt5/32lNBQA02MqxKzvI+ikeI5Ui9h+zva6syVcJtXq5jo5fU+Lps0yWzgUHpgLXqZ6+0G3fDktlJSTJyYi97Tb3x+ySCaB5U3CekO7XJNMj7u750MyYgczvvm1WWCqQRCp7JgFfdIo1mYSKiZTyF1jS1FTE3XG73wVF+Bkqq1Yr/L74pRjqyyeCkUggUiiEmVG+Eq0r1f/3f9zzxo8X+gFSQBVkIpnMqaeMonfvoFxIxDZpDOuqEEMgKHpzwYbBy0Xc1sZGp+onVp0Odb/9LuTAR06ejLRly8JSjYmRSJD2wfuIvGISNDOvR6el7wSlGp1YrRbWs5W+/DIA7o59oF9z3Px5yPzhe6HMPXEmFG854VtFN0fmcu7ilg+oFH36QJKUBLaxkVsX1wpCFUiGAeNnQRlXRSmsOp29JLJt1kA1jGtQ3bSfmjuWujohKPO2ul+4qIYPg2rUKCQ8/BDktp5zxnz7Ynr9SS6gVmRlQayOEFKoXK1XakpoSHvppUJ58mBQ9OsHxUBb/z/bBzcA6P7iKix6yg4QZqh8DPAbjxwBwN30i77xhmazP7yYG2+ExmHmyjEdy3ThAhqPHgXAVUQNBGlqijDrmPzMf5D+8UcAuHWCjjcEDOdyodu+nUvH9XImp6MSgmqHGSpTaSmqvvgSNT/+1KxojTBDFev6bjwAyDK4m7TGfNcNp33BZ2lEXnGFx7LX/PVG45GjLh/nm/ryMw/CWNPSkPrqYij793f1tIBhRCLhpgN//jYVFQEWCxiFIuA3z0nriNUR9tRVW9o33wQ8wuEGmca27r30xZfQeOhQs/2wVivXRxS2wmK2vxtzVTVYkwllS97xajwUUPnBMbjhK8QFmnLAAOEiCQAixgTnokeRxd3lr/n+ezQeOuSUY2qprYVu126nD3Ldzp1g9XpIU1PRbd3vSHzsUSQsWIDkF19ArwP7kfbOEmGdWTiIIyOR9u67SH35ZWH9STDwKVLWhgYwcjli/LjL3xKGYaDs29envgwXE+UgbjG3bufOFnOj3TFX8gEVdwJlGEb4u2toEpwYCwqQe+Ms5N95l9uKaI74D2SRSuX3TRdhhsoh3ctgSzUWx8UJ60pUtrv8jYcPe3Xhrf3rL4BlIe2cIQSTbZVIoUDnFcsRf++9wgJjx3LPwgyVLdgS236XluqW7y7yLR7UbnqlBIpj/7+a1d+CNZvBsqzQJNzTuhDGzxkqPg0m/ZOPkfLSS25bWDBSKVJffhlqW5qWqdheQr36++8BiwWqUaO8nk1pCSMSofPXq5CxYgWUAwZArFYj2jbD1XjIfrOu/g/ubnLE2EuD0h+sPbEH1fb3wIVHH0XpK6+g+OmnUXj/A0592vhGzZJE9wEAn/ViDMAMVeMxLi20pZYJ/Cyn/tgxl+cpPpiXpgeuFY2v+At0/vwtzCJnZARljSVpHXvFyjwhzRmA0MMMAOLvu094v+fffY/T57dVr0fJCy/CXF7O9U4dOdLeC7SqEvpT2aj2svIvvTv84HgB4q5pWSAk/edpiNRqSJKSgpaOEjF2LDfbYrUi7+ZbUP3112AtFphKS3H+9tuRP3cucq+7XmgA7HgBIMvMRNxddyF+/jzEzJoVsLLu7UHkZHtKY/TM6/0q+UlaRzVyJBiVCubS0maLSb1lsaVfOfZqUfLNnnfscNq27n//g/7oUei2b4du166W980HVK3ojyJycSHFr59yXPcg69YNkuRksHp9i2l/5ooKlNvuuGmubl0T6lDjb2aZbCl/1sZG4SKMT+3lF+Kb3VQS4xkLL8CQnQ2IRFCPC/4MSOTEiVz1zupqNB48CMOpUzAXF4NxKA3tikjR/D3QEtZsFl6/NNG7QjnSFK5YBH8xDtibmLtae9Uayr59ETHK/pnGB8N6h/Rd7dZtAIJTObK94ddg8jdWGg4cRKNDqwDd9u2o+PBD4WuT7fPaUxAsVD8737qAirVave7jJu3cGZKUFK7Vwv9+bfY4X9VWHoAmvf5qGlBpt3HvQ5WXa1NJaPHvOWNuLoznznFr3xQKpwIijESC1P++CoBbqlH3G1cHwJiXh3PXXis0hU9Y8C+IZDJhJtJUWtqskJAnFFD5wfFOXzBzahVZWei24Q90XbsmaLMtYrUaSbYmfAA3JXqqbz+cHTceBlsqlfHcOeRMmoSaH34QGusFM5BsD2L/+U+ox42DavQoxN19d7iHc1ESyeWImjIFAFD+9hKnO7TeEvq1xDneJJkISCRoPHAA+lP2CzzH3kaG7Jb7X1kDEFAJZdMdZqj4lFu5Q480hmEQaSsZXvP99273x7IsCh9+BKaCAkg7dULsP//hdtu2iP+Q5Nf5GE6fBqxWiOPjhQ9BvkcWn/bkDt+XSTVkSEgqyHFr3bgF9dq/t9sX2V86xuMaO0befJayJebKKsBqBcRiiL282cOvDTXbZqgajxzh7vZKJFAHKRODx99N1p88yRVzsViEv70IF8ULLjb2wiTcnXW+1YnmhplIfeMNAEDFx5+g5JVXoM8+LZQl97T2Wkj5KyoCayt17g9zSQk3eyqVtjiLyTCMUIBAu3VLs8f1Z7jzqqINBFQWnQ6sxWK/5gli0RriPz6g0p8+bQ9+hwxp1g9RNWQI4u69BwDQsGcPtH/9hZwpU7kbCgyDpGeeQayt8jX/PjYVXkDD3r1ej4UCKj8kProA0rQ0pL7+WtCPJYmJ8aqsamtEXzcDPffthbRJSVBGLofmhplC+dLi/zwDS2UlxAnxTumIFyNxVBTSP/oQnZcvhzQpqeUnkKCIu+suMEolGvbuRcmil31+vr2JpD01RpqcLFxA6rbbZ6kMjsGVF0VcAhFQiZoUpWCtVmG9QtM+bzG33gKAm1WoW/+Hy/1pt2xB4/79YBQKZHz2adDPLYHGV9kynj8PlmXt6X4OhWcksa6bPTbFNwHne1eFgmo4d96s/OgjobRvzK23enyOP419zbYmlpL4eK8bLUtTuDRmo61CYuWnXLNyzdVXB/19osjqDUYuh6W8AobTZ7jfr14PRqWiympwnqGyNjYKF46xs2cjauoUrgeY2YzqL75E3i3ceUCk0Xgs4CBJSuLSyU0mpzRPX/E3N2RpaV6lp8tsM+uOpa4Bbl0n30DasaJkqDnOUDUeOcI1E46MvOivedoqvlpk/R8bUPUFl5qndhP88qnxDfv3o3zpu9w3RSJ0/e1Xp+JMQjrsuXNCWrg3KKDyg7xHD3TfuMGp/G17J1ar0W3dOqS+8Qbi7rkb3bdtRe/Dh5C6aBG6b9nsVEo37o473ebjExJK8q5d0OnttwAAtWvW2AtBeMlUzH2A8xeTPL75aYNtut/a0OBU/Uy7bZtQkcodq87WkLs1M1RNSmbrj3NV6UQuqtLJu3VD9I03ALBX8OOxLIvSV/+LwvvuB8C1GGjae6094FP+rPX1sNTUCAVJHAMqsS3lz9MMlaWuDg179wEI7Ww7/4EOALBaETV9OlSjPK878adsuqWGL0rgfSoy31jYcPo06rdsQf0fXFAee8ftXu/DXyKlUiiOot28Cfpj3MJyRY8etG4FzjNUDXv2cOuYO3WCvHdvMGIx0j94Xwh6+T5OLa07Y8Ri4cLR5FDkxVf8TSk+ZbQlfDZA05Rcfu2LJCUlpD0sm3IMqPhZbPVll9Fa5jZKNWI4FH36gNXrhYqtfK/QppSDB4NRKGAqLIT+6FEwcjl6/PVns78VaXIywN+Islqh9HKWnM5URMAwDDRXX4XERx5xmnVhRCKkLHoJcXffjYRHHkHsHPdlUQkJNfW4cZBmZIA1GqHdvr3lJ9iwJpPQYb3pxQCfL6/7ezvMVVXchz3LQpwQD8WAAWD1ehQ/9bTH/Qd2hoq7mObXMEaMHesyDVg9gbszZ2jSOLNh9x5UrVjBPfeSS5D46KN+jymcRAqFsN7NXFwspIXxxXUAe+8di4cZqpoffwTMZsh79AhpKWRZt25CAQpGqUTiY4+1WLCEfw9YfWjsa3/veb+uVd6lCyCVwlpfj+L/PAMAiL7pppClX/GFQeo3bRZKH9O6FY7IoTiN/sQJANxaT/69I0lIQI/tfzutBfSm1LwsvfWV/kxuKvO5I0mw/f1WVDgVE7Kvnwrf7BTgGFA1oN7Woy7YRWuI/xiGcVp2kfjIw24DcrFajegbbhC+jp55vcu+VIxE4jRLGjtnjldjoca+xCuMVIrEfz0S7mEQ0gzDMIicMAFVK1fiwkMPo2bcZUj/8MMWL1RNpWUAy4KRSpvdyVf06wdFv37QHzuGul9+Ee4QK3r1RtITj+Pc9Gug27kT5spKt40CA7KGyrZ+hi9IIDShdfMBL/R5ycsDa7WCEYlgKipC0ZNPAgCUAwci/eOPwtLWIFCkycmwVFTAWFjIFZVAkxkq24eppbbO5fNZkwlVK78AAMSEeA0ZwzBIW/oOdLt3Q5qS0qzfjitCM3mt97Ov/rz3GJkMiqws6I8cgaWqCiKNBkmP/9vr57dW5PjxKBGLoT92TJih4vt3Xez4BrNWvV5Yy6lwqGIGcDNOUddMt68j8eKuupBCm+9/YQohvdTL4if8+ZLV62HVNQhVgflqeuFcPwUA4iju701/9AiMOTkhWUNIWidq8pWQfPkFGJUKyr6eG4wn/usR7kaq1YqEBe5vLKa8vAglL76IqCuugLSF6pW89vupSgghNurLJwoLtXXb/oTh1KkWGzqbirhKWJLk5GZpRQzDQHPNdOiPHUP95i3CRbpywADIe/SAok8f6E+cgG77dmiuucbl/v2ZJWiKD+RYvcEeQIjFbqvSydLSAIkEbGMjzOXlEGs0OH/77TCXlEDWrRvSPvygXQdTACBNSYH+2DGuXL7BAFGTdTbiqCgAgEVb7/L59Vu3wlxcDHF8vFMqc6gwEgnUY8Z4vT3/3mMbG2E1GLzql8W/98Q+BvOpi19B/R9/gLVaoR47tlU3A3wlSUhA4oJ/oex1rshC9E03QTlgQMiO35aJ5PbS+fxaTnnvXs22i5o6FdZ6LSDyrneXvFtXAPbZIX/4GlCJVCqIVCpYGxpgqSgXAiq+0E84K/wB9uIsfCU41fBhwjmFtF3e3EAAuJtMae8saXE7Zd++6GKr/ldX5/rmXFPt+5OVEELANbZVjx8vpAppt21rMaAy5uUBcF+pUz1hAkpfWYyG3budvgcAyiFDoD9xAvoTJ70IqFqR8ufQZJKfnVINGeK2SAAjlUISHw9zSQnMZeUoefElroqRSIS0Ze+GpJpdsEls6Zn8z0Peu7dTQMw33bbWuQ6otLZFxpqrrgpqM99AEanVgEgEWK2w1NZClJgIS00NKj74EGAYxN15R7OGoxatlntuhNqnY8m7dYP83nsDNnZfxd15J8QaDczV1Yi7446wjaOtEWaotFoYbecVRe/ezbcTiRBz801e71fRtx8Ari8Uy7J+9csTCvv40PRWHBsLa0MDzNXVkGVmgmVZe/+gns0DxVCSNamMGD3zBjdbEuKM1lARQto9RiRC2nvLhBkHQ865Fp9jzM0DAMi6ul68LUtPd8qjlnXtCkU/Lp1AYbs77Ng3pym+sWxrghghfa2uDtrtfwOwB3Xu8H3ydDt3QruJ6yMUd+cdHaY5Kl/Slr+Qaxo4CzNU9c0DKkttLeo3bADgvhJUW8OIRMJrstbWAgAuLHgUVStXomrFCpwZe1mzJtSBCObDJfqGGxA/b57X1QkvBk6Bv20tp7tUY1/Ie/UEpFJYampgunDB5+ezLAtDTg4A+FTkRrjpYUtjNRcXw1pfD0gkkHfxfj/BIE2zB1TSTp0QNWVyGEdD2hMKqAghHQIjFkM9YTwAwFTQ8iJrvhmlp0AjetYs4f8THnxAuIMr721rRHr8BFiz2eVzzeXNmwb7ShxtC6iqq9F48BCAllMb+Aut8re46oeRkye32yIUrij693f+uo9zQCWsOaqvd1r0DgDFzy+EVaeDvEcPr1NE2gI+sNb++Se0f/3VrOn0+VtvdSrl354DKtIcP0PFU/T2PPvuLZFMJqxZ4tet+UJ//ASsWi0YqRRyNzemXB5X7dw8V29bCynv0iXsFYT5/lwAEH/ffe0+RZqEDr1TCCEdhrQTN3thvFDY4raGXG4WS+YhoIr5x2yIVEqI1JGImnyl8H1F714QR0fDUlODut9+c5n2x5cFdmwa7CthhqqKm+1ilEphdsztcxKcj9fRqnIqmiw6blrNTFjvYLU6LXpvPHYc9evWAWIxkl9Y6Fd6U7iIbO8Dfn0RAETffBPi7roLOZOuAABUr/oaKS+9CCAwJftJ28HIZGCkUrAmEwC0eA7whaJ/P+iPH4f+2DGhUbo3jOfPI89WMU3WvbtPZcXFtlRUq45LTTWc5tP9wrt+CuDOH6lvvgFYLG7TuQlxhWaoCCEdhiydC6gs5RUee1KxRiNMhVyKi6xLV7fbMQyD6JkznYIpgCsswFcgK3r8CZS9vaTZc80V3AyVJKH1ARUvYsSIFi9cHAM4SUIClIMG+X38tkgkkyHurjsBABHjLoO8q/Pvj5HLAdvPyFpvX0xc9TnXqDbqqmnO/aDaAf2RI05fK4cNRdKTT0KWlobUN7ggq37rFrBWKwCaoepoGIZxWqMk79V8/ZS/lAMGAgB0u/d4/RzWbEbBvfcB4NZ5Jjz4oE/HtKf88QFV2yhIwdNcdRUFU8RnFFARQjoMkUYjVJtqPH7c7XbGggLAYoFIpYIk0fvF1I4SFiyAatgwAEDlRx8JPZEA7oKDn1VqzVoHRql0CqC8Wffj+HpUo0Z1yMaoCY8+iowvVqLT6683e4xhGIhtaX/8OipLTQ3q1nONattjsYOoa7gm8vKePZH2/vvI+PxziBRcBcioK6+ASK2GpbwC+qNHAVBA1RE5zjwHcoZKPfZSAID+6FGYSkq8ek79xk0wnjsHcXQ0uv2x3ufm2HxAZRECKlvKX6+2EVAR4o+O90lLCLloMQwjpIDl3zYHtb/+6nI7vn+RrEsXv1O/JDEx6Px/XyLSliZT/MyzQkqOubIKYFlAJIK4FUUpGIYR9gkA6vHjW3yOYx8ORQe9QGEYBhEjRrgtZ8wHVHwRB+22bYDFAnnPni6ro7V1iY89huQXX0Dm998hcuIEp6bOjEwG9WVcn5x6WwVDq1Dlz/+S/aRtYQ1G4f99KQDREklCgnBjqHrV1149p+633wBwa0wlfqwRta+hagBrNMJgKxAU7h5UhLQGBVSEkA5Ffdllwv8X/ftxYWbCkS/NL1uSuOBfEGk00B87htpf/gcAMJ7PA8BViWrtomZ+/YxYo4HUi14vij59hP+XdurUqmO3V3x6lKmU65FTbyux3l4q+zUlTUxEzKxZToGUI/UE7nVpt3ABlZBuGu/f7Ctpe/gZbwABL5QQe/tcAED111/D0kLPHYtWB+3fXMXRyCuu8Ot4/MypVatFw6FDgNkMcXS00AOKkPaIAipCSIeiuW4GMr/5GuqJEwGrFUWPPQZ9tr1xJWs2Q7uVC6giA3CBLcvIENb0lLzwAsreeAPaLVu5xwJQAjjx0QWIGDMGmT9879X2jEyGxMcfR9S0qYi8/PJWH789kqRyF2bmkmJYGxuh++svAEDkxPYZULVEfdlYQCyG4cxZGHJz7QGVl81WSdunuf46AIG5CdSUesIEyLp2hbW+HsX/ecbjtrU//gC2oQGyLl2ENhK+EjusoeL7wqnHjWtXhWIIaYoCKkJIh8KIRFAOGoS0d5ci4rKxYE0mlC9dKpTQbjhwAJbaWoijo5tViPNX7Jw5UI0cCdZgQOWnn6Fq+XIAnkuyeytm1ixkfPap0H/JG3F33I5Ob70V9hLE4SJN5gIqw7lclLz8MqwNDZCmpTWrENhRiDUa4UK75rvvAYsFEIkgiYsN88hIoMTfcw9S33gDae8uDfi+GZEIqa8uBkQi1G/YIJQxd6Xu93UAgJjZs/0OgPiG0xZtPeq32GaPO+jNDnLxoICKENIhMWIxEhcsAEQiaDdtQvlbb8FcWYmKDz4AwKV/BSp1RiSTIe29ZYi/7z6nNLv21OuoI5GmJAMAan/8EbXf/wAAiLvrrg5ZoIMXeSWXflX1+ecAuGIo1EOn4xApFNBcfRXE0dFB2b9ywABEXslVM+XfQ02ZiorQeOgQACBykv+z33x/vYZ9+2HKzwcjlUJ96Ri/90dIW9BxP10IIRc9Re/eSHnxBQBA5Sef4syYS9GwcxfAMIi9LbD9mcRqNRIeehDdNm5Al7VruepXkyYF9BjEO/JezlXQYufORfRNs9xs3TFEX3utU5l9Svcjvoq7k6uAWfvrbzAVFzs9xrIsyt54A2BZqEaNgjQ52e/jSGzPZRu4fmmq0aOoIiVp9yigIoR0aNE33IDExx4VvhZFRiL5uWeh6BW40sOOGIaBoldPyDIygrJ/0jLl4MFIffMNyLp1Q+yc25D05BMdfn2GKCICqW+9KfTgUk/wrZQ1Icr+/aEaMQIwm1H78y9Oj+n++gt1v/0OiMVIePCBVh1H2qT4ROTEi3OtJ+lYKB+AENLhxd11F6Rp6RBFqKAeOzbcwyFBxjAM15zzqqvCPZSQUo8Zg8wvv4AhJweaGTPCPRzSDkVePhENe/ag4cB+4XuW+nqULHoZABD7j9lQDR3aqmM0bSVBwT/pCCigIoRcFKKmTA73EAgJOuWgQVAOGhTuYZB2SjlkCACg8cBBWA0GiORyVC1fAVN+PiTJyYibP7/Vx2AYBoxCAVavhzg6GtIkSk8l7R8FVIQQQgghBIqsLEhSUmAuLkblx59Af+oUtJs2AeB67kni4gJynMR/P4b6deuRsuilgOyPkHBjWL6WMEFdXR00Gg1qa2sRFRUV7uEQQgghhIRU9epvUfL8807f01x/PVIWvdShK2US4oq3sQHNUBFCCCGEEABA9KwbYTx3DlUrV4JRKJD27rtQj7003MMipE2jGSoHNENFCCGEEAIYzp2DOCYGkiZFJAi5mNAMFSGEEEII8Yu8a9dwD4GQdoOSYQkhhBBCCCHETxRQEUIIIYQQQoifKOXPAb+crK6uLswjIYQQQgghhIQTHxO0VHKCAioHlZWVAID09PQwj4QQQgghhBDSFlRWVkKj0bh9nAIqB7GxsQCA/Px8jz+01hg+fDj27t0blH2H8hh0HP/U1dUhPT0dBQUFQa8kSe81Ok5HOk5Hei10nLZ9nI70Wug4bfs4Hem1dNTjbNy4ERkZGUKM4A4FVA5EtoZ1Go0maBe7YrE46BfSoTgGHad1oqKiOsT7oKP9bug4bfc4Hem10HHa9nE60muh47Tt43Sk19JRj8NPsIhaaGpNRSlC7P777+8Qx6DjtH30XqPjdKTjdKTXQsdp28fpSK+FjtO2j9ORXsvFfhxq7OuAGvuSYKP3GCGEEEJI++DtdRvNUDmQy+V4/vnnIZfLwz0U0kHRe4wQQgghpH3w9rqNZqgIIYQQQgghxE80Q0UIIYQQQgghfqKAihBCCCGEEEL8RAEVIYQQQgghhPiJAipCCCGEEEII8RMFVIQQQgghhBDiJwqoCCGEEEIIIcRPFFARQgghhBBCiJ8ooCKEEEIIIYQQP1FARQghhBBCCCF+ooCKEEIIIYQQQvxEARUhhBBCCCGE+IkCKkIIIYQQQgjxEwVUhBBCCCGEEOInCqgIIYQQQgghxE8UUBFCCCGEEEKInyigIoQQQgghhBA/UUBFCCGEEEIIIX6igIoQQgghhBBC/NRuAqo///wT06dPR2pqKhiGwZo1a5wenzt3LhiGcfo3ZcqU8AyWEEIIIYQQclGQhHsA3tLpdBg4cCDuuOMOXH/99S63mTJlCpYvXy58LZfLfTqG1WpFUVERIiMjwTBMq8ZLCCGEEEIIab9YlkV9fT1SU1MhErmfh2o3AdXUqVMxdepUj9vI5XIkJyf7fYyioiKkp6f7/XxCCCGEEEJIx1JQUIC0tDS3j7ebgMobW7duRWJiImJiYjBx4kQsWrQIcXFxbrc3GAwwGAzC1yzLAuB+aFFRUUEfLyGEEEIIIaRtqqurQ3p6OiIjIz1u12ECqilTpuD6669Hly5dkJOTg6effhpTp07Fzp07IRaLXT5n8eLFeOGFF5p9PyoqigIqQgghhBBCSItLgRiWn5ZpRxiGwU8//YQZM2a43ebcuXPo1q0bNm7ciMsvv9zlNk1nqPgotLa2lgIqQgghhBBCLmJ1dXXQaDQtxgbtpsqfr7p27Yr4+HicPXvW7TZyuVyYjaJZKUIIIYQQQoKDZVmc3V8GbbU+3EMJuA4bUBUWFqKyshIpKSnhHgohhBBCCCEXtfzjVVj/yTH8+v4RtMMEOY/azRoqrVbrNNuUm5uLQ4cOITY2FrGxsXjhhRcwc+ZMJCcnIycnB48//ji6d++OyZMnh3HUhBBiZ7FYYDKZwj0MQjoUsVgMiURC7U4IaePKztcBACoKtLhwugZpvWLCPKLAaTcB1b59+zBhwgTh6wULFgAA5syZgw8++ABHjhzBypUrUVNTg9TUVFx55ZV46aWXfO5FRQghwaDValFYWNjh7soR0haoVCqkpKRAJpOFeyiEEDeqinXC/x/eVEABVTiMHz/e44XI+vXrQzgaQgjxnsViQWFhIVQqFRISEuhOOiEBwrIsjEYjysvLkZubix49enhsvkkICZ9qh4Aq72gFassboElQhXFEgdNuAipCCGmvTCYTWJZFQkIClEpluIdDSIeiVCohlUpx/vx5GI1GKBSKcA+JENKE1WJFdWkDACA2NQJVRToc2VKIsbN6hnlkgUG3cQghJERoZoqQ4KBZKULatroKPaxmFhKpCKOv6wYAOLO3NMyjChw6AxFCCCGEEEKChl8/FZMSgU69YgAGaKw3obHeGOaRBQYFVIQQQtqMrVu3gmEY1NTUeP2chQsXYtCgQUEbE8MwWLNmTdD2TwghHV19Jdd7KipeCalMjKg4LjXXsVBFe0YBFSGEkDbjkksuQXFxMTQajdfPeeyxx7Bp0ybh67lz52LGjBk+H9tdYFZcXIypU6f6vD9i9+eff2L69OlITU11G6COHz8eDMOAYRjI5XJ06tQJ06dPx48//hj6ARNCAsrQaAYAKCK48g2xKREAnAtVtGcUUBFCCAkIo7H1qRsymQzJyck+rTdTq9WIi4tr9bHdSU5OphYcraTT6TBw4EC89957HrebN28eiouLkZOTgx9++AF9+vTBzTffjPnz54dopISQYDA0cD0Y5SouoIqxBVRVxQ1hG1MgUUBFCCHEpfHjx+OBBx7AAw88AI1Gg/j4eDz77LNCC4vMzEy89NJLuO222xAVFSVc9P79998YO3YslEol0tPT8dBDD0Gns9+FNBgMeOKJJ5Ceng65XI7u3bvjs88+A9A85W/FihWIjo7GmjVr0KNHDygUCkyePBkFBQXC/hxnlhYuXIiVK1di7dq1wmzH1q1bAQBPPPEEevbsCZVKha5du+LZZ58VGi2vWLECL7zwAg4fPiw8b8WKFQCap/wdPXoUEydOhFKpRFxcHObPnw+tVis8zs+QvfHGG0hJSUFcXBzuv/9+r5s6f/nllxg2bBgiIyORnJyMW2+9FWVlZU7bHD9+HFdffTWioqIQGRmJsWPHIicnR3j8888/R9++fSGXy5GSkoIHHngAAJCXlweGYXDo0CFh25qaGqefE/87WL9+PQYPHgylUomJEyeirKwMv//+O7KyshAVFYVbb70VDQ3eXQxNnToVixYtwnXXXedxO5VKheTkZKSlpWHUqFH473//i48++giffPIJNm7c6NWxCCFtj6GBm6GSq6QA7DNUlPJHCCHELyzLwmSwhOWfr42FV65cCYlEgj179uCdd97BW2+9hU8//VR4/I033sDAgQNx8OBBPPvss8jJycGUKVMwc+ZMHDlyBKtXr8bff/8tXNADwG233Yavv/4aS5cuxcmTJ/HRRx9BrVa7HUNDQwNefvllfPHFF9i+fTtqampw8803u9z2sccew6xZszBlyhQUFxejuLgYl1xyCQAgMjISK1aswIkTJ/DOO+/gk08+wdtvvw0AuOmmm/Doo4+ib9++wvNuuummZvvX6XSYPHkyYmJisHfvXnz33XfYuHGj0+sDgC1btiAnJwdbtmzBypUrsWLFCiFAa4nJZMJLL72Ew4cPY82aNcjLy8PcuXOFxy9cuIDLLrsMcrkcmzdvxv79+3HHHXfAbOYuWD744APcf//9mD9/Po4ePYqff/4Z3bt39+rYjhYuXIhly5Zhx44dKCgowKxZs7BkyRKsWrUKv/76K/744w+8++67Pu/XV3PmzEFMTAyl/hHSjtkDqqYzVLoO0fCe+lARQkiImY1WfPzwtrAce/474yCVi73ePj09HW+//TYYhkGvXr1w9OhRvP3225g3bx4AYOLEiXj00UeF7e+66y7Mnj0bjzzyCACgR48eWLp0KcaNG4cPPvgA+fn5+Pbbb7FhwwZMmjQJANC1a1ePYzCZTFi2bBlGjhwJgAvysrKysGfPHowYMcJpW7VaDaVSCYPBgOTkZKfHnnnmGeH/MzMz8dhjj+Gbb77B448/DqVSCbVaDYlE0ux5jlatWgW9Xo8vvvgCERHcBcGyZcswffp0/Pe//0VSUhIAICYmBsuWLYNYLEbv3r1x1VVXYdOmTcLPzZM77rhD+P+uXbti6dKlGD58OLRaLdRqNd577z1oNBp88803kEq5u709e9p7uSxatAiPPvooHn74YeF7w4cPb/G4TS1atAhjxowBANx555146qmnkJOTI/y+brjhBmzZsgVPPPGEz/v2hUgkQs+ePZGXlxfU4xBCgsee8mefoRJLRGisM6KqSIe4Tu5vqrUHNENFCCHErVGjRjmtZxo9ejTOnDkDi8UCABg2bJjT9ocPH8aKFSugVquFf5MnT4bVakVubi4OHToEsViMcePGeT0GiUTiFBD07t0b0dHROHnypE+vZfXq1RgzZgySk5OhVqvxzDPPID8/36d9nDx5EgMHDhSCKQAYM2YMrFYrsrOzhe/17dsXYrE9cE1JSWmWtufO/v37MX36dGRkZCAyMlL4WfFjPXToEMaOHSsEU47KyspQVFSEyy+/3KfX5cqAAQOE/09KShJSJR2/5+1rai2WZamPGyHtWNMZKqlcjPQ+sQCAswdCcx4JJpqhIoSQEJPIRJj/jvcBRaCPHUiOgQUAaLVa3H333XjooYeabZuRkYGzZ88G9Pje2rlzJ2bPno0XXngBkydPFmZ43nzzzaAcr2mwwzAMrFZri8/jUwonT56Mr776CgkJCcjPz8fkyZOFoh9KpdLt8z09Btgb4Dqm2Lhb2+X4GhiG8fs1tZbFYsGZM2f8mmUjhLQNTQMqAOg+JAF5RyqQc6AcI67u0q5vmlBARQghIcYwjE9pd+G0e/dup6937dqFHj16OM2+OBoyZAhOnDjhds1O//79YbVasW3bNiHlryVmsxn79u0T0vuys7NRU1ODrKwsl9vLZDJhBo23Y8cOdO7cGf/5z3+E750/f77F5zWVlZWFFStWQKfTCcHk9u3bIRKJ0KtXL69ejyenTp1CZWUlXn31VaSnpwMA9u3b57TNgAEDsHLlSphMpmZBTmRkJDIzM7Fp0yZMmDCh2f4TEhIAcKXgBw8eDABOBSraopUrV6K6uhozZ84M91AIIX5qWuUPADIHxEMsEaG6WIcz+0rRc7j7dOu2jlL+CCGEuJWfn48FCxYgOzsbX3/9Nd59912ntTlNPfHEE9ixYwceeOABHDp0CGfOnMHatWuFog2ZmZmYM2cO7rjjDqxZswa5ubnYunUrvv32W7f7lEqlePDBB7F7927s378fc+fOxahRo5qtn+JlZmbiyJEjyM7ORkVFBUwmE3r06IH8/Hx88803yMnJwdKlS/HTTz81ex6fllhRUQGDwdBs37Nnz4ZCocCcOXNw7NgxbNmyBQ8++CD++c9/CuunWiMjIwMymQzvvvsuzp07h59//hkvvfSS0zYPPPAA6urqcPPNN2Pfvn04c+YMvvzySyHlcOHChXjzzTexdOlSnDlzBgcOHBCKRyiVSowaNQqvvvoqTp48iW3btjmtLQsWrVaLQ4cOCcEb/3NumnLZ0NCAkpISFBYWYteuXXjiiSdwzz334N5773UZIBJC2j6L2QqzkZvN5tdQ8f8/dGpnAMCf35xG0ZmacAwvICigIoQQ4tZtt92GxsZGjBgxAvfffz8efvhhjz2BBgwYgG3btuH06dMYO3YsBg8ejOeeew6pqanCNh988AFuuOEG3HfffejduzfmzZvnVFa9KZVKhSeeeAK33norxowZA7VajdWrV7vdft68eejVqxeGDRuGhIQEbN++Hddccw3+9a9/4YEHHsCgQYOwY8cOPPvss07PmzlzJqZMmYIJEyYgISEBX3/9tcuxrF+/HlVVVRg+fDhuuOEGXH755Vi2bJmnH6PXEhISsGLFCnz33Xfo06cPXn31VbzxxhtO28TFxWHz5s3QarUYN24chg4dik8++USYrZozZw6WLFmC999/H3379sXVV1+NM2fOCM///PPPYTabMXToUDzyyCNYtGhRQMbuyb59+zB48GBhVmzBggXCe8PRJ598gpSUFHTr1g3XX389Tpw4gdWrV+P9998P+hgJIcHBp/sBgEzpnBw3ZEpnJHaOhEFnxpq3D2LXmhyc3FHk8V9tedvrXcWwHaFWYYDU1dVBo9GgtrYWUVFR4R4OIaSD0Ov1yM3NRZcuXaBQKMI9HK+NHz8egwYNwpIlS8I2hhUrVuCRRx4R+lIR4kp7/Rsj5GJQXaLDqoW7IVOIMW9J8/XDJoMFW786hdN7Sr3aX0S0HP98aTTE0uDPC3kbG9AaKkIIIYQQQkhQNG3q25RULsak2/sgPSsWOQfK4Gmqp+RcLXQ1BpzdX4peo1KCMVy/UEBFCCGEhMhff/2FqVOnun1cq9WGcDSBkZ+fjz59+rh9/MSJE8jIyAjhiAghbYmh0RZQRbgPOxiGQe/RKeg92nOQtO/3POxeew6HNxdSQEUIIaTt27p1a7iHgLlz52Lu3LnhHkbADBs2rM1X1fNVamqqx9fkuH6OEHLxcVXhz199x6Zi7/9yUZ5fj+oSHWKSI1p+UghQQEUIIYSEiFKpdFtSvr2SSCQd7jURQgLHoLPNUCldp/z5QqmWIa13LPKPVyLnQDmGTWsbARVV+SOEEEIIIYQEhaumvq3RbQjXTy/nYFlA9hcIFFARQgghhBBCgqKx3ggAUEbKArK/rgMTwIgYVBRoUV+lD8g+W4sCKkIIIYQQQkhQ2AOq1qf8AYBCLUVi50gAQOGp6oDss7UooCKEEEIIIYQERUM9V5QiUDNUAJDWKwYAUJhdFbB9tgYFVIQQQgghhJCg4GeoVFEBDKh62wKqU9VgPTWuChEKqAghhLQKwzBYs2ZNSI+5detWMAyDmpqakB7XlczMTCxZsiTkxw3Ez338+PF45JFHPG4TrtdHCOkYAr2GCgCSu2kgkjBoqDWivjL866gooCKEEOJWSUkJHnzwQXTt2hVyuRzp6emYPn06Nm3aFNZxXXLJJSguLoZGownaMebOnQuGYdz+y8zMDNqxCSGkI7BarGjU8il/gVlDBQASqRiRsQoAaBMBFfWhIoQQ4lJeXh7GjBmD6OhovP766+jfvz9MJhPWr1+P+++/H6dOnQrb2GQyGZKTk4N6jHfeeQevvvqq8HVKSgqWL1+OKVOmAADEYrHf+zaZTJBKA3dxQQghbZFeZwZYAAygVAf2nKeOUaC2rBHa6vAHVDRDRQghxKX77rsPDMNgz549mDlzJnr27Im+fftiwYIF2LVrl9vnFRQUYNasWYiOjkZsbCyuvfZa5OXlCY/v3bsXV1xxBeLj46HRaDBu3DgcOHDAaR8Mw+DTTz/FddddB5VKhR49euDnn38WHm+a8rdixQpER0dj/fr1yMrKglqtxpQpU1BcXCw8x2w246GHHkJ0dDTi4uLwxBNPYM6cOZgxY4bL16HRaJCcnCz8A4Do6Gjh64SEBGHbhoYG3HHHHYiMjERGRgY+/vhj4bG8vDwwDIPVq1dj3LhxUCgU+OqrrwAAn376KbKysqBQKNC7d2+8//77wvOMRiMeeOABpKSkQKFQoHPnzli8eLHTGCsqKtz+jABg27ZtGDFiBORyOVJSUvDkk0/CbDa7+9WhrKwM06dPh1KpRJcuXYRxEkKIP/h0P0WEFCJxYMOOyBg5AKC+2hDQ/fqDAipCCAkXnc79P73e+20bG73b1gdVVVVYt24d7r//fkRENO9EHx0d7fJ5JpMJkydPRmRkJP766y9s375dCG6MRu6Dtb6+HnPmzMHff/+NXbt2oUePHpg2bRrq6+ud9vXCCy9g1qxZOHLkCKZNm4bZs2ejqsp9RaeGhga88cYb+PLLL/Hnn38iPz8fjz32mPD4f//7X3z11VdYvnw5tm/fjrq6uoCt/XrzzTcxbNgwHDx4EPfddx/uvfdeZGdnO23z5JNP4uGHH8bJkycxefJkfPXVV3juuefw8ssv4+TJk3jllVfw7LPPYuXKlQCApUuX4ueff8a3336L7OxsfPXVV83SDD39jC5cuIBp06Zh+PDhOHz4MD744AN89tlnWLRokdvXMXfuXBQUFGDLli34/vvv8f7776OsrO00zySEtC8NdYFfP8VT21L+tG0goAJLBLW1tSwAtra2NtxDuajUlDWwv7x7iP3prf3sqZ1F4R4OIQHX2NjInjhxgm1sbHR+AHD/b9o0521VKvfbjhvnvG18vOvtfLB7924WAPvjjz+2uC0A9qeffmJZlmW//PJLtlevXqzVahUeNxgMrFKpZNevX+/y+RaLhY2MjGR/+eUXp30+88wzwtdarZYFwP7+++8sy7Lsli1bWABsdXU1y7Isu3z5chYAe/bsWeE57733HpuUlCR8nZSUxL7++uvC12azmc3IyGCvvfbaFl9j09fpqHPnzuw//vEP4Wur1comJiayH3zwAcuyLJubm8sCYJcsWeL0vG7durGrVq1y+t5LL73Ejh49mmVZln3wwQfZiRMnOv0sm47H08/o6aefbva7eO+991i1Ws1aLBaWZVl23Lhx7MMPP8yyLMtmZ2ezANg9e/YI2588eZIFwL799tuefjRh5/ZvjBASVtm7i9lld29if3prf8D3fezPQnbZ3ZvYX5YdCvi+ed7GBu1mhurPP//E9OnTkZqa6rKyEcuyeO6555CSkgKlUolJkybhzJkz4Rks8cmJvy/g/LFKXMiuwcYVJ7Hnf7nhHhIhFz3WzzK0hw8fxtmzZxEZGQm1Wg21Wo3Y2Fjo9Xrk5OQAAEpLSzFv3jz06NEDGo0GUVFR0Gq1yM/Pd9rXgAEDhP+PiIhAVFSUx9kSlUqFbt26CV+npKQI29fW1qK0tBQjRowQHheLxRg6dKhfr7Mpx7EyDIPk5ORmYx02bJjw/zqdDjk5ObjzzjuFn5NarcaiRYuEn9PcuXNx6NAh9OrVCw899BD++OMPj8dt+jM6efIkRo8eDYZhhG3GjBkDrVaLwsLCZvs6efIkJBKJ08+kd+/ebmcjCSGkJY1B6EHFE2aoqsI/Q9VuilLodDoMHDgQd9xxB66//vpmj7/22mtYunQpVq5ciS5duuDZZ5/F5MmTceLECSgUijCMmHirokALAJBIRTCbrDi4/jwGjE+DIsCLFwlpc7Ra9481LXjgKe1K1OTemMN6JX/16NEDDMP4XHhCq9Vi6NChLtfe8GuO5syZg8rKSrzzzjvo3Lkz5HI5Ro8eLaQE8poWbWAYBlar1e2xXW3vb2DoK2/G6pg6qbX97j/55BOMHDnSaTu+2MWQIUOQm5uL33//HRs3bsSsWbMwadIkfP/99z4dlxBCwiWoKX+2NVRtoShFuwmopk6diqlTp7p8jGVZLFmyBM888wyuvfZaAMAXX3yBpKQkrFmzBjfffHMoh0p8VF7IXVhcu2Awtq3KRkWBFsf/voChUzLDOzBCgs3F2qSQb+tGbGwsJk+ejPfeew8PPfRQs3VUNTU1LmcuhgwZgtWrVyMxMRFRUVEu9719+3a8//77mDZtGgCuiEVFRUWrx+yJRqNBUlIS9u7di8suuwwAYLFYcODAAQwaNCiox3YlKSkJqampOHfuHGbPnu12u6ioKNx000246aabcMMNN2DKlCmoqqpCbGxsi8fIysrCDz/8AJZlhVmq7du3IzIyEmlpac227927N8xmM/bv34/hw4cDALKzs9tEry9CSPtkbOSK4ChUgQ85ImO4CRNDgxlGvRkyRfjCmnaT8udJbm4uSkpKMGnSJOF7Go0GI0eOxM6dO90+z2AwoK6uzukfCS1drQGNdUYwDBDXSY2BE9MBAIc2FAiVYQgh4fHee+/BYrFgxIgR+OGHH3DmzBmcPHkSS5cuxejRo10+Z/bs2YiPj8e1116Lv/76C7m5udi6dSseeughIc2sR48e+PLLL3Hy5Ens3r0bs2fPhlKpDPrrefDBB7F48WKsXbsW2dnZePjhh1FdXe2UEhdKL7zwAhYvXoylS5fi9OnTOHr0KJYvX4633noLAPDWW2/h66+/xqlTp3D69Gl89913SE5O9joF77777kNBQQEefPBBnDp1CmvXrsXzzz+PBQsWQNR0VhNAr169MGXKFNx9993YvXs39u/fj7vuuiskvxtCSMdkMlgAAFJ54IMdmVICmYKb0Q93YYoOEVCVlJQA4O74OUpKShIec2Xx4sXQaDTCv/T09KCOkzRXYZudik5SQSoTo8eIJMR1ioBeZ8Jfq08L27FWNmSpO4QQTteuXXHgwAFMmDABjz76KPr164crrrgCmzZtwgcffODyOSqVCn/++ScyMjJw/fXXIysrC3feeSf0er0wY/XZZ5+huroaQ4YMwT//+U889NBDSExMDPrreeKJJ3DLLbfgtttuw+jRo6FWqzF58uSwpYXfdddd+PTTT7F8+XL0798f48aNw4oVK9ClSxcAQGRkJF577TUMGzYMw4cPR15eHn777TeXwZArnTp1wm+//YY9e/Zg4MCBuOeee3DnnXfimWeecfuc5cuXIzU1FePGjcP111+P+fPnh+R3QwjpmISASuF/3z5P7JX+wpv2x7Dt8CqVYRj89NNPQu+QHTt2YMyYMSgqKkJKSoqw3axZs4TeH64YDAYYDPaItq6uDunp6aitrXWbqkICa88v57D31zz0GJ6EK+/sCwAoO1+H7/+7H6yVxcBJ6SjLq0Px2VpExipww5PDoIoKfB4uIcGk1+uRm5uLLl260JrONsRqtSIrKwuzZs3CSy+9FO7hkFagvzFC2qaf3zmIgpPVmHR7H/QaGfhm7L+8ewj5x6sw4Z+90WdMasD3X1dXB41G02Js0CFmqPiGi6WlpU7fLy0tFR5zRS6XIyoqyukfCZ36Kj0ObSoAAKT1jhG+n9g5CoOv4GYLD28sQPHZWmH7M/tKm++IEEK8cP78eXzyySdCet29996L3Nxc3HrrreEeGiGEdEj2lL8gz1BVhXeGqkMEVF26dEFycjI2bdokfK+urg67d+92m+dPwm//uvMw6S1I7qpB1ugUp8eGX90FGX1jodLIkNE3Fr0v4R4/d7A8HEMlhHQAIpEIK1aswPDhwzFmzBgcPXoUGzduRFZWVriHRgghHVKwA6pIodJfeNdQtZsqf1qtFmfPnhW+zs3NxaFDhxAbG4uMjAw88sgjWLRoEXr06CGUTU9NTRXSAknbU3SmBgAwZHIGGJHzonCJVIzpDw4Svq6v0uPUjmIUna2BrtaACI08hCMlhHQE6enp2L59e7iHQQghF42gz1DZKv3Vh3mGqt0EVPv27cOECROErxcsWACA62eyYsUKPP7449DpdJg/fz5qampw6aWXYt26dZRL3UYZGs2oLtEBAJK6aFrcPjJWgcTMKJTl1SH3UDn6jWte8pcQQgghhLQdwQ+oaIbKJ+PHj/dY5Y1hGLz44ot48cUXQzgq4q+SnFqABaLiFV4Xmeg2JAFleXU4e4ACKkIIIYSQts6kD80MlbZa79RzL9Q6xBoq0v4UnakGAKT2jGlhS7tugxNtz62hHlWkXWqHRVUJaRfob4uQtsdqZWE2WQEEf4bKbLTC0GAOyjG8QQEVCYsLp2sAAJ16RHv9HE2CEgkZkWCtLHIPVwRnYIQEgVjMfZAYjXQjgJBgaGhoAABIpdIwj4QQwjPb0v2A4AVUEpkYykju7z6cvajaTcof6ThMBgvKz9cDAFJ9CKgAoOvgBJTn1yPnQBn6XBr4fgOEBINEIoFKpUJ5eTmkUqnXjVkJIZ6xLIuGhgaUlZUhOjpauHlBCAk/fv0UwwBiafA+9yKi5WisN0FXY0R8mFaEUEBFQq7kXC2sVhbqWDmi4pU+Pbf7kETsXnsOhaeqodeZoIigu5Gk7WMYBikpKcjNzcX58+fDPRxCOpzo6GiPfScJIaHnWJAimGub+Nkvk8OMWKhRQEVCji+X7uvsFABEJ6kQ1ykClRd0OL2nBAMmpAd2cIQEiUwmQ48ePSjtj5AAk0qlNDNFSBsU7Ap/PAqoyEWJD6g69fC+IIWjPpd2wl+rT2P32nPoOihBqPBCSFsnEomolQMhhJCLgsnAFYmQKoIbbvABldkYvoCKEvlJSLEsi4oCbv1UUpcov/bRb1wnJHWJglFvwdavsqm6EyGEEEJIG2MMcsl0nlQW/hkqCqhISNVX6mHUWyCSMIhOVvm1D5GIwcR/ZkEkYXD+WCXO7CsN8CgJIYQQQkhrhCrlT9IGUv4ooCIhVVGgBQDEpaohFvv/9otNjcDQyZ0BAMe2XQjI2AghhBBCSGDwKXghm6GilD9ysSgv5NL94tPUrd4XXza9OKcWulpDq/dHCCGEEEICI9QzVGaaoSIXC36GKj699QGVOkbBrcNigXMHy1u9P0IIIYQQEhghr/JHM1TkYsCyLMrO1wEA4tMiA7LPboMTAQDnDlFARQghhBDSVphCVZRCmKGyBvU4nlBARUKmuqQBDbVGiKUiJGYGJqDKHBAHACg6WxPWxYiEEEIIIcQuZDNUMi6coRkqclEoPFUNAEjppoFEGpg/rugkFSJjFbCaWVw4XR2QfRJCCCGEkNYx8gGVIkRV/vQUUJGLQOGpKgBAWm//Gvq6wjAMMvrGAgDyT1QFbL+EEEIIIcR/jXVGAIAiQhrU41CVP3LRsFqsuHC6BgCQ1js2oPvO6Mul/eUfrwzofgkhhBBCiH+01XoAgDpWEdTjSKnKH7lYlOdrYWw0Q66SICEjMOuneGm9YiASMagta0RteWNA900IIYQQQnynreZa2qhj5EE9joSq/JGLRWE2l46X2iMaIhET0H3LlBKkdNcAAPKOVAR034QQQgghxDdGvRmGBjMAIDImyDNUMpqhIhcJviBFoNP9eF0HJwAAcg6WBWX/hBBCCCHEO/zslEwpgUwpCeqxhD5UBgtYlg3qsdyhgIoEndlkQXFOLYDAFqRwlDkgHgBQcq4OxkZzUI5BCCGEEEJapq2yrZ8KcrofYE/5Y1nAYg5PLyoKqEjQleTUwmKyQqWRISZZFZRjRMUpEZWgBGtlUXSmJijHIIQQQgghLbOvnwpuuh9g70MFhK+5LwVUJOjs6X4xYJjArp9yxM9+8ccjhBBCCCGhVy9U+Av+DJVILIJYEt7mvhRQkaArzLYFVL2Cs36Kl9bLFlBlUz8qQgghhJBw4WeoIkOQ8gcAErktoApTYQoKqEhQ6XUmlOXVAQje+ikeH1BVXtChwdZMjhBCCCGEhJZ9DVXwU/4Ah0p/NENFOqK8IxVgWSA2NQKRQW7spoyUIS5NDQC4kE1pf4QQQggh4RCqHlQ8odKfngIq0gHlHub6QnWzlTUPNvs6Kkr7I4QQQggJNZZloRXWUIVohirMzX0poCJBY7FYUWALbPiy5sFmX0dFM1SEEEIIIaFm0JlhNnLV9kI1QyWR2XtRhQMFVCRoSs/VwqS3QKGWIiE9MiTHTO0RDZGIQV2FHnUVjSE5JiGEEEII4fAV/pSRUkik4pAck28eHK5epBRQkaA5f5ybncroEwtGFLxy6Y5kCgmSukQBoPLphBBCCCGhFsoeVDylWgoAaKw3heyYjiigIkGTf7wSAJDRNy6kx+1kW0dVQOuoCCGEEEJCyl7hLzTpfgA3GwYAjdrwVHnuMAHVwoULwTCM07/evXuHe1gXrYY6IyoKtACA9Kzg9p9qKt0WUF3IrgZrZUN6bEIIIYSQi1k4ZqgUahmA8M1QScJy1CDp27cvNm7cKHwtkXSol9eu5B3hqvslZERCFSUL6bGTumgglojQWG9CXWUjNAmqkB6fEEIIIeRiJVT4C8MMlT5MM1QdKuKQSCRITk4O9zAIgJwDZQCAbkNCUy7dkVgiQmxqBMrz61FRoKWAihBCCCEkROor+ZLpIQyo+BkqLa2harUzZ84gNTUVXbt2xezZs5Gfn+9xe4PBgLq6Oqd/pPX0OpNQEKLb4MSwjCE+nWvwW1GoDcvxCSGEEEIuNmaTBWX59QCA+LTQVHgGHNZQUVGK1hk5ciRWrFiBdevW4YMPPkBubi7Gjh2L+vp6t89ZvHgxNBqN8C89PT2EI+64Dv6RD6uVRVwnNaKTwjM7xP8RVxS4//0TQgghhJDAKcmphcVkhUojQ0xy6K4BFWo+5c8Elg39+vkOE1BNnToVN954IwYMGIDJkyfjt99+Q01NDb799lu3z3nqqadQW1sr/CsoKAjhiDumsvN1OLiBmxkcMb1L2MZBM1SEEEIIIa3HsiyObCnE6pf3oOCE5wrKfIZSWu8YMExoWuYA9pQ/i9kalua+HSagaio6Oho9e/bE2bNn3W4jl8sRFRXl9I/4z2K2YvMXJ8FaWXQfloiug0K/fooX34kLqLTVBujDlE9LCCGEENKeGRvNWP/Jcfy1+jQqCrTYsPy4x+uqAj6g6hXaCs9SuRgSKRfWhCPtr8MGVFqtFjk5OUhJSQn3UC4aJ/4uQuUFHRRqKS67qWdYxyJTShAVz5XrrCiktD9CCCGEEF9UFenw3av7kHOgDCIRgwiNDI31Jvz93RmX22urDSjL4+oRZPQJbUAFAIow9qLqMAHVY489hm3btiEvLw87duzAddddB7FYjFtuuSXcQ7tonNlXCgAYOqUzlJGhLZXuSny6bR0Vpf0RQgghhHjNqDfjf8sOo6a0AeoYOa57bAim3NMfDANk7y5B3tGKZs85d4ir8JzSTYOI6NBV+OPxaX96mqHyX2FhIW655Rb06tULs2bNQlxcHHbt2oWEhPClnV1MdLUGFOfUAgC6DQlPZb+m4tNs66gKKKAihBBCCPHW7rXnUF+lR2ScArOeHo7krhokd9Fg4OVcAbetX2XD0Gh2ek7OgXIAQNfB4bn2VoZxhqrD9KH65ptvwj2Ei9q5g+UACyR1iUJkbOg6Y3tin6GilD9CCCGEEG+YDBac2F4EABh/ay+nrKMR13RF7uEK1JY3YuPyE7jijj6QKSSoLtGh6EwNwITvxrq90p+5hS0Dr8PMUJHwyjnIN/JtG7NTgH2Gqrq4ARaTNcyjIYQQQghp+/KPV8JstCIqXoH0JmuhpDIxJt6WBZGIQd6RCny3eB+yd5dg19pzAIDM/vFhu7EuV3DzREY9BVSkHWqoM6LodA0AoFuYpnldUcfIIY+QwGplUVWsC/dwCCGEEELavJwDtpvkgxNdlj5P7RGNGY8OQUS0HDWlDdi4/ASXqQQIKYHhIFNxAZWhIfQBVYdJ+SPhk3u4HCwLJGREIipeGe7hCBiGQXxaJC5kV6OisB4JGaHr2E0IIYQQ0t6wVhbnj3O9pjythUrppsFN/xmOXWtyUFveCABIzIxCp57RoRimSzKlbYaqkQIq0g4JdzKGtJ3ZKV58upoLqKgwBSGEEEKIR3WVehgbzRBLREjo7PlGtDJShgn/zArRyFomtwVUTYtlhAKl/JFW0WtNKMyuAcBNDbc1CXylPyqdTgghhBDiEV/IKzY1AmJx+woTwjlD1b5+UqTNOXe4HKyVRVyaGtFJqnAPpxmh0l9BPViWDfNoCCGEEELaLj6jhy/s1Z7QDBVpl6wWK45uLQTQtopROIpOVkEkYWDUW1BfqQ/3cAghhBBC2iw+oyc+vf0FVDRDRdqlgxvyUVGghVwlQZ9LU8M9HJfEYhHiO3EnheN/F4V5NIQQQgghbZPJaEH5+ToAQHxa+yvkRQEVaXeqS3TY+788AMClN/ZAhEYe3gF5MHRKJgDg4B/5qCqi8umEtEUmowX1Vfpm/8LxwUgIIRcbq8WKNW8dhK7WCKlC3C5nqOQOAVWol3lQlT/iM6uVxeYvTsJitiKjbyx6jUoO95A86jo4AWm9Y1B4qhoFp6oQmxoR7iERQhw01Bnx1fO7XAZPEqkI1/97KLU9IISQICrNq0dZXh2kcjGuum8AZIr2FyLwfahYFjAZLCF9De3vp0XC7uiWQpSc4/7oxs/u7bLpW1sTnx6JwlPVqK+gdVSEtDVl5+u4YIoBxBJ74gRrYWE2WbFxxQn0HJHU4n4SO0chPSs2mEMlhJAOqfAU13sqo28sOvWMCfNo/CORiiASMbBaWRgbzRRQkbbLqDdjzy/nAACXXN8NkbGKMI/IO1Fx3DhrKxrDPBJCSFO6GgMAoHO/OFx9/0Dh+w11Rnz9wm5UFemwa805r/bVf1wnjLmhB8RSymgnhBBvFZ2pAYB2G0wBAMMwkCkl0OtMMDSaoQ7hS6GAivjk1M5iGPUWRCep0Hdsp3APx2tRCUoAQH0lBVSEtDVaW0CljnZei6mKkmHavf1xaldJi/nwxkYzcg6U4+i2Czh3uAJylQTKSCmuvLMfVFGyoI2dEELaO6vFitJcrhhFSvfo8A6mlWRKMfQ6E4yNlpAelwIq4jWWZXFkM1cmfeDENDCitp/qx7PPUOnBsmy7SFMk5GKhq7YFVDHNi9ukdI/2+gM+72gFNi4/AV2NQZj1OrQhH5fM7B6wsRJCSHtg1JtRW978JrJMIYHGdpOZV3lBZ1tzJG7368zlKikAPQwNppAelwIq4rWyvHrUljdCIhej16iUcA/HJ5FxCoABzAYL9FoTlJF0x5qQtoKfoYqIbl210Mz+8fjHS6NRUahFZaEWf393Bgc35CMuTY3uQxIpDZAQclE4f6wSG5Yfh0Hnukpqr5HJGHdrL0jlYgBAcU4NACC5qwaidnSz3BWZkntNRn1oK8RSQEW8du5QOQAgs1+c8EfYXkikYqij5dBWG1Bb0UgBFSFtCN90OxBrMhURUqT1ikGnHtE4urUQteWN2Lj8BI5sLsBV9w+k9D9CSIfFsiz2/JKLfb/lAQDkKkmzG0mNdUZk7y5B8bladBuUgN6XpKA4pxYAkNJdE+ohBxxfiIJS/toCnQ4QuwgYxGJAoXDezh2RCFAq/du2oYGr+egKwwAqlX/bNjYCVqv7cUREeNz2wqFCSEyN6NpT5fw8vR6weHjjOu63pW1VKm7cAGAwAGYPdxh82VapRGScAtpqA+qL65Cc6OGtr1RyvxMAMBoBk4dpY4XC/l7xZVuTidveHbkckEh839Zs5n4W7shkgFTq+7YWC/e7c0cq5bb3dVurlXuvBWJbiYT7WQDc30RDQ2C29eXv/iI/R7jd1sPfPcuyqK+yBVRxioCdIxgA42f3wsENBSg6U42Kc5U4+ls2Rk7v6nq/vvzd0zmi+bZ0jrB/TecI37dtJ9cRbf0ccWZvKQ6tPQkJgKwJmRhzUxYXUDlsW3y2GhuXn0RDURWOFlXh/J58NNh2k9wtut2fI5QiIySmRpir6wBddOvPEZ7+7hyxRFBbW8sCYGu5H2Pzf9OmOT9BpXK9HcCy48Y5bxsf737bYcOct+3c2f22ffo4b9unj/ttO3d23nbYMPfbxsc7bztunNttrSqV87bTprnfb9O32A03eN5Wq7VvO2eO523Lyuzb3nef521zc9nNX5xgl929iS2YfqfnbY8ds+/3+ec9b7tnj33b117zvO2WLfZtly3zvO3//mffdvlyz9t++61922+/9bzt8uX2bf/3P8/bLltm33bLFs/bvvaafds9ezxv+/zz9m2PHfO87WOP2bfNzfW87X332bctK/O87Zw59m21Ws/b3nAD68TTtnSO4P75eI5Ydvcmdtk9m1izyRKUc8ThzfnskT7XeN42N9e+38ce87wtnSO4f3SO4P7ROYL7F8RzhJMwXkcIOtg54vdJz7Hv3buZNerNdI7g2c4RtQALgK2trWU9oYRy4rP2ml3buX88AKCm1MOdRkJIWERo5E49qAIpMk7Z8kaEEHIRS8+KaXfLOdoShmVZNtyDaCvq6uqg0WhQW1SEqKio5htcxFP1m1Ycx9kD5RgyuTOGX9WlXU7Vm80sPvv337A26HH9IwOQlOnid2zbltJ5QOk8PErnsQtCOs/ZA6VY/1UeUrppcP2/hwblHFF5QYtvF/4NlVKEOYvHuN62HaTzOKFzhO/b0jmC087OET5vexGm/J07VIYNn5+ASMRgxmNDkJAW6fU5or5KD4NFjJj0KIjFonZ/jjixvQh/rT6Nzv3iMGV+/1afI+rq6qBJTUVtba3r2IB/qvu9XsQiIpz/eD1t58s+veV48grktkof7tI6bGu1ssg9p4dZqkTakLTmr8Xxw6Elvmwrl9vf2AHYViIDMvvH4ey+MmQfq0dSXy8qFcpk9j/EQG4rldpPMoHcViKxn0ADua1Y7P172JdtRaLgbMswwdkWaBvbtrFzRIs8/N3XNXIXB2q+IEUQzhGRsQpYxTJojYBRLBcWLbsVrL97Okf4vi2dI/zbtgOdI1q1bYCvIwRhOkcUnKjC2YNlYK3OAXDekQqYpUoMm5aJhF7JzZ/o4RwRGRGBSMdvtPNzhCIhGmapElqjpPk+/DlHeAreHVBARVpUcq4WBp0ZMqUESV3cR+ftQdYlKTi7rwyndhRj5DVdIVfSnwAh4cRX+ON7xQWDTCmBXCWBocGM+io94lLVQTsWIYQEw4H157Hzpxy3j8ekRGDY1MzQDaiNUkRygWOjlvpQkTbm3AGuXHqXAfEQidv3srv0rFjEJKtQXdKA439ewJDJncM9JEIuak4V/oIoMk4BQ4MW9ZUUUBFC2peSc7XYuYYLpnqPSkZ0svOsIsMw6D6Ueu0BgFLNBVT6eg9p0EFAARXxiLWyyDlYBgDoOjghzKNpPYZhMPjKDGz+4hT2/paH7kMTERVPC9YJCZdA9qDyJDJWgYoCrXA8QghpD8wmCzZ/cRJggV6jknH53D7hHlKbxvcZNeotsJisIQsyKZQlHpWer4O22gCpXIyMPrHhHk5A9B6VgtQe0TAbLNjyf6dAdVkICQ+WZe0BVQhmqAD7jBghhLQH+37NQ3VJA5RRMlx6Y49wD6fNkyslYERcoZFQpv1RQEU8yrGl+2X2j4NE1jHKaTIiBhP+0RtiqQiFp6pxcntxuIdEyEXJoDPDZOAW/IZihgoAzVCRNktbbcCfq0/jwunqcA+FtBHl+fU48Ec+AGDcLT2hiPCy+MxFjBExUKj5dVShS/ujlL8OxmKy+jXjIhIzzdZHsSyLnANcul+3IYkBGV9bEZ2kwshrumLHD2ex/fszyOgbB3WMl9V9CCEBwc8WKaNkQb9hE2XrRUUzVCRcWJaFxeS6jDgL4I/PjqH4bC2ObilEVLwCPUckY9hVmVwpa3LRsVis2PTFSbBWFt2GJKLb4I51HRZMSrUUjXVG6OtDN0NFAVU71VBnRF2lvZY+awUO/nEeuYcr/NqfTCHGtf8ajMTO9ip+JTm1qK/UQyITIaNfXKvH3NYMvDwdZ/eXoSyvDttWncK0+waAYdpr22LSlNloQeUFHVg0v8EgFosQ1ymi3RdZaa9YlkVVkQ7Zu0oABH92CrCn/NXRDBUJobqKRjTUG9FYb8L278+gtsxDDxyn5+mx77c8XDhdjSvv7Ec3/C5CB9efR2WhFvIICS67uWe4h9OuKCNphop4wFpZnD9WiaIzNTi8pQBWc+DW/hj1FmxaeRLXPzYEeUcrYTFZcWRLAQCg+5BESDtIup8jkYjBxNt649uX9yLvaCVO7ylFr5Eu+jeQdqfkXC3Wf3IM2mr3DQfj09Xod1knt0G0KkqGzv3ihFxsEjiHNxVg+/dnha+7DAj+DRs+aGusM8JstHSYFGYSPtUlOhSfrXX7eEVBPY5uu+D1/hgGGD+7N1K6a1B4qhq71uSg+Gwtfn7nIG5+biREdC66aNRX6bH3tzwAwNhZPaGK8rKPFQEAKNXcz6uRZqjaH9bK4tSuYpQXaAO2T5lCjCFXdobJaMGxbRdQcLIKpbl1wuMRGhlEEvsddnWMHJfe2APRST406QNgbDTj21f2oqpIh1Uv7EZDrT2iV0RIMfr67q1/MW1UXKoaw6/KxO6fc7H9h7PoPqR9lB3N3lWM0vP1zb4vV0rQf3xahz/56nUmHNyQL6y/cWQ2WpC9swRWKwu5SgKZi15jjVoTKgq02PpVtsfjdO4Xh8nz+3XIGwrhYrFYcWhDvvD1mBu6Y+Dl6UE/rjxCAqlcDJPBgvoqPWKSfWiSSkgTZpMFP711EI11Ld8Bj4xVAAyQ1isGo2Z0g0Tm+jNGJGYgkXLnmpjkCKRnxeL7/+5DdUkD8o5UoOug9l9pl3jn6NZCWM0sUntEo+eIpHAPp91R0hqq1nvvvffw+uuvo6SkBAMHDsS7776LESNGBOVYdRWN2LX2HBpqDdDrzKi8ELhgileaW4fKIp1w0haJGaT1ikGXQQnoOzY1IClqMoUEY2/qiT8+PY6GWiMYBujcPx4iEYP+4zt1+IvzwVd2xrE/i6CrMeDM/lL0HpUS7iF5lH+8EhtXnHT7+PG/LiA2xeFikWHQdVAC+o93PxvT3uz5JRdHtxZ63Kb70ERM+EdvlwFVfRWXTtPg4WKo4GQVzh+rxOGN+Rg2rUurx3wxY1kWJ7cX48y+UhgbzdDVGqGKkuG2ly8J2Q0MhmGgjpGjuqQB2hpDhwiozh+vxKEN+WCtwa1UGtdJjUtv7EGztQ5O7ylFY50RiggpkrtpXG4jFjPoNSoZXQb6FwhFJ6nQd2wnHFh/Hn9+nY0jmwtcbieRiTFoUjrSeneMSrwXO6PejBN/FwEABl2R0WE+t0NJpeFSZGtKvUuxDYQOFVCtXr0aCxYswIcffoiRI0diyZIlmDx5MrKzs5GYGNjFfHlHKrBxxQkYGszC98QSEfpelgqpvPV3sy0mKw5tKkDhKa7aT3SSCt2HJqL7sMSgNKXsPjQRZ/eX4dzBcgy6IgOXdOBZqabEEhH6j++EXWvO4dDGAvQckRyy1AqLxYrGOu+npHW1Bmz5v1MAuNmT+HTn98K5g+WoLmnAhfoap+9fyK7G7p/PgfHy2lUkYtBrZDJGzegGsaRtzdgZGkw4uZOrzNj3sk5QRDQ/jcV1UqP70ES3H0SRsQpM+Edvj8fJ3lWMjStO4ui2C+g1KsXlviI0sov6IrOx3ghLC6nHVosVu9bk4My+MqfvD5iYFvLZYD6g0nlIBW0vWJbF39+eQU1pQ9CPdeF0DboOTkCnnjFBP1Z7oK024MD68wCAIZM7Y/CVGUE7Vv/xnXB4cwF0tUboat3fADp/vBJylQQiEYPuQxIxeHJnt+c/qUIMuYsbTaRt2P3zORgazNAkKJHZAdevh0J6Vix2/3wO+ccrYTZZhJnfYOpQf1FvvfUW5s2bh9tvvx0A8OGHH+LXX3/F559/jieffDJgxzmzrxR/fHocAJCYGYVBl6cDDJCUGRXQJrESmRj7fstD79HJuOyWXkFNO2IYBlfe0RfF52rRqUd00I7TVvW9tBP2r+MWgO5eew6pPaP92k90ohKahOYpl6yVRWleHQyN9gBcrzVh549nPX5IuqNJUGLyvH7NgvehUzNReKoaZqM9Fa6uohF7/pcLo8OxvXFoYwFqyxsx9Z7+Ib1DVlPagNoK93eVsneVwGywIDY1AuNu6Rm0sXUfloQdP+WgodaIL57e4XKbmGQVJs/rh7hOgb/J0dbt+y0Pu38+5/X2IhGDodMyEZOsCltfu4gYbh2VtsZ1QKXXmVCWV+eijElgxXdSIyK6dUUGqop1qCltgEjC4PI5WUH7Ozi1swT5xyuRc6D8og+oqop0KDpbgz2/nENjvQkKtRRZY4Kb0aCOUeDGJ4ehqljndpv845U4tbMEBh13jj+67YLHtVuMiMFV9w9A5750sd6WsCyLI1sKcWQLl31x2c09L+obdq2RmBkJdYwc2moDDm8qQHx6ZLNt3F2v+YthO0hXU6PRCJVKhe+//x4zZswQvj9nzhzU1NRg7dq1Le6jrq4OGo0G2344CnVE8x8+7+Af+dDrTMgak4Jxt/QK6h18Q6OZ7iSFyLE/L2DbKs9ralrCMED/CWmI0DhfLF04XYP845Vun+P1xRADZPSJxYR/ZvmUiqnXmdBY733gVlGoxcYVJ2A1s+g/rhPUIajCBnB3fo9uK0RLV7QMA0yZ3x9dBwd3TcGJ7UX4a/VplwVgrCwLsIBEKsLASemQKS6ev1OL2Yp9v+bBamXBiBi09O6NSlBi4j97I6V7dCiG59bun89h3295SOmmQeaAeKfHrBYrDm8uhD4EjSAlUhEGXp7uMh3VWyXnapF7uAKZ/eNw1f0DAzg6Z3lHK/Dre0egjJJxNw8vUrVlDTjh0LMwLk2NKfP7IToxcBdkraGtNsBkMKO6pAHbvz8DbZXrmwYsy4JlgYhoOQZMSAvxKIkn/N80APQf1wmX3dIrzCNq3/7+7gwOb3KdJgu4v15rSqurx7iZ/VFbW4uoqCi323WYK4CKigpYLBYkJTkv3ktKSsKpU6dcPsdgMMBgsJ906uq4gg97/pcLpcxzfn1cmhrjbu0V9P4QFEyFTt9LU1F1QYsSh8IfvjCbrKgu1uHIZtdre8QSEWJTnd9XKd01GHVtt4CkiXqiiJD61BAwJjkCteWN2L32nE9VqgIlNjXC7Y0KmUKModMykR6C9QJ9xqSiz5hUl4811hux4fPjKDhZjf2/nw/6WNqiboMTMOXu/uEehtei4rkbA8U5tSjOcV2dTR0jhzIyeOtGjY1m1JY3Yv+6wLxngt0jML13LGQKMRrrjNj5U05Qj9UeRCepkNk/DiOv6dqmKkVyZdXliEmO8Fi8wmS0YPVLe1Bb3ki/zzZIJGJwyQ3dKdgNgAET0lBRqHWZndPS9ZqjRqP72WFHF/XV+uLFi/HCCy80+37P4UmIULpP4RFJRRg8KYOa7XUwjIhp1R0hlmVxdl8Z8k9UNpthEcvE6Ds2FQkupp3bqsFXZsBqtqI+lH17GKBzv3h0H9r2GxgqI2W4+sFBOP7nBZTl+ReEt2dSpQQjrmpfxTq6DUlEVXED9G5mazWJKgy6Ij2o+fZWKxuw94xKI0eP4cGtACaWinDFnX25Ju8dIp/FTyIG3QYnILN/fMvbtmFSmRhT7+mPI5sLYLVczL/QtkckFaHPJalI6uJ+FoR4LypeiRn/GuzyMU/Xa03pGrXA8paPd1Gn/LmaoUpPT29xWo8QQgghhBDSsfHLgVqKDTrMFItMJsPQoUOxadMm4XtWqxWbNm3C6NGjXT5HLpcjKirK6R8hhBBCCCGEeKtDpfwtWLAAc+bMwbBhwzBixAgsWbIEOp1OqPpHCCGEEEIIIYHUoQKqm266CeXl5XjuuedQUlKCQYMGYd26dc0KVRBCCCGEEEJIIHSYNVSBUFtbi+joaBQUFFD6HyGEEEIIIRcxvr5CTU0NNBqN2+061AxVa1VWcn2C0tMv3l4bhBBCCCGEELvKykoKqLwVG8v1tcnPz/f4Q2uN4cOHY+/evUHZdyiPQcfxD3+nIxSzoPReo+N0pON0pNdCx2nbx+lIr4WO07aP05FeS0c9zsaNG5GRkSHECO5QQOVAJOKKHmo0mqBd7IrF4qBfSIfiGHSc1glFVUl6r9FxOtJxOtJroeO07eN0pNdCx2nbx+lIr6WjHoefYOFjBHc6TNn09uL+++/vEMeg47R99F6j43Sk43Sk10LHadvH6UivhY7Tto/TkV7LxX4cKkrhwNvmXYT4i95jhBBCCCHtw0XX2DcQ5HI5nn/+ecjl8nAPhXRQ9B4jhBBCCGkfvL1uoxkqQgghhBBCCPETzVARQgghhBBCiJ8ooCKEEEIIIYQQP1FARQghhBBCCCF+ooCKEEIIIYQQQvxEARUhhBBCCCGE+IkCKkIIIYQQQgjxEwVUhBBCCCGEEOInCqgIIYQQQgghxE8UUBFCCCGEEEKInyigIoQQQgghhBA/UUBFCCGEEEIIIX6igIoQQgghhBBC/EQBFSGEEEIIIYT4iQIqQgghhBBCCPETBVSEEEIIIYQQ4icKqAghhBBCCCHETxRQEUIIIYQQQoifKKAihBBCCCGEED9Jwj2AtsRqtaKoqAiRkZFgGCbcwyGEEEIIIYSECcuyqK+vR2pqKkQi9/NQFFA5KCoqQnp6eriHQQghhBBCCGkjCgoKkJaW5vZxCqgcREZGAuB+aFFRUWEeDSGEEEIIISRc6urqkJ6eLsQI7lBA5YBP84uKiqKAipAAYlkWtYZaAIBGrqGUWkIIIYS0Gy1dt1BARQgJugZTA2L+GwMA0D6lRYQsIswjIoQQQggJDKryR7xi0uvBsmy4h0EIIYQQQkibQjNUpEU7v/8aO777Cj1GXIJrHn063MMh7ZBKqoLxGSMAQCKi0w4hhBBCOg66siFOakpLsOuHr2EyGITvnd71NwDgzJ4d4RoWaecYhoFULA33MAghhASYxWKByWQK9zAI8YtUKoVYLG71fiiguog11NWiLO+c0/f2/7oGeYf2u9xeplSGYliEEEIIaeNYlkVJSQlqamrCPRRCWiU6OhrJycmtKphFAdVFymq14JvnHkd18QWXj4+Z9Q/I1WoAQE1JMQ78thYAVWYj/jFajPjPpv8AAF6+/GXIxLIwj4gQQkhr8MFUYmIiVCoVVW8l7Q7LsmhoaEBZWRkAICUlxe99UUB1ETEbjfj5rVdQWZgPq8UCbVUlJFIZYlI7OW2X0W8ARs28Wfi6uqTIFlBRUQriH5PFhDd2vgEAWDh+IQVUhBDSjlksFiGYiouLC/dwCPGb0pZ9VVZWhsTERL/T/yig6uAsZjOObv4Dem09akqLkXtwn9Pjg6dOx2Wzb/e4D8Y2M0VF/oi/pGIpHhv9mPD/hBBC2i9+zZRKpQrzSAhpPf59bDKZKKAizRkaGnBk0zr8+X+fO31/0OSr0eeyCRBLpIjP6NzyjvhpfIqoiJ9kYhlev/L1cA+DEEJIAFGaH+kIAvE+poCqgzr51xb89t5bQhDUecBgRMUnQB6hxuiZN0Om9P6uEv9GYynljxBCCCGEECfU2LeDuZB9Er+8tRjb/u9zIZiKSU3D1Y88gSvvfgjj/nGHT8EU4BC5WymgIv5hWRYmiwkmi4kaRBNCCAmL8ePH45FHHgn5cfPy8sAwDA4dOhTyYzf18ccfIz09HSKRCEuWLAn58RmGwZo1a0J+3GCjGaoOpPTcWXzz/ONCICWRyzH//RVQqiNbt2M+449mqIifGkwNUC/mqkZqn9IiQhYR5hERQgghF5e6ujo88MADeOuttzBz5kxoNJqgHWvhwoVYs2ZNsyCyuLgYMTExQTtuuFBA1UHkHzuC7156GgAglkoxYc58pPTo1fpgCoA9oqKAihBCCCGkPcrPz4fJZMJVV13ltkS40WiETBa8SrzJyclB23c4UcpfB7D1i0+EYAoAxv3jDgy8YioSM7sGZP/CGiqKp4ifVFIVqp+oRvUT1VBJqSoUIYSQ8LBarXj88ccRGxuL5ORkLFy4EACXmr5w4UJkZGRALpcjNTUVDz30kPA8V6lq0dHRWLFihV/j2LZtG0aMGAG5XI6UlBQ8+eSTMJvNwuPff/89+vfvD6VSibi4OEyaNAk6nQ4AsHXrVowYMQIRERGIjo7GmDFjcP78eY/HW7FiBfr37w8A6Nq1KxiGQV5eHhYuXIhBgwbh008/RZcuXaBQKAAA69atw6WXXoro6GjExcXh6quvRk5OjtM+CwsLccsttyA2NhYREREYNmwYdu/ejRUrVuCFF17A4cOHwTAMGIYRfk5Nf45Hjx7FxIkThdc5f/58aLVa4fG5c+dixowZeOONN5CSkoK4uDjcf//9QqXJtsKvgOq9995DZmYmFAoFRo4ciT179njc/rvvvkPv3r2hUCjQv39//Pbbb06PsyyL5557DikpKVAqlZg0aRLOnDkjPL5161bhF9L03969ewHY81Ob/tu1a5c/L7Fd0Gu12Pjp+9j/61oAACMSYc4b72HwlOmBPZBQ/IQiKuIfhmEQrYhGtCKaqkIRQkgHw7IsTHp9WP75ui535cqViIiIwO7du/Haa6/hxRdfxIYNG/DDDz/g7bffxkcffYQzZ85gzZo1QgASaBcuXMC0adMwfPhwHD58GB988AE+++wzLFq0CACXFnfLLbfgjjvuwMmTJ7F161Zcf/31YFkWZrMZM2bMwLhx43DkyBHs3LkT8+fPb/Gz9aabbsLGjRsBAHv27EFxcTHS09MBAGfPnsUPP/yAH3/8UUjR0+l0WLBgAfbt24dNmzZBJBLhuuuug9VqBQBotVqMGzcOFy5cwM8//4zDhw/j8ccfh9VqxU033YRHH30Uffv2RXFxMYqLi3HTTTc1G5NOp8PkyZMRExODvXv34rvvvsPGjRvxwAMPOG23ZcsW5OTkYMuWLVi5ciVWrFjhdyAbLD6n/K1evRoLFizAhx9+iJEjR2LJkiWYPHkysrOzkZiY2Gz7HTt24JZbbsHixYtx9dVXY9WqVZgxYwYOHDiAfv36AQBee+01LF26FCtXrkSXLl3w7LPPYvLkyThx4gQUCgUuueQSFBcXO+332WefxaZNmzBs2DCn72/cuBF9+/YVvu6oDefMRiP++GgpzuzZAQDQJCXj5hdegzomNuDHsvehooCKEEIIIc7MBgOWzrkhLMd+aOX3kNpmVbwxYMAAPP/88wCAHj16YNmyZdi0aRMSExORnJyMSZMmQSqVIiMjAyNGjAjKmN9//32kp6dj2bJlYBgGvXv3RlFREZ544gk899xzKC4uhtlsxvXXX4/Onbn2NnxwV1VVhdraWlx99dXo1q0bACArK6vFY/IzQACQkJDglHpnNBrxxRdfICEhQfjezJkznZ7/+eefIyEhASdOnEC/fv2watUqlJeXY+/evYiN5a49u3fvLmyvVqshkUg8pvitWrUKer0eX3zxBSIiuLXVy5Ytw/Tp0/Hf//4XSUlJAICYmBgsW7YMYrEYvXv3xlVXXYVNmzZh3rx5Lb7uUPF5huqtt97CvHnzcPvtt6NPnz748MMPoVKp8Pnnn7vc/p133sGUKVPw73//G1lZWXjppZcwZMgQLFu2DAB3kb5kyRI888wzuPbaazFgwAB88cUXKCoqEqYEZTIZkpOThX9xcXFYu3Ytbr/99mYReVxcnNO2UmnHayLaWF+HTx64QwimUnr2xsynXwxKMAVwM18AaIKK+M1oMWLh1oVYuHUhjBZjuIdDCCHkIjVgwACnr1NSUlBWVoYbb7wRjY2N6Nq1K+bNm4effvrJKQUvkE6ePInRo0c7XcOOGTMGWq0WhYWFGDhwIC6//HL0798fN954Iz755BNUV1cDAGJjYzF37lxMnjwZ06dPxzvvvNNs0sFXnTt3dgqmAODMmTO45ZZb0LVrV0RFRSEzMxMAtw4LAA4dOoTBgwcLwZQ/Tp48iYEDBwrBFMD9HKxWK7Kzs4Xv9e3b16nhLv87a0t8mqEyGo3Yv38/nnrqKeF7IpEIkyZNws6dO10+Z+fOnViwYIHT9yZPniwES7m5uSgpKcGkSZOExzUaDUaOHImdO3fi5ptvbrbPn3/+GZWVlbj99tubPXbNNddAr9ejZ8+eePzxx3HNNde4fT0GgwEGg0H4uq6uzu22bYXFbMKq/zyKhtoaAFx/qZlPvWAPeoKIZa1BPwbpmEwWE17Y9gIA4N+X/BsycfAWvBJCCAktiVyOh1Z+H7Zj+6LpjXaGYWC1WpGeno7s7Gxs3LgRGzZswH333YfXX38d27Ztg1QqBcMwzTJ1grWORywWY8OGDdixYwf++OMPvPvuu/jPf/6D3bt3o0uXLli+fDkeeughrFu3DqtXr8YzzzyDDRs2YNSoUX4dzzGg4U2fPh2dO3fGJ598gtTUVFitVvTr1w9GI3dTVKlUtuo1+sLd76wt8ekqvKKiAhaLRZiC4yUlJaGkpMTlc0pKSjxuz//Xl31+9tlnmDx5MtLS0oTvqdVqvPnmm/juu+/w66+/4tJLL8WMGTPw888/u309ixcvhkajEf7xuaRtEcuyKDhxFDu//xo1pdydiCvmPYAb/vNS0IMpWvNCWksikuC+YffhvmH3QSKi4qKEENKRMAwDqUIRln+BvEZRKpWYPn06li5diq1bt2Lnzp04evQoAC5NznEm6MyZM2hoaPDrOFlZWdi5c6dTgLZ9+3ZERkYK17YMw2DMmDF44YUXcPDgQchkMvz000/C9oMHD8ZTTz2FHTt2CCl4gVJZWYns7Gw888wzuPzyy5GVlSXMkPEGDBiAQ4cOoaqqyuU+ZDIZLBaLx+NkZWXh8OHDQrENgPs5iEQi9OrVq/UvJITa3ZVNYWEh1q9fj2+//dbp+/Hx8U4zYcOHD0dRURFef/11t7NUTz31lNNz6urq2mxQdXrXdvxvyavC12lZ/dB/4pWhObjDyYplWQqwiM/kEjneu+q9cA+DEEIIcWnFihWwWCwYOXIkVCoV/u///g9KpVJYwzRx4kQsW7YMo0ePhsViwRNPPOH3spL77rsPS5YswYMPPogHHngA2dnZeP7557FgwQKIRCLs3r0bmzZtwpVXXonExETs3r0b5eXlyMrKQm5uLj7++GNcc801SE1NRXZ2Ns6cOYPbbrstYD+LmJgYxMXF4eOPP0ZKSgry8/Px5JNPOm1zyy234JVXXsGMGTOwePFipKSk4ODBg0hNTcXo0aORmZmJ3NxcHDp0CGlpaYiMjIS8yWzi7Nmz8fzzz2POnDlYuHAhysvL8eCDD+Kf//xns4mWts6ngCo+Ph5isRilpaVO3y8tLXW76Cw5Odnj9vx/S0tLnWril5aWYtCgQc32t3z5csTFxXlM5eONHDkSGzZscPu4XC5v9sttS87s2YHNn38Is9kMk74RABCT0glxaem48u6HQpLm1wzLOgVYhBBCCCHtXXR0NF599VUsWLAAFosF/fv3xy+//CIUcnjzzTdx++23Y+zYsUhNTcU777yD/fv3+3WsTp064bfffsO///1vDBw4ELGxsbjzzjvxzDPPAACioqLw559/YsmSJairq0Pnzp3x5ptvYurUqSgtLcWpU6ewcuVKVFZWIiUlBffffz/uvvvugP0sRCIRvvnmGzz00EPo168fevXqhaVLl2L8+PHCNjKZDH/88QceffRRTJs2DWazGX369MF773E3T2fOnIkff/wREyZMQE1NDZYvX465c+c6HUelUmH9+vV4+OGHMXz4cKhUKsycORNvvfVWwF5LqDCsj6XbRo4ciREjRuDdd98FwNXzz8jIwAMPPNAsegW4Mo0NDQ345ZdfhO9dcsklGDBgAD788EOwLIvU1FQ89thjePTRRwFwM0WJiYlYsWKF0xoqlmXRrVs3XH/99XjjjTdaHOu8efOwf/9+HDhwwKvXVldXB41Gg9raWkRFRXn1nEDJO3wABSeOOn0ve8efqC2zB6NShRK3v/UBIuPiQzq2xvo6vH/XrQCAf329FiKRuIVnEEIIIaSj0uv1yM3NdepbREh75en97G1s4HPK34IFCzBnzhwMGzYMI0aMwJIlS6DT6YQCEbfddhs6deqExYsXAwAefvhhjBs3Dm+++SauuuoqfPPNN9i3bx8+/vhjAFyO6COPPIJFixahR48eQtn01NRUzJgxw+nYmzdvRm5uLu66665m41q5ciVkMhkGDx4MAPjxxx/x+eef49NPP/X1JYYEy7KorywHa7XC2NiINa+9CIuLajISqQw3v/gaJDIZIqJjoVCrQz5WhnGYCaNKf8QPOqMO0f+NBgDUPFGDCFnzBbCEEEIIIe2RzwHVTTfdhPLycjz33HMoKSnBoEGDsG7dOiHXMT8/HyKHVLRLLrkEq1atwjPPPIOnn34aPXr0wJo1a4QeVADw+OOPQ6fTYf78+aipqcGll16KdevWNYsSP/vsM1xyySXo3bu3y7G99NJLOH/+PCQSCXr37o3Vq1fjhhvC0xehJRs+WYajm9Y7fU+TmIRuw5wrtGQOHIKkrt0RVg4ZflylP5qhIr4zW4NTfpYQQggJp1deeQWvvPKKy8fGjh2L33//PSTj6Nu3L86fP+/ysY8++gizZ88OyTguRj6n/HVkwUz5q7xQgL9WrYBJrwcAFJ48DqvFDIlcDgYMJDIZrrz7IXQf7l/Jy2AyNOiw7Hauw/XD//cTJB2wtxcJLitrRXE9Vx0pJTIFIiYM6/8IIYQEBKX8OauqqnJb7U6pVKJTp04hGcf58+fdlnJPSkpCZGRkSMbR3oQl5Y94R1dTjcKTx4SSmEc3rUP+sSNO26R074VbX34zHMPzkdMUVfiGQdotESNCp6jQfKAQQgghoRQbG9uqBreBwlckJKFHAVUQsCyLn/77AkrPnW322IS5d0MZFQWGYZDep38YRuc7x6J+LC2iIoQQQgghREABVSvt++VH7PppNViHjs0sC5j0jRBLJEjtmSV8v1NWPwyZOj0cw2wdhmaoSOsYLUa8s+sdAMDDox6GTCwL84gIIYQQQgKDAioPCk4cRc7+PR63ObppPYyNrjtl95twBSbddX8whhZSjFPKX/jGQdovk8WExzc+DgC4b/h9FFARQgghpMOggMqFquILMNZWY+0bi2DQ6VrcXpOYhJlPv+g0kyMSiRGVkBjMYYaOyP66KOWP+EMikmDOwDnC/xNCCCGEdBR0ZePCV089AoWtkl1ETCz6jJ3gdluGYdBz1KWISem4C+4dZ6hYKwVUxHdyiRwrZqwI9zAIIYQQQgKOAioX5Co1FDIpRBIJxt4yB33HXR7uIYWX4xoqmqEihBBCCAkphmHw008/YcaMGeEeCgAgLy8PXbp0wcGDBzFo0KBwDyfsqBmMC/PfX477P/8G9378fxRMoWlNCgqoCCGEENL+zJ07FwzD4J577mn22P333w+GYTB37tzQD6yVPvzwQ0RGRsJsNgvf02q1kEqlGD9+vNO2W7duBcMwyMnJCfEoOZmZmWAYBgzDQKlUIjMzE7NmzcLmzZt93tfcuXPbTIBJARXxAhWlIK2jM+oQ/Wo0ol+Nhs7Y8rpEQgghJBjS09PxzTffoLGxUfieXq/HqlWrkJGREcaR+W/ChAnQarXYt2+f8L2//voLycnJ2L17N/R6vfD9LVu2ICMjA926dQvHUAEAL774IoqLi5GdnY0vvvgC0dHRmDRpEl5++eWwjam1KKAiLWIYKkpBWq/WUItaQ224h0EIIeQiNmTIEKSnp+PHH38Uvvfjjz8iIyMDgwcPdtp23bp1uPTSSxEdHY24uDhcffXVTjM7eXl5YBgGP/74IyZMmACVSoWBAwdi586dwjYLFy5slhK3ZMkSZGZmCl/v3bsXV1xxBeLj46HRaDBu3DgcOHDA69fUq1cvpKSkYOvWrcL3tm7dimuvvRZdunTBrl27nL4/YQJXG+DL/2/vzuOiqvo/gH9mBgZQECRZFRQVDTVBUQl3k0Qrk7TceHJN/Rm44ZKYoGVPuOSuSe4+PpJmPaKVWYS7IipKLiCJipoJuLDIsA3M/f1BXB0BmRkHRvDzfr14OZx77j3fS7eZ+51z7jnbt6NDhw6wsLCAvb09hg8fjvT0dLFuRkYG/P39YWNjAzMzM7i6umLLli1qbV+/fr3Cc69IaXvOzs7o3r071q9fj5CQEISGhiIpKQkAUFxcjLFjx8LFxQVmZmZo2bIlVq5cKR5j/vz52LZtG/bu3Sv2eJWe/+3btzF48GBYWVnB2toaAwYMQEpKisZ/T10woaLKqT1CxYSKtGdmbIY/A//En4F/wszYzNDhEBFRFVAUKqAoVKg9HlBYXAhFoQIFRQXl1lUJj9fxVBYroShUIL8oX6O6uhozZoxaYrB582aMHj267PkoFAgKCsLZs2cRHR0NqVSK9957D6on1h4FgE8//RQzZsxAfHw8WrRogWHDhqkNv6vMo0ePMHLkSBw/fhynTp2Cq6sr3nrrLTx69EjjY/Tq1QuHDh0Sfz906BB69uyJHj16iOV5eXmIjY0VEyqlUokFCxbgjz/+QGRkJFJSUtSGPIaEhCAhIQG//PILEhMTsW7dOjRo0ECv515qypQpEAQBe/fuBQCoVCo0atQIu3fvRkJCAkJDQzFnzhx89913AIAZM2Zg8ODB6Nu3L+7evYu7d++ic+fOUCqV8PX1hYWFBY4dO4YTJ07A3Nwcffv2RWFhodZxaUwgUVZWlgBAyMrKMnQoLxSVSiV8Nfht4avBbwuKrExDh0NEREQGlJeXJyQkJAh5eXlq5ZgPAfMhpOeki2VfHPlCwHwIH+39SK1unX/XETAfwo2MG2LZ8pjlAuZDGP7DcLW6DRY3EDAfwqW0S2LZ+rPrtY575MiRwoABA4T09HTBxMRESElJEVJSUgRTU1Ph3r17woABA4SRI0dWuP+9e/cEAMLFixcFQRCEGzduCACEjRs3inUuX74sABASExMFQRCEefPmCe7u7mrHWb58udC4ceMK2ykuLhYsLCyEH3/8USwDIOzZs6fCfTZs2CDUrVtXUCqVQnZ2tmBkZCSkp6cLERERQvfu3QVBEITo6GgBgHDz5s1yj3HmzBkBgPDo0SNBEAShf//+wujRo8utq8m5l6dx48bC8uXLy91mZ2cnTJw4scJ9AwIChEGDBom/l/73fNL27duFli1bCiqVSiwrKCgQzMzMhF9//bXc41Z0PQuC5rkBe6ioUhL1WSkMFwgRERHRc7KxscHbb7+NrVu3YsuWLXj77bfL9LwAwNWrVzFs2DA0bdoU9erVE4fp3bp1S61e27ZtxdcODg4AoDZ0rjJpaWkYN24cXF1dYWlpiXr16iEnJ6dMO8/Ss2dPKBQKnDlzBseOHUOLFi1gY2ODHj16iM9RHT58GE2bNhWfFYuLi0P//v3h7OwMCwsL9OjRQ+38Jk6ciJ07d8LDwwOzZs3CyZMny7T7vOf+JEEQ1O45165dC09PT9jY2MDc3Bzr16+v9G/yxx9/IDk5GRYWFjA3N4e5uTmsra2Rn59fpRNxcNp00orAhIp0oCxWYn3cegDAeM/xMJYZGzgiIiLSt5zgHABAHeM6YtnMLjMx9fWpZRZ1T59RctP95DDwgI4BGNd+HGRSmVrdlCkpZeqO8hj1XLGOGTMGgYGBAEpu3MvTv39/NG7cGBs2bICjoyNUKhXatGlTZuiYsfHjz7TShKB0WKBUKi1z76RUqg9XHDlyJB48eICVK1eicePGMDExgbe3t1ZD1Jo3b45GjRrh0KFDyMjIEJMjR0dHODk54eTJkzh06BDeeOMNACXDGX19feHr64sdO3bAxsYGt27dgq+vr9huv379cPPmTezfvx9RUVHo3bs3AgIC8NVXX2l07tp48OAB7t27BxcXFwDAzp07MWPGDCxduhTe3t6wsLDAkiVLEBsb+8zj5OTkwNPTEzt27CizzcbGRuu4NMWEijQjkbB3inRWWFyIwF9KPrhGeYxiQkVEVAvVldctUyaXySGXyTWqaywzLvfzoaK6z6P0mRqJRAJfX98y2x88eICkpCRs2LAB3bp1AwAcP35c63ZsbGyQmpqq1vsSHx+vVufEiRP4+uuv8dZbbwEomVTh/v37WrfVq1cvHD58GBkZGZg5c6ZY3r17d/zyyy84ffo0Jk6cCAC4cuUKHjx4gIULF8LJyQkA1GYJfDL+kSNHYuTIkejWrRtmzpypllDpy8qVKyGVSsVp0E+cOIHOnTvj448/Fus83cMkl8tRXFysVta+fXvs2rULtra2qFevnt7jrAiH/JFGJP/MTMEeKtKFTCrD+63ex/ut3i/zzSMREVF1k8lkSExMREJCAmSysp9L9evXxyuvvIL169cjOTkZBw8eRFBQkNbt9OzZE/fu3cPixYtx7do1rF27Fr/88otaHVdXV2zfvh2JiYmIjY2Fv78/zMy0n8CpV69eOH78OOLj48UeKgDo0aMHvvnmGxQWFooTUjg7O0Mul2P16tW4fv069u3bhwULFqgdLzQ0FHv37kVycjIuX76Mn376CW5ublrH9bRHjx4hNTUVt2/fxtGjRzF+/Hh88cUX+Pe//43mzZsDKPmbnD17Fr/++iv+/PNPhISE4MyZM2rHadKkCS5cuICkpCTcv38fSqUS/v7+aNCgAQYMGIBjx47hxo0bOHz4MCZPnoy//vrruWOvCBMq0kzpkFYmVKQDUyNT7P5gN3Z/sBumRqaGDoeIiAj16tWrsBdDKpVi586diIuLQ5s2bTBt2jQsWbJE6zbc3Nzw9ddfY+3atXB3d8fp06cxY8YMtTqbNm1CRkYG2rdvjw8//BCTJ0+Gra2t1m316tULeXl5aN68Oezs7MTyHj164NGjR+L06kBJz9PWrVuxe/dutGrVCgsXLizT8ySXyxEcHIy2bduie/fukMlk2Llzp9ZxPS00NBQODg5o3rw5PvzwQ2RlZSE6OhqffPKJWGfChAkYOHAghgwZAi8vLzx48ECttwoAxo0bh5YtW6JDhw6wsbHBiRMnUKdOHRw9ehTOzs4YOHAg3NzcMHbsWOTn51dpj5VEYJeDKDs7G5aWlsjKyqrWbsKaYPlwP6iKizB+3VZYWJd9cJOIiIheDvn5+bhx4wZcXFxgasovyahme9b1rGluwB4q0kjppCuCivk3EREREVEpJlSkGXEaSyZUpL1cZS4aLmuIhssaIleZa+hwiIiIiPSGs/yRRkonpWA+RboQBAF/P/pbfE1ERERUWzChIs1IOMsf6c7UyBTnJ5wXXxMRERHVFkyoSDPiwtVMqEh7MqkMHvYehg6DiIj0iF+yUm2gj+uYz1CRRh6vQ2XgQIiIiMigjI1LFtXNzeUzsVTzlV7Hpde1LnTqoVq7di2WLFmC1NRUuLu7Y/Xq1ejUqVOF9Xfv3o2QkBCkpKTA1dUVixYtEleDBkoyw3nz5mHDhg3IzMxEly5dsG7dOri6uop1mjRpgps3b6odNywsDLNnzxZ/v3DhAgICAnDmzBnY2Nhg0qRJmDVrli6nSE+RSEsTKpWBI6GaSFmsxI6LOwAA/q/5P/cK90REZDgymQxWVlZIT08HANSpUwcScfIqoppBEATk5uYiPT0dVlZW5S7wrCmtE6pdu3YhKCgI4eHh8PLywooVK+Dr64ukpKRyFyE7efIkhg0bhrCwMLzzzjuIiIiAn58fzp07hzZt2gAAFi9ejFWrVmHbtm1wcXFBSEgIfH19kZCQoDYf/Oeff45x48aJv1tYWIivs7Oz0adPH/j4+CA8PBwXL17EmDFjYGVlhfHjx2t7mlRG6aQU7KIi7RUWF2L03tEAgA9afcCEioiohrO3twcAMakiqqmsrKzE61lXWi/s6+XlhY4dO2LNmjUAAJVKBScnJ0yaNEmtt6jUkCFDoFAo8NNPP4llr7/+Ojw8PBAeHg5BEODo6Ijp06eLK0dnZWXBzs4OW7duxdChQwGU9FBNnToVU6dOLTeudevW4dNPP0VqairkcjkAYPbs2YiMjMSVK1c0Ojcu7FuxNaOHoCBXgdHLv4G1Y0NDh0M1TH5RPgZ9NwgA8MPgHzgxBRFRLVFcXAylUmnoMIh0Ymxs/MyeKU1zA616qAoLCxEXF4fg4GCxTCqVwsfHBzExMeXuExMTg6CgILUyX19fREZGAgBu3LiB1NRU+Pj4iNstLS3h5eWFmJgYMaECgIULF2LBggVwdnbG8OHDMW3aNBgZGYntdO/eXUymSttZtGgRMjIyUL9+/TKxFRQUoKCgQPw9Oztbi7/GS4aTUtBzMDUyxc/DfzZ0GEREpGcymey5hkoR1QZaJVT3799HcXEx7Ozs1Mrt7Owq7AVKTU0tt35qaqq4vbSsojoAMHnyZLRv3x7W1tY4efIkgoODcffuXSxbtkw8jouLS5ljlG4rL6EKCwvDZ599Vul505OTUjChIiIiIiIqVWOmTX+yl6tt27aQy+WYMGECwsLCYGJiotMxg4OD1Y6bnZ0NJyen5461VpJwYV8iIiIioqdpNW16gwYNIJPJkJaWplaelpZW4cNc9vb2z6xf+q82xwRKnuUqKipCSkrKM9t5so2nmZiYoF69emo/VAFx9h5mVKS9XGUuXFe7wnW1K3KVnGaXiIiIag+tEiq5XA5PT09ER0eLZSqVCtHR0fD29i53H29vb7X6ABAVFSXWd3Fxgb29vVqd7OxsxMbGVnhMAIiPj4dUKhVnFvT29sbRo0fVHoyMiopCy5Ytyx3uR9opnQ5VUHHadNKeIAhIfpiM5IfJHDZKREREtYrWQ/6CgoIwcuRIdOjQAZ06dcKKFSugUCgwenTJlMgjRoxAw4YNERYWBgCYMmUKevTogaVLl+Ltt9/Gzp07cfbsWaxfvx5AyY361KlT8cUXX8DV1VWcNt3R0RF+fn4ASiaciI2NRa9evWBhYYGYmBhMmzYN//rXv8Rkafjw4fjss88wduxYfPLJJ7h06RJWrlyJ5cuX6+Pv9NITEyoDx0E1k6mRKY6PPi6+JiIiIqottE6ohgwZgnv37iE0NBSpqanw8PDAgQMHxAkgbt26Ban0ccdX586dERERgblz52LOnDlwdXVFZGSkuAYVAMyaNQsKhQLjx49HZmYmunbtigMHDohrUJmYmGDnzp2YP38+CgoK4OLigmnTpqk9/2RpaYnffvsNAQEB8PT0RIMGDRAaGso1qPSNvQukA5lUhi7OXQwdBhEREZHeab0OVW3GdagqFj7hQygyM/DholWwbdLU0OEQEREREVWpKlmHil5i4qQURNorUhVhT+IeAMB7bu/BSMq3HiIiIqodeFdDGhHn+GOHJumgoKgAg78fDADICc6BkZxvPURERFQ78K6GNFP6XBwTKtKBVCJFj8Y9xNdEREREtQUTKtKI5J8+KvZQkS7MjM1weNRhQ4dBREREpHf8qpg083jMn0HDICIiIiJ6kTChIo08XoeKCRURERERUSkmVKShf7qomE+RDvKUefAI94BHuAfylHmGDoeIiIhIb/gMFWmkdNZ0PkNFulAJKvyR9of4moiIiKi2YEJFmhHXoWJCRdozNTLFb//6TXxNREREVFswoSKNiM9QqZhQkfZkUhnebPamocMgIiIi0js+Q0Ua4aQURERERERlsYeKNCQ+RGXYMKhGKlIV4dfkXwEAvs19YSTlWw8RERHVDryrIc1IOMsf6a6gqADvfPsOACAnOAdGcr71EBERUe3AuxrSyOMpKZhRkfakEik6OHYQXxMRERHVFkyoSDMSDvkj3ZkZm+HMuDOGDoOIiIhI7/hVMWlEnJSC+RQRERERkYgJFWnkcUId1xHZAAArFklEQVTFRVmJiIiIiEoxoSLNcFIKeg55yjx02dwFXTZ3QZ4yz9DhEBEREekNn6EijXBSCnoeKkGFk7dPiq+JiIiIagsmVKQZTkpBz8HEyAR7huwRXxMRERHVFkyoSDNMqOg5GEmN4Peqn6HDICIiItI7PkNFGpH8M+iP6RQRERER0WPsoSKNSKSc5Y90V6wqxrFbxwAA3Zy7QSaVGTgiIiIiIv1gQkUa4ix/pLv8onz02tYLAJATnIO68roGjoiIiIhIP3Qa8rd27Vo0adIEpqam8PLywunTp59Zf/fu3Xj11VdhamqK1157Dfv371fbLggCQkND4eDgADMzM/j4+ODq1avi9pSUFIwdOxYuLi4wMzNDs2bNMG/ePBQWFqrVkUgkZX5OnTqlyynSUx4/QsWMirQnkUjQyqYVWtm0Etc0IyIiIqoNtE6odu3ahaCgIMybNw/nzp2Du7s7fH19kZ6eXm79kydPYtiwYRg7dizOnz8PPz8/+Pn54dKlS2KdxYsXY9WqVQgPD0dsbCzq1q0LX19f5OfnAwCuXLkClUqFb775BpcvX8by5csRHh6OOXPmlGnv999/x927d8UfT09PbU+RyiN5PHE6kbbqGNfB5Y8v4/LHl1HHuI6hwyEiIiLSG4mgZZeDl5cXOnbsiDVr1gAAVCoVnJycMGnSJMyePbtM/SFDhkChUOCnn34Sy15//XV4eHggPDwcgiDA0dER06dPx4wZMwAAWVlZsLOzw9atWzF06NBy41iyZAnWrVuH69evAyjpoXJxccH58+fh4eGhzSmJsrOzYWlpiaysLNSrV0+nY9RWEZ9Ox93kJAyYGYLmHbwMHQ4RERERUZXSNDfQqoeqsLAQcXFx8PHxeXwAqRQ+Pj6IiYkpd5+YmBi1+gDg6+sr1r9x4wZSU1PV6lhaWsLLy6vCYwIlSZe1tXWZ8nfffRe2trbo2rUr9u3b98zzKSgoQHZ2ttoPVUDsoGIPFRERERFRKa0Sqvv376O4uBh2dnZq5XZ2dkhNTS13n9TU1GfWL/1Xm2MmJydj9erVmDBhglhmbm6OpUuXYvfu3fj555/RtWtX+Pn5PTOpCgsLg6Wlpfjj5ORUYd2XnqR02nQmVKS9PGUe3tz+Jt7c/ibylHmGDoeIiIhIb2rcLH937txB37598cEHH2DcuHFieYMGDRAUFCT+3rFjR/z9999YsmQJ3n333XKPFRwcrLZPdnY2k6oKSCT/5N4qJlSkPZWgwu/XfxdfExEREdUWWiVUDRo0gEwmQ1pamlp5Wloa7O3ty93H3t7+mfVL/01LS4ODg4Nanaefhfr777/Rq1cvdO7cGevXr680Xi8vL0RFRVW43cTEBCYmJpUeh56Y5Y89VKQDEyMT/Pe9/4qviYiIiGoLrYb8yeVyeHp6Ijo6WixTqVSIjo6Gt7d3uft4e3ur1QeAqKgosb6Liwvs7e3V6mRnZyM2NlbtmHfu3EHPnj3h6emJLVu2QCqtPPT4+Hi1JI2ehzhvumHDoBrJSGoE/7b+8G/rDyNpjesYJyIiIqqQ1nc2QUFBGDlyJDp06IBOnTphxYoVUCgUGD16NABgxIgRaNiwIcLCwgAAU6ZMQY8ePbB06VK8/fbb2LlzJ86ePSv2MEkkEkydOhVffPEFXF1d4eLigpCQEDg6OsLPzw/A42SqcePG+Oqrr3Dv3j0xntIerm3btkEul6Ndu3YAgP/973/YvHkzNm7cqPtfh0SlawcxnyIiIiIiekzrhGrIkCG4d+8eQkNDkZqaCg8PDxw4cECcVOLWrVtqvUedO3dGREQE5s6dizlz5sDV1RWRkZFo06aNWGfWrFlQKBQYP348MjMz0bVrVxw4cACmpqYASnq0kpOTkZycjEaNGqnF8+Ss7wsWLMDNmzdhZGSEV199Fbt27cL777+v7SlSecS1WJlRkfaKVcU4d/ccAKC9Q3vIpDIDR0RERESkH1qvQ1WbcR2qin33WTBuJ1zE21Nm4dXO3Q0dDtUwikIFzMPMAQA5wTmoK69r4IiIiIiInk3T3IAPM5BmJHyGinQnkUjQ2LKx+JqIiIiotmBCRRp5/AwVEyrSXh3jOkiZmmLoMIiIiIj0TqtZ/uglxh4qIiIiIqIy2ENFGhF7qAwcB9UMquJiRG1Ygwe3b4llUiMZXh84FE3c2xswMiIiIiL9YkJF2mEP1UtDkZmBG/FxEFQqrffNuHsHlw49XlRbKSnGfxueR919+3CkdTxMjUz1GSoREVGt9fDvO7hz5fIz60ikUrh4eKKuVf1qioqexISKNMJnqF4+P61YhL8SLz3XMVp164UW3l3x56U4BKccAFRpKFYV6ylCIiKi2q24SInvPg+GIuNhpXWbdfCC38yQaoiKnsaEijTDmdlqtPMHfsSR7ZtQXKxFMiMI4jdeujCpa44eIz5CnXqWyMvPw/snX0N9B0fIZXKdjkdERFRT/XXlMiIXfY6CvFztdvzni2yTOnXR8NVW5VbJzc5CavKfyHn44HnDJB0xoSKNiD1UOgz/oqqRr8hB7J7vUKjBm/OfsSdRXFSkdRutur2Bvh9P1SE6daZyU7ye6QwHm5Ywlhk/9/GIiIgMIT8nB7GRmn32PunOlQQU5Cp0btfrvcHo+O6gcrfdvBCP7/89V6fPedIPJlSkkceTUnDIX3XIzc7Co/v3nlnnQvQBXPj9gMbHrGtVH/5hyyGVyjSqL5FIYFbPUuPjP4vMqOStRqVNDxkREZGWcjIeajQ8TlcXfj+AC9Gaf/aqkUgw7PMlsLS102o3qZERzMwtKtwuMy75jGVCZThMqEg7zKeqXG5WJjZPnaDxN1mvvdEHFg1snllHAglc2nWAhXUDfYSoPZkUqSaPUKBKg0pQQSrhig1ERKRfmal3sW1GAIqUhVXe1mu9fWHxinafqbZNmsGxxat6j0VmVDLyo1ip1PuxSTNMqEgznJSiymSm3sVv36xCQW7J8IGCPAUKchUwMjGBmXm9Z+5r08QFvcd+LPYAvaiUkiJ81ewoAGCKciPqyusaOCIiIqoKWemp+HXdSvEzrTrl5WSjSFkIY1MzmNY1r7J2bF2aoveYiS/MZ6+0dBRIERMqQ3kxrgR64UnESSmYUOnLXwmXcP+vW0g+E4PbCRfLbPcZ+zFa9+htgMj0TyozQt0iOSRS9kwREWkqPycHV0/r9gysoVyLiy33M606vTNlFpq272jQGKpTaWJXk66T2oYJFWnon4SK+dRzEwQBGXfv4LvP50AQHk/y0XvMRFjZ2QMA5HXqwMFV/8MCDMXCtB4++/NNmFu/wt4pIqr1BJVKL88cH9r6DRKOHdJDRNWv16gJsHZwrPZ2zepZwq5p82pv15CYUBkeEyrSSGkHFYf8PZ/se+nY8WkQcrMyAQCWdvawbdwUNo1d4N7nrSd6AmsXTkpBRC+LW5cuYM/iz1BUUKC3YzZt31F8TqYmaODcGO36vlNrP9NeNDLjkmtDxYTKYJhQkUYk/0wiwIRKN/k5OYj54VvcvXpFTKakMiP0GT8Jzm3cDRtcNZCWPjDL8d1EVEOlp1zHH7/tR3Hxs29a/05K1Gsy5fyaB/xmhTI5oQqVJttFRUoIgsBrxQCYUJFmxEeomFBpIyfjIbLvpeHS4d9xMfpXsfytyTPRvOPrMJabGDC66qNEEXY0PA+pVIaPivJhamRq6JCIiAAABbm5ePDXzUrrRW8KR3rKNY2OKZFI8a+FKyqdgVUTpnXNeYNMz1Q6KQUEAYJKBYlMs+VRSH+YUJFGJOA6VNrKzcrElmn/p7b4n/ub/eDYshVe7dz95fqAlElw3vJvAECxisP+iOjFIKhU2DlvFu7fStGovlQmQ+cP/CudYMe2SVPYNmmqhwiJKvfkbIPFRUpImVBVOyZUpJnHD1EZNo4a4I+o/Yj/bT8KchUozMuFsakZ6lpaoYFzE/QaNeGFmWa1OpnK6+Dd1FYAAGPJy3f+L4uEowdx9sf/QaVSVV75CVKpFJ7vvFdrZrWkF8OtS3/gyH83P3NtHpVKhYy//4JUZoR6lfUmSYDWPXzg9d5gPUdK9HzUE6oiGL8cg19eKLyzIc2I61AZOI4XUEGuAldOHEWxshCCAJz47r9Q5ueJ233GTkSr7m8YMELDMzUxQ/eHLgAAKTh1+oskX5GDpJPHUKyHhTBP7fkOedlZOu17bv8+JlQvuTtXEpB2/arejnch+lc8+OuWRnXd3+yHN0ZP0FvbRNVJKnt8O8+JKQyDCRVp5PHgtJc7oxIEocwK7Ee2b8LFg7+plVnZO+DNcZNgUqcObF2aVWeILyTpE9+eqYqLAOOaM1uVoRQXFUFVDcMjj2zfhEuHovR2vLpW9fHWpBl48l3jWR7cuYWDm8NRkKfQWwxUNYoKC6ts2HduZia++3xOyfuDHkllMgyYORdGz/jKXmZkBPvmrnptl6g6SSQSyIyMUFxUhKJn9MhS1WFCRZop7aFSvbwJlSAI+P7fIbh1Mb7c7U09O8HYxBRSqRRt3+yHRq+2rt4AX2ASmRQPjUueJVMqCyE3NTNwRC+2a3Gn8eOyL6t1TZFmHbxg9JyTpEgkErTu6aPVzJV1LC0BAIW5uZXUJEP6fdM6/PHbz1XeTj0bW72uwde0fUc0bffyLPBKLy+pkXHJF3HsoTIIJlSkkccTKLw8CdXNC/FIOBotThWvLCioMJlq5NYGfjNDXq6JJrRQUFyIL11LFqeckv8IdS0sDRxR9bt5MR4JR6I1WnrgTlJitSZTTq3bYsCMuQa5fuVmdQBAbfIWqljiiSO4ce5MtbYpCAKSYo5VeTtSmRF6jZqA5h28qrwtotpGZmQEJbi4r6EwoSKNSMRnqGpnQlVcVIS061cfvxEJAn5ZuxSKzIwydVv36I03xvyfWpmxiSmTqUrIVTIIqPq1qARBQPqNayh84jk2gxME/LJ2GRQZDzXeRSozwuhl61DHyqrq4vqHIa9fkzolCVXpUBWjWjIcNDcrEw/u3NbrMYsKC3Fg7TKDLZDt2LIVBs35rMqOL5UZ1Zr//kTVrXRiCq73aBhMqEgztXyWvyPbN+H8gR/LlJtZ1FOb0UlmLMernbtzyJqW6srr4qub76EwLw+mkqqdfujiwV8RtX5Nlbahq6evp2exa9ocVvYOVRyR4RmbPl6TrDAvF0bGNb/3UlmQj//MmlTuFzL6YN3QCW17+1bJsSsikUrRvKM33/uIXlClzypzyJ9h6JRQrV27FkuWLEFqairc3d2xevVqdOrUqcL6u3fvRkhICFJSUuDq6opFixbhrbfeErcLgoB58+Zhw4YNyMzMRJcuXbBu3Tq4uj5+SPThw4eYNGkSfvzxR0ilUgwaNAgrV66Eubm5WOfChQsICAjAmTNnYGNjg0mTJmHWrFm6nCI9pTYO+Dv1v11IOHoQgICs9HQAQH0HR0ikJes3SKVSdOg/kDOP6YnUyBhAHlRFmn+7npWeip9WLkaBIkfjfXIySm5iLRrYwNjkxVlAuHRq8DY9fQwdygtFKpXB2NQMyvw8FObmok69FzOhUmRm4MflYcjNyqy0blGhEorMDBibmOplYdcnyYyN0cN/DBq39dDrcYmoZivt3eWQP8PQOqHatWsXgoKCEB4eDi8vL6xYsQK+vr5ISkqCra1tmfonT57EsGHDEBYWhnfeeQcRERHw8/PDuXPn0KZNGwDA4sWLsWrVKmzbtg0uLi4ICQmBr68vEhISYPrPt5f+/v64e/cuoqKioFQqMXr0aIwfPx4REREAgOzsbPTp0wc+Pj4IDw/HxYsXMWbMGFhZWWH8+PHP8zcioNb0UOUrcpB47BAK8/MR832E2tAZG+cm+HDxag7dqyJPD0e4eTEe6TeuPXOfmxfjkZr8p9ZtmdY1x4hFq2H6xBcu9OIyqVMHyvw8FBjoOao7SYn4Oymh0jp3rjy7ztO8PxiOjv0HPk9oREQaKZ06nUP+Kpafk4OEY4e0WiYkR8MJk7ROqJYtW4Zx48Zh9OjRAIDw8HD8/PPP2Lx5M2bPnl2m/sqVK9G3b1/MnDkTALBgwQJERUVhzZo1CA8PhyAIWLFiBebOnYsBAwYAAP7zn//Azs4OkZGRGDp0KBITE3HgwAGcOXMGHTp0AACsXr0ab731Fr766is4Ojpix44dKCwsxObNmyGXy9G6dWvEx8dj2bJlTKj0oDTJUBYUoCC35k5vfGT7Zlw69HiKc1uXZug1quT6sHF2YTJVRQqKCrDDKhZK0zy8m/UQ0tsy/PBlKAQNF4D1+ehjvOLUWOP26ts7MpmqQUompngARcZDFNjZV2vbBbkKfL/g0zLLIVSk2/BRcGzpVmk9Y7kJbJs0fd7wiIg0IjMq6aHKV+TU6Pu0qnT4Pxtx+cjvWu2Tr+E09FolVIWFhYiLi0NwcLBYJpVK4ePjg5iYmHL3iYmJQVBQkFqZr68vIiMjAQA3btxAamoqfHweD4OxtLSEl5cXYmJiMHToUMTExMDKykpMpgDAx8cHUqkUsbGxeO+99xATE4Pu3btDLpertbNo0SJkZGSgfv36ZWIrKChAQUGB+Ht2drY2f46Xyz+JRsz3EYj5PsLAwTw/106dYVLXHO36vsObnmpQpCrCcbM/ATNgd9hcmAglbz1Wdg6V3pxaN3RCW59+THZrMZN/Zvrbs6jqJjyojPkrDeDcuu0z69SzsUWH/u9B+s+wYCKiF0XpKJAfl4UZOJIXn6tXZ40fCcjNywf2/FZpPa0Sqvv376O4uBh2dnZq5XZ2drhy5Uq5+6SmppZbPzU1VdxeWvasOk8PJzQyMoK1tbVaHRcXlzLHKN1WXkIVFhaGzz4z3Ad4TdL4NQ9cOX64VozNdWrdFv2DgnmDXo2MZcYYW38A7iQlQiZIAQBGxnL0/uhjNGnbzsDRkaE19eyEu9f+NNiQYpmREXp+OBYtvbsZpH0ioufl0r6DQd9Hawrn1zzQf5rm94DZ2dnAzE8rrfdSz/IXHBys1nuWnZ0NJycnA0b04nLr2hMtvbtBEDQbovUik8qMmExVM7lMjo2TI/9JyEve7CVSKb/pJwDA6wOHoOO7g2CoaW8kEimkMl6LRFRzeQ8ahk4DPkDtmj5M/0qHRuqbVglVgwYNIJPJkJaWplaelpYGe/vyx73b29s/s37pv2lpaXBwcFCr4+HhIdZJ/2cWtlJFRUV4+PCh2nHKa+fJNp5mYmICE5OqncK5Nim54eBNB+mudEgC0dN4bRARPR++jxqOVJvKcrkcnp6eiI6OFstUKhWio6Ph7e1d7j7e3t5q9QEgKipKrO/i4gJ7e3u1OtnZ2YiNjRXreHt7IzMzE3FxcWKdgwcPQqVSwcvLS6xz9OhRKJ94eCwqKgotW7Ysd7gfEVUfQRBwT3EP9xT3au3i0ERERPRy0iqhAoCgoCBs2LAB27ZtQ2JiIiZOnAiFQiHO+jdixAi1SSumTJmCAwcOYOnSpbhy5Qrmz5+Ps2fPIjAwEEDJ7HFTp07FF198gX379uHixYsYMWIEHB0d4efnBwBwc3ND3759MW7cOJw+fRonTpxAYGAghg4dCkdHRwDA8OHDIZfLMXbsWFy+fBm7du3CypUry0yIQUTVL1eZC9uvbGH7lS1ylYaZGpuIiIioKmjdNzhkyBDcu3cPoaGhSE1NhYeHBw4cOCBOAHHr1i1IpY/ztM6dOyMiIgJz587FnDlz4OrqisjISHENKgCYNWsWFAoFxo8fj8zMTHTt2hUHDhwQ16ACgB07diAwMBC9e/cWF/ZdtWqVuN3S0hK//fYbAgIC4OnpiQYNGiA0NFSrKdNLvznnbH9E+qUoVAD5Ja+zs7NRLNd8cV8iIiIiQyjNCSobXSMROP5GdP36dTRr1szQYRARERER0Qvi2rVraNq04mV2+PTaE6ytrQGU9LJZWlpWSRsdO3bEmTNnquTY1dkG29FN6UySt2/fRr169aq0LV5rbKc2tVObzoXtvNjt1KZzYTsvdju16Vxqazu///47nJ2dxRyhIkyonlA6VNHS0rLKbnZlMlmV30hXRxts5/nUq1evVlwHte2/Ddt5cdupTefCdl7sdmrTubCdF7ud2nQutbWd0g6WJx9nKo/Wk1LQ8wkICKgVbbCdFx+vNbZTm9qpTefCdl7sdmrTubCdF7ud2nQuL3s7fIbqCdnZ2bC0tERWVla19VTQy4XXGBEREVHNoOl9G3uonmBiYoJ58+ZxsV+qMrzGiIiIiGoGTe/b2ENFRERERESkI/ZQERERERER6YgJFRERERERkY6YUOlZWFgYOnbsCAsLC9ja2sLPzw9JSUni9pSUFEgkknJ/du/ebcDIiSq2du1aNGnSBKampvDy8sLp06fFbRMmTECzZs1gZmYGGxsbDBgwAFeuXDFgtETPdvToUfTv3x+Ojo6QSCSIjIxU2y4IAkJDQ+Hg4AAzMzP4+Pjg6tWrhgmWSAOVXdMV3XcsWbLEMAETPUNl99JPEgQB/fr1K/e6r05MqPTsyJEjCAgIwKlTpxAVFQWlUok+ffpAoVAAAJycnHD37l21n88++wzm5ubo16+fgaMnKmvXrl0ICgrCvHnzcO7cObi7u8PX1xfp6ekAAE9PT2zZsgWJiYn49ddfIQgC+vTpg+LiYgNHTlQ+hUIBd3d3rF27ttztixcvxqpVqxAeHo7Y2FjUrVsXvr6+yM/Pr+ZIiTRT2TX99H3H5s2bIZFIMGjQoGqOlKhyld1LP2nFihWQSCQGiFIdJ6WoYvfu3YOtrS2OHDmC7t27l1unXbt2aN++PTZt2lTN0RFVzsvLCx07dsSaNWsAACqVCk5OTpg0aRJmz55dpv6FCxfg7u6O5ORkNGvWrLrDJdKKRCLBnj174OfnB6Dk205HR0dMnz4dM2bMAABkZWXBzs4OW7duxdChQw0YLVHlnr6my+Pn54dHjx4hOjq6+gIj0lFF99Lx8fF45513cPbsWTg4OFR63Vcl9lBVsaysLACAtbV1udvj4uIQHx+PsWPHVmdYRBopLCxEXFwcfHx8xDKpVAofHx/ExMSUqa9QKLBlyxa4uLjAycmpOkMl0osbN24gNTVV7Zq3tLSEl5dXudc8UU2TlpaGn3/+mfcdVGOUdy+dm5uL4cOHY+3atbC3tzdUaCImVFVIpVJh6tSp6NKlC9q0aVNunU2bNsHNzQ2dO3eu5uiIKnf//n0UFxfDzs5OrdzOzg6pqani719//TXMzc1hbm6OX375BVFRUZDL5dUdLtFzK72uK7vmiWqqbdu2wcLCAgMHDjR0KESVquheetq0aejcuTMGDBhgwOgeY0JVhQICAnDp0iXs3Lmz3O15eXmIiIjgt0RU4/n7++P8+fM4cuQIWrRogcGDB/N5EyKiF9DmzZvh7+8PU1NTQ4dCVKny7qX37duHgwcPYsWKFYYL7ClMqKpIYGAgfvrpJxw6dAiNGjUqt87333+P3NxcjBgxopqjI9JMgwYNIJPJkJaWplaelpam1sVuaWkJV1dXdO/eHd9//z2uXLmCPXv2VHe4RM+t9Lqu7JonqomOHTuGpKQkfPTRR4YOhahSFd1LHzx4ENeuXYOVlRWMjIxgZGQEABg0aBB69uxpkFiZUOmZIAgIDAzEnj17cPDgQbi4uFRYd9OmTXj33XdhY2NTjRESaU4ul8PT01PtwWWVSoXo6Gh4e3uXu48gCBAEAQUFBdUVJpHeuLi4wN7eXu2az87ORmxsbIXXPFFNsWnTJnh6esLd3d3QoRBVqLJ76dmzZ+PChQuIj48XfwBg+fLl2LJliwEiBowM0motFhAQgIiICOzduxcWFhbimHtLS0uYmZmJ9ZKTk3H06FHs37/fUKESaSQoKAgjR45Ehw4d0KlTJ6xYsQIKhQKjR4/G9evXsWvXLvTp0wc2Njb466+/sHDhQpiZmeGtt94ydOhE5crJyUFycrL4+40bNxAfHw9ra2s4Oztj6tSp+OKLL+Dq6goXFxeEhITA0dHRYLNHEVWmsmsaKPliYPfu3Vi6dKmhwiTSSGX30vb29uWOGHB2dn5mR0aVEkivAJT7s2XLFrV6wcHBgpOTk1BcXGyYQIm0sHr1asHZ2VmQy+VCp06dhFOnTgmCIAh37twR+vXrJ9ja2grGxsZCo0aNhOHDhwtXrlwxcMREFTt06FC579MjR44UBEEQVCqVEBISItjZ2QkmJiZC7969haSkJMMGTfQMlV3TgiAI33zzjWBmZiZkZmYaLlAiDWh6L/30Pnv27Km2GJ/GdaiIiIiIiIh0xGeoiIiIiIiIdMSEioiIiIiISEdMqIiIiIiIiHTEhIqIiIiIiEhHTKiIiIiIiIh0xISKiIiIiIhIR0yoiIiIiIiIdMSEioiIiIiISEdMqIiIiIiIiHTEhIqIiIiIiEhHTKiIiIiIiIh0xISKiIiIiIhIR0yoiIiIiIiIdMSEioiIiIiISEdMqIiIiIiIiHTEhIqIiIiIiEhHTKiIiIiIiIh0xISKiIiIiIhIR0yoiIiIiIiIdMSEioiIiIiISEdMqIiIiIiIiHTEhIqIiIiIiEhHTKiIiIiIiIh0xISK6DmNGjUKEokECxcuVCuPjIyERCIxUFREREREVB2YUBHpgampKRYtWoSMjAxDh0JERERE1YgJFZEe+Pj4wN7eHmFhYRXW+eGHH9C6dWuYmJigSZMmWLp0qbhtzpw58PLyKrOPu7s7Pv/88yqJmYiIiIieHxMqIj2QyWT48ssvsXr1avz1119ltsfFxWHw4MEYOnQoLl68iPnz5yMkJARbt24FAPj7++P06dO4du2auM/ly5dx4cIFDB8+vLpOg4iIiIi0xISKSE/ee+89eHh4YN68eWW2LVu2DL1790ZISAhatGiBUaNGITAwEEuWLAEAtG7dGu7u7oiIiBD32bFjB7y8vNC8efNqOwciIiIi0g4TKiI9WrRoEbZt24bExES18sTERHTp0kWtrEuXLrh69SqKi4sBlPRSlSZUgiDg22+/hb+/f/UETkREREQ6YUJFpEfdu3eHr68vgoODtd532LBhSEpKwrlz53Dy5Encvn0bQ4YMqYIoiYiIiEhfjAwdAFFts3DhQnh4eKBly5ZimZubG06cOKFW78SJE2jRogVkMhkAoFGjRujRowd27NiBvLw8vPnmm7C1ta3W2ImIiIhIO0yoiPTstddeg7+/P1atWiWWTZ8+HR07dsSCBQswZMgQxMTEYM2aNfj666/V9vX398e8efNQWFiI5cuXV3foRERERKQliSAIgqGDIKrJRo0ahczMTERGRoplKSkpaNmyJQoLC1H6v9gPP/yA0NBQXL16FQ4ODpg0aRJmzJihdqzMzEzY29tDJpMhLS0N5ubm1XkqRERERKQlJlREREREREQ64qQUREREREREOmJCRUREREREpCMmVERERERERDpiQkVERERERKQjJlREREREREQ6YkJFpIWwsDB07NgRFhYWsLW1hZ+fH5KSktTq5OfnIyAgAK+88grMzc0xaNAgpKWlidv/+OMPDBs2DE5OTjAzM4ObmxtWrlypdozDhw9DIpGU+UlNTa2W8yQiIiIizTChItLCkSNHEBAQgFOnTiEqKgpKpRJ9+vSBQqEQ60ybNg0//vgjdu/ejSNHjuDvv//GwIEDxe1xcXGwtbXFf//7X1y+fBmffvopgoODsWbNmjLtJSUl4e7du+KPra1ttZwnEREREWmG61ARPYd79+7B1tYWR44cQffu3ZGVlQUbGxtERETg/fffBwBcuXIFbm5uiImJweuvv17ucQICApCYmIiDBw8CKOmh6tWrFzIyMmBlZVVdp0NEREREWmIPFdFzyMrKAgBYW1sDKOl9UiqV8PHxEeu8+uqrcHZ2RkxMzDOPU3qMJ3l4eMDBwQFvvvkmTpw4oefoiYiIiOh5GRk6AKKaSqVSYerUqejSpQvatGkDAEhNTYVcLi/Tq2RnZ1fh808nT57Erl278PPPP4tlDg4OCA8PR4cOHVBQUICNGzeiZ8+eiI2NRfv27avsnIiIiIhIO0yoiHQUEBCAS5cu4fjx4zof49KlSxgwYADmzZuHPn36iOUtW7ZEy5Ytxd87d+6Ma9euYfny5di+fftzxU1ERERE+sMhf0Q6CAwMxE8//YRDhw6hUaNGYrm9vT0KCwuRmZmpVj8tLQ329vZqZQkJCejduzfGjx+PuXPnVtpmp06dkJycrJf4iYiIiEg/mFARaUEQBAQGBmLPnj04ePAgXFxc1LZ7enrC2NgY0dHRYllSUhJu3boFb29vsezy5cvo1asXRo4ciX//+98atR0fHw8HBwf9nAgRERER6QWH/BFpISAgABEREdi7dy8sLCzE56IsLS1hZmYGS0tLjB07FkFBQbC2tka9evUwadIkeHt7izP8Xbp0CW+88QZ8fX0RFBQkHkMmk8HGxgYAsGLFCri4uKB169bIz8/Hxo0bcfDgQfz222+GOXEiIiIiKhenTSfSgkQiKbd8y5YtGDVqFICShX2nT5+Ob7/9FgUFBfD19cXXX38tDvmbP38+PvvsszLHaNy4MVJSUgAAixcvxvr163Hnzh3UqVMHbdu2RWhoKHr16lUl50VEREREumFCRUREREREpCM+Q0VERERERKQjJlREREREREQ6YkJFRERERESkIyZUREREREREOmJCRUREREREpCMmVERERERERDpiQkVERERERKQjJlREREREREQ6YkJFRES10qhRo+Dn5/dcxzh8+DAkEgkyMzP1EpMuUlJSIJFIEB8fb7AYiIioYkaGDoCIiKgqrFy5EoIgGDoMIiKq5ZhQERFRrVJcXAyJRAJLS0tDh0JERC8BDvkjIiKD6tmzJwIDAxEYGAhLS0s0aNAAISEhYu9SQUEBZsyYgYYNG6Ju3brw8vLC4cOHxf23bt0KKysr7Nu3D61atYKJiQlu3bpVZshfQUEBJk+eDFtbW5iamqJr1644c+aMWiz79+9HixYtYGZmhl69eiElJUWrczl+/Di6desGMzMzODk5YfLkyVAoFOL2Jk2a4Msvv8SYMWNgYWEBZ2dnrF+/Xu0Yp0+fRrt27WBqaooOHTrg/PnzWsVARETViwkVEREZ3LZt22BkZITTp09j5cqVWLZsGTZu3AgACAwMRExMDHbu3IkLFy7ggw8+QN++fXH16lVx/9zcXCxatAgbN27E5cuXYWtrW6aNWbNm4YcffsC2bdtw7tw5NG/eHL6+vnj48CEA4Pbt2xg4cCD69++P+Ph4fPTRR5g9e7bG53Dt2jX07dsXgwYNwoULF7Br1y4cP34cgYGBavWWLl0qJkoff/wxJk6ciKSkJABATk4O3nnnHbRq1QpxcXGYP38+ZsyYofXfk4iIqpFARERkQD169BDc3NwElUolln3yySeCm5ubcPPmTUEmkwl37txR26d3795CcHCwIAiCsGXLFgGAEB8fr1Zn5MiRwoABAwRBEIScnBzB2NhY2LFjh7i9sLBQcHR0FBYvXiwIgiAEBwcLrVq1UjvGJ598IgAQMjIyKj2PsWPHCuPHj1crO3bsmCCVSoW8vDxBEAShcePGwr/+9S9xu0qlEmxtbYV169YJgiAI33zzjfDKK6+I9QVBENatWycAEM6fP19pDEREVP34DBURERnc66+/DolEIv7u7e2NpUuX4uLFiyguLkaLFi3U6hcUFOCVV14Rf5fL5Wjbtm2Fx7927RqUSiW6dOkilhkbG6NTp05ITEwEACQmJsLLy0ttP29vb43P4Y8//sCFCxewY8cOsUwQBKhUKty4cQNubm4AoBanRCKBvb090tPTxRjatm0LU1NTnWIgIqLqx4SKiIheWDk5OZDJZIiLi4NMJlPbZm5uLr42MzNTS8gMIScnBxMmTMDkyZPLbHN2dhZfGxsbq22TSCRQqVRVHh8REVUNJlRERGRwsbGxar+fOnUKrq6uaNeuHYqLi5Geno5u3brpfPxmzZpBLpfjxIkTaNy4MQBAqVTizJkzmDp1KgDAzc0N+/btKxOHptq3b4+EhAQ0b95c5zjd3Nywfft25Ofni71U2sRARETVj5NSEBGRwd26dQtBQUFISkrCt99+i9WrV2PKlClo0aIF/P39MWLECPzvf//DjRs3cPr0aYSFheHnn3/W+Ph169bFxIkTMXPmTBw4cAAJCQkYN24ccnNzMXbsWADA//3f/+Hq1auYOXMmkpKSEBERga1bt2rcxieffIKTJ08iMDAQ8fHxuHr1Kvbu3VtmUopnGT58OCQSCcaNG4eEhATs378fX331lcb7ExFR9WNCRUREBjdixAjk5eWhU6dOCAgIwJQpUzB+/HgAwJYtWzBixAhMnz4dLVu2hJ+fH86cOaM2jE4TCxcuxKBBg/Dhhx+iffv2SE5Oxq+//or69esDKBmW98MPPyAyMhLu7u4IDw/Hl19+qfHx27ZtiyNHjuDPP/9Et27d0K5dO4SGhsLR0VHjY5ibm+PHH3/ExYsX0a5dO3z66adYtGiRVudJRETVSyIIXEaeiIgMp2fPnvDw8MCKFSsMHQoREZHW2ENFRERERESkIyZUREREGujXrx/Mzc3L/dFmaCAREdUuHPJHRESkgTt37iAvL6/cbdbW1rC2tq7miIiI6EXAhIqIiIiIiEhHHPJHRERERESkIyZUREREREREOmJCRUREREREpCMmVERERERERDpiQkVERERERKQjJlREREREREQ6YkJFRERERESkIyZUREREREREOvp/RlDsUMWE8tcAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 1000x1200 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ax = hist_soiling.plot(subplots=True, figsize=(10, 12))\n",
+    "ax[4].axhline(soiling_params[\"cleaning_threshold\"], color='red', linestyle='--', label='Cleaning Threshold')\n",
+    "for date in soiling_params[\"manual_wash_dates\"].strip(\"[]\").split(\",\"):\n",
+    "    ax[5].axvline(pd.to_datetime(date).tz_localize('UTC').tz_convert('Australia/Sydney'), color='green', linestyle=':', label='Manual Wash Date')\n",
+    "ax[4].legend()\n",
+    "ax[5].legend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d4853cab",
+   "metadata": {},
+   "source": [
+    "## Troubleshooting\n",
+    "- 401/403: Ensure API key is valid and access includes soiling endpoints.\n",
+    "- Empty payloads: Reduce `hours` or adjust `start`/`duration`.\n",
+    "- Parsing mismatch: Inspect `.to_dict()` from the SDK response and adjust normalization.\n",
+    "- Time zones: Use `.tz_convert()` after setting a UTC index.\n",
+    "\n",
+    "Tip: For larger periods, paginate historic queries (max 31 days per request) and concatenate the results in pandas."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "solcast",
+   "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.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/notebooks/1.5 Dust Soiling - Kimber (Live, Forecast, Historic).ipynb b/docs/notebooks/1.5 Dust Soiling - Kimber (Live, Forecast, Historic).ipynb
new file mode 100755
index 0000000..a81929f
--- /dev/null
+++ b/docs/notebooks/1.5 Dust Soiling - Kimber (Live, Forecast, Historic).ipynb	
@@ -0,0 +1,749 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "38f991ff",
+   "metadata": {},
+   "source": [
+    "## Introduction\n",
+    "\n",
+    "The following examples shows how to retrieve Kimber dust soiling loss using the Solcast Python SDK and visualize the data.\n",
+    "\n",
+    "- Live estimated actuals (near real-time and past 7 days)\n",
+    "- Forecast (near real-time and up to 7 days ahead)\n",
+    "- Historic (date-ranged queries; up to 31 days per request)\n",
+    "\n",
+    "All requests here use the SDK, returning convenient response objects that can be converted to pandas DataFrames."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "20bc8a2e",
+   "metadata": {},
+   "source": [
+    "## Model Background\n",
+    "\n",
+    "The Kimber model calculates the fraction of daily energy lost to soiling by assuming a linearly increasing soiling loss until a cleaning event resets the loss to zero. The cleaning event occurs whenever rainfall in a rolling 24-hour window exceeds a user-defined threshold or when manual wash dates are supplied. A grace period parameter allows for soiling to be 0 for some time after a cleaning event (presuming that soil is wet enough to prevent dust formation). Users of the Solcast soiling API can configure the soiling loss rate, rainfall cleaning threshold, and manual washing schedules. Solcast supplies the precipitation inputs so the model can be run without sourcing external environmental data. The output is a soiling loss fraction suitable for applying directly to PV forecasting or yield models. See [Kimber et al., 2006 (IEEE WCPEC)](http://dx.doi.org/10.1109/WCPEC.2006.279690) for the original model discussion."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7f4377a1",
+   "metadata": {},
+   "source": [
+    "## Prerequisites\n",
+    "\n",
+    "### Dependencies\n",
+    "- Solcast API key with access to soiling endpoints.\n",
+    "- Python with `solcast`, `pandas`, `matplotlib` installed.\n",
+    "- Set environment variable `SOLCAST_API_KEY`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "5c7c1166",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "from solcast import live as solcast_live\n",
+    "from solcast import forecast as solcast_forecast\n",
+    "from solcast import historic as solcast_historic\n",
+    "from solcast.unmetered_locations import UNMETERED_LOCATIONS"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7c250fc7",
+   "metadata": {},
+   "source": [
+    "### Configurations\n",
+    "Set API base and key. Default base: https://dev-api.solcast.com.au"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "0b97adfa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "API_BASE = os.environ.get(\"SOLCAST_API_BASE\", \"https://api.solcast.com.au\")\n",
+    "\n",
+    "API_KEY = os.environ.get(\"SOLCAST_API_KEY\", \"\")\n",
+    "\n",
+    "# Using unmetered location metadata to keep examples consistent without sharing site details\n",
+    "sydney = UNMETERED_LOCATIONS[\"Sydney Opera House\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "55872a09",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "## Live Estimated Actuals\n",
+    "\n",
+    "Endpoint: /data/live/soiling/kimber"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f5984878",
+   "metadata": {},
+   "source": [
+    "### SDK Parameters\n",
+    "\n",
+    "The following SDK function will be used:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "6d92e26d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Help on function soiling_kimber in module solcast.live:\n",
+      "\n",
+      "soiling_kimber(latitude: float, longitude: float, base_url='https://api.solcast.com.au', **kwargs) -> solcast.api.PandafiableResponse\n",
+      "    Get hourly soiling loss using the Kimber model.\n",
+      "\n",
+      "    Returns a time series of estimated cumulative soiling / cleanliness state for the\n",
+      "    requested location based on Pvlib's Kimber model.\n",
+      "\n",
+      "    Args:\n",
+      "        latitude: Decimal degrees, between -90 and 90 (north positive).\n",
+      "        longitude: Decimal degrees, between -180 and 180 (east positive).\n",
+      "        **kwargs: Additional query parameters accepted by the endpoint (e.g. depo_veloc_pm10, initial_soiling).\n",
+      "\n",
+      "    Returns:\n",
+      "        PandafiableResponse: Response object; call `.to_pandas()` for a DataFrame.\n",
+      "\n",
+      "    See https://docs.solcast.com.au/ for full parameter details.\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "help(solcast_live.soiling_kimber)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8bc6a76b",
+   "metadata": {},
+   "source": [
+    "### Accessing Additional Parameters\n",
+    "\n",
+    "For this example, we will provide additional parameters as specified by the Solcast API docs. Following is a brief summary:\n",
+    "\n",
+    "- latitude/longitude (EPSG:4326)\n",
+    "- period: PT5M | PT10M | PT15M | PT20M | PT30M | PT60M (default PT30M)\n",
+    "- cleaning_threshold: rainfall (mm) in a rolling 24h window to clean (default 1.0)\n",
+    "- soiling_loss_rate: Fraction of additional energy loss due to an additional day of soiling\n",
+    "- max_soiling: Maximum fraction of energy lost due to soiling. Soiling will build up until this value.\n",
+    "- initial_soiling: 0 to 1 (fraction at period start)\n",
+    "- manual_wash_dates: list of ISO dates when cleaning occurs\n",
+    "- time_zone: `utc` | `longitudinal` | `offset`\n",
+    "- format: `json` | `csv`\n",
+    "\n",
+    "Tip: Use the SDK’s `.to_pandas()` for quick plotting."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "da9292aa",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'latitude': -33.856784, 'longitude': 151.215297, 'period': 'PT30M', 'hours': 48, 'initial_soiling': 0.1, 'manual_wash_dates': '[2022-10-26,2025-11-14,2025-11-26]'}\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "status code=200, url=https://api.solcast.com.au/data/live/soiling/kimber?latitude=-33.856784&longitude=151.215297&format=json&period=PT30M&hours=48&initial_soiling=0.1&manual_wash_dates=%5B2022-10-26%2C2025-11-14%2C2025-11-26%5D, method=GET"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "kimber_live_params = {\n",
+    "    \"latitude\": sydney.get(\"latitude\"),\n",
+    "    \"longitude\": sydney.get(\"longitude\"),\n",
+    "    \"period\": \"PT30M\",\n",
+    "    \"hours\": 48,\n",
+    "    \"initial_soiling\": 0.1,\n",
+    "    \"manual_wash_dates\": \"[2022-10-26,2025-11-14,2025-11-26]\",\n",
+    "}\n",
+    "print(kimber_live_params)\n",
+    "\n",
+    "kl_resp = solcast_live.soiling_kimber(base_url=API_BASE, api_key=API_KEY, **kimber_live_params)\n",
+    "kl_resp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "3e3f76b8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>kimber_loss_fraction</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>period_end</th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 15:00:00+11:00</th>\n",
+       "      <td>0.1030</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 14:30:00+11:00</th>\n",
+       "      <td>0.1029</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 14:00:00+11:00</th>\n",
+       "      <td>0.1029</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 13:30:00+11:00</th>\n",
+       "      <td>0.1029</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 13:00:00+11:00</th>\n",
+       "      <td>0.1028</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 12:30:00+11:00</th>\n",
+       "      <td>0.1028</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 12:00:00+11:00</th>\n",
+       "      <td>0.1028</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 11:30:00+11:00</th>\n",
+       "      <td>0.1027</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 11:00:00+11:00</th>\n",
+       "      <td>0.1027</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 10:30:00+11:00</th>\n",
+       "      <td>0.1027</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                           kimber_loss_fraction\n",
+       "period_end                                     \n",
+       "2025-12-26 15:00:00+11:00                0.1030\n",
+       "2025-12-26 14:30:00+11:00                0.1029\n",
+       "2025-12-26 14:00:00+11:00                0.1029\n",
+       "2025-12-26 13:30:00+11:00                0.1029\n",
+       "2025-12-26 13:00:00+11:00                0.1028\n",
+       "2025-12-26 12:30:00+11:00                0.1028\n",
+       "2025-12-26 12:00:00+11:00                0.1028\n",
+       "2025-12-26 11:30:00+11:00                0.1027\n",
+       "2025-12-26 11:00:00+11:00                0.1027\n",
+       "2025-12-26 10:30:00+11:00                0.1027"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "kl_df = kl_resp.to_pandas()\n",
+    "kl_df.index = kl_df.index.tz_convert('Australia/Sydney')  # type: ignore\n",
+    "kl_df.head(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "746d31a9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: xlabel='period_end'>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "kl_df.plot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b7047435",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "## Forecast\n",
+    "Endpoint: /data/forecast/soiling/kimber"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "f14a503b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'latitude': -33.856784, 'longitude': 151.215297, 'hours': 120, 'period': 'PT30M', 'initial_soiling': 0.3, 'max_soiling': 0.4, 'manual_wash_dates': '[2022-10-26,2025-11-14,2025-11-26]', 'grace_period': 1, 'cleaning_threshold': 6.0}\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "status code=200, url=https://api.solcast.com.au/data/forecast/soiling/kimber?latitude=-33.856784&longitude=151.215297&format=json&hours=120&period=PT30M&initial_soiling=0.3&max_soiling=0.4&manual_wash_dates=%5B2022-10-26%2C2025-11-14%2C2025-11-26%5D&grace_period=1&cleaning_threshold=6.0, method=GET"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "kimber_fc_params = {\n",
+    "    \"latitude\": sydney.get(\"latitude\"),\n",
+    "    \"longitude\": sydney.get(\"longitude\"),\n",
+    "    \"hours\": 120,\n",
+    "    \"period\": \"PT30M\",\n",
+    "    \"initial_soiling\": 0.3,\n",
+    "    \"max_soiling\": 0.4,\n",
+    "    \"manual_wash_dates\": \"[2022-10-26,2025-11-14,2025-11-26]\",\n",
+    "    \"grace_period\": 1,\n",
+    "    \"cleaning_threshold\": 6.0,\n",
+    "}\n",
+    "print(kimber_fc_params)\n",
+    "\n",
+    "kf_resp = solcast_forecast.soiling_kimber(base_url=API_BASE, api_key=API_KEY, **kimber_fc_params)\n",
+    "kf_resp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "cdd2e05f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>kimber_loss_fraction</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>period_end</th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 15:30:00+11:00</th>\n",
+       "      <td>0.3000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 16:00:00+11:00</th>\n",
+       "      <td>0.3000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 16:30:00+11:00</th>\n",
+       "      <td>0.3001</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 17:00:00+11:00</th>\n",
+       "      <td>0.3001</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 17:30:00+11:00</th>\n",
+       "      <td>0.3001</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 18:00:00+11:00</th>\n",
+       "      <td>0.3002</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 18:30:00+11:00</th>\n",
+       "      <td>0.3002</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 19:00:00+11:00</th>\n",
+       "      <td>0.3002</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 19:30:00+11:00</th>\n",
+       "      <td>0.3002</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-12-26 20:00:00+11:00</th>\n",
+       "      <td>0.3003</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                           kimber_loss_fraction\n",
+       "period_end                                     \n",
+       "2025-12-26 15:30:00+11:00                0.3000\n",
+       "2025-12-26 16:00:00+11:00                0.3000\n",
+       "2025-12-26 16:30:00+11:00                0.3001\n",
+       "2025-12-26 17:00:00+11:00                0.3001\n",
+       "2025-12-26 17:30:00+11:00                0.3001\n",
+       "2025-12-26 18:00:00+11:00                0.3002\n",
+       "2025-12-26 18:30:00+11:00                0.3002\n",
+       "2025-12-26 19:00:00+11:00                0.3002\n",
+       "2025-12-26 19:30:00+11:00                0.3002\n",
+       "2025-12-26 20:00:00+11:00                0.3003"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "kf_df = kf_resp.to_pandas()\n",
+    "kf_df = kf_df.tz_convert(\"Australia/Sydney\")\n",
+    "kf_df.head(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "3c9a197a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: xlabel='period_end'>"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "kf_df.plot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0f05b0fd",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "## Historic\n",
+    "\n",
+    "Endpoint: /data/historic/soiling/kimber"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "8eeaafbb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'latitude': -33.856784, 'longitude': 151.215297, 'period': 'PT30M', 'start': '2025-10-25T14:45:00Z', 'duration': 'P30D', 'initial_soiling': 0.1, 'cleaning_threshold': 6.0, 'grace_period': 0, 'manual_wash_dates': '[2025-11-03]'}\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "status code=200, url=https://api.solcast.com.au/data/historic/soiling/kimber?latitude=-33.856784&longitude=151.215297&start=2025-10-25T14%3A45%3A00Z&format=json&period=PT30M&initial_soiling=0.1&cleaning_threshold=6.0&grace_period=0&manual_wash_dates=%5B2025-11-03%5D&duration=P30D, method=GET"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "kimber_hist_params = {\n",
+    "    \"latitude\": sydney.get(\"latitude\"),\n",
+    "    \"longitude\": sydney.get(\"longitude\"),\n",
+    "    \"period\": \"PT30M\",\n",
+    "    \"start\": \"2025-10-25T14:45:00Z\",\n",
+    "    \"duration\": \"P30D\",\n",
+    "    \"initial_soiling\": 0.1,\n",
+    "    \"cleaning_threshold\": 6.0,\n",
+    "    \"grace_period\": 0,\n",
+    "    \"manual_wash_dates\": \"[2025-11-03]\",\n",
+    "}\n",
+    "print(kimber_hist_params)\n",
+    "\n",
+    "kh_resp = solcast_historic.soiling_kimber(base_url=API_BASE, api_key=API_KEY, **kimber_hist_params)\n",
+    "kh_resp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "028f8834",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>kimber_loss_fraction</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>period_end</th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 02:00:00+11:00</th>\n",
+       "      <td>0.1000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 02:30:00+11:00</th>\n",
+       "      <td>0.1001</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 03:00:00+11:00</th>\n",
+       "      <td>0.1001</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 03:30:00+11:00</th>\n",
+       "      <td>0.1001</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 04:00:00+11:00</th>\n",
+       "      <td>0.1002</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 04:30:00+11:00</th>\n",
+       "      <td>0.1002</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 05:00:00+11:00</th>\n",
+       "      <td>0.1002</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 05:30:00+11:00</th>\n",
+       "      <td>0.1002</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 06:00:00+11:00</th>\n",
+       "      <td>0.1003</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2025-10-26 06:30:00+11:00</th>\n",
+       "      <td>0.1003</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                           kimber_loss_fraction\n",
+       "period_end                                     \n",
+       "2025-10-26 02:00:00+11:00                0.1000\n",
+       "2025-10-26 02:30:00+11:00                0.1001\n",
+       "2025-10-26 03:00:00+11:00                0.1001\n",
+       "2025-10-26 03:30:00+11:00                0.1001\n",
+       "2025-10-26 04:00:00+11:00                0.1002\n",
+       "2025-10-26 04:30:00+11:00                0.1002\n",
+       "2025-10-26 05:00:00+11:00                0.1002\n",
+       "2025-10-26 05:30:00+11:00                0.1002\n",
+       "2025-10-26 06:00:00+11:00                0.1003\n",
+       "2025-10-26 06:30:00+11:00                0.1003"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "kh_df = kh_resp.to_pandas()\n",
+    "kh_df = kh_df.tz_convert('Australia/Sydney')\n",
+    "kh_df.head(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "97efcdd2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: xlabel='period_end'>"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "kh_df.plot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "484e8244",
+   "metadata": {},
+   "source": [
+    "## Troubleshooting\n",
+    "- 401/403: Ensure API key is valid and access includes soiling endpoints.\n",
+    "- Empty payloads: Reduce `hours` or adjust `start`/`duration`.\n",
+    "- Parsing mismatch: Inspect `.to_dict()` from the SDK response and adjust DataFrame parsing.\n",
+    "\n",
+    "Tip: For larger historical ranges, paginate (max 31 days per request) and concatenate in pandas."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "solcast",
+   "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.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/notebooks/2.1 PVLib - ModelChain with Solcast weather data.ipynb b/docs/notebooks/2.1 PVLib - ModelChain with Solcast weather data.ipynb
index 5ad3700..0b9a0c8 100644
--- a/docs/notebooks/2.1 PVLib - ModelChain with Solcast weather data.ipynb	
+++ b/docs/notebooks/2.1 PVLib - ModelChain with Solcast weather data.ipynb	
@@ -8,16 +8,6 @@
     "Running PVLib's [ModelChain example](https://pvlib-python.readthedocs.io/en/stable/user_guide/modelchain.html) using Solcast API's data for the weather data. We will use one of the \"unmetered locations\" [available](https://docs.solcast.com.au/#unmetered-locations) from the Solcast API and the SDK: "
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "8a016ea9-5946-45c4-8b67-46405a3c4253",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#!pip install pvlib"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 2,
@@ -68,7 +58,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "id": "9d5255fd-7d1c-4294-bff6-4f7cb6b12d3c",
    "metadata": {},
    "outputs": [],
@@ -76,7 +66,7 @@
     "location = Location(latitude=lat, longitude=lon)\n",
     "\n",
     "system = PVSystem(\n",
-    "    surface_tilt=20, \n",
+    "    surface_tilt=20,\n",
     "    surface_azimuth=200,\n",
     "    module_parameters=sandia_module,\n",
     "    inverter_parameters=cec_inverter,\n",
@@ -130,13 +120,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "id": "16d4d452-cf64-4fae-a437-2b45bfb501f1",
    "metadata": {},
    "outputs": [],
    "source": [
     "solcast_resp = live.radiation_and_weather(\n",
-    "    latitude=lat, \n",
+    "    latitude=lat,\n",
     "    longitude=lon,\n",
     "    output_parameters=['ghi', 'dni', 'dhi', 'air_temp', 'wind_speed_10m'],\n",
     "    period='PT5M',\n",
diff --git a/docs/notebooks/2.3 Dust Soiling with Kimber.ipynb b/docs/notebooks/2.3 Dust Soiling with Kimber.ipynb
index 6949522..2d42715 100644
--- a/docs/notebooks/2.3 Dust Soiling with Kimber.ipynb	
+++ b/docs/notebooks/2.3 Dust Soiling with Kimber.ipynb	
@@ -17,16 +17,6 @@
     "First off, install `pvlib`."
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "8296e7de-cb04-4bc5-b788-01ab1b98cae7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#!pip install pvlib folium"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 2,
@@ -56,7 +46,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "386742a4-c8d2-42a3-ab9e-55bbd0aebef6",
    "metadata": {},
    "outputs": [
@@ -169,9 +159,9 @@
    "source": [
     "# Surfrad's Fort Peck\n",
     "latitude, longitude = 48.30783,\t-105.1017\n",
-    "start, end = \"2024-05-01T04:00:00\", \"2024-08-01T04:00:00\" \n",
+    "start, end = \"2024-05-01T04:00:00\", \"2024-08-01T04:00:00\"\n",
     "\n",
-    "map = folium.Map(location=[latitude, longitude], zoom_start=5) \n",
+    "map = folium.Map(location=[latitude, longitude], zoom_start=5)\n",
     "folium.Marker([latitude, longitude], popup=\"Fort Peck\").add_to(map)\n",
     "map"
    ]
@@ -186,7 +176,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "id": "b5666543-fdd3-4359-867c-4207c7283d81",
    "metadata": {},
    "outputs": [
@@ -260,9 +250,9 @@
    ],
    "source": [
     "rainfall_data = solcast.get_solcast_historic(\n",
-    "    latitude, longitude, \n",
-    "    start=start, end=end, \n",
-    "    api_key=os.getenv('SOLCAST_API_KEY'), \n",
+    "    latitude, longitude,\n",
+    "    start=start, end=end,\n",
+    "    api_key=os.getenv('SOLCAST_API_KEY'),\n",
     "    output_parameters=['precipitation_rate'],\n",
     "    period=\"PT1H\"\n",
     ")[0]\n",
@@ -295,16 +285,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "id": "71f018e5-2d7d-425b-b31b-fd3153d1db6e",
    "metadata": {},
    "outputs": [],
    "source": [
     "def plot(\n",
-    "    time_labels: pd.DatetimeIndex, \n",
-    "    precip_rate: pd.Series, \n",
-    "    precip_daily: pd.Series, \n",
-    "    soiling: pd.Series, \n",
+    "    time_labels: pd.DatetimeIndex,\n",
+    "    precip_rate: pd.Series,\n",
+    "    precip_daily: pd.Series,\n",
+    "    soiling: pd.Series,\n",
     "    threshold: int=15\n",
     "):\n",
     "    \"\"\"function that plots the precipitation accumulation alongside soiling rate.\n",
@@ -317,22 +307,22 @@
     "        threshold: amount of daily rainfall required to clean the panels.\n",
     "    \"\"\"\n",
     "    fig, ax1 = plt.subplots(figsize=(12,5))\n",
-    "    \n",
+    "\n",
     "    # line plot showing the soiling loss\n",
     "    ax1.plot(time_labels, soiling.values*100, linestyle=':', label='soiling loss', color='orange')\n",
     "    ax1.set_ylabel(\"energy loss fraction (%)\", color='orange')\n",
     "\n",
     "    # secondary axis for the rainfall\n",
     "    ax2 = ax1.twinx()\n",
-    "    \n",
+    "\n",
     "    # horizontal line for the threshold\n",
     "    ax2.hlines(y=threshold, xmin=time_labels.min(), xmax=time_labels.max(), linestyle='--', label='cleaning threshold')\n",
-    "    \n",
+    "\n",
     "    # bar plot of the daily sum of the rainfall\n",
     "    ax2.plot(time_labels, precip_daily, label=\"daily rain accumulation\", alpha=0.5)\n",
     "    ax2.plot(time_labels, precip_rate, label=\"precipitation rate\", color='blue', linewidth=0.5)\n",
     "    ax2.set_ylabel(\"precipitation (mm)\", color='blue')\n",
-    "    \n",
+    "\n",
     "    fig.legend()\n",
     "    fig.show()"
    ]
@@ -347,7 +337,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "id": "7bbfe97f-c17c-48ae-9e4f-9a62de0946ff",
    "metadata": {},
    "outputs": [
@@ -371,10 +361,10 @@
    ],
    "source": [
     "soiling = kimber(\n",
-    "    rainfall_data.precipitation_rate, \n",
-    "    cleaning_threshold=15.0, \n",
-    "    grace_period=3, # Number of days after a rainfall event \n",
-    "    # when it’s assumed the ground is damp, and so it’s assumed there is no soiling. \n",
+    "    rainfall_data.precipitation_rate,\n",
+    "    cleaning_threshold=15.0,\n",
+    "    grace_period=3, # Number of days after a rainfall event\n",
+    "    # when it’s assumed the ground is damp, and so it’s assumed there is no soiling.\n",
     "    soiling_loss_rate=0.0015 # Fraction of energy lost due to one day of soiling.\n",
     ")\n",
     "\n",
@@ -382,7 +372,7 @@
     "\n",
     "f = plot(df.index, df.precipitation_rate, df.accumulated_rainfall, df.soiling)\n",
     "\n",
-    "print(f\"average soiling loss: {df.soiling.mean()}\") "
+    "print(f\"average soiling loss: {df.soiling.mean()}\")"
    ]
   },
   {
@@ -395,7 +385,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "id": "b8ca7deb-4ea0-478b-9a63-08bf40a86a29",
    "metadata": {},
    "outputs": [
@@ -419,9 +409,9 @@
    ],
    "source": [
     "soiling = kimber(\n",
-    "    rainfall_data.precipitation_rate, \n",
-    "    cleaning_threshold=10.0, \n",
-    "    grace_period=3, \n",
+    "    rainfall_data.precipitation_rate,\n",
+    "    cleaning_threshold=10.0,\n",
+    "    grace_period=3,\n",
     "    soiling_loss_rate=0.0015\n",
     ")\n",
     "\n",
@@ -429,7 +419,7 @@
     "\n",
     "f = plot(df.index, df.precipitation_rate, df.accumulated_rainfall, df.soiling, threshold=10)\n",
     "\n",
-    "print(f\"average soiling loss: {df.soiling.mean()}\") "
+    "print(f\"average soiling loss: {df.soiling.mean()}\")"
    ]
   },
   {
@@ -442,7 +432,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "id": "42ebe363-2b45-41a1-87e2-99a64312a0ba",
    "metadata": {},
    "outputs": [
@@ -466,10 +456,10 @@
    ],
    "source": [
     "soiling = kimber(\n",
-    "    rainfall_data.precipitation_rate, \n",
+    "    rainfall_data.precipitation_rate,\n",
     "    cleaning_threshold=15.0,\n",
     "    grace_period=3,\n",
-    "    soiling_loss_rate=0.0015, \n",
+    "    soiling_loss_rate=0.0015,\n",
     "    manual_wash_dates=pd.date_range(\"2024-05-15T00:30:00\", end, freq=\"14D\")\n",
     ")\n",
     "\n",
@@ -477,7 +467,7 @@
     "\n",
     "plot(df.index, df.precipitation_rate, df.accumulated_rainfall, df.soiling)\n",
     "\n",
-    "print(f\"average soiling loss: {df.soiling.mean()}\") "
+    "print(f\"average soiling loss: {df.soiling.mean()}\")"
    ]
   },
   {
diff --git a/docs/notebooks/3.2 Comparing to Measurements [GHI] - Quality Controlling and Gap Filling Measurements with Solcast Actuals.ipynb b/docs/notebooks/3.2 Comparing to Measurements [GHI] - Quality Controlling and Gap Filling Measurements with Solcast Actuals.ipynb
index e1e9048..e3f4e9d 100644
--- a/docs/notebooks/3.2 Comparing to Measurements [GHI] - Quality Controlling and Gap Filling Measurements with Solcast Actuals.ipynb	
+++ b/docs/notebooks/3.2 Comparing to Measurements [GHI] - Quality Controlling and Gap Filling Measurements with Solcast Actuals.ipynb	
@@ -9,15 +9,6 @@
     "We will be using some external libraries for this task, in particular [Pvanalytics](https://pvanalytics.readthedocs.io/en/stable/), an industry standard when it comes to PV analytics, and [Plotly](https://plotly.com/python/), a common Python plotting library."
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# ! pip install plotly pvanalytics"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 2,
@@ -133,7 +124,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -232,7 +223,7 @@
     ")\n",
     "solcast = resp.to_pandas()\n",
     "# convert to UTC-7 to compare to measurements\n",
-    "solcast.index = solcast.index.tz_convert(\"-07:00:00\")  \n",
+    "solcast.index = solcast.index.tz_convert(\"-07:00:00\")\n",
     "\n",
     "solcast.head()"
    ]
@@ -386,7 +377,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -413,10 +404,10 @@
     "\n",
     "fig.add_trace(\n",
     "    go.Bar(\n",
-    "        x=df.index, \n",
-    "        y=df[\"missing_or_stale\"], \n",
-    "        name=\"missing or stale\", \n",
-    "        marker_line_width=1, \n",
+    "        x=df.index,\n",
+    "        y=df[\"missing_or_stale\"],\n",
+    "        name=\"missing or stale\",\n",
+    "        marker_line_width=1,\n",
     "        marker_color=\"green\",\n",
     "        marker_line_color=\"green\",\n",
     "        opacity=0.1\n",
@@ -439,18 +430,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# check we do not exceed clearsky irradiance during the day \n",
+    "# check we do not exceed clearsky irradiance during the day\n",
     "df[\"non_physical\"] = ~quality.irradiance.clearsky_limits(\n",
     "    df[\"ghi_QC\"], df[\"clearsky_ghi_solcast\"], csi_max=1.2\n",
     ") & (df[\"zenith_solcast\"] <= 88)\n",
     "\n",
     "# cloud enhancement can temporarily exceed clearsky limits (especially on a 5min scale)\n",
     "# so check that there is at least two contiguous timesteps\n",
-    "df[\"non_physical\"] = ( \n",
+    "df[\"non_physical\"] = (\n",
     "    (df[\"non_physical\"] & df[\"non_physical\"].shift(1))\n",
     "    | (df[\"non_physical\"] & df[\"non_physical\"].shift(-1))\n",
     ")\n",
@@ -473,7 +464,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -504,11 +495,11 @@
     "\n",
     "fig.add_trace(\n",
     "    go.Bar(\n",
-    "        x=df.index, \n",
-    "        y=df[\"non_physical\"], \n",
-    "        name=\"non-physical\", \n",
-    "        marker_line_width=1, \n",
-    "        opacity=0.3, \n",
+    "        x=df.index,\n",
+    "        y=df[\"non_physical\"],\n",
+    "        name=\"non-physical\",\n",
+    "        marker_line_width=1,\n",
+    "        opacity=0.3,\n",
     "        marker_color=\"green\",\n",
     "        marker_line_color=\"green\"\n",
     "    ),\n",
@@ -554,7 +545,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -582,11 +573,11 @@
     "\n",
     "fig.add_trace(\n",
     "    go.Bar(\n",
-    "        x=df.index, \n",
-    "        y=df[\"manual_bad_flag\"], \n",
-    "        name=\"manually flagged\", \n",
-    "        marker_line_width=1, \n",
-    "        opacity=0.3, \n",
+    "        x=df.index,\n",
+    "        y=df[\"manual_bad_flag\"],\n",
+    "        name=\"manually flagged\",\n",
+    "        marker_line_width=1,\n",
+    "        opacity=0.3,\n",
     "        marker_color=\"green\",\n",
     "        marker_line_color=\"green\"\n",
     "    ),\n",
@@ -609,7 +600,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -642,11 +633,11 @@
     "]:\n",
     "    fig.add_trace(\n",
     "        go.Bar(\n",
-    "            x=df.index, \n",
-    "            y=df[qc_col], \n",
-    "            name=qc_col, \n",
-    "            marker_line_width=1, \n",
-    "            opacity=0.3, \n",
+    "            x=df.index,\n",
+    "            y=df[qc_col],\n",
+    "            name=qc_col,\n",
+    "            marker_line_width=1,\n",
+    "            opacity=0.3,\n",
     "            marker_color=color,\n",
     "            marker_line_color=color,\n",
     "        ),\n",
diff --git a/docs/notebooks/3.4 Rooftop PV Tuning.ipynb b/docs/notebooks/3.4 Rooftop PV Tuning.ipynb
index 39163a3..89b174d 100644
--- a/docs/notebooks/3.4 Rooftop PV Tuning.ipynb	
+++ b/docs/notebooks/3.4 Rooftop PV Tuning.ipynb	
@@ -30,16 +30,6 @@
     "### 0: Imports and functions"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "bba9a869-8fbe-450e-8a16-9cff24613e73",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#!pip install solcast plotly kaleido"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 2,
diff --git a/docs/notebooks/3.4b Rooftop Shading Corrections.ipynb b/docs/notebooks/3.4b Rooftop Shading Corrections.ipynb
index 7b26426..71b4ac5 100755
--- a/docs/notebooks/3.4b Rooftop Shading Corrections.ipynb	
+++ b/docs/notebooks/3.4b Rooftop Shading Corrections.ipynb	
@@ -32,17 +32,6 @@
     "### Imports and Functions"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "34b33639-6902-47b3-86f9-cbb95c3f9e4d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# !pip install solcast plotly\n",
-    "# !pip install -U kaleido"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 2,
diff --git a/docs/overrides/main.html b/docs/overrides/main.html
new file mode 100644
index 0000000..702c96b
--- /dev/null
+++ b/docs/overrides/main.html
@@ -0,0 +1,11 @@
+{% extends "base.html" %}
+
+{% block content %}
+{% if page.nb_url %}
+    <a href="{{ page.nb_url }}" title="Download Notebook" class="md-content__button md-icon">
+        {% include ".icons/material/download.svg" %}
+    </a>
+{% endif %}
+
+{{ super() }}
+{% endblock content %}
diff --git a/mkdocs.yml b/mkdocs.yml
index f4c48ff..86a86f4 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -4,6 +4,7 @@ site_dir: public
 theme:
   name: material
   logo: 'img/logo.png'
+  custom_dir: docs/overrides
   palette:
     primary: black
     accent: yellow
@@ -21,7 +22,9 @@ nav:
         - '1.1 Getting Data: Historic Solar Radiation': 'notebooks/1.1 Getting Data - Historic Solar Radiation.ipynb'
         - '1.2 Getting Data: TMY in your local timezone': 'notebooks/1.2 Getting Data - TMY in your local timezone.ipynb'
         - '1.3 Getting Data: Make Concurrent Requests': 'notebooks/1.3 Getting Data - Make Concurrent Requests.ipynb'
-      - '2. PVLib': 
+        - '1.4 Dust Soiling: HSU (Live, Forecast, Historic)': "notebooks/1.4 Dust Soiling - HSU (Live, Forecast, Historic).ipynb"
+        - '1.5 Dust Soiling: Kimber (Live, Forecast, Historic)': "notebooks/1.5 Dust Soiling - Kimber (Live, Forecast, Historic).ipynb"
+      - '2. PVLib':
         - '2.1 ModelChain with Solcast weather data': 'notebooks/2.1 PVLib - ModelChain with Solcast weather data.ipynb'
         - '2.2 Using pvlib.iotools helper functions to get Solcast data': "notebooks/2.2 PVLib - Using pvlib.iotools helper functions to get Solcast data.ipynb"
         - '2.3 Using pvlib.soiling.kimber to model soiling losses': "notebooks/2.3 Dust Soiling with Kimber.ipynb"
@@ -45,6 +48,7 @@ nav:
   - API reference:
       - api/client.md
       - api/response.md
+      - api/pandafiableresponse.md
 markdown_extensions:
   - tables
   - pymdownx.highlight:
@@ -61,7 +65,9 @@ markdown_extensions:
 
 
 plugins:
-  - mkdocs-jupyter
+  - mkdocs-jupyter:
+      include_source: True
+      execute: False
   - mkdocstrings:
       enabled: !ENV [ ENABLE_MKDOCSTRINGS, true ]
       default_handler: python
diff --git a/pyproject.toml b/pyproject.toml
index da09372..ac88a37 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -19,15 +19,17 @@ classifiers = [
   "Topic :: Software Development",
   "Topic :: Scientific/Engineering",
   "Typing :: Typed",
-  "Development Status :: 4 - Beta",
+  "Development Status :: 5 - Production/Stable",
   "Intended Audience :: Developers",
   "License :: OSI Approved :: Apache Software License",
   "Programming Language :: Python :: 3 :: Only",
-  "Programming Language :: Python :: 3.7",
   "Programming Language :: Python :: 3.8",
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
 ]
 
 dynamic = ["version"]
@@ -38,7 +40,18 @@ Documentation = "https://solcast.github.io/solcast-api-python-sdk"
 Repository = "https://github.com/Solcast/solcast-api-python-sdk"
 
 [project.optional-dependencies]
-all = ["notebook", "matplotlib", "pandas"]
+all = [
+  "pandas",
+  "notebook",
+  "numpy",
+  "matplotlib",
+  "plotly",
+  "kaleido",
+  "folium",
+  "pvlib",
+  "pvanalytics",
+  "scipy"
+]
 
 [tool.hatch.version]
 path = "solcast/__init__.py"
@@ -63,4 +76,4 @@ docs = [
   "mkdocstrings[python]==0.26.1",
 ]
 lint = ["black>=24.8.0", "isort>=5.13.2"]
-test = ["pytest>=8.3.5"]
+test = ["pytest>=8.3.5", "pandas"]
diff --git a/solcast/api.py b/solcast/api.py
index ecaba75..99ed5e0 100644
--- a/solcast/api.py
+++ b/solcast/api.py
@@ -12,7 +12,20 @@
 
 @dataclass
 class Response:
-    """Class to handle API response from the Solcast API."""
+    """Class to handle any API response from the Solcast API.
+
+    Attributes:
+        code: HTTP status code of the response
+        url: The URL that was requested
+        data: Raw response data as bytes
+        success: Whether the request was successful
+        method: HTTP method used (GET, POST, etc.)
+        exception: Exception message if request failed
+
+    Examples:
+        >>> response = Response(code=200, url="...", data=b"...", success=True, method="GET")
+        >>> response.to_dict()
+    """
 
     code: int
     url: str
@@ -25,6 +38,7 @@ def __repr__(self):
         return f"status code={self.code}, url={self.url}, method={self.method}"
 
     def to_dict(self):
+        """Return the data as a dictionary."""
         if self.code not in [200, 204]:
             raise Exception(self.exception)
         if self.code == 204:
@@ -36,13 +50,23 @@ def __call__(self, *args, **kwargs) -> "Response":
 
 
 class PandafiableResponse(Response):
-    """Class to handle API response from the Solcast API, with pandas integration."""
+    """Class to handle API response from the Solcast API for timeseries data.
+
+    Attributes:
+        code: HTTP status code of the response
+        url: The URL that was requested
+        data: Raw response data as bytes
+        success: Whether the request was successful
+        method: HTTP method used (GET, POST, etc.)
+        exception: Exception message if request failed
+
+    Examples:
+        >>> response = Response(code=200, url="...", data=b"...", success=True, method="GET")
+        >>> response.to_pandas()
+    """
 
     def to_pandas(self):
-        """returns the data as a Pandas DataFrame.
-        Some common processing is applied,
-        like casting the datetime columns and setting them as index.
-        """
+        """Return the data as a Pandas DataFrame with a DatetimeIndex."""
         # not ideal to run this for every Response
 
         try:
diff --git a/solcast/forecast.py b/solcast/forecast.py
index 3081d1b..abdedb6 100644
--- a/solcast/forecast.py
+++ b/solcast/forecast.py
@@ -121,7 +121,7 @@ def soiling_kimber(
 
     See https://docs.solcast.com.au/ for full parameter details.
     """
-    url = kwargs.get("base_url", base_url)
+    url = kwargs.pop("base_url", base_url)
 
     client = Client(
         base_url=url,
@@ -158,7 +158,7 @@ def soiling_hsu(
 
     See https://docs.solcast.com.au/ for full parameter details.
     """
-    url = kwargs.get("base_url", base_url)
+    url = kwargs.pop("base_url", base_url)
     client = Client(
         base_url=url,
         endpoint=forecast_soiling_hsu,
diff --git a/solcast/historic.py b/solcast/historic.py
index adbc776..f8f549a 100644
--- a/solcast/historic.py
+++ b/solcast/historic.py
@@ -188,7 +188,7 @@ def soiling_kimber(
         duration is None and end is not None
     ), "only one of duration or end"
 
-    url = kwargs.get("base_url", base_url)
+    url = kwargs.pop("base_url", base_url)
     client = Client(
         base_url=url,
         endpoint=historic_soiling_kimber,
@@ -242,7 +242,7 @@ def soiling_hsu(
         duration is None and end is not None
     ), "only one of duration or end"
 
-    url = kwargs.get("base_url", base_url)
+    url = kwargs.pop("base_url", base_url)
     client = Client(
         base_url=url,
         endpoint=historic_soiling_hsu,
diff --git a/solcast/live.py b/solcast/live.py
index 15746d8..3cbb478 100644
--- a/solcast/live.py
+++ b/solcast/live.py
@@ -95,7 +95,7 @@ def soiling_hsu(
     latitude: float,
     longitude: float,
     **kwargs,
-):
+) -> PandafiableResponse:
     """Get hourly soiling loss using the HSU model.
 
     Returns a time series of estimated cumulative soiling / cleanliness state for the
@@ -113,7 +113,7 @@ def soiling_hsu(
     """
     from solcast.urls import live_soiling_hsu
 
-    url = kwargs.get("base_url", base_url)
+    url = kwargs.pop("base_url", base_url)
     client = Client(
         base_url=url,
         endpoint=live_soiling_hsu,
@@ -152,7 +152,7 @@ def soiling_kimber(
     """
     from solcast.urls import live_soiling_kimber
 
-    url = kwargs.get("base_url", base_url)
+    url = kwargs.pop("base_url", base_url)
     client = Client(
         base_url=url,
         endpoint=live_soiling_kimber,
diff --git a/tests/test_forecast.py b/tests/test_forecast.py
index 90ac179..aef1625 100644
--- a/tests/test_forecast.py
+++ b/tests/test_forecast.py
@@ -1,4 +1,5 @@
 import pandas as pd
+
 from solcast import forecast
 from solcast.unmetered_locations import (
     UNMETERED_LOCATIONS,
diff --git a/tests/test_historic.py b/tests/test_historic.py
index 618bcdf..63fa058 100644
--- a/tests/test_historic.py
+++ b/tests/test_historic.py
@@ -1,5 +1,4 @@
 import pandas as pd
-import pytest
 
 from solcast import historic
 from solcast.unmetered_locations import (
diff --git a/tests/test_live.py b/tests/test_live.py
index 1add13e..b713683 100644
--- a/tests/test_live.py
+++ b/tests/test_live.py
@@ -1,4 +1,5 @@
 import pandas as pd
+
 from solcast import live
 from solcast.unmetered_locations import (
     UNMETERED_LOCATIONS,