diff --git a/examples/tutorials/try_optuna.ipynb b/examples/tutorials/try_optuna.ipynb
new file mode 100644
index 000000000..a407204e7
--- /dev/null
+++ b/examples/tutorials/try_optuna.ipynb
@@ -0,0 +1,1159 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "c25b63fd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# --- Setup: Logging and Display Configuration ---\n",
+ "# Configure logging to see training progress and plotly to render as PNG for VS Code compatibility\n",
+ "import logging\n",
+ "import pandas as pd\n",
+ "import plotly.io as pio\n",
+ "\n",
+ "pd.options.plotting.backend = \"plotly\"\n",
+ "pio.renderers.default = \"png\" # Use PNG for VS Code notebook compatibility\n",
+ "\n",
+ "logging.basicConfig(level=logging.INFO, format=\"[%(asctime)s][%(levelname)s] %(message)s\")\n",
+ "logger = logging.getLogger(__name__)\n",
+ "logging.getLogger(\"choreographer\").setLevel(logging.ERROR)\n",
+ "logging.getLogger(\"kaleido\").setLevel(logging.ERROR)\n",
+ "logging.getLogger(\"choreographer\").disabled = True\n",
+ "logging.getLogger(\"kaleido\").disabled = True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "84299333",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/fleur.petit/projects/openstef/.venv/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning:\n",
+ "\n",
+ "IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+ "\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Downloading load_measurements/mv_feeder/OS Gorredijk.parquet...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/fleur.petit/projects/openstef/.venv/lib/python3.12/site-packages/huggingface_hub/utils/_validators.py:202: UserWarning:\n",
+ "\n",
+ "The `local_dir_use_symlinks` argument is deprecated and ignored in `hf_hub_download`. Downloading to a local directory does not use symlinks anymore.\n",
+ "\n",
+ "[2026-03-25 17:34:36,163][INFO] HTTP Request: HEAD https://huggingface.co/datasets/OpenSTEF/liander2024-energy-forecasting-benchmark/resolve/main/load_measurements/mv_feeder/OS%20Gorredijk.parquet \"HTTP/1.1 302 Found\"\n",
+ "[2026-03-25 17:34:36,294][INFO] HTTP Request: HEAD https://huggingface.co/datasets/OpenSTEF/liander2024-energy-forecasting-benchmark/resolve/main/weather_forecasts_versioned/mv_feeder/OS%20Gorredijk.parquet \"HTTP/1.1 302 Found\"\n",
+ "Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.\n",
+ "[2026-03-25 17:34:36,295][WARNING] Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "✓ load_measurements/mv_feeder/OS Gorredijk.parquet downloaded\n",
+ "Downloading weather_forecasts_versioned/mv_feeder/OS Gorredijk.parquet...\n",
+ "✓ weather_forecasts_versioned/mv_feeder/OS Gorredijk.parquet downloaded\n",
+ "Downloading EPEX.parquet...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "[2026-03-25 17:34:36,425][INFO] HTTP Request: HEAD https://huggingface.co/datasets/OpenSTEF/liander2024-energy-forecasting-benchmark/resolve/main/EPEX.parquet \"HTTP/1.1 302 Found\"\n",
+ "[2026-03-25 17:34:36,550][INFO] HTTP Request: HEAD https://huggingface.co/datasets/OpenSTEF/liander2024-energy-forecasting-benchmark/resolve/main/profiles.parquet \"HTTP/1.1 302 Found\"\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "✓ EPEX.parquet downloaded\n",
+ "Downloading profiles.parquet...\n",
+ "✓ profiles.parquet downloaded\n",
+ "\n",
+ "✅ All files downloaded successfully!\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Download dataset from HuggingFace Hub\n",
+ "# The dataset is stored as parquet files for efficient loading\n",
+ "from huggingface_hub import hf_hub_download # pyright: ignore[reportUnknownVariableType]\n",
+ "from openstef_core.base_model import Path\n",
+ "\n",
+ "repo_id = \"OpenSTEF/liander2024-energy-forecasting-benchmark\" # Public benchmark dataset\n",
+ "local_dir = Path(\"./liander_dataset\")\n",
+ "target = \"mv_feeder/OS Gorredijk\" # Specific installation to focus on\n",
+ "\n",
+ "# Download required files: load measurements, weather, prices, and profiles\n",
+ "files_to_download = [\n",
+ " f\"load_measurements/{target}.parquet\", # Energy consumption data\n",
+ " f\"weather_forecasts_versioned/{target}.parquet\", # Weather features\n",
+ " \"EPEX.parquet\", # Electricity prices (optional feature)\n",
+ " \"profiles.parquet\" # Standard load profiles (optional feature)\n",
+ "]\n",
+ "\n",
+ "for filename in files_to_download:\n",
+ " print(f\"Downloading {filename}...\")\n",
+ " hf_hub_download(repo_id=repo_id, filename=filename, repo_type=\"dataset\",\n",
+ " local_dir=local_dir, local_dir_use_symlinks=False) # pyright: ignore[reportCallIssue]\n",
+ " print(f\"✓ {filename} downloaded\")\n",
+ "\n",
+ "print(\"\\n✅ All files downloaded successfully!\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "524f65a1",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "[2026-03-25 17:34:38,354][WARNING] Parquet file does not contain 'sample_interval' attribute. Using default value of 15 minutes.\n",
+ "[2026-03-25 17:34:38,386][WARNING] Parquet file does not contain 'sample_interval' attribute. Using default value of 15 minutes.\n",
+ "[2026-03-25 17:34:38,413][WARNING] Parquet file does not contain 'sample_interval' attribute. Using default value of 15 minutes.\n",
+ "[2026-03-25 17:34:38,428][WARNING] Parquet file does not contain 'sample_interval' attribute. Using default value of 15 minutes.\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Dataset shape: (35136, 28)\n",
+ "Date range: 2024-01-01 00:00:00+00:00 to 2024-12-31 23:45:00+00:00\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.microsoft.datawrangler.viewer.v0+json": {
+ "columns": [
+ {
+ "name": "timestamp",
+ "rawType": "datetime64[ns, UTC]",
+ "type": "unknown"
+ },
+ {
+ "name": "load",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "temperature_2m",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "relative_humidity_2m",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "surface_pressure",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "cloud_cover",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "wind_speed_10m",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "wind_speed_80m",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "wind_direction_10m",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "shortwave_radiation",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "direct_radiation",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "diffuse_radiation",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "direct_normal_irradiance",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "EPEX_NL",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E1A_AZI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E1A_AMI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E1B_AZI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E1B_AMI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E1C_AZI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E1C_AMI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E2A_AZI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E2A_AMI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E2B_AZI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E2B_AMI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E3A_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E3B_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E3C_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E3D_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E4A_A",
+ "rawType": "float64",
+ "type": "float"
+ }
+ ],
+ "ref": "d3c6b0a3-a111-48be-861b-80ebd30875c9",
+ "rows": [
+ [
+ "2024-01-01 00:00:00+00:00",
+ "423333.3333333333",
+ "7.2435",
+ "85.02532",
+ "994.23645",
+ "100.0",
+ "28.185953",
+ "43.832863",
+ "204.92845",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.01",
+ "2.97e-05",
+ "4.031e-05",
+ "6.206e-05",
+ "7.815e-05",
+ "5.683e-05",
+ "6.431e-05",
+ "2.42e-05",
+ "3.404e-05",
+ "5.292e-05",
+ "6.425e-05",
+ "5.839e-05",
+ "5.839e-05",
+ "5.839e-05",
+ "5.839e-05",
+ "7.931e-05"
+ ],
+ [
+ "2024-01-01 00:15:00+00:00",
+ "436666.6666666666",
+ "7.281",
+ "84.80853",
+ "994.1865",
+ "100.0",
+ "28.75338",
+ "44.97622",
+ "206.93102",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.01",
+ "2.91e-05",
+ "3.866e-05",
+ "6.079e-05",
+ "7.537e-05",
+ "5.572e-05",
+ "6.058e-05",
+ "2.395e-05",
+ "3.352e-05",
+ "5.236e-05",
+ "6.326e-05",
+ "5.826e-05",
+ "5.826e-05",
+ "5.826e-05",
+ "5.826e-05",
+ "7.931e-05"
+ ],
+ [
+ "2024-01-01 00:30:00+00:00",
+ "410000.0",
+ "7.3185005",
+ "84.59174",
+ "994.1366",
+ "100.0",
+ "29.320807",
+ "46.11957",
+ "208.93356",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.01",
+ "2.794e-05",
+ "3.771e-05",
+ "5.799e-05",
+ "7.33e-05",
+ "5.451e-05",
+ "5.967e-05",
+ "2.338e-05",
+ "3.312e-05",
+ "5.113e-05",
+ "6.252e-05",
+ "5.782e-05",
+ "5.782e-05",
+ "5.782e-05",
+ "5.782e-05",
+ "7.931e-05"
+ ],
+ [
+ "2024-01-01 00:45:00+00:00",
+ "403333.3333333333",
+ "7.3560004",
+ "84.374954",
+ "994.08673",
+ "100.0",
+ "29.888233",
+ "47.262924",
+ "210.93613",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.01",
+ "2.712e-05",
+ "3.649e-05",
+ "5.659e-05",
+ "7.12e-05",
+ "5.211e-05",
+ "5.708e-05",
+ "2.325e-05",
+ "3.219e-05",
+ "5.083e-05",
+ "6.076e-05",
+ "5.89e-05",
+ "5.89e-05",
+ "5.89e-05",
+ "5.89e-05",
+ "7.931e-05"
+ ],
+ [
+ "2024-01-01 01:00:00+00:00",
+ "420000.0",
+ "7.3935003",
+ "84.158165",
+ "994.0368",
+ "100.0",
+ "30.45566",
+ "48.40628",
+ "212.93869",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.0",
+ "2.714e-05",
+ "3.44e-05",
+ "5.728e-05",
+ "6.668e-05",
+ "5.045e-05",
+ "5.493e-05",
+ "2.359e-05",
+ "3.198e-05",
+ "5.158e-05",
+ "6.036e-05",
+ "5.726e-05",
+ "5.726e-05",
+ "5.726e-05",
+ "5.726e-05",
+ "7.931e-05"
+ ]
+ ],
+ "shape": {
+ "columns": 28,
+ "rows": 5
+ }
+ },
+ "text/html": [
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " load | \n",
+ " temperature_2m | \n",
+ " relative_humidity_2m | \n",
+ " surface_pressure | \n",
+ " cloud_cover | \n",
+ " wind_speed_10m | \n",
+ " wind_speed_80m | \n",
+ " wind_direction_10m | \n",
+ " shortwave_radiation | \n",
+ " direct_radiation | \n",
+ " ... | \n",
+ " E1C_AMI_A | \n",
+ " E2A_AZI_A | \n",
+ " E2A_AMI_A | \n",
+ " E2B_AZI_A | \n",
+ " E2B_AMI_A | \n",
+ " E3A_A | \n",
+ " E3B_A | \n",
+ " E3C_A | \n",
+ " E3D_A | \n",
+ " E4A_A | \n",
+ "
\n",
+ " \n",
+ " | timestamp | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 2024-01-01 00:00:00+00:00 | \n",
+ " 423333.333333 | \n",
+ " 7.243500 | \n",
+ " 85.025322 | \n",
+ " 994.236450 | \n",
+ " 100.0 | \n",
+ " 28.185953 | \n",
+ " 43.832863 | \n",
+ " 204.928452 | \n",
+ " 0.0 | \n",
+ " 0.0 | \n",
+ " ... | \n",
+ " 0.000064 | \n",
+ " 0.000024 | \n",
+ " 0.000034 | \n",
+ " 0.000053 | \n",
+ " 0.000064 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000079 | \n",
+ "
\n",
+ " \n",
+ " | 2024-01-01 00:15:00+00:00 | \n",
+ " 436666.666667 | \n",
+ " 7.281000 | \n",
+ " 84.808533 | \n",
+ " 994.186523 | \n",
+ " 100.0 | \n",
+ " 28.753380 | \n",
+ " 44.976219 | \n",
+ " 206.931015 | \n",
+ " 0.0 | \n",
+ " 0.0 | \n",
+ " ... | \n",
+ " 0.000061 | \n",
+ " 0.000024 | \n",
+ " 0.000034 | \n",
+ " 0.000052 | \n",
+ " 0.000063 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000079 | \n",
+ "
\n",
+ " \n",
+ " | 2024-01-01 00:30:00+00:00 | \n",
+ " 410000.000000 | \n",
+ " 7.318501 | \n",
+ " 84.591743 | \n",
+ " 994.136597 | \n",
+ " 100.0 | \n",
+ " 29.320807 | \n",
+ " 46.119572 | \n",
+ " 208.933563 | \n",
+ " 0.0 | \n",
+ " 0.0 | \n",
+ " ... | \n",
+ " 0.000060 | \n",
+ " 0.000023 | \n",
+ " 0.000033 | \n",
+ " 0.000051 | \n",
+ " 0.000063 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000079 | \n",
+ "
\n",
+ " \n",
+ " | 2024-01-01 00:45:00+00:00 | \n",
+ " 403333.333333 | \n",
+ " 7.356000 | \n",
+ " 84.374954 | \n",
+ " 994.086731 | \n",
+ " 100.0 | \n",
+ " 29.888233 | \n",
+ " 47.262924 | \n",
+ " 210.936127 | \n",
+ " 0.0 | \n",
+ " 0.0 | \n",
+ " ... | \n",
+ " 0.000057 | \n",
+ " 0.000023 | \n",
+ " 0.000032 | \n",
+ " 0.000051 | \n",
+ " 0.000061 | \n",
+ " 0.000059 | \n",
+ " 0.000059 | \n",
+ " 0.000059 | \n",
+ " 0.000059 | \n",
+ " 0.000079 | \n",
+ "
\n",
+ " \n",
+ " | 2024-01-01 01:00:00+00:00 | \n",
+ " 420000.000000 | \n",
+ " 7.393500 | \n",
+ " 84.158165 | \n",
+ " 994.036804 | \n",
+ " 100.0 | \n",
+ " 30.455660 | \n",
+ " 48.406281 | \n",
+ " 212.938690 | \n",
+ " 0.0 | \n",
+ " 0.0 | \n",
+ " ... | \n",
+ " 0.000055 | \n",
+ " 0.000024 | \n",
+ " 0.000032 | \n",
+ " 0.000052 | \n",
+ " 0.000060 | \n",
+ " 0.000057 | \n",
+ " 0.000057 | \n",
+ " 0.000057 | \n",
+ " 0.000057 | \n",
+ " 0.000079 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
5 rows × 28 columns
\n",
+ "
"
+ ],
+ "text/plain": [
+ " load temperature_2m \\\n",
+ "timestamp \n",
+ "2024-01-01 00:00:00+00:00 423333.333333 7.243500 \n",
+ "2024-01-01 00:15:00+00:00 436666.666667 7.281000 \n",
+ "2024-01-01 00:30:00+00:00 410000.000000 7.318501 \n",
+ "2024-01-01 00:45:00+00:00 403333.333333 7.356000 \n",
+ "2024-01-01 01:00:00+00:00 420000.000000 7.393500 \n",
+ "\n",
+ " relative_humidity_2m surface_pressure \\\n",
+ "timestamp \n",
+ "2024-01-01 00:00:00+00:00 85.025322 994.236450 \n",
+ "2024-01-01 00:15:00+00:00 84.808533 994.186523 \n",
+ "2024-01-01 00:30:00+00:00 84.591743 994.136597 \n",
+ "2024-01-01 00:45:00+00:00 84.374954 994.086731 \n",
+ "2024-01-01 01:00:00+00:00 84.158165 994.036804 \n",
+ "\n",
+ " cloud_cover wind_speed_10m wind_speed_80m \\\n",
+ "timestamp \n",
+ "2024-01-01 00:00:00+00:00 100.0 28.185953 43.832863 \n",
+ "2024-01-01 00:15:00+00:00 100.0 28.753380 44.976219 \n",
+ "2024-01-01 00:30:00+00:00 100.0 29.320807 46.119572 \n",
+ "2024-01-01 00:45:00+00:00 100.0 29.888233 47.262924 \n",
+ "2024-01-01 01:00:00+00:00 100.0 30.455660 48.406281 \n",
+ "\n",
+ " wind_direction_10m shortwave_radiation \\\n",
+ "timestamp \n",
+ "2024-01-01 00:00:00+00:00 204.928452 0.0 \n",
+ "2024-01-01 00:15:00+00:00 206.931015 0.0 \n",
+ "2024-01-01 00:30:00+00:00 208.933563 0.0 \n",
+ "2024-01-01 00:45:00+00:00 210.936127 0.0 \n",
+ "2024-01-01 01:00:00+00:00 212.938690 0.0 \n",
+ "\n",
+ " direct_radiation ... E1C_AMI_A E2A_AZI_A \\\n",
+ "timestamp ... \n",
+ "2024-01-01 00:00:00+00:00 0.0 ... 0.000064 0.000024 \n",
+ "2024-01-01 00:15:00+00:00 0.0 ... 0.000061 0.000024 \n",
+ "2024-01-01 00:30:00+00:00 0.0 ... 0.000060 0.000023 \n",
+ "2024-01-01 00:45:00+00:00 0.0 ... 0.000057 0.000023 \n",
+ "2024-01-01 01:00:00+00:00 0.0 ... 0.000055 0.000024 \n",
+ "\n",
+ " E2A_AMI_A E2B_AZI_A E2B_AMI_A E3A_A \\\n",
+ "timestamp \n",
+ "2024-01-01 00:00:00+00:00 0.000034 0.000053 0.000064 0.000058 \n",
+ "2024-01-01 00:15:00+00:00 0.000034 0.000052 0.000063 0.000058 \n",
+ "2024-01-01 00:30:00+00:00 0.000033 0.000051 0.000063 0.000058 \n",
+ "2024-01-01 00:45:00+00:00 0.000032 0.000051 0.000061 0.000059 \n",
+ "2024-01-01 01:00:00+00:00 0.000032 0.000052 0.000060 0.000057 \n",
+ "\n",
+ " E3B_A E3C_A E3D_A E4A_A \n",
+ "timestamp \n",
+ "2024-01-01 00:00:00+00:00 0.000058 0.000058 0.000058 0.000079 \n",
+ "2024-01-01 00:15:00+00:00 0.000058 0.000058 0.000058 0.000079 \n",
+ "2024-01-01 00:30:00+00:00 0.000058 0.000058 0.000058 0.000079 \n",
+ "2024-01-01 00:45:00+00:00 0.000059 0.000059 0.000059 0.000079 \n",
+ "2024-01-01 01:00:00+00:00 0.000057 0.000057 0.000057 0.000079 \n",
+ "\n",
+ "[5 rows x 28 columns]"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Load datasets using OpenSTEF's VersionedTimeSeriesDataset\n",
+ "# This class handles versioned data where each value has an \"available_at\" timestamp\n",
+ "from openstef_core.datasets import VersionedTimeSeriesDataset\n",
+ "\n",
+ "# Load each data source from parquet files\n",
+ "load_dataset = VersionedTimeSeriesDataset.read_parquet(\n",
+ " local_dir / f\"load_measurements/{target}.parquet\"\n",
+ ")\n",
+ "weather_dataset = VersionedTimeSeriesDataset.read_parquet(\n",
+ " local_dir / f\"weather_forecasts_versioned/{target}.parquet\"\n",
+ ")\n",
+ "epex_dataset = VersionedTimeSeriesDataset.read_parquet(local_dir / \"EPEX.parquet\")\n",
+ "profiles_dataset = VersionedTimeSeriesDataset.read_parquet(local_dir / \"profiles.parquet\")\n",
+ "\n",
+ "# Combine all datasets using left join (keep all load timestamps, match features where available)\n",
+ "# select_version() materializes the lazy dataset into a concrete TimeSeriesDataset\n",
+ "dataset = VersionedTimeSeriesDataset.concat(\n",
+ " [load_dataset, weather_dataset, epex_dataset, profiles_dataset], \n",
+ " mode=\"left\" # Left join keeps all timestamps from the first dataset\n",
+ ").select_version()\n",
+ "\n",
+ "# Preview the combined dataset\n",
+ "print(f\"Dataset shape: {dataset.data.shape}\")\n",
+ "print(f\"Date range: {dataset.data.index.min()} to {dataset.data.index.max()}\")\n",
+ "dataset.data.head()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "2a64bbb5",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "📈 Training period: 2024-03-01 to 2024-05-30 (8640 samples)\n",
+ "🔮 Forecast period: 2024-05-30 to 2024-06-13 (1344 samples)\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Define training and forecast time periods\n",
+ "from datetime import datetime, timedelta\n",
+ "\n",
+ "# Training period: 90 days of historical data\n",
+ "train_start = datetime.fromisoformat(\"2024-03-01T00:00:00Z\")\n",
+ "train_end = train_start + timedelta(days=90)\n",
+ "\n",
+ "# Forecast period: 14 days after training (this is where we'll predict)\n",
+ "forecast_start = train_end\n",
+ "forecast_end = forecast_start + timedelta(days=14)\n",
+ "\n",
+ "# Split the dataset using time-based filtering\n",
+ "train_dataset = dataset.filter_by_range(start=train_start, end=train_end)\n",
+ "forecast_dataset = dataset.filter_by_range(start=forecast_start, end=forecast_end)\n",
+ "\n",
+ "print(f\"📈 Training period: {train_start.date()} to {train_end.date()} ({len(train_dataset.data)} samples)\")\n",
+ "print(f\"🔮 Forecast period: {forecast_start.date()} to {forecast_end.date()} ({len(forecast_dataset.data)} samples)\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "bfe2a41f",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAArwAAAH0CAYAAADfWf7fAAAQAElEQVR4AexdB4AbxdV+kq7f2adzxRUMoXdC751A6IFAQqgp9CQQSgLhpwVCCyXUQAIOECD0FrrB2PTeuw027u10vqbr/367mtNotSPNSrvSSvfsm52ZN2/ee/PNavfN7OxseID/MQKMACPACDACjAAjwAgwAmWMQJj4HyPACDACjAARMQiMACPACDAC5YoAO7zl2rPcLkaAEWAEGAFGgBFgBHJBoAzrsMNbhp3KTWIEGAFGgBFgBBgBRoARSCLADm8SC04xAoyAPgLMyQgwAowAI8AIlAwC7PCWTFexoYwAI8AIMAKMACMQPATYolJAgB3eUugltpERYAQYAUaAEWAEGAFGIGcE2OHNGTquyAjoI8CcjAAjwAgwAowAI1A8BNjhLR72rJkRYAQYAUaAERhqCHB7GYGiIMAOb1FgZ6WMACPACDACjAAjwAgwAoVCgB3eQiHNevQRYE5GgBFgBBgBRoARYAQ8RIAdXg/BZFGMACPACDACjICXCLAsRoAR8AYBdni9wZGlMAKMACPACDACjAAjwAgEFAF2eAPaMfpmMScjwAgwAowAI8AIMAKMQCYE2OHNhA6XMQKMACPACJQOAmwpI8AIMAIKBNjhVQDDZEaAEWAEGAFGgBFgBBiB8kBgqDm85dFr3ApGgBFgBBgBRoARYAQYAW0E2OHVhooZGQFGgBEoJwS4LYwAI8AIDB0E2OEdOn3NLWUEGAFGgBFgBBgBRmBIIpDR4R2SiHCjGQFGgBFgBBgBRoARYATKCgF2eMuqO7kxjAAj4BMCLJYRYAQYAUaghBFgh7eEO49NZwQYAUaAEWAEGAFGoLAIlKY2dnhLs9/YakaAEWAEGAFGgBFgBBgBTQTY4dUEitkYAUZAHwHmZAQYAUaAEWAEgoQAO7xB6g22hRFgBBgBRoARYATKCQFuS0AQYIc3IB3BZjACjAAjwAgwAowAI8AI+IMAO7z+4MpSGQF9BJiTEWAEGAFGgBFgBHxFgB1eX+Fl4YwAI8AIMAKMACOgiwDzMQJ+IcAOr1/IslxGgBFgBBgBRoARYAQYgUAgwA5vILqBjdBHgDkZAUaAEWAEGAFGgBFwhwA7vO7wYm5GgBFgBBgBRiAYCLAVjAAjoI0AO7zaUDEjI8AIMAKMACPACDACjEApIsAObyn2mr7NzMkIMAKMACPACDACjMCQR4Ad3iF/CjAAjAAjwAgMBQS4jYwAIzCUEWCHdyj3PredEWAEGAFGgBFgBBiBIYAAO7xSJ3OSEWAEGAFGgBFgBBgBRqD8EBiyDm9Xdw+1tXdSb1+f614dGBgw63bGu13X5QqMQKkh8MjTM+m/j71YamZ7Zi+uEbhWdBvXDM+EBl8QW8gIMAKMQFkhEBiHt7mlldbf+RitcM2tD+TdCX+59i7a6scn0uvvfOZa1vxFy8y6x/zur67relVhi71PSMEK+X1+cTZddM2d9PEX3+alBs7Ntbc9mJeMXCrPmrMgpU1O58O8hUtzEV1Sdc66+BYTh6C09bb/PEk33PFISWGYydgXX3nPxNfp/LLTZr75ET097U3z937Tvx/LJJbLGAFGgBFgBAKMQO4Or8eNqqqspAN/tH1KGDu6ydSy63abptDX+cFkk57PYa3VJ9KOW29MI6LDXIupqa4y62620Vqu63pd4YiDd6ef7r8Lbb3ZuhTv6jZn4g4/4UL69wPP5qzqyRfeIDg5OQvIseJA/4BZE/1uPxdEvq62xuQp50NvX7/ZvP4EHmaGD54hMHb0iJTrCc4tIRxpOYweGaXRo6Lm733ViWMFG8eMACPACDACJYZAYBze+roauuSPv0oJm2+0tgnnmScdnkLfe9etTHo+hyMP2ZNuvuw0Wn/t1VyLGTWi0ax79sk/y1gXSx8yMhiFOjwGm+PfCMNZP+e3v6DzTz+arr/kd/T8fX+j6//yW5P3ihvvpRdmvmumS+2wzQ/XT+lv+bxAm1XtyQdLlUwVvZC6VDbIdK/t8UKeFzLkNnqVxm9ePqeQxkAK5xbScsDgeuvN1jN/7wftvYPSBC5gBBgBRoARCDYCgXF43cB0ueHMnX7BTeb6W6wvPPeyf9Jvz/s7LV0eo8eefZWOPPVS2vVQw5nd+Rja62dnEh4Rfznr+xQVTzz3Gp34x2vo+wVLBulCLh6tQz6WCSCcd8Xt1NrWMcjX09Nr1r3lzscHabAD8j776juCHOjdYJdj6VdnXEnfzl04yCcSH38+m35z5lUEHjxGPf2CG007z/nrbYLFdRyJhGnX7Tejf151pln3d+ddTx2dcTONw5U33UeHHX8h7XDgqeYjXdh41S3/peXNK1Fshkuuu4u++GaumUZ7RMAyDhB1ZIAPAY+AUX/6ax8g62lwizf6FOeIaPsvTrmEXn37kxSbhMwFi5bR6+98Spf+/W46+Zxr6a33vzD5sIbzhtsfISwdQb8hBg/aCH4w/f1fD5nnhtNyhAeffNks++TLb8Gad8Aa8r/dcv+gPYf8+ny668HnyD4z7KbPcP6ecPbfzPMS5z7Oy6XLW1zZ+sCT083zDBjhHANG7R3WeYj1sKeee515rjs5xJf+/T8mRh2dXYM6cf4cd9rlBHsQUH/OvMWD5XiygT7AU4mW1na6476nCXaff9Udgzz5JD7/eo5p00uvvT8oRpwr6MuLr7nTvN7ANlyLOozf3KKlKwhpnG+gw54VsdbB+iKRrW2Cj2NGgBFgBEoEgcCaWZIO73sffUXPTn+LjjjpL/Tny/9Fjz7zCk2b+Z75Itmb731G7338FY0fO4r22nlLGtE0nP437Q2Cg7Nw8fLBjsANc8YbH5p1BFHI3f/oc0z5q08eZxY9/NQMusJwFs2MccAjZ9T97OvvjJz19933iwi0Q39zAd35wLNUV1tNeDQPR+iEs682nXOLk2jmmx/T4SdeZDpcW2yyDmHJBmiwc+abHwm2nONtNl+fxGzU519bziuEPf7cqzTbcL7X/sFkExvQ4BycZDj+cESQb1nZPugkL10eMwcRiPsSL/fpyIAchE8Nxw6YLJBwB92L4Abvdz78ktCnOEdWmzSOdthqQ3r/k6/NAQccDmGPkPmHi242Byr/efgFQvm8hUuor6+ffvmHK+nmOx8zl47stsNmNKy+jsCDNi4xsIKcCauMNs+DR59+BdnB0Gvgd90/HyTYsuaUiYP0XBM9vX2ENeS33/cUVVdV0n57bmsOyi674R4674p/pYjV7TM49jh/Zxrn50brrUGbb7y2ea7CgUsRmCGDJwsXXDWVFixeZtoUHd5gYnTob84nOOgVkQhVVlaav0n0gSxq3sKlBu/zBtZ95u8HZTg/Meh48/3PzX7DsoIXX33fdPKXLIuBhXoNLNAH9z46jfY98o90lTGIe3b624S1uiZDnodYS5vZpwsWLR+UJM4VDCDve+xFGhEdTjXVlYRr0bG/v5z2O+ocM43lE6gEe/75nyeRHAw6bRtk5gQjwAgwAoxAXgiUpMMrWtwZ7zIf4b/04LX09H+uoAmrjKJfHbEvvfXULXT3DefS1RecRPfedB5h6QFu2jM1nckTjtqf3nnmVvrvP86nZ+65wrj51hCc3j7D6RG6VTEcoRfuv5oeuf0v9Nx9V9FWm65LuJF/+uV3ZhXMEv7l2jvNNGyceu0fCcsRXnviRpo4brRJ9+Kw4TpTTDGYSTYTxuHWK8+g15+80ZwBBjbADM42Zqm+m7vI4CC64rwTaLMN1zLTD952IYkwecJYk6Yjw2Q0DnB28Ji4tqbKyOn/wWnAzJhTkActkJgN717D0bzo6n+DlR6fegnddf05dMvlf6An7/yrSYMTaiakwzffzjeXiTz9n8vpxQeuMQYkmxGcRgyk9tp5C/Nc+/vFvzXPj0v/9GupJtGPdtnSzP/38RcJTqmZMQ4491YYM3xHHrKH6aAapLz+HjMGeeg3rN9+6J8X02Xn/IYeveMS2sIYQAG/Dz+bNShfp8+AkzgvwY/fDZb84HzRPS9nfTefsHZ83TVXpafuvty0Cb+hX/5sH8IA895HXzBtOnTfncz4Edug4CljYIqCQ/fbGZH5u4HzCnmvPnaD8Xs+2Twf/3L2L83yqf992ozFYfHSZtp0wzXp39f9iWY+er1xDfizKPIt3mPHzWn6Q9eadj1775Xmbxj9ssNWG9HLD19n0lGOwe/015NPOnBNcNM23xrAghkBRoARGCIIlLTDC2dsV+MR/phRUZo8YQxVGTNdmJXFeuCFxqwiZlefeO41WrbCeiQ7V1q+oOpfrOU79biDSThpI40ZYswIgn9FLPnoH3mngLrjxowwizCbtcdOm5vpRUtWmPE3hlOAm92h++5Mm26wpknDobIiQliSgLQXYXLCQf3623mD4uA4hENhgmPy8usf0mPPvkKhcMgsh01mIsvBjQyshYTjIWabs4geLEYfrDpxFXIKEWOGcJDRSGTDGzPcs+YsMF/sw+xunzFoQQA+wP+r2fMIgxBD1ODfv/52pskPHjgq0caGwdnCM088PMVhxUz+YEUjgXMPLxKuMJzbGQbGBsn8w84XSPzkx5azh3Q+4bmX3zarn3zMgRRO9CHOWQzWUDBNWr+t02ezvltAwGmNVcfTdltsABFmwDkciYTNdLbDS69ZDt3xR+5HwxrqBtl/84v9zPRT09404y2NQSBwxSASA1EQsQzjof/NMAeXO2+zCUiDa9CPPXxvUx76DQG/eTB8bNuNBL9TDEQwMz0iOsw4f8aCzddw8rEHEl5sgxKct2gb0qcedxBhrT/SOCewLh1OP56WgPZCon9024Y6HBgBRqD8EOAWFQ6BcOFUeasJNxc4uHapcOawlnH3w/5gPpb+46W30r/ufcpk6zecHTPh8tBoPJZFFazdRewmNA5rMNlF3e++t9YerpfDy3KmIM0D1hCCdbVJqyAyA26yOx38W9r/mHPppD9dYy4HmTbzPbOsf2DAjLMdXjBu1PnKyKZjT2OQgNlvp4DBTab6dry/n7/EZL//8Zdoo92OSwnikboYEJmMxqG2tto4pv7BMcY5N27syNQCh5xwajHLi2IMJma++bExU7yp+RQCtHzDN8bACU6dcKqEvB+sNsFMfjfPmrFHRqfP5s63zsudt7WcTdRzG+DQoY6wAWmEhvpa0/n8/Os5yJoDu8MP2NVMT0ucfx98+o05o/vzg3ajysoKs0zIwxp8ue+23e9ks3z+oqVmLA51tbUiWbR4mNFWKLf/nurrLNs6EmuT3bYNMjkwAowAI8AI5I5AyTq8Tk3GWjs4c7ixHn3oXvSvv51FeMz4wK0XOLFr08IhaxZUu4LEGImk1u3qtj5W0dEZl7i8T8JBg9RN1v8BIvMlLLzEFu/qobNO/pnxuPdcwlKQP//+SLNc54AZ83xl6OjJh8eOd3tnpykOa1wvPONYcgqYwTWZMhzQXwi9fdk/VLL2GpPM2Xu8FIeXIsV63p8ftHsGDaoiZ3prW+egYyhzaPyKdgAAEABJREFUCGdRzFrr9tnKVuulzCmJdeuyTN10V5d1bjsNRLHOGHLEi2r77bkdsvTQUzPM+PFnXzVjbAlmJoxDe7vVd5jFd+q3M0443OAK1l9YMRtunyUvxbYFC2m2hhFgBBgBdwiUlcOLNZZo/q+P2Nd06rb+4XrmmjrMMIEehDBujDVDKGz1wybsSIEX5yAbWzAhnpFYv3z1BScTBgN4nI/ZUuwpjHKd4IUMHT1e8kwaP8YUN2ncaDpk350cQ53G3r5YXgFBWN+LOFsQM5j3Pz6dMNOLdbBbbbZetmra5T+YMoGwZrXL9vUvsXRGtFu3z3AuQLl45I602zBpgoU1lhPJdfuMJyvzFi4zZ3lDIWsAOG7MCHNv27c/+IJwvmJnB6wdlx1u8XQCgzanvttnt61kNSWVLue2lVRHsLGlhQBbywjkgUBZObzLEttrVSUeiQpcPk28MCbyxYzXXWtVUz2+8Ca2K+s1Zg2xzZF4zGky5HDA7BnetP/VH64wa1/1fyeaayKREY5MZWUEWTNAL2bDzYx0aIpayzDEW/CiyI0M1IETg10D3v3oK2SLEjDbCsVT73/WdBCRFgHrRnXf5N/GGDyhHtadAmek585fQg88MR3JtLDbDj80sccuCljPe5TxxEGstU1jzoEg9qjGGnW5+kP/e9nMbrTuGmas22errzre5H/y+ddT1jRjO7qlmtuSCZ3od1NY4jDtlffMnT9+uNHaCYoVHWoMQJD67Z//jogOP9Ba5mBmjMPGiacT+Mqb/AKgUWTKw+w10qUYyrltpdgfbDMjwAiUPwJl5fBuvJ51k7/jv88Q9pPF2t0Tzv4bnXHRzYHpycZh9fT7Xx9i3rD3PepP5vZKG+/2S3M9rVsjV8RazXZiGyjsTfqjn59Fx552GYH+x1N+TvIHOrbY2HI2zr/yDrrh9kfoxjseoUN/fT5hWy273g3XWd0knfWXW+jeR6cRPjO8cMkKciMDAqa/9oG5Lyxm8JDXDa+/+ylhP2KngLZlkJNW1NQ4jM757RGDeGNv4MeMx+do009+dR6dmnC20iraCD8/eHfCmlngteU+J5r7ru59xFnm1nI2VjOLF8jELC8I++6xDSJX4cqb7nXEAYOUYw77kSkLe83eNPVRcxu9C6/+t9mfePFs78Tsp26fYYeTvXbegvDi2nGnX2F+ae+8K26nPQ8/w8TOVJblsOPWGxG2M4PT/MdLb6WnX3zTlHPa+TeYNcULdWbGOGAnA8yuY40z4l2328ygJv/w8tyu221qbiH3k1+eZ273hxfb8NvG/r73PjYtyVxiqXJuW4l1BZvLCDACQwSBEnF4rceg2fpk7TUm0XmnHWXeoO95ZBpd/Y/7CWtZTz72ILNqKJSUI5LhcHYIwmGrXiicyhsOJfOhUIKHrNhUKB1kPVhygW2k8IIQbvT77bkt3fn3c8zlF/aXkCQRjkm0EzNqeOkHb8bjpR/sXoEvyckVfmLMpmF9JJwL7CULx6+mptrcjQB8CfORpJ8duBtBDmbG/3LtXabT0tHRSW5kQFA4ITQRgZQxCD48qodT6hSwjhZCQiEL55AG3lg7i9nuYQ21pqMPRxofKcBjdrwlD3kIoVAIkSHRis1M4gDHGdt/wYnFTiB4MQtrSy844xiTAwMZMyEdsKQGWWwd5lSOMqcQDlv6sd+sEwaYecfuIdj6bq3VJ9KNhsN7+gU3EV7Mw04Ft19zNlVErJl8N312/unHmNvo4WU+DAgwm40txbCjgpOddlooFKJbLjud4Dhj5hkDTcjBco77bjk/7YU9rDfGjhaQ85Mf7zi4MwryIlxpPKU45biDCAMufNDl/668nXDO41zf3ZhFB18oZOGFtB8hFLLkh0JWDB2hkJUOGWcL8iKEE3QRC3ookUgUmzmdtpmMfGAEckKAKzECjICMQNJjk6kBSWNP2E+nTzW3HJNNwt6ebz99i0waTMMhef3JmwgvqmGv1Rf+ezWddPQBBDlnnpR8yQVOMGhwkkVlldxzf3ekWR/rDsGL2TvUvfaiU5A1A2ZtQcPaSpOQOOy185ZmXft6Qzi5N176e3OfTji/qAdnVF7DmBDhGKH90CfCzEevN2XBVmxDZa8EB+iSP/7KfFHt/n9cQNMeuNrco/j804827dtl200Hq2DNM+S89vgNhL1ooWuN1SaYTpSuDAjD/sKwDw408tkCdIA/U4DzBDlu8A6FQuZs94sPXEPY7/jRO/5i7pH61lM30xknHAZxZlDJNAuNA9a5YkCF8wR71WLGcv7CZUYJkdPuDU8l9pX96X7WvrImo8YBznkmDHbaZmNTCpxdOL1iv1ec99hjWB40uen3xuH1BGcZLzM+/K+L6b3nbqPTj/+puRcxzi9TaZYDZFx9wcn05v9uNs9HyMKLoxsm9oW2VxeY44mEvQx5rDE/8agDCH2F/Wwfu+MSesP4fWOf3/0TL77V19WY5/DVF5yEKjkFnOOqNmLggv7AIFAIF3bjdytoiIEXeO2/47NO/plpI7a6Ax+CTtvAx4ERYAQYAUYgfwQC7fDm2rzhDXW03lqrEW46YrYsV1l+1Jv55kfGo+fnCR8HWLBomRn/4cKbTFX77La1Gft1gNOGF9lWGT2CsunADBxu0JiFlnndyJDrBSGNmVZ86QxOYSgk5t30LLvixnvppdfeJ3ytDuut739iujn7DccTM76yFMxS4wMQeDnQaQAi8+abRlugA+e9SpabPgMvBoJiZwWVzEx0DJpgE2Rl4tMtC4VC5n63cDAxu6tbrxT4QqHybVsp4M82MgKMwNBAoCwd3qB3HdZJXvr3/9DPT7qY9jj8DDPGCzh4sUk8pg16G4aiffiK2CnnXEf7JdZeX/i3qeYyFHxtzb7tFHZmAEZYToGYAyPACAQaATaOEWAEyhwBdniL0MH48thNfz2NsAcuHqnjETaWX5xtPPYsgjmsUhMBrI2Gc3vmiYfT/512FGFZw2NTLyHMZNpFrL/WFLr4rONo9x1SX8Sy83GeEWAEGAFGgBFgBPxHgB1eXYw95MNjdazDxNpWvDSF3RSw/MJDFSzKBwTg2B6w13aEHRIOO2BXwpv2WIfppGo3w9E9eJ8dyekjDE78TGMEGAFGgBFgBBgB/xBgh9c/bFkyI8AIMAJliQA3ihFgBBiBUkOAHd5S6zG2lxFgBBgBRoARYAQYAUbAFQI+ObyubGBmRoARYAQYAUaAEWAEGAFGwDcE2OH1DVoWzAgwAowAETEIjAAjwAgwAkVHgB3eoncBG8AIMAKMACPACDACjED5I1DMFrLDW0z0WTcjwAgwAowAI8AIMAKMgO8IsMPrO8SsgBFgBPQRYE5GgBFgBBgBRsB7BNjh9R5TlsgIMAKMACPACDACjEB+CHBtTxFgh9dTOFkYI8AIMAKMACPACDACjEDQEGCHN2g9wvYwAvoIMCcjwAgwAowAI8AIaCDADq8GSMzCCDACjAAjwAgwAkFGgG1jBDIjwA5vZny4lBFgBBgBRoARYAQYAUagxBFgh7fEO5DN10eAORkBRoARYAQYAUZgaCLADu/Q7HduNSPACDACjMDQRYBbzggMOQTY4R1yXc4NZgQYAUaAEWAEGAFGYGghwA7v0Opv/dYyJyPACDACjAAjwAgwAmWCADu8ZdKR3AxGgBFgBBgBfxBgqYwAI1D6CLDDW/p9yC1gBBgBRoARYAQYAUaAEciAADu8GcDRL2JORoARYAQYAUaAEWAEGIGgIsAOb1B7hu1iBBgBRqAUEWCbGQFGgBEIIALs8AawU9gkRoARYAQYAUaAEWAEGAHvECiGw+ud9SyJEWAEGAFGgBFgBBgBRoARyIIAO7xZAOJiRoARYAT8Q4AlMwKMACPACBQCAXZ4C4Ey62AEGAFGgBFgBBgBRoARUCPgcwk7vD4DzOIZAUaAEWAEGAFGgBFgBIqLADu8xcWftTMCjIA+AszJCDACjAAjwAjkhAA7vDnBxpUYAUaAEWAEGAFGgBEoFgKs1y0C7PC6RYz5GQFGgBFgBBgBRoARYARKCgF2eEuqu9hYRkAfAeZkBBgBRoARYAQYAQsBdngtHPjICDACjAAjwAgwAuWJALeKESB2ePkkYAQYAUaAEWAEGAFGgBEoawTY4S3r7uXGaSPAjIwAI8AIMAKMACNQtgiww1u2XcsNYwQYAUaAEWAE3CPANRiBckSAHd5y7FVuEyPACDACjAAjwAgwAozAIALs8A5CwQl9BJiTEWAEGAFGgBFgBBiB0kGAHd7S6Su2lBFgBBgBRiBoCLA9jAAjUBIIsMNbEt3ERjICjAAjwAgwAowAI8AI5IoAO7y5IqdfjzkZAUaAEWAEGAFGgBFgBIqIADu8RQSfVTMCjAAjMLQQ4NYyAowAI1AcBNjhLQ7urJURYAQYAUaAEWAEGAFGoEAIBM7hLVC7WQ0jwAgwAowAI8AIMAKMwBBBgB3eIdLR3ExGgBEoOQTYYEaAEWAEGAGPEGCH1yMgWQwjwAgwAowAI8AIMAKMgB8I5C+THd78MWQJjAAjwAgwAowAI8AIMAIBRoAd3gB3DpvGCDAC+ggwJyPACDACjAAjoEKAHV4VMpr0Bcs7qZxCX/8ALWqOl1WbCt0/C1d00sAAMYZ5/jaWtXRRd28/45gnjrH2HuqI9zKOeeLYbmDYYmBZ6OtJuenr7umnZSu7hvT5qOle5MPGdR0QYIfXARQmMQKMACPACDACjAAjwAiUDwLs8JZPX3JLGAF9BJiTEWAEGAFGgBEYQgiwwzuEOpubyggwAowAI8AIMAKpCHBuaCDADu/Q6GduJSPACDACjAAjwAgwAkMWAXZ4h2zXc8P1EWBORoARYAQYAUaAEShlBNjhLeXeY9sZAUaAEWAEGIFCIsC6GIESRYAd3hLtODabEWAEGAFGgBFgBBiBfBF4dvrb9Po7n2qLuffRaXT6BTdm5D//qjvo1rufyMhT6EJ2eAuNePnr4xYyAowAI8AIMAKMQIkgcPmN99DdDz+vbe3Cxcvp0y+/y8j/1ex59P2CpRl5Cl3IDm+hEWd9jAAjwAgwAkMEAW4mIxB8BB694xK64s8nBN/QPC1khzdPALk6I8AIMAKMACPACDACfiHQ0dlFR556KT3w5PQUFXPmLaZfnHIJvfvRV7Ro6Qo65veX0Q4Hnkrr73wM7XroaXTtbQ9ST2/fYJ3zrridbr/vKZr55kd01sW3mPwtre10za0P0D2PvDDId/oFN9FePzvTlAN5f7z0Vlq8tHmwHImOzjhNvf8Z2v/oc0y+U8+9jpY3r0SRY2ht66BLrrvLtAv2HXfa5fTFN3Mdef0issPrF7KacpmNEWAEGAFGgBFgBBgBFQJ1tdXUFG2gm//9GPX3DwyyPfL0TPpy1ve03lqrUXd3D42IDqNTjj2Irr3oFDpk353ptv88SVP/+/Qg/+dfz6G/3XI/nXD21dRuOKzDh9URGeLgeM6dv2SQr7evlw47YPks27YAABAASURBVBe65sJTTHmvvvUxnXv5PwfLkVgRa6X7H3+J9ttzWzO8+Or79CfDMUaZPfT19dOv/nAlzXjjIzr6pz+iy875DbV3xE0nHo6wnd+vPDu8fiHLchkBRoARYATcIMC8jAAjoEDgsP13NWdZ3/7wC5MDM7cP/e9lOnTfnai2poomTxhLV19wsuGo7krbbr4B7W84optusKYx+/ulyS8OG623Bs189Hq68dLf098v/i01Dq8XRYMx6Mcdvg/ttM3GtNO2mxiytjNfaoPjKpjgXD92xyX06yP2NR3Yk44+gF59+xNauGSFYBmMZ7z5IX3y5bd0xXkn0NGH7mU6yBef/UvCLPGb738+yOd3gh1evxFm+YwAI8AIMAKMACPACOSBwNabrUdjRzfRw0/NMKVg1hWzrD8xHF4Qevv66OY7HzOXDGy5zwnmkoT3P/namEntQvFgWOcHk82Z4EGCQ+LZ6W/RQcf9mTbb89e026GnE5YugK2/vx+RGepqa6iyssJM4wBHGjFeaEMshy+/+d7MXnzNnXTIr883w9l/ucWkLVi0zIwLcSgth7cQiLAORoARYAQYAUaAEWAEAoRAJBKmnx+0Oz35/OsUa2kjzO5utuFatMaq400rb5r6KN1w+yN0xMF70CO3/4Vef/ImcybVLHRxwCzt6RfcZC6TuPem88zZ4AvOOCarhP7EUotQKJ013tVtEn/3q5+QCKcf/1O65fLTaedtNzXLCnFgh7cQKHugY+XKEL30cpiWLnM4mxzkf/1NiP7vogqa+Sp3sQM8TGIESh4BbgAjwAgMLQT233M7s8F48QxrZn9+0G5mHodX3/qEtttiA/rlz/ahtVafSMMb6ijs5H2COUN4+wNrycQFZxxLmLXF0oWKSCRDDavozfc+MxOrTlzFjOXDlMnjzOy4MSNph602SgmTxo82ywpxYG+oECh7oOPd98h0eN95T8/hffNti2/Zciv2wAQWwQgwAowAI8AIMAJFQmDMqCjttfMW9K97nyIsKdh1+80GLdly03Xp/U++oWkz36MPP5tF19/+MD327KuD5boJrPsF738eet5cd4sX067+x/0gpQQsp5j55sf07dyF9M97/kcPPPky/Xi3rR2XS+y+ww/N5Ri/Pe/v9PLrHxJ2l0B8+gU30vTXP0iRm2NGqxo7vFowBYApMVKLx/Uc2O5uPb4AtIxNYAQYAUaAEWAEGAENBA7dd2eTC7O71VWVZhqHww/clbA+F07lz0+6mF5751PaYO0phKUQKEeIhLO7fNttuYHpuF5583102PEXmo7zJuv/ANUHQygUMl84g8O671F/ImxrtvnGa9O5vztykEdO1NfV0D//dhatMnoEnfSna2ifX5xtxtgZYvzYUTKrr+nsrfdVPQtnBBgBRqAACLAKRoARYATKAIFtNl+fPp0+lU77zaEprZmwyii66/pz6IX//o1efOAawvrb//7jfJp67R8H+ZA///SjB/MiAd6LzzrOzGL5AnZTeO3xG+np/1xO0x+6jq6/5HemTvGSGnTDhtcev4GeuvtymvHI3+nmy05L2fFBlgnBq08eR7dfcza9++yt9Oy9V9JbT91CD952Ia29xiQUFySww1sQmPNXEmvhGdv8UWQJjAAjwAgwAoxA+SIwbuxIc/lAphbqlGG7Mmx1Js8Q2+vBAV514lga2TTcXqTM11RX0cRxowmzvkomnwrY4fUJWBbLCDACjAAjwAgwAowAIxAMBNjhDUY/sBWMQIAQYFMYAUaAEWAEGIHyQoAd3vLqz7TWNDenkZjACDACjAAjwAgwAjoIME/ZIMAOb9l0JTeEEWAEGAFGgBFgBBgBRsAJAXZ4nVAJME13xrYYL7l99XWIbrg5QosXB/e06uwM0c23Rujt9zyzMcBnC5vGCDACjAAjwAgwAkCA7/pAgYMnCHz6eZiWLA3R7O88EeeLkMWLB2jhohB9/DHveuELwCyUEWAEhjAC3HRGILgIsMMb3L7xxLK2Nu8du55eohdfDtPcuc6y43FPTPdFSLyLT3lfgGWhjAAjwAgwAoxAgBHgu3+AO8fJNPtSBTiXL0wL07dznJ3P3j4nKfnRvvgyTNMNh3fGK846naQLO5zKCkkDXm71dXXpt9OtbOZnBBgBRoARYARKFYFv5y6kN9//3HPzv/52Hr338VeeymWH11M4Cy/s61khmvFqmD75tHBOWZ8xw4uWfvWN8+nTZ3OyZ80O0UWXVBCcZNQrpfDyzBBdcnmEXn+jcPiq8BkYIFqypPh2qOxjOiPACLhCgJkZgZJHYOabH9E/7nzc83Y8P+Ndmnr/M57KdfZYPFXBwtwg0N5BdPvUCH32hZ5j09dr8S1dasVudPnFO/f7VFtaW618cwl+La6j07I9HoBZ3meeD9MNt0To4wIObvw6R1guI8AIMAKMACNQSATY4fUQ7bb2EL31dph6eoypuBzlfv11mL6bG6L/PR0hciGjtsYFc56snS7X6DbHLIW6O0xY3P4e7UtDVNriccvhVZUXki5sWbYsODYVsv2sixFgBBgBRiDYCLz02vu0/9Hn0Po7H0NHnnopfTV73qDBZ1/yD9rhwFPNMvA8O/3twbIOw7G44KqptMXeJ5g8jz3zymCZVwl2eL1C0pDz9jshevLpML32esTI5ffX2uqu/opmZ/7OeKrz/cVXYTr/4gp6973cbYxncXh1nUlni5na00M0fUaYli3Xc2xnzAyZfbp8hR4/I8wIlCICbDMjwAgQLV9B9OXXAwUPy5ZnR/+bb+fTKedcR7tuvxnddf05NHpkI/3y9Mupo7PLrLzRuqvTVeefRI/dcQntv9d2dPoFN1LLynaz7Mqb/0sz3vyQ/njKz+mGS39Pq6863qR7eQh7KWyoyxKOXn+qj5kzLM2JmVEdAV3dzs5Ol22GcuFCInMt6DKPjNQxrgx5MAs/bXqEsGOF1837/IsQvTg9TB99ovfzXN4cNvv0e9tSEq/tYnmMACPACDACxUXg9Xf66cobegseZr5heznHAYanXnyDJo4bTb//9SG02YZr0bm/O5JWxFrpzfc/M7kPP2A3GlZfSx99Pot6E2+yf79wifFUvJfuf/wlOuXYg+gnP96RNl5vDdrQcI7NSh4e9O6oHir0T9TQkByLpbbTjVMs14zbHGG5zE06nmW2142sbLxd3URYNpKNL9fy5mbnQQPkxa0BKpJm+OjjEL08I0RffqmuYzLmcGjvsGQuXqQ3KIl35qCEqzACjAAjwAiUHAIjm4jW/kGo4GHUCOu+lAmwBYuX06YbrjnIMrJpOI0d3USLlqyg9o44HfP7y+jo311mOMCfUxw3dIOzv6+fFi01pq2N9CYbJOsaWc//2OH1HFJvBIaMc2v4sKSs5uZkOp+U3XHLRxbqdhbQ4f3XHRG68uoI+eFkf/xJiK65PkL2nSQE7nHbAGFFwjnuTbw0CCwQXn4lTI88rv+zWrwkRK22vZLjCUw7bTohH0E8SUAaoTPBjzQHRsBEgA+MACNQlghss0WYzjy1ouBhh22y39dGRofTl9/MHcQdTu7ipc00IjqM3nj3M3ObsRfu/xtdfu7x5iywYFxlzEgzudhwjM2ET4fsLfBJcTmK9WKnBOG8YNnBSsU6XuEQ5YJhXOFE5SKr0HXiXSHz0b3AyEv9yxLrZdPmVAeMkYeDohWK9bLvvhem994P07IVaZLSpCxbRnTjLRF64klnHXGXjuzKlWkqmMAIMAKMACPACBQEge233NB8Se3Z6W8ZEzkdNPW/T5t6sbyhvs56sx6zvVi3e88j08wyHCorIrTbDpvR3Q8/T3PnL6aPP59NL77yHoo8CUIIO7wCCQ/itvb8hchOTott+YKQ7ofDJ2T7Gctt81OPl7LnzneW1tPt7ND2JfYottd6+50wfWFb/tDWZnHZZ2wtKhEcfJHWiY0nQzpszMMIMAKMACPACHiCQCiUnLDZZvP16ZTjDqLTL7iJtt73JJp6/7P094t/S6NHRmnLTdelPXbcnA7+5Xm07f4n0+vvfGLqD4Ws+scetje99f4XtPcRZ9Nxp19BlZUVZrmXB3Z4vUQzQLJiMXfGPPxohC69ooK6e9zVc8Pt1oFTyVYNBOz8b7wVpjffzu8U71es0xfrbO06WxNOrEyHo//EU2G67wHnnTG8wkXWyWk3CDAvI8AIMAKMQC4IHHnInnT7NWcPVj3xqAPo3WdvpWfvvZJef/JGc+YWheFwiK696BR6+eHr6JXHrqfrL/kdfTp96uDLaZtusCa99sSN9Nx9V9EbT95E9950nukso65XIT9vwCsrykxOf781Yilks+zbj2XTLdamCj7sOgDH7Ls5/YJkxp2dIerM8FJU3GGJREuLWTXnw7dzQvT8tHCa3l6X+xs/9UyY/ve08ynuFi+5MXHFUoNmxSBDOMH9qdDKIrXS4uW0eGfq7PLChc7n2+xvQ/Tiy2HimV8teJmJEWAEGAFGwAMEaqqrzN0aKiLpkzyjRjRSU6P0gpKkD0sbJqwyiiIR5/u2xJpT0h+pOZlSPpVUa2/9bKF9+zGVLruja+frkrY36+8boL9eGaHLrqoglZPXFU86X8Ihw/pjWW57u7NDJvPI6U8+DdHMV8P0xlup9doUcpYuo7SZ6WxOngqvZYqPOoi2wU6dJSUdHeC0wvz57n5mbYqlMUJvp22Q0dVt6bEfX38zRHgJ7/vkOwR2Fs4zAowAI8AIMAJDAgF3d+IhAUlpNVK1/jPXVsjOVkvik8BwYJtjqc6nk/xOaeazWZrtdLtXbXLng6ROWZ6se/HiEF1/UwXdcWfqSFL1Alc/GiMLSKRDIctxF7OxCfJgJLdtkJgh0Wmbhc3AmlYk2h+LpRYJNGItIpVabs91dVl8sRZPf+Z2NZxnBBgBRoARYAQCjwDfCX3oorY2y3nyQbRnIttsW2HFYplFyzO5mTnzL5VnU7NJE47l/PmWc5eNv6XFma+jM7efgsoRb2l1tkS1JljmVrV/TpYPS8RtewXLMuU0XqCbv8AZB5nPy/Snn4UIwUuZpSQLbf/uu1KymG1lBBiB7AgwRykhkNtdvpRaWARbe3pSnYkvvwrRK6+lQo2vsV16RYTuuieV7oe57dIjcrE0IfGRk5zU6c4wCuGqZRSwYfqMEGGWVvAiFrOpug4c6iConE+UZQtdms5iNjmiXMzSiryIFy9NPTdAj8VwTAbR/iTFSmVbAxy3LXXo7bXqycdFxow4XqB7abr35x2WkVz81wrHl/P++2CEEGRbhlIabb/jLu/fOh5KGHJbGQFGgBHIBwHv73r5WFOmdZ9+NkLPvYCXsJLOTksLERyUpcu86wKVw7d0KQ1+AjeeeMytglpn/1hVXbf0d94N04vTI/TOe0lcZBnAR847pWMuH9e7ddaddLqh2Xm9mCmPxexSnfNOs7jihbd8d+Po6AjRNKPv5sxN9h2WkfT0EC1QvEQHK51sAr2cQzzEVFeUAAAQAElEQVSx1Eexmsax6TNfDdFrryexdWQKKBGD+1dL1PaAQspmMQKMgAcIeOdteWBMuYpY0Wy1LJ+dASwJuR3fejdCF19aYX4KNzcJ7mu1aDhlCxdZN3R8bUzWMHp05iUhOk6ujn5Zp2oZgcyTa1o1Y5urPN16mRysfB3/r2eFzPPp08/cXUJ6FPsX67apFPly6f/np0XomedT16UXq+14wVO1tt3JJgzunw2I7U72Ma1oCLBiRqCoCLi7WxXV1NJXvmSJN3DDmcNM2pdf68lrS+wNuyKmxy+Qhh6RLmT8fZa1qqrlByp7xQxbpjY4OSVyvaamTLUzl8lyZE4dx13mz5Z247R3SrtIZJPrVL5ihUV12iGitZVo5UprMAMuVftRFqSw3GjT4sXufiNBst8vW26bGqarrqmgDsUuKbLeZo2BrszPaUaAEWAECoUAX90LhbShx+nGH4sZBYq/TA7RCy+F6T/3hunDj5OOhcrhy3c2T2Ge9+SExGzLLjoy7AucEJESOTmzKQyKTK71FOJ8J6vsdaLDUfXLOenrI8IewKLBsv5M57TgL1Z8/c0VdNsdEco0M15o2+T194XWLfR1d4dMTN58J3mtQdnrb4bpxlsi1NmZSkcZgoqOMg6MACPACBQaAXZ4C424g75580L0+ushuuCSClq82IHBgRRPvKCk89a/Q3XXpHiX86nijwOTeUmDa+MVFeKJtZVysRNNLi9kurraGxyC1KZC4udWF35L3d0DFGtxW1Ofv6vLXZ9i/b2+9MJyfv5FiLAcafFi5zap6IW1snS1seWMACPgLQLOXoy3OoaMtFgst6YuWx6iRUvDhBvugkXZuwTOZ7fHuwpks9wPp0m1e0MsZs0YyY/oW2LZLHRfLs88itqq2WWVraoZuLj0QQ4hG3Ffn9U2pLOFri585U6fP5s8e3k8MWiy03Xy2T6E44Stjlwveb7+Jkz/d1EFvfp69t8UdpjwUrdK1udfZLdFrhtXDDRlnkKl4xrXnD5jdr9Q9rAeRoARYATcIODu6utG8hDibWsPmc6qaHJr4oMNIu8mjsWyc8eNmckFC/1xhMTaTLsVjY3Oszjg++CjML3wUvYXbGIxcOsHldOkc+PV16LHGWtxxnuJwzZjkNimWCOr+gof+hT17CHuckbQXj9TPp8dI9o6nPEQ+lTtEeUixtZ07QqsBE+u8TezrZqqPrJKrePKlVbs/zEzbnb9OjguXhI2d4GZK+2YYZeTa37hohDFYlbtuG2A5PSbmDePbykWWnxkBBiBoCHAV6c8ewQ3yiv+FqFHnkw6fHj5xa1YpxlEyFbJUbuf6TWcdoeIxdL5MlFaWtQ36unTwzRjJmYjM0nwrsx+4/VOsv+SQiFnHFXOfa4WxY1BUa517fXw6eYum7wujdk+uxyn/MOPhunyqyqo0+W6bCdZdlrc5qDZy4uRVw14ZFviEtY666w/+2zA3Od71rfO55Ys22168WLvZbq1QYufmRgBRoARyIIAO7xZAMpWLGZEdR6569y8ZH1uH7PGFHvSdnlw489ke3/C6K5u55uj7BzFJVvi0o09ISKvSNV+nb7Jpthp0JCpzopmN0OSTJKcy9qkj4k4cXjlQC9ZSnT9TRX0yOPuLhW6s/DNzdY5s1hz7bpTW1U0pw9vqHhlervxxEbOe5n+ZpbV3kwyXfddYhCli3km3VzGCDACjEC5IuDuLla6KJS85QPCq9RoSSZHMhZLF5CJP51bjyI7n52Skys7jvEu6+bvh349K5Nc2WzQGTTEpXYmJeeXUsnEtnT5Sdar3ZFwrDsUb+I3NzvLUdlt527PsjTCzu8m/8mn1vnlpg54e3v8G6ysbEm1CV9hvPbvEfryq/wvxbqYo41Ooc1w9K+6toLeelvPls5OC6dmxUA7HqD1x07tZRojwAgMLQT0rmxDC5OcWht3OVupM+sYlx4br2xLvVFmMrLTpS0yf4dP6ymFvXEHpzCecHwFjxdxTHETVskWNsgOuYpXRXe7JrbZYfBhl+1Wpr1+prxbjGRZKkdX5il22s32Yjq/Ry/aYx+34qt0K2IhWrDQWXqsJfV3jy/bvTQ9RH19lrPpXMuiov2XXFZBt0218smjc+qbb0KEZVSffJaq05mbqCvxu43FnDniLq9DzlKYyggwAoyANwiww+sNjiQcJo/EmWLiknOIm5dJNA6xlgGKxYxEnn/tDs5tR2LWRlc0nDbhJIo4U10/HbhMenXL/J7JBV66tmTik8+NTHz2sniGWbeu7gHDkUqtEUsMHNpcDLhSJWTOxWKZy4tRKtpcDN3ZdH70SYhemhGhWbOT7wyIOvbBaqzFcEq7ibAsRfBkir06N1U6sINDX6+qlOmMACPACPiLgKPD66/K8pQ+IHukiibGWvRmTuTq384J0WNPhqnHcEYEvVnxxbTWNqLHnojQt98567HPyq1c6cwn9OjGwkkUsW69bHxxxQyRvF1ZNhmZyltydLZkp13Vp3A++vsHCFvOZbJBlMWlwY2gZYplGzLxoSwuPSmIKzBtjoXokssq6V//rkCVtLBseRopJ4L8NCEnAWVWKZa4Jsh9lKmJSxO7guD8svN99VXI/ECEoMcT51RcsRxF8BUqvuWfEbrYmHEulD7WwwgwAoyAjAA7vDIaOaTFjFlLS6rz2OzCmcrkBHzwYZjefS9MqjWUsskfG7M/774fok8/0+tWN06TrEc3vXBR2NyYXmfm10lmPPHI1F6mwktFt9cvRB4z5c++EKG/3xihzz5PPTec9Gfri7jCUZVlqXjiCcdH5rWn5yY+59xmDJrsZbp5HT1xjXbo6tPlsw/0stWznUfZ2LOWY9swwaRqf1yjjyAj0/7bWOQQawGXFcQ5hd8fgkUt3NGO4+LFIeq3r+konDmsiRFgBIY4Anqe0RAHKVPz4y5u4Kobr44MeQJZKSfhILa2ZrJYvyyWeJwtarzxVoRuvCVMC+bj1iqo6viWW8N0820R8nrmV6VRhaPcjrgP21/Bnqefi9DDj6c+Zo4nnBjV7hWopxvszoNTPdUAwYnXTnPzUqS9rsgLB0vk3cRi4Oimjl+8cRe/aR0bFkrrcyG7M48Z147EOaWjV+bRGTDL/E5p1XXHiRc0tBUxB0aAESgXBEq7HezwBrz/3N5k0Jx8HB/UV4XPPidjxtaYtV2a/bSBgwa3GF+PU8nLlR5rSc6YQo8bOW75dWV//kWIYrGkXbr1gsLn5omEbHNNjZxLpt2et147R7m2J9kC71K9PamyFi/GLyOVppuLxXQ5C8cXk36PhdPKmhgBRoARcIdAds/FnTzmzhEBL274sZilvM2jGV5LWvLo5sbWLa05TkpwTuXzuNUL3JytKh5Vxjlmm2X30iovnP9FxmNq2aZipNvaif7vogr639N6l7N580M0bXqY2toLM0D53tAn4/LokxE6/+IKiktrq+XyfNItiWtANhnY41t+apSNf6iUAxfdtl59XYSuvT71qY5uXeZjBBiBwiOgd4covF05a2xt66DmFp88PhdW6d54hMh4YjmCyOcT43OtudZvVzzyl50wWXZccdNe0ax/ahVqyYNstz0tO92ZZgfxOLo/9wk6u9qi5p0GCzIO+RqHlyexjrlb8UGSfOWL+suWWqnFS/Qc2K++CdHLM8KENe9WzcIeV6wImS+XLZKWOqgsUC3BUf3uVHJkOp66XPiXCrrjTmdnzem8kOvnm563IHs/zf42RM9Pi1CuHw/JxcaHHgnTRZfoD0RwTVyR+HBKLvq4TtkjwA0MGAL6XknADLeb02FMV5167nW09b4n0fYHnEo/O+liWraixc42mJ828z1af+dj0kJXdw/NW7jUpB92/IWD/Eh8/vUck/6rM65E1nXABdJ1pQJXcPuFsLhiTWFzs2V4KJT95mZxFv4orxvVcbrfez9Mf70yQs+94OwoyC0Y0STnkmmVo+LFTG4sltSTa8qOg/Gzyipq1qwQ3XVPhD76OPVy8s67YXr1tRB9N8ffc2DeglS9doPtv7tlyyyOuLRWd2VbZhlWDf+OKsdWxn9F4jcFKzoVA1OUZQtiPsCOi8jHFYNvGa9sOuzlzdK5uSyx04SdR86/9nqIZr6K/Yn9PXdknXO+D2sPROT25IOLrL/U0r29A7QwAE94Sg03trd4CBT3Ku9hu+95ZBp9NXsevfTgtfTGkzdRJBym6/75kFLDAA1QXW0NPXX35SmhqjK5LdMnX35Lb73/xaCMqfc/M5jOlmiO5X+hVt0Es+nWLZcdPlHH7Y1U9da1eAlKZ7s2odvLWHYU5LSsw+2NqmWlVXvBwux9+9Usi9d+jMsDBHuhi3wssaVcXHLaXFTXZu1QOFYrE1hA0EefhulrY9b0HWNAgDxCrCVErW1IEclbaMUVTwQsztyObr8615bYUxg2Co2Y9RTpQsZiYKg6R2Vb5s51d7mOrUzyN6/I/7FEXOEIyzZ6le7usX5j/Rof2PBKZ65ydPouV9lBrocZ+Jv/EaFPc/yiYZDbxraVJwLJK2KJt++Zl96iQ/bdicaMitKwhjo68pA96OGnZhgjdvWFvqa6kladODYlhELWhRZwHHHw7vTPe55EkuYvWkZPPv86HbrvzmY+20G+mWbj7etP6pR5VRdSN7Jlefa0G2eprtb5Yxf48pNdLvItrc5tirXkf8rpPHaX2yanYVuuAY/o7XVjMTulQPkBC1/VOSJbkc/AaWXCsYY8GccViUe5en1h2WrJSKabi4UdDEmEb+cQvWrMJiayBY28+C1kNFhx6WtJ4N7enrG2Y+HtUyP077tTn3DMX+DISl5cp5wG5c7amFpoBMQAqKc3+ZvOxwauywj4jUD+3offFmrKnzNvMU2eMHaQe9L4MWZ6ZZvD58TMEqIVsVY656+30YVX/5v+N+0N6sWngBJliH524G706tuf0Kdffkf/eeh5w4ne03SoUeZlmDtXLU3MRqk5ClMSaymMHh0t9sfuok48MXtofxmnIjlpL1g9jV97I0yxWKpIvLTX3aPwOFJZfc/pOMUqI2Rn2UmOqi9kRzgWU0lX0+19KDhVdJTLDjnyOuGppyP07PMRcvrqoE59Ow+ekFxwcQU9/Zz7S+vnX4Zoxit6zkOsRY/Pbp+cdzszjrrfzQ3RrNkhkrHOd432q6+H6Quj7ZBvD7Iee1lQ8osXu+/roNhut2Ou0b8vvRym7m57CecZgdJHoCx+qXhsjjW8NdVVgz1SXVVppjs6nJ/5jh09go49fG+aMnmcyXfWxbfQ5TfcY6bFYUTTcMIs799u+S/9+4Fn6Rc/2UMUDca11amzHaKguipCjfWVZhC02hoy86DX11QIMlVEQhR2uH+B7vSFq1xvApBH0j/YDluG1VlYiaJKsuxGuaB1xcMimRI72Q2GbsXjz1FNkUEM5LqwQwTUR4gbXSdoVRWpNgo6cAYvQn9vmO68u4Iu+EsFVUaS9nbFI1RnnA/1xox+hYE1Ecki0gAAEABJREFUeBHQPiEHeRGAB+iIBQ2xXBd5EZpXJHUJGh7nd3VadLmdVRWhwfbLtlO/My7CRrstKjrsRpD5YTdoCKgnbKw0MAINQbYFeRF6Eo+WUQcyBR15Efq6rXaKPGI4wj2Jl9VkGXL7q8LJPu3oSLa/tqLS3MXg4cciVGGAJ3T29Vj0F1+sGMQQZcL2bkMf8giwFXYgGCJS+CsS50CrMXstbJszJ9kGyIOMXMLcOZWElxrnGvJEfaEPtsgBfSHKED9nON4vvGi0OVQ1yAa6kAN+USDjCHsFvSteOdhWYCroPb1JfEc2JXEXshFDJvhjMRqUIesEjihHqJD6DnTUR5CdP8gDDUHuD8gEDaEyVGEMOML06ONJ+0BHu6FH5gXdz4B2QCeuzU56qivDJOyR2/Phh6m2O9UtFdoXX0UIDu9336b+xoYb9whcQ+V2oH+Bl8BELsuURt82GPe/TDzlXgbcOBQegXDhVXqvMRQKmetx8cKZkC7SdXWGlymIUrzhOlPojBMOo18fsS+df/rRdPFZxxHWAdtneX/xkz3pzfc/p/323JYmjhstSbCSff1WbD/is7I9fQOEIMoWLiIzD1ov7oqJAsxaOc0FzpmXYLBFccMRtJG0stAjM/b0DtC8hWTMbKdqb+3oN+2U22avK+Sk1hRUInxpLJlLpr773sIEGMh1V7ZbOkEX3Ggn8gjNK2XuJI7AWfAD0uXNRLC1uUVQiTDbeN5fBujM8wbMMlGC9kE2gqAh7jX6bcGSAbMe8iKEFb8W6BU8cgw7kJctBy/0Ici2t3U44yLosAmyRBC22+mQiyDTYQdoCKgnZMw1zi/QEGRb5i+WbJGMh0zwxm1bzrV3SkxCuBGLsSb0G1nzT7T/nQ8H6PJrk/WgH7IRZs+1flRfzx4gpEBDWLIUOaJZ3yb7H3TUhXBIQx4BtoKGINNRJtYlwy6UgaenB0crLF+RbD/43QSBL9ou6kGPJTn1CF5R1m3oBzbgmDvPaifSKBdywA8aAngFXbQfdPA40TGDLejfzwenFQQNMWRa1CS+kCdoAivkVfguWoxSK2CwDrkIMj9kgoawMMGPPkFeBLQbUmReUeZXLNqHa7OTDtjSZ1wbUCa3J96V+/kCWTmFhB1e1+3qAuq4J4TMe4CQP/WeATrjzwPU2p5sK/oX3EuWJ88XwZ8pxnmmwjhTPS/Lvpw1QHfeN0Dytc5L+dlkATcOhUdAcQsvvCH5asRa3LnzE1dPQ9j3C5YYR6LhDXVmnO0weqT1Wn2vbU+vyRPG0HmnHUXH/2I/RxHdPX2O9J7efuqI95pBZhC0ru5kvXbD2REXeJm3x+PHSn240kgKHn+a6ErD6Xjn/eQNFsWdhm2wU26bvS74EJzsBl0VZFzkuitifSZW0CvXRR6hpyfVxiXLLX7IE/y4CQmZSMt0PI7HC3ZyOxYvtWRAvuBF/M3sPrr8b0T3PihugaASqZYotLal8lncREKXsAl02AV9CLLtSIOGIPOvbLXOo86uXlQfDN3GeQdeO31FzDrnZDrsAC8C2iyE4EYNGgL0C/qyZZYM0FFX0L/4qo9uunWA3ng7ee6iTOZBXgTRDrl86bIBs5/nzU/tT+iHPgTx2xgw1MCZAw1h8VIL59Z2MmWAhoC60IlBFvIIcvthB2iDIfEiHuxCGeoijRhB7iPUmT2njxCQzhbQL5DRUG/1G/hl2SgTAbyiDE8EhC2gCx4M4CADQabLNor2ow54wIsg0/uNkx80BPCAF0H8jkCHTNAQkEeQeTuM6xTKEFT4ivaAB2nIQFi0OHn+QiZoCG0dSTryIqAuZHTGk79RlM2d30fX30L04SepdJTlGwT+S5Zb56iQN2deL309q9eYGOin7sR1XW4/bBW8pR7j9wnc5T5Cm2It1m9v9nfp14Z5xgANPLqh37gPxRP3GN06XvO9/2E/vfs+0cefJn+nXuqYv7CPPv4siZVdNjDmUHgEysbh3WvnLeiBJ6bTkmUxamvvpLsefJ4O3mdHCoVCJqpT73+Gjjz1UjONA2Zz3/3oK2MWr5sWLV1Bt979BG216bokL4sAH8LhB+w6uPQBeTk0G4//5Lw9jVlKO82ejyse/9v5XORN1uoa6yJlZhwO8cSNX57dAlusGcfUoFoz2BnPrCNVCpFKzrffhujaGyroi6/0TsmeLOtjxdvvdv06+XnzrHPGvn5a1ZcqutDlFiNRL1PcrDjv4NhnqpdP2bfGY/rZ34Xou7l6fSR0dUqOkqDpxDFpJwiZPxaTc8k0llGIXGen1YfI6+Av7ySBOnK46R8RQpBp2dLfz3OHkXC2ssm1l99xV8QYgMhtTXLIvzXMoCZLkinV78jp/Ory6TqVtCY9tWRZKu27OSGaM5fok8/c4ZsqJXPOPtFw4z8q6B//qshcaQiX+nnNcYL1409DdJ1xr1hs2xLtsSfDNPUuvX4S99xs124n/dloS5eG6PqbIvTvuyson/tQNj1c7h4B/64a7m3Jq8bPD9qdVl91PO1yyO9pqx+fSD09vXTqcQcPyly6LEZffGNcKROURcZzmKN+eylt/qPf0G6Hnm6M3vvoorOOS5RaUSiUvJFYFP1jPPFoqNAXA9nC2prc7ZflZErLTkYmPqeyWCxJxR6YK1YQLVyYpGVKtUh1Zb6exON23BgFHXJFWidujjnjFlfc8FUXzVjixaJ8MFLZGzfOL6y1W7go1VY3b97LdgtboS/elbwsdBl6QMsnLJY+RQ2dX34Vom+/S7VbJd+YmFQVZaR3G4+ZBYMKf9gieLqltcqCZo/t29HNmBmmbw0HzM5XyDwGip0dSSzlNsl2qK5Dqt/RbbdH6D/3RWQRRUnHbdv4tdqWNukZ5Y5rqfGIXq4htqxb3ixTk2n5t5Okpqfmfh+i6S+HU5ZVpXMFg6I6X4Jg3TezwrQc9wrbte/d98I0+1uiZsW9oVC2z18QMvwJS1tLixXzMRgIJO9swbAnZyvq62ro5stOo9eeuJFefvg6+u8/zk/ZUeHMkw6nt5++ZVD+6cf/lN599lZ65p4r6NXHbqB7bzpvcI0u1up+On2q43KIk445kP551ZmDclQJ+4Va8GFUOm16hObb9nLVmYWKRoUUb2P7BXuOMYMHG7HuT2iKxUTKn1iMhOHIyRoyzbzJfEh3Gc5uu3TzBw1hztzsDgH4RBAXzFhMUKxY1UdxhSNs1Uo9inamUonsfWAvt+e/+CJsvlzywYepP+HeHjsnkUq2yu64tEa8U3I4xGBE1YZ0zekU6Hz6mYj2xyiaE49S0yWpKbbNVpSMsMWpUNU+2YnGQOOFl8I0U3NXBSc9Mi0Wk3PJdCyWTMsplY3NhiMg8zmlO6X+dSoHDU83MDBB2uugo1/oTDufFZMQb78bNj8v/cZbqb8HIccp7kuupkgpXmi7NqcUamReeyNk2vLeB8nrDqq9adj2ouHwwmFDPshBvgbATqcv3un+zlDfy9CpeGdA6IhL1yxByze+/6EI4WVo24rHfMVy/QIjoH91KLBhuaprHFZPo0Y0alXH8gVsXxZtbNDi94Lpsy9C9PKMEH1pe3SvmoXKR2dNtbvlBkIXHhnBxq++LvzpYb9YLbGWYgvTMsYrlocylqNQ5eSgTAQVjx99JHQuWUrmVlZzJedclDnFwimPazgvTvVzoalwUTnUsZizltTVuxZPXDGTvMI222Zxq48zXw3ThZdU0Cuv53fuvjAtTJgxUuHblVjKs2y5Wo/oI7W1ziUrmrOfx6jZ7MAXW5m9rtwm/MbhuPfndqmAGdTbM0BPPRtOm+1WnRey/pi0L7dMNwUbB6xtNqKsf21tFktnYpmWlVMfH3okQhdeWkHz5mfHSy3FKrEPhFsSfdDSkipbtGXhojzAtlQ6Htvaibx4IuMkfPkKqy2xluT53tZu0Zz4/aJh6c+s2UkbnPSI36ZTmZ22ItEuO92ex3mCp02trfaS9LybAV16bab4iUDmM8dPzUNUttONPRbzB4wa5w0qsirrSrwsh4tLVmaXDJCJi6cfX1CKu5hpdWl2TuwCR7myygmYb9x4X38jTLO+Tb2JxBWOoCwzWzoWy8ZR/PLKitR261i0dBlRh+2mK2aisEWZjgwnHqx3nWE4zjNeCZPbm5dbfll/POFEyx/7QDnWA3dKa5IF7Zrr9ZccqGbFMDDA0oylSwbxh/jBoNMeOD5vvBmmN4zzd7BiDgknXarfi3j/IAc1ZpW5iXX6y5alt/s7l8tU7APh+OAMo7Nj29eXrtM0Ko9DewfRlVdX0r+mpp8TWEphP386Df77HwoTvpAoq40rBtCdDgMJXMtRV9VHKPM6xFqIxDsnTueLk77/PROmJ59ydnUgz6mOitZue4L48swQPf5EqmwVhiqZTC8cAqk9VTi9Za8JM3Y33Byhzz9PhTg+eDF0D0F9nfMFVCWpydp4QlWspKse9SkruCj45BO8cBChl2Y6v1yw1OEG5EK8J6z2GZtcheKmkmtdUc/t+RKX1t8KGYidbligv/9hiG78R4RaFC+IgUcEFS6NwwVH9hgyYrF0vrnfp9MyUVYYj+6vv6mC7ro39fflNOuZSU4sZpXCLitFJJxlnV8bZn1EPcRxhcOAsmwhrrg23HZ7mB55PNVJwvZY2eTJ5dmcA5VDHHfRnsU2p7k7MXCW7fAqna092fRgR49MPLnOzssy5dlQmW4fxLa0hOjjT1PPY5lfJ73UeBKG/ejjtkE/tg775x2RtPPnS+Pp3SeGznfeTdVrr6+ju6Ul9dzUqeMFj+65iaUkb72T2k6hvyUxGy/y2eLe7tSrwrvvR+id98O0zBh8Z6vL5cVHwPksyGQXl2khgBm7JUtD9MVX3lwMolGio4/s09KdL5N49JavHKf6Yg3USoWDJR5NirpffhWhy66KEJaCCJoqjsVUJe7o9hkbd7Xz447lefNQ3QTiipni9z8IE9aVz56dPE9VN3uBi93GFkVfOiEhZDiVuaGJ88c+4xIzZoCc5KhwEbw6dvX0JjES9WBHXOGoCh4v4kLoyNfOFc2pEuT197GW5K2mJsvuMalS9HL9A1bfxFqsWNTCo+jpM1JpKNPpb/D5Eex9iS/NPWDMtmJ5idf62hKP4O06xYBBxPnohaOdT32v68akcy2b7FgsG0dq+SLboE6U2u9bgs5xsBBIXoWCZVfJWCN93E3L5mbbTUGrUoKppjqRKFAUUzgPBVJvqvn0C6IO4zHSItsWNGZhDgd5y6FYS/qNMAeRFIu5q4XdFb51+dhUV0NjY+oMhKg3b36Y8MIMHtcLGuK4Ygbvmusr6HJjoAGebCEWy8bhfXlzLNl38s4UqvZ0GI9w3Vohz/qi7rx5OKYG5Npz3HYNdb0Oy42Z71xkqp4M5CIrW51Fi72/7WDg4aQXTzBenB6h775Lni9OfF7SxDV+wGmxuoOilsR1VtUGexX7UwWUxxROXnuHM9azZ6OW+6BykJuLcA2ItfjTpxDJqs0AABAASURBVE74CqQWLkrFMxazSmIK/DsSX9u0uIj+fXeE/nql89NNwcOxfwik9p5/espW8mJjFjeXxqluzEJWNCpS3sWqC0RlhbOT5J3m7JJUeMRimS9qqplLlcZ2yfFpV3wwQlXXC/pKY8YFDu8rr6rbFYulavp6VohefU3vp9rS4ix35swQYUukr2xPHPAUIlWblcNNu90YaFi5wh5j0s2jU2P2VHbi47ZHusLyN98OE17OEnmdOG0WULFDQKtihrvF1o86OlU8sZaQ1nri1lbn/lfJFXTV70+U22MVznY+pzzOLSd6dfKLx07FGWkqmdgTFRVjLTgWNixekqqvttb5OivOX50na9giDS9l3n2P8/UAH5ORtS5ZauXs/dvVbZ0n4ombxZU8xozzLZlLpuxykiWpKayzRUilkjHojtBrbzvjYOf9zpgUeOHFMPX06vHb6yPv1hH/6psQYTeGGcb1EvXzDfZzYJbxJK3TYT10vnoCUj/wZjj/agJvdukbmOmGUVvrXftGjswua2WON8nskvU5mhM3pG7bGimVhNfeiNAzz4UpruEQqWTo7L2qqpsrHTcs1O1R7PvqdON+/fUwqdagQZYcVBf4eOIG1yHN6GIG02k2I0gXZOEMyG1EulNqxyLbrAvK7QHbVc2YGSbZiZdnhu38Tvm4YllIoWZH41KbnewTtIcejdDsby2HRtBa20KErdREPt+4S9OWhx8J00rNdZKxxDVAts1+LupiIMtAujmWigdoCPJ5hN8DaAh9DqvHMul2Kuu0XZvss4PQg6AapHzwUci8xoFHhBZjwIyXxb76xvnWHe8MGddEwZ2M44qBYLvtpc9kjWTKqW3JUitlx+vyqyrTZjLRl9NfDtHTz+s5sK+/GaIZr4Rp4QLntlqarWNzHoNLuX3iJdjlzc46qyqdbe/U/D1Y1vKxWAg492qxrClDvfKPSbd5a6/l/KNC/WgUR/1gvxA51czFRic5bmhx2yi3K3Fz6DQu2DpyvjBmKl/L861wrLvCCx1+7TearR1xhQMl1wNObe0yJbc0to5CTYGzPY28CCG/rgpCgUPs9hzskm7g8izVyBHOvx04CVArD6h6HPYsBo/YLQFpOcQT56hMQzoesJvdh4aj9OlnqQ7eZ18M0M23RmixYg0i2uFH+ODjMM3SfHzu9JJbl+03Ipx2uc9luyPh1P7P1jdyufzbEGtf8XKkkP/MCyKVHjs5PLIDLdfAb1rO9ydMjtlmVbG7AK5xS6UXolokx07l5DnZIuuT0+J3IdOQlm3UkSfwQl3Y1d0zQGLHFNAQxPVu+YpEg0HMEMS9INdlOnbRcl/LZXL7ZhkzsHKZSIu+XGkMOARNjlWyZR5OFx+BItzait/oQloQl27M0KuzqXlTdICiirWYkOEUKhTLgnLdi9dJh5c0+SIjy1VdgGUer9LLlodo7vcheu/94vwM4goHSm4fcLKfQ3K5PY21zpgZstPbNGZyRB3509LiQi/K/IpVbWxpTd4cgUU2/csT+2ouyXGpEeTr9EtMWnaBOkELvYqtr3L9zLO9fZ2ddoo6v1LzCZIbTNuMGWsnjfhNy3RxXg0bJlOzp4UtK6XlKgtc7p8rO9CyRp3zGPyifntij2HQ3Aa7E61bX9dGJ3ny7wfOr+CRnXVB04nlNsiyVXVVtst02aGX5bRI/S3TRV90ak7IyHVVaaYXHoHi3OkL387AaOzyaauehnrnJq4y1pkuU+ULikzPlq724W1rlU6V46Uzg62SKejyhVDQSjX+/IsQPWw80lY9PtVp10LppSJxodep5wfPkiVJhzcuzaR2SWlZbyxm5XJ5Sc2q6d3x5VcidMElFaTr8HmnmchpaUwm+bJjkolPlMl9IWiq2GnZjIpX0HO9Jon69rhVMTNn5xN5p/MnV4dNyBSxG+xEHafYC3vs11V73klvNlpLS+rThWz82crlc0HnoxIyvnFpUkH+TWS75i9JrH3OZJufv5lMerksdwTY4c0dO7PmwoVm5Pqg2vfStaBEBdVWP5tt1k/bbKX5unBClm5UW+N8YYtGdSXo83UlLlz294bkGRh9ad5whn399eRn44cfOveNXWoolM4Xi9m5UvPyThepJfnl8DIf9gbVkdKZOB90ePPhkZ2KNsVLjqobHx6PYs22/Fg8H1v8rqua9fJbbzb5KnxRr9dhrS3o9iA7TfYyvBz10vTU34HTxERPL2m9OBhXDMaEXjHrLPJOcTYZTnXc0MQMubiuirr2vKCLOBOOgkdle1V1EmPZsV5qOJfnX1xBzz6fekFVyRnUo/GUQXaQV65MlS/kOMU6a5vleipc4tKSnM4s54Usj9P+IKB/Bvijv+Sl4hGy3Ahswp/JEaqstH70XbalDrIMzNbWSl9JC4VCtPqU5EyXzCvSqkd2q00eoK19cniF7kLGjY3ea8t1GcVwFx9cgNVGNyJyFayzxVUVk1n34prLHprt0k4XpjIPDvhIBxze56fl2mIPjMgiokfxomGWaoEqjrWoL/m654yXDcrkzGbS02k4Oy+9HKKLjBn0L74Kk3A4qqoyXychU9aJeng56qUZ6V8oA689QO/z08Jpy6Bk5yye4dpulyfn3cxAyvWQlvtOHqShDEF2MJFf5uKT3fG4+pyBLATVeVVdlfw9L5HWj8elAev8BWHCNXj+giQvZKbgCIItLJS2qnRqs41dmZVtUTIlCnC+JJKmzSKtit3IVslguncIZD+TvdM1JCThhZ9MjlBPT/YLcmUlUY20U8Oqk/vpwP2sqYw113Cere1RvIBTaNAzOfuZbIno3W/SRMQ9GDXjDfY0wT4QcFF3K/bbOSGKxdzWKj1+MaM2QKk3PVVLmmN6fPb6+dwY7bLKKW9/wUi07dvvLJztg7Xv51t0wWePKyvslGR+7vfOtx3ZaUtyO6e6jJkz4WTJM9NLljrLdpZiUTsd1mXGDflWaeqxvZ1o5qthenlmqp6uPK5Ddmc0VSORaKedLuezXQe7JAdTrqdKy/K64s73HLlui2Lt60qXS0lkmSIt96+g5R0PJCV0xaVMkpw15UXbsiphBk8RSP3VeiqaheWKQG2duuZSxad3GxrSf7SZXnxriqp1iJJsF+I6aRZa1BkzOt0OUZYp1l2La38JL27NpmQSnbUslzWGEGq3BTS/w4TxueHrt11eyY/F9CTFWvT4mEsPge/nZXZg7U9WvpmV+daBx/8qzf1iWwIbg+xkyUX4aMR3c9Ptc3KEYjG5ZjLtxCtKnZz9uMJBbHF53sU1HGG3zqiw289YdV2VcZTvD6pr6GJpFrZZ0TfZ2uFmIARZccVgRZbjdD6hrgg6/Ry3fVRC1OU4uAhkvmoF1+6ytqy6MnVELS9vUDV8yx+m1lHxCbrqi1yiHHG2C/Gqq6brrHFwgiHL/oKbzo0A9exh7NjCO3x224VNNYo1zKI8UxxrSb+BZ+IXZZj9F+lMca7yM8ksRplqH95YrPDWqM5Z+QYrpwtvoX8a7YPntiw7B1QrrgPCQmy3JdLZ4kefiNDtU9MfAS1clK1mslx2dpJUK4VH6lYq+zGTHKfabvmdZKhosRbV7VtVIze6rEduT7b7A7Spnmp1dqLUCrGYt9f0uGKwEtcYfFgWkblcIZuDLsuTBwJCBsfBQ6Awv5jgtdtXi6oq8xcvv4QmL29oalLLrsswM4xasRiORNEo0cQJ+V9kamosefZjiNJl19qcw3iOM7MjjPbbH6/a9Xudt9su5NfXp7cTZSoHGWUc3CHQ0emMsTsp3nCrztm4dIOV095ozV+K6neaj2SnWVFZXq3i2iB48NEYLA+QP5ARV8zMqZwmnUFdLCY0Osdff21crVQKnKvkTY3F8haRUYDsoMqMcRcOn1zPj7Rsy0BiGVOmpwJ+2CBkxrv03SB5VlvUR7yiGUcOQUdAv6eD3pIA2Td+XPrMpxvzKipDVJ/FeXWS98czep3IaTQQ9ty9nw4+IE87KyApPUyaOJBG9MLBFkLtj1cFvdCxamBTa3PuvbYrKA51NOrcshrpbWxnjvKiBn12Z8yY3J4m5NNLdbXp1wC7vJWtIWqRvsIWlwYOdl43+WYHhzKucPba2p0lyy+QyRwrHGSjXHaaYjFQ3AeVAx9zuYxC1iyfm/LsbAqPAzYqx06uJ6djLclzTNbj1BdyPaTFQEfnRbpWaT9x2UZ5K0XIdBNU54aTDNWsdlfiS5aqOqKNTuVMKxwC7PD6gHUonPzxuxE/cgTRIQf3mbOvw11ulO5Gj4rXraMyrMFZUr0Dfdiw7DdAZ2np1GKsnU23ongUvx3qfFsW7/Kur/O1pRD15Rt8IfS51bHtlkSrr6Zfa/PN+mmU7ZPkjcPd9WmV9Ha+agIVLwvFYvp2qZwnFV2WHFc/UZLZck67cZrcKmmOOd9PmjWw0zk3nXhUjp2O7W6xiCcGOjo6+3qTWMj8cQenXWWrHTecnwsXJeWq6tnpTrjZeTBw+uvfKuiKqypp8RJ2t+z4FDrPPVBoxDPog1O40QbixiLi1ArVGtvuiBpNihk4UW6PazRmZex17Pm11hygmmo7lRxp6Vx6FPkRrfypWL3a/nO5nZ2vdsDLKyvd2uJGr31dp5u6pcgbi5Wi1ZbNo0dZsc5xow36yf4S7AhjMH7sUX1UV+d8XbLLlZdXTZ9RPreZxUvsLbXyc+cSrZRmqy0qUUuO50x7h3sHTOj0M45JM7n56IknnNx8ZKjqwslUlTnRn30hZH52+2WX52k87iQtlRaLEfX3DVCvEVYsD2afplpc3rnyuRL51U85yB07Ru+mANHyNl7y+tz6eucfx5gxqOVPaGocINkeoWW1VfXbM3F8v6hWkLijADeGesVNXna85cai/yeMS++/6mpnHGulLehkOW7S0agzd7sPe+Y6a/KH2umwZZQ/mnKX6sWWgNmWqcRiudvnVc0pqw2QPHMLuar19NhKMdt1o6fXn9tPu/TYGzZ6GVQv673zfpietn04wa3eWCxZo7fb+VohL51Icqem7DOYojTuo5Mpv3Mi9GWKO13Y4pWTrbJH3EMUm4eoqmnRZdu7FH2qJYiZPEHAnyuOJ6aVrpB119F3+lTbuYwa5SwDjxs32cj5YpgvYpA6ZlS6o4YbXaOLDz6oZpZlhz4fW0ePgqWpEqLR1LyXOQwynAYCkyY69xF0n3dGBe29V6qd66+HkvQQlbAVF8holCgaTecFxYslHbq7PUCf2+A0w+9GhnzDVu3S4Eae37ztLgZd+Oqh004jY0anW6lyJjPtcZsuxVuKXdro0QMkf1xAlNfWEG22Ser5L8pE3G5bPyuvNxU8ucS9Dnudx2LOkpx+1+CMa8zegU8On3+efu28/c4K+vfdFTKbmZbPcZOQOMSzDPBysSshmrCERKR1Yje60luuoyF/Hnyh7YUX9dwYnY+SyBZ1Z1iXC7649JJlDzuzgCTwQe9MCXwzgmUgLva6FmEZgy6v4Dv4wD5lPyrwAAAQAElEQVS68LxekfU0Xmct50vX2NGpzl1FhChsBDfKsVbKDb+Kd5jDnsMq3mhUVaJPx6N7p4FJg2KXBkjGhzRqa1Jv+PjqndOs1+pT+snJuXGiQbZqZnm99VL1gVcV8Nh61Eh9fpUcJ7p8I3Aqd0vr6s5cY2VL5vJ8SmMtqZfIadMjlMvHDYQN667dT+PHiVwy3mOXPrKfG5tsPEAXnJv+Ox+p6Dd5ljhmYLJ4cVK+X6k64+nEOWf3aItXvegJAZ05OJmol09w+l1DXjyHNb8qWctXQKJeWLxUj68QXE79EYs5a16wMORYEGtxpjsy50DEPWXu96k6VJ8+//Kr1N9yNnXNzaly7fxxaZbazaDXLofzhUPA3RmQ1a6hx4C1brW2ta8qh8QJndbW5I9K9VjIiW53hqo92hlguy1DtNmm6Y7QzjsOpNAbhhENVzmeofT6aHuDw8tsoLsN22w9QKto7sdrdzrd6srG78WsNWZ4jz0y3bFpdHjRL9Ngaucd+rOZO1i+6mSi357cR5tmmYUbrOCQUM00y46XQ7WspLjk+KxoHqBLLqugDz5SX6rcPoqU3+7OaoyN4eUZIXr3/VRiZ+cAPfZkmNp8eJTuNKicPGmA8DVH+yz9KsYsMeiwLhYLkcoJQTkCHOx1DAcc6XyCfC2KZXFwphiDO5Wu1lZViTf0Ulge05xwsmLSQKu52Zv2q6S0xFQlyXuTnaNZWYcoLs18Ot27TFnwVM1E6sFJbiyWypMt166YJcd1NltduXyhwz7PeCKgGtiIJmX7Dcg6OF1YBNR3kcLaUbLazjq9j9ZZO938gw+wPgUsSlSPIaNRwUEpL3bJjo3OI2LlhSUpXis1eVKINt0o3XGaOHGA9t6zlxrqZTHOju2G6w8QlkEMM5ximTvTEgCZL1u6uppo3LhUrojiTN54wwGaMG6A8sLHuJKNW8W5rT85sI8yfRlPthIDoTrFemCZT6SbRohUMsaezKrlJRgE+LXcJWlBMlVbFzIeZyfzIlWrGHzpOsJxh9m1XG/6dbbBKGyU3+5G3m2ISzM7qNtl2Pvue2GaNRs5KfiUrDd+g2f8vpfsX90LhYkOOTB94GQ3Q5zJ+I1u8UORs3P5k68zzpl11nLW2ebRevO4Yl9VN7uHdHU5t3/pMmfbnblTqToDrWyDFFmiyrFS0eW6OukOF/2xeEnSOZZ/HwsVM7/NLUkLVL/tLo93e8n2dbWkRVbKCUc4uy0rrXL7cZH0VTl7GeeDgYBxiQyGIeVmBR6Dy23CVl1rr5nuSMqzI1Okl8PgHEWj1sVVx+GVdfmVrq4O0Shp/Wyj5KxXG04o9A4bHiI8zj/2qD7aY9fU9rpph2rLM1L8w6yXU1FdHdHxv+4zZoSdSvVoTU0hEu2z14DesaOtfrKX2fM11f20izFTbqe7zR+4Xx/ttksqtkLGiKZUW+yzgILPq3icMZjIJEt2clWOcKb6omxljrN/VcY5K2R4GTs97h3oT970vdTltayWlqSdlRWp50u+umKx7BJqjd+kE1e+AxEhMx4XqdTYzQxvZyfRHXemr9laKT2RS5WuzglHV6d9b7wVos+/CKcIc1oCA4b2Nnd91+7yCYTOulQ8UcA9DHg1O/R9tBGWWkF2IOfNT56DVmnqccYrIeqUZmpVfZpay8q1tFix/Sj6wU53m29xaCdk6K6Rdlqvj/rlHoLQvtRfVhAsKmMbtt12gLbcPNVRGTXSyuNFr9VWS72AiR/GBBdfRYtGiwPg3nv20RnGrNPIEaltkK3ZaEOrrTINaVwwEctBtU5R5sknbZ8dE7LwJTeRluPKSnW7ZL5safHCUiyWjTN1xl/mxoCicbhMSaajUSstLu6Z+sPi1DtiuzknTqd+kgd7UyY71XJPmzXb+VIl2uleYu414oYz5OYGnEmTcAIaE/2WiTefshHGoA31nZwS0Esl5IN7t8sZw2+/C1FzLLNjpoObk6Pb02PJbXa4DixfkXqt+fAjZy3dCRn2UpyfdhryS5ZZOtttLwuizE1obUty4xG/6okTuFSzqosWozQ1QFZtjUXr67NstXJETgNMUWaPjQdyRr9Z1Lg02+/UDxaXu+PKtlTb3NUmcnM/dyub+TMj4HwXyVyHS3NEADO4222b6vQ1NIRod2O2bo/dUulQsf12/bTzTgPk5VfKIFcEzCIjnavTACe9oY4Ie3yuuw4RRvuQpwr4sIbTSzi4QKnq6NIb6nU5LT7VSwbDFRvsb7dNP+Ey5/eMqWWddVx/vX7Cy4FWzt1RXNxFH+vWxpZqTrzd3U5UonXXtm7OWGohc4hBjIjlMud0blTRTlXtGttWcPINUFVHpi922HdVdfNV0WV5kQjOIpniJp1PXTd63PNm62cdbKAVb93HbUtGQBfBabmLKMsWx1qy3+6iUaJoNClJdT1IchCplqvJPPZ0R7v1u7HTkRfOMNIIuFbdenv6bPMKxctw2bDu7oHUZOhJfMwhrpgZT3JaqeXLrFjn6ObeYi0XsM7xvn4d6dl5dNuUXVKSo9/mjCdLOBV0BMJBN3Ao2LfjDv20wfrpv3C81b/rTn2Eka8TDtGoE1WfVlNt6czmNGSSeNYZvXTqSb1kf3FPVUd+CUfVLlXdTHRsj5Sp3F4mz0Lay5zyq08huvD/emm/fSzMnHi8pmG5xP775qdPzJjo2qbaE7hesSMFZn4vMnARjq/Qc9ih/YSlF3ZHWJRnir0YAAn5cPj3+VE/YX0zaNlugNEouJJh/gL9S6QsO5Lun5hCGxxeRDQLNA6xFg2mIrHY1+vbzZCxEb89p9lN9P2iRUlnsLrKLil73kkuaglHsMVhVhXlTmHu99n7f8ftU9/XcJJjp8VaLMfOTlfl581L53e7vKJPseRGzPgKfFQ26NLjncn+c3tv6ewYoEceD9OMmdlxz2TPTKP+3LnpmM2era7ltk/UkjwoYRG+IJDfWeWLSaUttMY2oxSE1rh1egphc6fxWBgjenyMQeX4qpwGlX2Ztjyy18HstJ2GfFMTjuUT4HDCcc63Rbvv2k8H7Kd/Y19vnf6UXT2gf5RiOy2UySEWk3P5p7fesj/tJUeV1IYGVYk7+gHGQGWXnfIbrLjTWFxu1W84k1WyE6ziO/Qn/YRzWFXuRP/k0zBhOYK9TEcf6uAFXcS6YdXJSQdPt87Dj0Xo5Vfc3X57bDOz0OXk3KvaOXcuaqSH5li6YwiuRYpP4S5fkcov7nlPPxuh3l6ixYuzt0vlCMdWhqi5OVU+bFlh0wlapvDO+2Ga9W26nDfezm6bkKtaGtKpeJnPq52ShH6OvUdAv/e9112WEjGjFLSG+WFTU9TlRR5TNxIwXYm3oJuMGbUx0otwggWO5/ou9pVFvSmr6TsYbpZA+IEf7G1uxjFzGOu8O0TmSrbSXx7TR1v8UA8bp10NIA7LUX7osF0dynSDahY+2+NwXfle8E1SrJdX7dLhhc5ylLHKKtlbpbM8YfRow+Gtzi4rFkvyLDUeuX/gsI3dosVkOmRJTudUPqtOVM6mk6Z+/fGjWb3Z5phiKYXTZMaixSGyXW7N+rEWM9I+PP1smPocbJw7L9VtENfHL74M0bx5RPYrTaf08plQjqUOTtv4NTs4u6jTmsPLgqhnD3FpuYz8Qq2dD3nVjPe8Bc74tmdYpgJ5HIqPQOqZW3x7ysYC8RJKLFY2TUppSKaPLqQwJjJTbC/kJciEm16T4kW3g4wZxWMc9qcVdeU42thPeIy+uaZjt+YP+ujoX6RfzcWjb3l2uSax9EPWV6h0jQdPDOBQTpqoZ/HYsXp8dq5oY/YBEHbpOOsPfWlr0vGBhd/80pgasgv1Ob/TDv20+ab9KS+RACsntXDgsG+tU5lbmsCqWfPaIG7MYsYpnD5x5dYE3/mrjd+McIR0lOW1baCDglgsnYjdD155Nfst76AD+tLO0XRpzhSVk+TEHU8M+lFWX0ek+oQ5yhHss5w9xk/G/tEF8CEI5zYeR84KsRj2kE4/eZYZAwSLI/UIp/n771NpyL3/QYg6JcdxlOL6DV6EaS+l6wR95ivp9D67twxGIzz5VITwslyn1B6DnPjTj4Cz4K5VbJ8oylXxx5+GCDPIolxcM955N3UdUyHf9xC2cJwZgey//sz1uXSIIlBRmX6xyhWKsWOca0YqiDDT61yaTq0w+Ie5eCQ9InGhjsUsWdEo0TZb9dP55/SSzoxeVWLmadz47M6epSH4R3nbOT+sxUAJ/WSXPXGCnUI0fFgqTXYQUktyy2Frt/3360956QgDnp12GCDhZMqSRye2n5P3JxU3O5nP67S4MYubfWNj7hqWLQvRwoW513dTs8ZwenX5a2qS15PpMyMkngChfk1i0BeXnCzQRejsFKlkjCUNTvydkpOZ5E5NYXmG0zmaypU5hxd4K7NcI2X7KquIttwi83Uk7uDsYWmEkyX4nYEe70riivyHDjPfn3wWpjkO613BH1O86Nct4bj66pnt/uobZzfDbhv0LZX280VehO6eAZo1K0wCAzdP6IQMxPMV+wKjDEHIR1q8qNvRkYohynql5SVVVVb5Z1+EDKfcSoPHaQkK6ByKh4DzmVg8e1izCwTETJGLKoFkxedJ/TTMrWw42jo3PLE/5jiFw+5Gb1DWfw2rH6ALzuulIKw/lV9wBJZxhcODMi/Dbrv0kXAyZbnbJ3ZY6Za2g9I5T2QZxU5jdgqPvGEHlhMhFiHWYt2scS6KgaagCZ5CxN/PC5HsxNbUWFpV+5x++ZVlN7gi0noEPDYHTQ75nEPrrR2iJts+17JsOQ2n+bw/SV6RXKhIi/6QMc+2prwjsZ403pUq9PU3U2/tqm0YUQszubMd1ruiTA7RaDLX3JxM48XVSOrkpllo//2aROMgfjPiiYVBGvz7/MsQzV+Q7M/BAlsCW1wCYxvZdTYUSuqav2CA5KUTy402ApslS9Id+pUrk6rkD2Qslz5M4jRoTtbiVDEQSP1VFMMC1hk4BGpqkheBQhi32Wb9tGvAXvDJ9tZ5JlxyudCJR7o93ZkkF6Ys30fmtQkHJV9r118nXwnu69e4tF3sq+xek1VDOGVeYWZJze8ozsX8pLirjaVI4kM7OjNj1YlZNWgZMDcMRIpI9TVHya+xGKXjD9ZIPke33xC7pFnVyZOJRkQLe21c8wcDjp//brRtn2h35N99L9UDHZMclEstJ6qstLKyw4xr34gRFr05ltwDV8y0WyXJY5UxOz1p4oBJaFmZxEc8JRPnuMlgHCZPCBtHopaVVh0zIx1U/S+ecIAVHwI65he9SGoF0Z5YLJV9h+2Tfb9kSZjaEwMIcHUZA+w5c5BKD7JTHo0my+PSvr+NtidUSS5OFQsB68wrlnbWG0gEamqdL0RujdV1HrC7ws4Fdngxi5WpPWIWIhOPqky33U71OxwezzrxBZnm9q16e1vE7N748USbbmwvJapOPOK2l1QbN17QVDNLKMsWalw8hoesNdcYEBLenQAAEABJREFUoA03yO33EjecKdxUISefcwb1SynAWbHbO7yBKOpiqUa0KemoyLKGK5yMPXdP58dsLWY+t906WTa8MbUvOw2nR5avSotBbty2hMCJf/ttU3U48WSjrb66gVfC0YJTKvjHjLFkW0dBJZo8KdnGJJVIrJmNS+3EbO3GiY8E4TPWceM8RR2co8KxRd4prJBeOtsy8T4FznGsNxb8qxoDB6Q7HF5mA10VhB2qctAbGuwtB5VItZPG9ts442LVIpLbAxq+3IlYFVY0J0u22WqADjm4jxqHWzSVI2+V8rEQCLDDWwiUS0mHg63iUZtcpDML5NZ5kOX7ndax328bZPmYVUEej9AQD+XQ1Z2cJTp4v/RL1F57EJ10fPoLh0cf1Ue/OrYvbe2v31jC6YUO+VE08tmCjnOUTUYpljstYYo2ZnY87O08+ADrhUM7fdNNnOXILyuJOo2GI3L8r/roB2sISu5xbeKpWFfCOcwkaUxiLXgmHjdl/dJPYf11nR0+7LICmfZz9KD9rcr25QWYtQW/2KMXaUwCwBlGWieEQsnf8QsvJn/HkyYIuogtaaNGWbH9uJM0C7t0WWodO+8WPxwgNy+X4j6w1x7O5wxki+U/SCPsvKOFF9IiYNAk8O2SlpYAq42MwXAo0fT29sy2C3kc+4dAoiv8U8CSyxMBvHFfni0rTqty/aJartZitibXuvnWq63JT0JFZGDwQxKyJLzlPnmS8w1f5tNJq7Zn06nLPLkh4Oa8gKMyzHBY7Zoi4dz6X/XhHLt8p9lpO0+h8huub7W1tTWpUUxOxGJJWqZUY+JDKJ02R91pfez4cZa+TPJUZXFpBlnFo9oSUH5i09amqp2kY01xMpc95TQYEk+R5ME3JI1owjE1jB5NNDmHvZhTpXCuEAiww1sIlA0d0cbcLxZG9ZL8GzEiRKFQqCRtL7bRfp8vYvZd9QjYz/bnu+TBT9uE7Fy3ZxP1deJC7ZagY4suT021f9cxL84LeamSmEEXyw0ytbG6Wu86tfMOmaQQdXVnLs+3VDimcPi/n2dJi0vrRi1K/kcx+IjbZiyzS9bDMbucJIcYnMu2JEvTU9l2cHjk0Yr0SjbKtls7n+dVlen0EdEkTddGmzrOFggBdnjzAporZ0Jg+PABahyCjn4mTIJWFs5xRixo7YA9TYk1jUgHIYgbtcoW++NSFV+Q6Ko2ZRugiUfp2fjybSscQSFDLC+oTSw3EHSdWOxS0RxLdeDWmEKOW9YJmR3tIuVPHI9bcuUnbIJmlXh7jGvMzMoaYy1ELUYQNDzWF2l7HIvZKc752sQTIbe2OEsjwu4LqrJMdJ2Bk1c2ZrKDy3JHgB3e3LHjmowAI5ADAtVVyRmRHKrnVWVFLNWBcSMs2mhx2986t6jpR3GjTi/JjRIXzk7CAXAjZWSTG+4ceV1Wk7e2cllVyd44nKiiIvc+VgqWCmpzcKCbE86djtMkqTKTwokXs7smUTqo6BJLQZPiPQQMjkaN9P+3vmx5iObNt5oInVYq/RiNWjR5CYhF0Tva+71Pf5MIPQXM5TsCYd81sIKCIpDPDEptDjfSgjZOUobZYyk7ZJPCCQoSAGOzvJRTW1s8a7/7zp3uWGK2Cr8rsTqnSzHr1dfr7809ntgBoEaxk4TYYspdC8uLG2tPVW/q67TUq2tgTbXzuVBrc5ZbEo4wzi+VfWI21/5bF8uR7HSVnELTa4zztEt6AdUv/VjX+3Xi4xa10j0s1pI68AmRc584OcmiPzAoW9mW7iataA7RR5+kyverfSzXOwTSe9I72XZJnA84Al6sodNpohcOT757xerYmYkHb+ZmKve7TFykhRPktz438rNt3eNGVrF5ezVmcdZIfGlqZWtxb4Drrq1+27wYOMrraYuhX6VTrHmVnSPBm+81UDhZXlzjhE2qeGQBZk9VukU7hWOo4tOhC4ddXNN06uTC05h4QmOvC8fcTpPzy5fLOSstf3jCovCxFBBgh7cUeilANuKRYb7mVFc7S6ircx6BO3MXl6rayL1QVmW7SBfKDjd6mhKPFN3UkXl7ewp/fmD2SLbBKb18edIuzAiBJ9qYzfkEl7ehEI+P3VgsHsW7qeMXr+gP9M+gg+Xjk4bG4e5bItvovrZ+jb4+7wdmToMHXYvEoF18eES3XqnxDZ53NcnrRam1odTtZYe31HuwwPbLW8R4rbpK+nqS17Ldyos28kXJCbNc1iA6ycmFNm8+X65ywS1odcRMnpglDJp9Xtgj9l71QpbXMsR612jUO8liZhwDCiG1ri7VsRZlI6PO19YaxTIQIS/Isc7gTqy1FktUgtyegttWIIV8BykQ0H6oyWdUDXsaFF8lQhkHRsAJgVrbGkQnnlxpjYpHjkKe821SlJZG7Cd+hUDAi/2ia6oLP/udDZtCDnCjjVb7hQOYzTZVuRg4xKWtw1S8KfSBVEc0pSxLpjaxRrYr8QKlnV0exFQW8eVUu11+53Wc2O/m5I673/YPFfns8JZwT4tRda5NyLRlTK4yva4XNZwgv2Z+c3nEXldntbCYOw1YFpTuMaLYBrMpqnRp825stNE/2TrG4UtMxx7VRzozQTryisXj9LEHv20RTpZYe+u3vlKRP4iL4iVKuR1ie8hYTKbqpYUTi+uluOd0aujUk+4vV2fCMc/0u6tv8NcGlh4cBNjhDU5fsCUOCODN+CCt7V1rzX465cRe2nP39E9MOpifkbR8RfBG/F68aBRNzGCpGr/jdv1U7Jf+VLb5RR82bICmrKbndHd16VkhHB497tLlEk6WWAPpZ0uG5+j81CQex8dLxBEUGDYmljUIp1bQgxKvPkX9mxG2Z7I1LhxexXsjqFuhGICjTDcU9kquaxXz2RFgh9eOSInnxUi+xJvh2nwvHDWV0lVWSb2cjRlNnuz1met+kCo73dBralPbJOpmmgkRPF7EvIWWGsWOTue+sdeo0XzpqilqPUK31y/1vHik72U71lg9N6yELcLB8tImt7KiUatGs8vZ3HjCWRfOuyWlcMfRo9PP+1Xz+GRva6vaWfa6VdGo1xJZnh8IhP0QyjKLh8APN9G/YNdUubdTXNh1Z5fqEzsv6Dw2iubx2Dmboya+nGRvsfwSlkq/7ocG7LL9yFdprIvT0VudmJGy8zbm8Ha5XYZOfuyYwt2MdOwpFx6dWS83bRXnvvjdu6nrN6/uNcidHcE+L8V6XT/6oytutT0X2VWVVl13WKdy19f3k9OEjbAn3pnKny33zawwvfNu0on2awmfsC+bPVxefATY4S1QH6gcrgKpd1RTm1iP6lioIG6+aR/tsmMfbaLpWO+1Zz/ttUc/jR6lEOgxOeLyjK7VeAkr2uixkXmImzwp9cYiHJI8RKZUxcb9KQSfMhPGeys4FEre2LyQrBr8eCHbrQxhSyzmtmb+/F2JWb/axMtKbiRi8OTnri5ubMmVd2VLrjWz1+vpzs5j5xCzsLn0h12Wl3n7dSlX2atPSa9Zk3jJUazHTedQU1rbQoOFw30azAv7oOj9D0LUl/9qN4ji4AMCLt0DHywoU5FBuyB5BfNo43H+LjsPkM5bqdC5mvFIartt9GedUSefsMGGqQ5hrrImT0za7LEvlatJZr1h9antEw6JWTiED+PHJ/urEDCINY94kUcsp4kn1gsWQn8p6MDgSXwNrBTsdbJxhY+DjPkLvR2kOdnvF81+rg9rSL0u6erV+bCLrqyg8PFHKYLSE+l25Ozw9vT00jffzqfPv55DnfEchqrptpQVJQiPOQYUn1IsB6CbmlIvsFWVVqtUn4+0Sh2OCpJfj78U6jwjNzToOX7VOSxn8cxIHwRVevDiSSazMv2exXKaeFd+DkxVmfVJJjy9LIvF8pcmtlurqMyvD/O3JBgSxPmuWkbQstIdTj2Kj8bMmxeM9upaMWmSM6fAy7mUqUFBwJXDO3/RMrrw6n/TIb8+nzbZ41d0wLHnmunNf/Qb2ucXZ9NZF99Cn3z5bVDaFkg7ajUeoXtleEO9u4uSV3oLISc6POnw4gs99fXutFYW8SMXDbZZWneWZ+YWN+5MXHjZSWyvlomPy5II1ObwSD9ZWy8VpN1I9CzOjyuX5TixmKUTM+tWSu9Ynbju2mcmRe2ttuynrY0wblzyuiLKCh0X4lxTtUnQxWN6+zICMbhbtFhw6sVtbaV7L+qT5hAwEVLr8LKowEsPDeYqFgJaDm9Pbx/dcd/TtOfhZ9DLr39Au26/Gd1+zdn09H8up+fuu4ruvuFcOuLgPWj23IV02PEX0mU33EOtbR3FalOg9YoLRiGMrKyQfqmFUFgkHW7X2MLha0i8TKcyecwY/y7QOrNIfq751lmOEgoV/8av6huvXtxTyS8WPRTK75wTTl2x7Her1+vlONGo2gJx3VXNwq+91gDt86N+yvQOQF0Og55o1LKppUW/b3F9smpZR+Hci2U0FjX1KGZi/Z5pFNeO/qFxazFB/uTTVDepOsMWZ2YFPgQWgdSeVJh5/pW3003/fowuPONYev6+v9FJRx9AW226Lk2eMJYmrDKKNt1gTcPh3Z0evO1CuuXy0+m5l9+mI07+i0La0CHrzLYVAw3xEox73eVRQ1y0M7VmqM222bFYZ207JTj5utqBnI0RM3zy7hw5CwtYReHUOZk1Ipo7Zk7yhiLNaWYvKDiImVg3M42qnVoK0aZo1NLS0qo/ELBqFP44lJz7wqNbWI1aDm9DfR099M8L6ZB9d6JIpiGwYfsOW21Ej9z+F1prDcViF4NnqPzxp3tz7+lSdsoby+CTzcW8GeZ+1mSvKWb4ahOPuO01GhM3Yjud894hoMI4k8PunXYPJRVYlJjF9UptbY1XknKXsyKAH9/JvTVcM+gIaDm85/z2CHM2V7cxjcPq6ar/O1GXnfkYgbwQ8Ovx/4m/6SMEt8aFI+5qZHoMiceZ+Wy+7s6S7Nzh4E/IZG8EcwQSAZ0nL24Mb262uP0cPOO3O268pUf3ODnHuSAxi6urR4dPOL2Z1lP7MRDJ5ylNpnaNHMlPMjLhM9TLtBzeufOX0F0PPmfuyNAnr+Ae6uhlbj+XaiCArYs02IrCMm6VAULwWnlNdepFuSaxz6RKz3bbpPKr+ApBHy69LFgIfYXQIW76XusKR5z7Lcjro73CoLqIL4V60YYa229UJXOVsQNU7XJ3jWwD4rY2lTZv6B3S6zVw2CE103pqrwci0OeHTMhtyHF7NNTlUP4IaDm8La3t5oto2J1h631PotMvuIkeeHI6fTt3YfkjlGghXsJrbmlN5IIbyS+uyOmgWmzfVzaodnppl7jJ6MqscXCIR48JUZ7vOOmqL3s++0tCXjV4uOLmG20MeaUisHLS18AH1lRHw/BkxbHAR2JNrXVeLF1mxX6p6uJdRP2CluUGHAEth3fDdabQW0/dQv+86kw66tA9aeGS5XTBVVNp36P+RDsceCr9+fJ/0RPPvWbQVwS8ue7N6zCeI5167nUER96KObUAABAASURBVH/7A06ln510MS1b0eJeUIFqyI+f5HSB1LtWE9I6A12LLfsK9XUD9Kcze2ndtZ1nEcsFgJFN1s0/FiuXFqW3Y1gR13yL9bSZdgBIt7j8KW4HpV4ggtliL+QEScboUflfn8TEjXjhNJf2uR3ANDVZWnR/F8JGqxYfg4qAtrtRX1dD22y+Pp163MF0703nDTrAh+2/K309ex798dJbafefnk6YDc6lsUGtc88j0+gro30vPXgtvfHkTRQJh+m6fz4UVHPZriGEAG7KNQ57Qg4hCAabKm5QgwSfEmJ3B9ULRLnclLG3p0/mstgCI9CcGJh5uW54+HBrD7DGxgI3RkNdRUVmh7ahQUNIFhYxcSNeOM3CXpRiYWNRlLNSbQS0HV5ZIvblxZ67X87+nj7/Zs7gxyZWnTiWKsrs6v3MS2+Zu1OMGRWlYQ11dOQhe9DDT82ggYHMP3QZL04zAoyAGgEvnQO1Fm9KahO7OxgPfhwFenRTdpRtJ06aODSuQcKZUGFux6UY+drEjge5DHiEvaq6TYmdQ+bMDQnWnOLBwVpXTtUdKw0blp9NjkKZyAj4hICWw9vb10cffz6bpv73GTrxj9fQJrv/kg4/4UK6//GXaPzYkXT1BSfTyw9fR0/dfTlhJtgnW4sids68xSk7VEwaP8a0Y2XiwxrD6iqpsiL5o6+IhAg0BHmNJXhAQzAFJA4yHWVuAuomxFBDbaWpF7GdBpmYDRR02UZBQwx5YcPo+prU77TWVEVM2ZDjRTBUQJ0ZZFuQNonGoaoyqVPmF/Ta6qSNsFvYJbffEEPCdvAgjwB5gh9p0BCgX9DdxNCB+iLUGLZDrp0OmyEXegQvYkFHWgTYC14ElAs60qCJAD6UQR9oKEdeBJSDLtsieEEHnoIXMWgIdhxBQ5BtF7JBl+XABtAQwAO5CLABNASkQUNAXdCEbNgHenVl2HiikvxtCbqQDx4RoAcyEAQfyiATNOhAXpQhBh0BdVGGgHaDJvhBQ4C9oKMe8pCLGHTUQRplCEjDRgSkEcCP+gioA5oIqAO6sAO8KEMedJEHDQFyQZ80LvXyDTsQwCOHqooIRRy2k4Qdgh82IKAeaNCNtAjghU47vSJxvUMseBGDF0HIFPWAK+SDRw5oE8pkGtLgHd4QQZL6+6wYGciGTUiLAF2gIwatpsq6RsA2yAENZaIebAK/UxA8qCNCnTHYAR0yBA2yzfoJx6+r2zpf0RbQBS/ahzrIg440gqBDTiRUCZK5Nh96kIGNDcY9BumQIRp5pFE+bkwYSWpdGSLURwbyRo1Aiqi7s8KUhRzaX5dYI9zXa9VDHZUtTVHLlh6jPWgLZECnSCOPAHsgA3qRh42IEaAT5UhDFwLS4QhROBxCkiBP1JH5zULjgHLQjaTZFiFDpqNMBPDCTpEXMWjCFkGDXtiOOoImYrk94AMdMfgRIy8CeGUZIQqZRdAJftEfJtE4wHYj4j9tBLxjtM78LPI++mw2HX7iRXTlzfeZJyq2HMMjfji45/7uSNpr5y1o1IgAPm/J0q5sxZjFxRreGuk13Ooq60LQ0RE3qw+rraBK6WYSMX7IoCGEpV8GeEBDMCsmDjIdZW4C6ibEUH1NhFAXsZ1m0uusHyHKZBuRFwHyYHJdtXFFEkQjNn+4Rjshx4sg4yLbgrShzvyrNpwdoUvmF3TZRtgteOX2Q9CEsWETF/AgjwB5gh9p0BCgX9DdxMAH9UUQeRELOmyGXOgRNMSCjrQIsBe8CCgXdKRBEwF8KEM7QEM58iKgHHTZFsELOvAUvIhBQ7DjCBqCbLuQDbosBzaAhgAeyEWADaAhIA0aAuqCJmTDPtCrKsIkaMgLupAPmgjQAxkIgg9lqA8adCAvyhCDjoC6KENAu0ET/KAhwF7QUQ95yEUMOuogjTIEpGEjAtII4Ed9BNQBTQTUAV3Y0d9n/VaRBx11BS9iyAUdMfIiwA4EkRdxlTEgrzAcU5EXMewQ/LABAWWgVUZSbw3ghU47PRI2BvjGtQEx6ooAXoQwLigGUdQDrpBvkFL+0JaJq6TqBAN4UQdpESMN2bAJaRGgC3TEoNVUWfJgG+SAhrIaYwCPNGwCv1MQPOBD2HKzMG31wwjBBsigxD/IRn3IAkmUgQ90kUf7RDnoSCMIOuSobJTpQg/sk+uivpAnp4V+yBBpIQN8KltGN0UgjvDEAm1BBjpFGnkEyIIMYYvQgTLoRDnS0IWANHhEGvLEzDZ0Cn7wIaAccpC21xN0lIkAGuwUeRGDZpcNebAddQSfiOX2gA90xOBHjLwI4JVlfJeYiYdO8Iu2Cn60SaQ5LiwC1hUhi85xY0bQj3fbmkZEh9H01z6g629/mP55z5P03Mvv0NLliUVLWWSUYnEoFKK62hrq6u4ZNF+k6+qsZ1itnb3UI23V1tc/QKAh9EvLHsADGsKgMCMh01HmJqCuIcL86w/1mnrb431mHgekhTzZFtlG8IkAeTC5oyspA2Xx7j5TtpCVb6yyBXZBH0JXT/+gTplf0GUbYbewCW1GfRHAhzLwCBrkgYaAtKBDP2huA/ARMhCLvIhBQxC2QA/yIgi6vA4V9go7UG7nFWXgQ1lNtXXeybygoxy8si1oM2gIwBN8IoCGUF2beg6AhiDbLmSDLsuBDaAhgEfIhg2gISAt6KgLmpAN+1DW3dtPgoa8oAv5oCEgQA9kIAg+0FEfNOhAXpQhBh0BdVGGgPMHNMEPGgLsBR31kIdcxKCjDtIoQ0AaNiIgjQB+1EdAHdBEQB3QhR3NK601m8iDjrqCFzHkgo4YeRFgB4LIi7i7d4B6+9KXP4QifST4YQMC6oAG3UiLAJuh006HbaAjFryIQUMQMle2WvojFf2DOsEnAtpSYzvnUAZbRF+IGHTIhk1IiwBdoCMGLd5t4QjbIAc0lIl6aAv4nYLgQR2EphED1GOcj7ABMkBDgGzUhyzkRRn4QBd5tE+Ugy5+6/MWpdvY0TFAQj/kyrYjDzkoFzJhAwLooMlpoR8yRFrIAB9sQT0E1EUMOviRRp2WVutaAJ1oF+giQBZkiLrgF2WQgXLkIRMBafCINOR1doJK1Gf8F/wWhQjlkIO8vZ6go0wE0GCnyIsYNLtscc1EHcEnYrk90At6VaV1jRV50BDAK8vARBno0AlsRFtBQ0CbEHMoPAJ6Du/YkXTFeSfQjEf+Tk/e+Vf65c9+bL6cdvE1/6adf/J72ucXZ9Ml191Fz05/y7iwWj+OwjfFH41Ylzx3/uJB4d8vWGKmhzfUmXFrR49xIRww0zjgxgIaApxH0BB6jJsOaAjIiyDTUeYmoK6Q09tvOLyGLW2dSeccaSFPtkW2UdRHDHn4MbfHe5EdDOYP15AtZOUbq2yBXUJpd08fCT0yv6B3diVthN2CF20WMhCDD2XgQR4B8kBDQBo0BOgHzW0APqgvQtywHXLtdGEL9AhexIKOOsgjwF5hB8pBQ0Ba0BGDD/TKqgETL5QjLwLKwSfbAj2gIQBPwYsYNBGQF0HQZNuFbJTJcmADaAjgETJgA2gISAs66oImZMM+lHUZg54+YwCJNIKgC/mgiQA9kIEg+FAGmaBBB/KiDDHoCKiLMgScP6AJftAQYC/oqIc85CIGHXWQRhkC0rARAWkE8KM+AuqAJgLqgF5fbzk/4oMJjY39Zp+iruBFDLngR4y8CLADQeRF3N1ruBLSoFzQDReOBD9sQEAZaD3G9QppEWAzdNrpsA30Ybb9mUFDEDJb2622hcJ9gzqFbMRoCwLScoAtoi9EjHLIhk1IiwBdoCMGLd5tXSNgI+SAhrLmldY9Cs43+J1C3Bjkg18E6O42HF7QIUPQx4zpN/tI4CLKwA+5Ii/ahrxMjzvYiLXKy2OWjZAr2448dMcN+4RMtA8BdNDkNPSBDhkiLWSAD7agHAF1EYMOfqRRZ8731v2tt7+PwsYgCXQRIAsyRF3wizLIQDnypsx2S05VFVF/4ncNnFCOADmCH3kElEMO0pANOUjLdORFAC+wEXkRg2aXLa6ZqCP4RCy3B3pBxxpo2CjyoCGA10kGdJr8ZLUbvAiwHbFPgcVmQEDL4RX1Q6EQTZk8jn7y4x3p8nOPNx3gWy7/Aw2rryPsZoD9edsTj/pFnVKPsVzjgSem05JlMWpr76S7HnyeDt5nRwqFrMeOpd4+tp8RYASCicAwD95wR8tqavhaBRxEEI/Qvfj4wSpjhVRv4+4A7pU7YUI/GQ88tRpaWRmipsTLdqIClkcgXWfNFSE5JMLw4UOimSXRSFcOL1q0aOkKemram3Th1f+m3X56Op1w9t/MXRrWWHU8HfPTH1GNtN4V/KUefn7Q7rS60bZdDvk9bfXjE6mnp9fcmq3U21Xq9k+YSDR2TOrIudTbVBD7XSiJRl0wlwmr7g29lJo7Ybx7a73eOUM4me4tSdaIJ3YXwExbkppM4RF1MpeaEs5XLJZKL1ROPLbPZKPKFr9tF3h2xr0bGNXXe3dt9rv9KtxBl79KhzyH0kZAy+HF7OZF19xJe/3sTNrt0NPpzItvphdmvEM7bLURXXneiTT9oWvp8X9fSmeedDiJl7pKG5ak9fV1NXTzZafRa0/caO5E8d9/nE/YoizJQSS2zZFpnPYXgcoKovXW9e6i6q+13kmPRr2TVU6SpqxqPTLPt0011tL8fMUUrX5NtXdOixeNEI5ztg38GzXO63jCIautcW5jkPsubr3jbNwrUlEVuIg1vaml/ubCibu/wFPYqNIaT+CvKi80XTjC+ejNVhcz7bFYNi4uLxUEEqd8ZnPnLVxqfklt/bVXo/P/cAxhHe/MR6+nC884lvbZbSsaPVLjapVZReBLG4fVk2onippqZ/OrqoaeQ+aMBFO9QGDKqgMUjXohqfxkCMdK1bJC3BxVugtJr60dMJyq4F134gmHr5BYFEJXtNGbgVYhbBU6enqs82O4yy/8dcWtekJOEOJoNAhWONugOjeGyrXIGZXiUrUc3g3XXZ1ef/JGc7/dn+63s7mOt7hml4b2utrSsJOtVCEQLLpXt5too1eSgoVPqVjjdibS7exfjWIGNBs+sZjFUegbcjhE1DicCOs+LQvK55jLEga0viuxfANpr0NbmwG4ITQUNg7SXzFnm4UZI5pKbwAhbOc4+AjYTnlngysrIlRRZl9Qc24pUxkBRkAgMHoUO8YCC3ssnINoo/MNOtPlsqbauY5dx1DJD28kwuP1CRPK73yrqbF6sb8/ZCU0j60Jp1STvTBsOWiZsprVp/YZ/qYRzsIah2fGyS7HWUr+1EaeFMgfxABK0HJ4P/96Du1/9DlaATsZBLCdgTUpSOt/o6XwI7fvCZNDz9YmbkI5VPWkyhSP1pt6YkwGIbvtkr9jVhLnVAYMci1qMB4X1ya+bJWrDC/r1QTIFi/b5ZesaKO7c19cxzsVj/3b2izHL5O98sx6a2smztzK6muz25CbZHWtVSdbOMa7MjuyagmpJV5vqHcWAAAQAElEQVTJSZXKuaGCgJbD2xnvpllzFpjhB1Mm0Hprr6YMYQzVhwp6HrRTtf7XA9GFFlEQffX1+V84V1ml8Bd+GZympvzbIMvLlBY34kw8qjKsB1WVMT0dgZYWoq6u5Lk1dmwync5dWErtEFpeVVNt4d5ZwHXD4jrepXixq3+gcL951ZlVWaUqYTojMDQQ0HJ41zSc3BOO2t/86tgHn35DG6+3Bp1/+jF02Tm/SQt1tdVDAzluZVEQwKblmRTX5rh+MZPMUi4TN+JSbkOp2I6HD52dxXdsSgUvHTvlWU8dfvCIZQRdHs0qQqb7UNo1ahNPwVQz1qXdOrZ+qCKg5fAOa6gz95596cFr6Oif/ohumvoo7XjQb+m2/zxpfnFtqILH7fYWgaYmd/JCiS/YiBscamNGc/w4a4YHeQ7pCFRUMD7pqBSPImYki2cBaw4aAoVaq6pqt7imqmasVfUKRRf2OelzuxzFSQbTyhMBLYdXNL2hvpaOPnQvmnb/1fTHU35O1972IG2738n05azvBQvHmggwW/4IbLnFAO2yUx/9cJNUB26sT18/yt/i3CSMGk3mSz2TJ+dWH7XkmfGJE0EJbhCzSrU1qf2ai8VrrG6tIdSp21Cvw+U9T6abt/faho7EWCxkNtbtQNqsVOTDosWW7UU2wzf1jcPyEy1moPOTkrk2f0w1Mz6lWOrK4UUDu7p76PHnXqMbpz6CLO27xzY0smm4mR6qhyB9XG4oPcLGJyp32WmAxozRd2pK8RyFI3bBn3tp9136cjZ/3LgkRn7fSqvzXFYiZpWyzXyO0HgisNMO+k5zRWXO8HJFFwg0pe+d6qJ28VmjLl7uFY5Zl2I9cXu79+0RDn6sJUyxmCU/aJiHI5ZdQT2i34YPT712uN23OKhtG8p2aTu8HZ1x+s/Dz9PuPz2dzr/qDtpt+83o6f9cQZefe7zygwxDBVg4XkFpa20t0bA8R8+4OPLo1vsezdcR9N4ifyRiWYk/klOl2m9IqaWcYwSKj0CNcT2GFZ2Kl9mWLM18C8426IPsXIMbxz1XHap6TVFr2B1rsWIVXzZ6ZvRSa7u5LuGpSyiUatvIkakOcKp0zpUCAlrny+y5C2mng39Pl/79P7T3rlubju7pxx9mfmENOzjIwZdGs1BXCGTaA1RX0KiRupz58YnZCF0puBDp8sp8xby4CzvcXHBFnXKKR2W5YWBWpZzay23xBgHxm493eiMvCFJ0B2vjx7OTlam/Vpuij49fTz8bS/yJRSZ8y61My+GNtbQRZnjReMzy7n3EWbT5j37jGFpafXhGA8VlGsIh/R+sLgRw7vDIqDGPlSb19d7bpWt/Jr6aIbJpf7k5x6tNHqCJEzOfU2I2LFP/cxnRUMNADIQ64+XT8pEj9NoyKctvRk9K+XI12pYdlG9LuWVeIKDl8K42aRW68rwTtUKdX8MoL1obQBmNjamPTbww8bij++j8c3rNF528kMcyCo9A2f2MvD/NXXZKZmdbVxgGk+CNxXDkwAj4i4Dtqbq/yjSkT56cfBdAg51ZGAG/EXAlX8vhHREdRvvstpVWqKyscGUAM/uDQNAulP60Mn+pP3DxFn++2mqqi+715duEkq0vPhUai1lNEI4rcnIaeQ6MQKEQaFlZKE3e6NF5UdQbTZaU1Vb1ZqBqSfPv2MTLGvwD10PJWg7vex9/7VplLnVcK+EKjECeCOywfeFmLPjLZXl2VobqEyYoChNkHmokgCinyIflYIWGBx8r8UKn2Le3Os8dUrywxSsZ0SjRlNWcHd6mJme6V7pZTnkioOXw3nHfU3TRNXdSR2dXVhR6+/po6n+foTMuuikrLzMwAjICVZV8EZPx4LSFQHViP16xP69FTT1WltCWYqXwkot4USwV5WDlpthm/9y+ABus1uhZM3+BM1888VW5clv779xaIt2X/lT1ZfpQmp2V2z0U01oO70/334Wef/lt2veoP9IjT890/Loa9uedNvM9OvyEi+jKm++jE47cfyjiqWzzULkQKQHQKCj04zINk5glAAjUJmatuhJbO9XVu5+v1Zn5GspLG7q7Uzu6NvFp2VRqsHKNjcGyx4010Rxt7+52f+67sStf3nj2ObGcVOgMejMJjjYW7kleJju4rLgIaDm8O2y1kbkV2Y923pL+fPm/zK+r/eyki41Z3JvpnL/eRsf8/jLa/oBT6bfn/Z0mTxhDLz5wDcFJLm7TgqW9pjppTzSaTHMqiQD2EE7mCp8qhZu8F6ioZzS8kO6/jMocngQUesDp57lU78MX4To69Pqtuir4T2EE9uIxv2hZNGql8t371ZKS7zE/HIPmwIkBpV9bx9XaBr25oB+kD0TlYj/XyR8BLYcXahrqa+msk39GLz14Ld165Rm0546bU0VFhOJd3bT1ZuvR5ef+xnCKL6erLziZxo5uQhUOPiNQ6Ju4z80puvgxY/K7CRW9AQ4GrLmGQ5uCPUnk0IrcSOEittPPJQHF/CJcsQelOmeC2N6uM/FEQKfOUOapqbauEfE88CqFe9G667qc5R3KJ0WZtl3b4RXtHzMqStttsQEde/jedNk5vzEd3BOO2p923X4zY3Z3rGDjuAAIyLPGBVBX9irCrn8NwYekvsG6mcmWbrTB0LjwD89jH2oZL05nR2DM6PTzLHst5mhtLeKoLAG/GJzFi7DPcXOzZUQ0asV8ZAT8RKAMb/F+wsWy/USgorR2tPMTCl9l5+PY19b4apq3wgvkSzRp3KzXXy+7Q1jK5399nbuuK+a2icLJ0uk3d61SczfHrJPR/mJdX591Xni5VETMtnYWwYFVI1A6JdFo6djKlrpDgB1ed3gxt48I/GCNfuJ1Vj4C7IFo8bjYA1FDSsTY0dln1SdNyM5TLqCtOtly9MqlPfm2w8ulIuLJn2rGVtDFzG6+tlv1sx/FLislNWjO3izmKCEE2OEtoc4qd1NxAa51OVNU7phw+xgBPxFg58NPdIMpO57YwqzQfT+4y0qtNdsdTHTYqnJGgB3eIvduMd62tT9WKwQEhdQhHukVSiccdSddKroTL9MYgUIjUN9AVM7naKzFQjTaWH6zyeg7q3V8LDUERo4sv/OxVPqAHd5S6Sm2UxsB8UgvtUL2i0yuN/+aaudH0Sp6ql2c8wuBcnR0vMRq9CgvpXkjKxr1Rk7ApeRtns5671iLNZMajeatjgV4iMCkidnvRR6qY1ESAuzwSmB4kdRZg1rM7ZK8aGMpyth+uwHKtk6u0I/47DjWJLYHstM5H1wEGjWdicqq4rahrpZvssXtgeJrF0/2YjFnW5oT9FIfKE6cSNTgsDuNc6uZOpQQ0HJ48VnhvX52JumE1jbNHczLFOW118p+Y8n6WcQyxUY0K59dAoQMt3FlBVG19PEPt/Xd8A9Q+jkQjWaXkOsMc3bJzFFsBEaOKK4FtYmN+4trBWvPhoBwSrPxcbkaAcx+jxqpLueSoYuAlsO74TpTaM+dtjDDsIY66untNdOChnhFrJWiwxuoAmfb0MWTRo10frxdbEiCNHs4flwwMfKqj4bn8Olbr3SzHPcIFGJ7qlIZzESjzviNHZs+iJM5/WyfrKfc043DM+NcyPZX11i2iF0d3Ogu9VliN21l3tJBIKxj6kF770B/OOGnZqgxntkfsu/OZlrQEJ950uG0YPEyqohoidRRyzweIhCkG1JlpbW2zMPmBUpUpKJ0HPp8nL0gnVOBOgHK0JhsL4LWKNaxlyEUQ6ZJ4qnAosXW9Vp3+U65A1TDS89Ktotde6dz5i2ivr6+tAZvsv4PCLO833w3P63MXwJLZwQYgWIgsOrE0nHsi4EPdE6YMEBBfDkMtnHIHwF2AvPHsNQk5DPQF7PmpdbmcrHXtcO7/tqr0Z0PPEcdnV0pGLww452UPGcYAUagtBCIRt3ZW1dnPfJELf6QAFBID8f/so9OPak3vcAvSoHlFmLNqXAwcnm0XmA4hoQ6dtpy72Yxa567BK6ZDwKuHd6Tjz3YcHbjtMXex9PpF9xIV//jfjry1EvpxqmP0l47b0nrrrlqPvZwXUZgyCFQ7fBCUTiUdCZLAZDVp2S2t9bHTxIX8zO1Tn0jHDSnMqa5R6AmsVxCfDDBvQSu4SUCtQ7XKy/lsyxGwCsE7HJcO7x4ge3hf11Mu+2wGb39wRf0r3ufoiXLmulXP/8xnf+Ho+3yOc8I5I1AdHjeIgItwGl9ZLnNmNbUqrtA5SCq6HZJjY12SnHzunYX18qk9qANGJKWpaZiMStfCi9E5bM23mpleR3b28qrPdya0kTAtcOLZq69xiT6+8W/pZmPXk+fTp9Kz957JZ32m0OpcVg9ijkwAp4i0DQi8+yhp8pYWMERqFXM/mbbNzl/Q1kCEAjagAE2FTs0ulzeU2x7g66/pzfoFrJ9QwGBnBzeZStaaOabH9Oz099OCz296S+0DQUgS7WNpfQRjHCEaPQY643hUsWb7Q4GAk5rT1WOt2yxDo/Mz+lUBPAbTqVwzgsEOuPWpACfn16gOURlDIFmu3Z4P/psFu108O/ohLP/Zq7hxTpeOXR0xocAbMFqYj4vEQwP6HIBp0eCB+7bT/XSi1K59kKQ9rrMtQ32euJG5/fMlPw4ecwYuxWlmY9ELGchGrXiTK3ItDQjU718ymTM85HjR91ql1s0TXKxs0coxINb3T7riltYldpyGt32MR8j4AUCrh3ef977P/PFtHtuOs/U/8jtf6HXnrjRXNO763ab8rIGE5XCHmrzeYnAuk4W1uAiayvH+2gBHLG0XqurSyP5QnDr8NXXutsubcMNBujwQ/to5x2TDu/Ikcm0L40qglCnteL5mvHDTfzDaeIEflqYS/8IpzfemUttrsMIlC8Crh3eb76dTwfvsyNhezLAgj15sXb32MP2phdffZ+WLEu8WYBCDowAI8AIFBiByir3o7j11h2g2tqk8za8IZkusPm+qavJZ2CssKrK5QyvQowjORJx34+OghLEmoSt5b69WW1iTTw/bE10vC8RCy1FBFw7vH191uxJRSRCE8eNpq9mzzPbPSLxKv28hUvMPB/KB4Foo9Xn5dOiwrRk5CiiUMjbmzbxP0bABQLyXskuqnnGKpwvzwTmIagm4Qh6ub1ZVQ6DqzyaUHJVnZamlUojGur1Br1BOsdLBdti2ena4Z2wyij67KvvTHu33WIDumnqo/TiK+/RP+563KSttfokM+YDIzBUEHDaRxdtH9ZAtOrk0h8s5LNGHDjoBuGQ6PIzX3YEvHbI3PaRaqmN00uD2VsTLI41VqfBdwpK2bErJqqxFmtCINqo51zmaqvqGp1J3ujRmUqTZW5/E8manCo0Aq4d3kP23ZnGjx1p2nniUQeYH6E49c9/p8eefZXOOOEwaqjPsOGmWYsPjEB5IeDH2shCIRQKD2RVVav5KDxfx3gkbz+XtS+KxRBttDTXJmZJrdzQPk6eVPqDWfSgGHwI5xM0j0PRxZXyNbro4JWRC6YFTwAAEABJREFUAa4d3n1224pOOuZAE4Ixo6L00kPX0gO3XkBvPHkTHXv43iadD4xAqSAgbuSlYm+udgpHpaIiVcLGG6auXU0tdZer1XSMVVKrKlUlQ5s+fFjx218KK3N0ZwljMQvPaIkv1WpM7BVczo6q1VOFPYq13oXVytoKgUA4VyVz5i2mF2a+S09Pe5O6unuotrY6V1FlW6+2xGZD5MdyYtRfkM7xUYm4KahUlMKNXGW7Gzoeu/3hd710uhHs9aqrrceKdjrng4FAJOLODrdbhbmTztyMQO4IRKO51/W6pur+jGul17pYXjAQcO3w9vT00jl/vY32+cXZ9Lvzrqc/Xnor/eKUS2j/o88ZfIEtGE0rvhWq9WvFt4wtCDoCuaw5y9amxkaihoB8DLHUZ9eyYe1nuTwwddIzfpwTlWmlggDbmRsCYcObyfbbkCXz/VlGY2ikjVPEXUNvu+d/5nrdU447iO6+4Vx64s6/0oVnHGsK+f3/XU+9fbx3ogkGH0oGgSmrBc9UXnOWvU+qqgayMxWIQ/eN7kKYU1kRHFwK0d5i6dCZCYw2Wn0Ra0m1UlW3XJ6spbY2/5zAMZOkyZMsrDPxuCnT0elGHvMWHwHXDu8zL75JP95ta8ILa5tusCatPnkcHbLvTvSnU48gLHOY8/2i4reqrC3gxnmNwPrr9hGWNowa7e0F02s7WV4qAvX1wVmKMWpUqm2ZcjU+LyGZODH/8zha4utbM+HvVZnqkbiO/Hzq6sgvVR4/93X2ChMelHiFZOHluHZ4sV531Ylj0ywdv4p1xW9pbU8rYwIjkA8CYrZTZ0eBXPRsucUAXXheL00cn7+jkIt+ruM/ArV5vlDnpYXyBy68lCtkRYcPofNYNJrjvBHojFvnjWr2OW8FGgLWW8eyQYOVWRgB1wi4dng33XBNmnr/szRrzgIaGLBOzuaWVvrHndY+vGuvMdm1EVyBEciEwG679NPhP+0n7CiQiY/LGAEVAmLQpCpnevAQiOT4pbWoWEaQ2I3BzbrO4KFQOIu64tYTk9oSe9m6cAixplJHwLXD+7tf/sRsM15S2/Gg39JBx/2Ztj/gVPrftDfovNOOovq6QP1aTFv5UNoIYLuq9dYpjz0vS7snktavtqo12E1SOMUIpCMwfHg6TZey9pr8m9fFyg8+3p4rP1T9ePE4P4u4tmuHd9zYkfTC/X+j3//6ENpik3VplTEj6chD9qT7/3EBHX7ArowoI8AIMAJDDoEgvUCnBr/wJeFQ7gOjVcaWj8ObXC6QOx6F7j3V0oagOsKrjE1iqzNLXVmZ5PcDW36q5Aeq+cl07fBCXeOwevr1EfvS1RecRDdfdhr98ZSfU0VFhE499zrzy2vg4cAIMALli4DODcXv1otH137r0ZEfpBfodOxlnswIZFoGUV+f3VGyO4tiuUBNGWxXL7dNTmdG1P9S+Slgti3H8FXIjTfI3o9urA6FrCUhbuowb2ERSHF481EdW9lGL776PvX09uUjhuvmgEBQR9w5NKUsqkSj+Tcj0w03f+n5S8h2Q8lfQzAl8KxNMPvFb6vkfl97zQEaOYJo3Di1w1RTXT6z05mwralWY5CpnmdlifeI3MqrrQnRJGkbs2jUrYR0/vHjhkafp7e8dCieObyl0+TyszSfUXaQZsnKr2e4RX4gUKDBgKPp5TBD59gwJmZEAA6SYNhk4wH63Sm9NHZMkZ09YdAQjnfYfoDGSUsZiglFZWUxtbNuHQTY4dVBiXkYAUagaAhUebTWjp84Fq0LWTEj4AsCFRVE1R6/J19XywOZ9M4qDwo7vOXRj65awbO6ruAqGDNvaJ4KtZjJHTc+lZ5rrrEx15pcjxEILgLihTisS5WtjMetXNGXHVhmeHoU1wZPhSaEVdfwWtwEFGUXaTm8c+cvpguumpox3HHfU2UHDjeIEWAE9BDwkyvM9x8/4Q28bHZAMneReCFOXnaBGvEu64eTz5I3yCmHUOvxLHA5YDIU26Dl8La2ddLr736aMXw7dxFNHDeawvzcsOzOo7p6/5okvwzinxaWzAgwAjoIZJsNHF6Er7gN5WtEbZnPNorZaZ1zMx8eN06/B+dbPqZyXR8R0HJ41197NXr23iu1wrCGOh/NzS66ta2D8OW37JxDiyOfx+V+Lsbnl4BK6zz081FiaSERPGtrPZjFyuYYNDXx+kanno82+vOGvnC+xHIFHQfRL1uc2p0vTcxOy3KiUTlX+PRmm/A5XnjUC6NRy+EtjCn5aenojJv7AG+970nml99+dtLFtGxFi1LotJnv0fo7H5MWurp7zDq7HnqaWSY7z/Gubtpi7xNMen8//yhMoPiQEYFtt+6nNX8wQD/cRLohZqzBhYxAbghkc1ZVs7cRD+4CjUV2UnJDrHRq1SZmep0cxNJpRWlYyh+RKY1+ysVKDy51uaj1vs49j0yjr2bPo5cevJbeePImioTDdN0/H1IqGqABqqutoafuvjwlVFVWpNS599EXB/P/e+EN/rDGIBqc0EFgnbUH6Mif99FOO7LDq4MX8/iHgMohbmjwb/Cu0ulfK1lyEBBws7OKjr3GrVqHjXkYgYwIlI3D+8xLb9Eh++5EY0ZFCcsqjjxkD3r4qRk0kGFj6prqSlp14tiUEApZC/2B2hEH70533Pc0tXfEqa+vn269+wk64uA9UFT2odKjraDKHqiANbC6Knn+Bsw038yJNvrnsPlmdIAES5c8z61iR8VzSHMWWMjfyYQJ3l6HMn3oRjy5qKjIrFNejlVILHLuMK7oOQJl4/DOmbeYJk8YOwjQpPFjzPTKtg4zdjqsiLXSOX+9jS68+t/0v2lvUG9f6lfitt18A9MZfuh/L9PLb3xI1VWVtMu2mziJcqSV8o9q0oSkE9E43LF5BSKyGjcI1NUNUC3vI+kGMuYtAgLjM3ylrAjmDGmV/tynkvcPv8HdbtsB2nWnPpog3bP81snySxOBwDu8CxYto9v+86QydMa7zVlcrOGtqa4a7AU4p8h0GLOziO1h7OgRdOzhe9OUyePMorMuvoUuv+EeMy0OoVCIfvOL/UzdN019lI4/an8KhVNHkVUVYYpIi+AqjDRoCBGJF2nQECQyyfwocxMgk4x/kJetHngMVvMP9QR/Cj1inQ6VkRCNbEq2s6YqTILfizhFp5GRZZoGGgdgKtPdpCOGTEOE+SfXMwnGAeUy3Yu0IXbwr9I4J5BRyUXbUC6C4JPM1sZb1EEs5FRXh4RoLTmDzEZCyBCxQTL/RF7YLusTZSajcRB5xMDaIJGdvyJinWsog0yTV6KBXmGch2hJBJVBSATwIgg6ipEXAXmwIhY0xKCJYC9DuRxk+1Bn0EZUBCERRB0bOSvuiepmhLqQo9QZSWKFCuBFsPODhmCnRwwFxp/ZB6gvAngRUCZoSINmlwGaCIIXsaAhRl4E5BGAm6AhBg1hh22IVl8t6RSBhgAeEWADaAiChljYaKejnaAhBp8IsAF0fA5Y0BDL8lFuD+ARATKgF7LtfMhDluBFjDzo4EdeBORNeiS1TyOGcNCNSLCaMWgIZgaHRAANIZEdjECD7kGCkYBM0KHDyA7+oU2Z6Kg3yGwkwIsg0yETNASDZfBPpodC+BUPFhGykdTmm+cmZCCMlF6MRB5B1glJoImw5uoh2nO3EFVXhgd/dyp+1EVAuaiPGDQRhtWHTDkRMAmiESMPXhvZ5HVLN8TxXxEQCBdBpyuVPb19hJlYVRgY6Dd+QCFzPa544QwKRLqurgbZtLDhOlPojBMOo18fsS+df/rRdPFZxxHWAdtneXfdflNT9orYStpzpy3S5Ayrq6CxI5Mw1lVHCDSEKuMHKCogDRpCxLiRC7rMjzI3ATIhB/Ky1RNOGPhRT/CjLmgItYZjix/zsLpKgl2U+DfMaKOXQWULdIRxNTT0whbkcwlonyHC/KuvTfaHkI3yXOSq6kCHqSxxaKiJmCkVP9pmMiQOqA9eGRfkdcLwBksX6gp+0U6IF7JFmVMs+BHL5SOjFRBBuNALurBd1ifKUB8VZJ3AGjQ7v3x+QSZkIAavCPU1FYTzU8gQdPAiCDp4kBcBefAiFjTEwj6U2e1BuRxk+8A/YUzI/F0LnaAhiLZCHvII0CPLckqDTwRhp10n8EBdxIIXMWgIdn7QEGR6xPg9oX5lZcTEEvVFAC8C9Asa0qDJMlAGGgLai7wIyDvRQUOAbsGLWPCjDLpAk/FCGjSEieMjJuaog7wIqIf6CIKGGH0DGmLkRYANoMt9hDK0EXRVAI8IkFFlYIjBvxM/ZAlexMiDr0q6B4COPOiQh7wIgm63EbwIMi6oA0wQkBYBPOCFbtCQRyzwgg7kRYAN4FfRUU/wIoY+8Mt01AUNZeARQdBRJg9sYBOuJ9UV1nVL8EMmeBFGjwqbZPAij6DCBWVOQcVvCjYOsj7Uhy6DTI3DQ8b9vNI879AG0ERAHrwq2ZApeBEDEzs/9ICGcg6FR8A6swqvV1sj1tieffLPSBXw4hmEgQ8fyEAa4fsFSxDRcM1t0kaPbDL5ew0H20wkDhWRCP2f4RBfeMaxVGn7kYJl+cpu6ujqRtIMKzt6CDSEzq7kEgmkQUPo6U3ObMj8KHMTIBNKIS9Rb1C3Pd/V0w9WM6CeKEddk2gc2jp7CZtPrGjtJthlkMw/wetVrLIF8vsTa65hC/K5BLTPNNw4NLcm+0PIRnkuclV1oMNQNfjX3NZjplX8aJvJkDigPnhlXJDXCRTuNaWgruAX7UTBQDjZflFujwU/Yrks3ttNW20xQJv/sG/wvBK2y/pEnepq63zvo6ROYA077Pzy+QWZkIEYvCK0tPdQb98ACRmCDl4EQcc5jLwIyIMXsaAhRvtAR7Dbg3I5yPaBH3mUC52gITj1HfSAN1NAXRGEndAhaIiBB2QgRl4E0BDs/KAhyPSa2n5qi/dRV7fRK9J1p6IiNNin0C9kI22XgTLQENBe5EVAHvTOxO42gg4agt12wY8y6AK/jBfSoCEIXsTIi4B6qI8gaIjRN6AhRl4E2AA6+lzQEAMn0FUBPCJARtzAsN3A0okfsgQvYuTBZ7cFedAhD3wiCLpsYzRKg30k42LWifSQHRfwQDZ0gwd5xAIv6EBeBNgAfhUd9QQvYugDv0wfCFnXBpSBRwRBB38fbiqJAtiE33SHgWWCZEaQCV4EgQF4kUcQNJPZOICWKaj4jarmn6wPcqALBaHwwCDmdlyQB69KNmRChgjAxM4PPaAJHo4Li0DgHV5dOPbaeQt64InptGRZjNraO+muB5+ng/fZ0Zz9hYyp9z9DR556KZJmwGzuux99RZ3xblq0dIX5QtpWm65LNdKyCJPROGy3xQa0w1YbGSn+YwRKB4HVVh0wzv/87P3x3n203TbJwVImab86ro/OPavPmEnMxMVlhURAtYe21zsz1NYSrbfuQCGbpqGrdFiaDOcW1lZXeYfhypWQ6G+odX6ASiq6eMHMblVTkzz3ANoAABAASURBVJ1S/HxTok+Kbwlb4BUCZePw/vyg3Wn1VcfTLof8nrb68YnU09NLpx538CBOSw1H+Itv5g7mFy1ZTkf99lLa/Ee/od0OPd2YSeqji846brCcE4wAI+AOgUpj1lBskJ+tZpW0zjgbL5eXBgLrrJWbs+bPS1P5YxaN5i/D7bZsXjh+4UjINLzfNk4N2+72bm0zheZ5KIbOPE3m6mWEgO0nULotq6+roZsvO41ee+JGevnh6+i//zjf3KJMtOjMkw6nt5++RWTp9ON/Su8+eys9c88V9OpjN9C9N51HE8eNHix/8YFraKdtNh7Mi8TWm61Hn06fSuGwdVER9GLGqtF0MW1i3YVFQHyRqbBac9fGO0kksfPCyUlKG1op3QFWsVBxe212w6+agRw2zHng0Wjbbaem2uYRFwukEtNbXZ3EN1w2HlSJdUKO5pZddzUOq6dRIxq14MDyBWxfFm1s0OIPKlOmPQqDanM52VUTgNnKmurSQtTNjb20WlY4axs9mIGUrC3JZG3iC2QlaTwbXZII1ErLOCZPTDq/JdmYIWZ02Tm8Q6z/PG1ukB43DVDpXEgwWzlpUvDsDfJep/K5Fm3kmSZPf8geCGts9EBIkUSoZj6LZE7JqpUdu5JthN+Gh/xWwPK9REDf4fVSK8sKJAJBesTVUF9aV5JIAH9J1SU26xvIH0UWo4LiXI0Z7fGAq7R+fmYvBaUvTGPK4ODmyWG0hAdIZdBV3ARNBAJ4m9a0nNnKGoHKivxn/ULGTXu4bd1aWYOWY+OijR47SznaUQrVhFOVr63RaL4SUuvX1aXmOVdcBGrrjItPcU0oqHZcawuqkJUxAjkgwA5vDqBxFf8QEC8ENAzL/YYhnJJGY9YhiDOv/qFXPpKj0fJpi25LGodgm3WxKQZfPlu3VXm4vVgx2s46GQEXCJQMKzu8BeqqSMRZEd/kUnHZb59+2nuvPho1kmcdU5EJRi4csfpFDEyCYVWwrKiR3uLWsSwblhXWB+8yilK9tMgzvxlhy1jY1pb7oDujYC5kBBiBoiDADm+BYN9wA8tRKJC6klUzedIAbbOVP1i5dURKAcTVpwzQ2msOED4yUQh7NzLO48MO7addd3LRRzkYFqBd/1xbL7+Qp1NZ9XLQyBEWxhusn315T61iScPYMZYMHTv84fFeP14S9cdWlsoIMALljAA7vAXrXe8v/LmaLh75o/648cGxC/b4Gdw6In7a4pXsVScP0BE/66MpqxWuH9dft5/83vd3+PDCtcervvBaToNiP1Wv9XglL+qw28akSUQ6M9RubBgzxg23mrfaxy3NqqvKd3a4ooJ/m+qzKnsJcxQPgXDxVLPmICAwzqObR65tkZ3vXGVwPUaAEQgmApilbvB4m3O3s/+qga6fg7a6utycwkhiyVAwe9Oyavx4Ky73o+q8Kfd2l3P72OEt597ltpUgAmwyI8AIeIlATQl9UWzChNwcZS/xyiZL9SJwNJqtZmmVl9J5U1rIFs9adniLhz1rZgRMBLye5Y42Bv+maTa8hA519f4Zu8nGQ6e/VOuV/UO3MJK9Wh4RhO29og5LUwqDooOWMiBF+XocmF5khzcwXcGGlDIC5XojL+U+8dL2ykovpaXKaooOHYdXfkxcX18+7fZzeUTq2TI0c/k4jdU15XOeDc3e967V7PB6h2WgJelckCORknvRIjCYl9oLRoEBjg0Zsgj8cFM9R8TrJyDFBFx2+HO1gx04d8jV+vhyYm1N0pampmSaU8FEgB3eYPaL51ap9umUFdU36N2A5DqcthDYYH3vsItGLZl89A8BnQGgf9qDJblYN+qKEnhBy+uekh2kFNkh/etHrdKBS5FY8pkal/tZF6PBNbXutFZV6vezO8nMrYMAO7w6KA0RniCsHytVqKesyheyUuo7nQFgKbXHK1trpRkrr2SynMwIbL1lv7mXdmauoVfqxWy4Lmr5LJkQOnS+rrfxRtn31BbyOPYeAXZ4vcc0sBLZsMIgUFNVGD2lpEVnRjXKL8sUvUvdzlh5bXCQZvUKZcs2W/dTrcuZQje4i0FMIR1IN/YFgdeLNfqjRmRvybAGXjaYHSX/ONjh9Q/bFMniopNC5IwvCESbijvbqvrqlS+NdRCa643azxl+nlF16CgPSdEyeRO8gE5ZVvSDZEtWYw0G1e9eDGJqFNuzedXOUnYmdtoh/5nX6mqjExz+Jk3MX7aDWCblgEApn6M5NLewVWqkNUheXVQK2wJ/tOnM9uWjuXGIf6Vr3Ljc0Cs0btFobnZyreIh0KTRZ0F9qSqfQUG4yOuNdWzP9R6jmoxxe50e7tGgy61ep1+D26/BDfPxq4YVEScLmVYMBNjhVaHuAb221vnxxVD5Uo0KQp7tUyHD9KGGQCnujLLzTplnrGrL8KWqsUX+ImUxfhc61+nKKu+fpunozYbH+uv2U2NjNi4uH2oIsMNbhB5fZ82+ImhNqsx1JiApgVN+IiA/GfBTT6nLxmdrS70NpfK4U8bZeRgvc5RfWueFpFxajWVE0RJ2zMaPy83hrfV5b9zVpxCtPiU323LpR65TGgiww1sa/eSplTWKtVyeKmFhOSPAAxI96Ib7+BhSz4LCc+WzXMDN9mO1vFtDQToXs5BweguizCMlXlyfvFi24FFzWMwQQsAjh3cIIcZNZQQYgZJEYMzo0p/xqS3QcgEvnJpsJ0lFpTVXPKwhGyeXywiEqLjnca0Hg6EIr2uVu5TTBUKAHV4fgda5aTRpvATio4kpoqurrBuQTHQzKyTX43QGBKRN5qPRDHxclBGBqmrrfA0rrmLDh6VWr69Pzeebi6i+TJiv4Az1J4z33tnRuU5lMCnnookTBuiwQ/toz90zrwnOWUGZVsSscKamqRzSispMtQpbNnx4YfV5qU35e5Gu69Cn6geUcSgOAopbRXGMKTetpbZ0oK4u/WZa6Df3y+0ccGrPlFWdqN7RKiosWZEy/3WvMmaANtsUwdlhGjky/Xy2kPHm6Oeb3SoL85mlrqxwxqOm2pmussFL+vrrDlBjY/H0e9mWoMhSOWReD/iC0t5C26FyZKO23YFU/VBoe4utL0j6y/yWGCSovbdFrP0q5g3L+1aVv0Tc4MM+zg7usF0//eH3fbSjB3tLBrk3wsZj0QP366ONNmCHSaefZIennAdD7GjonA3B4tHZdi1Xi63nQLnW5nrlhAA7vCXcm5tuPEA779hPG67vPMNVGk0bms7KZJ83Iy+dmXmi6gKtSy2N30NhrBzWUL6/u5oSfikXS9xUS3Sczox8XmJ0kleOtGI8iSlHHMuhTezwlnAvYqZw1537aeLE0m3EpEmlaztb7g0C/Ma2Nzi6ksLTXq7gKiSzm/WttTxYzNo1bgYQWYX5zcDyfUWAHV5f4WXh2RAIh8t3pilb24dC+aqTB2j0KKKJE4ZCa923sc7jF+ncW8A1/ESAl1ekossvQafiwbnCIsAOrwd4T5pMVJnhDdho1AMlLEIbgcrEbhOFnsTaYvN+2tII2oa6Zyy5Gtj8/dSTemnNH6Qvu8Fm/liHXuvBNkcyMF7Lk2V7nd5p+yQu+ABBKFTos9brFhVWnp9rP71oSSkvr/Ci/fnIqK7OpzbXZQTSEQink5jiFgG8ACK/EOK2PvN7i0BD3QBttWU/7bxjYb9ot98+/bSvEXJtTU310Jrt/vUx/XTm6b3k9SxYQwl9kEJezgFfF8uUcj1/ilFPDC6LoZt1FhaBQg8k6+qytY/LGQF3CLDD6w4v5i4RBH78o37adJPSciCH2uM+vHDT4MMjfT9kZjvtvXbas+kLQnlNLREGl0GwhW3wHwGncxwv2fmvmTwfFBfCZtYRPATY4Q1en7BFHiFQamJq+BGeY5fVGo6VY0GAiMWYncfLTdiaTReG4R7PfNd5vBRFtx3MN/QQKPTs8tBDeGi0mB3eodHPrkfIo8eEzJeNsDH8EIGImxkgBMaOSc7OrzJGWuc6RNfDr71WEgPRTVhKNXliEidBV8U/3GyADj4gXY6KPxt90iR93dlkZSuPRrNxcHkWBLiYERjyCLDDO0ROAbcj5Pq6AcLLRlgLO0QgCkAzC+dABKCxaSY0Sk5NsdfvybbIhkYbvXEYN1xvgH6wRj/pPhKuqwvey2y83ZN8ZhQuPdSWPhUOWdZU7giww1vuPazbviLxZdrdokgmFU1tHb+kUTTsC614j9376KgjvHGeC20762MESh2B4cNKvQVsfy4IsMObC2plWKe2tnCzi5FIEsBivGCU1B6sVFVl4fogWC1na4qJwMiRQ/O8y/TUy6v+iESCMzNfW5O7LaWwjl6nz7ATCviG6jmPtg/lwA6vx71fqp9JHTvGYyAyiJs8kWe2MsDDRSWIQENDCRqdMHl4GX9mONFEM7IvH3HadcBk9PDg1RZ5tR68IChvgee2iV7viZuPLW5tl/nHraI/uKuqzn2AIOvkdHAQYIc3p75QVyrWD1ltkVVSLe3xqlqfaHHykREoLgKYhRk/Tv/GVFxrLe2jR/IgzkIiv2MhnzRls9TNWlm7M51NtnC2ca5n40U5toBD7EfQWZfu9Xrt2jxmm/PBoKpKv3aQzkV9q5kzEwLs8GZCx0VZXWJJQFC3lqqtKS0HwgX0rlnd3pxcK+AKeSHQ2Ei09lp8vuYFYiErZ9G16cb6fbnK2CzCyqS4ptoaIDUO18emmE1fdXJp2FlMjFh38BFgh9ejPvr5Yf30m1/1kbzWSSxviEhrVj1Sx2IYgbJDoHbwsW1+N9dw2KofzvBEUsywBQ3EaKNle9DsyseeXXYqzBcPo4odNBql3T/yaUeh69ZIT+W80h2NZpck8HL7G0n+ftU6hvHLYmpwuMR3BArh8PreiCAoGG6M1CeOT71ZYb3QNtv00+67WKP5INjJNjACQUUAN9htt+6n7bdN/R2l2pupzOLcaYcBOu3UPtppR/XvTufmbEnjY5ARKJUZUjuGjVFrNDZmtL0kmR83LpnWSXl9TruVp7PsYtSI7L9fnbYGkaeiwurTINrGNlkIsMNr4eDbce89+mn99dQ3Xt8Us2BGoAQR+NGe/bTl5qm/l9ra5I1Ed1ePpiZ/bqz539RKsFMCbPKIEQE2LoNpTdEBOv+cXtp3H+9mv1UOZ7QMnxpkgNa3IkxqZRI+YcIAVfPSwUwQFb2MHd4idEFdffIGXgT1rJIRKCkEqqRHuxUVxTFdzHbhpqZyLIpjGWstJQSi0rKLiAfnsmrZAzte3p4Vm24yQD/c1BpEV1ZZsV0DXkCsLdLLeHZbSiZfYEPZ4S0w4FBXyfutAgYOBgJjRidnM8eODdHYMQO09v+zdx5wUhTZH3+zOe/sssuSREmiIPHIEpa0gGIABFFBUBADKgoiCKKo6KEomOAQFVFUuBNPOZBgQNBTVPTUU1T+6hkxIoIILLAz8+9XvT3bMzuhZ6Z7prvnx4fqUOHVe9+q7XldXV19Yk2clAX/TUCAp1vEpeaSAAAQAElEQVSwGvyjZtYXU1k/qwctQwHxmgeaEcSxCcY4EU6m0i/9dYLj5U9Ev/Pc6hfU9ZMISfEiAIc3XqRRDwgEIJCrGu3nZXAmX+aiU7sHHkEIUBxRBhHglTz0Xns0ElXZsc72vsQXSUlz5mV7tCxt1atX+Ju9tLTQfx+FGl7M0kIpJ1tLrpo82Rjdq4Gh4xFEgYBeBODw6kUyCjnxHBFQVoyIQk0UAYGkJJAdxOFxUGiHSw9YvAxUsNE7PeTHW8b0qS7iEK7eVA2/SM4C4/mH09PI9DSs6mMk3rjLxm9v3JEHrVDD5SVoWSTESCCeIwJm/SBGjAiJCBJAIL4EOneq7XDlF8RXB6NqM+o6kZfrodyc2txC2ZFtoxHuUHb6p7VtE36U279MNOdwxEJT46c8oXNoSzXqb0pb7cilJgCHV03DxsfZeNxm49aFaUYSSPEbceva2U0cp/5EtpbH9UbqqJZdt66DQq1BTCH+mWl+splGuON5/XQWhmigcEkRpFvJEVO/7BeBicgKAj4E4PD64LDvifriptedq31pGW9ZRrrxdaCG2Ag4q5dzKvBbLD9daru5s6vonOHxGYmL1IocaSQ11BrEkcpDfiL19RM89CeA3yT9mUJibQJweGszsXOMqWwrsMlj4Gig5uZFUwplYiGgOLCxyEimsk5nZNYWRpg/MumJy82j+YmrXa4ZfVfmoNcWDrZeJK0lBw6vtdpLd23z8z1CZqOG8l6cGLxRfhjN9BjYYJMhHgQMIWDnL1cFA6bf3NNgNfjGN24Uv2ujb804swOBeE1RsQMro22Aw2s0YRPJ52WW/Bfub9bUQzOvq6KB/c35eNZE+KAKCJiOgF1eltMKlle2qVsa2AGNtyOsVWe75Qs2txqj0IFbmpfkC5yC2HgTgMMbgrjdkm6YXkU3zqyqZVZODhH+KAn/QMD2BBo2kG9sj2tkTVP55bFUv5cIFUv0nmerZYk0pW477TMzQn/+IytT7kOhbK5THPimJFQZrWn4rdJKCvn8CcDh9Sdi43OeQsDBxiZaxjSMhsS/qU5obNyPcPytia7G0lKiW2/iJzquSAUkNH9WZuxtF2xd5WCG6fGOAT/O9n+qFqy+RMX7j4zzS4+x6JKVTdTIwGkgyjS8WHT0L5udKTv5sd7k4LruT9Zc53B4zdUe0AYEEkYg2+brnjqLYneajG4cu7dBtPyCPUaPRF5BAj5YwaORRr4foUd/0XtknJe2Y7vDtY3TGS5H4PSUaNfck8Tl5QW+BmRle+iC81w0eqS1bgQlk/A/AgL6ObwRVIqsyU2ARz3atfFQl07hH40lN6n4Wl9aN/CPQXy1SO7aeHTMqgTS0+VRMrN+KexIZWL6d2qqzMWIdrVyfzGCRziZSh8NlK9lCw+VlYXvI1ra0+n0raHIAjfbvhrb8wwObwLatbB6XU8jHs0kwJyIq+S7/xHDXNSzBxzeiOEZWCDWx3kGqmY50cmoMH9NjT/K0bsnRsnU7c9c1OexHifr70as3PQqz05xYUFk0iLNH5l05NZKAA6vVlI65uN1HW+eXUUTxuGHQUesEAUCIJBgAqcPcVP7duFHyRKsZlyr5+u9UqH/fFklPpJ9Mt6YKktZRsLJqLwZGUQYsY2IrmkyJ73D6/F4qMoVf8czNZUoJenpm+bvAIpIBPSYJymJsd1/vIiS+CbNzU28DnpooPd8WT10SiYZmRnyzZgjRd4nk+2wVfK5kh3C+pe2U8Xo62ph6DfyWmpdPp5+33/Am1Z55Ch1HnKZiHe78QfjBYMDWxDQ4wWYqECgEAiEIcCjamGyJDxZj5Uk2AjFGdNLHsuMR0ixgBP5lw4e6lfupjattf1+OxyOeKBDHXEikLRjjN/u/pkGnTedZt6xLCTqVc9v8aa/8PJbdOhwpfccByAAAtYk4CzE/HFrtpw+WvMHLPSRVCNFryck/ELvyBEu6t3T2D7KLw/XaB/7UZtTtDmRsdekTUJJSW1+PP+2vLdb89PV/PzaMrTVHn0ulDSOQNI6vA3qldDj999As6eMDUr3guED6LHVG+ngoUpyudy07Ml1dMHwgUHzIwEErEigqMg6WidC10wNa8DyUkzWoWhvTbU8qcjOMvfIHY9AqqdxqJ3p7Cx92k/vwcvCQiKmmpNNhv7TugpIfi5rE5sqKTEsgRZbzShtBIGkdXjTUlOpXmkxFRXmBeXao9MpdHyjMnr2hW207a0PKTMjnfr2aB80PxJAwHgCqCFeBIqL5ZpycsL/cPJHDYqcHrkAtgkloHYOWRG9HESWlaigtsHfvmh0ys4JXMrpDByvJZZfpps53UUTxvt+zTPYTWq0Uzbq1zPv35lyzdDCC3niT8B2Du8PP+2hh59aHzQcrjyqmbLD4aBJY84QspaseJ4uvfBMcvjd8RXmppOdQorDQfk59rJJaZ+06vUwszNTDW2zAomfhDFkHZkZqcT/MtIcIfMpuhu5Zx1YF6O5RGpDblYapabI/ZH148C6RipHyc/9mmVwYNlKfLB9z64pnJWOa6CtjeoUy45xQW5K1G3K9nGl3FfVeinx3G/U8XXryP2opMi3T3M+lsP7bKmvZaQH14lZcF4OnF+RL6HnKBGUON5zHo5knfhc78CyOajlcl0cxzqp4xVdOI3bV0njcyWU1UkX7aG201+OUk69b1iWIkQobcEMsySW6jzq48zqdYiLpScm6nhFdxam1lGdJ9wx/21yeQ58rOQvK5V15PiCvJp+mqsaZWVGSn62m/NmZ5JgwvGsE8dx4HSO48D1cBwHtoHjOKg58rk61CtJoxJnulc2p3FZlsGBZaZK12GWkacageV4zsuB9eW8XI7POah1zMmusbMwxO8vy2Q5SvuxnEhD3VKWQKTWhWWwTE7xj69bksLRVFrHV8cWTeX4ls3SBBuRCZu4E5BbIe7VGlfhsSoX7d13IGjweCKbk9OvZwfKyc6S5P1BFX0611K8ysWrPNgneMgjpm/YzS62p2ULotRUouZNPcTnRgWXW6IoDUKEku9wSBmk3pSRSYbqEkoHJU1SV9KEyC39aShxZti7PTIjl/Q3JhSUNqxrtLqp5XAbhZNzfGMP3XMHUZ+e2tqIb3IkFSkzO/r+xfaxDDZdrZ8Szy/LquO7dJJ17NbFt07Ox3J4zxxDtS2z4Lwc3FJGRX56GsfIQYnjvbtaGd7xud5BrtGXOdfF8dwj1PUpunAat6+SxudKUOLSM5QYkq5yvvKVPOq9wkVpC/7p8Egn6jzq44JCWX4tHTlCTpKurb7tpC4f6lhqlmoJ5PN3qrY/U3UtUY8Ccx5FtqJKkTSSq8QxN0U4pyvxmSpezF+JV7hwGSUu1J7Lcl4Owg6pEtZJQslRInC8IoPTOJLLKXEZGdLFiSOloI5X0gPtWaaUnbieQOla4v7SzsEiyL9OlskJ/vGK7k1O8G3nwQPlv1OeV8z1clmE+BOwncPLUxBmTD6PggV2XiPBzFMfbpo6jm657iJKT5O8Jb/CByuryE6B/5APHXHZxSYfO7p2rSJe/zg1w/g2424Sql906VJFw4e5qUf3xLNWLsBHjiVeFzWzw1I/5B/XQ0dqHpGyruo8kRyr5VQe1d/WvHzpl1xq+Fh0rFtXXiKR7VbbxjIl0XSsyu3Tp9V51MecT8l/5JhbuqkKXo5ZcF4OZWU1+Ro0lO3h+ECyWSd1vF7HXB8HtTyui+P4+qSOV+zkNG5fJY3PlaDEeVJq+pG/HCWPeq9wUdrimMtNzFKdR30cTEclnvVR66guG+7YkVqju/rvVG0/HytyWGeuj0NqWk2bst0cx+lK3szsGtmcrsRTyjHOKgLboMQrXDhBiQu157KclwPrznUflv7+eM9xHDhekcF2cByXU+Lc5CLlRUN1vJIeaF+/wTHi6Q+dOtXYHyhfqDjWy18Xzq/o7q+LojvvOV+wwDIR4k/Adg6vVoR8p37sWBVVSSPCXEYcB1mP99TOp1Cvrm05GwII6EIgVfrLa9/GTbk5NU6FLoKjEKJ8CaqgIPG6RKG+rYqUlca/DQqqRyYZZHpa7fqdTk4xfyio/oKl+TWNXMNo57tyTdIDSt4RUfQ7Z2HtfhG9tNolnRpWTTmxWWQ6OJ1El09yUeuT3bUrRExSEpB+dpPSbvry6x+o/cCJYlmyn3/9XRzfeOejyQkDVic1gX593XTNVS5q2iSyH5R4QePHr/GqKxnr4TmndrCbpyspdijTS5Rz7K1PoKTE+jbAgsQSSFqHt3mThrRz6wqfMH/WJG9rbHlmEfXp3s57rhx069hKlLHjciWKjdgnFwEebS4uMqezm1wtAWuDEYh0hLNQNWodTKZV4+vFaZWCHNVLZbGwSk/HtSUWfiirH4GkdXj1QwhJIAACIGAsAeUlJL45MbYmc0pX7PfXrk4d/xjdzk0pyOkkqlcWvQOZpnoRMZyBejmquUGWQAtXP9JBQG8CcHj1Jgp5IAACIKAzga6dXNSvj4u6d3PrLNna4o5rFJiHszB6p9DaRGTtgzm2ynx9ORe2IJBcBODwRtveKAcCIGBZAgWF8nJDVjGAF7Qv7+Oh9HSraJxYPfUanYzGipQQv6p6vEAWTCf1KHh+hC/wOZ3BpCZ3vHLjkJWV3DdQdukFIf407WIi7AABEAABXwLKOsi+sTiLloDZyuXlhb6hiXROcCT2hRpFVTulkcjUktdIZ1pL/XbMc0prN02+1EUVAwI/STCyH9mRZ6JtgsOb6BZA/SAAArYgYLfH6IkcJQ3WIZQRt2DpWuONcDzzc+VRwFAjvFr10zOfmdoxLVVmpKd9RssqK/NQsLnzWEHGaPr6yo+Tw6uv0pAGAiCQXASUF1/s5lSauRVLis2nXajR00RrmxrBC2F66arF4VKv9V1UpFfNRE5n5LLy8rQ7vPnVH3KJvJb4lTDixil+2idfTXB4k6/NYTEIWI6A+rOweiifnRX6kXcsdYSd7xeL8EjL8qezIi1TnT/Yj3mjhkS8zu0JjbU7L4R/MREojNC5LNDZWUzEKHGwUdWYQKJwUhOAw5vUzQ/jQSA5CRjplGZlRs80I1N2xPPzopfBJXt0c9PwYS7qeaqbT3UNLZq76ZY5VdShvf6ywynasEG4HPZMdxYSNW5Mmr8apve0ijyd1uStV0/u3/ZsJVgVDYF4loHDG0/aqAsEQCAmAsFGHWMSaqLCDep7aOz5LjptiCsmrTIlp7t9Gw+lp9vLwcjIiGxU2emMCaNpCvOI+sTxVTRoYPxvMvSCwCtHBLvRLLRJO+nFCnKMIQCH1xiukAoCIKALAV8h2Vm+55GcxVJWSz3Z2bIzlhrjizktmntImbOspV498zhSzOkgswPPdqam8ja6UGRDp8qRIve56IiELqUXL+Um1b/t9JxPHNoSpIKATAAOr8wBWxAAAZsTUH54jTKzWxcP3TSrinr3NM4JMUp3RW5+gXJkrj1P0ZDZRjbC6f8Dp/ej/kRT4icC0eigxBRBIwAAEABJREFU9ebP6YxGum8ZrXX5lrLqmcF/+1bFYhK9/a8HJlELaoAACICA9QjotWxWoix3kHl/sKNh276dywdlQbVDr2WedVa2PNqdka6NCb/Mx5Xlxjj/mmVoDdEwYdlZ2bw1T7CLU9yxPVHfPm5qdbK2PmOeFkgOTeDwJkc7w8rkIAArwxBo2sRDLZpHNkoYRiSSTUzA6ZSdVn8VW7cO3wfqlXmoYoCLyvtoc164Xw3o56ZePcLL9tdHj3NnYU29wT6IUKc4sC3OwsDxeuilRYbRT1+06KBHnkKJIzu8ZXUTy1MPW+woAw6vHVsVNoEACAQkMH6si8aeX+MYBMyEyIQSuHySizgYqUShxmW7evbwUKOG2p2X3j3d5D/NIJjzaaR92dWj0/51FBXJtsQyzzzSF8z4hTvWw5+D1pFzLsshI4O3RP5y5NhAW8SBgC8BOLy+PHAGAiAAAiCgIhDv9VDr1/MQB5UKlj484QRZ/cws2dmUzxKzbdqEqEN7D7UO8sg9209HPUZ+mzaVbzDL6vranJPje66cNZGewrRv66HmTX15ndpd/szv4ApZnpIfexDQSgAOr1ZSyGc7AjAIBEDAl0Bm9SiaOtYKX7xS62u243plsoOWbeDHTvxtdqqmN6Rn1Ezr4K+uDTvTRc38nEmlvLIahnKuxz4/j2jOrGM07Czf+dTBZPMHTYaf7aLjjvN1eDl/WZlHfPSEjxFAIFICcHgjJYb8IAACCSNgl7l+CQMYpuJgo25hiiUsOTuGZeoSprSOFVdW1jizgcTyqhQNG3gCJfnHGXqenuYg1oVU/6z8t8xOPJuSiC/Qcb0I0RGAwxsdN5QCARBIAIGsTHm0LAFVJ12V6lFCsxrPTlNxMdEJx5tVQ2P1KnKGdmaVVSmM1SI66Va+WenezU39yl1YjSG6pk9YKTi8CUNvsYqhLggkkEBWZugf9gSqhqoTTOCaK6vo4nFVCdYiePX8AQeeQtCyhf43a+zwK6ONag0KC+WznOqPochnJts6rPs3zS8ylvf2YHqFybpUOHXg8IYjhHQQAIGEE8jP8wgdol13VBTGJigBftzs/yWsvDw5e0kdmb18hi0TiDSMG+Oi04fo7/CyHqlpvPUN/BWzqy6vorHna5s361s69Bk78J06uolD6JyhU50Fcr9yhhmlDi0FqSCgnQAcXu2skBMEQCBBBLp1I+LHiPXrJUgBm1c7Y1oVzZjm6xyVlBBdd42Lhp5mjKNmJNKaJwKyU2VkXWaVXVpKlJurTTt2kLXllHOdOdRNvASbfBbbNtdkH8GIzRqUNjMBOLyGtA6EggAI6EmgRTM3DalwU6DRLD3rSVZZ2ZLTkeW3JBWzKJBG4Xj0l4+tFE5p5aE+vd21ViPgR9FsT4MGVrJGm66pqaFfYNMmJf650gOsDBJ/LVBjMhCAw5sMrQwbQQAEQCBRBBJQLy9p1b/cTfn5vpWPGuGiuTdWkfIRA99Ua5/lafyYhrWthPYgED0BOLzRs0NJEAABEAABEEgoAeXDINk6rPMb6dSGhBqOykEgQgJmcHgjVBnZQQAEQAAEQAAEmMCY86po4ngXBZqSwulagrPQEzCb8rJowEREgoDFCMDhtViDQV0QAAE7E4BtIBAZgTp1iBo3DuywapXEy5sFypuWbty84LQ0WXZGemy6B9IbcSAQiAAc3kBUEAcCIAACIAACSUIgp/qLdTWrWxhveIMGHurdy009ultvFRDj6aAGQUDnDRxenYFCHAiAAAiAAAhYiUDLlh7q28dNbdv4jrbWKZad0ZISea+nTbxaxoC+bmraRE+pkAUCwQnA4Q3OBikgAALmJgDtQAAEdCDA83/Z4W0ojbqqxfXu6aFbb6qiRg3VsTgGAWsSgMNrzXaD1iAAAiAAAiAAAiBQTQC7cATg8IYjhHQQAAEQAAEQAAEQAAFLE4DDa+nmg/IgoJ0AcoIACIAACIBAshKAw5usLQ+7QQAEQAAEQCA5CcDqJCQAhzcJGx0mgwAIgAAIgAAIgEAyEYDDm0ytDVu1E0BOEAABEAABEAAB2xCAw2ubpoQhIAACIAACIKA/AUgEATsQgMNrh1aEDSAAAiAAAiAAAiAAAkEJwOENigYJ2gkgJwiAAAiAAAiAAAiYlwAcXvO2DTQDARAAARCwGgHoCwIgYEoCcHhN2SxQCgRAAARAAARAAARAQC8CcHj1IqldDnKCAAiAAAiAAAiAAAjEkQAc3jjCRlUgAAIgAAJqAjgGARAAgfgQgMMbH86oBQRAAARAAARAAARAIEEETO/wJoiL5mob1MkmO4XUFAfVK8qylU3xbp/6xdnkcBAYxvi3UVKYSRlpKeAYI0dnbjrlZKWBY4wccyWGhRLLeF9P7FZfRnoKlRRkJnV/JPxLCAE4vAnBjkpBAARAIGICKAACIAACIBAlATi8UYJDMRAAARAAARAAARAAgUQQiLxOOLyRM0v6Eh6Ph6pcrqAc9uzdT4crjwZNRwIJfj/+speOHD0GHCCQUAL8t/rDT3vI7fYE1SPU33vQQkgAgRgJBOt33Fd/+nUvfmdi5JtsxeHwWrzFv//xV2pdPp7OvfQWH0s+/fwbET/xugU+8XqcrH9pO1WMvq6WqG93/0ynjZlBfYZPoU6DJ9Gcu5bTsargjnEtAQmMWPfim4LXvQ+v8dHiqX++JOIffmq9T3wsJyyrXf8JNGDUVOpYcQlNnbuY9v9xsJbI3ZIT0nnIZbTwoX/USrNahMvlpl5nXyVY8g+Vnvp/8/3PQi7/HagDs9OznkTIMpIb23PV7PvE3+pA6e+5z/Cr6Z6ltfvat7t/Ie6v7BRzGSuGRFwn9+47ELBfvvWfTyyDMBHcFDjB+t0bOz6WfmOupv4jp4q+e/t9K0PerCnysAcBOLw26QMf7/qK3nn/M681K/6xyXus1wE7tIPOm04z71gWUOS8e1fSSc0b07ubltH6J/5Km159hzZteTtgXrNGsjO6/4DsfLKz/uiqDbqr6izMo0cXXi84Pbd8Hu344DN6buPrPvUc+PMQXT5jIR06XOkTb9WT9/77f8QOQLEzn7hf6GlHg3oltOHJO33ChSMHUWmdQj2rSYgsI7mxQS2bNSbug+9tXka3XT+Blq/eQB99+j9OEuG8K26jIRdcL47tsInHdVLhxE/C+HjpndN8+ma7Vs052lIhntwYTLB+x08PJ02/m0ac3od2bFwq+u7Tz71Cazf/m4shBCeAFIkAHF4Jgh3+XzB8AD3ytDwKySODPAo7cmi517R9+/8kvojwqBeH8dfMp11ffudN57RX33yfbl30hMj35Tc/eNOUA3YsHr//Bpo9ZawS5d2zk8h33mPPqaDsrAxq0rg+nT34VHpx2w5vHrMfnNzieOrY5kR6Zt1WoepL296l0mIndTilhTjnzbsf7qIzx80iZsjh+tuWEtvOaV98tVuMtL//8edi1HbMlbdzdK3A7dKtYyvB6cSmjai8Rwd67a0PvfmqXC6aftvfhC6Dyrt446188MIr2+mMih50vtRP127y/XGa/+DTxIF/yHiElrnx6A7byyPvt0l98l8vvkGcvmDJao72CelpqXR8ozJvKCkupDXrt9HlF57lk8+KJ9Fy09oXr7x4GHEfzMrMkPpheyorLaLt7+30orrv1qto1ZI53nOrH4S7TrJ9M25/yPs0gv/WN2+Vr2E8iDBHemrFeZSw5PG1tGjZM8ppwH2j+iXevsn9lK+PATOaODLe3IL1u/9+8qWgdNHoIZSTnSX6Lt/cvvz6eyIeGxAIRQAObyg6Fko77+z+xA7nzl1f01PPvkTseNYtcXotcKQ4aFB5Z3r0num08oFZVLeOk2bPf8SbzheSK2fdR2mpqSIfX0y8idUHnFavtJiKpBHK6ijvbs9v+8Rxo/qlYs+bxg3LiOep8rFVwsTzT6eHVq6TRlaP0MNPraNLxgz1UT1Lcub5YssMly2YRp998S09+vQLIs/hyiPEIyHTbllCzY5vQH1P7SDiQ214FPmNHR9R65ZNvNnuWryajh6tkm4sxnjjDD8wsAKeI7rhlbfp9P7daLDkwP/f/74nDkqVPCXhhZe3U/+eHWnh3CvoD2mE/aGV/xLJv/3+B61eu4VWPb+FunZs5cNJZAiweWLNZuLR3SH9uwZItU5ULNyi6YvcDj//+jvxqK9Cia8hZdLfvHJu9X246yTb1/bkpnT3zVfQ2sdupzMHnSpuXnnK0V/atqR/bniN+EkX5zt4qJIWP/YcdWrXkk+DBp6SdOOdj9ITz2z23hwHzWzShHhzC9bv0tPTBaEUXvdRHBEd16Aufbf7l+oz7EAgOIGU4ElIsRKB4qICukAaPbtn6d/pcenCOmbEQB/1C/Nz6dwz+9HhI0fpw51fUEZGOvE8X3UmfvQ26+oLaPyowVS/brE6KezxH9IjeM7EcnnPIVMaNdq77w8+tEzo1bWtsJ2d1kOHj1BfafRVrfwpkmPas0sbYufg48++osKCPPIfDV/3+F9p8kXDaMJ5p6mLBjyed+8TdODPw+IGhTOsev4V2rb9A1p0y5WUnp7GUZYP/37nv8IGHtXmkX8eSd/wylsiTtnwKM25Z/WTbra6SOzOFiPeyiPhtq2a0VMP3ih4nhbGieVHng8uf46mXXquuHlT5FtxHys3tllrX2Tn7ZqbHiB+wsH9m8vaMYS7TrLNo8/qT/m52fTfT7+kqup3EL778Rdqc1IT4r77zw3y9COemsMj4j06ncLFaoVM6Rp7/rD+xP232Jkv3UCvp/FT/irdzFrvRdV4cqsFUhXRtlVTYpZT5jxAm7e+Q/9Yt5WeWfeqKoc+h5BiTwJweG3UrmNGVNDb738qHh2rR1rZRH7EWTF6Gt1yzwr65PNvqEp6bM7x6pCXm6U+jei4IC9H5D92rErseXNEcq6LnQV8aJmQkuKgSy4YKhyuS8eeQampvn8iG7e8TeUjrqEnpVH07374RaS7/FjmZGdqsnfJiueJH70vXzSDeESDC634+ybx+JNHOO9avIp27vqK3nx3p/ix5HQrhnUvvUlZmel0xwNP0S0LH5dGzyvp2Re2kcvlDmhOk8YNxHzfX3/bL9Jzc7KI20WchNk8Io22801Jv54dwuQ0f3Ks3NhCLX2RR5KvvflB0R4PzLta9Gkua9cQ6jrJjv/4a+bTuCnzxbW0UrqGMQd3dV/lQYWn/vkyHTl6TLoGvEjjpMEB/2sE5+eQJznNPP2LrydTLx1FT9w/SzzZ4KdCnG61EC9uobjwwM2T0s0vT6978tmX6T8f/Z/ot8c1rBuqGNJAQBDw/TUXUdhYlUBj6Y9+zrUX0qVjzqhlwrPSo7hmJzQkHvG55bqLiB9R1coUQ0RJHXn6BDuBipivv/uJIh0pVsomcj+4bxdiZ/f0Ad1rqfG3x9fS5IuGiWkhs64eQ727taVI//GSOjwX9THJuX1m2VwxcqTIuHj0EPGIlF9s48A/pjy/UpgL9dQAABAASURBVLmhUPJZZc9zx195/T9U0aczlRYXisB89+47IH6sAtmx64tvRbSzIFfstW64761c8yJdc8k55HA4tBYzZb54ceMnM5fPXEj8yJ4dMu5zpgSio1KhrpNvvfeJ6Jcv/+MeunP2paIvqaseVC7Pqb/7b6uF83pWxanq5JDHdUuKRDo/ZRMHFtskips/Jp4HPW/GBHENvkn6veMnbPz0yD8fzkHAnwAcXn8iFj8fLT0W5sfG/mbkSaNkfx48THv3/UE//vyb9Bhoq3+WsOf8iJlHcJXHfOK4enST77y7d2pNK9e8RDxi9NW3P9K/XnxTODphBZssQ3p6Gl09YQTxI0l/1Qryc+nX3/bRgT8PiSkhm1/d4Z8l7PlNC5YTvwCzcO5kMSWCXzLkUCWx5Mf6k6QbFiWc1JxfpGtBHB9WsAkzvPz6e+IRJN8cXDH+bOLAbDu3P4k2SKPlisq8/BEz5Rf+ePR8UHlnMe1GSdeyXyyNmLNc7oda8ps5Tzy48ZSdMZPn0S97fqdbr7+YDh6uJO6H6nn3PMf86DH5ETwfczAzN626BbtO8tMElvHTL3vFTQCvAMDnSuAR83OG9iGO532oG4Rt2z8Uj933HzhIhyS29z3yrHjR6qTmjRVxltsH5CZZoSc3SZxYzjJYv+N5/dwPeXnD2+97UlxfRpzem4shgEBIAnB4Q+KxTqLDEXpEa/jpfYQx/Dh+wLnTaM9e+SUzEalx8+XXP1D7gROJlyXjl1v4mF/GUIrPlkY8+RE8r8E79MIbJGe3E/FonpJuh/3l486il197l7oNvYIuvPqvxM6xw1H9ZxSmDRT7d3zwmTi8bMY9Yj1jXtOYw+4f94h4O23Wbn6Dhg3pVesx+VBp9JxXEjkqPRpmeze88rZgyis08I8nO8gcT1K3TtHAlVccWSfdYE2ZOEIUs/omdm4SuDAQ+AaDR8d4PvrwCXO8fXHUpJu9JXucMZkGny8vS8ZrbPc75xpvmhUPHI7QXLp0OJkG9u5EzKPHmZNp+7sfCzMdjppyyjXt3DP7irRgG3bYbrxzOTFDXtFl45a3iKeM8OBAsDJmjXc4auwPpKOe3Fg+MwvW71ZKT3HaD5hAvA7vb7/vpzUP3ypuJLgcAgiEIlD9Sx0qC9LMTIDn6u7cuoICPfK+QhpRe+Tu6UJ9nlqw5uFb6KXVd9OOjQ8Rv6DG5USitOFj9fJbUlSt/82bNCTOpw7zZ03y5uOR5c2rFtCWZxbROxuW0u0zJ7JD6E038wEvmcV8Aun45IOzxbxeTju18yn06rP30qan76I31y0mTvvb/Gs5SUxNYDYOR+gfB2bE+fwDP6oTglSbhXOvIJ7/p4qy1CGvZhFIfx4d27FxqXcUd9KYoaJfbl+/hHhOMy8txobyC5TLFtT+yAmnqUPLZseJvhmuD6vLmPk4Vm78ghX3L4cjeF8sKy0SzDifOrz+/ANeNNxGwdK8mSxwoPU6yXPF7731Str2z/vo32sfoAdunyIYtTm5qddKXg2nbatm1OrEE7xxgQ7Ycd6+frG4HvI18bXn7qduf2kVKKtp4xLBjWGE6neTpCdgfP394OVHxe8Y92MugwAC4QjA4Q1HyGbpPNmfH8sZaRZfgHiUzsg6Eimbl2fjpXB4/ddE6mG3urlfBrpxs5udetsDbnoTJeIbrqLC/FqCebrWY6s30tgRFbXSAkXwtYKvhxwcDr75CJTLPnF6cQtFhPs7rr+hCCEtGAE4vMHIIB4EQCAuBMaMGEi9u7WLS112qgTc4t+afx48RLx044BeHeNfuYVrBDcLN56NVIfDa7LGhDogkGwEeJoIT0lINrtjtRfcYiUYefnSOk4xJ1293njkUpKvBLglX5ub0WI4vGZsFegEAiAAAiAAAiAAAiCgGwE4vLqhhCAQAAEQAAEQAAEQAAEzErC2w2tGoibSidd15TU1+atAwdTas3e/WDfXP50/jsBpvIakfxrOQQAEQAAEQAAEQMBKBODwWqm1ItD14afWU7v+E2jAqKnUseISmjp3sVhIXRHx7e6fidfV7DN8CvG6uXPuWi4W++b07e/upK6nX06c1uOMycSf2vx411ecVCssWvYMtS4fT/zFplqJiAABEIgbAVQEAiAAAiAQnAAc3uBsLJ3CXwB6dOH19O6mZfTc8nm044PP6LmNr3ttmnfvSuIv/nD6+if+SptefYc2VX/5ypHiIP5kI68zy+tH8hJjix973ltWOWB5jzz9gnKKPQiAAAiAAAiAAAgkmkDA+uHwBsRi/ciRQ8upW8dWlJ2VQSc2bUTlPTrQa299KAzjaQq8ePrYcypEOn8w4uzBp9KL23aIdC7HH2LgLwLx+pGDy7uIsjxFQmSQNuxA33H/U3T3TZdLZ/gPAiAAAiAAAiAAAuYlAIfXvG2jm2b83fE3dnxErVs2ETL3/CZ/Vpi/oiMipE3jhmXE832lw1r/33j3Yzq5xfHEi6hzIn+K9Iob7iX+IlGLJo04CgEErEUA2oIACIAACCQVATi8SdDc8+59gg78eZh4RJfNVebbqteSzMzMoL37/uBkn7DuxTeJw7RLR4n4/X8cpEnT76ZrJ40kXgdURGIDAiAAAiAAAiBgSQLJojQcXpu39JIVz9Oa9dto+aIZVLfEKawtyMsR+2PHqsSeN0eOHKViZwEfegNPe5h5xzK6eeo46t6ptYh/6z876fsff6XvfviF7lq8ih5ZJc/hvffhNfTp59+IPNiAAAiAAAiAAAiAgJkIwOE1U2voqAsvK7ZgyWp67O+b6Jllc6nNSfJ0Bq6ipI7s+LLTyuccvv7uJ6pft5gPRdi89R0xkjtvxgQadWZfEceb5ic0pCkTR1BRYR7xi3GK8+wsyKWM9DTOgmA7AjAIBEAABEAABKxNAA6vtdsvqPY3LVhOK/6xiRbOnUyFBXm0+6c9IvCLZ/wyGo/YrlzzkliD96tvf6R/vfgmVfTpLOSt3fwGTZ27hGZeeT516XCyKMflDx2upGaSwztpzBmkhFFn9BVlxp87RKSJE2xAAARAAARAwI4EYJNlCcDhtWzThVZ8xwefiQyXzbiHKkZf5w27f9wj4mdfPYZ27vpKrME79MIbJGe3Ew3u20WkffjJl2I//8GnveVYxuat8ioOIhEbEAABEAABEAABELAIATi8FmmoSNXcvGoB7dy6olY4vlGZEMVLkXEeXmf3nQ1L6faZEym9ekoCr8EbqOywIb1EWfWmeZOGog5laoM6LUmPYTYIgAAIgAAIgIDJCMDhNVmDxFsdXmeXPywR73pRHwiAAAiAgN0JwD4QMA8BOLzmaQtoAgIgAAIgAAIgAAIgYAABOLwGQIVI7QSQEwRAAARAAARAAASMJgCH12jCkA8CIAACIAAC4QkgBwiAgIEE4PAaCBeiQQAEQAAEQAAEQAAEEk8ADm/i20C7BsgJAiAAAiAAAiAAAiAQMQE4vBEjQwEQAAEQAIFEE0D9IAACIBAJATi8kdBCXhAAARAAARAAARAAAcsRsLHDa7m2gMIgAAIgAAIgAAIgAAIGEIDDawBUiAQBEAABUxGAMiAAAiCQ5ATg8CZ5B4D5IAACIAACIAACIGB3AorDa3c7YR8IgAAIgAAIgAAIgECSEoDDm6QND7NBAASCEUA8CIAACICA3QjA4bVbi8IeEAABEAABEAABENCDgI1kwOG1UWPCFBAAARAAARAAARAAgdoE4PDWZoIYEAAB7QRsl/PX3/bRln//J2T4dvcvxOG5ja/T7/sP2I4BDAIBEAABuxGAw2u3FoU9IAACMRHYuetruurG+0OGf7/zEX302f/oxjsfpd0/7YmpPhQGARCwCwHYYWYCcHjN3DrQDQRAIO4E+nRvRx+8/Kg3DOzdiU5ucbz3nNNGn9WPKqT4N9Y+SCc1bxx3HVEhCIAACIBAZATg8EbGC7lBICYCKGx+Ag6Hg9LTUr0hJUW+TPrGOeizL76lK2ffR7/vk6c0/H3tFrrmpgdptbQ/c9ws6jzkMpp5xzLaf+AgLXl8LQ06bzr1G3ktPfL0C3S48qgXxIE/D9Ht960Uaa3Lx9PF194pZHsz4AAEQAAEQCBmAvKVPGYxEAACIAACyUXgD8lRff/jz+nI0WPCcJ7a8NJr79JjqzfSGRU9aPyoQbTuxTepxxmTadOWt+ncs/rS6f2706Jlz9AbOz4SZVwuN02ctoBee+u/NG7UYJo/axIdPFRJY6+6g9gRFpmwAQF7EoBVIBBXAnB444oblYEACNiZQLEzn9auuJ0uuWAoTb5oGPXq2oaaHd+Ann3kVrp49Gk07bJRdErLJpLD+7HA8NrbH9LHu76iu+ZcRuNGDhKO8m0zJtChw5X09vufijzYgAAIgAAIxE4ADm/sDCHBKAKQCwIWI5CTnUVZmRlerUuKnZSdlUnp6WneuLolTvrxZ/lFt11ffCfib1v0BJ1zyc0izJi3VMT9gJfhBAdsQAAEQEAPAnB49aAIGSAAAiAQgEBqau1LrCPF4c1ZeUSeyztl4ghSwtRLR9HSO6dSeY8O3nw4AAEQAAEQiI1A7atxbPJQGgRAAARAQCOBJo3ri5z169ahXl3b+oTjGpSKNGxAAARAAARiJwCHN3aGJpEANUAABKxGYECvv1BZaRFdPed+2rb9Q/rm+5/FfurcxbR1+wdWMwf6ggAIgIBpCcDhNW3TQDEQAAEzE0hxyFMTHA7fvVpnBznUp+I4xZFCDinwSW5OFj1yz/VUr7SYrrhhEZ02ZobY81fcGpSVcBaEaAigDAiAAAj4EUjxO8cpCIAACICAisDCuVfQmodvUcXIh907taadW1dQw3qyY3rtpJG0edUCObF6O/e68fT3h26uPpN39956Jf1t/rXyibRt2rg+LV80g97bvEyUf2fDUlFfy2bHSan4DwIgAAIgoAeBZHV49WAHGSAAAiCgGwFe3aFR/VLiUV/dhEIQCIAACICAIACHV2DABgRAAASSlQDsBgEQAAH7E4DDa/82hoUgAAIgAAIgAAIgkNQENDm8SU0IxoMACIAACIAACIAACFiaABxeSzcflAcBEIgzAVQHAiAAAiBgQQJweC3YaFAZBEAABEAABEAABBJLwFq1w+G1VntBWxAAARAAARAAARAAgQgJwOGNEBiygwAIaCeAnCAAAiAAAiBgBgJweM3QCtABBEAABEAABEDAzgRgW4IJwOFNcAOgehAAARAAARAAARAAAWMJwOE1li+kg4B2AsgJAiAAAiAAAiBgCAE4vIZghVAQAAEQAAEQAIFoCaAcCOhNAA6v3kQhDwRAAARAAARAAARAwFQE4PCaqjmgjHYCyAkCIAACIAACIAAC2gjA4dXGCblAAARAAARAwJwEoBUIgEBYAnB4wyJCBhAAARAAARAAARAAASsTgMNr5dbTrjtyggAIgAAIgAAIgEDSEoDDm7RND8NBAARAIBkJwGYQAIFkJACHNxlbHTaDAAiAAAgkHf1vAAAAZElEQVSAAAiAQBIRgMMboLERBQIgAAIgAAIgAAIgYB8CcHjt05awBARAAAT0JgB5IAACIGALAnB4bdGMMAIEQAAEQAAEQAAEQCAYgdgd3mCSEQ8CIAACIAACIAACIAACJiDw/wAAAP//yK2pCAAAAAZJREFUAwCpfmQvci7rQQAAAABJRU5ErkJggg=="
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Visualize the training data\n",
+ "# The plot shows the 'load' column (energy consumption in MW) over time\n",
+ "fig = train_dataset.data[[\"load\"]].plot(title=\"Training Data: Energy Load over Time\")\n",
+ "fig.update_layout(yaxis_title=\"Load (MW)\", xaxis_title=\"Time\")\n",
+ "fig.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "12d8302c",
+ "metadata": {},
+ "source": [
+ "## Define a base config with inline search space\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "a001a0f0",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/fleur.petit/projects/openstef/.venv/lib/python3.12/site-packages/mlflow/__init__.py:41: UserWarning:\n",
+ "\n",
+ "Versions of mlflow (3.9.0) and child packages mlflow-skinny (3.6.0) are different. This may lead to unexpected behavior. Please install the same version of all MLflow packages.\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "from openstef_core.types import LeadTime, Q\n",
+ "from openstef_models.models.forecasting.xgboost_forecaster import XGBoostHyperParams\n",
+ "from openstef_models.presets import ForecastingWorkflowConfig, TuningResult, fit_with_tuning\n",
+ "from openstef_models.presets.forecasting_workflow import create_forecasting_workflow\n",
+ "from openstef_models.utils.tuning import CategoricalRange, FloatRange, IntRange\n",
+ "\n",
+ "config = ForecastingWorkflowConfig(\n",
+ " model_id=\"xgboost_optuna_demo\",\n",
+ " model=\"xgboost\",\n",
+ "\n",
+ " horizons=[LeadTime.from_string(\"PT36H\")],\n",
+ " quantiles=[Q(0.5), Q(0.1), Q(0.9)],\n",
+ "\n",
+ " target_column=\"load\",\n",
+ " temperature_column=\"temperature_2m\",\n",
+ " relative_humidity_column=\"relative_humidity_2m\",\n",
+ " wind_speed_column=\"wind_speed_10m\",\n",
+ " radiation_column=\"shortwave_radiation\",\n",
+ " pressure_column=\"surface_pressure\",\n",
+ "\n",
+ " # Pass TuningRange objects directly as field values — tune=True marks them for Optuna.\n",
+ " # None values for low/high fall back to the class-level defaults in XGBoostHyperParams.\n",
+ " xgboost_hyperparams=XGBoostHyperParams(\n",
+ " n_estimators=200,\n",
+ " learning_rate=FloatRange(None, None, log=True, tune=True), # class default: [0.01, 0.5]\n",
+ " max_depth=IntRange(5, 15, tune=True),\n",
+ " min_child_weight=FloatRange(None, None, tune=True), # class default: [1.0, 10.0]\n",
+ " reg_alpha=FloatRange(None, None, log=True, tune=True), # class default: [1e-8, 10.0]\n",
+ " reg_lambda=FloatRange(None, None, log=True, tune=True), # class default: [1e-8, 10.0]\n",
+ " ),\n",
+ " optuna_n_trials=20,\n",
+ " optuna_seed=42,\n",
+ "\n",
+ " mlflow_storage=None, # Disable MLflow during tuning\n",
+ " verbosity=0,\n",
+ ")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9b47824a",
+ "metadata": {},
+ "source": [
+ "## Inspect the resolved search space\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "65a76a06",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Resolved search space:\n",
+ " learning_rate : FloatRange [0.01 — 0.5] [log]\n",
+ " max_depth : IntRange [5 — 15]\n",
+ " min_child_weight : FloatRange [1.0 — 10.0]\n",
+ " reg_alpha : FloatRange [1e-08 — 10.0] [log]\n",
+ " reg_lambda : FloatRange [1e-08 — 10.0] [log]\n"
+ ]
+ }
+ ],
+ "source": [
+ "from openstef_models.utils.tuning import FloatRange, IntRange, CategoricalRange, get_search_space\n",
+ "\n",
+ "# Merge custom annotated hyperparams with class-level annotated defaults (filling in any None bounds).\n",
+ "resolved_space = get_search_space(config.xgboost_hyperparams)\n",
+ "\n",
+ "print(\"Resolved search space:\")\n",
+ "for name, param in resolved_space.items():\n",
+ " if isinstance(param, (FloatRange, IntRange)):\n",
+ " scale = \" [log]\" if param.log else \"\"\n",
+ " print(f\" {name:25s}: {type(param).__name__} [{param.low} — {param.high}]{scale}\")\n",
+ " else:\n",
+ " print(f\" {name:25s}: CategoricalRange {param.choices}\")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "08768e60",
+ "metadata": {},
+ "source": [
+ "## Run the Optuna study with `fit_with_tuning`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "8601c179",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ " 0%| | 0/20 [00:00, ?it/s]"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Best trial: 12. Best value: 0.8388: 100%|██████████| 20/20 [02:15<00:00, 6.75s/it]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Study complete: 20 trials\n",
+ "Best R²: 0.8388\n",
+ "Best hyperparameters:\n",
+ " learning_rate : 0.1661524390633895\n",
+ " max_depth : 12\n",
+ " min_child_weight : 6.81957188819057\n",
+ " reg_alpha : 0.04112476622444426\n",
+ " reg_lambda : 0.0022086692193693247\n"
+ ]
+ }
+ ],
+ "source": [
+ "import optuna\n",
+ "optuna.logging.set_verbosity(optuna.logging.WARNING) # Suppress per-trial logs\n",
+ "\n",
+ "tuning_result = fit_with_tuning(config, train_dataset, create_forecasting_workflow)\n",
+ "\n",
+ "print(f\"Study complete: {len(tuning_result.study.trials)} trials\")\n",
+ "print(f\"Best R²: {tuning_result.study.best_value:.4f}\")\n",
+ "print(f\"Best hyperparameters:\")\n",
+ "for k, v in tuning_result.study.best_params.items():\n",
+ " print(f\" {k:25s}: {v}\")\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "096af1c0",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Final XGBoost hyperparameters (tuned values marked):\n",
+ " n_estimators : 200\n",
+ " learning_rate : 0.1661524390633895 <- tuned\n",
+ " max_depth : 12 <- tuned\n",
+ " min_child_weight : 6.81957188819057 <- tuned\n",
+ " gamma : 0\n",
+ " objective : pinball_loss\n",
+ " evaluation_metric : mean_pinball_loss\n",
+ " reg_alpha : 0.04112476622444426 <- tuned\n",
+ " reg_lambda : 0.0022086692193693247 <- tuned\n",
+ " max_delta_step : 0\n",
+ " max_leaves : 0\n",
+ " grow_policy : depthwise\n",
+ " max_bin : 256\n",
+ " num_parallel_trees : 1\n",
+ " subsample : 1.0\n",
+ " colsample_bytree : 1.0\n",
+ " colsample_bylevel : 1.0\n",
+ " colsample_bynode : 1.0\n",
+ " tree_method : auto\n",
+ " random_state : 42\n",
+ " early_stopping_rounds : None\n",
+ " use_target_scaling : True\n"
+ ]
+ }
+ ],
+ "source": [
+ "# The best config is already applied inside fit_with_tuning.\n",
+ "# Here we inspect which hyperparameters were tuned vs kept at their default.\n",
+ "print(\"Final XGBoost hyperparameters (tuned values marked):\")\n",
+ "final_hp = tuning_result.workflow.model.forecaster.hyperparams\n",
+ "baseline_hp = config.xgboost_hyperparams\n",
+ "best_params = tuning_result.study.best_params\n",
+ "\n",
+ "for field in type(final_hp).model_fields:\n",
+ " value = getattr(final_hp, field)\n",
+ " baseline = getattr(baseline_hp, field)\n",
+ " marker = \" <- tuned\" if field in best_params else \"\"\n",
+ " print(f\" {field:25s}: {value}{marker}\")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d86e3cbc",
+ "metadata": {},
+ "source": [
+ "## Full-set training metrics\n",
+ "\n",
+ "`fit_with_tuning` trains the final model on the full training set with the best\n",
+ "hyperparameters. The fit result is available as `tuning_result.fit_result`.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "5be7e4a8",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Final model already trained by fit_with_tuning!\n",
+ "Full-set metrics (tuned model):\n",
+ " quantile R2 observed_probability\n",
+ "0 0.5 0.978403 0.503819\n",
+ "1 0.1 0.968634 0.263426\n",
+ "2 0.9 0.955630 0.743750\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Final model already trained by fit_with_tuning!\")\n",
+ "print(\"Full-set metrics (tuned model):\")\n",
+ "print(tuning_result.fit_result.metrics_full.to_dataframe())\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3fc5f542",
+ "metadata": {},
+ "source": [
+ "## Inspect the study and forecast\n",
+ "\n",
+ "1. How did $R^2$ improved over trials?\n",
+ "2. Which parameters had the most impact?\n",
+ "3. Final tuned model predictions on the held-out forecast window.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "c29a1423",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAArwAAAH0CAYAAADfWf7fAAAQAElEQVR4AezdBWAURxsG4PcSCElwd3eXIgWKF3dKkVIcirsW+YFSKO7uxa1QpLhrseJWrLi7JEiSf79J7rjIJZsQOXlbZm93Z3Z25tkNfDc3t3Hy4X8UoAAFKEABClCAAhSwYwEn8D8KUIACFABABApQgAIUsFcBBrz2emXZLwpQgAIUoAAFKBAWATs8hgGvHV5UdokCFKAABShAAQpQ4LMAA97PFlyjAAX0C7AkBShAAQpQwGYEGPDazKViQylAAQpQgAIUsD4BtsgWBBjw2sJVYhspQAEKUIACFKAABcIswIA3zHQ8kAL6BViSAhSgAAUoQIGoE2DAG3X2PDMFKEABClDA0QTYXwpEiQAD3ihh50kpQAEKUIACFKAABSJLgAFvZEnzPPoFWJICFKAABShAAQqEowAD3nDEZFUUoAAFKECB8BRgXRSgQPgIMOANH0fWQgEKUIACFKAABShgpQIMeK30wuhvFktSgAIUoAAFKEABCgQnwIA3OB3mUYACFKCA7QiwpRSgAAUsCDDgtQDD3RSgAAUoQAEKUIAC9iHgaAGvfVw19oICFKAABShAAQpQQLcAA17dVCxIAQpQwJ4E2BcKUIACjiPAgNdxrjV7SgEKUIACFKAABRxSINiA1yFF2GkKUIACFKAABShAAbsSYMBrV5eTnaEABSJIgNVSgAIUoIANCzDgteGLx6ZTgAIUoAAFKECByBWwzbMx4LXN68ZWU4ACFKAABShAAQroFGDAqxOKxShAAf0CLEkBClCAAhSwJgEGvNZ0NdgWClCAAhSgAAXsSYB9sRIBBrxWciHYDApQgAIUoAAFKECBiBFgwBsxrqyVAvoFWJICFKAABShAgQgVYMAbobysnAIUoAAFKEABvQIsR4GIEmDAG1GyrJcCFKAABShAAQpQwCoEGPBaxWVgI/QLsCQFKEABClCAAhQInQAD3tB5sTQFKEABClDAOgTYCgpQQLcAA17dVCxIAQpQgAIUoAAFKGCLAgx4bfGq6W8zS1KAAhSgAAUoQAGHF2DA6/C3AAEoQAEKOIIA+0gBCjiyAANeR7767DsFKEABClCAAhRwAAEGvGYXmasUoAAFKEABClCAAvYnwIDX/q4pe0QBClDgSwV4PAUoQAG7ErC6gHfVxj3IWboZNmw7FCT00PELVf6lq7eCzOdO6xHw8vLG2BkrsXbz/kht1LI/d6p7RO4jYxo+aXGktiE8T3br7kPlePz05fCslnVRgAIUoAAFHEYg7AFvBBH5ePuomr19fF/VhtnCuN/HQr5ZUa5GsYC3tzfmLd+EHftPRGpL8ufKjP5dGiNBvNjqvLL+bYmCat0WFw8ePVeO5//9zxabzzZTgAIUoAAFolzA6gLeKBdhA0wCet9U6C1nqjiIlfCow1httkxp8EPtcogf1zfglfXC+bMZs3W/hmebdJ80Egvae/8ikRI8FwUoQAEKWLeAzQe8k+b+gXZ9x+PO/ceBpFdv3Kvyzl2+ofJGTl2G7oOnQbY7D5yEQpXbokStTpD9Hz9+UmXMF3sOnUKLbiNVOSnbqf9E3Lzz0FTE8/0HVf/sJRvx8vVbzF++Wat/KgaNma/KSL16zzd62nLUbzNEtUc+hq/YsBfGzFiBp89fqbpkEdL59NQh9Rjb9e/1OzA6yPlmLtog2Th57orqV+Eq7VR7xs9ahU9eXirPuJBt6a+0OVeZ5pDjh01chNdv3qki7zw80aHfBLV+9OQlVZ9cJ/FQO7VFSHVoRXD+8n/q2L2HT+P6rfuQ6y3XYenanZIdpvSl/Te2aeueYxCz2i0GqCkUP3YcpuwCNuqfs/+iVc/R6j6S+63r/6ZApimYl5NpH+Jz78ETHD5+HjIFQ/yWaf0cq90HUnbpmh3KQsrJPSf7zly4pvaJv9w3cp/KPbv70EnJNiVjm3cd+AeLVm9D3daDINetRtN+EFtTQb+VN2891DQKKSd1yuuE2avx4PEzvxLAtZv31P0jfZJzS/8PHjtnypeVDx8+4vdVW9W9LfWU/b6bui+27jkq2UwUoAAFKGBfAlbbG5sPeFMmS4x9f5/Gn5sP+EOWYGrinNWQeY+Z06dSef+c+RfyD60EaTv3/4MMaZLj2YvXWKj9gzxw9DxVxriQYE4CjiMnL6JEkdxImyopdh08iSo/9sGjJy9UsU+fvNS5Zc5otcZ9VYC6VQuCJKiQAqE53/ptB1VAl1UbnaxYurAcrgLo9lowL32RHSGdT08dUo+xXRKoGR3kDYMEkxIsSeAipkafOUv/0vp5Rg5VSUYGO/WfpPorQWj1CsUgAa4Eoa16jIa3t49Kj5/6OkmerEt69sI3gNdTh5xMyktbJs9bg+pNflYBplyHMxevSXaY0pf239im7oOnqgD8ncd7dX/IGwWxu3rjrqldO/afQONOw1UQK/dRrmwZsH3fcVRu1AfyhsNY8L/bDzTj0+jxy3QVHC/Rglt5w3X/0VO8ePVGFXunvYkQQ0nGNxYSdIqPu1sMlC9ZEPlzZYLcsx37TfQXyBrb3GnAJIyYslS7718hY9oUkOPb/zxeC8AfqXPIQt5k1WjWT02jkID16wLZ8VALdCXI3rzziBRRP1cSLO/Ufo7SpU6ufkak/z/1GgNptyqkLYZNWoxR2hvNx89eoEyxfEiRNJHKlzcdWjb/UIACFKAABSJFwClSzhKGk/T7bbYaXZTRI/O0cv1uf7VVKuMbHK5YvwsftQDUmLn/yBntH/XXaFy3PGK4RDfuVq8929bHqe1zsGLmIOxePQFJE8dXX5K7fc/3H30J/mR0NXvmtDi4bgrGDe6A1bOH4Nc+LdXxC1ZsVq/GxcPHz5E/d2b8PvFn7P9zMhZPGWDMUq8hnU8KzRrdE4c3TsWcMb2087XH5iWjULZ4fjUa/d+tB1LElCydLzR1SGUdmtfGP9tmK4d184fJLt9gqcXn/WvmDlX7/z5xXr3KYtveYyo4q1+zrOYzGSP6/YTdf0xAnSolVXv3HD6FWDHdsHLmYCmO0lqgI36SFkzoq/bpqUMV9FtcvHITrX6oqq7DvrWT0KVVXb+csL+Etf/GM+bKmh7is3XZaGxaPBLdfvpeZcmIpqy810Y3ZaRW1jcu/E27rh0wfUQ3TPutm+zCuJkr1Kv5QoLlQd2batd/JHatGo8WDapgaG/f+65Vo2qq/+LYvU09dVixgrkg9/Daeb9iwi8dIfeA0X3d1oOqjPlCgtyl0waqutf/PhwdmtVS2Tv2H1evspA3PnKPdWn1HaTM5GFdsHfNJHX/J0oQV432/zLudymK9QuGYdHkfpgxsgekj7JT3mjKqwTo8imL/Hxt0e7nUQPbaj8b/bFb+5n7ofa3UoSJAhSgAAUoECkCVhvwyj+SaVMl00bO/Cd3N1d/MDHdXdGozrcquN2nfextzFyxbpda/a5qKfVqXMjxzRtURvTo0dSuJIniofF3FdT62Ys31OsObVROVqRc7Fju8PLyVqnsNwVkN85e8i2nNrSFjNxNGtoZBfNmVV+UktFgbbf6o+d8UlCCayeDE679d1eNzK3begAGJ4NkBZquYel8oalD2tW+aU3Tm4FM6VOqwD9BvNho1+Tz/qwZU6s+HTh6VrVFFn9u8Q2kWmiOzs7OysYAA4xvPvQ8QSO0dcibBgkopY8J48dB8iQJpClhTl/Sf+NJ61QpAfExbjeu63sfHdU+FZB9F/79TxsZfa7dn+WRXvs0QfZJKlU0L/Lnyoz9R87ild8UENkvae7YXqhXowzSpEyqrke8uLFkt8UkPydyD8uUGpk6sXXPUZzxG/2+ceteoOPkZyVvjoym/eVKfKXW7z98ql4/eXlBgtRUyROjRcMqap8snLR7sXblEpDR/ItXbkFGhqWdMrrr5ffzIW2WfsnItYwMy3GSZLrQA+1NoaxLkvbKmxdZZ6IABSjgyALse+QJOEXeqUJ3JhnBWzylvxoRMn+tVr5ooIqMQa2M8kqmjNBKMFFWGyFNmSyR7Ao2GYORB499/9E3ztPtPXQG8pRrYUrFqndQ9dx94H++sLubm9qvdxHwfHKcBNml6nRGjWb9IR8xDxg5Fzu1j4slz/hkClmXZOl8O7RAXW8dUk/AFDd2THi+/xhwNyToN36ELpnXb/oGUjJv1NxHPs6W/Ifax9/yGlwKbR3u2kf2wdUXHnl6+2/pXPJJQpYMqdQbFJnWceee732SLVPqQIfkyJJO7bv34Il6NS7cQtlPCXS7D54GuTdl6oSs/zphkbG6EF/jaNdcCn3wm8P+0C8wlaA4mvZmRvICptt3fT8JkU9bzK+/rMu0Bin/5NlLuGtvTuXn9dmL16jcqDcath+qpjdc1EbrpQwTBShAAQpQILIErDbgDQ2AjLLJyJJ8YUamJRjn8+r92NQYUMpopZz37VsPeUGnFnUwpGfzQKln2wYqP6yLgOeTLyl1GThZBZu9OzRUQb58TD2ga2PdpwiPOiydLGDgIwGMlA3KRvZVL19MsoNN4VFHsCcIx8yA/ddTtcEAeH74oIpGj+b7aYLa8FtEj+as1sxHQtWOQIvgd3T4eYKal166WD5MGd4FMq3g0IapSKCN1Ad/pG+us5P/vwI8Pd+rjBgxXNRrUIu3Hr4/HzLaK9c7qGQcmR7WtxUGdmsCGZmXL9jJdA/5ApxMGQqqbu6jAAUoQAEKRISA/3/tIuIMkVRng5pl1ZlWrt8DGemVj2SLFMih9oW0kCBZyqROkURekC51MvWaL2cm1K1WKlCqUq6Iyg/rIuD59h3x/UKYzBVu+n1F9XG3fOzrGkzQEfDc4VFHwDotbcsbDMmrUu7rQDbiJVM7JN+YvLSPyY3rxtfQ1mE8zppf5aP7O/efQEZ5DQYDUiVLrJp7N8AoruyUL6PJa7IkCeVFVwro+Pzla/VUCJlLPHV4V5Qpll9NnZCRal0VBlEohV+bb9y6H0Su7y7jz0nq5ImDvP5yD8jorpSWNwvysynzjo9tnoFxg9urYFy+FCqj01KGiQIUoIAuARaiwBcI2E3AK3MR5R9Z+UUHMnrYRAscnZy0YbYQcOTxS7+v3KJK5c6WXr3m1QJdWZkyf62/L8LJPvkijoymynpYUlDnk2/dS13Ro/uO+sn6Jy1IDM1Hv+FRh5xXTzI+03bGwnWBistH9MZ2G+dJ3/L7CNy8sN46zI+x9vXVf+1VT6soXji3amrmDKnU68oNuyFfYFMb2uLB42faqOwxNUc3ccK42p7g/8SJ7a4KGOfZqg1t8czvkXVGZ22X+iNTcuRnQG2EcuHm6gIJ2GVqgiTzw+XpDTJKa3yzsmDlVjVH2byMTOUwPqVE2rD/yOe53/LzWbF0YeTPnVkdIveKWuGCAhSgAAUoEMECdhPwyj/UMpJk9KoWxFxfyZOAVR43tmDFFsxYuB7ftfqf+ke7Y4vaSJwwnhRB8UK51BMS5B/871oOVI8t++OvfZDnzFZs2AvL1ul/Bqye8xXKm1WdSeCV4AAAEABJREFUd9Do+Zgyby2maoH2960HQR5NpTJ0LMKjDh2nUUXkyQHykfncZZvUM2BXbtij2tp3+CyUb9AT/5y9osrJomjBnOrZxQNHzcOyP3eqZ7vK/tDUIeV1JlVMvjQnj0iTEVDZIevyLGBZD88kb4jGzVyp9X07+o+Yg18nLFLzVls1rKpOI080aNO4urq/mnUdgXVbD6ovhP3Q3vfJF306NITBEPKbsjQpk6h6pR/TtTcZS9Zsx/J1u9QX2+Q6yH0q880XaG/cpB3y6DzVgDAu+nX+UR0pj1iTe3HDtkPqEXSVfuiNE2f+Vb/Qo1/nRiq4r9bkZ0z7fZ3qmzyn97tWAyGPPpMKnr94hbZ9xkIedSdTGeQLdVJm5/5/UCB3FmTNmEaKMVGAAhSgAAUiXMD6Al6/AMDJ7zWggMHgGyAYDL6v5vlff+U7hUG+PR7cx7rypZvR05dDnu0qo1DyBIA2P9Ywrwqj/9cOEgTff/QM8szQ/42eBwk45Atc3/p9s91gCNwGf5X4bYR0vu+qlUKtSt+oLztJQCMBhKtrDPVtfanCeBqDwfL59NYh9VlKxjnMAfOdnf3fJvLIsT/mDIW8qdj392kMGbtA/aIECYyK5M8O40i51PNzxx9QsXQhrNm0TwWEEqjJfr11ODn5nttgsNx3qc88ScAtb07k2sp+Wd++75isBpucLXxJy9nZtw0BD5YRSwn6h09agj+3HIDMI/9jzhAY569K+fbNakEefyYjo/KoPfmlJK/feEAe5VZRG+2UMpIMBt/+GWCQTX9JzjNGux+l/inaGyI5nzxLWEZ2Jw7trKYI/LXzb8gvHpF2yKPG5BjzSpxCcDTmyzGF8mWDPN5MnjYi96K8kZEpCPJc5ny5MkkRyPx4aVPsWG7qDZr0TZ7TK1M65OkmUihh/Ljq2stzgeVZvN0HT4OUKaq9CRr+cys4OQXuqxzHRAEKhIcA66AABcwFgv6X3LxEJK/Xq14a5/csQPUKxYI88/+6NVH52TIFHh3apP2jLwdJHfIaVJJAQJ4temDdZMjzU4/8NR3yD3TAf3xl/qw8nuvopunY88cEyHNq/944TT1vtUaF4qpqeSSatFXmJaodQSz0nC+aFmgN69tKPU9VnqG6c9U4LJs2EIO6N1V9lbmZUnVw59Nbh9Qjzx+W+ZSybp6M8yzN98m6PONVni8s68Ykc4xH9m+D0zvnYsvSUcrlxNZZmDe+D/KYPfYqY7qUGDe4Aw5rduJ9aP0UYxXQU4eMtouxvIkxHRjCyg+1yyk3Oc6Y+ndpbDoqPPovlclj2U5um636L/eGPE0kTcqkkmVKcl3k8W+nts+BPLNWntcrZQPe311b11VtlsfDmQ42W5FHmUn98mXGXavGY4RmL9kFcmfGjpXjINdI0vEts9C+WS3I9ZVtKSOpuPaphVgEdJRrIPsHafealDMmKS9tlS/AyRfh5PqJmwTdUsZgMKBy2SLqeb5S5s/5v2LvmomQnxd5AyllJPCXay/3yLblY1Qbpaw8a9o4D1jKMVGAAhSgAAUiWsDqAt6wdvjh4+eQ0S35B1m+ER5SPfHjxoZ8sS1goBvwOIPBoKY6SCAio7sB8/Vu6zmfBB85s6ZDssQJ9FYbqFxo6gh0cBh2SEAnwYuMBsqbBEtVxInlrrxlVDJgGb11BDzOGrZdXKJD+h/SvSH9luBfnCyNGOvpj1xfefau+X1rfByazL11c7X8dAU99QcsI5+UyGP05PoFzDNuSxn5bYYyhcNgCDxqK9dXHg8o7ZOyxuP4SgEKUIACFIgsAbsJeOXJDIImH7XKKxMFKEABClBApwCLUYACdi5gNwFvzizpMbR3C3xbooDFS9amSQ3IlAiLBcI5I7LPF87NZ3UWBOTpC3KvFcyXzUIJ7qYABShAAQpQwJoE7CbgLacFunWqlIR8xGwJuGzx/BbnBls6xrQ/DCuRfb4wNJGHhEFAppzIvZYxbYowHM1DKEABClCAAhSIbAG7CXgjG47nowAFKOCoAuw3BShAAVsTYMBra1eM7aUABShAAQpQgAIUCJVABAW8oWoDC1OAAhSgAAUoQAEKUCDCBBjwRhgtK6YABSgAgAgUoAAFKBDlAgx4o/wSsAEUoAAFKEABClDA/gWisocMeKNSn+emAAUoQAEKUIACFIhwAQa8EU7ME1CAAvoFWJICFKAABSgQ/gIMeMPflDVSgAIUoAAFKECBLxPg0eEqwIA3XDlZGQUoQAEKUIACFKCAtQkw4LW2K8L2UEC/AEtSgAIUoAAFKKBDgAGvDiQWoQAFKEABClDAmgXYNgoEL8CAN3gf5lKAAhSgAAUoQAEK2LgAA14bv4Bsvn4BlqQABShAAQpQwDEFGPA65nVnrylAAQpQwHEF2HMKOJwAA16Hu+TsMAUoQAEKUIACFHAsAQa8jnW99feWJSlAAQpQgAIUoICdCDDgtZMLyW5QgAIUoEDECLBWClDA9gUY8Nr+NWQPKEABClCAAhSgAAWCEWDAGwyO/iyWpAAFKEABClCAAhSwVgEGvNZ6ZdguClCAArYowDZTgAIUsEIBBrxWeFHYJApQgAIUoAAFKECB8BOIioA3/FrPmihAAQpQgAIUoAAFKBCCAAPeEICYTQEKUCDiBFgzBShAAQpEhgAD3shQ5jkoQAEKUIACFKAABSwLRHAOA94IBmb1FKAABShAAQpQgAJRK8CAN2r9eXYKUEC/AEtSgAIUoAAFwiTAgDdMbDyIAhSgAAUoQAEKRJUAzxtaAQa8oRVjeQpQgAIUoAAFKEABmxJgwGtTl4uNpYB+AZakAAUoQAEKUMBXgAGvrwOXFKAABShAAQrYpwB7RQEw4OVNQAEKUIACFKAABShg1wIMeO368rJzugVYkAIUoAAFKEABuxVgwGu3l5YdowAFKEABCoRegEdQwB4FGPDa41VlnyhAAQpQgAIUoAAFTAIMeE0UXNEvwJIUoAAFKEABClDAdgQY8NrOtWJLKUABClDA2gTYHgpQwCYEGPDaxGViIylAAQpQgAIUoAAFwirAgDescvqPY0kKUIACFKAABShAgSgUYMAbhfg8NQUoQAHHEmBvKUABCkSNAAPeqHHnWSlAAQpQgAIUoAAFIknA6gLeSOo3T0MBClCAAhSgAAUo4CACDHgd5EKzmxSggM0JsMEUoAAFKBBOAgx4wwmS1VCAAhSgAAUoQAEKRITAl9fJgPfLDVkDBShAAQpQgAIUoIAVCzDgteKLw6ZRgAL6BViSAhSgAAUoYEmAAa8lGe7XLXDvqQeYgjfw9gEePAu+DA098Pz1B3h88OL9pONn6sNHbzx59Z5WIVg9euGJT14+dArBSf7+eev5CS/efqSVDiv5B1LMIjPJOXUmFgtCgAFvECjcRQEKUIACFKAABShgPwIMeO3nWrInFNAvwJIUoAAFKEABBxJgwOtAF5tdpQAFKEABClDAvwC3HEOAAa9jXGf2kgIUoAAFKEABCjisAANeh7304dNxH5/wqce6a/ny1iknWoUIKU6SQizIAlBOvKdCvhM0I2UVckmHLyFOkhweQgcAnXQgWVkRBrxWdkFsrTknzn/AlWtOTCEYHD39EZdDKENHJ5z/Fzh1zpv3k4575cQ5L1z410CrEKwuXTXg+NlPdArBSf7+OX3BG+cu+QRvpaMeqcve05FTH/05Xf/PAI+32rsrW/tH3IHay4DXgS52RHR1yzZg0RInphAM5i6gk5775PdFBsxbSCs9VvN+BxYuNvBnL4SfvYWLncCfP31/R89faID8DOq5/xy9zJwAf6dv+MsJnh8YUkVEnBFedfLqhJck6zEK8JUCFKAABShAAQpYlQADXqu6HGwMBShAAQrYjwB7QgEKWIsAA15ruRJsBwUoQAEKUIACFKBAhAgw4I0QVv2VsiQFKEABClCAAhSgQMQKMOCNWF/WTgEKUIAC+gRYigIUoECECTDgjTBaVkwBClCAAhSgAAUoYA0CthXwWoMY20ABClCAAhSgAAUoYFMCDHht6nKxsRSgAAV8BbikAAUoQAH9Agx49VuxJAUoQAEKUIACFKCAdQnoag0DXl1MLEQBClCAAhSgAAUoYKsCDHht9cqx3RSggH4BlqQABShAAYcWYMDr0JefnacABShAAQpQwJEEHLWvDHgd9cqz3xSgAAUoQAEKUMBBBBjwOsiFZjcpoF+AJSlAAQpQgAL2JcCA176uJ3tDAQpQgAIUoEB4CbAeuxFgwGs3l5IdoQAFKEABClCAAhQISoABb1Aq3EcB/QIsSQEKUIACFKCAlQsw4LXyC8TmUYACFKAABWxDgK2kgPUKOHTA+/L1W2zedQQ+Pj6RfoXeebzHJy+vSD8vT0gBClCAAhSgAAUcTcChA9479x6j5y/T4eXtHanX3cPzAwpVboN9f5+J1PPqOVmfYTNx5cYdPUXDVIYHUYACFKAABRxJ4M3bd3j56nWouvzx4yc8ePQUHz58DHScDJZ5e0f+QF2ghtjYDocOeKPqWsVwiY5VswajYN6sUdUEi+fduP0wnr94YzGfGRSgAAUoEC4CrMTOBTw8PDFoxHTUbtIDdZv3RqefR+HZ85fB9vr23QfoNmAsqjTohMbtBmDr7sP+ysuAWZ0WA7Fp59/+9nMjZAEGvGZG9x48Qaf+E7XR17Zo1XM0tu45ZsqVkc8StTohZ+lmqNG0n7+8EVOWYunanZi+cB0adxqu3YhHsGHbITV6PHT8QlWf7D9y8qKqz8nJgOGTluDu/cdqW44fM2MF2vUdr8r2HjoDt+89UnmyuHHrvmqPnLvKj33QrOsINRVD8kJKDdsPxe5DJ/GL1g5Zv3bzHiz1ZdzMlaq6gaPmon6bIVi+bpfaPn76stouVLkt+v02G2cv3VD7uaAABShAAQpQIGiBdVv24sate1g2ewTWLhwLZycnzF+2IejC2t7HT1+gRechSJQwHsb/2gMblkxEyaL5tRzfPxInFKz0E+Tfcd89XIZGgAGvn9bHT14qqIwdyx0LJ/2MOpVLovvgqbirBcFSJE/2DBgzqD3WzR+GGhWLq7yXr95KFm7eeYhhExfhyvW7+LbkV0iWJAGePn+lglI3txiYPKwzMqRNjtHTlqvysjh57gpkHq+sy/Er1u3GN4VzYcrwLqq+VRv2AFrme+3jjLZ9xsHbyxtzxvTCwK5NcOvuQzx7oe/jkTMXrqFjv4mI5uyMiqULwd3NFZb6Ur1CMe2MwA91vkXPdvVRvFAu7VyP0LTLb6hYphCWThuAFEkTocvASVEy71k1jgsKUIACFKCADQjsPfQPKn9bHIkSxEWsmO6oXbUMtuw8aPHfzz827EC8uLHRp3Mz5MqeCa6uLogbJ7app60aVsXOVeOQNHF80z6u6Bdw0l/UvkueOHNZBZp1qpRUHU2fJhlyZU2PvYdPq+0GNcshdkw3nLl4DZ+04Fh23r7/SF5Uat2oGsYNbo+m31dEgdyZ1dl/wBwAABAASURBVL6iBXOiZ9v6+LpADjSrVwkXr9yEMUhWBcwWP/1YDY3qlEeR/NlRr0YZ7D/iO7/31PmruKONBA/u2RxSn6SUyRKbHRny6oyRPdCvcyPVhuRJEsBSXzKnT6Uqy54pLQrly4bUKZJg4/ZDSJsqKYp+lVP1u1TRvHj4+DkuX7utynJBAQpQIDIEeA4K2JrAXe2T2hTJkpiaLQNGsvH67Tt5CZSOn7yApIkSYPi4uejYewQmTF+CR0+fm8rFixsLyRInQPRo0cD/Qi/gFPpD7PMImc4gPZswe7U2WrtYpejRo8HD8z3evvOETCNo2mUEZFqC5/sPUlSNuqoVbRHT3VVbWv4T091NZXq8f69eg1vEiulqGv19+PiZGpVNk/LzD01wxwaVJ/UZ9+vpi7GsvN7SfmAfP32pPIZNXIyRU5chf67MagRb8pkoQAEKUIACFPAvIE9/8vD0hHxnx5jj4hJdrXp6BB0H3LxzH27ap7DFCufF97XK4/L1W+g9aALkC2zqQC6+SMCOAt4vckDC+HFVYLlgYl8sntLflFo2rIK/T1zAP2f/xY6VYzGyfxt0bV33y04WiqNzZkmnBb+ekEeoheIwi0X19MXb5/NTKxIniKeNUGc3eRhtihfKZfEczKAABShAAQo4soDBYICbqys+fPxkYjA+ccHVLYZpX8CVWlXK4NtSRVCq2Ffo17U57mqfJN+6+yBgMW6HQYABrx9avlyZ1NqoqctVgPnOw1NNZ9ix/wRi+o3ePnj0DDIlQb6gpgpHwiJD2hRIEC82+vw6Q31RTr5YJsF3WE8dUl9kSoXML5Y5zdLXMsXzYdfBk+pLePIoFJmbLF9mu3rjblibwOMoQIGIFmD9FKBAlAukTJEE9x58nvp47+ET1abYMd3Va8BFpgxp/JX39ntkqvx7HLAst0Mv4NABr/YGzCQWN3ZMzBrdAweOnlFPSpAnEsgzeg0woHD+7ChfsiDqtByIYjU64PDxc+o4g8GgXmVhMHxel23tMDiZ7TOuGiRDFQCM+6D9ZzAYtKXxz+d1g8GAiUM7w/P9R0ycs1p7/aDm1Jp/TGI8Ss9rSH2RecRL1+xAvm9bYtHqbSiQOwuG9m6hnvKQt1xLlKzdGQtXbYWLC+cQ6fFmGQpQgAIUcEwBecLCpu0H8OTZS7x954G1f+1GpXLFtX/7ff+NHzp2DmYtXGPCKfPNV1i5brt6/u6rN2+xduNuxIsbG+lSJVdlZNDJOL3h46dPnOqgVEJeGEs4dMCbI0s6nN+zAPIEAwGRuambFo/EoQ1TsXfNRBzdNB3lShSAk5MBE37pqPYdWDcZk4d1Ucflzp5BDsP0Ed3Q6oeqat24kC+pzRrd07iJxAnjqWOS+n27Us4rwaQUCHh8xdKFsHXZaMlSKU+ODFgwoS+kbZ1a1IHMqU2TMilev3mnRpxlJDZQev1WHSvnkX6pDW0RUl+kv3v+mKj62qF5Le0IQL7IJxZiIjbSDjm/yuSCAhSgAAUoQIFAAjUrl0ZqLVht2LovajXujk8fP6Fpg+qmcnfuPsDDx09N27Uql0G+3FnV83e/a9oTR06ewy9926mnNUih3kNnIl/5VuqL7ANGzlXrN27dlywmHQIOHfBa8pHRXnmMiMHg+y7MWE72xdfebRm3I+u1U/9J+LHjMPUoNHkOb96cGSG/tGLsjJXo8cu0IFPfYbOCbV5wfXF2dlKPUTEYPvffYDCofWITbMXMpIDNCbDBFKAABcJfQB4DOqxfe/zx+xismDMCU0b1Vf+OGs80c9wADOzR2ripfXIaHf27tcSahWOxZMYwLJ05HNmzpDfly5OgzmuDdOYpfRrf0V9TIa5YFGDAa5HGejK6tPpOG2UtoaZWjOjfBjNH9lCjzoN7NlPP5pXn8wZMMmpsPT1gSyhAAQpQgAKOKRAnVkwkiB9Xd+dljm+SxAlMUx90HxgeBe24Dic77pvddC1bpjRawFsSDWqWVb8MQkZg7aZz7AgFKEABClCAAhSIYAEGvBEMzOopYGcC7A4FKEABClDA5gQY8NrcJWODKUABClCAAhSIegG2wJYEGPDa0tViWylAAQpQgAIUoAAFQi3AgDfUZDyAAvoFWJICFKAABShAgagXYMAb9deALaAABShAAQrYuwD7R4EoFWDAG6X8PDkFKEABClCAAhSgQEQLMOCNaGHWr1+AJSlAAQpQgAIUoEAECDDgjQBUVkkBClCAAhT4EgEeSwEKhK8AA97w9WRtFKAABShAAQpQgAJWJsCA18ouiP7msCQFKEABClCAAhSggB4BBrx6lFiGAhSgAAWsV4AtowAFKBCCAAPeEICYTQEKUIACFKAABShg2wKOEvDa9lVi6ylAAQpQgAIUoAAFwizAgDfMdDyQAhSggC0KsM0UoAAFHE+AAa/jXXP2mAIUoAAFKEABCjiUQJABr0MJsLMUoAAFKEABClCAAnYtwIDXri8vO0cBCnyhAA+nAAUoQAE7EGDAawcXMSq7UKm8Dxo38mIKwaBVMx80CaEMHb3Q7EdvtGjCe0rPvdCyqQ+aal56yjpyGfm5EytHNtDb9xZNvNGssTf/Ptfxd7X8nW7uWr2qN2LE8InKf44j4dy2fQoGvLZ9/aK89V/lioHMGXyYQjAolNcFWTLSKaR7JUdWA/Llcub9FML9JI4FckVDtiygVQhW2TIDBfNEp1MITnJP5cnhjJzZnGilw6pIPhd/ThnS+sDdPcr/SWYDghFgwBsMDrNCFjAYtDJMQAgGjuIUkkNI+eIkKaRyzNduOe2eoxWg516gE6DXiVaAXqtA5cD/rFmAAa81Xx22jQIUoAAFKEABWxRgm61MgAGvlV0QNocCFKAABShAAQpQIHwFGPCGrydro4B+AZakAAUoQAEKUCBSBBjwRgozT0IBClCAAhSggCUB7qdARAsw4I1oYdZPAQpQgAIUoAAFKBClAgx4o5SfJ9cvwJIUoAAFKEABClAgbAIMeMPmxqMoQAEKUIACUSPAs1KAAqEWYMAbajIeQAEKUIACFKAABShgSwIMeG3paulvK0tSgAIUoAAFKEABCvgJMOD1g+BL2AR8fMJ2nKMdpZxo5WiXnf21CgE2ggIUoADAgJd3wRcJnDj/AVeuOTGFYHD09EdcDqFMRDleu2HA6zdfdJl5MAUoQAEKUMCmBRjwArDpKxjFjd+yDVi0xIkpBIO5C6LOad16J3h6GqL4TuHpKUABClCAAlEnwIA36ux5ZgpQgALWJsD2UIACFLBLAQa8dnlZ2SkKUIACFKAABShAAaNA6ANe45F8pQAFKEABClCAAhSggA0IMOC1gYvEJlKAAtYpwFZRgAIUoIBtCDDgtY3rxFZSgAIUoAAFKEABaxWw+nYx4LX6S8QGUoACFKAABShAAQp8iQAD3i/R47EUoIB+AZakAAUoQAEKRJEAA94ogudpKUABClCAAhRwTAH2OvIFGPBGvjnPSAEKUIACFKAABSgQiQIMeCMRm6eigH4BlqQABShAAQpQILwEGPCGlyTroQAFKEABClAg/AVYIwXCQYABbzggsgoKUIACFKAABShAAesVYMBrvdeGLdMvwJIUoAAFKEABClDAogADXos0zKAABShAAQrYmgDbSwEKBCXAgDcoFe6jAAUoQAEKUIACFLAbAQa8dnMp9XeEJSlAAQpQgAIUoIAjCTDgdaSrzb5SgAIUoIC5ANcpQAEHEWDA6yAXmt2kAAUoQAEKUIACjirAgDekK2+j+Tdu3ceRkxd1tf746cu49t9dXWVZiAIUoAAFKEABCtiaAANeW7tiOtu7/8gZzFy4Xlfpucs2YdfBk7rKspB9Cbx5+w4vX73W3SkfHx988vLSXZ4F7UuAvaEABShgqwIMeG31yrHdFPgCAQ8PTwwaMR21m/RA3ea90ennUXj2/GWINe7cdxSN2w2wWO7Dh4/oNmAs2vX6zWIZZlCAAhSgAAUiWyCcA97Ibr51ne/qjbuo32YITp67gu6Dp+LHjsNUA+89eIJO/SeiUOW2aNVzNLbuOab2y0KmHsi+nKWbocqPfdCs6whs3nVEskJMi1ZvQ9nvu0GOLVGrE6Yt+BMyAhfwQGlX3daDMHPRBlVe2jF7yUZ/xa7+dxft+o5Xbew9dAZu33uk8l+8fIOG7Yeq/XKctO/ytdsqjwvbFVi3ZS9u3LqHZbNHYO3CsXB2csL8ZRssduju/Udo0n4gRk5aYLGM3HsTZy3DuYtXLZZhBgUoQAEKUCAqBBjwhqO6h+d7nLt8Az2GTEPGtClQpnh+fPzkpYLc2LHcsXDSz6hTuaQKhu9qQfB7bTSsbZ9x8PbyxpwxvTCwaxPcuvsQz17o+4g5aeIEGKAd8+f8XzGkZ3NMXfAn9v19JlCPpF0Xr9xU83SlXP2aZTBh9mp1LmPhXQdO4pvCuTBleBfcvPMQqzbsUVkGJwMqli6EuWN7YdHkfkiSMB76j5ij8riwXYG9h/5B5W+LI1GCuIgV0x21q5bBlp0Hg3zDJL1MmiQhxgztjo6tGshmkGn52q24ev0WWjWuHWS+w+1khylAAQpQwGoEGPBGwKXY8Ptv6NC8Nlo2rIITZy6rALJOlZLqTOnTJEOurOmx9/BpnDp/FXfuP8ZgLVgtWjAnJKVMlliV07OoUKog0qZMgktXbuG/Ow+QIF5s9Wrp2JED2qBEkTzo2bY+0qZKqrXtX1PRn36shkZ1yqNI/uyoV6MMZA6wZMaNHRP1a5SFx/sPOK2118UlOiR4ljwm2xW4q43gp0iWxNSBFEkTqfXXb9+p14CLaM7O2pud+JD7IWCebO87fBJrNu7C0P4dENPdTXYxUYACFKAABZSANSycrKER9tYGd7cYpi7JdAbZkBHVYRMXQ1L06NEgo64PHz+Du5sr0mhBq5QJbRoxZSlqNOuPbXuPqVFhqVdGi/XUky1TGpy7dCPIorFiuuKdx3uVJ9MhKjTogSFjF+CCNkrMLywpFpteyNQDD09PxNDevBg7Im9kZN3T77rLut506epNjJmyEEP7dVBBsd7jWI4CFKAABSgQWQIMeCNYOmH8uCqoXTCxLxZP6W9KMvqbM0s6LbD0xMvXb0PdiqfPX0Hm8M4b3weTh3VRo7ZZMqTSXY+MLidKGDfE8n9s2oeM6VJCRq1lOkTDWuVCPIYFrFvAYDDAzdUVHz5+MjVUvmwmG65mb9ZkW0/atusQEsSPgz0HjmHGgtXa63HICLKsy1Mg9NQBsBQFKEABClAg4gQY8Eacrao5X65M6nXU1OUquH3n4ammM+zYfwIZ0qZAgnix0efXGeqLbONmrsQ/Zz9PM1AHWljIaK5kyQjy23e+dZ44c0V2WUxXbtyFfAlt3vJNePj4OcoWL2CxrDEjlrsr3rz10EaQX+H+w6emub3GfL7apkDKFElw78EjU+PvPXyi1mPHdFevoVl8XTA3KpT5GnFix1TJTQuaY8SIrtadnZxCUxX46DaZAAAQAElEQVTLUoACFKAABSJEgP8ahSerNnIWsDqZ8zhrdA8cOHrG9KSDnr9Mh0H+18pPHNoZnu8/YuKc1drrBzW31vyj5oD1GbfjxHJH9zb1MGDkXBSu0hZjZ6xQwbPBYFBFDAbfV7Xht2jZfSSK1+yolV2Job1bIGvG1H45gMFgXv7zep2qpSD/lf6uK76t3wNPnr2QTSYbFyhZND82bT+gXc+XePvOA2v/2o1K5Yqb7oPV63eox4sZuynTID5qI8LGKS3m64UL5MIP31U2pSJf5UaihPHVtpubq7EKvlKAAhSgAAWiTIABbzjS586WHuf3LDAFDcaq8+fKjE2LR+LQhqnYu2Yijm6ajnIlfEdX8+TIgAUT+qr8Ti3q4PHTl0iTMik8PD/g5au3FpMEHjIt4uimGdixchzW/z4cW5eNRrP6ldRpG9etAJnuoDb8Frv/mIB9ayfhzM55MH6JTrKmj+iGVj9UlVWV5KkMUpdsJE+SAKtnD8H25WNwbPNMzBjZQ/VR8piiTOCLT1yzcmmkTpUcDVv3Ra3G3fFJC2abNqhuqvfps5e4duOOafvm7fuo0qCTeizZk6cv1PrYqYtM+VyhAAUoQAEKWLMAA95IvDoy2iuPgTIYDKazduo/CfK83u6Dp6rn8ObNmREF82bFuq0H0OOXaRbT3fu+H0HHdHeFBKWmCoNZcXZyQsL4ceDsHPrLniJZIph/GS+Y0zDLBgTky5LD+rXHH7+PwYo5IzBlVF/IvWlseptm32H9kvHGTaRLkwLb/5juL/Xp3MyUb75SrUIJTB/9s/kurlOAAhSIIAFWSwF9ArojH/mC1PhZq/TVylK6Bbq0+k4bbS2BwvmzY0T/NpipjaA6ORnQoGZZ9WxeeT5vUEkeK6b3JCmTJ8avfVoGGnnWezzL2a9AnFgxkSB+XPvtIHtGAQpQgAIU0ASctKTrz9mL1/n8VV1SoSskjweT6QUS4BYvlCtMo68hnVG+GFe7comQitltPjtGAQpQgAIUoIBjC+gOeAvkyYKT565C5o46Nhl7TwEKUIACFLBJATaaAg4roDvgLZQvm0KatXijGum9eOWmv1cvL2+VzwUFKEABClCAAhSgAAWsSUB3wDth1ir1HNmp89eibutBgdKbdx7W1C+2JawCPI4CFKAABShAAQrYmYDugLdnuwZYPv1/FpM8LcDObNgdClCAAhRwYAF2nQIUsB8B3QGvPBUgd/YMkJQpfSpky5xWrcu2pGjOzvajwp5QgAIUoAAFKEABCtiNgO6A95OXF6b9vg4lanVCwUo/YcuuIwqhbZ+x6Dxwklp3vAV7TAEKUIACFKAABShg7QK6A94DR85C5u+WLpYfqZInNvWrTpVS2Ln/H7x8/da0jysUoAAFKOBgAuwuBShAASsW0B3wLl+3Ez/ULoehvVtApjcY+5QnRwa1eu+B72/+UhtcUIACFKAABShAAQpQwEoEnPS249/rd5AlY2qLxV1colvM88vgCwUoQAEKUIACFKAABSJdQHfAmyd7Rvy14294e/v4a+TK9bvVtvk0B7WDCwpQgAIUsCDA3RSgAAUoEJkCugPedk1r4tipS6jWpK/6hRPb9h5Du77jMXPRBnRtXRcxOMIbmdeN56IABShAAQpQgAK2LxBJPdAd8GbNmBpr5g5F+jTJ4fn+I3YdPIkHj55iSM/maNmwaiQ1l6ehAAUoQAEKUIACFKBA6AR0B7xSrQS9U4d3xbHNM3Bu93ysnfcr6lYrBScng2QzUYACFIgIAdZJAQpQgAIU+CIB3QHv4DELsGTNdtPJDAbfIPfytdso+303PH/52pTHFQpQgAIUoAAFKECB8BZgfWEV0B3wPn3+Eq/evAt0ngTxYuPh4+d48OhZoDzuoAAFKEABClCAAhSgQFQLhBjwXrxyE2cuXNNGcN/g3oOnal22Jf1z9l/MWrxB9SFd6uTqlQsKUCBqBXh2ClCAAhSgAAX8C4QY8P7Uawwath+Kk+euYM2mfWpdtiU17jQcW3YfRa/2DeDm6uK/Zm5RgAIUoAAFKECBqBPgmSlgEggx4F0woS/+mPMLCuTOgno1yqh12Za0/vfh2LtmEprVq2SqkCuOJVCpvA8aN/JiCsGgVTMfNAmhTEQ51qzhDVc3H8e6MdlbClCAAhSggJlAiAFvxnQpkS1TGswc1QN9O/6g1tOmSgbZnzFtCj6hwQzTEVe/yhUDmTP42G6KpLYXyuuCLBmjxiljOh/EjumIdyf7TAEKUIACFPAVCDHg9S0GuLhEw9xlm1CiVicUrPQTtuw6orLa9hmLzgMnqXUuHE9APaxDHtjBBARjEOVO4H8UoAAFghdgLgXsWUB3wHvgyFlMnb8WpYvlR6rkiU0mdaqUws79/+Dl67emfVyhAAUoQAEKUIACFKCAtQjoDniXr9uJH2qXw9DeLZA2VVJT+/PkyKDW7z14ol65sGcB9o0CFKAABShAAQrYnoCT3ib/e/0OsmRMbbG4i0t0i3nMoAAFKEABCtiVADtDAQrYlIDugDdP9oz4a8ff8Pb2/23vlet3qw6bT3NQO7igAAUoQAEKUIACFKCAFQjoDnjbNa2JY6cuoVqTvpBfRrFt7zG06zseMxdtQNfWdRGDI7wBLye3KUABClCAAhSgAAWsQEB3wJs1Y2qsmTsU6dMkh+f7j9h18CQePHqKIT2bo2XDqlbQFTaBAhSgAAWsU4CtogAFKBC1AroDXmmmBL1Th3fFsc0zcG73fKyd9yvqVivFZ/EKDhMFKEABClCAAhSggFUKhCrg9fHxwdUbd7H/yBkcOHpWvcq6pE9eXl/UQR5MAQpQgAIUoAAFKECBiBDQHfD+c/ZflKzdGTWb90fbPuMCpbfvPCOifayTAhSggKMJsL8UoAAFKBDOAroD3nEzVyF+3NhYPKU/ti8fg52rxvlLcWK5h3PTWJ0tCGiD/rbQzChvo3w6EuWNYAMoQAEKUIACNiUQfo3VHfA+fvoClcoWQf5cmZEiWSIkS5zAXzIYDOHXKtZkMwInzn/AlWtOTCEYnLzwET42c1XZUApQgAIUoIB9CegOeAvly4YzF67aV+/Zmy8W2LINWLTEiSkEgx27AI6Gf/HtFmQF3EkBClCAAhQISUB3wNuheW3sP3IWc5b+hQ3bDgVKHz9+CulczKcABShAAQpQgAIUiBgB1hqMgO6A999rt1U142etQt/hswKld57vVT4XFKAABShAAQpQgAIUsCYB3QHv7CUbkStremxY+Bv+3jhNPYtXnsdrTHFjx7SmfrEtFKBAUALcRwEKUIACFHBAAd0B77MXr1CqWD5kSJMcsWO5w93N1V9yQDt2mQIUoAAFKEABGxVgsx1LQHfAW6poPhw9edGxdNhbClCAAhSgAAUoQAGbF9Ad8GbJkArHTl3C2BkrsWTNjkDpw4ePNo/BDlDAvwC3KEABClCAAhSwBwHdAe/ew6dVf+ct34ThkxYHSh7vP6h8LihAAQpQgAIUsDMBdocCNi6gO+Cd8EtHnN+zwGLil9Zs/E5g8ylAAQpQgAIUoICdCugOeO20/+xW+AmwJgpQgAIUoAAFKGCVAqEKeA8eO4cJs1dj2MRFgZKHJ6c0WOUVZqMoQAEKUCCSBXg6ClDA2gR0B7x/7fwbP/Uao76stnTtTkjwe/z0Zcj6lt1H4eXlZW19Y3soQAEKUIACFKAABSgA3QHvqg17ULF0IexYOVaxzRnTC2vn/YrWjaohVYokiBXTTe3nQp8AS1GAAhSgAAUoQAEKRI6A7oD3/sOnKFYwF2LHdFcte/zspXqtUu5rnLlwDTdu3VfbXFCAAhSgAAVCIcCiFKAABSJcQHfAG8MlOl6/eQcnJwOyZ04Lmc4grfv06ZO84JWWp1a4oAAFKEABClCAAhSggBUJ6A54U6dMguNnLquml/2mAMbNXImRU5eh/4g5SBAvNnJmTafyImTBSilAAQpQgAIUoAAFKBBGAd0Bb8fmtVGvehl1mlYNq6Ba+aJYuGorYsV0x6gBbRHN2VnlcUEBClCAAhEnwJopQAEKUCD0AroDXpnC8M/Zf9UZXFyiY2T/Nji7az4WTe6HogVzqv1cUIACFKAABShAAQpQIBIEQnUK3QHv2YvXcfHKTX+Vy3xefzu4QQEKUIACFKAABShAASsT0B3wFsiTBSfPXcUnK33e7juP9xHatpev3mLzriMWL5/n+w/4+NH3C3zyxIojJy8GWdbb20fV8/L12yDzI2KnXpuQ+hgRbWOdFIhQAVZOAQpQgAIU0AR0B7yF8mXTigOzFm9UI70y2muevLy8VX5ULOS3vBWq3Ab7/j4TYae/dfchev4yHT4+PkGeo1WP0Rg/a5XK23/kDGYuXK/WAy7kF3RIPfcePAmYFSHbobEJqY9zl23C1j1HI6Sdjlzps+cv4RmK31Qob5os/bx9+PARj5++sHifOrIz+04BClDAkQUcve+6A94JWjD3zsMTU+evRd3WgwKlN+88osxSHpm2atZgFMybNcraMLR3CzSpVzHKzm/pxOFpc/rCVVy7yectW7IO7f679x+hWcdBqN+qL6o36oKx0xbj46fgf2OhvOGaOGspJs1e5u90sn/Ryr9QtWFn/PDTz6jXsg8u/HvDXxluUIACFKAABRxVQHfA27NdAyyf/j+LKaa7a7gajpiyFKOnLUfbPmORs3QztOo5Gldv3EWfYTNRqHJbdOg3AZev3VbnlLnEwyctwd37j9W2HDtmxgq06ztele09dAZu33uk8kJaSOCweuNe1G4xQB3buNNwnDx3xXTY76u2omLDXiqtXL/btF9+E92hY+dM2+Yrh4+fR42m/VQ/mnT5zTwr2PUN2w6h7/BZpjLSpwUrtpi2m3UdYWqbfKmwfpshqs39fpuNs5d8g52ANvIs5YGj5qly4ii/LlrqNVWqrQTVRxnZPXz8Apat3QE5z4CRc7WS/PMlAlPmrEDG9KmwYclEzJs0CHsPntDScYtV7j10QgWym7YfCFTmwuXrWLhiI8b/2gOblk9GhdJFMXTMLMhocKDCFncwgwIUoAAFKGCfAroD3rSpkiJ39gwWU3g/luzmnYdYuWEPShXNh7lje+P23Ueo2bw/kidJiCnDu6irMX/FZvUqCwlK33m8l1XIsSvW7cY3hXOpsrItAanKDGGxcfthDBozH5XKFNHO2wvFC+XCxSu3TEedOH0ZA7o2RtN6lTBk3O8wzsW9efeh9lGy72+fMxXWViTQlmA9V7b0WDS5Pxp/V0Hbq+9PyuSJIEGvTEt4r31UPX/5ZixcvVV9XC31Hjt1CelTJ8ctzaapFkhXLFMIS6cNQIqkidBl4CRVTs5kbvPb5CU4evIi/tetieqfBMS3tLZLOWMKqo/5cmZG1oypUaJIHvRsVx+N6nxrLM7XMAi8evMWx09dQJ2qZeHq6oLUKZOhgnbP7T/8j8XaCufPhamjf0a5koUDlTl09AwK5M2OjQKqHQAAEABJREFUXNkzIXr0aKhdrSyePH2B6//5vikMdAB3UIACFKCAZQHm2J2A7oBXev7k2UvsP3IWW/ccC5RC+ihWjg9t+unHamhYqxy+/ioHKpctgtLF8qFr67ookj876lYrhYNHz1qsUo5tVKe8KluvRhmt3frm967QRm2rVyiGNo2rI0+OjGjbpAZ+qF3OdJ5Jv3ZWQZ/sSxAvNoyPajMVCLCyaecR9Ys5hvVthQK5M6N8ya8ClLC8mStrepUpc6WPnryE/Lky4/UbD1y6egsX/v0PWTKkQry4sbBx+yGk1d6QFP0qJz5pH4mXKpoXDx8/N42Aq0q0hef7D1i39SDaN6sF6aP0L0+OTFqO/z9B9TFp4vhIED82UqVIgkL5sqnftuf/KG6FRuD5c983R8m0N3DG41IkS4JHWpBq3A746uYWA0kSxoebm2vALO24Z0itXRtjRqIEcdWq/MyqFS4oQAEKUIACDiygO+A9c+EaStXpoqYYdB88FQHTOw/PCGV01/6xNz+Bm2sMPHvx2nyXxfVYMV3xzm/012IhvwyZJlEobza/reBfYsdyh4fHh2ALyUisBKIGgyHYckFlyvOOi2sjzKfPX8Wug/9AftmHBKq7D57E6fPXtBHsPOqwW/ceqdHlYRMXQ5L8BjwJjp8+f6XyjQv5MpOs59FG6uVVT9LTRz312GGZL+rSm7e+c96ju0Q31SPX+8VL/9fMlBnCyps37xDDJYa/Um6uct9H7M+lvxNygwIUoAAFKGClAroD3jnL/lKjekunDVRdWTvvVxzaMBXlShRA2eL5ETd2TLU/ohYGQ+gDxrC0JVXyRLhy405YDg3ymMwZUuHew6dB5unZKcHy0VOXtFHcwyhTLD/Kl/gKG3ccxokz/6Jwft/APHGCePi6QHYsntLfX5Jg2fwcKZMlhrs2OihTIMz3h2rdwlMqQlUHCyNWTDel8MnvUXayIU9YiBc3jqyGOsXS3nx9+Oj/zZeHp6e63qGujAdQgAIUCJUAC1PA+gV0B7zyhbE6VUoiZ9Z0qlfyeC0JcpvXr6yNPp7Eoycv1H5bX3yrBZR/aQHl/iNn8MnLC3+fuIAd+0+EuVsy/ULm0MrUBvl4ecmaHaGqq2C+bNj392lkSp8SMq1Ath8/fYlzl28gb07f6QhliudT10Dm+0qbZWR3+bpd6kt+5ieT+boVShXEyKlLsXbzfixZs119Cc28THDrMsXilDbaLPOJ9Y6uB1efI+fFj+875eD+wycmhjv3HiJJwnim7dCsJEmYAHe0kX7jMXKvyXoiv6kNss5EAQpQgAIUcFQB3QGvl99zduXLaamSJ8a/131HQRPE8x2RunNf31MQQgNtMFge1TUYDIFGr7RdpuoNBvNjzddNRYJcadGwKkp+nRdt+4xD3nIt0WnAJDg5aUz+6vt8qHG3k7ai/VEZBsPn82XJkFrNP+41dLqaEnLs9KVAZdQOC4vsmdOoflYpW0SViB7NGZXKFIYEn3G0UT3ZWSB3Fshj0X4Zv1C1uWTtzli4aitcXKJJtkrGJnVqWQfZMqXB7CUbcezUZeTPnRmuLi6qDIyFfLdMS+Pu8iUL4vHTFyhQoTU6ay6mAjpWWMS/QJxYMdWXzNb8tVs9g/f23QfYsfcoShQtoAq+efsO7Xr9hj0HPj+1QX4G5ZebeHt7Q+Zq+677qPLFCudRX4I7d/GaerTZmo07kUgLnjOkS63yuaAABShAAQo4soAWyenrfspkidQXpaR0sUK5MG3Bn9h14B/MXLRedkECO7USTovpI7qh1Q9VTbW1blQNU4d3NW3LyOmxzTNM2+f3LIAEfrIj4LEVSxfC1mWjVSAgv03MUpKRSzdXFwzr2wont83G7tUT8PfGaShbPD9yZ0sPOYfB8DmY3bR4pApm5ZyTh3XBTz9Wl1U0rlsB88b3UetOTgaM+V877F0zUU0BkT5IPRJ0vn7zDpbaYnz6g7zBkH5KnapCbSHB7YqZg7S1z39k9P3opumm80jb0qRMqgrI+Yw2MuI3bnAHSL68yi88SJcmuSoXUh/Ta+VkKsu+tZMwf0JfdQwXYRfo2LIerly7CXkGb4vOQ7RgNz9KFfP9UqO3tw+uXr+FV2/emk6weedBVGnQCfJYsm27D6v1bbsPqfwcWTOg0fdV0G3AGFSp3xEbt+7HgO6ttDdrn+9XVZALClAgqgV4fgpQIAoEdAe8dauVRoqkCVUT2zWpiXcenmr0U77137NtfdOcRFXAShfnLl1Hj1+mWUwydcDYdBeX6EiSKB6cnXUTGQ8N8lUCTZkCYp45dsZKi23pO+zz83fNjwlu3WAwIKjzmB8jz/GVZwzLlw6/azUQF6/cxPfVSpkXCXE9Yfw4kJHmEAuyQLAC8iiyhdOGYums37Bu8Xj06tgE8kgxOShO7JjY/sd01Kj0+dpUq1BC7ZP9xlSpXHEprg3OG9CsQXVsWDoRi6f/ij8XjUPObBlVHhcUoAAFKEABRxfQHc1VKVdEPc5KwCQQ3P3HBMhvN5MR0OYNKstuq0/y5II5Y3rBUpKP7COzE4N7Ngu6LVobZZQ6ItoiT3po0aAKCubNpq7n5iWjkDhh2OaNRkT7HLFO8ZcvE4ZH311juCBpkoQc2Q0PTNZBAQpQgAJ2I+AUmp48f/ka8mWoUVOXYZw2Onnu8n/w5rf2Q0MY5WWTJU6A6hWKqWcLS4BvfFpAlDeMDaAABSgQhAB3UYACFAgPAd0Br/y2sm9qdsLQ8Qvx+6qtKg0ZuwDf1usR4i9fCI+Gsg4KUIACFKAABShAAQqERUB3wDts4iJVvzzr9dT2OTi9c6565qv8hq8uAydDvkGuCkT6giekAAUoQAEKUIACFKCAZQHdAe/V/+6qj8FlHqx8sUaeHiDr8it45Zmst+4+tHwW5lCAAhSgQMQL8AwUoAAFKBCkgO6AN1/OzHjt9+tQzWvKnjmt2gyvpxmoyrigAAUoQAEKUIACFKBAGAUCHqY74JVfdiC/yevgsXPqUVbyOCtJW3YfVb8Y4Y0WDMu2/Ea2gCfhNgUoQAEKUIACFKAABaJKQHfAu2HbQdXGn3qNQd3Wg0xp/KxV6pm83/80WO37qfcYVY4LClCAAtYtwNZRgAIUoICjCOgOeHu2a4Dl0/8XYpr2WzdHsWM/KUABClCAAhSggO0LOEAPdAe88lvIduw/gdzZMwSbsmVK4wBs7CIFKEABClCAAhSggK0I6A54z168rubu2krH2E4KUCBcBVgZBShAAQpQwGYFdAe8BfJkwclzV/HJy8tmO8uGU4ACFKAABShAgS8T4NG2KKA74C2UL5vq36zFG9VIrzyRwTx5eXmrfC4oQAEKUIACFKAABShgTQK6A94Jfk9jmDp/rXoag/mTGmT9zTsPa+oX20KBKBXgySlAAQpQgAIUsB4B3QFvSE9piOnuaj29YksoQAEKUIACFLAGAbaBAlYhoDvgTZsqabBPZ4jm7GwVHWIjKEABClCAAhSgAAUoYC6gO+CVg46cvIi+w2ehYfuh2Hv4tOzCmBkrMH/5ZrXOBQXCJMCDKEABClCAAhSgQAQK6A54z1/+Dy26jcRRLeiVXx/86vVb1awUSROpoNfz/Qe1zQUFKEABClCAAmET4FEUoEDECOgOeJev24VyJQpg58pxyJ8rk6k1Rb/Kodbv3n+sXrmgAAUoQAEKUIACFKCANQnoDnj3HDqJ0kXzwWAw+Gt/3Dix1PaHj5/UKxcRLWBd9Vcq74PGjbyYQjD4tizgZLCua8fWUIACFKAABRxFQHfAmzVTGsgc3oAwh46dU7tSJU+sXrlwLIGvcsVA5gw+TCEY5M/p4lg3BntLgcgQ4DkoQAEK6BTQHfDWr1EGG7cfxrCJi/Dg0TNcuXEHC1ZsQZ9hM1Gr0jeIHctd5ylZzJ4E1IC/jFwyAcEYSBb4HwUoQAEKUIACUSKgO+AtX7IgBvVohj+3HMS1m/cwd9kmjJ6+HFXLfY3eHRpGSeN1nJRFKEABClCAAhSgAAUcXEB3wCtO9aqXxsF1k7Fh4W9YMXOQtj4Fowa2RdzYMSWbiQIUoAAFrFaADaMABSjguAKhCniF6b87D/Hf7Qd49Pg5nj5/KbuYKEABClCAAhSgAAUoYLUC/gLe4Fr5+s079QsnarcYgE79J6LTgEmo0ay/ejbvg8fPgjuUeRSgAAUoQAEKUIACFIgyAd0B77hZq3DmwjV0++l7LJ7SH8tnDFLr8uW1nkOmR1kHeGIKUIACESDAKilAAQpQwI4EdAe8O/YdR8XShdDqh6rInyszcmdLr9bbNqmJk+eu4P4jjvLa0X3BrlCAAhSgAAUoQAEA9oGgO+CV5/AmTZwgUK9LFc2r9r1966FeuaAABShAAQpQgAIUoIA1CegOeOU5vKs37sXL12/9tf/Grftwd3NF6pRJ/O3nBgUo4DgC7CkFKEABClDAmgV0B7ybdx3FOw9PFKveATlLNzOltn3Gqf0FKrRW+6r82Mea+8u2UYACFKAABShAgYgSYL1WKqA74JVfMNGrXQOElJo3qGylXWWzIkLAxyciamWdFKAABShAAQpQIPwEdAe85UoUQLP6lUJM31crHX6tY01WL3Di/AdcuebEZMHgv5tO8NH+93chuUEBClCAAhSgQKQKOOk9W9/hszBmxgrcuvtQ7yEs5wACW7YBi5Y4MVkw2LHLAO9PBge4E9hFClCAAqEX4BEUiCwB3QFv3hwZsWLdblRu1Acd+k3AwWPn4O3Nz7Mj60LxPBSgAAUoQAEKUIACYRPQHfA2rFUO+9ZOwvCfW+Ph4+f4qdcYVGvSF8vX7cIbPpIsbPo8SocAi1CAAhSgAAUoQIEvE9Ad8Mpp3FxdULNicayePQTLpg1EgnhxMHT8QhSp2g4jpy6DPKJMyjFRgAIUoAAFKBDOAqyOAhQIs0CoAl45i5eXt5rOMHvJRvUb1mRfxdKFIc/ordbkZ/T8ZbrsYqIABShAAQpQgAIUoIBVCOgOeF+8fIPfV22FPGdXpjP8e/0O+nVuhEMbpmLc4PbY/+ck/NqnJd6+87SKjjloI9htClCAAhSgAAUoQIEAAroD3oGj5mLU1GXIlD4lZo3uic1LRqFRnfKIGzumqtI1hgtqVy6B6SO6qW0uKEABClCAAlEnwDNTgAIU+CygO+CtVakEti4bjanDu6J4oVxwcuKjlj4zco0CFKAABShAAQpQwFoFdAe88osnUiVPbK39CFO7eBAFKEABClCAAhSggP0LBBvwXrp6C/XbDNGV+Ggy+79Z2EMKUMBuBdgxClCAAnYtEGzA6+ISHSmTJzIl2T53+QYSxI9j2mfMd3IKtiq7RmTnKEABClCAAhSgAAWsVyDYKDVDmuQYN7iDb9Jeu7auq3oiT2Mw3y/r7m4xVB4XFKAABShAAQpQgAIUsCaBYANea2oo20IBClDAWgTYDgpQgAIUsC0BBry2db3YWgpQgAIUoAAFKGAtAqdLEaYAABAASURBVDbTDga8NnOp2FAKUIACFKAABShAgbAIBBvwPnvxGn/t/NuUDh47q86xfd9x0z5j/sePn1QeFxSgAAX8CXCDAhSgAAUoEMUCwQa8/91+gN5DZ5jSzEUbVHOHjl9o2mfMf+f5XuVxQQEKUIACFKAABSgQWIB7ok4g2IA3V9Z02LFynK4UO6Z71PWCZ6YABShAAQpQgAIUoIAFgWADXnnubvIkCaAnOfFXDVsg5m4KhEaAZSlAAQpQgAIUCG+BYAPe8D4Z64sYgSfPXmLb3uMRUvn1W/dx9OSlCKmblVKAAhSgAAUsCjCDAuEowIA3HDGjqqrrN++j26ApX3z6O/cfo/vgqfjk5WWqa9/h05i1xHfutmknV8JF4Nnzl/D0/KC7Lm9vH3h5eQdZXvIePX3u79oFWZA7KUABClCAAg4owIDXAS+6pS6/fvMOW/ccg48WWFkqY2X7bbI5d+8/QrOOg1C/VV9Ub9QFY6ctxsdPn99kBNUpHx8fTJy1FJNmLwuU/ffxs6jVuDsa/dQPlet1xMZt+wOV4Q4KUIACFKCAIwsw4A3l1W/YfiimL1yH2i0GoFDlthg+aTHOXryOZl1HqO1fxi/Ei5dvVK3yKuWlnCQpc/nabZU3cuoyf6Opdx88gZQ9cvKiyg9uIcHP76u2ouz33ZCzdDP8Nnmxv+L3tLo69Z+o2tOq52gVxBoLjJiyFJJ+6jVGHftjx2G4dfeRyh44ap56lXbUbzMEpy9cU9vSD3kyh/Shcafh0NNGdSAXQQpMmbMCGdOnwoYlEzFv0iDsPXhCS5anpOw9dAL1WvbBpu0HAtUnI8TDx89DkwbVsHnlFAzq3QYTZy7F/YdPApXlDgpQwJ4F2DcKUCA4AQa8wekEkXdGCwK3aaOgbZvUxK99WmDJmh1o0X0UKpcpjElDO2HPoZPYdfAfdaTByYCKpQth7theWDS5H5IkjIf+I+aovKb1KmL/kbOYuXC9Gt3r+ct0ZEiTHEXyZ1f5wS027zqKUVrAXLdqKayYOQglv85rKi4jhRLkxo7ljoWTfkadyiVVYC0BtRS6eech/tpxGOW+KYBxg9vj1eu3mLlovWShUZ1v1WuPNvXQs119pEudTG1fvHITbm4xMHlYZ2RImxyjpy1X+7kIvcCrN29x/NQF1KlaFq6uLkidMhkqlCmC/Yd975mgaiycPxemjv4Z5UoWDpR96txleHh6okbFkojm7IxviuRDyuRJcOTE2UBluYMCFKAABSjgqAJOjtrxL+n3/7o3VYFsxdKFkStrenRqURv1a5ZF0YI5tcC3CI6e8v2SV9zYMVG/Rll4vP+A0+evQp56IcGjnDtZ4gRawNkB035fh84DJsHT8z0GdG0iWSGm1Rv3oHqFYmjfrJY6f/FCuU3HnDhzGRLU1qlSUu1LnyaZKrP38GmoHdqiyfcVIe2V9ndoXgv7/j4NGTXOlimNlgsUzJsVhfJlg7Rfdki/eratj68L5ECzepUgfXj56q1kMYVS4Pnzl+qIZEkSqldZpEiWBI+evpDVIJO82UiSML72psM1UP6TZy9UgCv3ljEzbapkePzEcn3GcnylAAUoQAEKOIoAA94vvNIx3V3hY1aHbMvHzLLr6o27qNCgB4aMXYAL2ijpJ7Mvg0l+iSK5VeAqAacE0W7aiJ/sDylduXEHBfNkDbKYTGeQjAmzV2PYxMUqRY8eDR5aQC37A6b0aVJAfqPe46e+gVjA/IDbMd3d1C6P9/xFIwoilIs3bz3UEdFdoqtXWUiw+uLlK1kNdXrz9l2gQNglhgveavtDXRkPoIDjCLCnFKCAgwkw4P3CC+7kbJnwj037kDFdSmz4/TcM6dkcDWuV83e2a//dxYZth5A2VVJMXfCnxW/g+ztI28iTIyMePHqmrQX+kzB+XLi7uWLBxL5YPKW/KbVsWCVwYW3P5au3tCUQL05MGAwGte7tYx7Cq11chJNArJi+bxg+ffxkqvHDh4+IFzeOaTs0K7FiusPDw9PfIR+0TxRiavv97eQGBShAAQpQwIEFLEdrDoyiuh4Oi1jurnijjeg9e/EK9x8+xaoNe0y1vn3niU4DJqF1o2pYMOFnnD5/DTMXbzDlB7dSvFBubNh+CP+cvYLb9x7hj017TcXz5cqk1kdNXY53WiAkSaYz7Nh/Qu2XhTx+7PWbdzh57goW/7FdTc+QUUb5KFzyT52/qo0If9CO5yiueIRniq+9IZH67pt9qezOvYdqfrfsD21KlCAe5KkPH80C6Bu37iFxonihrYrlKUABClCAAnYrwIA3vC+tNkpq/K1zdaqWUrWX/q4rvq3fAzLfUu3QFjLNIW6cWOjQvDaSaMHJmP+1w9T5a/H3Pxe03OD/VChVUBvFjYHGnYah0g+98fzFa9MBMu921ugeOHD0jHpKgzxZQb4QZ4DBVGbTziP4ulp7yBMaYmpBeb/OP6o8N1cXtGtSEy26jUTBSj9pQfhVyGFOWp/g959x1SAZfvv4ol8gTqyYKJA3O9b8tRsy9eX23QfYsfcoShQtYKpk6Ng5mLVwjWnby8sbEtB6e3vj0ycvv3XfUfi8ObOocuu37MUnLy8cOHJKe3P1BEW++jyvWxXgggJfIMBDKUABCti6AAPeUF7B83sWIH+uzKaj5ozphabfVzRtt29aU30ZTXYkT5IAq2cPwfblY3Bs80zMGNkDcrzkjRrYFsumDUT0aM6yiVJF86o8eUqDfCHMUpKR4UQJ4mLN3KHYsWIsTmydhVmje6pjVUXaQtq3afFIHNowFXvXTMTRTdNRrsTngOqnH6up9hzeOA3zxveB1Kcdpv50bFEbx7fMUscWLZhTfUlN6leZ2iJxwnjqXEkTx9e2+CcsAh1b1sOVazfVM3hbdB6iBbv5UarYV6aq7mhB8MPHT03bm3ceRJUGndRjybbtPqzWt+0+pPLd3GJgSN92mLFgtXoG75BRM9GpdQMkT5pI5XNBAQpQgAIUoAAQTgEvKYMTSJEskRqRDa6MMU+mQPT4ZRospfnLN6uiBoNBC2oSwjWGi9oOaiGjvRLMGgyGQNnuWqAUJ5Z7oP2yQ0Z65VhZZwp/AXkU2cJpQ7F01m9Yt3g8enVsAvliofFMM8cNwMAerY2bqFahBLb/Md1fqlSuuCm/WKE82LJyKhZN/xWblk9GjUq+nyyYCnCFAhSgAAUo4OACDHit7AaQ5+fKqLGlJCOwX9LkH78r7++5vV9SF4/9MgEZLZcvGH5ZLb5HOzs7QR51Zh44++ZwGekCPCEFKEABClidAANeq7skEdug4oVyIWvG1BF7EtZOAQpQgAIUoIDDC1gTAANea7oabAsFKEABClCAAhSgQLgLMOANd1JWSAEK6BdgSQpQgAIUoEDECzDgjXhjnoECFKAABShAAQoEL8DcCBVgwBuhvKycAhSgAAUoQAEKUCCqBRjwRvUV4PkpoF+AJSlAAQpQgAIUCIMAA94woPEQClCAAhSgAAWiUoDnpkDoBBjwhs6LpSlAAQpQgAIUoAAFbEyAAa+NXTA2V78AS1KAAhSgAAUoQAERYMArCkwUoAAFKEAB+xVgzyjg8AIMeB3+FiAABShAAQpQgAIUsG8BBrz2fX31944lKUABClCAAhSggJ0KMOC10wvLblGAAhSgQNgEeBQFKGB/Agx47e+askcUoAAFKEABClCAAmYCDHjNMPSvsiQFKEABClCAAhSggK0IMOC1lSvFdlKAAhSwRgG2iQIUoIANCDDgtYGLxCZSgAIUoAAFKEABCoRdIDIC3rC3jkdSgAIUoAAFKEABClDgCwUY8H4hoKMfXqm8Dxo38mKyYPBtWW84R/Nx9NuE/TcJcIUCFKAABaJCgAFvVKjb0Tm/yhUDmTP4MFkwSJdGgl2DHV1xdoUCFKAABSgQDgKRXAUD3kgGt7fTGSSWYwKCMwD/owAFKEABClAgKgUY8EalPs9NAQoEJ8A8ClCAAhSgQLgIMOANF0ZWQgEKUIACFKAABSJKgPV+qQAD3i8V5PEUoAAFKEABClCAAlYtwIDXqi8PG0cB/QIsSQEKUIACFKBA0AIMeIN24V4KUIACFKAABWxTgK2mQCABBryBSLiDAhSgAAUoQAEKUMCeBBjw2tPVZF/0C7AkBShAAQpQgAIOI8CA12EuNTtKAQpQgAIUCCzAPRRwBAEGvI5wldlHClCAAhSgAAUo4MACDHgd+OLr77rlkj4+lvOYQwEKUIACFKAABaxBgAGvNVwFG27DifMfcOWak9Wlqzec8PKlDcOy6RSggHUKsFUUoIBNCjDgtcnLZj2N3rINWLTEyerSqlVOeP3GYD1QbAkFKEABClCAAlEmwIA3/OlZIwUoQAEKUIACFKCAFQkw4LWii8GmUIACFLAvAfaGAhSggHUIMOC1juvAVlCAAhSgAAUoQAEKRJBAlAe8EdQvVksBClCAAhSgAAUoQAElwIBXMXBBAQpQIMoF2AAKUIACFIggAQa8EQTLailAAQpQgAIUoAAFwiIQ/scw4A1/U9ZIAQpQgAIUoAAFKGBFAgx4rehisCkUoIB+AZakAAUoQAEK6BVgwKtXiuUoQAEKUIACFKCA9QmwRToEGPDqQGIRClCAAhSgAAUoQAHbFWDAa7vXji2ngH4BlqQABShAAQo4sAADXge++Ow6BShAAQpQwNEE2F/HFGDA65jXnb2mAAUoQAEKUIACDiPAgNdhLjU7ql+AJSlAAQpQgAIUsCcBBrz2dDXZFwpQgAIUoEB4CrAuCtiJAANeO7mQ7AYFKEABClCAAhSgQNACDHiDduFe/QIsSQEKUIACFKAABaxagAGvVV8eNo4CFKAABWxHgC2lAAWsVYABrxVdmZev32LzriPw8fEJ11a9fOVbr95Kr9y4g3/O/qu3OMtRgAIUoAAFKEABqxZgwBvJlye409259xg9f5kOL2/v4IqFOu/W3YeqXr2B9PZ9J7Bg5ZZQn8dWDvjw4SMeP32h+43Fm7fv8PLVa1vpHttJAQpQgAIUoEAAAQa8AUC4ab8CEvAvWvkXqjbsjB9++hn1WvbBhX9vWOywh4cnBo2YjtpNeqBu897o9PMoPHv+0lR++oLVKP9dO3+pa/8xpnyuUIACwQowkwIUoECkCTDgDYF6xJSlWLp2J6YvXIfGnYZj007fKQcr1u1ClR/7oEStThg/axUePH6mavL29sG85ZvU/pylm6FVz9HqOJUZykWfYTNN9dRo2g9b9xwz1SDtGj1tOdr2GQvjea7euAs5plDltujQbwIuX7ttKi8rMxatR9nvu0Hy5yz9S3ap9E4L7AaPWaD2S3/WbTmg9svixcs3aNh+qMqT45p1HRGoXilnC+nC5etYuGIjxv/aA5uWT0aF0kUxdMwsyDULqv3rtuzFjVv3sGz2CKxdOBbOTk6Yv2zD56I+Pvi6YG7MnzzElPp1b/k5n2sUoAAFKEABCliFgHUHvFZAdPPOQwybuAg3IMHOAAAQAElEQVRXrt/FtyW/QrIkCbBp1xGMmbESHZvXwazRPXHj9n1Mnf+nau26rQcwVstrVr8yVs8eghyZ04Z5Pmye7BkwZlB7rJs/DDUqFkf3wVO1j9bfqvNIu1Zu2INSRfNh7tjeuH33EWo274/kSRJiyvAuqsz8FZvVq3Fx4+Z9DOnZHPWql1ZB+p37j1XW6OkrsO/IafTt+IN2bFdkSJtC7ZeFwcmAiqULaefohUWT+yFJwnjoP2KOZNlcOnT0DArkzY5c2TMhevRoqF2tLJ48fYHr/90Osi97D/2Dyt8WR6IEcRErpjtqVy2DLTsP+psKIftTpUgCY0qSMH6QdXEnBShAAQpQgAJRJ+AUdae2nTO3blQN4wa3R9PvK6JA7sxYpo34VihVEOnTJFOdKK0FnVt2H8UnLy+s2bQftSp9g5YNqyC7Fux+UziPKhOWRYOa5RA7phvOXLyGT5+8VBW37z9Sr7L46cdqaFirHL7+Kgcqly2C0sXyoWvruiiSPzvqViuFg0fPSjFTGjmgDUoUyYNe7RsgbaqkOHbqEj5+/ISV63drwXttfFe1JPLmyIjcWqBtPChu7JioX6MsPN5/wOnzV+HiEh0Xr9w0ZtvU66Onz5BaC06NjZZAVtafPPs8TUG2jenuvUdIkSyJcRMpkiZS66/fvlOvsjh17jJGTf4dMxf8gbMXrsouJgpEiAArpQAFKECBsAsw4NVhF9Pd1V+pm3ce4Pjpy9rI72KVJMjNmjE15OP//7TR3gK5s/grH5aNt+880azrCDTtMgJHTl6EpxZwSj3eXkF/oc3dLYZkm5Kbaww8e/HatB1wJVumNDh36YZpKka+XJkDFlHbMk2iQoMeGDJ2AS5oga4E9SrDBhdv3rxDDJeATq6QKR0BuyPzfT08PbXy0U1ZLlqwLxueHu/lBZkzpEHFssXU6O79R4/RfeBY7D10QuVxQQEKUIACFKBAhAiEqVIGvGFgS5o4AX78rjwWT+nvL8mIYZECOfDf7QdhqNX/IX+fuKCmQuxYORYj+7dRI7f+S/jfMhgM/neEsHX+8n9IqH1UnyxJQlXy4SPfOchqw2zxx6Z9yJguJTb8/puaDtGwVjmzXNtajRXLHR8+fvDXaAlq3d38v6GRAgaDAW6urlr5T7KpkjzdQVZc/d5cfFuqCJo1qI4fvquMwb3bQra37T4sRZgoQAEKUIACFLAiAQa8YbgYMp1h1uINOHvxOry0Eddbdx9h3MyVqiaZMrB83S71xbUN2w5h1LRlan9oF8ZR5QdaICrP0ZUvzoW2joDlb997rEaKV23cA5m/W/LrPIgezRnlShTA4jXbcevuQ9WnXQf+MR0ay90Vb956aKPFr3D/4VOs2rDHlGdrK0kSJsCde5+nhBinMiTSAv+g+pIyRRLce/C5/L2HT1Sx2DHd1WvAReKE8bXRYt/R34B53I5kAZ6OAhSgAAUoYCbAgNcMw9KqweB/9LRZvUqoVr4YGrT7BXnKtUDlRr1xRgt+5fhKZQqrL4Wt3rgXMjoq0xuCGkGUsgGT+WkK58+O8iULok7LgShWowMOHz+nihsMn9tiMHxeV5lmC4PBANN5tXXJ+q7V//BVxZ8gT2To06EhcmVNL7vRvH5lHD15SetHH7ToPgryhS6VoS3qVC2lLYHS33XFt/V74MmzF2rbFhfFCufB8VMXcO7iNXz85IU1G3ciUcJ4yJAuterO6vU70G3AWLUui5JF82PT9gNan1/i7TsPrP1rNyqVKw6DwSDZmLv4T9y8fU/VdfnaTfy5aQ8K5suh8rigAAUoQAEKWIMA2+ArwIDX18HicvqIbmj1Q1V/+TKXUwLG0zvnYteq8Ti+ZRYWTOirykRzdkbPdvWxafFItS9xwriQ+bIyJ1RGai0lmbObI0s6nN+zAFKHk5MBE37piL1rJuLAusmYPKyLyjN+oSxgu1o3qoapw7uqNshCvrh2bPMMWUXubOnVsYc2TMXWZaNVe5t8X1HlySJ/rsyQvG3Lx+DvjdOwbNpATBraWbKQPEkC9bSJ7Vresc0zMWNkD1WXyrSxRY6sGdDo+ypaUDsGVep3xMat+zGgeyuItXTl6bOXuHbjjqyqVLNyaaROlRwNW/dFrcbd8enjJzRtUF3lyeLkmUto1XWoqqtj7xEooQXI31UvJ1lMFKAABShAAQpYkQAD3i+4GBKYJk0cH26uLqZazmijh+XqdUen/hPVM3gnzF6N9k1rqmkBPX6ZBktp/vLNpjrMV+Tj9vhxY5vvCvO6TF9IlTyxv/YaK5O8lMkSwdk56FsihZYX8ItxxmNt5dVgMEDm3G5YOhGLp/+KPxeNQ85sGU3Nb9PsO6xfMt60LSPkw/q1xx+/j8GKOSMwZVRfyPUwFpBteT7vgilDsGHJRPTq2ASuMT7fC8Zy1v/KFlKAAhSgAAXsWyDo6Ma++xyhvZOnNfzcqRGKFsyFWhW/gYyaFi2YE7FjuWPOmF4WU8cWtSO0Xaz8s4AEpUmTJDSN7H7OCXotTqyYSBA/bpCZsWK6I2XyJHA1e9MTZEHupAAFKEAB6xdgC+1WwMluexZFHZNRQZl7+0PtcqhWvihk1DSKmsLTUoACFKAABShAAQpoAgx4NQT+oUAoBFiUAhSgAAUoQAEbE2DAa2MXjM2lAAUoQAEKWIcAW0EB2xFgwGs714otpQAFKEABClCAAhQIgwAD3jCg8RD9AixJAQpQgAIUoAAFolqAAW9UXwGenwIUoAAFHEGAfaQABaJQgAFvFOLz1BSgAAUoQAEKUIACES/AgDfijfWfgSUpQAEKUIACFKAABcJdgAFvuJOyQgpQgAIU+FIBHk8BClAgPAUY8IanJuuiAAUoQAEKUIACFLA6ARsOeK3Okg2iAAUoQAEKUIACFLBCAQa8VnhR2CQKUIACoRJgYQpQgAIUCFaAAW+wPMykAAUoQAEKUIACFLAVAUvtZMBrSYb7KUABClCAAhSgAAXsQoABr11cRnaCAhTQL8CSFKAABSjgaAIMeB3tirO/FKAABShAAQpQQAQcKDHgdaCLza5SgAIUoAAFKEABRxRgwOuIV519poB+AZakAAUoQAEK2LwAA16bv4RR24FK5X3QuJGX1aXv63ohdiyfqMXh2SlAAQpQwI4E2BVbFmDAa8tXzwra/lWuGMicwcfqUqb0Pogb1wqA2AQKUIACFKAABaJcgAFvlF8C226AwaC131qT1rTI/sPzUYACFKAABShgfQIMeK3vmrBFFKAABShAAVsXYPspYFUCDHit6nKwMRSgAAUoQAEKUIAC4S3AgDe8RVmffgGWpAAFKEABClCAApEgwIA3EpB5CgpQgAIUoEBwAsyjAAUiVoABb8T6OkTtKRK6gSl4AycDkCxB8GVo6Ib4sV3g5uLM+0nHz5RLdCckihODViFYJYnnimjOBjqF4CR//8R0jYZ4MaPTSoeV/OMuZpGZ5JxMYRdwCvuhPDJyBXg2ClCAAhSgAAUoQIGwCDDgDYsaj6EABShAgagT4JkpQAEKhFKAAW8owVj8s8DrN+/w/OXrzzscfM3b2wcPHj/DJy8v3RJSVo7TfYCdFAzNvSNG9x89w/sPH+2k96HrxpNnL+Hh+UHXQWJ05/5jPHvheD+XH7T74+Hj5/Dx4W9YDOlmCc09FVJd9pwvfzeH9u908Xj6/BUkyTqT9QjYa8BrPcJ22JJ3Hp7o1H8ivq7WHt/U7ISG7YdC/gK1w67q7tLew6dRpGo7lPu+O/KWa4mVG/aEeKwEMXVaDMSmnX+HWNZeCoT23pm9ZKPy/LZedxSo0BrdB0/Fy1dv7YUj2H7cuvsQVX7sg1J1uqBgpZ8wcNQ8fPxk+c3UgJFzlVHFhr1QolYnNO40HC9evgn2HPaQKQHutN/XIb92f5T9vhtK1u6M0xeu6eqa/NzmLN0M8goH+C+099TIqcsgPubpx47DHEAK6p4Izd/pEhzL31fysyf3YKUfejuEky11kgGvLV0tK2nr0rU78e/1O9i9egL+3jgNzk5OmDjnDytpXeQ3QwLXnr9MR8cWtXF651xMHNoJQ8YugIy0WWrNmBkrVBBz7eY9S0Xscn9o7514cWNh7rjeOL5lFtbO+xXHTl3C2s377dImYKd+nbAI2TKlUX3fuPA3bNl9FFt2HQlYzLSdOkUSrJw5GKd2zMXmJSPx3+372huv3QBMRexy5dT5q5g6fy0WTe6HU9vnoFalEug2aAokAAmuw5ev3Yb83AZXxt7yQntPyZuJ0sXyYdPikaY0ZlA7e2MJ1J+w/J0+ftYqLFy1FW2b1MT+Pydjw8LhgerljqgVYMAbtf42eXb5h7dutVJIkigeYsdyR+O65bFm0z6H/Sjx6MmLkJHLhjXLIpqzM74t8RXSpkqqjRCcsnh9WzWsip2rxiFp4vgWy9hjRmjvne+rlcbXBXLAzdUFWTKkQuli+bHv79P2SOOvTy9fv8XBY+e0n60Kqu/p0yRHrUrFsW3vMX/lzDfaNK6OnFnTIXo0ZyRPklBlxYsTS73a82LXgZMoWjAnCuTOgujRoymzh4+f4/K1Wxa7/fjpC7TrOw6DujeFu5urxXL2lBGWe0r6L3/Hy99nxpQscQLZbdcptH+ny/00b/kmdG9TD43qfIsE8WLDEZxs7SZQAa+tNZrtjVqBm3ceIk3KpKZGyMiSbLx6805eHC49fPJcBbguLtFNfc+YNgUePHpu2g64IiOX8hdi9GjRAmbZ9faX3Dvycf7BY2e1oC69XRtJ555oAZm8pkqeWF5Ukp85mcusNiwsZB7rjIXr0aTLb8ifOzOqlPsa9v7f/UdPkT51MlM3kySKp9YfPXmhXgMuZPSuY7+JqFO5JKqVLxow2263w3pPSfDX77fZGD1tOU6c+ddufcw7Ftq/089cuK4OP3fphppK1KrnaKzfdlDt48J6BBjwWs+1sImWyEdcMprpGsPF1N4YfoHeu3eepn2OtPJKG40LOEoUQ/ORL2Y5kkNIff3Se+fXCQvx+o2HGsEL6VxfkG8VhxrfPJq/iZJ76tmLV8G2z8vbR003evnqDV69fofXbz2CLW8PmfLz5xojhr+uyM/jm3eB+y7THPqPmIOU2huJ9s1q+TvG3jfCck/lzJIOtSuXQDrtDcXt+4/QpPNwbN1z1N6ptJ+dt4FG/uXn77WFQR35YpugJEoYF83rV8JXebLg5+Gz8ZcDfT9D+m/tiQGvtV8hK2ufwWBQfxHIt8GNTTOuu7u7Gnc51Guc2DHVlAbzTr9//0FN9zDf5+jrBkPY751pC/7E6o17MW98HzWVxt4t48RyV138+PGTepWF3FMJ4sWRVYvJzdUF4wa3x1+LRiBaNGc1t9ViYTvJkJ+/9x8++OuNvCmP5e7mb59syJdrJWCLHcsNY6Yvx6ipy9TP7soNu7VAzvJ0ETnW1lNY7qnqFYqhU4s6+OnH6pg0tDNk2xHm0Ms9JfeQ+TWXnz+Z3mG+h5llkgAAEABJREFUz3xdPtVr16Qmyn5TAPIqVtv3HjcvYoPr9tVkBrz2dT0jpTcyl0u+7Ws82e17j9Sq8S9UteFAi6SJ4kM+qjcPTuRLfcmSONb8XD2XPLT3jozIyUep81dswapZg5E7m/1PZxDHRAl9P5Y3/mzJvv9uP0DyJPrmTxoMBmRIkxzGkSc53l5T8iQJITbG/hmnMhinNhj3y2usmK7o0uo7pEyWCDKtSJLvfjftjXwMWbXb9KX3lMDINKy3797Lql2n0P6dLlOP5AvIMu3KCPPpkxc+fvr8htW4n69RJ8CAN+rsbfbMFUsXwqoNeyD/sLzRPjJdtHo76lQpCYPBYLN9+pKGF8qXTR2+7M+d6hm8O/afUE9oKFU0n9ovH4PVbT0Im82+YS/PljUGyPKXonFdHWBDi9A2NaR7Z8HKLWoOnLHe/42eB9k3bnAHxI0TC3cfPFFJ/Ixl7PE1rvapgXwRS362ZM7pjVv3sX7bIVQoVUh1N+A9JT+H42auhJT7qP1DK4/lWrv5AArl9b031UF2uij7TX71Bb9/zl7RAgwvLFy9VX0ZNGvGNKrH8mQP+fmTN6Uy1UFGK82T7KtS9muUKJJHlbfXRUj3lPS7++BpkCfIyLokefLAtf/uKtdzl29gyZod+KZwbsmy6xTS3+nm95RA5M+dWXvD5IqZC9fDy8tbPRZP/r4vXsj+raT/tpIY8NrKlbKidv5Q+1tkSJsCZep2Vc+elWBNPvayoiZGalPc3WJg8rAukGdWyjN4uwycjAFdG0Pe9UtDZJTy4pWbePHqjWyq1HvoTOQr30oFxvL8VFmXYEVl2vEipHvn8ZMXuHT187fr5R8W4WjbZywqNOhpSnfvP5Hddp36d/4R57UgQ57BW63Jz1qwWxCVyhRWfQ54TxkMBhw6fh5SLt+3LfFD+6GqfLP6lVR5e17ky5kJbZvUQONOwyB9X7FuN8YOag8nJ9834DKXV37+PN/7n/ZgzyaW+hbcPSXH3Lh1D/e0N5WyLunvExdQo1l/5Vq/zRB1TzWtV1Gy7DqF9Hd6wHtKPt2cNLQTfl+1FXnKtVA/fz/ULod6NUrbtZOtdY4Br61dMStob0x3V0wf0Q2HNkzF3jUTsWLmIIeYVxkcfdni+XFm5zxsWz4Gp7bPQcNa5UzF48aJifN7FvjbN25we7VP9huTPHoKdv5fSPdOr/YNcGzzDJPC1mWjAzmJl0yNMBWy0xW5H6T/u1aNx9FNMzCsbyvIY7ekuwHvKXFdPXuIKrd5yUjNcKYqb/xCqRxjr8lgMKh5pie2zsJ27efvyF/TkT9XZlN3yxTLr+6hrBlTm/aZr8j9VqpoXvNddrse3D0lnZZnXY/TPk2RdUnyd7s8a13uKXkWttyDrjFcJMvuU3B/pwd1T8knMoc3TlX/Bsg91b9LY8hjKu0eyoY6yIDXhi6WtTVVPiJLlCCutTUrytrj7Oyk5gYag5JADeEOkwDvHRNFiCvyrGYJaEMsqBWQcvL4Mhmh0jYd6o8EYimSJTKN7DpU50PZ2dDcU/JFLbmn3FwdI9A1pwzt3+kS4Mr8cJkmY14P161DgAGvdVwHtoICFKAABSjgMALsKAUiW4ABb2SL83wUoAAFKEABClCAApEqwIA3Url5Mv0CLEkBClCAAhSgAAXCR4ABb/g4shYKUIACFKBAxAiwVgpQ4IsFGPB+MSEroAAFKEABClCAAhSwZgEGvNZ8dfS3jSUpQAEKUIACFKAABSwIMOC1AMPdFKAABShgiwJsMwUoQIHAAgx4A5twDwUoQAEKUIACFKCAHQk4ZMBrR9ePXaEABShAAQpQgAIUCEGAAW8IQMymAAUoYMcC7BoFKEABhxBgwOsQl5mdpAAFKEABClCAAo4rEHLA67g27DkFKEABClCAAhSggB0IMOC1g4vILlCAApEjwLNQgAIUoIBtCjDgtc3rxlZTgAIUoAAFKECBqBKwufMy4LW5S8YGU8D2BF6/eYddB/7B0+evAjX+n7P/4vSFa4H2c4ftCBw8dk5dX7nGkp69eG07jWdLKUABhxBgwOsQl5mdpEAUCJid8s79x+g0YBIuXb1lttd3dfys1ZixcL3vBpfhLnDk5EXkLN0Mt+4+Cve6jRXOXfoX+gybpa7xmBkrcPtexJ3LeM6wvjbuNBwDRs4N6+E8jgIUsFEBBrw2euHYbApQgAJ6BHy8ffyKGV/9NsPxZd74PmhU51tV46bFI5E3R0a1bo0LHx8fSLLGtrFN9ivAnkW9AAPeqL8GbAEFKOAnsHLDHjTrOgLvPDz99vi+jJu5Ev1HzFEbK9btQueBk7Bw1VbUaNpPjV526j8RT569VPmy8PLyxu9m+bVbDMDWPcckSyWZQvFjx2G4dvMeJs9bg1Y9R2Pp2p3QU/eCFVtQ5cc+KFS5rUpyrNSnKtYWsh5U3YePn0fd1oPUMTLiKm1av+2gdoTvHw/PD5DjpB3dB09V5aR/ew+fxvnL/+GnXmPUPum7nMP3KN/l/iNn1bFSb8WGvTDt93X4+MkLDx8/xy/jf1eFug+epsoMHrNAbYfVSB2scyGeXf83Bcu1ayZ9EbO+w2fh5eu3qo3S1rLfd8McbYRY+i/Vyqs4LFi5RV1nOUbKrd28X7JNSUzkXjH2Wa7jx4+fTPkDR83DvOWbsP/IGfQeOgNSdtLcP3Dy3BVs23tcWch5zly4hgePn6n8ErU6qftJ2jRh9mplaKxQ6pN9ci9KvrRJ7oUPHz4ai+DNWw+MmrrMdH/IObfvO67yQ/JWhbigAAUiTIABb4TRsmIKhEbAMcqePHvF31xPme/59PnnQDV/rkw4duoSNu08YgJ59OQF5i7bhBxZ0qp9dx88wc79/6ggqnqFYpC06+BJSCClCmiLiXNWY8q8tShdLB8mDu2EjOlSorsWRBoDxVdawCWBjwRh27XgJ2H8ONpRgJ66X799hwqlCmFIz+b4X7cmeP36HVr1GK2CHanklYW6X715i9zZM2BA18YYN7gDsmRMjZ+Hz8Y/mokc9+nTJxWMDZu4CC4u0dG9zfeIGdMN7X8ej3ptBiN50oTo9tP3uH33EQaafSQvAV3bPmORKkVi1deKpQth6vy1WLR6K9zdYqB4oVxSPcpoFlW//RpFC+ZQ22E1UgfrXIinBHzzl2+GXKdm9Spiw7ZDKFa9A7bsOoL6NcugarmiGD9rFQ4eO6tqNTqMnrYccWLFRJvG1dV+mYZgtJLpGWLy6MlzDNSuwddf5VDTYoZPXqLKyuLilZsYO2Ml2vYZh7faG6g4sd2RI1M6JE0cHxnSJIdYSEqUIC4kaE0QLzY6Nq+NCb90RN1qpTF7yUYsWLEZxv+kPtknbWhWrxJKfp0Ho6cvx5GTl1QRCWhbdh8FeaP19Vc50a9zIySIFwd//LVX5YfkrQpxQQEKRJgAA94Io2XFFKBAQIHpC9epeZ4yn9eYbt55aCqWOX0qFMqXDUvWbDftM47sVStfzLRPgpN184ehdaNqGNHvJ7RtUgMygnr/4VPIF+MkQJZ93dvUw7clvsKI/j9pwZ8rNmtBlqkSbeW3fq2x/vfhGNm/DX6oXU7bAy1IiQ1LdUuBTi3qoGvruqhQuqAWPOZEs/qVICPS17XRYsk3poB1VyxdGIO6N0UNLUj/ukAOLZCroYqePn9VvRoX/bs0hvSpYa1y6NvxB7V79MB2KsCWNkqfZGRaRiUlU0Yci2tBrRwjfZV8CXr/3HwAsWO5o9w3X0kxFXBKndKOLzVSFepcqGu1wPdaddACyhJFciNj2hT4Y84vaNGgCnq0rYdcWdNrAe85fzUO6tEMv/ZpiVY/VMWauUNV3vqtviPiEszLjmXT/4cGNcsqm+YNKmPl+t2QN0iSJylPjozY/+dkTB3eFZOGdsa3pb5CiqSJkCl9SoiFpBTJEiFNyqTqTUh9ra5iBXOpa5Q/V2acOHNZqjGl8iULYtHkfmjyfUXIdZJ+7Pv7lMrfc+gUzl2+AblW8kaoduUSWp3t8UuvlqG6J1Vljr5g/ykQAQJOEVAnq6QABSgQpMCMkd1xeudcf0kCC/PCMhf03+t31GinfCy/+I9tKhiNGzumqZi7myuiR49m2s6XM5Nav//oKW7cuq/WJfiRKQSSGrT9RQWlAb9MVShfdlXWfBFc3VJOvngn0xjylmuJUnW6oOcv02U3PN9//mhbdgSs+/nL12paRuEq7VCsRgdUb/KzFIPH+w/q1biIFyeWcRUSLMqGBK7yKsk4Gv3o8XPIR/hiJaOP0k9j2n/kLCQolvJBpS81CqpOS/vE0zWGiyk7UYJ4cHON4e/6JUkUD/cfPjGVkZVY7m7yolJMd1dkz5wWt+76vjm6dPW2CpLN74ki+X2v5X+3H6hjZJEtUxqToWxbSp+8vCBvxsp+3w2Fq7RFxYa91P339t17f4fE10aBDQaDaV/K5Ilx575vuy9fv632F/UbQVcb2kL6Fhpv7RD+oQAFIkCAAW8EoLLKCBfgCWxUwMnJCdGcnf0lg8EA8/9KF8uvghSZ97nn0Ek8e/Ea9WuUNS8SaN3Ly1vtc9bqljmgsiGjcF1afQdjkmC7bZOakhWqZF63zD39rtX/8PadJ+aM6YVdq8bjz/m/6qqv/c8TsO/v0xjcsxk2LxmJY5tnqn4Gd7CzU+C/osXQeMwHvzmrMopr7Ke8jhvcHjNG9jAWC/Qa3kaBThDMDmfnwH0yOPm/B4I63EsLSqNFc1ZZMgVBgmC14bcwBtVSzm+X7pdpC/5UU2Aa1SmPtfN+xeGN09SIeEgVRDPry3u/Ny6uMWIEOiwqvQM1hjso4KACgf/mcVAIdpsCFLAOgehaUPPjdxWwcfthTJ67Rk0bkI+gg2vdoePnVXaalEmQNlVStS71lCiSB+YpV9Z0Ki80C/O6z1y4rg7t3b6BapfMB43hEl3tC24hX2aSL0c1rVcJVct9rT5Cl/m1wR2jJ0+CvgTaqOOrN+/89VP6/E1h37m7MWL4tu+92ZerwttIT1u/pIx8IfFfbdRfprxIPenTJoc8bs0YSMq+Y6d9px+kTJ5INi0mcTc/TgoePHpOzXVu2bAKsmRIhTix3OEU4I2YlAsupUudTGUf92uH2tAW8oYpYr21k/APBSgQogAD3hCJWIACFIhsgTpVSqhTysfyjfwed6V2+C1k1HfrnqM4e/G6+mKSzPmtW60U4seNrQWTSVCuRAEMGfc7Vm/cq6Y4SBAic10nzvnDrwbLL8HVndMvYF61YQ8kgJUvZHUfPM1yZX45sWK6qY/k5QtyR09eUvONZSqEnMuvSJhf2jWtBbGQ/l25cUc90UE82vQeq+rMmcU3yJc2S9AoX7qSNwZfYqQqNltcv3Ufj5++UHsuX7sNmdOsNr5gse/IafULSaRvHbTRcalKvuQmr/Wql5EXNUVEvogoT/dYtnaHClrTpPR9w6MKBLEo+lVO7D9yBnJPyDWUOb+F82fHyXNX1Zchpe9BVYEAAAc4SURBVD554sM6v/nCQVQR5K6y3xRQI/a/TV6MNZv2qftOnrjx8/BZX3xPBnlC7qQABUIl4BSq0ixskwJsNAWsRUDvqFnihPHUl9dkBFVGKwO2XwKqXycsQoN2v6hHT9WsWBy92zeE8b+hvVuiXo0yGDRmPqo1+RlNu/wG+fJb1oypjUXUa1CDeMHVnUAbTe3VrgG27zuBhu2HQh65ZawzYF0Bt+UJCy9evUHzbiMgc4CNH+0byxkMgT/WNxh89zk5+b5Kow0G33WDwfe1vtbPPh0aYtmfu1Cr+QD1RIfhk5ZA5q9KeXniQ28tX76wJ49CkycLyP4vMZLjzVOrHqPw55YDaledlgNx9tINtW4w+LZRbfgtDDD4rX1+cTI4waClz3uAoycv4gfNWN5Q3Hv4RE3RMAazBXJnxtDeLVSgL2WGjF2ArJnS4Nc+rUxVODs5mdbNVyqULoTc2dKre0Ku4bX/7qJBrbLKSx75JvXJqH6urOlhvEZyvLNT4PoM2nVx0pLky3zimaN6qC9HDhw1T9138sSNbJnTSLbWXn33pCrMBQUoEO4CgX+Cw/0UrJACFHB0AfnC0fk9C9Q0gIAW8q336SO6+dstH2EfO3VJfRs+mrPvvE3zAqmSJ8aePyZi9+oJOL5lFob/3Bry8b6xjAQfg7o3VV+O27FiLA6sm6y+rV+5bBFVRIJoaU+yxAnUtvkipLrlqQxS38aFv6lzD+vbClJXoXzZVDWW6i5eKBe2LB0FOe7QhqnqyRByXDu/ecUyCizbVcr5tlEqS540oapbjpVtSRJgSzl5xJlsS1Am85WPbpqumUxQJmd2zoM8rUHyJTX9viJ2/zEBO1eNU08ZkH1fYiTHmyeZyyxtMibjF8gkyN+6bLR5UTWHecXMQf72yaPAAt4DPds2wLHNM1Sf5EkL8nQH84PqVCmprq/Mhz64boqaUy1fEDOWkXPIPWDc9ntFymSJMG98H3VPyHUoWjCn2if3odwr0pdl0wZCjl8woa/xMLUdsD558oM8AcJYKEeWdFg9ewj+3jgNUpd8QVOeRCH5IXlLGSYKUCDiBBjwRpwta6YABcIoIB9Ry6G1K5WQlyCTBHoS4Li5fn4CQMCCEixL0ChTHQLmBbcdUt0ybzd9muQI7txB1W8wGCDHSfATVP6X7DMYDJCRcTGR9gesSywkwJdX8zzZDouReR0RtS5PeJA+Wapf2i6jvvHixrJUxOJ+uScCXgdxkE8VLB6kM0OeqiF1SfsCHiL7JE/OHzCP2xSgQMQJMOANaMttClAgSgV8fHxw5sJVyMhn3DgxA7UlWZKEkC8WIQL+SxaBdUdAc+2ySmdtRF+mEwR17e2yw+wUBSgQKQIMeCOFmSehAAX0ChgMBjVfs2OL2kEeIr98YfKwLkHmfenOiKz7S9sWFcdHxTnlKQoyncB8GkdUtIPnpAAF7EuAAa99XU/2hgIUoAAFKEABClAggMAXBrwBauMmBShAAQpQgAIUoAAFrEyAAa+VXRA2hwIUsFEBNpsCFKAABaxWgAGv1V4aNowCFKAABShAAQrYnoA1tpgBrzVeFbaJAhSgAAUoQAEKUCDcBBjwhhslK6IABfQLsCQFKEABClAg8gQY8EaeNc9EAQpQgAIUoAAF/AtwK1IEGPBGCjNPQgEKUIACFKAABSgQVQIMeKNKnuelgH4BlqQABShAAQpQ4AsEGPB+AR4PpQAFKEABClAgMgV4LgqETYABb9jceBQFKEABClCAAhSggI0IMOC1kQvFZuoXYEkKUIACFKAABShgLsCA11yD6xSgAAUoQAH7EWBPKEABPwEGvH4QfKEABShAAQpQgAIUsE8BBrz2eV3194olKUABClCAAhSggJ0LMOC18wvM7lGAAhSggD4BlqIABexXgAGv/V5b9owCFKAABShAAQpQQBNgwKsh6P/DkhSgAAUoQAEKUIACtibAgNfWrhjbSwEKUMAaBNgGClCAAjYkwIDXhi4Wm0oBClCAAhSgAAUoEHqBiAx4Q98aHkEBClCAAhSgAAUoQIFwFmDAG86grI4CFKBAYAHuoQAFKECBqBRgwBuV+jw3BShAAQpQgAIUcCSBKOorA94ogudpKUABClCAAhSgAAUiR4ABb+Q48ywUoIB+AZakAAUoQAEKhKsAA95w5WRlFKAABShAAQpQILwEWE94CTDgDS9J1kMBClCAAhSgAAUoYJUCDHit8rKwURTQL8CSFKAABShAAQoEL8CAN3gf5lKAAhSgAAUoYBsCbCUFLAow4LVIwwwKUIACFKAABShAAXsQYMBrD1eRfdAvwJIUoAAFKEABCjicAANeh7vk7DAFKEABClAAoAEFHEmAAa8jXW32lQIUoAAFKEABCjigAANeB7zo+rvMkhSgAAUoQAEKUMD2BRjw2v41ZA8oQAEKUCCiBVg/BShg0wIMeG368rHxFKAABShAAQpQgAIhCfwfAAD//8pfn9IAAAAGSURBVAMAxY73Xst0SFkAAAAASUVORK5CYII="
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "from optuna.visualization import plot_optimization_history, plot_param_importances\n",
+ "\n",
+ "study = tuning_result.study\n",
+ "\n",
+ "# How the best score evolved over trials\n",
+ "fig = plot_optimization_history(study)\n",
+ "fig.update_layout(title=\"Optimization History: R² over Trials\")\n",
+ "fig.show()\n",
+ "\n",
+ "# Which hyperparameters mattered most (requires ≥ ~20 trials for reliable ranking)\n",
+ "fig2 = plot_param_importances(study)\n",
+ "fig2.update_layout(title=\"Hyperparameter Importances\")\n",
+ "fig2.show()\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "571d30d9",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAArwAAAH0CAYAAADfWf7fAAAQAElEQVR4AexdBWAUx/f+ds/jQnDXUqCFOtXUjbrrry7U3f+l7m7U3d2VNlSoF2vR4haI27n835vdvWwud5e75KAJTLLjb+ybvdtv3szOqRH5JxGQCEgEJAISAYmAREAiIBHYiBFQIf8kAhIBiYBEAIAEQSIgEZAISAQ2VgQk4d1YR1b2SyIgEZAISAQkAhIBiUB7ENgI80jCuxEOquySREAiIBGQCEgEJAISAYlAMwKS8DZjIX0SAYlA6ghISYmAREAiIBGQCHQZBCTh7TJDJRsqEZAISAQkAhIBiUDnQ0C2qCsgIAlvVxgl2UaJgERAIiARkAhIBCQCEoF2IyAJb7uhkxklAqkjICUlAhIBiYBEQCIgEfjvEJCE97/DXtYsEZAISAQkAhKBTQ0B2V+JwH+CgCS8/wnsslKJgERAIiARkAhIBCQCEoENhYAkvBsKaVlP6ghISYmAREAiIBGQCEgEJAIZREAS3gyCKYuSCEgEJAISAYlAJhGQZUkEJAKZQUAS3szgKEuRCEgEJAISAYmAREAiIBHopAhIwttJByb1ZklJiYBEQCIgEZAISAQkAhKBZAhIwpsMHZkmEZAISAQkAl0HAdlSiYBEQCKQAAFJeBMAI6MlAhIBiYBEQCIgEZAISAQ2DgQ2NcK7cYya7IVEQCIgEZAISAQkAhIBiUDKCEjCmzJUUlAiIBGQCGxMCMi+SAQkAhKBTQcBSXg3nbGWPZUISAQkAhIBiYBEQCKwSSKQlPBukojITksEJAISAYmAREAiIBGQCGxUCEjCu1ENp+yMREAisJ4QkMVKBCQCEgGJQBdGQBLeLjx4sukSAYmAREAiIBGQCEgENiwCXbM2SXi75rjJVksEJAISAYmAREAiIBGQCKSIgCS8KQIlxSQCEoHUEZCSEgGJgERAIiAR6EwISMLbmUZDtkUiIBGQCEgEJAISgY0JAdmXToKAJLydZCBkMyQCEgGJgERAIiARkAhIBNYPApLwrh9cZakSgdQRkJISAYmAREAiIBGQCKxXBCThXa/wysIlAhIBiYBEQCIgEUgVASknEVhfCEjCu76QleVKBCQCEgGJgERAIiARkAh0CgQk4e0UwyAbkToCUlIiIBGQCEgEJAISAYlAeghIwpseXlJaIiARkAhIBCQCnQMB2QqJgEQgZQQk4U0ZKikoEZAISAQkAhIBiYBEQCLQFRGQhLcrjlrqbZaSEgGJgERAIiARkAhIBDZ5BCTh3eRvAQmAREAiIBHYFBCQfZQISAQ2ZQQk4d2UR1/2XSIgEZAISAQkAhIBicAmgIAkvKZBll6JgERAIiARkAhIBCQCEoGNDwFJeDM0ph6vH8+98Rl++HVWhkpMXEwoFMbq8kqsIuPzBxILyhSJgEQgJQT4s8Sf33/mL01JfhMQkl2UCEgEJAIbFQKdhvDW1DVgVOkpKZkHnnq70w1Ck9uD+ya/hS+++y1p2+YuXCb6uMdRl6CxydNKdvmqtSJ9l0MvgNvji6ZHIhF8OuUXHHba9dhiz9Ow97GXYx8yW+1zJg7+37WCbK+rrI3KX3nLZFGOGdNt9z8Hx028BR9/NS0q9196fvr9b4FZeUV1ys3gPpj7FOtfuaYi5bK6oiBPdvg+e//zHzpt83lcjXF555Op7Wrnhu7n8pVrxb04459/29VemUkiIBGQCEgEOjcC7Se8Ge6X3WbDofvt3ML0KCkUteyx07gW8ZsN7S/iu6I1ctgA/O+ofbG2ogaPPv9+iy6EwxFMuvcFEXf7NWciy+UQfq/PjzOvuBdMYleuqcTxh+2JGy/9H6467ziBy6Jlq8XD+rX3vxHybAVJC8zuQfvsiJOO3AfHHLIHttlyBGbNWYSrb38KH331Eyf/p2YmtYW1apXVdWm3I/ZeMcJZLmfaZXWlDOFwWExuvvnhz07b7M9oYmY07sMv23efdYV+Gn2UrkRAIiARkAh0fgQ6DeHNznLitqvPaGG22WKEQPCKice2iN9/j+1FfHss1pSmki/TcuY6zz/tcDCZf/mdrwQBNdJYa/fr9Lk4bP9dsMv2WxjReOntL/HzH/9gi82H4NOX78R1F52Eow/eHScTcWbMpn30GJjYRjOYPBP/dyiuPv94/N8lJ+OJOy/BPTecK1LLps0Ubjwr1b7Hy7sh4ooKclvcD4yBYThtQ7RB1hEfAd7a88EXP4InduNGD8Nfsxdgzdqq+MIbUazsikRAIiARkAh0bgQ6DeFNB6Yb7n4ObGLzPPPapzj36gfAD11OY80oh59+9RNM/XkmTrvkLoze/VTwdgKWDZNGleUMEwyF8Pwbn+OYs28ScvsedwVue+hlNDS6DZGoy9sLDDku754n3oimteVhzS1rcFnu+rueRSAYEhrfOx99DUzYmOBzGhvepvDQM++yF/ffOBHduxUIv9nKz8vGndeeJQiwOT6ef1D/niLabrcK12y9/UlZi77f/vAraHJ7zSLCzyTmjMvvAW8v4K0XF//fo+CtGCJRt/z+AF4kos4YsRxjdN61D+LLMm3LBy91f0jEiMVve+gVMW48VjxOHNdRs2ZdtdCIc/t4ef2Ui+8EL7Wby+X9mkadi5evwcPPvosLrnsIr70/JSpWNm2GuG+4D2w4fRktf0cFdA/3nzXnB5x4lcCF63v1vW+i21LuefwNga3RHr637p38Jqpq6vUSNIe13Xc99rrYpsLt5vKuu/MZzJ67mMrygjFkyd+mz4tidumkxzkqrlm0dJWQ489ArIDb4xVpfN8ZaVN++As8ttxONiddcDteeOsL8GfJkEnmfv/LTJE8Ye/xYMOBL6f+zk4rkwgzxiBZP3+fofWdXXOhTKx5PHniaMTzigbHMd6MJ48hfw98N226ISJdiYBEQCIgEcgcAp22pC5JeH8jLSibWFTn/bsc/MANBIMiKUhEksMPPv0OJl7zAGbPW4LRIwYJcsn7gD/95mchxxZrNS+47mEwCWHywxpTJgRMfs647B6YyTGTB95e8Pf8JRi/zSgM7NsTn3zdXBaX15bZYavNcdSEUvB2hBff+gK3PviSIDRMhPNzs2H8/T1vsfAef9ie6NWjWPgTWUWk+UyUxvGBQBBMNNm/z67bsBM1dxPJ4u0Uq9dWCm1xQV4OmLAdddaN0QkEC39DS+lMgljjvMv2YzB6s8H4+vs/sP8JV2HB4pUsIsxtRJa5zIrqWuy+41j07tENTB6ZzLEAY8uG/dVE+iqqasHG62vet8xp7THLV60ThJEnJSOHDQCvCDC5PeuKe2FeYq+urRf3yyPPvYeDTr4GT778Mb79aTpmzV0kquXJDxMv1rpzXwf07SHSmYTyREQIkcXEi/v/8VfTUFyYj3Gjh4Lr4wnDv0s0TD766ifwfTViaH/sW7od5YKYXE2kCRpPtDiCJ2pMxlijb7fbcOCeO8BBLmtM3/q4TNyDjBHLMnbsZ8P94Lh4ZkC/nuB7iD8DbtOecJadQuT2eyKoJcXaJIrv4QtveBgz/1mEcWOGYdSIgeDPFJP1WGLO+eOZT6don4O96f7aY6ethIgxsREB3WoLM+4Xi7qJlLOfjdHPiqo6MW7ssoxhWJb7s4QmL0Ycf744jieZ3CYeGx7P8699SEyCDTnpSgQkAhIBicDGjUCXJLzpDgnv62QN6K+fPoE3n7wRz95/pSjCeDhz4CvSQvGDkfe6/vThI2D57959EIcfsCuY2Jb9PIPFxPIskwcml1++fg+eufcKPPfAVWC/EEjDuuTso4RGl8k3E63YrQxc1JIV5eyIJWLhSdO6dNJjOPH823DkmTdix4PPxxsffotTjt4Pe+yskREubhFpAVkby+Tws1fuEn1nnE4/7gCwNvP1D7S9wXwiBJM4zvPJS3fg/knniW0Sj99xCUfh/iffFC4TDybWvG3ji1fvxt03nINXHr0O373zII4/bC8hw9sxjtP9902aiHeevkmYfXUyKIQSWNW1DUJbytpjs5m7cJnI8SgRWG4D1/vUPZfj3v87Fx88fyv4Prj1wZdbvSzI+c44/kBR//fvP4yLzjgS/PIbT34Yk58+fFT0ldt461WnizpeePNz4fIk4sZ7nxf+5x+4Gi8/ci24zqnvPYgzT5gAp1Pbh81xP3/ymLhf7qf+fk647LHTOHFvLV2ujfGMvxeKCRBrRrkubv/7z92Kt56chO3GboacbJfwc2WlO44V7WW5Fx68mqPiGqvFIra/cOIUmqywaxhDE3rQ3juKqFf1PeBv0Wfk4VsuxOS7LgPjccXEYwk7rR9CMIFVV98EJtG89aZPz25iNWJbajdPhPgeM7IFaOKVDLMimjRwn1k+1X6ybDyz4zajxX3HOD548/ngcTDKNk9+4uWVcRIBiYBEQCKw8SCwSRBe3g/LGltVVcTIbT9uJD3AnbQMv06E2frgi5/YwWnH7g8LkYRQKAyF/vfbXdPGsaaLBQziO2HvHdG3VwlHCeN02IWbjsWa3LNOPCia5awTJ0T9hmd1eaXwGlo4ESBr6s8zhTaaSZlhOI6SWly8HaO+oUloj3NzXCKNl6hZm8saRY74jpbt2T37pIOQm5PFXmHO0tv22ZRfRXjOgqVCO37C4XtjUP9eIo6t3cZviXGjh+GHX2ej3rT9g8lgeUUNiwjD2zGYWIpABy3WRMcari8YConTLIYM6C00pEY1TMBOPWY/gcOfsxYY0cK9/JxjcMlZR4lJRXFhHnp1L8I3Ojk8le4HxiRE9wObPfSJAq8WcOY5RLJ5UsCTle3GbcZRwjC5vvjMIzF8cF8RZuKsKiqY+PE4ffjlj1D0+5HJNQupFpUd1BChr6MxEwGyWNPK9y9523Udsu9OIp9BcDnAx3CxpnPPXbYSxJTjmByzyxpydtm4nHYxQSrMz+VgUvPtT3+J9Al7jRcuWwfutQM7+LKseVtDqpiJjB20eNLF9x3j+dfsBdSO36Ia/CXLV3ewdJldIiARkAh0DAGZe8MhoD1hN1x9naImRVGEZtW8L3HxMu3hx3v9+Ngvw/AyODd6rX501hJdG8dbEji+I8ZNS8yvvPt1tIjJL30U9RuenkS+2F9BS/7sGubPWfPFkjgvuxuG44x0w32aNNAfvXg7WHP77dsP4EfSXvPyPO/X/f4XTWvNhI3lhw7sw07UsEaRl/FZA8qRK1dXsIPNhvYTrtnafPhAEWSCzmRvwt7jUU3Ebf8TrhRHod392OswyhGCHbBYu/7DB48g1rBmca1OsDen5fjYKobp5JPJnjmNl7vNYfYbmPDWFeNeYHfHg87jZKwq17Dg46w4YstRQ9hJaJhA73b4hTj4lOvE9hreuz3lB40ghiMRkW+rMcPBfeO9xlzPOVfdhyde+hDm7RNCME2rf58e4EkeE1yDXH+mn6Rw1ITSaGl80gUHJl7zAHjbxg13Pye2cPB2H45vy3z81TQhMpgmQ0uWrwEb3u7DkR9++ROMclLFjPN11DDRvXTS42A8eSsO+1nL39FyKHV9UAAAEABJREFUZX6JgERAIiAR6FoIbJKEN94QMTnj+JsuPxXxzEGk0eX0uoZGdkjDqb38JQLttB546i2xdM6nLvDeYiYFrP0zF2doUnlZ2Bx/9kkHi6Va3ibw0C0XmJOS+llTd8lZRwuZL8v+EK7P5xcu7xsVHpPFe0g5yGTF69fkbFYrR7UwNqtFhPllNfbwqQk3XHKy0Jryi0O8ZYK3VbA2mtPXlzEmMfHaaNXbaPQ3WRua9DOSLzjt8Lj3w+XnHCuye3TsnPbEGn7e73zRDY/A6wvgyvOOi27vuP7ik0QZhsUYfvrKXWCtMmsmWWP+6HPvY/cjL8ZXU7WxMmTTdY86SCO2vE+Xx5K3nDC5Hr/NqGhRRxy4q9hyweSYCf97n30vXuI79pybxYuVUcE4Hp5oMKHmJH7pbcLJ14DNKRffyVHiPp89V9uPngpmIlMGrPOueVBodXlrxKO3XwTeijPt48fExCIDxcsiJAISAYmARKCLINBlCa/b0/r0gI5gPmKIprU8YM8dcOSE3VoZPsOWy+9ZUsQO+E1y4Wmn9cufc8RpAEwujj1kD9yi7w29/q5nUGdazh4+WGsXH2FWrmuZuUo+xo2XatnwMjzHpWosqjbsbo/2wxf9+nQXWfktd+HRLV7C53N/WcurKAr69iwRKbEaUo5cs66KHfTsXixcXh7nfvEe098/n4z7J00UJIO10eb+sTDXw24mDL8cx+WsWN28XYXDbMrXVbOD3j21NopAAmtgP21CM3bU0Fb3At8fB+y5vcjZv7eGHRNEERHH+l7/9b37J50nzmDm7R88bvG2weTlZIG3WHxL2vip7z0E3j/LRT7/prZnmP1sQqEQOymb3XcaJ7bxvPXxd/hr9kJBQHkPNY+TuRAmwLwnfcY3z+Klh68VW1V4D3u8l0TN+XgPPIcnkGaf2282hub4c/1HWVLBjMtiE6+fdCtyEk0gfMJNZPGP2Uz/e6F4UfWx2y/G7juOo4lqL/BWokR5ZLxEQCLQiRGQTZMIdAABjfl0oID/ImuvHsViuZy1Skb9vOzL+yONcLqusf9yMi0hx+ZdXV4ZXY4fNkjbk/lxzKkM/FZ+bL5EYd7nesUtT4jkm644FaqqYDgtt593yqGiX/xWvEgkqz+RUf6hCvLiipsnw0x6OS5dEwiGYJCnLTYfKrJvMVJbjudtDiJCt6b8+JfY87r1FiNEjLElgEkTv8AmIsniNvEeTdZKlhTniz6wdpKSxMVbHPYt3Q7jxgwTYcaTPXwSBLvlOllmf0cN7znl/bK/z5iHRfo2FS4zSATxrY++Yy+M7RcikMDakoguJ/GPgzBm7DcMT7ZYa8vhoYO0bSCswY4l8ryFg+9RYzuKzWbhLMJwezhdBHSL7yHzPdytKB+8X5rxYy05i9lsmnbdvM+W49syTK6ZqHN7rr3jaSF+qL63VwTI+mzKr1FNLmubt95iuDjhgpKwdMUadhIaXp3gxCvOPVZoqFlLbRjWanMaa5W536lglqyfjAuX9/f8pewIw1rrX6fPE37D4tM/2G+UxX42PDmprm1grzQSAYmAREAisIkgoHbFfm6/1UjR7HOuug/Pvv6Z+HUyXvaNXfYXQilapx17gNBAcnl8bicfA8XHcl19+1Pgn/FlrRgXtfdu2wg5Jk+X3/wE+IgyPrqK9z1yeiqG97PyA5eXtPvpGkLOxy90sTaVXy76QdcKcvz5px0mtgb8NXsBDjr5WtFfPi7t9Q+mgI/5uuymx1ksrnn8xQ9w+8Ov4qb7XwTvX9yDlsc/+OJHcD0nHbG3yLPrDluIH7Xg5W7u7+ff/ir6dcmNj4r0c04+WLhMNPjFNiZNp9BSNZMcJjHHT7xFpF9Fy/WKoqCmth48NnzEFhPBL8t+A59swXtWeZ/qiCH9hbzxi3ncB9Zg89nIBpEUAulbIsclZx0l3FMuugN8KgXvLT3r8nvFsWmsdTZjLgTjWDttOxp7kFaUNYRHnH6D+PGPdz/9XpzLzPu8X/9wisjFmPD4MAk++qxJ4uxhHj/GkbdwrCWt/LZbahOGG+95Ho8+9z4ee/59HHXmjeLYN1GIbv2zYKnY48t5efLB7b6G7j8ue+L/DtGlII7CY9LGe2xfp3vgvslvRdOSeQxNK+/j5X3cvXt2ayHOJydMOOlqsW+Yx4x/BY8ngEy4ecLSQtgU4L26TN4ZM8bDlCS8rFHll+O4H78TKWWZtjDjjKxtjtfP4UP6CW31mx9+Cz5DmPc5H3/erWJsOJ9h+vfpIT6rPIa8F5tf1uQzjXl/siEjXYmAREAiIBHYNBDoIoRXaTEaJx2xD/jhygT3/iffApODEw7fS8SxoCGtKIaPY1sai0WFeZ8nv6D17jO3gJdkv/9lJm667wUiiq+ASQdvOxiz2SDwH+9pfea+K8UvpTExZCLHPwLAb+RzuqIkrpPT+YUkJkTbjt0Mxxy8B0dFDe+hvePas0SYtXDGKQpMON6Y/H/gnxMuKsgV/eUfxLj1wZcFEWNCcSWRTT7qS2Qmi7XG5Ij2v/re12CCziS6R0kRLjjtcLw5+cboiQyKomDynZdi39JthTwTee4Xn0LxBsnxCQdcFpuJpIU+79TDwBpHbiOTpIZGD/gYN4MUFRfmi7J4TyeT+0snPS4INBOY2685Q2i0uaytxgwTy/c8DkxcHnjqbazUXwbj9EQmVmMXK7cTkVU+gor3zN7ywEtgAsltYY0jk3JDXlW1219R4o/ZPf93Ls6nyQb/iAWT8v+75zmxDYVPbdhrl62NYsDHj/E+bJ7EcH+vv+tZgSOTPF6NOGLCbmCyyUSTydnjL34ojis7+uDdRRlG9ZsPHwDe7sD3HJ+iwe3me4xfLDvjhAlClq1rzj9e4Mt7bPkeYFLP8W2ZEUQUea84yx05QdvTy37D8GSA+8CknMeMiTT39eFbLgCTVEMu1v1GP9HiQNPpDLEyfKYwx331/R/stIkZCyXqJ9/vfB+xDE+UuL2szTXGVlG08eT75KFbLhSk99Mpv4BXTniydx7dw/yZ4vyGURQtj6JorhEvXYlA10VAtlwiIBEwI6A98c0xncjP55D+U/YC+tOyvrlZTE6fvPsyfPPmfXj3mZvx55dP4doLTwSfscny/JBmed7nyuH7J03kYAvDpxbEnp3L+yrvuu5szJzyLL547W5xsgGX/dwDVwkNqFEAE4dv3rxfpPNLML988rh4gHNdxjmthmysuxORMZZ74cGro8TPLLPl5kPA6XwCAS/PG2lWi0Wcp8pt/uOLp/Dh87eJF3Cmf/U0+IxR3vZgJiV89iyXYza8l5b31LLG1sDIKJ9/re3+SeeBzypmGX4ZjusaoxN9Q47bwdrGGV8/g49euE1gwP03H5tVkJ8DLotx/OqNe0X7+EUhPrM4VrvKJJSxZsMnSDC5M+qK53IfeH9rvDRzHP/IAPfl81fvFvX/RTjxvlKeVBhyxlgYxNOIN1zeBnDuyYfgt8+eQNm7DwrMua987xy8j3bUF8syJscftqeQY9w+f/UucU/yWbZ8nByn33b1GeIlQz4Ddsrb9+P1x28QExgen913HMfFiL2mfF4xjy/fV2zYP+nyU8QPUAghsoYM7CPw/ZnuOx6jaR9pmnhKavPi85W5TjNhNzJdds7Rog+8d/i9Z28Rff7kpTuFRtmQiecy4ecyjePP4snsW7qduK9vvPR/IpkxSYYZCyXrJ4/v758/CW4nfw8wDjzh43YYGn4ugydV37x1v7gH+HPCeE485VD8/vlkEccybHbYenPRPm4Th6WRCEgEJAISgY0LgU5NeJNBrSgKWHvGy+JMTJLJppvGD2MmZrzsn6hsVVXEtgA+RYG1xenW0RF5JsK8D5LrNhO4dMuMJ8+TCd4Dy+Q/XroRx9ozJiSMUaL+M46sHeb9yayVM/LGuoqigPHmEyRi0zoS5jHiyRLXz5r59palKAqYuDLmsRMFc5mKoogzbfvTUnq8+4Yx5TN1jRcfzXnNfh5fHls27Denmf38ghtr4XkszPEd8SuKIrS5PKnjPjOGHSmvrbyKkhwzzp+on3ycHLeTvwdYLpHhsed7gE0yPBPll/ESAYmAREAi0PUR6LKEt+tDL3sgEZAISAQkAp0EAdkMiYBEYCNHQBLejXyAZfckAhIBiYBEQCIgEZAIbOoISMKb6h0g5SQCEgGJgERAIiARkAhIBLokApLwdslhk42WCEgEJAL/HQKyZomAREAi0NUQkIS3q42YbK9EQCIgEZAISAQkAhIBiUBaCKwnwptWG6SwREAiIBGQCEgEJAISAYmARGC9ISAJ73qDVhYsEZAISAQASBAkAhIBiYBE4D9HQBLe/3wIZAMkAhIBiYBEQCIgEZAIbPwI/Jc9lIT3v0Rf1i0RkAhIBCQCEgGJgERAIrDeEZCEd71DLCuQCEgEUkdASkoEJAISAYmARCDzCEjCm3lMZYkSAYmAREAiIBGQCEgEOoaAzJ1RBCThzSicsjCJgERAIiARkAhIBCQCEoHOhoAkvJ1tRGR7JAKpIyAlJQISAYmAREAiIBFIAQFJeFMASYpIBCQCEgGJgERAItCZEZBtkwgkR0AS3uT4yFSJgERAIiARkAhIBCQCEoEujoAkvF18AGXzU0dASkoEJAISAYmAREAisGkiIAnvpjnustcSAYmAREAisOkiIHsuEdjkEJCEd5MbctlhiYBEQCIgEZAISAQkApsWApLwblrjnXpvpaREQCIgEZAISAQkAhKBjQQBSXg3koGU3ZAISAQkAhKB9YOALFUiIBHo+ghIwtv1x1D2QCIgEZAISAQkAhIBiYBEIAkCkvAmASf1JCkpEZAISAQkAhIBiYBEQCLQWRGQhLezjoxsl0RAIiAR6IoIyDZLBCQCEoFOiIAkvJ1wUGSTJAISAYmAREAiIBGQCEgEMofAf0F4M9d6WZJEQCIgEZAISAQkAhIBiYBEoA0EJOFtAyCZLBGQCEgE1h8CsmSJgERAIiAR2BAISMK7IVCWdUgEJAISAYmAREAiIBGQCCRGYD2nSMK7ngGWxUsEJAISAYmAREAiIBGQCPy3CEjC+9/iL2uXCEgEUkdASkoEJAISAYmARKBdCEjC2y7YZCaJgERAIiARkAhIBCQC/xUCst50EZCEN13EpLxEQCIgEZAISAQkAhIBiUCXQkAS3i41XLKxEoHUEZCSEgGJgERAIiARkAhoCEjCq+EgbYmAREAiIBGQCEgENk4EZK8kApCEV94EEgGJgERAIiARkAhIBCQCGzUCkvBu1MMrO5cyAlJQIiARkAhIBCQCEoGNFgFJeDfaoZUdkwhIBCQCEgGJQPoIyBwSgY0RAUl4N8ZRlX2SCEgEJAISAYmAREAiIBGIIiAJbxQK6UkdASkpEZAISAQkAhIBiYBEoOsgIAlv1xkr2VKJgERAIiAR6GwIyPZIBCQCXQIBSXi7xDDJRkoEJAISAYmAREAiIBGQCLQXAUl424tc6kR9jJoAABAASURBVPmkpERAIiARkAhIBCQCEgGJwH+IgCS8/yH4smqJgERAIrBpISB7KxGQCEgE/hsEJOH9b3CXtUoEJAISAYmAREAiIBGQCGwgBDod4d1A/ZbVSAQkAhIBiYBEQCIgEZAIbCIISMK7iQy07KZEQCLQ5RCQDZYISAQkAhKBDCEgCW+GgJTFSAQkAhIBiYBEQCIgEZAIrA8EOl6mJLwdx1CWIBGQCEgEJAISAYmAREAi0IkRkIS3Ew+ObJpEQCKQOgJSUiIgEZAISAQkAokQkIQ3ETKdKL6yzteJWtP5m+L1h9DoCXb+hnaiFlY3+BEORzpRizp3U/zBMOqbAp27kZ2sdXWEV4Bw62TNks2RCGyMCMg+xUFAEt44oMgoiYBEQCIgEZAISAQkAhKBjQcBSXg3nrGUPZEIpI6AlJQISAQkAhIBicAmhIAkvJvQYMuuSgQkAhIBiYBEQCLQEgEZ2jQQkIR30xhn2UuJgERAIiARkAhIBCQCmywCkvBuskMvO546AlJSIiARkAhIBCQCEoGujIAkvF159GTbJQISAYmAREAisCERkHVJBLooApLwdtGBk82WCEgEJAISAYmAREAiIBFIDQFJeFPDSUqljoCUlAhIBCQCEgGJgERAItCpEJCEt1MNh2yMREAiIBGQCGw8CKzfngRDIaytqIHH61+/FWW49GUr1+Lzb3+F1/fft/uXv+ZgyfI1oocz5yzCd9OmC38qViQSAY9BItnK6rqEY1NX35QoW1rx/INB5RXVCevx+wPiHuG2xhbMcXUNmWlHbNmdMSwJb2ccFdkmiYBEQCIgEdjkEFiztgqjSk/B6x9MadH3ux57HQeceBWYvHDCnAVLcdIFt2PLPU/HHkddgm32OwuHnXY9Pvn6Z07Gx19NE+VwWWy23f8cXHfnM3B7vCJ9fVgr11Tg0kmPJSWAXG8gGMIF1z2EJSvK4XTYOQpX3fYkFi5ZKfwb2nrs+Q8w7Y9/RLWF+bm48pYn8cOvs0S4LYvx3ufYy1uJLV+1VozXbodfJMbmhrufA/ebBddV1uKUi+/EhJOvxnETb8HyVes4WpgHnnobdz76mvCnYv30+9/Y7fALsedRl4p6bnvo5egvZjKZffzFDzFunzPFPbLrYReCCb1R7u8z5uHAk67GBDKXmsaN8x1z9k345oc/DdGNxpWE9z8eSlm9REAiIBGQCPx3CNR4Aqhs8m9wE4q07nOvHsW48bJTcOuDL2NVeaUQ+GPmfLz09pe454ZzYbfbwGT3qLMmYdSIgZjy9v2YOeVZfPXGvThgzx3w+Xe/ijxsFRXk4pu37hdpD99yAb6a+gfe/fR7TlovpqHRjS/LfkckHKdjphpffudLuJwOnH3iQdFYJo41tY3R8H/l6d+nO2696jTceO/zNDnwJWwGE9p9j7sCV9/+VFwZHr/NhvbHH188hU9eugNffPcbviCNNgtP/WUGeGx++OARDO7fC1N0YllRVYvX3p+CU4/Zn8XaNKw9PuuKe3HEgbvh988n4/3nbhX5P/zyR5F3xj//4rHn38fLj1yLGV8/g0P32wWX3PholBC//XEZTjxiH3z37oNg2Tnzl4p8U3+eCX8ggD122kqENyZLEt6NaTRlXyQCEgGJQNdF4D9p+c9LazB1cdUGN02+YNz+HkkEZvw2owTpamzy4MpbJ+OC0w4XBJcz3PHIa0RGxuHq849Hz5IiWC0W9OnZDWeeMAH3/t9EFomaXt2LRBqXV1KcDwvJGom8dH/w/64VmmDWFi9YvNJIwqJlq3HaJXeJNJZhsmwkrli9Dudd+yBYa7zLoReQRnQyWPPMWkyWYa0lawjN2kSOZ8PL//dNfgvnn3YYtUWjH/c/+RYn4Ya7nwXne+PDb/H3/CVCgy0SdOucq+7Dn7MWiBBrQe+d/CbOvfoB0Y4rb5kMbpdIJGs1TRZYi8xtPOPyewQRp2hxsUaViSJrvllrPu/f5SLesPYt3U5onj+b8osR1crtTXi/+PA1uO6ik1ql8RYB1ryedOQ+ROztGESk9tD9dqIJx+9CdtacxUR0ewv/4AG9MXveEuF/7o3Pccwhu6NHSaEIt2XNmrNIiJx67P7IcjkxfHBfnHzUvlHN7Lc/TgeP+1ZjhsNms4Lbs7aiBvMXaf39Y9Z8DOrXU9w/Qwf2wdyFywQZfuiZd3DRGUdCVRVR/sZkaXfcxtQj2ReJgERAIiARkAikiEDffCcG5Ls2uLFZ4j9+mWjcfPmp+PmPf3D02ZNQUlSAM044UPSGCeNfsxfgkP12FuFYy+W0R6O8voDQ+LF2+NJJj8NB2uED99pBpP+7ZBXOv/Yh7LHzVkIDyGT49EvvElpNnz+AM4kkZmc58eJD12C/3bcTmkEmRJz5lgdeEsTolUevw/2TzoNCxIiX6084fC9OxmVnH43Lzz0GA4lMiQiTxUSUydkOW4+Kxh60z47Cfzzl53w7bTsaTW4vuJ8iQbf+IQ0ka5E5yHuA3/zwO+y83Wg8evtF4DBrLDmN28IkNzcnCy8RKT18/13FVgvWmDN+TJzdHh8ev+MS3HDxycjNcXG2FuaQfXeOEsMWCXqAJxk82SjMz9Fjmp1K0tRyqG+vEnaE6d+nB9asqxb+0aSZX6zvGWZN8ZjNBmHN2iq888lUod0NhcLgeCGcxLLZbCJVVZqJab/e3bFC3yKxZl2VILRCiKzu3QrIBnhLBXvGjhomJgm8B5jxGzlsAL7+/g/Yqdzdxm9J94I3KsvyG4NRu1QnZGMlAhIBiYBEQCKQQQSy7VbkODa8sTTzlFa9YQ3iCYfvLYjcaccdILRwLFRd08AOSoo18sKBJ1/+GLc//Iowr773NUcJ4/Z4wdshZvyzCPWNTWAN7ivvfCXSPvv2FzAhu/jMI8EaQNZUVtc24Nfpc0Qe1gReS9rLbbYcgYmnHIohpInkbQec2U1kkclzYX4uth27Ge667mwwOeYlfE7nPByfn5vNwRaGifaIIf1gs1qi8cMG9RX+kUMHiPKYtImINqyzTpwAxmj7cSNx9MG7R/fd/kmaSyZwhx+wqyhhUP+eGD1iEHipfiZhwWm3XHkamNSxBrRPz2ZiKjKQNYy0pXMXappQCqZ11Te6hTxvPxEeshwOO6pr68kH7LrDlliyfDV4S8T02QvFpOOpVz8h7ew+RIqrsPexl+Gcq+4X2u7aOm2bx2dTfgVrwg3TQHVssflgsTXiohseIQ32b3jr4zK8/fF3og626huaSFPtYG/U8GSj0e0R4SMO3BWTX/4Iex1zKQb07YERQ/uDtbt8T3zwxY+ifceee5PY+y0ybASWuhH0QXZBIiARkAhscgjIDm+8CPCyO5NXJmpMQljryr0tKsxlB+WkvRMesuy0XO2w28XS+JQf/qIY7SoqyCUN7ERhnrn3Crzw4NXgl5hYw7eaNIrjxgzTBMkuLswTS+nlpIVcW1EtiBRvh6AkcbEsaww5cOHpR2DW3EXY/ciLBSl6+5Myjk7JrFhTAUPTmFKGFIVysp2kkdT23K4u1/Y+P/j0O7jtoVeEsRFGHq8Pq8orxPL/oP69kpZcSJrbZSvLk8okSswjzTKnBQLNW1Z8Pj9hmsfR4H3avN/22fuvxIcv3AZW0PJk4uQj98XnRGxZI/3ZK3fB5XLQBGSuyNNAExbes2uYcCQCnlC88uj14MnRK+9+IzTirB3u16e7yJNHEw6f3y/8huWmSVBOlqbR3ok06V++fi9efewGPHXP5fiq7HcUF+aLbRC8KnD39eeA28Hkl+8Zo4yu7ErC25VHT7ZdIiARkAi0hcAOtIy9225tScn0ToJAMBTCtXc8jUP32xnP3HcFWJv3+AsfiNbxUvq40cPwNi1/iwiyeA/nZeccjdLxYymU+DJIHp+mUFyQh/mmvau8hWBtRQ2RslwUElGuJm2v+disRUtXExnSCNt24zbD12/chw+fvw2H7r8zJt37Amks1xBx01TWTMYStaJPz26oqKqLmxyOhKPx3M9oIE0PkzbWZL7w0NXgbReGOf24A8B7Zpn0sUlWLPe9b2+NOCaTi5fWrVjTvpv3FC9dUQ7zBILzsYZdURRMfukjnHH8gcjPy6aJxGIYhHVg355iXy3LHnPIHrj9mjOjhskux7Nm9tarThfbUv7vkpPF3usdttqck6i+YnC9IkCWQVrNEw7WtHO7mJw/+vz7YO2uzx8QqwF9epWQhtguJkL/1Qka1OxUr5TkJOFNCSYpJBGQCEgEuigCblpi9WjLmF20B5tUs19++yuwdvHK844D70NlovPMa5/CeEnpyonHiv29fMwYa4KZILPmb8mKNa1w4n2jTHA5L297KCIyy1sKdt5ujCA1X5b9Jgj1C29+LvLy9oaxo4YKLeizr3+Kelo6//bHvzD974XYebsthMx9k98ClzlkYO8oyfaSBnMAETQWmPHPv+JMWLdH07hynGF4awS/JMZtNuLY5W0JXAfvv2WyOXJYf45G2bQZqKlrEHuRq4mEi8g2rLGjhwqJux97g7S+XmGm/jxTvMzF2y6YDD/1yidifyprxLk9IoPJ+nfpKmw+bIAppqWXj+5ikhgMhkSC8NNEhQNMRsdvMwovv/O1wGHJ8jX46Ktp2Ge3bTm5heGXA7/+/k+ccLi2/3nc6KFYvGw1uHxO22Lk4BbysYGqmnpx3Bmfw8vabB5f3qrAcnvsPA788txfsxcKmZfe+VKQ1xFDNGxZxjAffvmT2Naw9RbDxV7vkdR3vgd5DHkixGFDtiu7kvB25dGTbZcISARSQ2BTlpKEN+noF2XZ0C3bvsGNRVVatWsREa17J78pNHlMnFhgl+23wEH77CiOwGJitcXmQ/DSw9eC98Puf8KV4ize3Q6/CEuWrcGRE0ph/DFB3OvoS8W2g9MvuwesuXvugavEftvxRMj4pIRLJz2OHSZMxAtvfYmHb7lQ7A0uzM/Fvf93Ll7/4FuMp7QLrn8Y55x8sNjzymUvJWLNpxuM3v1UcVrDJWcdBSZELqcd5558iDjdgc8FnknEl+XNhrWXblpW/336PHM0Eb698dp732DsXqcTUfxKEO7zTjlUlL/zIRcQcZst5BWlGTNFafYDzX7G7al7LsOPv80SJzjwSQ2X3/wESShgzTG39+lXPxFbMh59/j2aVLigKM35QX8fEQHkPa3kjXstIo332L3PEGPChJD919/1bFT2ugtPxD/zl4izcSecfA2R3W3Ey39RAd3zJGl3uZ852S4Rc8CeO+D7X2aCz8xlPLcdu5mIT2S9/M5XAjM+h7eqpg7vPH2zwI7leeLC43bSBbcJGX7J774bJ4JfiuR0w/A9xdtmLjjtcCMKpx17gDglZMLJV4NPfiiiiVI0sQt7JOHtwoMnmy4RkAhIBNpEgLW7bKZNAxYubFN8UxMoZMKbQ4R3A5t4hHfIwD74p+wFMMk1j8Od154l9lPyXlSOZ03cm0/eiL++elqcs8suhw/Yc3tI+tu6AAAQAElEQVROFgSZyzEMn9P62O0Xw3hBjIWYnP755VP48vV78PMnj2HPXbbiaGH4ha5fPnlclM1nyZrJ0CO3XQTO9907D+Lbtx8Qy/EiE1nnn3YYWH7ax4+JvaAU1eJiwnnRGUfgsRc+ECc9GIlcd9m7D2Hqew/hvFMPFdH8stxvn03GtI8eA7ed+8Lt4sQn7rykRb37lm4r+sFpbMaNHibw4nZwmb999kS0f8cfticYD24776Vll+M4Hxs+go21ygcS+eRwPDN0kDZO3CbD8BgZsrx9hHHlsrkPt119BoyxM2TYvfuGc3DKMfuxVxjWQHObPnrxdrGvljX8IiGBddaJB+GL1+7GjG+exeS7LhMaXENUURRxnB2P1ddv3ItfP30CjAunmw2364cPHsEYkzb5ALqPeH8vb1u5ilYazPJd2S8Jb1cePdl2iYBEQCLQFgKGhnfCBODGG9uSluldCAE+LYH3xbLbnmbzL53xXlImorH5LRZVnOHLmsbYNM5n3gtqTmd51rKa48z+U47eT5xYwFsmzPFcX7ei/BbaVj79gfe2muXS8XM7Ysvk/LytId55t3x02S0PvIibLj9VaMJZtiOG6+A+pFsGa9lTyZPlcoBPteC9uInkeaz4xbZYzW4ieSOey2yLcBuyXcWVhLerjJRsp0RggyEgK9qoEKitBVjDy6ZSe4N9o+qf7EyXQsBut+GRWy8EE1He+9uZGs/n4V574YniqLDO1C7ZlswgIAlvZnCUpUgEJAISgc6LAJNdrxeoquq8bZQt22QQ4K0bh+2/izgFoDN1ms8Q3n+P7Vs2SYY2GgQk4d1ohlJ2RCIgEZAIxCDQ0KBFMNllX0UF29JIBCQCEoFNDgFJeDe5IZcdzjACsjiJQOdFoKmpZdtqa1uGZUgiIBGQCGwiCEjCu4kMtOymREAisAkiwC+smbvNGt9IxBwj/RKBDCIgi5IIdF4EJOHtvGMjWyYRkAhIBDqGQCzh5dJqatiWRiIgEZAIbFIISMK7SQ33f99Z2QKJgERgAyLAL6vFVidPaohFRIYlAhKBTQABSXg3gUGWXZQISAQ2UQRi9/AyDMuWsS3Nf4+AbIFEQCKwARGQhHcDgi2rkghIBCQCGxSBeFsali/foE2QlUkEJAISgc6AgCS8nWEUErVBxksEJAISgY4gEI/wSg1vRxCVeSUCEoEuioAkvF104GSzJQISAYlAmwjE28PbRTW8bfZVCkgEJAISgSQISMKbBByZJBGQCEgEujQCsRrezTYDVqzo0l2SjZcISAQkAu1BYCMivFr3GxrdqKnTf11Ii5K2REAiIBHYNBEwE96ddgK22gqQWxo2zXtB9loisIkjsNEQXrfHiwuuewg7TJiInQ+5AMdNvAWV1XUJh3fKD39hVOkprYzPH8DKNRUi/pizb2qRf+7CZSL+jMvvaREvAxIBiYBEoFMhYDTGTHiHDQMGDQIWLTJSpSsRkAhIBDYZBDYawvva+1OwYPFKfPfOg/jlk8dhUVU89My7CQcyggiyXE589spdLYzdZo3m+Xv+Evw2fV40/MJbX0T90iMRkAhIBDo9AmbCW1AA9OunNXn1as2VtkRAIiAR2MgRMLq30RDeL777DUdO2A3duxUgNycLJx25N9777HtEIhGjr61cp8OGAX17tDCKokTlTjh8Lzzz2icivKq8Ep98/TOOmlAqwtKSCEgEJAKdHgEmvIWFwMMPA+eeCwwYoDVZvrim4SBtiYBEYJNBYKMhvMtWrkX/Pj2iA9evd3fhr290CzeeVV3bgGvveBo33f8iPp3yC4KhUAux4w7dEz/9/jf+mb8Ur777NZHofQShbiEkAxIBiUBcBOaua0TZoir4guG46Z0nciNuCf/whMsFXHABMHx4s4ZX7uPdiAdddk0iIBGIh8BGQXhZi8t7eJ0Oe7SPDrtN+N1ur3BjrR4lRTj12P0xqH8vkXTlLZNx16OvCb9hFRXmgbW8901+Ey++/SVOPGJvIynqNnmDWN+GK1vfdWxM5fsCYQRC4fU+LhsTZuIz5AtlFLMGbwBVTX5UNvgyWm5nwN3rDyEYjnT6fgUbmhBxZTW3s3d//jqBf/HS5rgN8B3GYxYivBg39q9PIzq4iVispFlbUQOP19+leswKqs+//RVe33/f7l/+moMly9cI/GbOWYTvpk0X/k3W0jv+zQ9/grd16sGUnFQPDVhMeJu3i5oLbyLOxvcGv0tljs+Ef6MgvIqiiP24/MKZAYrhz8pyGlEt3DGbDcLl5xyDM0+YgBsv/R9uufI08D5g/gIxC554xD74dfpcHLTPjujbq8ScJPwq1b2+DVe0vuvYuMoHVCjoSn2as64BjQcdAvXTT/+TdkPgRbhl8H5GBHRFEIpE/pM+rffxR2bxWh/tVbweICenGf+sLKCoCNaPPoRlyeLm+AyOe6J+KISXoijrvU504b81a6vEi9GvfzClRS/ueux1HHDiVfD7AyJ+zoKlOOmC27Hlnqdjj6MuwTb7nYXDTrtebLtjgY+/mibKGVWqvZi97f7n4Lo7nwErhjh9fRgmKJdOeqzVSmlsXYFgSLxgvmRFOQwl1VW3PYmFS1bGim6Q8GPPf4Bpf/wj6irMz8WVtzyJH36dJcKJrBvufq4FvgbOTNYS5ekM8ani/GXZb7jpvhfQrShfNLuaVsONPppdniywAN9XiQ4NiHdffP/zTDz16sectZXJJs72D93fV5ASMkSKq1YCHYhQO5C3U2XlvbjLV62NtmnF6nXCn5eTJdy2rJLiQiESpA+j8OhW/z7dccMlJ+PsEw/SY1o6LocF69twjZmqo94fRB2ZTJXXGcuxWVVYLEpGxsViVdBE94TVpmakvER4NU77FT2++QyWj95fr/Ukqp94CJz2lO7llNtnpXFQFAVqhsYiUdv/i3g73Q+qmpl7bH223+JxQ8nOajFm6N8f6i8/w/nt1y3i12c7uGzGy0G4sX99GnThv149inHjZafg1gdfBr83wl35Y+Z8vEQrjPfccC7sdhuY7B511iSMGjEQU96+HzOnPIuv3rgXB+y5Az7/7lfOIkxRQS6+eet+kfbwLRfgq6l/4N1Pvxdp68Ni7d6XZb8jQpr8ZOW//M6XcDkdLZ6p/H5MTW1jsmwbJI2f97dedRpuvPd5mhz4kta55y5b4ZOX7mhhuF9JM/3HiangXEerQnz/3X7NmehJK+HcZF4BZHfyXZe1eMl/y82HcrRQFiY6NCDV+0IUpFsXnXEkmpo8eOeTMj0mM85GQ3j3Ld0Wb39chnWVtWgkoF5+52scfsCuUBTWKwB8wgLPiA3YWJv756wFYimovKIaT73yMbYfNxLGjNOQY/fYQ/aIbn3gcFc2Cyub8POyGvDyYlfux4ZqeyUtyf+4tJqW5pN/+XWkPTwWU86cI4qIVFYJd2OwSLELNoEQqXo3hg51xT7wL62xVtfc9iFDtJB8cU3DoZPZRx64G8ZvM0qQLn6WXXnrZFxw2uGC4HJT73jkNeyx0zhcff7xgpBYLRb06dlNrFbe+38TWSRqenUvEmlcXklxPikCLNE0Xro/+H/XCk0lPxuZsBiJi5atxmmX3CXSWIbJspHGyqTzrn0QrDXe5dALSCM6WWieWevJMnwkKB/pydsDOGw2wVAI901+C+efdhi1RaMf9z/5lhC54e5nwfne+PBbsZTObRIJunXOVfeBn9kcvPPR13Dv5Ddx7tUPiHZcSdpAbhensVldXim0yNxGPkaUiTjHs1m+ah3OuuJe0TfWms/7dzlHR82+pdsJHvDZlF+icfE8eTnZGNS/l+AGvDWSDU/qkuHK7Wbu8cRLHwoN/WdTfhUchOMZS8b61fe+FnFcJxPNdz6ZKrT33BfGZPrfC1Fb1yiOXuU4NqdcfCfmL9J+UMbr8+O2h14Gl8dp3H/eshEPZ64j1nzwxY/o3aMbdtl+i9gk9O3VrcVL/i6nXcgkOzQg0X3BfbjlgZfE+HG/eCVdFEaWzWrBeaceRmOs3RsUlZFLu+MyUtR/W8jxh+2FwQN6Y/cjL8b2B56LQCAoviSMVlUQETbf2OXrqnDyhbeLpaA9j7pULMPcfOVphrhwFUUjyyKwkVjz5yv49NUseAItX9DbSLqX8W5UVIWxeplKeIUzXrZRIJec3Vgpgo7PPgGYpIhQ17bCzHapC0zoyZHXf4EAv7SmE95fltdi3jrSou2+u9aS+nrN3cTtX38FysqAsjKgrAwoKwPKyoCyMqCsDCgrA8rKgLIyoKwMKCsDysqAsjKgrAwoKwPKyoCyMqCsDCgrA8rKgLIyoKwMKCsDysqAsjKgrAwoKwPKyhJ/zJk03Xz5qfj5j39w9NmTUFJUgDNOOFCMEhPGv2YvwCH77SzCsZZBQDje6wsIzRtrhy+d9Dj4vZYD99qBk/DvklU4/9qHsMfOW+HlR64Fk+HTL71LaDV5O+CZl98DXlp+8aFrsN/u2+GSGx8Fn0PPmZmkhEmL+8qj1+H+SedBoZUO3qbA77tw+mVnH43Lzz0GA/v15GALw0SUjwPdYetR0XjeLsiB4w/fS+TbadvR4K0B3E+ONwy/PM7aQg7zHuA3P/wOO283Go/efhE4zAovTuO2MMnj05peevgaHL7/rrh00mNCY874MXF2e3x4/I5LcMPFJyM3x8XZWphD9t2ZCOTyFnGxAeYTL7/zFQzD4WS4cn5uJ5PRhYtXYa9dt0ZPmpDwu0PTZy/EPf93Lq67+CS8+t43+Ob7P1hcbFFhbfN+u2+PZ++7AozN3IXLBeb7kpKP43j8uhcXiC0rnOmVd78GE9BHb78Yzz94FbbcfIj4TYJ4OLN8rJlPE4AJe4+PjRZhJs3X3/Us+J5iTbCIJIv71T/BoQGJ7gu+n1wuBx657ULibr1wz+NvUEnN1647bEn3oxcVVbXNkR30qR3M32my84fziTsvwbSPH8PU9x7Cm0/e2OJEhSsmHovfP58cbe+l9KH888un8MVrd+OnDx/F64/fQLMXbY9u314l+KfsBeTF2Q4x8ZRD8cy9V0TL6Wqed55z4dk78zB3QbirNf0/ae8/fys478Du+Pyz9k1+Uml0XX0YuTD9OuAvyTULqZTZGWSY8PJ5174M78PqDH3rMm3gY8l0wlte78W/tMITOe88gH+EosF0z3WZDsU0dOZMYMaMmMj0giecAPAcYEObZEch9yaN7QmH7y2I3GnHHQDW4nKvqmu0MSshgsNhNk++/DFuf/gVYVg7yHFs3B4veDvEjH8Wob6xCQsWr8QrRNA47bNvfxHPu4vPPBJbjRmO6y46CbxP89fpc0QefhHuWorbZssR4GfeEFIm8XI453UTWWTyzPtdtx27Ge667mxBjjcb2p+TwXk4Pj83W4TNFhPCEUP6gTV4RvywQX2Fd+TQAeB8xglLIjKJddaJE8AY8crs0QfvHt13++es+QI3XuHl7IP698ToEYMw9eeZmElYMDnjd3Z2qPQY2wAAEABJREFUG7+l0KT36ak991nWMMMG9wUTSyMcz11LK8O8h9UwTMyS4WqUwe8N3T9pIv531L4YOWwA3v6kDDyBYbyYczCp/fqHP4T4mx99ByaqZ590ELYg4nrOyQfj+MP2BMsec/Ae8JA2d+Y//4qtLkwgOZPX6xfvNPFq9ajhA4Xij3FNFee/5y2BIcvlseHx5nq5DUUFuXj61U9wykV3CM0+a6HddK9xfSzLhuXZ5UMDEt0XvOpw+TnHYIetNscpR+9HeC9DXX0TZxOGJ2/DaRwWLV0twpmwNhrCa4DBN4Kx0dqIS+TyAPGHqyA/J5HIRhdfX6sRtzXlG13X1kuH/l0EPIWzcPS5I9dL+VxoIADkoR61KID4W7BAOF3dYsKLCGj1hKyu3pmu2n4mvNka8Thxpx74v7MLsLbBh0g+3Wsbg4b3/POBs87q0Oi8+irw3Xcb3vTunbjZvOzO5JWJ2kPPvAPWurJ0UWEuO+AVSuEhi38syWG3YzYRlSk//EUx2sXEhIkVm2dISfPCg1fj8Rc/FNv+Vq+twrgxwzRBsosL89CjpJDKrQYTOc7L2yEoSVwsu4ZWRTlw4elHYNbcRWI1dd/jrhCEjeNTMFixpqKFIiqVPKnI5GQ7SRuobTtbXa6tlj349Du0tP+KMDabFR6vj7S8FYIMDtJPZ0pUdiFxgmUrkz8kdxs/Fo/dfnHU8BaAZLgadbFyzvAb4/jeZ9+Ldt720CtE/JZHJzi8TWHbLTczxKMuTxz2OfYy8WLZnIXL6Ds2FE07YsJu6EMTpsNPvwHbHXAuWCvrpklKVKANz6Jlq1FIpNYslpPtEpMiJuusLHzp4WvFBIq12oqS/qEB5rLZn52ladk9Pm0MOY4NT+xWr9XGk8MdNRsd4e0oIBt7/oY6jfCurWr+gGzsfe5I/xYR4d0Gf6Bb4zLg0087UlTCvIFgRGh4l2AQgnYXPEuWJ5TtSgm8o4GpbiAsVxP+s3Hj7TEuF/gs5KZ6BdN/dOCOR7zwZdMkf+HC/6xZGauY+1db26Hitt8eKC0FSkuB0lKgtBQoLQVKS4HSUqC0FCgtBUpLgdJSoLQUKC0FSkuB0lKgtBQoLQVKS4HSUqC0FCgtBUpLgdJSoLQUKC0FSkuB0lKgtBQoLQVoWOK2m5fdr73jaRy63854hpaxGxrdePyFD4Qsa3rHjR5GJHOqCLPFx2teds7RKCUCxuFExiB5/NZ8cUEeeOnakOUtBGsralBERKeQDGt7zdo21rIxKWb57cZthq/fuA8fPn8bDt1/Z0y69wVxrJeiaM8WMdFlwTiGiVhFVV2cFCAcaf6e4H7GFUohsrgwX5DaFx66GrztwjCnk6actz26SRvJJllR3Pe++ln+yeRi04qT4Bory+Eimmiwe/MVp7Zo6/2TaBWGEvr26hb39Ip3iSAPGdgHH794B266/FQcd+ieJK1dPFF57oGr8M2b9+H6i0/C6x98iy9MLzOacdZytLRZm8/9bxnbMtS9m/aSP2uYOSXZoQGK0vZ9wWXEMxVVtejVvTheUrviJOFtF2xdN1N9jTbkP/wSQrWbVIudqSudsC3LFqtC+yqa9u23wsm0FQgooo5G5KDC0RsrZyzOdBUty2OtX8uY9RJissuGz6tdLxXIQttGQN/DW762mUwsmWfBqiA9RILBtvN3dgkmvBUVQHV1Z29pyu17+e2vaEm+HFeedxx4Hyq/Lf/Ma59i1hyafVMpV048Vuzv5WPGWBPMBLmyug5LVqyh1JbXmnXVYILLeXnbQxGRWd5SsPN2Y4SG7suy38CE+oU3PxcZeXvD2FFDBWF89vVPwT/c9O2Pf4FflNp5uy2EzH2T3xJlDhnYO0qyvbS0PqCvtmd3Bi2x87nA7jhaRSZTrBXkNovCdIu3JXAdvP+WydbIYdr2iLJpM1BT1yD2IjMJ18WTOmNHDxXpdz/2Bml9vcJM/XkmvvnhT/DyOu8hfuqVT4SmewppxLk9IoPJ+nfpKmw+bIApJjVvMlzjlcAr0tx3fhGRx4r7z2ff8rn/LL/XLlvj029+Fts1GLNf/pwj+pGT5QS/0FhdW481pK039i9zHl4Z+Gv2ApR0K0DpjmPpHnLB5XRwkngx34yziIyxNh8xEIuWrWoRy/jxvcL7dt00YXjomXfFPcJ4siDvJ+Y2xDs0IJX7gsuINXxP8TacIUTsY9PaG9bYT3tzy3xdDoGmBm3I330uG6sq/eut/d7Tz0TgwYfWW/kbquC1q5oJb/C7svVSrT+gaXjrkI/5Df2wYkqV+FGD9VIZF/r448Bpp7FvvZowq3ipBnlKA4GwIa9Jk4CpU7UaifBWRqxYua6Z8H78cg4+/IkIRbJNpFru9O060t5NmgTMmJF+3vbkYMJbWwu89FJ7cne6PIuIaN07+U0wyWUyxA3kpfKD9tkRV9/+lHgZm/dR8pIyL2vvf8KV2HLP07Hb4RdhybI1OHJCKYy/6toG7HX0peBtB6dfdg94WwRr/rKznGLvKp+UcOmkx7HDhIl44a0v8fAtF4KXkAvzc3Hv/50rNIPjKe2C6x8G7x3dbfyWouilRKz5dIPRu58KPq3hkrOOEntRXU47zj35EHG6A58LzHtLRQaT1a9Pd0FAf58+zxQLsRf3tfe+wdi9ThcvgTEpPe+UQ0X5Ox9yAX76fbaQVxRNW8gBRWn2A81+xu2pey7Dj7/NEicA8EkFl9/8BEkoYM0xt5f3oPIL7o8+/54ghIrSnB/099GXP2GEvieZgilf47cZJU6giIerUYiitKzrjmvPAm8Z4LEaS/3nkyrq6huF+GnHHQh+eeucq+4X48xjoaoqDj9wN5FeesTF2OuYy1BZXSvCbPE486kHfF/sdfRlGL/1KOy92zac1ApnERljbTakPz76alqLWH8ggOvveg47HnSewPTzb3/BI7deKPYSs2CyQwPi3hcEgWrCwfAqNEpcHpsff5stSHX3bgUczIjR2E9GipKFdHYE+G15Q8PrblDw/rvrZ/ir/10K53PPoPGexzo7JG22z92koAQVWGYdjNDipfA/RmSxzVzpCQR0wtuAXKxEX/QKrkRV7XrccnL//cDzzwOvvZZeQ9OUDrN6l/IEgs1ki4LyWp8IMAG86Sbgo48Ar1fUtDZsxZJVLbW5q9EbYE1/pvfxsqaV67/1VmDSJFH/erW4v1xBWRnbXd6wNotfmGaSa+7MnUSKPnvlLvBeVI7feovh4sXsv756Wpyzyy6/qH3AnttzMpggczmG4Re2eb+p+WUkJqf84vaXr9+Dnz95DHyurMhMFpPbXz55XJT9xxdPiRefKFpcj9x2ETjfd+88iG/ffgBnHH+giGeLSTTL88vjTP44zmyYcF50xhF47IUPwCc9GGlcd9m7D4kXzs879VARPfGUQ/HbZ5Mx7aPHxD5Z7gu3ixP5BXVzvaxh5H5wGhve9sF4cTumvvcQlfNEtH/88hXjwW1//7lbRR84jvOx4SPYWKt84J47cDCu4Zfebr3q9LhpyXCNbTcX0KOkEBzPmHKb+Fxl3ifNaUwWb7v6DEyncWa8eUz22GkcLfMX4Z2nb8LXb9yL3z9/Enw+LuPDeU479gBxNjOXxePK+Rl3TouHM8ebzWH77yJO8fjp97+j0Xvvuo24R7hMNt+//zB22HrzaDpPorgPBt58L5qJaux9wS+pPXXP5dH8PNHi9jMWHMna7Meefx88OeFwpsz6YTyZap0sJwkC6Scx4fX7gImbf4wIz6Qmv55+ISnkWDJjnZAqXL0QFU3rT4uMq68GeGr46KPAUUcBS5cik38CL735TwTPAurdqJ2T+RfKvP6I2NLAhHcV+oB0vPhnbiSTXWkua9YsYM0aEQ6v53NYPT/Ox7yxT+H9O+tFfevN0vuT8fL32APYaaeMF7teCzS2KVRWAjoZDDqdWGPS8HL9gvCyZ1XLpUuO6pAhTZDI/+67ABNfboeIWD+Wp8YjCg7PpPta+DYti9+G532x7Lan5/zidt9eJTAIkbkMi0UVLz8x6TLHs5/zmQkNxxmG5VnLaoRjXSY71bQUz1smzGlcH79wrihKNJqJVH5edjScrofbEVsml8EaZINccdgwq8orccsDL4p9sVy3EZ+uy/gkwjVRWZyH2xRvLOx2m3jZjzEy5+fTPLJc2nYFczyXkagsLiMeJkZ+xvv/LjkZN9z9rNj2YcQbZXK5itI8RkY6uwbe7I81bd0XZvlHn3sfFosFRx9cao7usF8S3g5DmNkCGh+bjDUPZV6LyK1ctUYjUdsP0Ehb8YK/jGciJ2fM1CypiZb1548zsabeGw1n1MMaKirQe+X1wDvvABneYxsIhZHvJeJAddSiAP9GhsA3ewky/ecn5Vse6lE00oXinYqQg0YsnFGH9fJnIiDu1WvXSxVGodbPvseNuAl5C7TlSCM+o+7xxwPjxgF9+2a0WFFYKAQ0NQnverX+Jk3Kn39mpgqD8K6jSaf+xnPYZsfKcuqLXsOwLX2oyemphTI9WTDq10rHku9+1n2Zd1auisDl0z4n6tLMfy4z32JZIiPA5I2Xw5l08T5NjusshvfDXnvhieJ84s7Spv+iHRP2Ho9LzzqaJspV2NB/vDeZX4K778aJcSdiHWmPJLwdQW895M268nIU3HU7lumai0xWMXWBRkSLPeWi2G3wB5avzPxyc9ZvP4ny2bKvK0ejv/lhy3EZM16vKMrp0R563spqEc6U1UDtdvobRXENyMUSDIJl6XIRzqTl94Wp9AZk9XNiwIGFouiK6RnWvIlSyaqtJUu7vE++Cbz4ohZYD7bl32WiVNcq7ReARCDT1g8/AGuJuLOmkl9eymT5TN42BOG97jrg9NNR0ejDXytr4Ql04DNpaFj5jF1uP+ERtlhRV6NpZI44tw57H9MI1+hulAKEVq4UbsYso369wE9vX6z7Mu/MXUwzRSp2MQaTTdcy7X4jn7w6OQK8dYOXzlmr2ZmaymcI77+Hti2kM7VrQ7dFURQw6eUfrdjQdfN+Zr43mPRmuu5NhfBmGrf1Ux5pLFV3E1xrVqGuVjtgPJMVNbm1h152UFti3h6/4o+viCxkspIFC7DjO7dES5x5+XRMuydD2qtoqZonHENGPBWZm4369j8Q5TfdiWx/naisFgVYhCHIrcg84Q03aKQ6lJsP2+B+4D/PvPVLeJdhALr51wBffcXVrReTtUojIMUVi+FfX/t4WYtZXKy1/9lnNTdTNhNGfVuAUeSiKrfhzZzLmmSqq6IpgKU00a126/to2lMDlSOy8WRQJ59hqxXG3v3jJzbh9P/ZULBtkRBrWrRauBmzjPr1AosWzNR9mXdWLtC+x36FTlD4RygyX40sUSIgEdhIEJCEtzMNJBFeozkNM7QjaIxwJlx3UwQX4mFsNevDaHFzvtW0vdGIjnpMS+Zc1CXrbsTBDx3N3owbb4O2f88o2F+ZuUmC9fupKPzrVzgDGhndcoKC8uwByPt7yNAAABAASURBVPVWw1+lacqNejvqRuq0B3dWYQG23GYzrbjlGSYiWqlAo9afBRguYsJz5go301YoAhTVaIT3yMZXgKefznQVoryI14fZfUoRcboAXsYXsRmymIiaJlW/r6jF7HJtrDJUg1YM10PmiyfLcd4WCu65swNfyzrJFS+k6f4QaXgb61TkFYcxoDAbW/XOQ+FAJ+qRB/e/GZ5YmQjvQgzDKPdf8AbXzwrPumU+gd/v2Fa4mDFDc6UtEZAISATiINCBb9Y4pcmoDiHgq9fICBcy983MLwV6vQrGYgby6pu1ugWr5yKjf/yWNhXoRhbZ2lXoW4uazHJEUXCovqW2rYkIiUjIgGUhTXtkaQVyAnWitB2Ot6Chn3Yuo59/jULEZsji5WcqKpidi8IhA8kHuCpI+yp8mbV8+tmYL+FkzMIWwNwMj7/e3AZvAMN8c0SoBBWo/+5P4c+0FfL48fGsEajN6aVtbchgBeEALZnX1uKzuevABH5lnRezfrWhiTddZ7AeENnFvHm49MZhOBtPouw7bSWmXVUEqc2ckTXTuv/Hb3Ixb4YdOfkhWGmpEvTXvbuCVeiD0LIMT6x0kk1V4EfsjC0xE9P+WD+Et2pFE1eDPjtlY54yEpgxQ4SlJRGQCEgE4iEQl/DGE5Rx6x+B+grtC5xrWvruCtQ3dmAvHxdiMnzigJcUovxCFEc3DtU0iVnVmX3gBdZpL3ntVDQTTT37cFXCLP2rXLiZtIKNXkzFbjj5ymr8Yt0JVbO1ujNVh72uFrloEMV1790N/kHadoPQ4sy+IKPUa3WEc/NEXdU5fVDiXYXVFZknChE+poNqeQUn4gFcAtXnBZZktj9UPJb+rmkO3xx2EXgriHtFFUdn3FiDXvjgwGqlByKrMnsvh3XydsDmPTB32yPhL70Bz57ehH+XZO5zKQAx/RLdJEzC4Pnfod1/OskFE169/d9/lYsV/1qRnReGzaKIovv2UbAGvaCWZ3hipdfJlSwZqh3rtPaTXziYcVOzyifKtOTbMT0yFpFN9KQGAYK0JAISgTYRkIS3TYg2nMDyBcRI9eoGBxdi+ZrMER7WUPl8CnJ1Ate47XYot/dF/6oMa0WqNNLZVNgd7pIeem+A2n8zT3jR5IYHLnTrE0S9qxi5nopofZnw2IhM5aNOFLXDmIGwjuov/E1/Z5ggNjaIcsM5OcItH7wl9sWX+HtuhokVlR7xB8jWrrkYqXnmaJpYLZAZu+r3xaKgyp13xAr0Q2hdlQhn0vLoL3cx4f03PASRTBN31rwCosmj/3wXx1Q9gx0xDdN+yfC4GCRV1ARsXfu9sfNEj0nDMQinifAGYBMF5BaGYbVoX/n9e2kaXmdVZicJMPXFeeRYUW/4l+nCzZTlD4Uxd10j6tZo35e5ve1YgkEZn/Bkqr2yHImARKBzIKB9+3WOtmzyrVg+r1nDOwwLsbY6g4SXtEh+j0Z4G0ZuheoHHsWC3C0wrGFWZnGvrIRPccJa5MDP19yBn865S5TfuHiVcDNmnXMOCuf9jkbkoLhAQa2zBIW+dRkpnicHXJAlGEAe6tkLFBWh5zAHytETTTM1MqcldNxW9JfWIjmahtc9bisMxFLMW5BhYgUgohOi3AIiDdAJ73rY1tD0t4ZRyfiBqLZ0g7VGmwhREzJ2hfStIH7Y8XfjEKjLl2WsbC4oYiJvHGYzFP9i+aoIezNn6LNpLqwUZZj5dxDt+tPHF/yDEro/oBPevMIQbKr2ld+vhx1r0AuFtZnFDCbM+uwxDFVqNxQuzOykml+AnEeE163/UuSgUS5UoIRWK4gAM9FvF3Ayk0RAItA2Al1bQvv269p92Ghav3aJW/Rlda9REIS3KnOE96sFFahYbQFreJWB/VDgtGBFzzHYzD8bnkDm6kFVFT3kSpCbH0J4iy1QcPj+ok+NyzJDRkVhbPl8bGMtemBADxvqXCXo4V8p4jpqhXUixcvlTHjD/EIUFTpoWAir0AeRZZkl72qDpkWO5OVQLcStx/QU7trflws3k1bE54fbkoPiHmFECnJQ6eoNrAcNr23lMtHsPjuOhie3CK6mahHOpBXyeEVxrOGd5xsq/Fi4UHMzYPvcrT8XTHjXlGegcHMRJk3yjD67oz+W449Zres2Z0noNxFO6C/cBWAT4vlFYdj0LQ0FLjuqs3uJeP7Map4M2DrJ9oBWXvItmJu3NQauyyzhXURzqcPpMzK8/DfR4OHD6VOaVSL8GX9xUStV2hIBicBGgIAkvJ1oEJsqtQd41ZDRpEcsR+3q2oy1LkIlLZ1vQ761EVYiOt2ynagYvDnFAjVTM/dCkVJTgyqlGK6cCEb3yMWw7QeJOkKr1go3Y5ZOeMsJqUG0pNmQrT/w6jTy2JF6wkQKOb8t6EMe6hHK1TSvI4aqaEI2AjXNmniWa7dZvRooK4OtoVYUoebnCtfel0go+RrnZXh/JZUJIiRB2ODKjqBX/xAW2kdmlPByFWwK1i3BKvTB0J5O+AoLtSPQOCGDJqzfAxGnHYsxWCs5gy8URvilNa3UqD3C9i/KVyvRcEY8JsJbNXxL9MMKzJnPn9h2lG4mvOXlooAgrMLtM5ioryq8KHBaUZfbQwvwfaj5Om7r9buRhaJsK5b22BKbezNLeD3eCEpQgftxqWhv315FaDK2T61YIeKkJRGQCEgEYhHQv/5io2X4v0Ag3OAW1TaOGC3cg289BMjAwfC85y1Cz89lC23IUxqg5uXCblXhHjVC1FM5NXPbGhTS8FaEi5GVG0aWTYGdtJYe0vbYMv2jAH4/VnYfg1txPcYMcMGbVyz6ggzUY7ysZA96wITXmp8nymatWMjlAhq1cRKRHbH41+F23x055dqe4Eh+gSgta0B/4UaWaYRFBDJlEeENKDZkEeHt3iuMOaBJz7x5yPQfa3RXozd6FKsIdy/Siudlds2XETvi84lyug8BooR3Man/RGzHLUUnb9GSRo/G0PC/qKxYf4S3fvgYUZ17ejv7QeMrCmBLJ7wB2HDSVTXYbm83bPoeXk6uL9Q1vJkkvHr9L+AU5OepWN1X28eL339Hpv68Xvpegb+5OPpMNpT01cIZ+L7UCpK2RKDDCMgCOhkCaidrzybdnEiTRqSyd95C4NB3GWleiUCKQAesgNiUGkFTvYqscCMs+fmiNOc2g+FGFkK/zhThTFhKZQWqwkWC8DptVlFkla0HsmrWCX/GLK8XPthFcXnERy39NcLbsLjjJDGsa3i58O5Yh4hBeB1W+O1ZsPubOCmpSWmbiMcjyug9/0fwOFhpgsARBUM0wmtf2/G+cHktDJHEQMQGV1YY3XtGMNtHGt66OqirM7tNw+muQyO0LRqWPhqRXzm9okVTOhrgM3i5jKxiGyL9u8GrZiG48F+OyohRQsGW5YwZg26htfCVN7WM72hI1/B64EJogKapVha1U1NpJulrtBUCJryu7LBopVXfw8sBX3F3doD1QHgfw3nIdihoGEQTKqqlYXrmXoz0eiNwwEel6pfTCXefAVpg6VLNlbZEQCIgEYhBQBLeGED+y6Ci70nM3kEjvNwWb23Hl+gDoTBYwxv0K3CEPLDkakRkMD1b+SzW3IWZ0/CGK2tQhWJk5YSR49D2Dta4uiO3qQKBMKmZuVOZMD4ffIoDTtJUcnG5w7qxg9UzO751osb0gxbdUEkacWLUVHr3XIcgvM5AcsJT7w3iy/kVaPNXuYi0U7HovmIWgrDCblc4CLVE255R7C3H2sqwiMuUxS+t8UQhKxvo0weY4dUIiWV+ZrW8Lm8d6tUC0eycIUXCXTEzwYtru+4K8PmwpEFFGn8RugdY3J5vw6DNAliiDkb43/VIeLfQPpeFFZpGnuvOiNFfWqtFAawD+4H/ssvbuX9b17ByGdA1vEG6t1Rt7ilWdkQaWYHe2l5xrMrgZEcn3Fxnbo6KkkG5VBOwalm9cDNh0eJOS8JLGt7e/YNYix6A3NKQCYhlGRKBjRIBdaPsVRftlMIH5VLbldxcXN3nKfIBQdOPUYiIdlhBIppMNe2NOnlmlSiV07ubDbPtY9Fz9WwKZeayrl2NSnRDVl4Edv0Fmcbc7ijwVsCTyQP76cHuDTsEseaWdx9Vwg7Wzeu4FtHv9Yqy2OqpkJa1oIC9wgSdLjjDbuFPZPloghGmGUZTW/31NtcToGVnu1UjvFxubWFf9MZqzJoT5mDmDOHmJw1vdk4EfWhF+x+MEmVnmvBm+epQb9VWEvJHFIo61sxNQHiZwbBEfT3bKZuKVT4h6yiwYdjmQSwIDkF4UeY0fAp9bkQFhqUT8h41S8CfKSO6w65OEi/AI8geSLMQKrCvf1n7eKheFhUB/Ka91OWHHRYLfwMATqsqktjK6+5ANYoAXRPMcR02ev0Bup+tqoLNt3aJIlcv9gk3E5aXirIh0FxUdjb6DwpjGQag4Z/lzfHS16UQkI2VCKxvBJq//dZ3TbL8NhEQPwJAUhbSWJQP3Zp8QER/01oE2mnxj05w1hw0sgPkaBreHjkOLCvaHDn+GmB5Bh4Ubo0IsoY3N7eZqHmLeqCEloK9weY4rSEdsEm754vYifBqD/KB47uLwjxLO67hjZiIap8Iab90vLiCppxuoi++JH0x8G5Biu69F2Atponkih8HgPYXhJU0vJqfbX+PnuiFNZjX3peXuJB4JuCHL2xHdi4woJ8qJie+vCJkmvDaQl54LFQJtaFkpDYZWTs/wdgYhLe2lqRTvxoq/ELYWWjH5luEwPt4rUvaufdVlNTSUsPBlhGbaT/Wwic1/LOIWFfL1PaHdA1vI3LQs1hFda9h6I/lmDGnHSc10IQGxp+u7eZ7S7UACv3D9FdCw7IKfeBdstoU20GvXr+aRfezVcW222v3QNXK5sldB2tAqy0N9PkcMSKCFeiH4NJ2bgXpaKNkfomARKDTIyAJ73oYojpa0p5X0QjeSpBO8faAm0hCNmw2FQUDskTWSKNOUkWofVaAHqget4JcNGgFkAaZPb3ynCjvq2n4MGMGR3XMLFgg8gvCmy+8wgr36EGP1VVYsDgswu2zYnIR4fWEnTD2JhbmqqhSuiG0uuMa3giRwha1FRREg7XdBwt/cP584cazmPAyDQ+IvdMxEqT5jcaYyG8IFuhbnkWyvUc+0Z9GzF/AJYmozFj+AAKkfcvOiqB/L2JBVOraHiPheJZWFP7+m0KZuSxEFkNWuyjM1UufjKyoQty9zTSWQlA/Dk74U7DqdcLrKnJgm61VCMLrbUKmjqZyxG5doZWRhuJ+YMI7f3kwhRamKKLv4WXC26vIjuDAfmDCO/vvdnxedA2rUbOnuBdWozdUNULGiNXc7iUKTal6IbCcJnVaVMdtvX7FZhHa5PyCHFFm7RptciICHbT4dmmxh5fKGz1SBRNe59oMTNypPHlJBCQCGx8CkvCuhzGtavJj/rpG+OMRniT18f5an8UFm6Ki++bFQrLhu7+E2xFr7hwF5x/QHQ/gEq3P51XAAAAQAElEQVQYnfDyloP6zTbX4mYl3sfLmllvKmf1TpkCd0EvfI29kZvfTNTUXqRKolrWLqggOzNXhLSCnpAdfBoEl2izKKi2lyB3XceXtJuqTculXLiOF3ttowaygyXfauReBGKsEJFaumjZOxyTQkGd3JAPpKoSDlshWFpoeFUiV3yEXAaPlQX/+T0a4c0hxVvPbhaOwie7XY5wdg6mT/0D/1YSYRSxmlVL8my0UOq2PeRDWGfwed0K4FOdsFXVYFmN9qJei5JoLKPhNLY1NFb7RbbcEisG9bVgbcEgEcbizGl5tQJ12+mEr98QQXiXZILwnnEGcP31gH5PNNIUh1bnYRk6AIOUpTTZ0etNx9E1rEaWoN0FL5ywWCmGVxjIMa6+PVWwhteyNoMaXoPw2rV7y6jLXRk0vB12mfDaoY19430PiPJ6dbOjKrcvXF5arRIxG7kluycRkAikjYAkvGlD1naGiiafeEmM93G2La1JMDe2Bz3wW+jhRKMyeFQOWGPlzcAPNlRVh1FXrWIr6OTZROBKhmRjIYahflp8DS9r5L6Yvw4LYoiQ1uoYm55EWbVrUI6eKDARXmufnkKwabG2pD1jdR2mLq7CoqomLK7StkEIgXQsqkvbw6sRaxeRqxk9dsPO1Z+Csax2+5Fs20GyqrwNMUvJ+flR8W47DRH+ddP+RSVNbNiICJNljHsLDa9OBExiiCW8DloCNtKt+bnItzRg2WK6GYzIDLhhIrB+2MWuFqNbM/O3g9rUCNuSxZhd3iDwg/43c009xdXrodQcN02OHGEPDA1vodOGBmcxnPXVWEhj7gnETARoLKMlp0F43TXaMrmr0I6eOQ4EhvTRisngWbxagbptt8O++VBBeFesVMC/+KWntM/59VeAteomwutyAcrAQegfWYZ/FypI+8+4z4qKtKzaxwOqJYLYO2loP6vQ8GZVZlDDqxNuvyNLq59srz0XwTo/amM/V5TWnsvjAxwgizLn7LYL2UCfXCcae/QSfmnFR2DJ8jX4dfpckRgKheFmIEUoM1ZldR2+oklzZkqTpUgEMo9A7Hdg5mvYBEusagqAnzOx77wkgyJIX0DOkBs+q0u8Sb3lKAv4BIXshbPhDcYQsGQFaWkt7OxlC1CGUvBh7eA/E+HdbEQEsyxjEZkxg1NaGV8wjDB1pNGXgobGtESfn88IaMVlDdQIb2T1OtJ6RrCk2oN1DT7MXtOAmWvqsKZeIy6adIq214emoDO6pYHJYnk/TVtdMWsufltVix+WVKGKSGmKJUbFvPWa9igaYcJrzO690EiauMCcRVR+tTBuInhRWfLwlgZyYBBf9sc1BjmhxCCssNnJo19ZRQXIRhNWLrXoMZlxIt4AArAhNzeC4mKtzHkL8+Hu2RvZy5fSRC2CHxZX4v2/y/E9uX66L8NIj3hFVwNsNlGBy2aBO7cIhaEqPHlbDmbRmIsEw2on4fU1aONUUGJHtp1UmOO0yUg4AxreFvuvjXaShjdv3Aj0wSo0rPKjhrA0ktrlhvTPdTgssvud2cLNGm5sm1kuwmlZOuFET/0zp2dmDS8tgughzenf20o90ScJa7XJqJbSAVu/p22O5jLCDgec8GL67ObvhObU9H1ub4SmbNrYm5dFvEMGpV9YJ8xxw93PYVTpKVFz4vm3YfrfHf8FwR9+nYUnX/pI9Pg3Ir7b7n82aus6vmVOFEjW4mVrcMmNj5JPXhKBzomAJLwdHJd4S7T8+IrQmjabVItncuQIe+EnwmtVVYwcZMc/ljHouW4u7nnKhwUVzUvNM1fXU1jfj5tCBWp9LXbD1GbJnJyof/ttiFiHRiN/zSIsMr3wVU8E94v5FZhV3gB+TPmCbEezxfcQ4fU4NG1oXp4lKlM8rLfwh8rXYsaqOqjEn3rmOSkuAtaC/rysJv7eTpJIeAX8cAcdyCbixjJ5Tit8w/TtBt8vBPE08F7qqUR6f1xSjb+o3vKG1Ii1rzHIRTYbIjpGYGAPF5bZhiB39RJqe5jqiWB5zDI91x0h1HiiYOSLujohiIZ1TwiWFnt4kZeHQt86NDUoyMBRzHotQIQmCn6iC3m5iojb6zAv5s9wwDNoCEpWL4ONWFElTdiY6Fa5A/CSNjad+5gL5S0w7EZ0wsv+QGER9sQU/PNqBX6fGQBr4DleGPOWhjT2rPvrfSK7qo/PsFFB8D7OdT93/GiyoE5CRQVma+hQEfJ9MRfVHp10iZh2WMa9QMT30yGno87VXRTiHKoRd+fK5SKclmWUyW+kcUb9Y2tlDW/Mlobe9LFcjv7w2YhoZ4jwhvWxtNn1iqkNSpYDvLr0xwz+ZqSIDl5eD6IaXhCZNooLbT3a8Ma4XS+4b+m2+ObN+/Des7egd49iMOn1+2O2WnWgW2NGDsZbT06ilR5aUuhAOTKrRKArIaB2pcZ2xrbOIvL509JqsFlMy7XcRiav/HXPhsNJzZ13AvQgYq0gH3flt7lgHB3k33I4+G/5q4uwsLJR1PF3eT0WVTfhn7XNBJhlkpkQaWlbpJs0lpsPcOLf/C1E8soff8MfK2vBWw1W1nrAWt3KRh9p/QA+aksIJbOI8PoUJwq6hWA33VlFm2u/ghReUoElNW4EQxHkO6wYUpSNPnnaF66f4pDOH2kFPQE7+HgtI5t9lFZP/cxlKM6yYUC+C3lUDxPdpdVuLK/1GqJJXV+jrnkzpHidWfdzv9YWDEKPuiXom+9EgdOGOWsbBKGu1LXJ06dH8PbkXPz1i6bhRAp/QdLwZmWZBIdopGcwFuOtqXX4myYe5aQVDzCbNoml643QQ9NPhDc3T8tZUADUVVpQXTAMruVLMaw4B7mEGZ/gQXM2oZFPxP20Elrb/hrt+LuI3R5NXHPEEXBZ/Tgk60tcd0o38CSnya/jTGMZFazT8kbDSTxBt0+kWpyaOnHM2BChNRieuR0nvOHYX9PjzbVc27BhbOOQVS9g+bqg8LfbIqILBpdIqj9sgcOlf2P07w/+47H/Z44exxGpGCpLiMVoeGkODVXVJjkiXbemZ48Hv5zn/c40IdbT2uOE9Z9jttqa2x0eNBDj8TP+/rt1/e2pw+eP0B2sTzZM99jwzcLNGuv2FNyJ8mS5nOhFRHfEkH44/fgDRcvKK6qF6/H6ceejr2GXQy/Awf+7Fq++9zU4jhNffucr7HHUJUI7zOmPv/ABfX83jwXLsFlbWYOb738RCv0vX7UOx5x9Uyvjo+8KLjdRXTwRfvHtL6P13fHIK1y0NBKBTouAiZZ02jau94Z1pAKVEOSXetbS8irvd+S9qUxeucy4Gj5OMBt+6FE42OSGK+xGgDS8FBTXmAsHCbf037dgt6ioJs3bvHVNgjCyBjG6dCykEluRWJJkIrw5dguqho0SmbstmIOlpK2cvqoe89Y1ko4ygqBfxZtP5GDmn9RRIZXE8njgVRzIIq2r02aJCub1zEK5vS8ifyyBqykbI7vniv7YqE8VKy1iK2vaRI40lV444cpp/jIv2rafqNO+aBmKXHbkEHHrm+cCkzeaU2AtEUak8OdriNGktGCiQGPfQRgSmC/q6JVrRw5huKiyCbyFosYTwHUXO/H2E7n4tUwjYkjhLwQLUV61WXKHHYR/B/yCBfOBuesaxISHf9BiQUUHliH9QQRgQ16OIsovLgK8bgVT/+kD26oV6HfcYXB6snD5iQX4fSq3PwKewAnhFC1DywfeZqDnaTrpGPh7d8f/+n2F+moVi/9VMI00+2I7CN03uhiBm3rfAo3aOFmJHHD+4YMtWGYbjJw1SzHtb1IDcmQ7TdjYGmDkNzSJo0Zh+ehS7IFv8cMUK0T7DZl0XSanTHjJBEOWZsLLqlcATHg/+EondhSOvT6duw6/Lq9pGW20u0cPER9Wtc8hOxb+EIjYZqv31rn40HIY1Jtvgrsh9Ul0cwktfSGq36NmwW7S8PpOP1MIBaYv7vi+ZyrJ50dcwrvVOAVP4SySSPPivdRlZUBZGVBWBpSVAWVlQFkZUFYGlJUBZWVAWRlQVgaUlQFlZUBZGVBWBpSVAWVlQFkZUFYGlJUBZWVAWRlQVgaUlQFlZUBZGVBWBpSVAWVlMB9LmKzFM//5F0UFueirn3ZyF5Hd6bMX4p7/O5e+a04iwvsNvvn+D1FEj5IiXH/xyfjg+Vtx0+Wn4jEivN//0vqFZC+R5r/nLxHf8SXFBbjyvOOEueycY1BRXYv8vGxacbIiWV2ff/sb7n7sdRx54G5488kbsesOW4o2SEsi0FkRUDtrw7pKu1hLyWZYcTZY26ftGdVIWDiVTrAajeRC9PBzwQO/3UUh7cofPwI/jTwKB/nehYNIyOAiF7pl2dEjm4gIVeEPk6WJJrXDMXtMoS8BG5nsY3qiBoXos2QeRhMZHVyYhe5UB2tHuyEH75C28p/f7YZ4YpeIixdO8K+sWVSlhZx/5BCMDf+FJ+/NxrJFCupqgVp6Vl/0vxy8/2yu0CS2yNBGgH+kww87snObUWbCswhDULh2Jaym+kuoL33ynPAT8f86hZMi/E0akYo2IYbwqtQXTlv0zTJYVBX9C7IwsCgLVDwqSCPuJgLJ6T6zQlkfZ+ONfE43+0OwwGo1fRw32wwhmpjsgF/QsNaBUSW5GEj1RBQF5SkSd1FHjKUE/GDc8mlSwkmXXBnAfic0YMZyjSA1lbtRVaHgz18sWL3Eiu8/dWH2H1YWTd3oy9rQNa+cMYfI75ptdsTmq7/jIMrnZaOOJgeMl4gwLLO214hL5DLzoTRrtotsoJg+GzUl/VHiW40nH+kYeQvH7ps3CC/VlHvyQeiHFZjxXCX++IfYF8W16wqRhvvTT4GKCgSCFjiczZ9n95DhGI4FmL0gIO5bxPwx0fZR/gZDS26k0/eI8OqENxJRRJB/eEKle0cETNZuewVxf+hi2Kur4Hn2eU7pkOHJTpAmVDb6ijIKyt5qS+EtXvQPqmnMRaADFi0kwQGfVoJpXAb1siHw1DlafDr2CScAu+++4c3q1QlbOe2Pv3HtHU/jtEvuwj1PvImbrjhNaOhZ4/r2J2U4ZL+dkZ+bTRPXLOy07Wh8/cMfoqx9dtsGA/p0x7yFy7F0ZbkgyuyKxASWy2nH1lsMF+bP2TS7Jrm7rj8brOFNVtc71I6D9tkRE085FKNHDKJ2jKGc8pIIdF4ETE/YztvIztyy/F33Fc2zWRTk0/I2c9D5M21YvdQSdylJCJst/QHlrg8iC24EzITXZUHTkMFC07NgrirIVb7FgdWLbeBHY6pa0bBpu0CooMBcu/APHBEAvyAX+WuOCGeRxrJbth0DCrLQUK89ML0eBf7YrRFC2mTRk8gbccJFJJTgMCUAga1HYUt1Nn750YJnH7djh81yMH5kDpYvUTHtSyeRODM7bJE1YcBHj70sk4a3R44TK1xDkFe5vFWePIcN+WQaYwlCK0kgqBNeb2E3LdW0pYEjuo8fzA4qflyM1563YcYfKlYttGPeXzbqhsp/CQAAEABJREFUhw+sMWUBr4dt3RA5Eb4Ij5zwgW4Q3QOEFCvUaEjzhLYfj10cP2P2DFU87LJpXLKJFDNR1CTStxW63wJESAoKtdq6ZTmw/0n1WGTbDJXohnWLvKhYp415sMmGlx/MxVN3Z6dXES2Figx2m3DY2mlQEdZuuxMcDTXYMfsPzP7TCkVRUF9Tz8nAdttprhkfLSahrfp9Is2amy/cbjk2DDy6h/CH5q+AscVERKRpBQ3SzvlY47rLLuwTpvCgA4Q78N9f8eyLIZromMZUpKRo0VgYkv6wleahzeV4Ro3B1tYZqFhLGHmDMP99u7ASvy6vFbdPQ0waSMMqZPPyhEM3mXBVK2CJ/VBSytixwPfYFXOdW8L18IMwfVVQajsuGvuAYoPD0dwXx1ZUCRU10j0TcxbFTCYpPt2Lh8Zl08aeVMnR7D1ybRgxTo+PxqbgefVV4DuaiG1ow/dVguYVFeRhs6H90eT2kma3G8bT9yeLlq+rYgfvffY9bnvoFWHmErm1WiwinrcfHHzKdfhq6u+orm2AzWZFmGfiIjW59dPvf+PR597HQ7dciML8XLRV18IlK7HNFiOSFypTJQKdCAHtqZdOg6RsCwR6LZiGt29ejc8+tMJpteDTV7Nwx4VFeP+5XPFAQlt/4bCQ8LqDcMGDoMMpwmwV0LJ8ZMsB7AVmzxPuo/c6cNaReVi3yoIgs2sRm9wyf+H5RmzeSniQTnizF7b+4QF3kybOJC7UFhkhwuuOuJBFhFdRWt5abnqA28NeFK1biM8/sGGbHUIYPCwsTEONhZaGNRy02tqw3W4hwIQ3O7f5wdoj14HK/P7o1bgIUz634u6bHLjwdCfefMmGkw93YfqPdsoXgbHlhAJxr6BHIxj+omIt3di/qYUwar/NhO/XyatwyzUOHDchC4ftmYUbTu2GLz9T4aPJAQv4vAo7KZmQYoGdyCxMf/adxmOs7w+sWxKA1yDPtPQ9/VcblqwImSRT9ypEiAJEeLsXa+NTnGNHr94qRtwxDn/23gs2fxPOOdElCvzmQyeqyi3weUUwZSuiE1GFNEfmTNXb7ySCR3b7CmVf2nHT6cX46iOdAO26q0gza721iMS2QuSKUx1W7R4ooPrG7b85R8G5eBnWkrZdBNphRYwJCuc94gjgzTfZpxnSvvuKS3BIt28x7RsHVtYZg6Mlp2R/+y1gvChWUIBl6gA4NNhF9txtxmJwcCF+eU/BGtMZtqzZrfUFUO8NiK0mvI+S40QmtgwSbSWGS2HjI2shjCxofT/uVapih33dmJxzEbKWLAKvzJRffxPlbN8VDgQRhBVW0x5eLmntwDEYixn4c2YY/OejyTMb9qdr+H50WXxattxczSU7i1YRuP3kTe/afnugtBQoLQVKS4HSUqC0FCgtBUpLgdJSoLQUKC0FSkuB0lKgtBQoLQVKS4HSUqC0FCgtBUpLgdJSoLQUKC0FSkuB0lKgtBQoLQVKS4HSUqC0FIiZSJsbzWT35KP2xWN3XIzK6jpcc/tT4C1yRYXaRObmK07FK49eFzX3TzoPVTR55D28zz1wFR657SJcfs4xGD64r7nYhP7V5ZW4+P8exY2XnYIxmw0ScsnqYoEtNh9CpLiavdJIBLoEAtpTr0s0tfM2cuXjZbjsbCdG9crBC3fnC8IT8AEp7X3UCa/fGxIa3qC9+alX6LTAv9kA0fFPb1+GkT1z8NzjNjQ2AL+XOZCyhte0PFt7yumiPLO167ZOzLZuCXvAjRsOWIF3X7fioTvtOHLfLNTXaQ9JL5G4QBsEO8KEN+QUhNemavmMegq2HSe8/NBjvnrupX689YUbBxwSRAPV0eKhLSSTWKzioWQ/7MjJi8D4cxJhrOk5UBx/de/lITz/hA1ff2rFpCsd+H2aBTN+sQvNeFsThSBNPrhMn0F4jTfeOZJM9lDtgTAU/1IIOPZ/AYzfRSOgUz91wd2o9Z0xEwJmy2Ag5jjyhxUL2TGXvo+39/KZOHzvLOy7Qza+fs+JG4kovvl2c79jciUNWkJ+MG42wsoQ7J3jwNjdmjBoOxU9ixoxeJRfJK0r1/rh92muiEzBiuhbDSxOawvpfXbaHJHRo3HquodwQu2TmP27Db9/pxGg6MNf/zy0yJggYAlo7XSQFssQ6Tl2lPDmrVkmjr7zt1NlGaGJgSiILWvLfnBU4/idcXDNG9j/78mYN/lD8P79VPfUc36UlwtHWLW1eDb7PLiymsfUvvVWImk0/sZr7wXEVhmOcNMKxZuP52L6NBtsFlXcz00+bYLG6TC3myP0IlW6vSwxn0lOLqRJdU5BGC+E/odAt+4cBdsXX8C7dLnwp2vx3ucgrLA7WuYMjRuDLTETc/9Wwfvcpy2rFi97tpRKLcQff5fqiys8umde3PiuGtmtKB9P3XM5vv7+Dzz87LtiG8P240bijkdew5p11QjQdzvvxeWXx1iby/1k8sqa4ak/z8SfsxZyVFLDWxcuufEx7LDVSOy3+3aob3QLk5udhUR1cYE7bTsGH389DX/NXogVq9fh3c+mcrQ0EoFOi4AkvB0cGl5Cn+D4AhNvr8LYXTRND2v4mCSEUylb1yR5m0LIghshR7OGt4SW6Httre2L2r77XGy7pweHnlkPZ3ZEnM8aCOlPszbqiQQ0MsZialZz+RxmM6jQhe7HDWEv1L9m4/pLnJj8oB3/zFRx6dkaAfe6lTY1o/z2GZ+Nm5UThhLDkXrstL0o/w5cg6G9KpEzvAarvY2I5GmYLVucWl9EIfo+Tx8ccMRokmyj+gmRorplwjWsLFqVnzfbipp1apua8aBbw2v6rQ+SZn020KePUUzUbRg8HCds9yvmljfixrt8eO5tDw44wo9ZRKoNIb4HDH/U1cdbhE3kLqRYRVQLizVPFLFX/jQs+VfF8qUK7rxOG4+K6jClpH+poSAipAnj0yaM3MNLcoQ36HQiN0j9uXMpXv1zpYhjy++PGUyOTGZ00hWr4WUNnLLnnijwrMNN6iSciyfgXqpvaaC6RZEmTEQ4iWWhWWWTJRcOVY1K2bt3g8eRi4ODH2Dev2F8Mqccn86qgJ80ilGhFDzmzwz05WJzNus+e8EW8uJhXIjd/+90DNlhLJquu8Esktxvvg+ys+GjCaXDZRrTsWNF/mMc7+L7r+z4YUk1FvKLkX958dYTOZjybjb65bnEKlITfb7nVTSKdLCG18CSSgjrKy3daLl/QEEMC6V0XlUYNTqC+hoVd0z4ArX7HojiP3+B95HHKDX9i08BCURsRHhbfp4LdtwGvbEalX/XY+qiKlQ1BcAvyKZfA+D3A06VrDiZx/bOixPbtaNGDhuAB28+H0+/+gk+/moa7rj2LORku7DX0Zdi7F6ni9MV6uobxX7eS88+Gtff9Sy2O+Ac3Df5TbGHV1G0z6+iaC6jYfJi9tzFYNL87U/TMX7CxKhZvbYyYV1cBu8XznI5cNIFt2G/469ETW0DR0uz6SLQ6Xve/KTo9E3tnA0M7b8r9rd9gz0m+HHo/9zRRvppOZuXG6MRiTy6xs9Py+j5qEPIldVCcpuR/RDu2Qun7D4XTzwdxJuP56CkVxA1FRYEUtybxUthRqGqUyNMRpjdoiw7tr9mM/Zie+d0HH1hLe76YDWGjArAvKWhLc1oqMkLL5zgLQ0WteWtZadg9fDRGIzFOLD3NLBGt9odQK8RGmaz/rSL+lOyTISXX8Yx59n6lGEiONC5GgedXo8z/q8Gz/24BsO39OGvX6z4+OWcNnELefyijGAOEUHSSIpAjOUfNAg9f/sR1vI10ZQBAyNoqKWO6jF8DySdk5jIXQikgtPzRZ3CQrgHD8UpAz7Go09Px2mXNaJ7z4hIrqzWXBFIw7KEAuDzcbOI9BrZSnLssNN4rRu7LVREsP/jV2CbW67CkN51QiQYEE7KlqfOK2QtpD0UHrN18MHwd++B7uG1eBwTcfH8K7RUl35fmjDREhLbFtJWB1U7cmI0yTMOPAelKMNJR4xG7xfexPlHF4JJIdL4q60ONktntfxMcoLr3HPwzROv4yfbbvBH7MhZvgSOH39Ayn8mwhshQu3zqDDNdYHevRHp1g2X+u5GpGwOViyw45/yBvz0uzYZ+/FLJ15+3EWjFYEvEAb/eMsS/tVCnmzYbNFmhGlEOTC0JAvDu+eyt5WZeI6KfY5rwI0vjMM7+WeK7yD/osWt5FKJiNDNEmANrz3SQjxru61FOG/OHNgtChxWhch6RHwPiIQ0LD9NwFyKFxHTdoY0snd60VuuPA23XtVyJW7vXbfBP2UvgF8S61FSiCfuvAR/fvkUvn37Acyc8iwuPP0I0a/TjzsAv302Gd+8dT8+evF2fPn6PTjlmP1E2klH7gPe7sCBzYcPFOXx3t9tthwh/Fy+2fTtVYJkdbH2mc8J/ubN+0RbWBPN+bl8aSQCnREBtTM2qiu1aeAJE2BtbMARs77FhGUfYBdoDz3+Um5jB4DWTdbIkM/v1khWKA4hDQ0dhp6rl2LrQbmw01J0cfcwapnwplQBFW56uFpMb85TSvTarl8RagYOx2GjfsMFF4ex4xZO5BRqD9f98AV+K3NBmTYtKh/P42twwwunILzxbqxpr30ssh05/Cds3iMPh4zuhb6Dg8jOC2PBLFvbGmSRmyy/hpUfdlK+KRTRfI3Zazyasotxw9Yv45iJ9Sg91A3VEcSE0Hu4BA9g0RyqR59kNOdq6Qt7tX6rlmbi0FICaJh4gYgKfv4ZfDpJ69VLREUtL2nt+CxjEaHLCH8cK8RrznHiPVtvi0GzvsfOv76IXY+twS1vr0JhSRj1GheNkyN5lDXsF4Q3VmpwkQtZ47cD6utR8vlHGP7Bazjl2L/Ro38QgTS3NASagqJ4q8sq3KjFnj32gO/GSfDn5nMIe/i+FC4MrWQbOGnCEPeKJeBHwNJ6otQw6VossI5EjrsCAx+4G2vnB3DV5fHuSKO01q6nXuuDSCENrHBjrBFHHYRztv4C24Z+wUfqoQjO+DdGIklQ/9wLCRp7xti8pYHjlenT2cE29um4+MhinLZHd9x3WSGKe4aQVxgW244evroIvlAYbn8YIZbmcnkLhlmFR/G2OPMpihbX8G7ZOPGyWuxxeBPOfOsQzM4fD/+cFeBJqRBIwzI0vLbYYdlyS1FK39V/490n8/DVy/mgr0202I4hJNq2/D7AofoB0xm8befa+CScDrsgpFaaMJl7l53lRK/uReaoDvsT1aUoCnr1KAand7gSWYBEYD0joK7n8jf+4vfZByBNHE48EVvfcga+gDabZu1eG7xKw0Z/wIfrmkQ44nIK12yFhgwFZs8GZs0S0cU9iPBWWpCyhjfYrG2xGpo0UVKz1YO0fI6tx2LQ6rnYpl+BIKR9h9BDhUTs0NywTjQpKu7lrvTBCyeyciIgJU4rme7dC1G92RgMXfUntuuXjwLSzA0ozEJOQRjuBqXNrQbRAn30xKOADw4QVyBfy0vZd6bIBGgAABAASURBVHeMWTgFW/YqwEEjeyDfZcMJNU/jGvUu9J75E5y33doyQ0wobOyJtFliUpqDefvtDXf3nih56Vms+Op7/LOuEVkFwagAz1v4HnD79Th9nMGEJCrV7Akr8esKH3gQAjl56LlkAYYWZ6OoZgV6uSrRUN+cNx2fM+QWWxpi8wwvzsE2Y4e1iN65ZBYOG/cXAqRRa5HQRiCg/wCHSisH8URzJ56DqS+8j893vrg52dCihgRta45P4OMXKK0hH4IWRyuJwb1s+OW5Z/AKTkTPyBr0dFbjj7/CreSSRbjrA83JCQivg4jlwJF+zMNmWNNzFAo85TxfaM6XzGfqZ4TK4X3fWa6Wkzf07YtAYTGOGvUzLix4AY9VnChKPPvWSkF6OeB1K3D7Q/AT6RUvYwbpfqPyoJMgimYx8EtrwpPAKqax+t+1Ndj/kCB+LR8K59JlWK1r6hNkiRsdofoDESscjpjk/Hz4eg/CfbgMRQ89hiPv3B//HPgeXnwxps8x2eIFA37AoZC1iRPeeNjIuK6DgGzphkdA3fBVbmQ18rL3pEnRTmXBjTzUw09asXReWgvWNYoywnEIb2CnXcD7Y/Hcc0KmhDS8lWuY8DYTWZGQyAo2kwiroUmLIyuWHdesgfOmG5H36QcYPk4jlk54hXRYJ5oiEM/y+kjSSfm8sMR5QYZJblHpTug5VyPuXAT3wGaPCLxSJfDQ2+GDA9Y4zNq2775wrVuD0VVLkUekelzPXPQKrESutQm7+L5F9u23cNUJjSWskR0lAdHhjEVEEFbvWIriubPRZ/rPaPQFUA1tDDm9G42Rz6sgkKIWPhHhLfnfcWjccx8UL56Pncrn48iDd8R5ngdQU6fAE2geV64zZWPaztAiD9/L774LPPCAiC69ZiLGVv4o9peKiBStYJOGnzXelga9jF0O3g3l2+6oh8gxGFJKs0TQcjhgDQUQstooc8urd4EL2WMHofIgmoxS0tjN16K6WiFf6penKdwszLg0h6I+J622nHhhA175cyUGj3eJ+Bm/J5iJ1NYCpA3Dww9D/BExFC5ZvKWBHGRl8aeBfc3GO2YLbNY4E3fYrsVxeB1XD3kBw7f0w5kdFkI8qapbuAjFv/2kTYADAaHBN85qNuBspXEVuZutQUVZCJPwsdevgWdgP3QLlGP+Ampzs0hKPoX6FYQVdmfrvoSvvUqUcQ+uwG6Yigvq7sILz1hEXDoWz7sdig+IfTMunUKkrERAIrDJIaBucj1eHx2+8ELglVfgO/xIUXoxqoRWjJ4fIpzUMjQ9dQ1CLJKlPThFQLd8Rx8HlJYCDz0E7LknevbSHibr1oV1ieSOuR3GIf1xc4wdq0XfeiusT07GwBF+EbZHNbykPRIx8S0+dszZzYbCbmGoaoJbi1/EqqgAli4VhThtKjTCCwTNDUWSP37iUbIPDiLWEfK1vEL77qdF8CkHt92GggX/IH/JQjj9jfQoTt4HzmghIsWuqiToAyeSWXbsKWQDI3//HifeczluO6MnNsM8EVfcjUk8NBIiYuJYRA6M2IhqMby62+wUbr8VrEsWA488IiL7YTkaiVf5k24QFqJxrUgyzdjhhwNHHx3NxxM4DrS1f5tlDBNo9AuvPac1GRUJZDFZdAwuIJ92eexOzWPCRIuIbzM5s7GG1+poJZBFRPSIMb1w2nm9RNouwakI1BBBEqHULG+j6T5JQHi5pAKXTUxq6nWZqhVVHN3aGBp+IqQi0fjcUyAM7T6L2b5PKYD9wANRsHQhsirWiPAdi05Fv++/xhDrEhEOeFX0+fg97Hr6kVB9HvoQBRGxWLFguTYGQogsW6LPI6XxNbJHLnLtFthtVvQ9uAf474/XV9NEzoQDR7ZhwjTxC8CGeLdYcNfdRO5wTi5WXnIV+kZWoKBG64dISNEK0IqD0PDSkn6KWaSYREAiIBHQv2klEB1HgH+t51SNABWiBn4vhMakzYJ1khdp0LSDShzCK8rYTXtY4Lff0Lu39oBcrR8bJdKTWLzMaCQ7slsTaiMNY8dGvbx9Yvg6bQ+hAz4RHwq0fIiKSJNlD3nhUzXiYtGaaErVvdttp3luvx3YaSeMH1CEoxtfQiBA2tBUCZyu4fXDDtWqFdfC7tULwRNOApqagOuvR/4Rh0aTT8Qrmt9LA6T5WtmqTnjjaY/NwiP22wX+3n3gnPYjLG+9JZJKUQb+yy0MwetRBRnicNSYiE40jjwhJV5HKIGvMWPYBl5/XbjF4Uo0NagIGiRKxKZg8XlwJKaQ1pucxFfv3li+VDs2q1/NPAzEUjS5I0j1L6T/mpY9x5E0S86oHqTn2w3/9NwF5Y7cpLKxidwaB92XIas9NikaztN/ivWSWZeiT90C/Li0GtX6XvmoUAKPt1HTnlcP2By8tSCBGJxWC1h3HMrX2u9Zp01cW8kbYxXQtN8w3QchIqgsH29BwXHlZTQhtMHboxd+/2cZi2GPy07HrUMexvZ7+OgWV6DoZSmhMCL+ALwhm/jBEBYO61/xtsRzDxYT5ogteuPYLXuhYMd+Irzo3XL8PCP5Z14Imiw+3SIIK1q8gKenhwcPET71wAPQd+IZwj+m7mfhpmP5ifA6FS8UY1UgncxStmsiIFstEcgAAoloSQaK3vSKcJR0E50WhNenICJCbVi6RktpJHLGojlZbLc2V18NPP000NiI7Vd9IdLL1yjCbcuKhE0SyR4S3bsDfMg+i5MWdvM3nsWkE7/FsEGkOaK4tvbwusJNCFg0wmtNpB3dnAgEa8O4LwsWIOJyYbybNHD0EBN7EKmeNi+d8PpIw2u3xsfAx0dETZgA9O8PrFkDT0lPUWxfrBRuor20nGiNEGlQXbAoyUewb34W7C+9CBBB5HxsmPA6aWm622APAj5gbT1ZnGAYfYJjBA2XV7sNfyvXILy7747QsGEoCNcKwkv8ppVo0gi/X0t2JiaJmgDgKMpH0OlC6ZxXcQaeEUdBGWltuUGdVNqzk7MstUdPHDfgG+wcLMP00CitWP3zoAUS2zW02m6nlYdwsrX6oUNRu/9BopB8fxUqSfNcb+zPFrGJLX+TRnj/PO9WgFclEoiO6ZWLnQYWoVf/QiHhq6gRbkIrDuENwyLEs3Pi38u49144b56EbTfvDxQVCVmHrxGO3CAaiV83E94g+JSEsKqVx4JhaF/xDleEgykZ/4BBQi5/zTJM+zX1fCITEe4AaXidjvj5ArwN5403ABqbekc3bOVOn/AG6TbmsY+rRhaNkJZEQCIgEWiNgPZt2DpexrQHAV1Fk4NG0vAqqWl4dc2P0kBPLqpTyXaQneDaay+RsOtNR4CJ21pNCSfiklpmEpGM8HIh77wD8YLc1luj/+cf4KrPj8Wu+TM5hbRHQeEms7wWl0i2qElurfffFzI45RS4d98T2zeUCbxS3sOrEzcfEV7VIkiCVp7Jjgykh/bHHwOffw7ceCNWnHWeKZW8ZkwoaL7UUABBxQZrQjW1SXrPPYGbbgJPRpoOPwrbKn+g54AAnNkRIVRZpxEn6Fo4ERnHCifDa8AAgInyt98iMm5r5AerxEt+KeNl1KfjZmlLw0vyNup7SFfTZaMJbm+YYlO7Ql7tPnHmJCfWOQ4L8ktCqK1U8ddMfRy5nylU426K0Oj7ELY7EktnZaHgoftEejGq0FAHeAKp9cPbGBT5HFnN5FFExFi8l3tot2z0HkiTRUoLVFAl5La69M85LWVoSab7L6RPDnOydAw0iWabPic46ywt3EPbbmBzN+HWv/+Hc9beRescep/oHmMNb9jSPNEI0MSbM1qT3V8sYDKRggL4cvLBmv1Va7T7GCn+GRpeuyNBX0zlLOi5Hbb1/yxeuDNFt+n10+TYTpMdSXjbhEoKSAQkAiYEVJNfejuKAD1guYgsuMEvLKX0vpL+IFRZVUOZ1dwEGl5Kw8CBwI8/sg9jMQOVa1McPnND2iK8oD8+e3bECPIAzqoKjJ/xjPB76vzCjWvV14tov+oUbhYfvCt8caxRpM075hjg0EPhP+BA9PStxD7LXsUvP8eRjRela3j9sMPaFgSsUZ40CaESjShEizMRjmgceYKElSUcAm8xsCRVu5KwcZ1By7NkLD17oJu1GmPGe+HQNVyNRMyEmEHk9PEWcWZ/inVZiwuRG6wTEwRuqygnRSvk08ZPdVnbzMFEzpKTLeR2xo9wPfeE8KdiRTxaPfa8ZuIVL18eEd68Qm1CsPhfuyZCpE3zkP3KKwDjsnQpYv+aPBGd8Or5YgWMcDdt1aUbKmn5X0Wqqwhe/cdHXLnJ+2BUk9u3UPPW1mpurG2MNd93kycD11wTlQgZGt6scDQuoae4WCRZPW5sWf49+HvA6tPGs883n0P5+2+EVCuC0OL4ewjiLyzsVCxeNGns1x8DsRQ11UCjXxsjpPJHGuwAbHDY2ybKy/puC25/QH9/ASn+BQOgsad7LJXvshTL3LjEZG8kAhKBeAi0RRfi5ZFxiRDQCW/pnpVCIqUfntAf8Fa3todXzUlCeLnUfv3YRt+sCvCPTzQZx16J2PhW0CyT6kNCr8dcok9/+94cF/V7vcLrtzjABzQ4kzHRXr0AXtbcaSdYDzlU5FOaPHj5udTIBXTC66PHXuwPT4jC4lhK7OkXTDziyDEh4rNqA4odKWl4TWXYSrohL1CDEy5oRHa2puFiwsFlRsUM4sMRJn+YSApHtWkKCpDn0e6vdRVtkwpzeY36i1tqVmo4W3XCuw3+QP5LRNLMhSXxh3XC68hNon2l/PnUjiFj/MjKjWDhEo1cw4QJEowRZQVvR05Jy8dHBlIGJrzeJgV8nBkF27x8uoY3K9fSpiwL5PQpYAeReu1zLALxLCKE0D/zRrJBeHP1e8aIj+vydiBKyPa64Qo0wQkvGms1Mtvnm0+gzptLhLd5fI15lpqGhpePJQzmF6KXdR3qqlVUNfmoxhSvQBBBIttObaEnaabyIVuL9Kpv/hJuKhZ/lgKk4bVF/JAa3lQQkzISAYmAgYAkvAYSmXCztYe2K+IWpelKT+FPaOkPeNWr7eG15moa0oTyusaqr2stEV4VlclIqF6I+ZfWiIlBj07uDBzYKj3QSKqVVrF6hE54eQ8vL4frsW06ucX5QqZXYQPqaoS3bctPDzuS8hHhTbUuJTuHcpiuBGSK3/63RIJEGiywsnbRlKUtr4UIL8tkNdYiS9fW+WgeYBwRxWmJTMpVFRSIIngVobY2IvypWg01fiFqcTUTIhGRyNp5Z/gdGm6RNDYMh/V9sjl5yQlvMRHefY9rwMCRPng8itYK/fOgBRLbrDl3wIdICm/qu3O7gQlvUwMR3hT74ddfvFNslsSNMKVkkeadg5b6OnZaG4Pk8n1nsFBdKqhYhS83V8dAhBJYOuHttnIJbH43nPCiqTYohC36Z9A8eeKq7LTakELJogy2irPsUGxWOCwBNNSqqNO3qHBam8YgvI42JREpKRZCjWt0rfgLLwAvvSQGbklJAAAQAElEQVTiElk8YQkGFNgjRMJTnbwnKkzGSwQkApsUAuom1dv13dncXFGDM6wRXneTCCa39AehtalRyFny2lCNsBY5Px85WQFUr7OACZrImMxK8SHfooiBA1sEOeDTX+RhfyujP2z9FifsljRuK5dLFJXncMPjTfGxrGt4/bBDtaRG+kYMKBH1RC0mHtFAsydMxVnCQQQVGywpNieae/hwhOgeGFm1Ai6XhoHHrcCfAv68DB0tJ5mnoECkFqAW1alOEKD9NdVqExZbtlWLaMt+5hms6z1KSEUYGOFLwfL4hJCzm/Z5EIE4VoGTiBUxfVY+RocjHuGNE8caXia8qbyp788rAu/hdZOGN6Wj7wYPxjlfnSpabEnleAOW1O9jR1N965M5OJ2ZJ7s8WYt2liOAIDRSnZfopTVNTLP1STVWrBBhJryNtWHhV7ls8oXU5glNMGwBLx6oFJ/OpVissFlCaKhRkc7WGYX6FoANTkfbNToLHKJJDVUe4eKFF4AXX9T8CWxNwws4Mkd4E9QkoyUCEoGNDYG2v5U2th5vgP5kRTSmq/Oy5DXqD3Obp17I2Qs0AigCiayBA7F14DfUVVnSIrwhZxvaY3N9ffuaQ8If1JeqRSDW0glvwOqAM0WtmFEEtytHbUr9JAAdWB9peO02xSgmucsTBbOEPtEwR7GfNUjWSIA0vDZY0yHunHnvvWEhAjf0s/egK+LgIxLvC2qEhEVaLNMbJIgSFJWsVK6CAiHFhDelFQQhrVnuWp/w2HKaCZGISGKFHPr9GIvX118DpaXA6tWtckf0LTQGBq0ETBEOiwLiVs2r/PrnAfxn4GOO43gyfEyaHX4oRJopmPQKFBYLDe/C2XbU1qRwvwQCyPFrswmVf7UsaenNiVVqCZzuOvjN492crPmIEIoXELWQsIOwCDc/N4WbIAbUHJsHWRXaySMWHy0nUEkhVSuPvPT9oMBijUChf6TzRxpeuyWIxvoU2mQul/oXhBVOZxht/eV2swsRT41OeClv840gklpZTHhZwyu3NLSCRkZIBCQCbSCQ5rdZG6VtjMlp9ilE2ldnSNPwerTnT/IS9Ie5zatpeJ09C5PLc+rAgejrX4bKNUx4OaINo59LFjYO929DXCRTHcI1WWGvpiE0RTV7dcLLe3hdtuYHbrNAYl/Q6UI2TRL053ViQSNF12TVIw9Ol2LEJndjCS8/XOPk4O0f1nAArOG1qimWbS6HX5Ij7VuWfgxUyK/CFwwh7oPcRCLDaoqYFRSI2vJRh9ra9Nrnd+tL344UNbxUU8iRRTZd+n1KPu1aswaYOhWordXCZtun3Se52W1/vfDkiPdhhwkiUYQJk7iYCSGgvjFM0x0fVJdDj0nshIuLwFsa3n4iF3/+kgLO+v3FJVpS1fCScL21AC5fPZZUa59/imq+jH4RmY7tVzCitSklDe9mmwEFBdFyCy11GL9SO/XEok8EA7BG09mj0jCoad7LChF9mxpAXbUay8+5yIRGDQYQIA2vw9n2veks1MbOU+ttLs+Y5DTHtPCxttnnUWAL+wG5paEFNjIgEZAIJEeAvgqTC8jU9BCIuLLg0gmvl7R7bebWH4ROX4MQtbT9nACIjPZoWibkq6siwk1qhTRtSziNhzerKOtvuAkzz7wEQbum5UuF8AasTmTZ0rutgtm5yIvUIUDPsKT9MBL1BzsHldROOwb0JWfOI0wCwmtoeIO0DmxV0+uHKJdfkqqtRZ5O9p6/Jw9PPEAP9jYe5EqqhKSgQFSTiwbimimMvZDWrJBOROFIQ8PrzNIyxxJeI2wih5ogoNBAupEFK2m70cbf8JJsMNc3ikuVXbmJ9Djgg5qlaQmTVtOtEEx4WaYuRQ0vy7Kx2K3spGSarHlw+hpRqZ9D3CKTMf5MeKOd1SQMwtuzJIX77fzzATZaVhSGq3UfoAZ8wu8JWxBEc7tZw5sqrqIAslRBeEOorVJh3jZFSUkvhb7PuO7sFCaiBSVOUZavwfTBp/wiMoFltEUQ3ng/55Ygn4yWCEgEJAIpfMNKkNJCgIiVM9Qksng9KRAS/QueCW8TsmFPZRm9f3+hSeJl7R++a36wiUrjWPwQ4uikPynLAjEmcu21mHHWJfC7skWKvaFWuHEt3lRJCSGLDblpaBApC/zF3VASKIdPPzOU45IarzeabEmBVAnh4mKsOXOi8AqLiYfwtLSYl/ByaZgJr0VpmZhKiH8YoLoaefry9PKFVsybbWnOqY+3iAiHhcNWJFVynZfH4ihCNerr0mtfWF9ysKZBeCOGFs3cbm6BgZ9pLDhaGK8fAdLy2a1tf72M7J4L4lYIacpntNjyYeBjuKJwzXLTZ4sJr83VNnm39ihCP2h7XlPa0uDzaZWQraY6LiTrtecg11+DYCjO597oA08QYrAMRTScUsGLqgFMqxX8gxoijiyLx0M2UF1tA9FU4WeLu6CmOqHiDGQUq4VGUNPUN9RTRIoXa3hDsCDLGQeDmDIKu9NEkOKC9bpGnD98MdhQcovLrXWRNLw0RulM4FuUIgMSAYnApoiA9k2bsZ7Lgix5uXCGtG/lqrpQ24DoX/D2oAduJQspcaxBg0S5/BC/43rtoSEiElj6jgaEDfKSQC42Ol//gYKQ/mBxNlQj3rNc5NNJgs/mQo7dRPBEYnLL170niv1MeJPLRVOpLq8tRwSVVO/gnBysvuAykUdYOu7Cb7JYgyReWlNtSHV7sCk7wIS3thY52c2xPtb088OcowyX/WaynmpHdMKbjaa0CW9QPz1Bcdi59pRMSNfwtjpiz+gHE7iYkiL8pr5ii4lNHGQNbyikaAJGuYzNdde1jNNCwna7FdIhu2HJdopwUqub9sJiFtxIifC63dHi1DSw8jgLkBVsIMLbPJGJFmT0i1cWDPKrJwYiNqTzS2jQ7wE9e9RR9ElIo9dO6x46npRqSe/jSDkAi53uf9ITc6C6SmEnJaOGAvDDDqdLbVM+r0+ukAm5NWItAjHYiDiT5fFqRNoWIq1wOu8kmMqQXomARGDTRKDtb6VNE5d291pxueAk8soFeGjZld2kRn8Q2oNeeBUXLGoKQ6IT3gFYhmAwhYeR/hAJO5xJmxIvUSXiEbFq5MXVUEMro9oDp5WsV9O6Bq1O5LvsrZKTRfi790A3Xzn8vmRSpjR6sAcsDhFhTZUoknSooAjvO44iH13BIFmtLz6MQI2EIDS8KWgoW5XAb9E3NiLf9Ma9j6EhHFvJ6uPC8RFLiqxEf8jnOr2or08wFlxgHBPWtzSoDm0844i0ioq4srQ4U1tFhBGmyYcI6xa/VKT6ffCpqd9rDDMXF2HsQqZJIo2zKFb/jAi/bnlIw8teS7JfJmQBNvpRfsWoQl1tCp8vzqMb3suqe9t0vK585AVrEeCbiKXNxugD33eGX0+f1nM/OLPSGMvcXJEzVFAgXMOyN2qqWF/YFiW8QVihWiOpfa8YBZGr2uw0+dbGorY6he+YsjLg5puhkqo+ABtij72mIltdxlndYeOcX/6M8I3QSrI5wiC8ljCRZLmloRkY6ZMISATaRCC9b/82i5MCfM6tQye8Pl0bkRQV/QveShqLkGKFzZLCkAwcKIociKUwOAGS/Cn6G0E5O+2QRCp+0pBu2YjYrCIxy12NeM9ykejxCCdgc8DQDCPFv2CPnsjzV8PHmtBU8hDJCpIGlkVTgYvl2ChQ8GLOOexFk9sn3FiLCZs94odftcPBTCxWoK0wLzc3NaFXdw0zFtfnAuwF9PEWATPxURUR1aala+m3Vf9EQ0MK94qpwJDekJS0onq+cJamqlb0feB6dPPWAxqLaBx5Kpr8UInU8Ut/FEzpYg1vmCduTHjMmCTJ3VTpE6m2bLtwk1mqft4r7+NtSPNFPyWNyYEvOx9Z4Ubwi1UJ28MfWMLHnB70K7CnsAUgmodWK9gfztaIL/vNxk+E1xxWVdCdj7T+LFYLLNAIb0VFClmnTBE/4a3Sd02QSDZ/DNrKxdu3mpRsKHRfipNM+LPRxviTqCjWRgoC6J8FESEtiYBEoFMj0Bkap3aGRmxUbSAtVT4t6nGfvKnsSdU1WvwSBhNeSyrEp6AAwZxcDHMsgad59ZWrjGsixj6ERx+Nm54scscBhTD2/tp9TeAl/3jyQX1zXcjmjJecNC7So4dIL3GvBBNOEUhmEckKqA5BEixKippRKo8f/NBJ7IwV1Zi6SPvFMkoSF79dv6reKw61D1ocsDABEylpWKThZ2kXTWDYZSOIvEFy+KHOkTFGEY2LiYwXpPuLo493Pw/XWu04Kg6nYsL6loZ09vAiy6UVbeyL0ULNxD1mS8P8JUH46oII0oTBEG3LVS0RMCwRZr7656GtPOuWBoSIQppI4UliWfLzRWoOGlFf28bEwrSdgTNZLFZ2UjJMQEuQgB0a/WLCy501lRgksu90paHhNQhvgq0NnoDNVDpgsUagqkqLuLYCFiL6/AMsLFeVypYGnaiqYRp7WJHKiRMuuxUBxQF4A/DyUW6MSzDIVSY0hoZXCEgNr4BBWhIBiUBqCEjCmxpOqUsR4XEGNG2noY1Imll/ELpCjQgrFtiUpNLRRE+ffhjbbVE0nMzDS/QivT0EjjLWbLkV1qAXwpWN0BW5FNvyCusJaR19phcR4Z8aJn8vqqW+MYUHP5EsJlQq3b0KwpQztUtRFCg2ykTiISrDZ0wEKMzXv5VNWBMlvDake7wal2G8UJQdCsBYpvabJz46MRCyJn/EorVLxKdo2etqU5TUxCLUZ/bZUjnZgAXJqHYb2YDCZASmP/2+RcxN/uZLNoSbAkR4UyeK/NJaOExl0/gI5ktecRnkJ7ZuSvRW+8kGlBSOJbPqhHfcllVEeNvAOaY/ahrjEs7VXij017jhj7m3YIw198nADtof3SpwpKPh1bc0RBIQXl/QSrpZi1Y42RbyqoiQL/XLTuNuIfLKOdqcJLCQ3j9+FyFIhNemUqUcn8S4rCoCNDFSaQLrDWja5ChOCfJ5fBFko0lLlYRXw0HaEgGJQEoItPHtn1IZUsiMAGngVI/2hez3KuYUoKwMWBmjlTM9zEP0kLDRQ6BlpvghJrx9/NrRZPElTLHGcrQzfe0rl/Lnjffi09wjwBoynz/+gzOka3i9du2hz/lSNZGePYUoE96a2rDwJ7XoARmw2KHQ3asy600q3JyoMjm26Q9iIh76M7pZgBZ+uXf8s6Ws4TUlpO6lCQ8LO30ebFWqqd+92vyHo1saboA+JilreKmEiF5HoCkUf78oycS7IoQbx9tS+LEGlmOjGi8g8n36229AaSkwZw5gkLYYghgIRmBDACGLRpS5jLYM3fYIhxQI0m+Uy5matM9RCxLM8WQUv7alQdHxo6iEl03XUhfYG9FQp0AsnyeSpvvCnGSxp/GZKdDu/fDaelqpiLmPeay5YJ50MJbs100gqMKRjoZ3zBjgu+/g3W13vYSWTpAI54itNHw4hTXo7KZlrFao4RB46Ads5QAAEABJREFUq0VdDX3Q2sps9I/kIrwdIsXPZYBWUtSAHz7jO8o8/lRW7OWnyaMDet/kloZYeGR4Y0FA9mO9IJDCN9l6qXfjLZTIiOpuFP3T+YXwo6EB2J0eUK+/roUN2/TwCytWpHo0kbdPf5Q0auQ5hnMYJUddxVRHNDJNT8FQB/ilH58/QUav9hBqz8PV2ru3KLQnylHbwJRTBBNb1GG/6gDXpaRxBytQwQ9j0J8SDDH9JV/zFeaHNlXPe3iDFntzQjo+Gn8hThrv7fbwoqBbCD56SEc1V+YHOo8LEQshnyJBYFlFf9Az4Y17BBYLxTMBbblYdaSufVX1/dsKb2ngzZz8YxP19YiSUCZwprr8NCFiQpIOfvzDEwxLhAeTMTGVl8irEEniNNXuYCepselEdHDoX4yr/h6BcBJx3nJgSrbYU8dKKSoQOUNVjWi1j9foF5dv+IU04A+oSHtLQ2kp0LePXkJLJ0iEd+BI7YMaoUmc0PCmcX+J0ui+5BfQcvLDqE/l7GJTn8I02Ulx3o6g1Q4L3UNCw8ufP1M5oh0xlpc0vDyhEtH66THCLy2JgERAItAGAmob6TI5XQT4bQ19H6DPa4LX+CKP0SBFNWVUT5hUXdYUH0zePv2Q56lEFtxtvrgmyAqV395LVQClIAv8l/BsYY8bHriQYvO5qKix9esr/Kzhra0T3uQWPSADih3cLmskuag5leWha3gVHoeYvGES5igHvEiHsFG25ovHn0N0D2y7hwfj93cjyNtN+WHO8YbLfjYKgUuuoiueydv25XAImUBTmMgbt1oE27YINxaypHB2LcuxUc0aXsaMI/leZobKfi8fQcEezfBKvh1+MOnRYtq2+Z4hZSLAWHDZiPmLE6foMy/VYY8RjhOkVReOPWj+0/gmsAeaZi/gYHzj0yZuRqKq75c1wslca1GellzZgKChsdRimicIAboZDOz0tFBAIcKrB9JwrC7tMxmbJQAbinuFRHQECviUBtM3EVL6I5asUDttjgjEHvS2MpnGKEx57Sky3hATXn3yIiaFVGeyqjx0uznp8ylk9Imf8EtLIiARkAi0gUDa34NtlCeT+eFK2j1eCvTRl3MUEIPoGKTBSDB9wQdVK4yjetDGn7+oWEh0x7o2CS9iH74iZxqWEkFAf7gGqmriZyTi41Wc7SK8LpuKxrwSMOFN6agtIiX1HqqLSKKFlk/jN6h1bISjDI1lKAih0eU4w9AYZa1choJILWmeHEZseq5BeOkesFpU8AtDniaN1LYqiOqDrqWKkFasVXqiCH0ZP+gO0dBGEkm1jvf7RJxVzy8CbViqzSIkxKTJuFfDRLINv06ihRBZBCvRrQBClhSIKMnzpVIVTfUq6ptsME8AOU0YJsLC02ypQa0vqqFRb05q7dP3vBY1rRZpDf+uE25ciwmpKUFN4xvS2V0nvNUNYOJvKqbZy59/xq85Bv6gSoQ3jXHU84a3Got1W2yjh5qdAI2Aza6VF2HCS32wp0hAo6XQfWmhLzC+f2MgiYok8oStNlCViZJbxIdsDqhEeGs8NBHgcY7BpoUwBXyk4bVD015DEl5CRF6AxEAikBoCqX4vpVaalILx0lK+vQl+Xso2MDG+yPmBZ8Sxa8STP6xayU7tiuiaLQd8bRJe3ouXWqnxpVR6aPpdOSIxXNsg3FhLIRLqRfs0vNm0bNxY2ANMeGvrIrFFtwrzy1eNficUNUIP1nCr9EQRVlLxKrrGUmzzICJvluWas1csRTaaiPDazUmp+w0CRhpeq6KAVoa1vMY4G0RRiwVIG8ZeldrGbkrm6KOFmBVB1KWyBURIkxXUtH5KnosCqV1Wh00ICryMPjBRN/w07kJAt0LE9OxESEJEevSoNh0mVSwUDisQWj6aPHE4asKtx9iiszAllReXYgh+05K10aJbeWIIfOqfSCC7Z5EobsF3PsydJ7zNljHu3O6Y/rCGNyub775m8VR89i22wOfPvoeKMVu3EA/CCqutuTzeMtJCIJWAfl8S76XvFxqXtvKY+hShmz5Vgh2m8XPAh5q6sDbZ4XsrSV28c8pO95cQobzClZZEQCIgEUgBATUFGSmSDgK6hi/f7o5PePmBZy7P9KAIp3EEEvQfkXDQwyK2SHPxfMxX9JQGc0IaflVRoxrekmfuAz78sFVuhUiKF0RCLa2S2oxgrba7qAS8h7c+Pp9uWQaREk/YgfH7umGhtrVMbB0yYpgCRAyNJU08TNALEU5XdGKSjoZSZDYsffxBhDfPRcRD17QZyS1crosZBUVGrGl8FI88knKAaE0Q1TVEFESobcvY92q3tS1rSFgcGuWzBdwAYSbiGTg2HKCxYMcwkYgCOxGScArHhRl5VFXzBSJ08zAmER4JLU7YsWGKVAM+sgFLllO46Vi+tUn2zcT0x57GuOT30Qjv2ukezJ0T06LVmnZZYMh9NCX7AhYY8yRTdJtep962cMwqRwA2WJwaqBGarLIGvc3CYgWItHIUE2exJYcDKZqwfk+nIh6hm9FB32HVxkQ3BpvYMpjwsryIlxpeAYO0JAISgdQQ0L4VU5OVUqkgoBOeAlsD/F6lOYfx0DZIg5FiEAcKR9J4MkXsDsoB8H62mGe0iDesCHmYxDEZJW+7LpU0oYFsTcPb663Hgbfeal2OTnhV0rq2Tmw7xlvSA6zhra9vWxakVfSG7OA32636Qz+FXBjVIxcGgXO1emUNQrnIWHFZdbnayRHsT8sYzMXjwV5DS5CfRSSOCghpylXgzz+BtSYNo0VLV1TTvULySS+djFgQQk11UskWiRFdw+t0pP6xt5D2PVqI0Qm+lw0/jUU0nTxchV0QXhuFUrusVq3voQi1iz8PRtlJsluD2rK2XT+BIYmoSArq9y8HApVJZlWxn0/OkKLJG9JLSOaigW9R4Y9axiSRP6zcx2gCzSMCSrsIr1HEX+dcYXiFG6SpEPFc4WfL0KCzP2VTrG2Z6hVehZQIL98TRuEWGkfD35ZLpJXvl7paXTAGGz026vi8EBMqEWG3C0daaSEghSUCmywCaXwzbbIYpdfx7Gwhn2v3oMWWBuMhHvtANX3Bh3XyIwpow4rQg4JF+GERWyTHGyZCDyLefxlWLEZU2q5KS/MB/Re3RGYit8I1WYrfB3fEhTS6YMoNBHqWoC9WwrKy7aPWIh4fmMDbXWF6rqd3C4dtGg7fvutodTIpYxXRx2N+nx1btC/lgD7+xoHFhqLTGH6cfz7wxRfNxRmAWa3NcW35dFkLE966toRN6XojzBzWlBrXa3HamuP1/GJmoOMUy+w42mEJYMAoDefmzIl9xpJ7MEJ5uIDEotEU1WBhKZKekP554QKUBhNoc+cCfNwaJ7BhQsoumYAz/kthlBT30rcKIx918Ad4qmkSM7DjD2tMHyNQkJXOTwubirWoCqpGjDLFAIrTCqtKWIImcVS27qVQGtfYsUJ4ZGgOEV5tQiIiEllG/yg9ks4NluVAMapQ8OtPEJ+ZGGyouBYXD4+dJlQi0jSmIiwtiYBEQCKQBIH02EKSgmSSjoCu4c2zNhLh1ePYIeLJDmL3H5gfFKpViKRk6cuGDvjAD4FkeXgPbwjaAzCZnEiLYyl0l4RzNCIvkkl7KVyzRXE+ONCuhyuVkzWwN9nAVj89I9xkVtjnp0eeXbzok4aCVxRpsavCXTE/At7uIQK6FSHX36CpYu2uduJlaHjdbioNsOpDGg5x6SIK0XuA7omwDpixrK9LJHd0kmxDADU1pnKT56J6g3AjC1kutS3JaLrVYcKByRqn8D3Lhv0xGl4+bYGPdYNN7zjLtGF2P9iDMeO9iBA5i/ALlkbZRj7CyfAari1Eqj4OpEh6IsbMg/JYzYT35puBk06iWP0yfZjSWXHh3Pw7EA3IhRNetCK8Rh/48x+H1BnzJC4nLUOTUbP2mvNas1SM7pnLXlrHUNs3CdXZe47SSLdrCoRX1KZbxk2vB5M5qsuGYViI4249VDvfOQ425vx8uzG+Ii7FsRey0pIISAQ2eQRSf/Jt8lClCID+5Mq1uBF3S0Psw9z0BZ/OHt6w/mXPhJcfAolaF6EEheoMKakTEMrS4lLFQ7VZ2xXx6GTDJKVQnAcuKArXaEpI0est6S4kHQ1Vwk1qUYf9sMPuiEBV03wY6xpeX2O4dRXUdK8e7yxMs1yjNH3CY/wCmT4vaXn4gEEciQQZpzNE0tm/rRdqQQi1tUbFbbtKKIgAbFCIWrYtrUk4s2yah226j9gRxvCbCCLHc9dsVAtS1Lxynu59QijuEUKQNLwRZsyEC8dHjVFXNAKwGBpe/XNgSorrDZvao3oam2W4LjZGDBNS3R+xWnRf6o4t30YIB4jwKvEzMUAx/YnQiGQ1f7zi50sQa6HPZmySLdcC1vxyPJetquxL0+gTN5fqR8CfXt5IGpMd1eVoWXgMNi0TAbc3IvAV8aYxFeH1YMkiJQISgY0HgfZ8FW48vV8fPdEfFPkWXTPCD6RrrkGU8TzxRMta+QFoxFgSPCSNdJMb0b/sWdthLsIkIrz8LFfDQYSV9g+1Sn2wlzhFeWxFdO0l+6PG54WfSKiufIxGp+pZt9/BmG0dC1djZdtZ6KEoHuTWCKxq6piJgvVTGrKcASxdYBVRhhUisHz6qQd5+UZsmq7BXJqaREZ+6Yc94UCIHc0YpIomOxHCliMtlgg7qRkdZHFKQ13q/VcIN9b0q2kwoBZ7eA1yS+VE7+eY7S0EIen5vehWYFoRaKNXPEey2iOIRBREzGUnyWcP65Mu/XOQRFQkmTW8xEZFnLBoDKJ9oYgQTdzI0a40cNIyABGrDfyZ5B/gMOKEy/1iD03WzPVxVIQIb262wt60TbxP9R7HemHR7ytClMqMkEnz0nHNUppA86S2Mxv9Y8k0tjRYs00TKs7L48FuAsPkm/EVyXobhV9aEgGJgESgDQTifV+2kUUmNyMQx6dreLMUD3we/SHGjDTRF7kpPi0tn0sjoPzlz8/QOC0RUfyoU0lrxkRHRLTDUunhmT3QpIKKITmiSCIKXnrU07NbBNO1iO6gxloMlzvBOb/mAgmzMFRQs6AjbE5N7tc1vGFvCMsXtiS8nNFbr2l+swvT1+5x/qjRJwUG4TXzARjEMRJBWNXbkA650peMmfDWpgBXtE10HwZhjWr/ovFJPIpOroWI0W7CH0aH+BcERaJmURWwRQJQ0iIjKiwEQ4jGFLylgcvXitNswknzNNtRDW+K9YTtzZrESCDYXBDXZSo/5GtWZ0Z0nJuF2/aFSftup6mfqRgtE9fDPo8HMPwc1o3+taGHUneMCV9YP7WFc4ZpzCxWC3tJl0+fEP6giFAaln6Umyvig998vGKiIkwYIg3cbDnN4yKKNu4rEWhtOSvKcRz0X6tMcexblyJjJAISgU0RAXVT7PR67bOu4XXZeCmQHjZcGX+Jmx8IHGcYU3w6S4ER/YUaJrxcvFFcrMsvYikII6QQo4hNTDG8585QsXEAABAASURBVNBu2GxIEaJ/cQivShpeN7KgP2ejoql6LKSBrrMXY4uqH4DPPkuejTALwUIkKQKHVU0uG5M6/qiIiOHtAPEe5L4mLT2nSCMMQjhdq7AQxpYG/bjklhzHGDAiIhEiJ1y8kg5wOqFw2gNo1BTJXESbJuIPiftAvyvblGcBmz6xYn+LTtAYiLgaYtzUD1x7rQhytNjSkOJWA87E9yf/olcwYo1LBsHls6DJ2CI6MdWJmSkprlc194OPkjBLmQhoxNgqQentIby88sL9D4a0+4iK0S4GRvO16mOYiH5WOzW8xhaitfseZJSOsM0Oi6X5c6Gms3pglKKvVDgtPoSCKd4xel7F/KKjHpfIsWQ7EiXFjS+qWoQj8K6WlsY9pmWQtkRAIrApI9D8rbgpo5DJvutaB5fqRcDQjPAStvmBZ66PVWJGWCc/RjCZG9brYcLLxSeSjVCChQhWWOkAgaMyAAUNah7EH2uphKfZihAJ9qH9L61xSfUOnVTHKZ/To4b7QyQhHaWokbekt7a1wIogWAMf++Kar5ERA/KLO/DR4EmPvqXBYtXIQthMgIwBo3siQriKtqXTmSjhDWJdVURkT8WqWB5GSLVC1ZqUShbAfE/SGItMhD/YcKBaPxdNJ43suCJuqOmQEeq71RYGwUGG+mOUzeWz4ULZ1U2AtMAO+LSQ/jnQAont7BxXc6L5M8dlc8V6aoQPejX8Os56MDWHZjh2+MG/CNYig6mOFhMHXSi7nac0qPpgVh5wiF4SOTRmVj0+DNW4wyghjUsnvLk2Dxrr1bYzmsZM1V8MbTsT6D5xthQzldMyQQvZmho0D9spjj2LSiMRkAhIBFL4JssYSJtGQfqD3qX64DPO4eUHbKIvcn7g6shErDbd17aj6C97OOjBn3RLAz1olQ5uaRCtoXI81hzhVXz6/kkR0izjpTWoES2iHfbSvJFarrYIL7UlQo/xOIo/LX8yW8/EhNfrVmjJ1ywcgeqNiIicgg5MEJjw6n2w6J8warIoV1h8P7CH7omw1c4+evKnUZ9OxLIdATTUKlr+NmzeYRHyhsATH50LtZFDTybypPsAo93cGWq7iK/SXzLUw4Y20OJ0iORULIXKs5ByNwQLxFnBFG6Rz/QZ4XjeRcHjx37oxEz4k1n651KIGP3gAJfNhv1kFJOGtwXZp7RUrghpV+1EeN0+7T6K5jH3ScfKSAsTKTXtSDCiU3Kt+v2smM4jDvP9ocdH6HPCV0qFxRHKsXrhaVSiu3DiiEAc67ZqVXNSOi+txd4nMdg0F6r5rJ4GzcO2eUw5LI1EQCIgEUiCgP44TiIhkwQCDY1u1NSZvmxFbBzLppFWPos04NfJCD9gzQ88czbTw3b+8D3MKcn92Zq2lR+uXHxiYYU4KBOdjg21hViSz6G/iKSTORh/v/8O1d0EL5ywdqCaaf31ZdnY8o16dJd/5jZMJCGN+YGes9k5A89g5cN/YfHi5riHrinAvOlaByzpbDFoLkLz8YZMZpgUslojZAORsOaKgGnAjKOvFKt+rwiBNiwmNCTisvvhJjJC3jYvvs14G0dYtcCq528zEwuMGYOn7eeyDzBmVlwYG441xS2uciNgaLL1zwGLpGKstgjCNKbhYBhR7XGCjP5ghKixpqlPINI62kyOzKSKP5dGXyhXxLz5Nh2cKC9fChE48ZkMcMhkzHWK+prTIsRIs3MizRFp+CwWhXIDOXn6Z5PzxnwwLNotzSnpmdxc5JCGlzOtWZukfSefDHz8MYsJo5qPshMxiS3FaW+ZGINNy0TA5TGdoWwe01hBGZYISAQkAjEItPerMKaYjTfo9nhxwXUPYYcJE7HzIRfguIm3oLLa9KUb23X9S9ilapoRkcxL2Im+yE3xTQU9hHgqVnGW9qBwkIbXxJ9aZeU9vGokDNbstUpMM8Lv0jW8rGIz5z3pJCheD5jwqu28o4RCSn+BxVffaC69tV/XWFvSUIrGFjIAy9ADaxHQfyCAtzYsmGWHR39pTWGVY2ymVMMmDS/xS5ErZN43yvcDxxLZMo6iS2sPr76Um233wdOUOuCsFY2Q9i2NFWcgLw9LbEO5tYhqePmeNQgc+zmVwvW+ABz+eg4BaRBeRQX4lIYQ0VhxmgXhohWi2zFhP00kuS96amqO/rlkYdX8geGy2XACG7+JqVrSv8EctPLiUPwI6vcVFymMuQ7CSsTpVgQKXFl6IE3HQhNRzlJYrE2A2d+nKJsdYbhsxlcE0rUKCpAfqhG56oyf/hWhGMvcN0pSnVayU7ssTtNWE85i3E/sj2OcPtN3Q6ra/TjlyCiJgESgEyGwgZqibqB6umw1r70/BQsWr8R37zyIXz55HBZVxUPP6C9NxOsVa/co3qGYHpz8gI15KJCIdpm+4K321B+wJbk2BO1OOOCD1x/RyopjhylOjYQQUlJ/CFGWuFfQ/OMTZgm/X4S8cMLS3mqoC+H8XFFOwO0RbiKLoYwQSVDVSCKRpPEhnV0waTK4Z5gKpYt1jCKvxdbejlB2fhDrWmqL/gnjsilFu/h+YB+x/LDBRnTiwtFtGibUJOSMeKMclIJJL66S+2vJSv0eMwoMqToW+jjjhhuATz/Vko37lzoYoptNNbYEmAimJpjYViIqohpeLsQoE/of4aT7hMOTFBtMny8R24Zlbo+ZcHJdbIzsRvsprLRDwwuqx0GENxBSqIQEF2EVm5LlSiIfK2wKDyzMxsDCLOQX5EZjh/QuBExknb6yomlpebp1Q7ZHI7ysVU+Y14wfCSkOG9mpXRaaILSQNPaJt4jUAjwpdfmSKBs0MWlLBCQCEoG4COiP47hpMpIQ+OK733DkhN3QvVsBcnOycNKRe+O9z74Ha04pOeHlgLc5jVmV+SHbnNKsNaM4myP14bAQCQjT0qWT6jF4CBXR+iJOaAkHETGIVWuJ1GNyXc2yjY3Nfn1Zmwmv0k4SyoU5s4kxkWfGj8kJr9XnRoQIr0XnYZQl5Ytgg3EyApOmAC2Pc+YIWcxDOI68UNtDdjgjGyak+ktrRjEttjTw/cBydE8Endm4CTeictBWHJOWcYa1X3NLJRP/WMhReBvtuQ9U47Y0brR//gHWroX40/vJ2xD4HGNrUJv8pKPhpVkGWGkdgYIIb2mIIVAIhURVhsUvhNnhh9+WhlqUK9ALUI02cpjrYsN+MhH9XiYv2nMP8HFsLngQCnIJJkNjHQ2xf6utUHH0CSKK+03KVOFP1xreLRu7DSkGevUCDtK3BPFNxzdztLBI1JeWp7AQOU3aHu1W5wqbCzLhx9GWNDS8VvPpGZw5ieFeuHwpbCtLUoZMkghIBDZdBIxH2aaLQBs9X7ZyLfr36RGV6te7u/DXNyYnG6zlEYJssXqtxQOII3VjelhY0tj75rJZELLZwQ9+JgB6aa0cfkgIDa/aDnZoKk0hwvzpbS/gfDyqxZo1MToR8sIJNX0FolaeAuQWhNGIHDSsNU0WtNSoHdT3woZo+bt7riMan7KH6uFzSlmeEITBPUFA8VCo0Ei30pHNyKzh1fGxWKhCqozLJke7+H5gH90TAVcuJtF/xZCtkc5fIDcfDtLwtig3SQEhv7bnNWSxJZGKnxQ9K1gf57hS1JAQGUtI17yaCGZceVMk0VxYrBHwmIo9vFSOKRk0u2wR9PpAox+iiUsa97Tp+DKFtchGiVwXGz2sRG8IQG2Plp/G3kWE1xhivdiWfeD6LBa65RSRHCbGH6GQCLTXKibSe4h+UgMTXp7ZUVlcttreb3nS8Bp7Zs1HF1OxSa90vsessVsakpTMqzCja34REpF2/zKMyC4tiUAXRkA2vb0ItPersL31dal8rMXlPbxOhz3aboddIwxut0bKKut8iDWR3FwiovRU1nP5PT7U1GnyHGWWjwQ1IsLxtLLbqiyW5TR2Y02ISIUTXtQ2BOPmY/nqeh+USIhonJpQhuXaMm5fAEU9QvQod3FzUL22NlqeoRXzwgnGrK2y4qX7AyHkFoZE+aq3KVp2rGx5jab9jUCBjbTJsekcbvQE4SWCx/5YQ1BEiZKFKFZVnY4d4cQ8hJf9uYN+a1bCNsSWGRv2WR0INTSK/EHW5lGBfmoPOeLyNnpEWoiIl581mhTLRD62nGRhHntH2Avm/8nkjLQqAzcl/n0QpoKqG/yiXUYew43o2y181G5qatzL6/HD7QvBomtPGwKIW5ZRptn1B8IwtjQEfEHwPWuupK6h5WesoiZAny8/Qqol5To8RJGjZYZD0XwBuu8iNA7cntovvwOmTImKhZTE5dc3BcBjx/nMxme1I0txw0u3qTneT/0yCvbTZykYURCkCQ/H2R1hNHoC0TaZ86Xjb/Rq3yV13jC4fVy2MMSr0ynHkPXm5COrUdPwVtXFvzcq6fsvbPoO4/oUe3zcAnSv1xFunMcwnkjrR5CRFutWUF0jGmdyFQjbbAnxEgLSkghIBCQCMQi0/raJEdiUg4qiIIuW3HymF1kMf1aWMzE0dgfsxsH4LMXqnoimOeRgC6M/9DjO7rKyk7IJUT0O+JBM+xKh0iz0gA+p6ZVN2VpcKj2gOULN07SqimnpV9FfYvMS4W3PNgMul033vkRUuYygj4Nxzf+z9x0Astzk/T9pZnb3yrtX/NyNKwRsTLGDKabY2PSOqQ6dhF5CCC0YAoSEwJ9QQkKHxEAooYRmIIGADYReQiDUGNPdcXnt7nZnRv/vU9nVzu3e7ZR774ruRl36JP2kGf3mG81syh2ilJy0YkmZLxtQGT5oSMFbQdjP5NZ/uUjlAjsPIaZGiVX3B1NRqKkpCKfhtbATn+QkYywJ5oCyuEbRmPnBmUaYjDRjbdLwKjUicURUd8H0y70kNyLL2CjpcOY7gnG5qCFMmiOr4VVtM0/GZffjiY+BX1rLaUx564cgWX560c/8iseu/0m3YoZRYTpXXLQs7jew9SXf/Do63/iaywZU+VLH1DS0hrfHvRqIghqML39lBKThdUrdqEV5B8leoXJeZVW5isggeKJTcQUBuschX/kj33EQZq+/XBek+wLtjrQsfi5NThmlgAsv5046T7bf6mbY8Zhz+6ImLdcvEDwBgYDApkdAbnoEVgDgmKMOxa9/d0U/128uvVL752antbtzaxtFI0gj3BJ2LyPlapF+dfvMYBHw8wsio5RFH1PT8RJZnJcT2S0albTQQheRGF2O82+bTcxnyUgbxuGqZqpjpkrWMkR/e5L328rtY8OEN6ZH+FXq4C0ax9yYtGbxFFrpQl92Udb2WaNtzxBhdioamW+Wbhw6pGUqluWwFPQAPY64uWDS1CEMOX77FiP30EPMuG2daY2UzXlXMp1tWyBJxcf5ZqYMbonQVWqrI5WWTVBBWpIyM6YvLGOUyYlQsoaXedSo9GLc1ulE153LWNddTJdSYAdhUIznsBCm8W3SiGshI6xEKOwlDV6c93Tq3NbpkfWwvKJptSRiah6PaUQd2l54sW4rjblfpiXHnTDCAAAQAElEQVRjPXZM3v345fxTc9NwfzJP+23jdguqk8vOFPaeJvQ0h+NHmbmZBK1Yopg2s2MO/MMbKRFeP61FeV39CU2JOIkg3DyMFbZtWXod8ctP4t9iv3KybfsMuH1cHxNeScM3Sflinmm7feuLOAPbr7kMxXQXllBcVd90CuPl8iWEwVbCzYXZnduxpV/OeTi+aCKqo9Ub3AgLmv/FPC7s5GwCN3QxIBAQKIEAXXpL5N6EWe9+5mn40CcvwpVXX4c9e+fxng9/Dufc604QglaRcXiQ9iYR5vGizsL7Asdpx7z4VifS2Se1snYLbSxiuRdKeCnSnyUj7dmkckflc8SsG3VMsv0KgQkYe4G1s0TmTKicrWDwXBBTiHvzYwvnFi/OH8Vjsy2ToKCEmfaSbkS6/c9HCbDiT1AcF06kycP+0oY0vLDf4RUWd9ts6D+eD+yhyNym2yZx7EQmZw1vPg8SMVF+p+HdNTfYjz5RQcrUb5unmabooUNRQ3iPpbRbGkCEZCjDMgFBGMRE+hiLPCNVZ0FjiEK9/KlcfrlQxSUmQKsF9zek4eW62HAi9YEdZ2SSOO/kLo391vw6dBfNfO4X9PvA9dD8UjZREgOmoA3VcNw1iXHxBLro0pJ5XzAVuhO+hHy5dxa4P5TPHXGZ65g3Lq78SJfHyHuqBLoZGZkvRAYEAgIBgTEIVF7Ve/Qc/eJf/A4//r9fYX7BaMXG1LGuo//ogXfB8cccgTs/+Fm4zb2fAu73Mx5/zvJ9osUmlvkgDy92hUWhn+jFJ51yw8G/28+ElwlAX57vIT+vE1JlUKThpWDlQ7AgKt1L7KNqR3gtsaMkzGMKpHxjbwVj8OrKNhLS8I4T4EhCRhreEl8/6otTtPorVidSDGt4+fE4eUE0mB2Sam9UXEU6tqRFpAd2S0PSMoJ4b3NfiiO8FOG2OpRdv/NOBx0ivFAFYkUyRx72mfTPjr/TyOTlImVk+lAknn4ZJrwcTnJ7LWDSxRGTGBKftBXdakjoPe3eOTGqOF16oAlvmTntEXDpPVUBz2tXH/u9CkVSglC7cjz25E+Nopt89vBlc31S4rLfmhvciLj4hKNohY1xSKZOYexpnms/WZW351jCSyLQc3uJOFA0ft8orU1PqsiZ7KB5vCSju7b4CVyHFy+8LSp+tuAPCAQEAgLjECjFsH53+dV42WvfhQc/4SW45V3/BPd/3Hnaf6t7PBH3euTz8byXvwX/+9NfjKtrXcbPTHfw5lf+Gb76yTfii//29/jXt75Ef6Js2c7QwsNkqp+HCQ4vci7Cf9ud9/fa+LKEN6fH8R0swNtibCUNHOISiFRKvKjUUA8EOB/1ib1p3GEHcIuPJXYcuYg2bDYOVjKsQW6l+8aW9X8JK4rL94mJhYpMOSZNPjHhIUpUD7w3ulY/LOnB3r2QgkcAcIRQd4znA3uoQl7H2WufbrN3IqNowe/kC3DlVyrUs3UK0/WVsg+nW7zgz9vhHERUUx2T2D28KKEdZawj0vAq0vKrlG58+AZRS7MW4WR92uEpx2OnStQBT5MY0xhrQWxxXWzYXwSTntRwdCljxz5e2DtczJfN9ZHsRasFPuiwFFWGZbgCCjmSy4TX1seYgnBFlb/t2/ulenYPeD/C93B/vHAyU+JGYdQYFuRp0TwHuoMtDWWeIOjyAIIbEAgIbG4EJrrO9kgN9s8f+Azu9vDn4Itf+x7OusOp+KfXPR+fee+r8NkP/B3+5R/PwyPOuSsu+fVleNiTXoZX/uP7sHu5R2DrEPOtW2awc8fWyVpOixkdg7xMNuwCpCO9xdcnEXFrouHQIthiYtYWXfgvXnF80bCGN5VJMbpUWJL+jQt0kyl2AGYd7LvWfJj+ijMfgEtwPKKKWxqkZWKLcgpx5i1sXIdnHHFMEaNFJMlLmtBLmkS7F4L71NdcKVOctzQoGjwBG2Giy9n2x0cYI+YeXDiHN7buJocIirJkhKrkbJMbIlYttTjxlgZXZauCWlzwJlBumRPC/qKh+f2V/+jgmkttgqdRtTFjHUEYsCY8I/2627IylJlw8sM8ZnxDmTtw/cRxfk+TqF8a8/O5uezHsb+MfM7PZnqabUSLi+Avb+gAW0zY2GXDfmL5C12j4T3jgXSDpzihpjn3XOg7oBvfGCD5LC2nedfX0HNEGbNzZz8334f0A0UPjb0fldTV8BbkadmMmT9OJeaXLh+sgEBAYNMj4K3C47F4yav/CW9618fxsuc8Dp/7wGvw1MfcH7c55UT9fdojD9uJU06+ERHeu+DDb38Z3vKqZ+OzX/wWHvG0vx4vcE2mNNgoWmwifw8vEwX/Iu5fuL1qkymzAHpRy3o7s1PoiEWfMy/Jz4/SI2RQopzsJYJo4eS4vobX9eG73+Vo/PTR5+FSHIEyT5l1wYLVjdpIliG8jhApJklO81iQsVxQKKKyll0yaer1hMlOTpYJotGEFXVC0hiahAo2kVFdat8+xFYLrbJMR2mL5wN7KI5JHntj9yUEDkxiqI52tqD5zSTZ8555xp6M0qitIEBGBA7nsTLYWzS8FeEH32xDuO1N/k1dMfOScA4eEsaC5Sxh8Ux2vDKsaGYNL4Hrxa7g9QgSa3gzt5ekIHtICjdqKGKCgCW8yeI8eE9zv4R//tO4c4evvjzSyYoIfa35pqWMt6KJrvIjyntbGtJlfs2xOAmnyvxq3M1vjnOfuUtfO/otYHz6AeuhcRL8AWYblJ229QUnIBAQCAhMhoCcJNvszDQ+8o6X6V8ci1a4et7xNjfHR//pr/EHJ9xgEtEbMw8tlLyo9jvHRMGRHI70Fz8OWxOX+KU1LqKIVPCWhsX+i1ccO2wUBfmzZMpp6Shc7WBJQC9pmeJE5rTHfZJsepsOCmHJkQ6VsYz8btRBOyON17iidjFURHj5263jso2Np+YpGh9OZ8KbWuz4xkAPS5ZCabKrOEs1M2W14Hv3QggjRzmCxRKZsbFLFSpayNlrm8TeiYyYaqOT7ytyjbFl026q04Qjrzo0mSXcVcKfw8Wi1I/ugsDWafvCYQliLagCEQE531SRnCV7hQknvzqGjwmvspp6P22sn84Vl8bnZp+Mcn0OfPa7TOy6ePZPaqwmOe7uGya8vmz20xxbXPCF5n7gwPu5BTt2sK1NaveA60DRsueki26XfBchihTdktMEcAIYH+d3Ls8Bd5PNcd54cjCYgEBAICCwEgJuKVs23wuf+QitzV02k5fIj///7i+f4sVsMi8tlBERHSajuufLEQWdwVitkhpe1SJtKHpInZbSiBmyeZ0QKkcmS+yrG5JgApElsmnLkjl6ZKtTmH2QpyeNxkV66xZFT3wICJ23S4R3OQ2vI4gZPf5uWe2pLjihxXiklihFtMx2+9gJ6HeZ+AU/Gj9Z5wbBavl4n3Ni8eB6+030CEJO/eB4qpKdiY2YmkaSL5o2T1DKfi0MsH2foEg/C/FR419uHlOfmPDOzRpNMjyNqim8nJ2Dbwx4TPULZUNgLS23SNpGTXjLvOlniShLk0St+xpejqC2s7Pk7qEKqbLbWWJis0Pd8Ekc1yclMmUuv6zhjaTx63Y0YdnzVUFACFFNIpXrbTH7eHkbyaRCOlvtNWLCAtx1Hvt+dh8rF8lg+oS31PxyQoIbEAgIbGYEJrrK/vp3V+I9H/6s/iID/zoUgM2M2cp9J/YSiXyQj4mCfxGnhWSQOPAlJTUjih7rtbEIViAPpCz18QKvpGVeS5NLxaTtjsnvXlqzhDeNDOGtwKeMPGvzL5y1+esDNlx0cv5sFUXyAlmG71ARfUgisjmNDwciIrzz3i+gmbgc/H1X9lc2jvB+7WuY2XuNFuMreHENxV10EUA3DS4+icqRkm0HbSUNL6kI1WTl0tQS0aT8jY9wb9TxPNa9WWqxhrzbFZhK7P7rEmRRkGaX5w2TM4WV/3p0k8I3k3mnBLHyCBJr9vdaRfQSbbJfvZ0nftSKfqvdj3t0M8IkbVQBjifZqbLn5JjrwaiiE8eRfJdXVNxXz+V/+SfPYweptyNHR/iWf22jeO/egkIrH/xJuhTevGR8isW4jp6dw5xWYn5x9mACAgGBgMBEhPf63Xv1i2j8dYbb3uepePZL34QPXXARfvHrywKCoxCgxUbmKQTs8s0Xav8izhqeEeVaU95Ff0R6MYo1vLzwd7vFlEGYq+WvNOT8zHgQXcFniNVia9aUddoWIm0c0RUtdlB37U6TFhG5vcDPfqblFa1cq2FByArEJUmilkXdcISWiY9tPin3FGlLhfmiBZHiCDX+LOnB056GHd/5khakMjsXOPTDHwJ3vjNwxRXo5hwBMOEzvgltInCtbAHMA4a0lWOK5/aRtKK+jckyNloK28jlCC81ZHGeCG9kJ2OJLQ0QpuqciK/gG5piPTyJTRZtLywodLAA1TZzTkeuZBFeLgtrh3fvUS443qXzeHyin+L57c1Ou7tPz9F+in/Oc/+kpDnXT23eYzHL6AkCVVVZ/uLxf6DLpm6i6lDBsnW52Jb9FJ8Lr+QyzDmNfT+fj5WLpDrknt0uBP+rG4PI4AsIBAQCAuMRkOOTBik3u8lx+Oan34J3/N1z8eiH3A2XXfl7vPTvzsd9Hv0XuOMDnoEXveqd+ORnv0rxpLkaFNu8PlphltXw0sVbg+O0pDoAyCiyvgkdWsRbK2h4FS27EWky62p4HXnnz0fp1rm2M5mniDQ2Gt64HGenkuYQloilyRRm8j3AX/+1SSjaTIgojhfIMnyHiphDEVmm8eEA40I8jb3a9IirRfS4W2NF+XRkFcsRXirLpJScsUeuhE7jfYzaM6lFdXQyujGg/JaOkm/8kfdMriguOcdIpHRjykSNwiMPSuPfnOg4wltCA8cI8LzKifTw9pslTNAfJKq82zOEF1P2aQPFrXjQueLy8LjPE2nWYV+2Oy91Alllz0cqAhoXdpJ0nm5GDOYcHuoT10lzUOXcc5qPQkJSWOdryvLuPD1vaemx/XKM/lzcuNIF3ObmxmUcHc83e0zM+6mMTz9gPYU6AuG1uAQnILDWEFjD7ZmI8HL7+Xu0t7vVTcE/uvD+N724T4Afdr+z8H+X/BYveMXbcJeHPhusDeb8m9rQ4iVIS+FIIogMgMJ9TNzF24+jxHy7efGLvBMdithlWy0uu6WBq2INr6I2TSR0TCYhzOJMVWKvmAXvT9VZWdNLxCDLTLoUSkdXtXqWOGPXrpEiVGaerSpSCyZlv2ygJdItALWXvazpK2rHI9WDovQomvjUYFHDxpIejoyYRZNHjXkmrHJFqUCSGPx0YBLLPjfmT7jlVsZyxXL+tQbKoOw4knfiQ7i5Y29uRhYkkrK4INCRCyY5SYw7gc0952Yx6RGswbdj3C9Ksvt+8vC+6ynMA2XueLz28Ljv3Wdw75+XfI4W6gHNA6qu3GHHpU2EV9Ec7Rf2ZROOOWHqD1v/WtEvUNPDJz6JYLlCkqfi0bbD2F00591IQ5hQDgAAEABJREFUMd545ZAQgkd0ZM6Rke5mp5/oyevH8fj0A+QpcUNFucMREAgIBATo6lQBBP4uL39z96eX/AY/vvhX/R+bOOaoQ+kxc1RB4gYrQouZoAVHkrZQ94wWuCEND6XpeG8RnMcURNkFtjOFKbVvWcLLb6NH/CKWrDcu/FIRt5m/jMA//wsmuhzBjJG0Z+6xevX9goqlIU2s1m4PaXl1zLDlCGJOU7fTKbewsiRJ1s/v9SD0pmYQkebb8kCKNYfGisZBKU87Z5Imt+2LS1wgSc2eVsWBESbNuEWAV2RErhFRHYNTK1+ET5xG5NRRmf2QquA7Fh0zuSXdjQXP43HFsozmoUA76pkc4wmJSffsOx1/EO590qH0LILGk88Jd354eXxvr6vAWxqiLQYDP22s3+LF6Vx2nsg5+/vn5ShcPJKs805i2S0NSW+BxsUbdb9PhBWIhfaQGIlCILJPONDUH8lkUTmdJ5FkXzWT2BuxLF2mPI+ZTZZ0zZO2bhu1ovOHd+piahuNvcvpyXNR/XFyEXTNcd7gBgQCAgGBSRCY6FKY0gX6Bz++BOf/67/jKS94HW55lz/Gw5/8MnzwExfiiEMPwmtf+jT9K2Sf/pdXgTXBk1S8ofPQ4rnzy1/Av+JhppusnSAMTYBst/h5cdeLbbQ0UVqZw761ldn9mSOL0uITEbFTtMCOTJ84UuicET3eXiC6AfdZMt4ES+QmS216lX21JFkIU75PeO3nzihp+LCaUl7IO/Zx63CGFUJUzSX3eAC6s1sQI0WR8PKPdDBWkaSOriBqbLKn4Y2J+HA+R9TZ7xu+X+Dw3Ba2Sxhbh/40GVHFlUpmtqOCbsZWyltMF+4q4c3XYh5FJIX38LbFoklKLJkzoRVt/uBGRrcggm80SNZQAXe+2MjFRQHW8Kr2lI2ZwKE56ufaszc3QVfXIrW7UA/oxsdkKmHbcZlG4UbU1cOi2E8sNMsdsBzZsLHnU12piT3HUrslZqQ87o9NWEQbZafYth008v4nGUfNM6+Ox9zlv4HXv97WGJyAwHpGILR9fyIw0RX3+z+6BA9/yl/h1W/+AF3MBPiTYxd++PVggnvenz4Kdz/zNEz8K2T7s3cHqi57xW+ha1qQpsDHP278vu1dxHfJctsZtBj7xQSxaOvRkcOWokVcEuHN4mQ4oWSIeKIuwRxgXhDRYILAMczYSNtit9aCCTFHlzXSFuh/9myv2Z9qo/vO4qIhKhmRo5ZdjPuJk3iUyaSIkPGNgN1xAPdOmSQNVa73uZp6TO6SttXycamIN7aSh3kcOUuObmY076UJr62jTRreoV/0WlKDiVBugBJTn4mdzJa2iOJ5PK4IzeVj9v0Ut77mQpODbvqMZzKbpyePqeAtDTRnlyvFe3jbIIJaZg+vp+Fl2fPFTz2PqrNkH1gu7LgYLbKdbJxA+LCjDRE6RaCmytxUKbpeuPmv05uwSCaLURB0zVao+tdqm8GnJo8X4a4FlIPHMCpZHWuEc8KDipvDx8rEDNk5nbtDESEQEAgIBAQmQGCi6+zhh+zAvc++LXZs24KLvvo9/MM//Rve8b4L8NkvfhtX/f66CarZZFmYFVKXedEjB/rxv08W3OLqXdh3RVshJhoNLVFbebul3Xtc+m7gzDO1v2hxVfyYHv6CUsxUIszrKG+/0H3ickx4SXuWpRwAhGPGqPaXtuxj6jGEN7OaphwS06b7lSpikhGJDO5rXW4otIaXsIq5o5UkUyHW8p1xBnmAqEfEjHy5ImvEkfYEpmYokY4RyRgbZwlcSy2g59j62MxA3jN7MEWFOxIphZYs/DmsYzyLADxh/ie4xVX/5UVO7mUNrwLVwxOWjV+UZPvBtAewBlVZDPy0sX6ao37avnkbcnU510ZrpwrhtXtTuH2Li0qL0ZYvn9gjz780Nyc8P1GQ0vh13gatnM4ThrWqyNg+sel/x3kFQbmQiOJohVyFZLpoDBFeHyuX1YvL4xonvpMX3IBAQGDTITDRVfbwQw/C/3vxk/Glj74BF7z7b/HH595bv5z28te9C2c+6Fm41yOfj7/5+/fgPy76Jnj7w6ZDsdhhu3jxyzH9pFFkwVvId8e8pWGi4eiLFHbBP3rvj4EvfhEYQRIV5Y5Iw6tkyUWIyvlHFJm2xbHCAoiUuq80sHan3YbTYHK6X66sP2u1TZFReHHK5VeyTXpYCQuzDpe1+NNkiUhpvpqStnvgm4O6WGmJF10EbNmCODWElzXtOr5g6RewZnLEzPgKacsGmVRThk42T9ppHmUKLHO4l/2E24+7TN5ikrSkB+PGhAvQXM6s9j3fWv5pBX8NICOtPd9w9F8kY7kjTJcIL0e7+c/+FY09V1y+3vVWxUvt1nFEQuGRKh1XhfDqggBvueBTwwYxJJvqVEzymIz2MzTsIflOorQ3LC5cxpUWg4zxmaBgTmM4QbahLLqp0lxfdMKourw4fjqj8wVrsyEQ+hsQqIWAd5VZWY4QAscdfTgedO874VXnPUkT4Le86s+xZWYa7/vo5/X3effus29pryxu4+aIIt23aeHUSBR0L3mRt7/4eRfx3clWWhQ5sYSx5HA63W0KFRfshz0MW//+NbQEZWiExHEtQmFeTQGO8PKLTER47dZa0BThXKWNK5e5fZlECkYJmfrql3S08hdIHTOZJezir4jhxqTh5eZzSbcrRBKV5rSK4lnUwBApjbuG8Iox/UlJw9shDW9StkJL4FjDm02g4XWacVFW+0a9EY7wsjafwiMPmssR3VhxmpidYaeUielKlBMB1DgV53EhLPfa+d6heThpLTRHOWtmnyAs7E05SOecGnZNyNj2PDaBye19U9twNH6N5Ms0V91NqD/+5Of529/DS4pt6v7kFZTM6V44LVlMZ5f2fMl7FicdO97KhQSdWuMzjEzJUUbDmwYN70gUQ2RAICCwPAKlr7OXX3UNPv35b+Blr30Xzn7os/Hk579Gf6XhhGOOwGMfeg907GP25avd4Kl2oUxgVVHcXZ/wOnZHCx8nsdnb2gpZcjSUXcQ7qd3vWiAG+MpXkPzoh4bwVniUze3qG9vWXBLhJf0VnPqKXXpcnNktr5LS+2VKeFzTXZ9g6yuKyO3nz+BImJ9hAr8QxC4onyI8mPA6paUjjZFKwWmw/aGs1Y/ZWUT7zNiM1/BKdKZzMOErVZHdKzql5pGNwcqXl9s7ElGejSByjeN6bnYz4JGP9EVrf5YqSAuasI/1dcKEFs/9DBFGvrRmx8yJkvZmS5XZw2vPlSxpaTG3uOC12u3ffHLf3CQ0KYDVbrrgpG4vmcbd8R+4yePvBlx88dJiNOl4jnVV3E9rOYz7Mc14FETp6wq8PyHM+fLYrz8feNazvJTRXr09Q41OGxcrqQ5lr5k6D908aXeMFTS8Y4AJ0QGBgMCyCMhlU23ilVdfh7963btx93Ofi7Mf8mw89+Vvxn9+6du4421ujle/+Cm46COvxyfe9Qo896kPR9t+OcAW3ZwOr97U8zaMdo+86GtEOeAu6LTwcfB5R74Tr/yDvx9omzhyAiOslm8m3WVyO7kmBH40LIiQxkhBbMTFVnKl7RMT2gXVBpzmiok8Ed6cqmDB/rrF4UkNrXk660pbGhxxs83RZUpZdjMtL8wt0es/pWe+w3KinLTh1BjZBAHZsgXRbrPH3W354Dp8k6YCUzM5plsD8uOnj/UT5pzWyRdIrzoBw0jNAIloolOeRfeNjKyXx/yGNwQe/WgbMXAUEer+DZ6dl4PUlX1JLKCInGnCW5zHtu1Oilw0T5GEJbEuflnXtknx23GUcftvf0Q2Ha4udt0koGh9VJxkPdIib8FuLQJOK87yTQz4vNzby4ncKxND8814VseWooZcO19O+P1/A9/73lJBxZsEGsO45LkjFDXQx8DHytXoz4Hw0ppDZVk3JAYEAgLDCEy0+v32sqv0L6nd9MbH4iV//li9j/fLH/sHvOw5j8O9zr4NDj6o/J694WZssJBdKDswC7PundVKab9bJKzb7Um0p2gBFDp1YktZDdR0Zr9ZW1yweZEgwhsxJYpKEqoxrWAx+3hLA8nVWXhBJ/KV2b7YruukcpbpvOoQmeaCxb5wHJmcNInkQPVZGIfKm5we7Ue8h9fwQCJbRobUWEV17w+MsLk5CPc9YYuPSRjYPbulYRAzoc9qeDuKNLwWk+VK5jwXKINIys8DGVliRuX1MWKQVS8lzHKdjCoaXqojJwmS7wzGYGWEA4LnHOj+0JJY8k52vPSluOo2d9J5pd1q0n+SMKpOe37pAiUs3jbRP/ct7v16WA7F7SLCm8HcSSgiexY5Tm3G2DFSREBlxach3BBJbWN3rCmkD21NGFtoOEFIgZwvLC561Llvx5yziHb5OczlggkIBAQ2NwJyku7f7MTj8bUL3qi/t/vQ+56p9/FOUm7T5rFqzgTe58JYE+oAcYur1WQsdGO0O8qlTu5acjiTW21ScaEg+WphEbz4KtumgfByPkNHAdbwzmMK/e/wdqmPpGlLSVPJEmXltcj0//Ijb47X41nof0YLw39u6wEqLuLSLtD8SDkhzXfaM/IJKu3hl6bqkmktiC0ivHL3LvBaPm5LQ49udqZmTN+5yMTGkr22WqBerFxKWc22kGLlzIUcsoj1iLmkMgW+sdJFLRnX/gmtFhG0nAivYMJbnMfufLGyhD2XpMXARq/svOQl+P0d7NdM3PfonGx22fhSKhLe1O1DZ1l8frDry6b+9XIiedRfTgLNyYkuxDpzOUtBgMSXK+TnpnHpB6ndff8YT059EmPSxkUfs7UDaTXJOs8K9chaHdI1BCsgEBDYhAhMdJ1NSBsWR0YbsQkxKt9li1XsU5FrrhnIcRdsuwgupkR4p4gw+IvLIPdYn5ya0mnT+V7tLrFo4RA9y+jiykzUiLUzhcnbPBNet5CzfCIejojSVDH5S9oCQpfg9/C05stioyM9i7qkQ8JfIHXMZJay2fgGIBI5PV029TLP4iSJHKxtst3lqOqGCK/YvQeR1l6aeorC+EZhajYvRq8ctqSSCW/mNlAvU0p1M50qp8weVh2Y0JIt79znOTpiLvG4CKcnf/GLJ5Q8nG3suLvzxWZPUvPkRMxM25jJnavOPRefwP3Q1/D686xQDyo+Os/8l+ncnRQDBPtHdeZC0tXBnpPktynNOTxOJC2HRNVzEvxn5bAXvl9HLLVyyhPJ0XN9aW4Tc/Lhc0jcbxhzFOHDziizB7MYMf1GZS0XF3IHBAICGx6Bidb1H//fr3C/x7xwIrNnr/dlgg0P35gO0kWfU7Yps3+T/fj5z7WjLXdBT1Md7KYR4paCmGg0dBFj2RcEZ/NdJuwvqhzDiy1peNmrhGCnsnGlpVRYQAco/NIa814WXroPXIiMsIQ3igVyWqSJiVLs0kPZ78kq6ZGwpdnGxnTs6s/lY29Lg4MuynpQlKdVch/iyAo14d0FxkSMIaULixGmptXI4stG0gW1YyIAABAASURBVE0Gp3d4S4ObTxwxxuy5zhDeuR1lJxkQFYsIsaQW1iAn7iXNE09ckj5RBFXEGnbwvPULFPrn9vDC3vD5WVfyRzQYkcwh3JYGJ5vPRed3QuyNqwtO6ub2B2F0fpbLHl/23r3IxWD+CrkUTy7SlFHuRqSCQCG8wS+Oywh5fF5FqNAfOuf64papp4ek6n1IX3zwBAQCApsTAe9qNh6A+YUufv6rS7W54XFH4qQbHzvWSEv2xktblynlGr3SQuku6JZldbsREiK8UblagHZbl9ihfq/doX2CHEP1SPuTUipKOKayaSfURhpb5plaw7t7N/DMZ0J/raHVwnw317JllcWOSjrKx9rQDBGWkB7Kw0dGj87ZRfExu45c2doxHesW5lEM1sA7ok5Q6cISOZS/yOvYihYT3l27QLDB5ztFadOzrvfFlGXClvC21SLJFstkNEnz16Xas/2QWLtlLG5/Pz+T3aEIk5Lngm5TzBzASvMfo/9ykqC3NBTBcoNji0WLRsMb+ZpUm7aSw0ilsgVJNzY6b27bzHUW6qmqSsx8Iu4mGMvXFRoro75moHlOQcknFbmrdcg6hJoBcw0r9EFH2+0l2k+WEpJgkyj7J/wbTJZ50UXAZZctEbOINma3qCXxISIgEBAICKyEwERXphsRyX3yo++H6akOvvfDi3GLk07AS579WLzyhU9cYqan2ivVufHTJ13w7WKb5hLtqfIX8SV7GK28PsDz83D7HauSECfryC0d3PSwGVrMgHne0sAJX/kKwFsbiPCmRoFYQ/tiiEecKKKckto9zzUsMbxXlCO/M306O6XNjXfO6jIqkojdd3i/9CVEv/oF+I9fmuI09tc2W7YAdGPAL32N4gosXxH9np4xfefwxMYR3mweaXHcRwhZ3G0GKOqUJ7xD01lKjJpLrOGNYOoYlT6iSUuiFBG/drpv7M2OKxDZH/OQ0/SkwUVO6ArK14taSKwMulugGDpGYVjx2XlO10mSaA6n4S3Iz4nwsuFMdb6Ty+VHGr4xsQlSKOsr7yS+5rVf3PMUJjYTXi91Yq+MDPnXBa66CrjznYELLtBB30oRY8tc7kcFf0AgIBAQmAgBOUmuLbPTeMbjz8GFH34dHvPQe+BN538Md3rgM/H2916gf3FtEhmbKo+32Izst1v8rEZJEenRL62pkbnHRxa1tlaeX8BpeOFrUPwMJfy3PGIbWrHAAizRIDIH1sZowmsbT4+LS4hckpVEQREe40iTysxi98Dz4iVlJ4kgBZTOxuSKH8Hn/F3fs8/G1nf+g46P8hRVF20twLeY8FJ4q9gFrbkk/6hjpqLGqhd3wD9hO8l3eN2XDUSrPG4RjXm/3UxwmPT2I4wnzxXpKy3hHZFuci1v58Jejtz54bIXwknX3AwJ+9KmyzaJy+QyjVqIs0WT3Z0zTEy5bybW2BX7MfSTx4u2nkIf8lxAz3OqSVash4queHAdK12OVhTiMuS58w1ch5+LoSHsVLjWiIQKOhlFrbhXRw8JZmb5tgXhLyAQEAgIlELAu8qsXG52ZgqPecjd8fkPvhYvePof4fVv/zBOv+/T8NOf/2ao8KYP+NqK5cCwC0hGVCFpK9KelhoORLNTw9KLCzalSrfXlrRnFKx98Nq84BPebhe8taLXU1q24yw6UMJyi35K+t2M8Bi7pcF+giuOTH0lqtBZY+4A+UQSI1IZUpZHZEdeew3ugwuwfc/l+qU1ylL/mJvTMraI3X1Foo7wrG/gNpgq/8NkWkIvnqKRWCDEViYAyqrgRZTosmWsyN8+wuzJYujLUJnSOksdF0XaKW25boyYx76s2Gpno6nyL61JmqCG8PaQEknvDwyfi8V649ivdmK/mvbOS0fWCrIXezHpww1Os+1q9SzbIB4nyqDo5pG6TL6KhzfWagIRuTB9miDrUBbhY03no050mHnzqYsWZrfkCH8BgYBAQKAsAuUYFklf7Pbwic9+FW88/6MUAu5z19vhoO1mYdcRwQK8C/SycPAiSxmY4LU6dBGng4ITHyppD+e18vzIeNe1OihWejSpc61syVihv6WBvzHLhJfUslbxShrg0lPKVmqWU0FENsV4AuC+plD110WlJQIiSRAJJrxC1y+vuwb3x8cxt/dKqEnHT5dcxtq6VSfOiV19XqUjPOvruC1mKi7gqSW8K2p4L78cz/z203Styv7wgg5MaMnYy8j4OXIyNSB2/Nm1iCiczlnhO7xcjrXu7I4FSyeir52V/tYBm7aSw6Od0uRJ8kVkTHhdASZX3DcXZtf1k/1lDCkG+tl7PeNl+can7cVeRDcqUvtPPXqHdhu1bF8UBOKIe11RupWjS/t46QiyCv2qeu5ELYMFSUT/Zrcgm9OY8G7ZmrM3mIBAQCAgUAoB7yqzfLl98wt47799Dnd56LPxkr/7Z5x9h1Pxmff+P7zqvCdh5w6zsC8vYROlrkSYHDG12h9NeEnDK2TJhcnu4+wjO2KBcGlVFyJX3rkRLZ5DhJcf2bbbsApE8FccXN4yrqCFmfNnREJ5kWb/KJOnZrGLo1GpK8dFPOMF5YtixCqFUyZFu64nmp1SAtDptLRb27JbGraJ67HkhUIrPKVaZytreDvgbyynpF214lZ0ZIUtDZLGfEiwYAApxrnk7S4KuoHIUecvJx2xLu/ODx0gqxBOeualtdaWWUosdwg6xzLe0pB3kfP54mSzy2FfXFXC62t4e/azgAXZXU/D61fZmN8bGwhVXWw0ONH4pmaJIHsNc/FK8AnmQpO70sfanZSuOG+bsn4mvLNhS4NFIzgBgfWGwIFt70RXp0t+fRnOOOdZeMUb3ot7nnVbTXSf/aSH6V9Y4y84+ObAdmeN1O49Bly2RbzIUoacFnrz0pqi0ORHNLdlOLO/qM6bfY79DETw+v4aHv6Kwrx7aY3lcD2k4XWa18rV2LbnMkeKmCWPNLlVJScVOWkkzZRXxHyNhtdWQ4tsTDVz6LCtA80lhysbp+HFbmDM0HJfZwvDOGl9aTJFIzE/TvRAjMWWI3LSbLNbxiS+9o2JlJNB4+7k8A94bN3adcFKrnB7hWkslhPQyhZ0crS9/C88MndnDOK8h9b97jv4EgCfi2y0ZGt5ZM/GTOREc3aPO+d2hNC5HEcmVQMNLxhTiluN47b3mMd9z12sLnqobSMmsTe3dCUVMZOtAbFeouH16ughwdbwQFFDHayAQECgHAJykuzXXb8HrOHlvKzlvecjnodb3eOJI831u/dyts1txl30TzjB4OIu4HaBzYnwttoKcmhxMVmXs62ebZDFytMRvp8jqqpEuaxniCcOtjS4eNbwGuUoTjy4orrSyopiRQRuSc9sKpBnCgvoIHLkqJ8ymafFjIezkkYpYg2vVcDxY3RHeEFpnKW2sRreLUR4Rz0NZvkZIsxU+eEJKpzGHUJioa+lpqjRhzcXtlZ4GiN40J1kvmFw85v9Np6ndCwzG6rmTG0V0CWLhJeF6wSyXvtaPGLX28lT7eBTTNH48veLhzSWHkZ9yZSv7y/hyf0tHT07wfw+kKxcyf6WBgo2f3BH+1JV31fHM4SXE6QKsuX4c9cVGeXKxFuKlhl/Jrxz2wt1jhIY4gICAYGAQAEB7ypTSPGCx97gMLz6xU+ZyExXeHPaq2pjeB0hKPbmWc8yMW4xsossk55Wpzzh5cHrxlNGJtv+4lPQKKEpwpsoLKKwd5gIb5abhe7ogz3tFrdpQiMteUpIPuOhi3mPMnWYLH45itNblI+C1Y8oRkSUw8EkaCxWi/DOYdfYdqakzd4yV20Bz1rTuCO+jKPe+46x8nWCNy+2Tbd0VBkr9m8ueO7asfK/QaeUoCmWlxG7JO+U09wVCQ/XaXOrn/4MR2e/xGLkzXubNqmjEvMEQdGY98v4fhcZm3wuOLHrbzUaR3jBs4/PYJLq9Y9CzRz2GsRPMmTFbQa6IVaO9sOc48Zv7SJuke2TTZ7UaU0NsM4vtj/S43Dx6lgUHZpn1eqYtC0hX0BgjSAQmtEwAhNdOXZs24J7nX2biUxiF5OG27m+xDlCUGy1u4ArS3As22ICx19pcMnFYuPCIhLIomSQbOXpCG+R4LAYWrg4pprhtZO1LEOl6dF2xl87oEjXNfKWPAwmMgIYD124SHwoMs/IosM9VSdvpUPRDUCEFGnPLOJce5/wNoQV7IAKSVprrmBES7mvMzMTnYZLSmetDrbjWiQ/+T+s5h+/qDgk3+HjzXOZp0hEOpStdIAnFxcqzN3+I25Os3OiK6vdWAnQOeP2wzgyynKLdXJcRcKbt722uToK8nNEg3nu8OQ6mzZ6DqrqUnV5U3zoBsFELbWr9sWfS//8T0auHWsTMHYqElR9T8BICHZAICCwWRGYaKX97g/KL6hVymyYQRi3ULp4R0ztIphDYnZGISqpHYloMerFBW2rA7GwWAj/kaHLU8HlLiwhvFrDa4RRk4ynpM1EhIvEpLlVRErYz9sMtOtZ/L1XTnecxUua2PuYP7wBjtwxq19acwRaUek+4fUWX4quftjFPxEZhB3rorDWrASPYzF+krCyvzSmeisQzep3IboZSSS027ccPnSj4+L4pbUkyqC8Lze4tEnd3OKlf8zEL+S1X9nN4mPnvV9uhD/hcyyJTIp/jowaH9cek3tiW01PD/L6dQxioeicV26ee/Gr4RWiMH5VKxmFkbuWWZmi8pYG78a927XSrOPV25MtOl8mWrZs4eAEBAICAQGDwERXjn/+wKfxV697N/bNL5pSy9gpXQDP/9d/x3P+6k3L5NrgSeMWGG/h1ggQVuzywrd1i8R0yQ+2SyIema/h9RdX38+VUF526hrWrqT0GN6XsyBIW5UBFfmBL0rLyGAJyd/8DXDppUPpSDMiCwIRaU1R548a63+lAbSotmAX2oawcs2TIse4H54Q0y0kFUmCoBsNrkMt2n2iHBhl7Dyblx4RG5VvTFxUJLwj5jfz0ERQO+pgJ2wDnFbUBodufOy87kaeFtXlm8DdOdMCHOF136jmcowRG/Y7U7EvQxpeJm/btwO/+52Tqt18tffw6lqM5WA1oZL2iLEekkDnjR/+5llP8oMT+4eIMr8I65f0xiWTMWIh/dTgDwhoBIIVEFgJgYmuHA+9353xuS9+C/d59Avw0c98eeSvq/H3eT//5e/i4U/+K7z6zR/Akx91v5Xq3rjp4xZKVo9yr5Vim57dE0skX4oYczMR+UoetNikvobXyWUx3iLBwajuHgAWQiaOxZI9vP977SLyjB4Vm+5QrupHRBrePuF91auWEIUshya8rZbFsGpVUUT6tRxpauiAIMERPWTW4uJYO7UtOw+kUEOczZfbmc0hi4TSz7Cc32pT8x6Bslw+m5aJav2K/K80cJ8IOy3SuRQQNCr6JsSLo+hyB5EZXSBNtTPKUjROHF9VwzvHP/JgP80m/HroXFoySBXnwZCWm+sonIvc/pzGgkaevatuzAyvWA2PtysVUE6aAAAQAElEQVTqX1/GxMmplksp547CekR9rOHlm+5ywkPugEBAICAAeq42AQp3vM3N9afI7nHmrfGiV71T/7rauU99OWlx34wX/u3b8dhnvRJ3uP8z8MwXvwFHH3kIvvCh14FJ8gSiN2aWURdv7qkjA+5CbhdCRdRr57aJ7j1YSt+0SCOc+T8kYOXpDL6fI6Ly8rlY0QiZEy2MhqKzKCbCC/CLd0MJZQLCZGboGA8TIrvYD6vhjYl4U2qJo5CVxoI/TZVZbqUoOQFpKMmFv8hzuKqxcqJlNLyzU10kotrYKLtXVHVtJ8a0s9c1/apKeOPIE8xz1/bLf2mNcyS8h9elcURJI9wcLY451+lk2bQ0aruYUi4j3X9pjbWvrjQRXuXXw/FxtRsEFLc0MOlleZ7Jc4HcXX5X0qJ65ap5VbVixVL5iBsrOx4uazztbU1wkRO4ctS8cfV5dbCGd9XhmqC9IUtAICCw/hDg6/9ErZ6dmcLznnYuLvzw6/G2Vz8Hd7vTrRDTSriw2MVtTz0JrzrviUSKX4XXvvRpOPRgeoQ3kdQNmmnUxZu76uLdwmrdXEY4cnv5BZw/nJ8Wf22N62HjFgv2kxFVF28q6x8xaSN7GF7UslYLrHhz3fPzT+q3fBf8WbIMHsOyGDk5/Oic06lKF1XNJTwkUY40tTVTPf09vJRWTWihlF2ZWcObK1tPIUtMmn2tGS3ETxIUM3aLgv0xjnFlFN1QcVoqW+yUNlHitZ0HmQ1LKeDExJ4uCpxSzdDc0gXTVDt9y5vLKlc6upd0tFvWklSHatv5O78wKE510BQYhNlX6B9HTWSKhLf4iJ6EpDTHMzLkBRyeOtCQRTd0LCmXEaSQ7K1m/LbZ+bycIDFV/jqm5Y16AuXq8wYmpTkcuXhdMFiVEAiFAgKbEIHSV8JDdm7D7U87GY97+D3xyhc+URPcJz/6fjjrDqeSdvfQTQjhiC7bxWZJils83AXcai6itkQSlR4KWsgEMp/w0qIN92dlu6Cwj3FduKrLWw4WC58l4zawdozW1qpiNSUTVJo/S5bDw8LvE6UrCivKPT3t5aH40geRGf4OL4nrF22c8Nrxjkkr3q+k4JmeVYhktb6IKUv6igSxUAdjxlFZxQFKfEUnkw3XXm+eR6T3j2UKeHFcZxkjY3ujs1x/+I6HhKb+Vh4KT3pIar9s23r8vcI0EXgOD8mhOTIUnjDQvcEN8JPOzUxuvw4To+0v/ecU3W7Zcac26chVskQduW6sWQZhxA6bX127D7++bh68953DbK7CwcgP2cne0kaOwtrV566XJDWNWuAxJG84AgIBgYBAKQTsFbdUmZB5JQTGLfou/rLLgIsuAvhneUlWTIo3AUW+ckdKC0Lmf66Awn0JBdIgyhHqvpiiR0aKHvxbDZlN5F+u4j28nGajSjsCZipGRK4yWEIC+vMWOwqBf3hCEeGtzRFoLNrZPPpbGkhz2Ce8/iLPlVY1tpFymS0NnemcbnaqURJJT124aSttaVDUN86XyeFx47hJTJ8guswOH8LQRbEbiwx1CC8sXijcrLFsZ3qLVAcFekm17/DqWdayONDTKRJlDjp3lPEN7FEkbJA63tfu4PfJISZ9DOHNab6zMZlW1xZSVK/AjUlBwq+I7GrC652fF+LO2HvSzQs5JwsKd7MzKjuNjYvO6AIRST2KLiq4AYGAQEBgIgTClWMimEpmGndBdvGf+ARw5zsDV12lBQvS8LaXu+DrXEutmORlrfbSBIqZL+zrFG6Rp7Q6RxzLJYSXSTevSWPWxgmry3U+3gecLUN4QeSN02tPXEtm4p55rM1fUegT3lGPV3XrSlo0PlxCCoVx9zP80lpi83HeMuba+zwK/41TgNSQwHFlldWKZoLuJsZlWia+VbxZcu0t4CRJZykKJHgZsUuSlLTtK9ys+RlVRlhSxFUH2V8tJH+Zg/e9i7arx8ONiJviSUzCrot2AH/4h6hK3qNIoheP0L57Wx1yIrw8j6k6oN6Jg5F/Tia5tc4VKj9KPsEFxZaXyH2yHw7xYifzysi7yV2mSBq1CTm1TI7VSAoyAwIBgY2AQK1r4UYAYFX64AhBUbhbPNyCbrU/UUsgdmnFMiuEc0vcdDYnlwKLhU/IOS5BSbUOJm8pLGGwkrSGNxeQERr5ezceja8d/wAjy+uTjshyCCgIJpE6oqJlF9iFeaEF8NqdEJXXgYpjocv6lp0Hem8rV+CnWX8SK9LwVjsNxfHHoYsWhr42YOX6jrIa07ziAPlTjIAHbL/6LlXGY8KfedPpFK50RMIUs+eFCZBtiSj5wJ9g+y5OxYfu9bccrGREy0xU2V0clCeMHOH9/vStgW9/GzjppEF6CR9L70UtU2LE/l1OYLIb09izf7VNkZhWrs8fBwUivCTJOz8VBDq225RS6ojoJmFJAVefVwfP4aZOzyX1hYiAQEBgQyNQbaXd0JCU79ySEo4QFBPcldot6NaNScObxNWGIks8Da9bIKhe92Y+efUh/a856JhqFr9Uthtb8P0Hvxg46ywtJEtayDOAybCOqGBJ+9g1oYWPnlpib7zFSCkQReK7UIRjJKrhZYSSHRvS3oYlPYRdX8Nr0yhXvYPayQIiftSv2LfU8HaWRIqlCRPEsDathwQraXhBfWNxecW7nth/aY37JC329qaBZQsoSNAkqIGdcHI9gsOy4YX5h0dySBSUyyjzx09UOH80v4cdY5jwKuNVrh0mWNoWNJ6sidQFF8wTBO1n7LQHyKkPucPPi7fJ9R1PZuRuJKpIHYMFk2g9rbzzk/vUsort0lUtN2+8OlI6YaKK18rSbQoFAgIBgQ2FgF25NlSfDnxnItbxLNMMvVJQOi2yZCPuCIxZV7DSX86sx2XyFoZe4de3REOLRCTNlPnuOUR4zzxT15wT4eWq5Qrd1pnHWMrGH7qlhaSl8NMdtzIxDisTAtJcU6vIW9BdUinXjlHEJM0W7Gt4bR9tdHXHtlGSNjon7dcoQfzLckzyR6WtFDc1ZYgTVtjSkFtBWUTk2PrLOC2f8HJBh49zOY6MFFRTIY6iJz5EZIm/R3CLhRX11WhHqa5i4qThqRE48DxjQzIEjRc5lQ8+Q1J3I+preO18YME5Ed7Pt++Bn11FpPvWpFHmyCaNrWt2qoVDZ72b4rJ1WDm6mMWH/YrmM5+J7maK43LqU7ut2FvejJo3rj6+uFiJOc3h/aQYtzUGJyAQENgoCPC1eaP0Ze30w5KpJQ1yi0fhQh61BJJRF/wlApZG5G3vGaK3MKQ90rZ52UUSe6HqXvdimubqlmxnLdbwisqkHfQniMaSgxbhwMT551tP5iDMc1PjZZu7yBpe1CQliA0eTqsbk7ZvGvu4Crg0E6hhU1+4tOS2KvYZ80WcYTxkczMi0giSt/RBsIM1vEIPxvjiitXilFxVw9vxv4jBfWJD8sANYJcMj1/Me4W5QxSucuSs2qeCqnCzNkSq6IaHCW9SJOFUbtJDuD28fgGeWPb8VDwB/bSS/iiSePWpb8QP45sD9imOFuFhw31gGNsVx17LW86yfTl8roNjttvP1y2Xf1zamGtZTtcw1vL652dOhLczJcdJWj7ew2ZJRqqL437eugl+N30sIndjxJHBBAQCAgGBCRGY6OrEPyt893Ofi0nM7j2WNIxrwGaIj6LRvbSLUH8Btx++l50I7XiioUDxj8lmP44XbRsoanijliF4Nrmyw58N48JaCWcXqfb0FPFPAVGtCywOijRG7GkRDrxtIs1te/NhTV6uiANTXlmXKNi2O8I7ddVvcQiu5CagMcIrhJbHuLih2dfaijNxEdzf9JTAjN1T6uImdTv0+DhFDFhCO66cq7uqhlcUseaKuTKLIXsFjyBreMfNfc60gpGWyLi9tKOyK5oAORGrZISSdlT+UXHRFGFWTKCbBuXi7Li5YFlXUoG4Zb9m4m9p8LDJqQ88zzs03yl784frg3Or1uCV909FRfL0jSe57pg7VIC4Pir9ediMK/8PO16ALxz+IFR932Gc3BAfEAgIbA4E+Nq8Yk9vdpPjcLczTtNmy+w0esR2XNi511y3G9vmZokrjFhMVqxhg2WQcmmHHEngFLdyWDdqG2LESWVNbrWsuhwt2tolq2fJNHnxdPwjFk64MXtrG7eg6aqOPRbX3vp0iNlZKP3SGi+D1arQnIpg4P2s/Ji/l1GARTm2xn4ygh9pi5gWVptOcZUOS9Yc4XUyfnmb+wMPeYgL1nPtmCdIh+Qk7QFO22ajyjc7LJ4Jr3DfVsPoPweh06COzjU+VooR85mzF0iKfmmtEMfZJjXKaniR9sYW6W9pIEI5NtMKCXJqzDVKT2rA43io8hdJCb4x7KoE7tODKPxliEDZ0G7JQkrDwbqd8ZrT826seE7ldPPhf0JudmsO/TTDKzOxd7l5Y6+TWS4RRYpwW2XMJm50yBgQCAisJwQmunI88J53xJ8/+aHadOgR+oPvc6b2uzh2n/vUh+PSK65G7BjRekKh6baOunjz6ubi7fd33ePOhLR8VZugfFUXr0JWUOp9luxbOA1iZs6m1HNYK8US6J4HOOccfOs9H4Oa3UJKa1qIanBQAcFi0UloUYuBNI102F9QOYIfo3LOiSYuFxhn7Fj09+3afHt3HgUcRcaGm3A0CbBjo6ifnWmFBTGlRTMx0p4KFhNeTZyydNnSKjfpuSOUy+ZemshTtx9rcdNhL0GQhjdSGYiN6KQqltB3PUA23x0ubgkPLr8c8fXXUE0C7sfShjNOFpJTdm752XlC2zGqyxG5G7wPvcdPKfw9vB52UQt42J9eh2l74+U3pRH/zAxw/PHATW9aT5zX5jTN0WOSSxIVmYz81+7zxorOXSEkpVQ4vLnUL23Hgy4uOiqjm2qewnEkdDhYAYGAwIZCYNU7U/rq9KvfXk4chBa2QtNuedMbgrW8F//yd4WUTRgcdfH2V1G3gPMiS/DEdTS8/neArIaKRBJhHIzRItqkGWlmkUjsI1jbdPCiJ4SgOSFQda3j9jrTogWWtTg90uboOIeVDoA0yeQRgByFMSVNfFA9nDfyXlrjMD2i0E6TFr8EJZkMktAcEnzToCAoBCx5IUzHTm6lIoF0gzGm2OK80il9DaoOTW5JGY3O7N9sUQ6JHDTRyFftEMwUqWjWG8xdCsIRHnzqU5i7+Hs0YhEiUp7qtAqWbI/oD5ErvplicUKwXccoMDHrqXhYw2vnHEuOOxK3uds+8BYeDjdujjsO+PnPgac/vZ5oH4wsR0qGBeaE1yIR4P/+7XUc1EYSEZXaV8HysFlSmuriuDST4HNH+m3ihGACAgGBgMAECJS+Pt30xsfi3R/6LPYVvvP6n1/69gTVbZIso8iYH5fZBd2SuVYNDS98wmsXBkY57Q4eC/OLTQ1t4aVHtYYN2HUPC7ToRTyLiFMtt2Zxm5YzR811cPtjduCobVPgLQ0pLW46v8VI+8kSWYZcRPRAmAJ1DtvYd9t+NAAAEABJREFUFrpDUoY05kMp1QP8HV43NIqIrq7awAh/e0OVGpSMIPibcMsUzuyPNeRxNZYopW1ssQ4ph2IkUVHozg1FTxwQcWTyFl9aM7GAJfY53TTQgyYXW9pNZkbgQPNKWUmMqfVWcvh84HHl8w7+Hl6PqAnKNA7WSpXup0JuWwMpd02N3tMFQTfD1C0TX9aO6eagWIbGREdZN80j8I1Eh+rR8cEKCAQEAgIlEJAl8uqsT3vcOUR2F3DaPZ+EZ7/0jXjtWz+IRz3jFXjj+R/D3c+8NU680TE636a2Rl28ebFjw8A4Emff4E6qvtlMspT/9QW7MFA0MksaXvf0z+JHOEkvFBxf17QsV+B1zix+CjGt3Fy1+4JDlTpmOzFuuHMGvJgxL8tSS7IcVk6oyrUvIm2S9lS17BgV9/DCx7Oq7EK5WOREcw2dUuRjLRVnYUJUh7ixDEUMI8pTsKadw6NMan+OF5R3VPpKcTS8o7NYDDlRgOaBSoECCea0SY2wZcd+pcESXsawlYhJxS7JN7V9xGWPJrCwc01vQVlSavII7ofe0oAEan7wHV5l+8eSVCyRVBwP7M+/ww7Dq5/0WVMjsVy6vzV+Gm/toTjtkiVjHpmK4+KujSSnf7i7RDsu7Lhzp58neAICmxSB0O3yCIy48i8vhF9g+7d3vhxn3/FUfOt7P8E73/9pXHn1tfiTP7o3XvLnj1m+8GZJ9RY212Ve7L7xG/v4zy7cvX1GCxvX0PBKX1vFK4KrkBZw9qbKaM3aNQgCy3HG8UHuwmKmwGsSL9xc9Yhuu2KlXF440zEaXuQkihZHSYZ81Q9L1op7eKs+9l+uIUwGNVCUiSkBa6lA7Wd/0qpIEEgWH0pGkKThzXggOGKE6fWUibV9NoHJ7VZs5pAuQe3WLluePO6j3rYReXk5TwkjYoNFzpPLL+f6ZuMzRGBC6Wcp488je9fmF6IJbFECjw1q/BHvM08pQFpLt1+f5fknCPl3TI1oB+dba8aOP2/5SAknbh7zXI2XDXOcIBIfVSXxy80bO/5pKjWuCH8BgYBAQKACArJCGdz4hBvgDS9/Jr78sX/ADy86H//x/lfjz574EGzdMlNF3MYr85jHYO9iD7u3HNzvmwJRAkcWskzHZ13jJp1Kw6Bl5K22drVlFwb2O9KQgRZdihDVq6DSgyOxmlXuwkIv03qemPqlcoGm6mAe1UstcfIWVK3FpJVWCSASYtCoKj67wMaFLyiAK68ib5kyvKVBA0V5FM0DTXjJz0erpdipbHISJkdqeAcisx7fJQDfutWjBpFlfKOw5jfmLIYsimY3Ir4b8eI4voxR0sxV2KcT/bJuXvOko8gcEoXtwyjzp0YVpnnGnzzTcmS9uUVcFrwtp0ca3uEtDYOTMJkGphI7x3Wla9dSrp00DpmZSm46w93IcetlLGhkUO1v1Lyh+rQwGht201yCpjt7gwkIBAQCAqURGFyBSxS9+prr8eVv/AD/cdG3lpheakhcCXEbMisvmVnc6vctI6IDbQDYhTtdSCkAJDW2NKT+Z8ncAkFShTIrU0o0hIL0+JTt+sZ9VaBLTV/Mcr3exUQQuEtSqvoVkAR+bJnS4kbeoYOls5YpFxEiKYfSSgcssV2q4Y1Ki1qpAD8iz+3YZzQeMakAuQ850YNp87GGlUSMTc9JWylZw0s3AuMypXZ7SESEZFyeZeN9MuL8jH+BCAumQS59WYGjE0XEZw2lZSlZ3uHmNU8yis4Iw1GclZImOjrTg/OyX8DVwRE1p1YkIyRUBRNesTDPErVR0gj+LY7C1pPn0E5MWCeuYUu6FwAIo64bgxHzTbQkXWcq9smej/D/CvMrzSKMyuYXCf6AwEgEQmRAgBAofXX6/o9+jjPO+VM8+fmv0Xt4eR+vb/Z5e9ZI/qY9BC1u/ktCSpAyxF3As0zjki2m2m1PU6L2lbdU7D0WtXuCWYpIjezvf8Mwqrgq2WFhnpmeMVOGH5N39YY+RYuQBCthaJ33clb3xjHonsDUQ56+oJwX2cxQR+LY/fhKHkvMIn7RyhfQ8vD042v4pSBqa29AFMmhqUH0l33AljmKqHPQI2S9h9eIGylp0d5Y+VNlZMZxkUR0+knOrzsxmLeCyC63Axzfz1zOI2Mz5sp74VJLcHXaOZ1DkoZXoerfjQ4dATqfkzyJSah05yn5qxzM21nDm9qnK30Z0uD1QTwU0w+4CabtVoF++lr1uGtHDtDpN9xKxs3GSOo478G3wXLOqHnjZFs3pRs3vhkuJzjkDggEBAICBgGzwhj/RPY73v8p/WLa+970Yp3/o//01/jqJ9+o9/SedftTELY1aFiI3SpkrOZxQSFJG2oXaXsBd4Q3nvO2Jdj8kzpZuzPIahfsPUSknYb3+98220wsvxvkregjfqVLshJugbT53KOYCEKeCZCj0+paTBa6qZ2ajuyQUK6LQEQuI4xaHynL5AezasptNbzks0dTQFlx7ESCWk4H+xWRNb1oE1g5+bds4djqRlE/eKz1do8xYlJz7wNZlWBJOZBM7dYBisucX0eAepOD7n5sqLwj+pMrGy5s57W+q6KUDBHaNfY+t6fMTSD8P6pD2f4oS0z95DJ+SeV5jzFreP1yiuYthxWEhmmmTXd2HLHGjbBbGhiflHAaaq53fspEVN+mMcF5l9MMo+k+VH0IBAQCAgGBSRGQk2Z0+S7+xe9wzr3uBP48GcdlRN6Y5D7uYffEF77y37jyavtiFiduYsP785iMOAiyXOAH3zLE9ro95s3tlIgpp09NK3YqGV+L7H7I4re7FiCIjLLAnBYJdpt6aS2WZsrs6+ZYJA1vQos7y+d1TxM5DtQ0EfGANDP1+Bpe3s7A5I7FR6RRZLeysQvskj283k1KZdl+QSJXkcghGCCKJx+ihDz22L5NWV9Fh/oRqx6WfWlt0dThtqNUrGm4GM0D5j692NxwCRoP/UtrFD+ccfJQRI/EObfqFQgvR7KxTzAUEcY687k96l2DLKPTJ+VaYKe09lexIiLuUaKQjtHw5pDgsZh1WwWwtv9kYs5F/orFFXsWkfKTFhpv3WqeBNoDRDSv5zp08tpwKWfUvLHnjLsGKBr3uKVKiQ2ZqyAQygQENiYC5kpWom9ZluvcMS20Rx1+MH52yW91eMc285jwt5ddqcPBAnJvo2FKGstPvNuq81LzdYbpi3+gYWoZzqD9Za281RoUoUWbA8k3v4HTXvA09vYX3Y4lEzqyhmWVYJgnErWYKsR2ocozoC5RcM3iR++pI7xu0aNEnnmKbhxAjYhkRDE1Dpq/XDqBGQv2a2Pjtb8Ji9oqkdO/0NKUEuAf1pDEC2QssG0Hav3lpPKKVNr/QYBRwnr2pbUoqYgZ9aEv1/ml1JtBcphLCPdRKBqhGvjFpCHU9Vhiq/1sOVKV0SSjcEYaXv9dTYoqdUyNIppUR8/eJKLmRGZEmNAWNbyAnQPk8s0hf4oP6+BPtMy8Wdgn8JSHbsFvLnPnjKKeqH4PRMI97wfLeey8+T0OGpRTVrZ1c0g6dwbJwRcQCAgEBMogUPoKdeRhO/Gjn/1S13H6aSfjTed/DF/4r+/ire/5hI77g+NvoN1gAT4Z5Yt1HxNaXNk/+5sfs4OpGp8lS0dsaVDex+5dvcRPdF11LZ4wrIHtEdldJIIQWQLEXERwYt0KqDyTgW4akY8OixX5zEFhRRXV5CQAEUUWWPzhCeG+u8aJTRgCnsmgZDJI8ng8eG2PiOzy1g1JcbUO6gdrVrXSbYyg1BFeqnNMluWj7Rhzpl9cs48dgPrFv7bFY2EigIhofR1GEttfQFO91Ik0riU8sHszGMPEkWOTo5Q9Ugup6xBajqC+aU9Fi/exRqTtTAsaXmXlcvv5fm3K7lmuWM3+K2bPCUVPdH747RauvlYN6qbz0QWcht6FS7k0jzl/ETOO421M7Cqi1/zCJ/uDCQgEBAICZREovd4++D5n4ohDzV34Ux59f/BLas940Rvw8f/4Cp7z5IdhdmaqbBs2bn7vBagcmvbovv7yx2Zh1QGypqdzsqsdQ59YcoTAI7wZ0RCWzCSL3bpGUD+YkHJVC0SkYss8VS7qcB34f6wdY424jvMWVH5pTRNHgi+SpaeuFte37AIbaT2liX0lXoBL71vx011GxFKb2imFcg+AyRWIiQzpjEQkI1mvHzKW4O/fmsfMWuoSK+2a+dWqse/VCVXOQxMqIwKSM3OzcdwOJsI2WNpJLOHVj7Cnp5eW50lHsTnNwdkZRb7qR5e/C1YsrgxOot6QaKmj9vDCzrmc2t/u0CTWOde+Jd28Uaatv9+VaQ8HeZuDDpCVmB1b5Ktw0HziUmnhJoHj3N5tRfOtf+7ohDVhhUYEBAIC6wSB0pf2e519Gzz1sQ/Q3Ttk5zZc+JHX40Nveym+fsGb8LiH31PHB8sgsGVusGjn9CibL9icwp+RYteZqRr3CJm/ylhCoBa7TjTRuUj77Xqi/fWsHMxxWKO7kOWII6nF5QoQDX2WjBe11G1p8AkvaeF4H68ikl37E2iWfPhbGhQtqDX5J5b8CYGICK+gtoP+uA7e0gCKV2TiqCbxIe0b96HHA0DyRx090sxxfETkmN3ShtrpyvC4dFkeAZVTZC7M+PMeXk14a0y0liO8PI99OW4OZIZo5UQYJc0Bqr7ykfMk9kvT+PDc4iivuxysZJjwpkXyZgUrCHTiSmIPSCFpx4Ug0vX//vqcbtzIqwBhbxJAfzIy1xrylj9s2QyeDFehHf+cxj1JyosOJQICAYGAACNgViv2lTS/+u0V+M8vfwef+fw3sNjt0WP5Orf3JStfJ9lFOwFsWzMlaZEw5MbXiiyggzranrzt4W4XBhoQWyv6e3hl5ZHui+p7WFaXOHVG9SWWeGQpYLkP6v4xIVxMLSNwix4JVWT4qbkSEeK6ldkFNqJbAhbLRhEREYJ9DRoCizW8uTKCeR5QFKArEmjVJLyKCC/oT/74R2SPPuyWccRV93HrthrZu66XSHlMTj8d88fdkOa0NAlka+27vZGgYOkjbltZTHhHybGENxMxIq9NpSuiAmnk7X2nMD82z3IzRtADxJHVDX+Ce8keXis3J+LW6di+Vq9iv5WUBZa5a7cCDbyu/+/+bLAJXdhzSieUtWzZoZsEnmeenJxw46dLXlTwBgQCAgGBiREofdXt9VK88G/fjns98vn40xf/A17wirfhkU//G9zvMS/sv8A2ce0bPGM0NVhUmfAomAU1UsQObd9zuojP1PlKg7cY5UwUSK7oLpJtjgxGY1JHi2wkGVsIASakaUZaHgXElvDy2mTXLNT9Swi2NDVYMRFx8rgOHaY6IzIuvpJrG+t/pUHR+NjoSiJHFiKSExFLl2Q4Pafx5jf4QTiyaVE6x1c10r6AtePvXzNWRJYqnRYnFlMdKmF5bVxckOjR2OPDH8blT3waMk9TWlfDm7RN+wS/Acn4uCbSjZX2pql2lJCoO/55ZAZ1J2kAABAASURBVG+otESyaHI5ZaXXXUqoduhtORiuQ8H0L6c5MF3jRdVqLapeKpmKdGGCSLv77DZuDuR2brFfTHDycL6RxoKewdSl87gK7fgzbt7lTmcJVkAgIBAQmBQBOWlGl+/t7/uU3q/79Mc/EP/yj+fhk+/+W7zsOY/Tyc/6y39AarUwOmKTW6pFzM1ioOhCntoFMMrdW84gRYlAp8Z+vjQZaHjz1DzyBWncbbWkv4yctxGXeQhznDQT1Hb0CW9OYbtm1a6H181ebsmCN58USXZrYCuu2S+rQfRfWlNESLhvVE2jB2PmBHId3D+qSkclsdRuZctqeJUlBaPkuI8etJKKdXkd6C4KIrxKf5Luwx/LsbDPyIxopunH2zUmQWfKjLno0eOD2Ph1f9yg2z4qArCuhjcvDjTLTu35Q/J1vTWsVluhh2RYghsrGvyZGr+uOCx09UNJ2/RD2juCvXsHdfYWBn5Z5ybUYp7TzcBAovXx2JCX0/xpQVHhCAgEBAICEyNgVquJswP//oVv4N5n3xb8wtopJ98Ixx99OB58nzPwF894BHibw69+c3kJacWsGyzsv7SmBOn4DNz83VS/p0mdhaI9ILw/ufQ6/Ob6BYjFhb74IY1JP7a6R1FR1vDmxA2Yh8SR0VrxWsjxlFz70Psfx2h4WYvIb7vbaqvXZVdOX8Ob02IbkfawutARJWkhZzLoUhSRHf46A4hEKinQjiOXVMmNWqb8coTX3Qi13MtHZWuitroirOHNcqW/+9vrCqK5pn5Oj8wkYG8lE9v2LdHw8kRjiVbDC5pygrDjqKomiwc3o1oG1UGH9gqpnVoWP6UoEl6etyx0ZrvC3Cz71oeJtkzjuzgV+ukKNZl/TFORy8cD8DG4P2nPKRcu5dJ5wvkXMbiecbho6nyOrigrhAMCAYHNhUDpSzvv1z3mqEOXoHTEYTt13PW7vdt/HbN5LcGrnu1+lkvkMHDzZ6RstI7z+ISLntj1v/UrspTWJEWEd7FfPrd19iNqephnCOI4eU4EnhjCN7+U4NHnTOHqyyIUlWZVq+LHlr2uNMU9DS9/BkvkOZjwoO6fXWB9wssipa2W/Y0YGtxI8ihQu0lgTjc+XHVMQMZUWSeuV6G0hHlx3I81UJ1ZT5ENxJZQ6kAZi8bZZV9kDS+NAX8xo9eFnr8uTeYpQH1y4bJuxz46lzzmPnly9VtVtaI6aAqWFT+UP+fvhvkxVAf3iaN4zzW7dYy+aYOnpWZhNBfYmTtIYbpVSOOEolkj4U4H+A7+EHRx0S3y7qdxDv5Nx7ElaU6zW8nwSUEFc0iy7UHzTPt4PpBH0YkfrR/YqMXhCAgEBNYSAt7VZbJmnXKzG+H8D/4Hfv6rS+n6p3Sha6/fjbe+23yH98YnHK3jgkUIeOqIHmksc3sxT1SXEu1Bi2BcQ12ZzniqIloYtr30xbjhX59nhQP7MPhSRD+yjkcxpyENH3Gb7Z0EVxLR/dZXIywuCNRZ7+D9xQmQw05NIiIuyb1FD8LMxVV27QLLXzhwMhQE2vQo2oUbcamtx1z2HRyKK7S4nPrFi7YQAk3gJdqGAXS7CuP+HOFt2bftx+UbG09tdWkL8xIpcXc6wPwzh9RJSZwjEhRrcdWRJa2O/XSBzHo8yQali8SH6nBfBxlkKufLSYZfYr6bQdFTC44T0vSJ/VVNm067dAzh5ZuCHXTuVJW9v8vxjoYchIk9FxcWTAv27hF0xigTIDu2WzbIW/6wmOdcjytt64Md/wwR/Psgly24AYGAwMZHoIke0lWsnJg//eMH6QL8ktqdHvhMPPDxL8Id7v8MfOrzX8eL/+zRmJkmdYDOESy0iLlZGDLWiNqLeQS7slKaIjIhyK16CCi8+Qbn6eIiyymkvUMWE8ihiJoB1uS2Sc17g21TWBwok4GGPkvGXIQXN91Mu9ixf4HqmiYKv9DySD4nVDF25fQ1vLzYTnfyKtLGl6GF/GgivIfhcuw+8li8JX4qZKQAGndQGmr+XXXMKfg5TkDOLHSMrNS+WBQnpU93I5EHxPhovCX4pTXWhva8LQ3TcwotIr3w8toiEztJ27aPx3yUHLqhY2H6nKk51/LCVxr2dnt0kyVYPJoYF25er7iH1/YpJq3+cQfNmLrWgd2xN0oKQrfWEd4eaft1hLVG/oKdTVvRsedjWrxJ4IKW+OZ0/eSXATkqmIBAQCAgUBYBu8JMXuzwQw/Cf37wNXjWEx6M0255Ig475CA86sF3wwff+lI8/P5nTS5oM+RsDfYJZmCaax7EDpEsESGpoeEVhOPbjrWElx8p8+ZaivOPpvbWskzWSvK6zY/mOdzzlNWsueS4uqbV4h9q4J6RJLvYkQ/Rf/0XzsAXcf2WpVtqOL2U4U5QAX8sFASmtth6Ka2Rg4ktCWKivusGx+OtRHiThCJsPPlqHb+/0WlYQAcX/+9grhUFuq80tKsSXk/g4gJreBUyGhdfw6uz8NyzuOpwSaszY86PdncPhkgn1aVFWcILqkMS+dFxfauc55rDbjhUIOebRTIcKWqcj1xeGwHklsTpMFk8v8gB+CTSnvVhTXcE3Qww4rlu8AJreBW0hl+APDoWOHhLDWUHjSmLSX3C68bduorOz6Tql0ZYeDABgYDApkagNOFltLZumcETHnEfvPalT8WbX/lneMHT/4geNUV4xnl/r395jfMEQwh4hHcRbb1oUCxd0lN2tOGLuBSVhsGUF4Ajmhd+tIPf/lJHD1k1xA/J4YAgrST/wARzGw73eoIdbZpax5kn5LCY2MWOK3DE7XcHn8jBeiZh1omhseBtnbKe1KWluTM2NieSy/ckWsPLcXaRZ29V07bv+Oy6TmrN6yg5jie27Ge/RuVZNo7a7dJ56wpreHlYep6GV1AlbOhC4LKWdme3RIMyXp39SKqD/byHN4nqjdR3z/pjFtU3/MxF5UqHZQMTmYlgXny04sbbubq2tW9tm430tYv7xK3lL3UwUjz+ikgox2lTp1/2PBkivIU5wHV5l1RdZbACAgGBEQiEqJEI1Fs1PJHX7dqDL3zlv9Fzn/bx0jarV3hX59/gBnrRYCwi8PLKPoCv6bU0vApwBOq6S3Ps3UMRGP6THo8YTqkW4nUts5y9uziQ0VQ9/BWDvZgxgr1vIGW9XMddcoNba7eWJc3Uj2E7QsK4XiEE+VbpoKHp0mNgfYNi669bE79QlNHTg0hlsHxticjcbmloVf3hCU+i2cOrqC4F/kGL3N2YUB7BX2mogV9ib0JIFMCTTHvIskRXqxQpyIQ3Eop81Y/IEiwnQdF1i5vP4SaGRtDJUHwxjtut5Td8PrLM1TQt0qo6ssv1LJKG99qrJFK64fHPH06rbOy84bnsZOxdTPHxH16O63fP6yhOi+N6464FBSsgEBDYlAiYVX9Tdn31O+0I73vxCLwTf4ytB5uLtU94cxEhshf7ai0SYEUSE0RefATvf7SCFuhRN3sdIWZ/bUPyJS069ukvut2BxCaIAkvjLQ3sLu44BLjsMvZq417MIi6hw7UsS3gYMycnaoAQOll91xtbBaGj9aLtxevIitbUlJHJGlfeZjBKTGa/4DBNmjqbXs7x2ppD4se/XkCP2HVK2n0OO2G8hxw+UXUJE7q8t7Wf1asT3DlOoLnHjogEpJCo8yfs59wuuemZWgzvSXYvRTYxj5n8qyTSsvuWxYbb349bB54WAaJo7jrSy99efuJdDsUbzts23Hrbv+HICUO2bM/b95ylqd4wwV9nYSnchlbLzHcOBxMQCAgEBMogUG/VKFPTfsq7e88+8Fcj9lN1y1fTMvsq341H4xO4H464odHsTsFoLFzhKKpzEVfgPbq8GEjkUI6JkvAcZnhrPv0lSYND0uIX0TqepabNXdLyuFRuh/PXcWPSKHH5+QLhzRYNftKmc57KxhLeDkhdZYUYDa+yoYYcwstJchpEXTWTOJ/UuUwl3akpECkQkCScSRtG/OVWw9uJaeBGpK8Y5bWTSc+1Vwv84vf7QHyEZpyZY5L6I3ifi9ffFeUWMsjIa59XZ5/wcoVURtEdT1xz24GMTF17th5MEoGMNLzIzdiLyPRJJ1S0JLVfjcFbSHPuVBS934sl9nwTNNO48vl9pv2/+HFCV5ico4yhPhtPBduOhyJi7Urz9551lfZGh9NifjHSZQhuQKARBIKQzYJA/Sv7GkFq3/yC3kN82/s8VX814tynvhxXX3P92NZ9/svfxU3PfOwSw98Z5kJnPeTPdJpPnhcWuzjtnk/W8ePIBZd1RrYN4XXhrYd6i4ONVLRIRGRssLRzu2O2o0VajxQxImREeFVfRkYxHCB+wE5jRkp6pJ0bcfvmB/VxvImtZyexKb84PQdcd50JkJ1lpi5NGClc67ALrCTK5uRIwlHWIGxOzpDrja3lU9BbGrz4ofwlA52WwYT3n6ZEOkcVzy1uo9LKxikiJNdfE2FPNwXv4cylIY5JLKH38NbBz46JbhP7YzsRLOHRDJsTI4E61YD+WlNGdkbnDQWJ6yowhuxvgo/y8Co3kVkoGSbq5EBEkp11Y6ZowvIwO8LbXTCElzvg4thfa1B4vElIPGPGhbxgwqvI4344RdHcK1xSKTUcAYGAQEBgMgQmuvL++ndX4KV/d/6y5p8/8OnJalylXO/76Ofxs0t+iws//Hp8/YI3IZISf/+Oj4ytjZY3TE918Ol/edWQaRUWqfd/7At9GZ/6z6+XeynPvlHEF+qpWYWkM1gonFAmvAm11YXLukdvnwY3mcktP553izbLyYUhI41uaSDBvPhlKXno6PpbGoiIUFTto9U2InJQ+x3ZoajU7uEV8UTTlkosc9gFthMNOsAaXq1RKhSrFXSkjYSQEpZsIEoUIIQxqPc3PcWUXYKJBxOEUdLcWFUmJDt34ooz7qpFK6rpumukJiNpj7XLUseDyTa/vm9xNZElbcbEFWG/1ei6qAHhlYg4vZ9Q3jM1S/hTsSyLyAZyejLCXeCAPW3YW8sob+xZkLJMWsambo5bD6bDW33oGsVzjNvb9Z7qcLhvKE/fX9Zj580RN8r6JTO9d5uu1HZgctInx1bb3M8UPAGBgEBAYEIE7Gq1fO7de+bxte/8cFnzi19fjqMOPxiy5kK0fEvGp/77hd/Eg+9zBg7ZuQ1bZqfxqAffFf/26S/ROqzGFuq0E/CvxvlGiMFi9Ihz7oJ//sBnsHffAjJaEN/2L5/EI84xC/9YoV6CaBkNryKSsGU7XcijgexBNoG66x8/Oc0QgamP8gmiTHQ1ddYhLaBg8dqU2i0N/G1cl8wvtzh/HTeOlS6eCdL26EVPB5F2jVpZNvB5LfBeABIb8Y8lkMuH2ddp6uZwI8bWw7JSFbEDHi/taWBgOh0iBDS/WJ7TILPfN3lm+1S1vh07cMVZd++L3EWEN6XKmIdkjh3O2206BZLXLzSJhyeWy+e19bJdVradC7mMMFXcH+vKTejObDPnZi83Y8L7RBXyWyAGAAAQAElEQVSdolxcenVzuIoRQsD/FUQtw8oVkdTB9WJN8w2md+lanB8EhH+H6I9f2c5ZbJQnY5FvqGjquqdpOV3h1tEP1JVFYL3kD+0MCKxbBCa68t70xsfiP97/6okMk80DgcavfnsFjj5y8H3WGxxxiG7Grj37tDvKuua63Xjh374dL3vtu/QPZ6R2QXV5T7/VyZoQf+RTX8QXv/4/aLcS3Pn0W7rkFd3Ye/42tz2H4IWjUErRwhiPiC9kWzZITxyRIqb/FKR6G+Ql2Rzw1hAO1jKCZoz+LFluxHQXjct2MpLQc0o5E9s7gJyJnDcmWU9pQX3CqEP1rJYYaHgT0rwKMVjM60m2pfkzCta7b5fx8HiB62HGaKIq21Ok4VUQiJDR0CuM+sstbqPSJo6zk0hRXazh5XJac8z94ABrd9m1xIW9pY1flv0WO7cvXaU0v0koJ5FT6xi8wEc3VSQpoxtaujsmH9CEfMGSihPVYijWGeHlrgg676Xd/jOW8HLGqiY24+C/6NddVFqa4r3h2ge9fct6gxMQCAgEBEohQJexUvn3e+ZLL78ab3/vBWPN/EKX1imltxp0PILJ5JQbu4+0s+wWzaEH78DjHn5PHHf04TrpeS9/C171j+/TfmcJIfDER95X1/2m8z+GJz36fhBSL2Vwfylpz8aZLDYaVkUkYW5HhlGPMjlNKIFxMjie62J3nOGXxTJE9J/B1/AqKbkoeEvDuLJl4xX1l8XyGkRKPviEl9uRUnpZmcX8id2XmpFGRxHhdem9/paG5fHKqWF0LIspy2RwWqLHjjZRC3oPNKc1ZVRnSstm6zcXUwXk0YSXXAixYhtXagdPeT2HSNN2/a58pLycyRzVxz/GNk4eJY8s6/JDmLnUIo0yv7SmqECWCaJAJp6C+uCbFFemtEvngRbCFk8yYc41RYPJshzhZS0gh+sYR3h7PdP+nJ6McD1cNegcX0k2bx/h+5Vx+QQEFN0ga3nWSgkv7aUbw3Hl1mo8Y0I90s3vLgrtsuXi2J9Rn5drP+PFuI3MAzMO7VnjsrzFxRxcxu3hzSlPnIye475MLhtMQCAgEBAoIjC4uhRT1kiYv+vLmthxRilaYmlh5P247oUzbrrzT093OLjE3Owmx+E5T36Y/gGNlzz7MXj58x4P3gecZtlQ3rPucIre63vNdbtwtzNOG0rjwJ75HsaZBWG0FnyhPu4k0iQWNT4kgB/PLtKzu3EyOJ6yja2D05mLpKTf5T28XftGPpfJLbNi7sD5mjDz3RxRrMDKtm4vwyJ1a+6gnKsDd6+JOoTdZpDSAsdkzcmcX8h0PaIll8VjgYhxL82WzcMyWVgsUna0YcI7T2U5rSmTWi0lV5BTf9iNZI6cBk0RQahbj4gy5CT3dvgaFn56cb/P3X/4R+Be99ThnG5CuN59NDfG1ZcTqdy3mOr8o/LAaiWTKYFvfn4aLJM4IjJh5jjLZ9OltowqP0ncXvsVDpajm8wTlwJMkrh81jNjpWQ0tp2cbxITtc2lb8Hu4c3ovCcIqDZAEZ9bScbCYoaUABiXL+frUuHJTY8Fcw0TyB8n90DFC8HUlhpO7e/ROU/OkoMgWXZcMsJrnjKN7ANdV1igsD9jzP4enYv8qb3Frhn3jG7pE7qcjyzvXYe57FoxoR0BgYDA2kHAXPXXTnuWtIT31z7/aedinGGiy4U4H79cx342v7n0SnYwNzut3ZWsgw/arrOkRJS0x1oxPYb8SyLEL3vO45Awo7Pxztk228I4M7NloN278zl7EI3ceypw0LbpsTJYNtfF7jjDL3nxYhCBCCEt3JyfDRMDdqkLy8ofJ3dU/GwngYyIFNDi3WlFSHsCnSlDeGc6USP1zExTBdTwnMhURMTBtWMfLZYUDf5Mkosb5U7TotlOVm5LTtpXX8MbtwRmqewomVXjktkZbvKQiRJAkhZRkKkq15U79KAWFBHnHbgGrb17+/hP//oXiL/yXzrM2nhuwNzM+LnK7ZmbTnR+J9t3O50Wi8BRN+phfq/A/D5JpJdIEBEhnWCtztT4Onx5o/xbtw7Ol8g71wTJ5vwRq/vIr6QEh+sYV9fvfhWTRODK38akTeSagBbN65Vkz0zFSOgmYFw+vlaoNg20lm4swScieZMJ5I+Te6DiQXOVRpxaD3QXpHbZkjDnPvunZ9pYrn0x4TVLuI3MM9dhEWAFgPaQxfNW0vxq2RsHnufTdLM7srx3Haai4QgIBAQCAksQGFy5liStr4i7n3kaPvTJi3Dl1ddhz955vOfDn8M597oThDCL2Pkf/Hc86hmv6HeKtbnf+f7PwFsiLr/qGvALabc55UR02q1+Hue5/Wkn4463ubkLTu4mgwWPH/dHS94wJuJI7aNr+OQyR+SMac12hFfZx9c6Gz06ZZcJKrtNGOIaYHl6/yYJ7C4C01vMote2e28putaRkAaZBeREqrUqmQNkcn4mTy5jSU79gwhIjLQvJ2kpSO5gP6YBj6fhddL0SWfJm4ur6m6d0dJ08Wxh0BfwjQ8bSlEWN/JWPmaIpHHhhB4pdxcEFuYBngM0fTl6YJZEDJJW9PnYs9/K2nWNMkV7PeNKc06bQDXb7ZvftSvSAvZeTzItXmIAqU6rYkXUdmExc+VzZQSLiOpykevEdZj8Fkfhddc/sd9qQbdb/UAdD52LXFzZp1Ls56cO7PrXNAGDIcJfQCAgEBAoicCGuXr80QPvguOPOQJ3fvCzcJt7PwU9evz5jMef04fjKiLCP7n41/3w5Vf+Ho9+5itwq3s8EWc/5NngrQx/9bzH99Mb8dzoRvjwrV+AX+A4xER2oxEaXuVWkhoV8lqRIQKTt/4+RJKXSWLC5Db1fVwSBUX/kVSw3IBwFuBPrnHaFGlH2a1r2m2hRaTUI9BjUB0gyz1KlXXvEEgWH/zDAB1BjJ0DZKKl9zoUW/O4+937AhRMvwRzLCJEYNNPreaZIqVobklAb37QF1JXAgsLWqj7+gCYROqY8taRB23RhaQla4tEelkDp4p94LsvnbOC5beP5bIhMT/+HgNGHjfp/HwUXeVo8WMRKqhgxiSjG0WlKIKOqAFCzWKL3+HNrXyHIVW1bg5BmEjS5jLBVXq/iWk6h42PbL4QkVPpmJ7G9c9/Ia64xa0GxXNSCND1hretcSQrDCJhQeSIYAICAYGAQAkENgzhnZnu4M2v/DN89ZNvxBf/7e/xr299CfgTZQ6L5z714fjWZ97ignj2kx6K7/zH2/Dv7/t/+MrH/xHvf9OL9WfVXIYvfOh1OON2t3DBvnvbU0/CDy86H5IWgH7kOM+xx2LhzU/DS74V6a9gxaOImllvx0mYKL7dVkiJHDLh1UTHlnJk2lOa2JR6jiT+wWSHpbCGd3Zrhhe85Ur80R81sxi1LOHNmMg5kkOVZb2MbCBOqAHaV89ifHgRd1LiFg9G7oLNuGef3ZejmAVRKObmSwlYQoeaf05ud8FqQFmed6NAXI5j6hnbVkk3biyICW/GL2HZeI7ThvulPRUsZu+uGMthQ+H+TVxq+qd4AlJ8nSOxWzQyulFkOYLYqLJDLxt4UiGYPRc1vPpOB5D2ET3Xu16MpOnKbdUEl7Bi/xLjMi1JmCxi91+chytPuXU/s7ITt+8SbjWr6MsOnoBAQGDzIWAvY+ui4xM1cuuWGezcsXWivLx9gT9ftm3r7ET562SSRJC3ziZLRDDpWhJZMuKwG+TghZvJ2+8vHwxpJoyGt47ipdiUWEqYl9aETkp7ArwV4CZ/uIgTb2jq0wk1rCRSunTK7c8MyeWINDXxUTLoI8dXNSpJkMCQKJaxKhpeqoNls1EwmEWsJWWiyIYT6hqaWywiW0zZMYYJF/t+/GP8zQ8fzT7QXZpxq9g07lwssmSwS8pjkRP9EYWxiCLOVtsoWx8L6nN3S7SU7S+nVTX8DW4um1nCq+HSFsHE48OJNcwUfzC2PXw+ZHwDRzJlA/JJzH49hIc5X2dc5TQDnJeAK8yFQcpEPkFjzl/gcJlzml+k4CU1r9JRguZeJOrVoQUFKyAQENiUCISrx2oPuyU1pJyAGKWZtOl1mnHiLVLwQhER7XV7DXYn2/GWu/2jFiub4SBaVp7n4DWHHB3udkGEF2jkMbCWCLgtDbkS/cWOk/jLAOzGS+8bOLq8ocfvifeVhpg0y5I7V17S+BK0iBcTm65CCMKJKsnsS33khZsH4M9p6AiybD7ylT9sPyKLfbcrdBVLRBKm5YUvLaEYJFsnckN4+n1pog4rQ9mbEEWP6S3fhZQGz6WtmjzmhB1TEEx6vSIqN3LlqOuAl28y737OFUlI5NoIzUJN/R3QnY/xgoBzvkpuS0go72KlcuiacnvTK6kNUQNjU6lxoVBAICCw7hGQ674Ha7wDbnGIiBm4F2WabvLOw0gLSosob2lQVgvakwl+cdipuqrGXvLS0sy65rY09Ij4sIY3bnAhatutHxn/Mpl9USll0mO/oBFFwraknqOkBGMG+xe3FIRoRrYVCURR3+vW8v54NFWXxT5fHGir4e5IfMJL/e03pqKnZQlvb0EQ4RUAHfD/GurTkBbXPtp2hLeRKuy45EThuPmK2S7PMQrYJPJVP9pxBFnU8EZG4ysbmr/VW1e+5Ek3T3UhaUmvDpDVg50Q5EfNgeHp6Y+7suOu7FyWsYKsWQc3M5iAQEBggyEwYXfkhPlCtqoIsJaSykaRxNaDi+wAyKVZBClL5SMizUguI/BilKamjkzESKTx80JSWXihYCQleEuDVbqACW+cKCTUv0LWysFWK9dlU+qD25OcERlxdcadSKfXtkjLF6sBSTR7eFVtsUMCvC0Nwo6HhooX7iaYFVU2s40sOrKeISXkpYllMHQkUcdxndpTwSKsuJTTrqfdiAgvxfgyd+4EjjqKIusfStIY01xjSbky89hUSF2zbeG0ysbuF87prGEZvIfXzTXpWD0nVDQJkVpVJLx2+4RIqG8V5R6oYttpaLluBUH/ir3a+FuC/Js7nVjSkpQ/dxOM/YpjAJWb+vglU3sKUWo4AgIBgYBAOQTMFaVcmZC7BALSXqETAdzkZHPhHipO8UPhCgEWwQSBtZVEQ/oS4phTAOYO/ciaHkEzRpLJ+IUlkpV2ASa8O6brE3cSp49WSzvIeMHLMh3ISQN3yg8+rv1cn/bUtYhwMmZOTNxWlv64mAbc6em+EMaOA1Qt4BNF1Pvbsi3XAoY0vISXjpyf105TVsITmYRtkS1oLb+ggDv4Bb1739uFmnOpL3zD4wivEH6lE1WzYiZWIlI1+Alugu6fPGnF/CtlaMUSsnBjtpCa85+/crJS+bWWzjyUn1b515clbeQLw5LIySMiKaHcSULFHNEFDwyF+byRqzD2JDocAYGAwCZAQG6CPh7QLvIiwcvzHxw8C8RyRFs4dUR0yShFi0WEDFyfLkoLg6ut/whdJ9S3+DNnmuyQqIV5gVYbuPMJB1OomcP9VkNGhFcxEyGxsiJhqwAAEABJREFUTHi2X/cb8oEUSUK7dS1FdwI+4Y3oBiGOmyPuxfbRkOiohOoBjZcONGC1WqbNmf/Smr1RcBre59zi34Bjj61em218ZLebqFQS/6TZJuRAZoPY7enl6NnbD0GTLWOu6Po08jwaNKOML7d1aFJFmsTrsRWdm55QRsTIvLM0Jpl3s8OZ5q0CPo4jDq4r07Y3OjTig2tMsQc153TM4yoH57ay34921wBJ05wU58VaQzggEBAohcDmzeytVpsXhFXtuTLSD5klVmhJg4mxtneBtzGlHRaR02rA5I1JLwtQtCzpR+cUYM0IOc0cpG0hnkhkZyCOCe8gVN8n7MKZE+EVl14KfO5zpO1ViPiXDkh8YkkXeesdRND8LQ1RS4y+J6lXS7+044b6BkSpfnxdD48/y1DdwfYM2BsFdLuchPnOZF8u0ZlHWXbuJolp99ve0MbuayWkMGFdpIGJ1ovML271iHzm/NYSCyZ/Rv0RvR5egz/Hl058JMc2YhSdJyxIUR1MegVontn5x/F1DO9t98vnNJ85LJuavyxsP5lWm8ba7t911xiuOoe3hNg5wvFVTESFcr64kKsPGhNFHmVvdCTdKMqadZC4cAQEAgKbFAHvarVJEVjlbrvrMz/ihH8xt/X6j/BsVGlnjh6dtmYFtm/v0fLNSwTAcrXGhKSNqJZiqx0RdYjl8Rq0YJ+WN7bFwDbJEfWeIpWOjaO1D47ERQ39wAWpinGDhUtsDeSQcqnDWibyrsphiZSUVJGkU68BgqjbyfLIk3etCpH8DitHeFFCq8jFlxjb1hbdFHDary4R2Ltb6nnGYW2SRDt1LJ63XF7RPFOWTCma0nTQ+Gek9U3A0HGeuubJL74eL8HLtJiffSfBvj0RFATaDc2B2G7N0RWQldv+RBGNP4XX09Eiku6+yCAIJdd2SSTY+fl86vsreBh3/tqMK0r3ONrL4689hFvkLg46IlgBgYBAQGByBOTkWUPOKghIS0aYSImpwX5OJ0vJ+kNwyyO24ZDjFI48chHT00qLzkUEtzY0wEO0TGfJSGFhnwAp3HRUUljYdWQNKxYSSVshA+t8gCuun8cXL/k9pNXwTk1JNPGnSMPry1FEdvxw037eCsIyY9JUsduUEXYODRFexxIWF3U1ou6LWERAWVDL+zEFngM2mpOABiZan/BSn6482fzqFit60yyHmJ83P7ASm+rq2tOzalgEMawccjiuRshpw52IXBmiKxsi1E7u/nAj22bha/SLFQ9NhmLiZOGsM9XP6KZwlqY6ThLppkuD9gcrILCfEAjVbCAEmru6byBQmuyKIBIlrEDla0NsHCgdDfyxZiRPM8xMZ1qa4sXHVtxqkJAKai9xEV1Htyu0myS5dpuyhFSIidSkfQ0vIZcryNwsfMI1oG6FkSHUTowQpj8u3JhrvwgAe/MT0w1DY7JJkLB3Nl//rKdhZRU8pfXvSupqeC3mXFWLbkZYNBNe+JjxoHFCDeNuALNc4j9f9s/4NY6GIMabW5kZov6NnI2q7ExPO6kAay31p8n8/qDeH593+zC4yc2V1AKjxLg6sE6s2OLSbuW4My7EBbjP0pbbObI0YfKYLW068W32PDfn44L9hUVBGt4EJs5mCU5AICAQEJgYgfV35Z24a2skI12fhSCLmiNHLAjCkiBKrnW0SYMn8gzTU0rLUULCiU4sQdEJNS0hBPizZKA//llhcpA0SKhZnqRFjevgl9Y4nGdEeJUiwptxEEIYPHWgjlUgaEJUkDtJ/bYeN/wxLdzUCWiD+n9unB972WuBH/7QCCS82JMtLLAD0RoQCR1R1rLYCOpE0jFzjEUoCrOrje2n9le0eN5y0Zzmr1Xs4ZDeZch27eZorfWPanZFCyJrZoYsOhbQgSa8OQUanAJ8XnQxODlSYRoeWW0p1bZujthOMsbpYFyFO+C/lrbdnwtLUyeKOedmhw/ykVafA8LOZRkBUSQ4KpiAQEAgIFAaAVm6RChQCgG+PMd2IRCCQ8PFpVkDhyMrhCSTDdLqHX9cT5fmmogzaH+7rZ3GLNsdXHsN1wIivAMC1EQlghZXJjWs5WN5KkvBNSQq5SBc/TpQx+IV1CuvRoyPl1zdaxsspBHBQ2V8zdiC8GJJN8TFwHXXsRfImb2R1+47EXUrtdiwps9peEk6Imnr0QFiJOzWMEoYkJQS4J+tVkRFz174DOSPfqSlpoipTqX9da2ZOSMnh6T/HIKeIthu1hWty/P3pFNqrw6QlVOfyIFMzHnD/vViksRcqARp27nNvHeXDfv7pknwSKh+kZBc94asJLIbcTiYNYtAaFhAYC0jYFaXtdzCdd421ojYNZwWVQUUFoVWu5nFTxKhkURycrsgKSJBbnB9goKaf9wf3sPLYh50V/O4dnaOQ82ZmGBiDW+qzPKmiMizdEH9Y1dGZvFlfy0TOYSMFEGYGV/DNo0NSxS2uoTr5XnAhhNqGuG1e+8eAo/lWazUovlKQ+Q9Kubk0sa2NYol/CcGsU/ebD9R508akFi7T/c5yOmsYXHKPk7IECGKmzlnjrthhue/5Uq6mRLgec03CY5wc511TatDpB2DuZrZvsRE3OrK3u/l7fgLpXTVjBcbHXCWHTsXrOxG5rxHburir2ewrIiU5bKpOlhgMAGBgMCmQkBuqt4egM4eu30ax+8wL2Lwsuou3q4pggiE89dxI3pkLdIeic+1GF64hR3dVsMaXrce6YrI2nl4SvYkx2R54kgiaSlcPHsS+M/0CBjs4RUcXd8UX7KSdqGtL3lYggVMWGIaM6NnAsFmOGelkJPLhRe7liTYm4Rs3mxpkEnNvlmiEVGb296Whsh+tYHrRhFPHVnO4hs1LvGLizv4xxdtZ682ap/5JEjGhFfaPuqU6tbsrMSJf7ioBWjyRmQut6RUR9a0WjSHUwwIb56beTt0k1Czjv1dnIZfV8l48VjogLPsPHfByq6duz0aml9//lrsvOhCLUrQzdW6vFnQrQ9WQCAgcKARsJToQDdj49Z/6lHbcOsb2IWb1jv/pzO516KhEYiZ8OY5oMw+V9DKJO0b1e0m9/BCwOeFNzm1iyOPtXWimT9quq7jkqkTtUCVEQ2hyMi+tCYjAlKn1LQsiXNSGhoKJ27gWs2nsBXo7/AOUmv7fDwWFmgOsEQib+zkdiOssI+kOa6SIfy5XCQl/CcGQ32x/eR8lQ3J57K7rovws+8nfQ1vbr82kRKB9PvLeasae/+BnAaGCZzgpyO2n1Vl+uV4D28PST/KEUQ+V/uR68VjcdEYUZtnsFdrxsk7OGyeQURF35RREPB3nj/05/twxNe/oAVJ0uzHTdWhJR5gK1QfEAgI7FcE7BK8X+vctJUJ6rki7SU5/UMIju0HK3sSWl0lEd6ufaNZ0SKurLQWPQq03toOiYX/aaLDj+3VllkUwHuemUj1UjM9eUvDqS9/Pma71+isUg60ZjqiolX8LBkcA6oob2wxq/nir09wniSi9vO4s+GIusZrd5/w0lzQYi1RlO1mNLwxzV/WvmvZZAn/5qMJwssTjOT2Mjv2MOeHWFikWIAJb1NfueBPBWqhVIdg+kaP0FVTY0KC23Te9eARXmX6FMWmT5Rl/RwWF8ZpbKPtzcrY9EkTrJyc7qNbMFtyuCjf6LQaeiLG8oIJCAQENhcC5gq8ufp8wHrLYCtZIB5EIMY0qFR0izW8/CjQanWnt0rYNQr+I+hSQsdkju0avvNghfs+dnfjPFHSghfT4+BeZrAiHoJ4fl+/NVEk+/46HlG4ExBUbx15Y8s6ImjlJ/xrZex3AzS24GQJMjY4ce4Fxw8s4VVuD2/HDhpnqmK4vVQuJsLR8rY0SH8smtjSYLFyY69gyGE+P0+1QxPeiO4XdKCmdaOdMzhmxzRTXapF0dMRRdreAZY1xaNNikqf8H7nSxRBQqN2M/OXRO2/w46/7LkJNqLqqCHs7BxghbtPeIX3DegRtYeogEBAICCwLALr8Mq7bH/WdKJeMwokRwizoNduOC0SglQi7sUufuwcW+0b+2vL9wQ4TSW/rHboUaSG8dKa8PLb39QdpE7DS+Qt3ru3L1p4Gs1+ZBWPHpBBQSEaGouBSOOzRMDhlrCGj7ccNFRfZG9yuLKF+ZQdgDBjT3ffIjuQSU0yYtvaIoL7pJdfrWWyJf0riO0nx1c2th5FFJRlOBdWU50hQtzQ+O+YbuHM4w+CTATVRjXR+YOGZHPbi3t4WTvN8U21n2XtN8PzdaXK7NitlG3FdGkmVZ4ptGHmLwDwi6wrlg0ZAgIBgYDAGATMlWVMYohuFgHBy6ocJh6iCZLAzSQ5nbSL9q7rOQRQ2HiAdsf56ruSFiPXBV7Q+WP9skGSwC2Mie3KWCHLBQc1eYsXBhrexgivh5GuSK7S6WA1n068/pQXB9joiutZrc6g3VYRqjFjqdm80cglU81oeEFtTuhRPctmI+xNFfth+6n9VS07Jo4cEg01kjzC20Q1Rqix+YmFID2vPsQAS5Na3Wales/b0pDDyG5NRdWFHqiSk5BZmhuNNI/Of5aTZwItb0tD1jIack4LJiAQEAgIlEVAli2wVvOvl3bl0TDkoimySIuEuO467Pjp/2ooeC+iW6Oa/A4vt941mb/+IIRgGq/rbMpqUSX82LrbM8RAkbYy3jfQ8EaWFNWtT7SGSaD0yVtd4X55GhsOKtvuuDAHOK2W8YjGvn3KiOLtLeTLF8wea/6KBwWrH7btLKAzLdjRRvh9sf3UCRUtJ0/RrGIRzs32ma9NMBFuN3gDx3XAzmGpsma3NLQFeh7hdX2JVmue6c6skkUYrSg5MufrivlWymDlBA3vSkCF9IBAQKAMAkQtymQPeesgEGlyMCALWlYSa6e2ZReJvhwiH9J+vqlJwsvy3aPFTkexUgyTPO3kcmVMTBrenntxKVeIvD28aAyzYeyFRxzLtHXFvHZsnDa0xYyeCQSbFQuvnEFY+Zxzr9nqyl5t3B5eMVNTO+baSq674eEKXJ/YjyZUr7YvKczYZDAkStLTC66D4+e2KfY2ZqQddz2PqX9NCZ7ZIvSeYyfPkd+Op5F3aQ27zYs7/XTgcO9X0EbV0BR2dg7cPP0eHoZ/7dfEmvh+IHgCAgGBgEBJBALhLQlYnex/sHMG7SQaEiE1ZRyKqhawi7YrPB3T0Fpu3SJNk4uv6851YkiroWJ+w5TXEYa6sv3yTKr5kSbH8baJuP+sHog1M+GUmqaAmYWrptARxW09kTD7neOoYcLmVbmwJzUhq+FV9usGhWln8lS0efinZk0fYm//MCxRqShWFytyJr3VgFJ61xsmnxEBnptreKSoUomcKHYK1aBoSdg4kktdGByRHPjXi++ss4DZ2eVba+f58pkmSLVybqn+Gw/CR/oFWjLt+4MnIBAQCAhMhsAg1zq88g4avy59BVIgfXVZnQ4V5MZxBCmNwCnSxBpfM3Y7MXL40TKt6fRE2JAfE9uMzVsa3PcISXEAABAASURBVB5eReTN1/BK6lsTtUhm7J6g43bMeKEGvaRtZ2ntaeAmpy5ihrcE8OAQ0eL4ukZ6c2hx0TI2wkzLXVzUTm0tv7STidocEWFr2W87C34BT9dAVgFPiil9iMRodnOY+hRMf5RVXWeIsG1bXlrusgWoT0x4Nbl2/Vy2wGSJsZB4T/wYfHPbnXUB15dIDt/06sT1YC03vi95CXDYYc30onAtc0JF+EqDgyK4AYGAQAUEzKpSoWAoUhEBOQy59AlDRZG6mCVV2s8WLeK03rKv0ZfWWKB7tMgvrWWKlnHFsc0afjHK7eHNc4XhPbzDGFatWRFx88tunW75web8dgE/6LAML3jrldixg9pPuDVWAY21kzW/LzNeKz/vpjpc+AKbjitleXUwXXPf4h2azrafpeQWMqspuiuguLxIeLs9ioXeIsBbaXSgIQu2bxEy0vDS2DQkN6YbkQ9OPQpfmbuLlpgRWWePaFLdzgL3lxlDeFWnA7z0pcAhhzTTkqFJNRDJ14RBKPgCAgGBgEA5BJq7uperd/PmLpKCYrgqMkXCS4uGpAWXxbVbzWrEnIJVJBmIi0LI5qdRFOfI7Vca0jxH5L20JhvSkKkbn4huYggW44RV6IeW64iCUVYiZrh43NnoDDUtT84e9zELS3hnf/Fj7MM02nW3tbg6yGWY+oTXTQbuQm1WTUJmzHikMJpeRxJz+4MqlAOJBpB9DRlhB4bELflONsVVPSKSq78nnfItAnANduDL8gyIrduqijyw5caNL82JRhvmzpeC0NhMiUJsCAYEAgINIrChRfHSu6E7uOY6R4ug3ybLSf2oan5mIX5Jque003t4wVuuxA2O8xPq+yO78LTaRpaw5MqEmrFj0nx3LVHA7t1DQuU0aZSGYqoF1LP+FNccfHS1wmVKFcZG0yvGjE0ZOePyenK681bDm6Y695Zf/ww5JNp2G4qOrGNRXQkRnMRuaYikGkij+EGgmk/OGsK7pLT9AQ0FgVZTfXGV0LkiCaWINLzkdbG1XR52/pGRLFVa1jdwG9xzyxfQvvnJOrzurHHj2yRoDMoIeTnN4SjJOTWYgEBAICBQCQFZqVQoVB2BwqIhHHusLtGUjC0LNSEgirBjp8JN/nAR01Mushm3Y+U5LV8zUoelxIlC2hM6Ung/OsERkWxu2ra2eLg1KJfb2TdWY5VbzbSuhhd1Nv1MNTyenK7bw0vE1EnsISGSaLB0caVd3WgAVFcEBUd4ZeKNhe1nadlegWjrrA5l9vG/DpCluuZ7wkx8YqMwpdiGDrrrlER4BfVLuX42IDomuVGi0LM3btx2Oi0bkHyARIwbX+HNgSaaVryWkUweH7u9m0LhCAgEBAIC5RFo+EpVvgGbrgQtqPMzB/W7LURNIuIkFVdSqqef1PCCNLsl06KVNBoX2bB8Fs7dSe1nyeK9ezgKu+RW7Xpd0+GqVieW6PCvAzgBTY2Fk+dc7ozzkxtLS7Kbqs+Tv7Bg51Nuxoaq0/tenTaew5WMB3pCjDMmIsdyvKqBcYSIM05oxPS0zrnzCKXdnDR72tNLtcPWahEfJlVNEt4okgSJQrcnwX/cF9nwFzpY7n4zbftIp1hhU/PYyR2aVC4SiO1pM4gJvoDAgUUg1L6+EJDrq7kboLVEHHr8ur7tiqCw9dZziouEJ1fwpxTqSR8qPT1rSFXPfibohjsNSRnKVDMQ0+NLpxlzhHe3MIQ3Fg2q+Iq41Wz3yOK2Drf1IxIKaJIk+NrcRXMzgsy6AD2oj9BOzJih7h+1OyLNpftKwxAJ8eZc5Wos4T30aNN+BdNu9z3hHJJIZMOXLeqTIO1uREiB/Gjoj5XfcQtQlqsriPVN2uw8XgJPg5hp2SPm0SLaYCx1erACAgGBgEAFBBpeOSq0YLMVoYu5klG/1yJqaAiK2rW5OfTXIcMZ+nXW9czOGTLitjQkTfXBaxh/CSLNTMNju6Vht9iiczRZnfRx6wOmq2nAsiIsUVA09hwzxW/ps58NR9Q1npzugp1PPglGgqmOqFeL7QOorlYkwFsaOjMK8OYyMdF6dVDpeOsc2XTEEVlEFiGMa7/SoCjcZiapY5uyTB0szY0R++uamDDjPbyLqRmTnMj6utbwjnlprUnMNOZDd1E6hm5FInoaY/zBDggEBAICVRAwV+IqJUOZaggQYRCkIXOFJYWdv5ZblDMz0xfX9CBv2wY8/y1X4vb32Uv0AxBSoek/XvO6i6bl8R7z0tpuYciQJowNVSgssdLiihjqyAYs7kxRDBNSMSBaxeRSYU9Ob8FuZfC2NGQgstAyWJaS62d2dVC7Y5q/fLPT6ig9/v1s/s1DP7Kkx/24QWEstv/yJ1oQ1zhl95DriCYs6k+kKRXdyBXqrSM+Isj5Kw2p3dLAbScOXEfkgS07pvGiQcx0B8fIa9N80+nBWp8IhFYHBA4wAnRJPsAt2GzV06KhIrMZ7efyhsDDH9YMAkVSRcRBWDpC63kzdVgpUkj9Mhx/V5ajYjQ/jVjDy0RNy99n9vBeD7OlgeOaMtJ+3PMTH/8ycL/7NSV2WI4lgkIIgA3ob8yiTinlD0+WfbcL8AivfmmNHq2XF+yVcHWQ26I5fNpd9uHej9lF3aE+uWzFOejiy7j2Rk1FRq6bAzuu+LmWwuGm5zOsQN7WAOqfrqgBK4YAE94c5vxgV8aqAckHSMQYDW+TmOmejZhHOWEYCK9GJ1gBgYBARQTMlbhi4VCsAgK0oAq7wF4c3Rjy3HMrCBlRpLhIeIRXUJ0jSlSOcnuCDSUBIlZlVZbWLzjkiRMFRYSBI3d8/7vsYJcyGl4daMiKWomRFMXGXQ3bw186wttkPZ7MZ135ciPZI7xMEqfawsRXtb06EiKjf3jnedzt3N1wc1mLLc5BHVnSonnLJYSdU24OcBwbDkuqn/2NGSFopilI5FBSNCY2SSRiIrjcZtAfu01ARKIOzGFv3JZUTvgtiasT4Z0vTkxOo9Nq5y4Y3IBAQCAgUBqBQHhLQ1azAF/M2ZAYRxzJW/+wMrUg/onPk06CsKNrHZ3UhJWQhs+X07R8ls3EQBENYX+y63p2cD2aJ7zSEishmiM6urG+xZ2hsCZxyi7aXF8UUWyzR6qsTI/wNqrhpea2LWbkpcPDzfaTIqsffcLryfWk8ZwgDunF1PcKIcDaXSa88M+jmqIjBb3X2YnhGw9ph8fFrSt3HOEdmg8N9GjEeaFohKanZAPC14uI0M6AQECgaQTCFaRpRFeSxwsqLRC8+PFFfKXsE6f7i8S97gU87nGmqABoPUeTf30FG8lmudQddho1zJ1y0ur4Qnfl5qU1P6623+KmxCqeCrYOoQDpD4aiiNodIAGezFa2QBF0FL7SYJtACTUPqst98EGQKAqSbY8mKrFfaUB/klnZ1mHCGEmu2UY04CjqBBPeCBmaPFkSmsR09J9UgP7kKux3J7H752hifCdpKV8jC/kUBJKwh7eASggGBAICZRBYxVW+TDM2UV66mAtasHlxrfN28xLEeGV1kYW9dpIWC5fUhJvEw4QjkrIJsUMy+KUoXuT8yDfkT8d59/m0H1Xfb3FTq7mY2zp43IWw2DFmbOr3APDkJKq7RGKKGOM+obok87gIhw/V1W5F/Rkl4mhQYpwGcJBjZd8We1MTmTmVM8P1S1G8pPPHj6rrF1JCIqc+KcDvT03BsYTW8OYknUUpqsFuGefg+jPjxpfwa7QzI+rh83NuTjVaTRAWEAgIbC4E5Obq7hroLREHYRcI0WRzrEwt0i4YwmoQJemYdHxDVuwRjlYSIYmbn0a8pTbHQG42M4tLcDx+etTtG+qFFRPbvbsNEh0reeDYOoQQRHnUIL4p3/3vD9zoRlpaG4vofujjwNVX6zBbvKWBph17qxtquyvcItLp/NKLh513Lq2Sa19ak3ZOiaIQqi/253oxvUZYIkeTmn7uAu9Fd03ipzqr1HRXxeq6Y8ZX1J5chWaPAKk9pbBjJ2ngC1ltMDgBgYBAQGBFBAaMYsWsIUMjCNCCLYgwLKIN0ST6llTpNroFQxi6IKk+Hd+Q5QjPFJHEc29xBKZ5ZW9IthPD3y91fnbzKfPjFo1/fN5iJaKIq1kdY+s4dsc0zj3lqObr4K9L3PjGWm4LXeADHwCuvVaH2WKiVVvDa+cSy+vQTQ67S0wTGFrCK+yc4u0Gfj18zjQ8ncFdezTejcNwOZrogmvvdCsGP6l4M54C3jJxFQ7WYZe+7lz/GrOajbfny1AVNEhRk4MzJDwEAgIBgc2AQJOUa+3itZZaRhdtIXn5IzJKF/HGmkZy+7KcJsZqeJushuto2f2VsmnBLNyaOAEU0QQbRGYJb8RvArnIJly7iN/v5MObkDZahq1jKJGxYzMUWSNgSUIbi+hdZz7j5qQx4R3VBJc+kWvlg9o87RFeIWgeOwG1KyFBlvBCOrnOpTQ+KL5pDa+w85nFD+rVodqWr+FlYf5pyuF1Zdx1pdhoNzeK8VXDI0AyNz6qqsRQLiAQEAgIIBDe/T0JiCAIUlExCclFg1pFn2zYhUnahUgSdWyym/GIBalJ+SwriUEPmAfTM52e5WhEFK89TVkWK6xmn1wddjx002kewA/ryBqWldUiDW++e++QIN7S4HjkUEKZgJXviggI7RVEQLWHLddP9lc1c+ZLHKmVm4vBHNAiKb5ttb863IQlB+ch7xVtQqSTkbSdD7jRLRZx7I3TQcQB8lWuttUaXbQwN0ZnKhE74lzk9x38+5IS0kLWgEBAICCgESisJjouWKuJAF3MmfByFcx52G3EkNy+HJ/8UmTkLegUrH20I6npTryKKxB/vzT37seyKfPLcYZm1e7CQIDDzbmDlOZ8UhpZ/oC7OJNS37bytmA38j3DGt4UDdwl8KfuLrwQ4P3C1FrXFRkNyCIK846ylT9mZ3HVrW6H3Yceacq6ikwIufDqs3FNOkI0O8N8De/jX3wNHvWs3U02d//KGje+DWMGf065HtL8FqLZsXGigxsQCAhsDgTsSux3NvhXFQG6cEsijBlo4W4S/YjkuYZbTdvxO6Zx+2N2YPuMp2ZyeWq4LfuVBupGDSnLF21PgfTSgwXOEd5xa+7y0pZJdbg5d5mslZPGNbrJBZzmlWuf3D1MqhohvCz8zDOBw83WD7etICaNKyfhIx8BduzQ3lpWp4Mv//OH8bMz7m/EDKaADjd876ZlwvWBQir2ziMK1z38rzIcPJvguO1mL3pduQek/Lh5/KhHNducEeeionNFkmm2oiAtIBAQ2EwINEm5NhNu1ftKF3N+SqtIR9ro9dtfjCzhnevEuOHOGbQaHmX30loimiUHPqjcnQV0+lGO8DJ2/cgmPFwRy/EIIwcbNTTmWp4/4L5fJ9a0XB0kJt49eGGNgshkAxpeFuQZyR8V5rDrx+mnc6gRk9AgR/bXJXIUJu9qPFXwxl6IAsOu2SP/5csbHzqDWxxhtmzUFHtgio/b0nDMMc22x50fcvx1AAAQAElEQVSTvlQal4iMHxX8AYGAQECgDAKF1aRM0ZC3EgJ00Y4SSxTJX0nGqEL+IuH7R+WtGddm+cQLkpismrLGFS/KTu2WhqjpD/c7okiaxXFtqR3PeI0S4hGtUcml4ry5NHX9FUNFM9E84Y2khBDe+Pv+odrLB2J6dMBbWrjkErFEhjm+UeNVIqjuJmV3vB9LaCWySdH7X5a9kV71is87D788+nZD1fAeXm+2DaWFQEAgILB/EFjvtazzK/A6hP9zn0P3S/8FrbmSDV7CiYD00XAkrh/RrGeWVMazrRjbp8e8xNJAdVOdATZXHHszXHHXB2ipsknMWOI4MsppTZlVHg/dTDn+VM5XQcMb0TgIQWPEhhvgXPbXNAyXGxZVkCtW4SZLQPRbLKKBvx9Zw+P6wSKKN3Ect64MD8yoBhfGaFSWUnEnnoh9W3YOFeEqZMNjM1RBCAQEAgIbHoHxq+SG7/qB62An5u8mCBBnQGN//mLkr7KNVTAs6EE3OxynruLj2e2zVgsO4NdHnYIrb38v8gGr9VkyLXy1LH9sXB0XXQR84QsuVN9dlvAOsKxfkZHAP5HLH9cDMxETBaAZTyIjuC0NS+SLZuoYkuL1QTRMqvzvH9M94lC16y7QGnOD6+HXWJ8K5wz/IEjDQ9NYU4OggEBAYH0gINdHMzdeKxVo5W4SfbdAHH008IxnrHvAZtoCkvTgoL8MEewnhSGb5m5MFFdjwaZ29w83NqtZD/ejX+GwJ28cNOCE7TM4/iDvBawG+9YhZuOU0qJwjpz1oH3DnWsi5LVdLINjlar8z5IV+1JF3gEtsx9upPv9oznQ97OHtAMChcmA8BcQWMMIhKatOQTCFeQADUkmiLl5C23tZrj9dftzUard6PEC4kQQ3TXTMxUx8tTkpdsE42nKZtwcm25KZlEO18FxDZMpFtk3y4x7JpJ+tqY8Jx8+h9OP2QG4PjU4l7dOJWhPKd1UVSDr7Rkd3azl+kBSRWTmHHkbOXwNb/M7qRtp4uRC3DwulvDwKyZVDhc+uK2ojsi9KFlZaCgYEAgIbGYEmr26b2YkS/ddgC/ipYuNK+C0iLQwjMuynuLbPkeLWqThFbr5cVHzo2NrWH/8x8BFF9UQMEFRR0aHSeEEBUtkWUZ2XiAPJaROnrXBeXfsQaQ9tp/v4q0TfiPas6t8yYrpRtSvsKZ/2n5o5M4P2oMjjlznlHcc4a2J0ajisjgOdCMiVnnoR7UjxAUEAgIbB4FwCTlAY6mIoAhhSFwjTXCkyhHfRoQeOCGxR3jbrRaEMlgVCVDtFh53HHDGGbXFLCugQTI4tp5lxn01Xlrrt8PNYef2E6p7pmOJQ+c64C4Vbwo7U9Xlji3pjU/TpKpjX76MYwF+2XNsG9ZDgiO8p5463FoeqOGY+qEi4SWJrdWoh+SGYy0gENoQEFh9BALhXX2MR9YwtVXg6D/IRqZVinSLgbd4V5KzRgq12oOG5CLua3iTliG+g9R14HNEYTWbusy4525urEb9TnaDhJebOZ0IRIkCCv2a8rYNo6k/KfqSRNKshnfLlJE9NU196deyTj1uHh988HAHGh57Fi7ppoddZxTNM/6FRxcObkAgIBAQKItAILxlEWsoP//k6PRsg4ugIwbObaidB0pM0jLYvBgvxyU3Ogt5bloihIk3oXVi02K96i1dZtyVbJbEDfVllfY/TycxWMtf1Oi3ZlZ3/D3uO9TNqoGTTsnxqo9divs/bldVEWunXGy3ZKwCwS12UkRLl6ZkRFyxXAgHBAICAYFxCCy9qozLGeIbR8DofhoS60jVfliMGmrxsmLa9iP9f40X4ZITzoQjvOtyzVuGjC4LQpnE5cbdzY0y8g5w3ulWDP4EXRG6mS2NnjW6l9LDbhTR0pkqWpGQOOTIDLNbKgpYS8Wchrc4nzz8mmquHHGiJ3HzY99Ue/eznFBdQCAgUAGBQHgrgNZEkXYS46CZVhOijIzIavGKDMGkrju7RRreG968q9ud9gQyu/sjavqlNV3DKlv7QzO23LhHVjO3Gt1cBbLDzeRvVT/zNVfhkKOtap8jycjl+knplQ6vD1HhUXoleV4h98uAXhVe6jrzJolpcHEMVqFzxa0liups082DaUCwAwIBgYBAeQQC4S2PWSMlojhCZ+hTBDXFusWIyVVNUWuh+My0xLNee5VuSpoCuSW88XokvG5saNHWHVoNKzI3PN/ccRYeeegnh2rIIktUhmIbCjiyY+tvSKoWc8ppGaZmh7V6q8J5vHFRDZ8/broKMdwP3cH1Zo2bx6vQN1EYh+0zbRw026CCYL1hH9obEAgI1EYgEN7aEFYUcLvbASeeWLHwiGKOcHiL94hc6ygqh/u1Ld7OwIYb7+LYv26MW7xXgRj0MbDjf+3s4bgsPaQfzZ7c1c+Bpo2tF6vQtwfd7AgcPme/62XbrXhjr/U35nhtl+a+oTHRsVhF7XpjrZxQkCO8xfnk4TehpBWzyVZhINw8W7Hk0gwhJiAQEAgIMAKB8DIKB8K8//3AC17QXM2O6K7C4tNcIyeXJCHh1ri0B2T2ybZcj4oyNyar9IKXRtXWEcsc84uRjnJW0/tSnVztujuR1eybrshYUtmJYIKN23PbmhXpXrqzw9Os8P0tzRFd15kdO1atBaJ4ou+n+bVqHQqCAwIBgQOOQCC8OOBj0EwD3GLkWGIzUg+YFEUzU0ZK15+mor+lIXLPiHXKOrGcZswRhdVo9jHHaKkykZhfGH70uypaUV0bWat9oxUVyPtqaHi9OuZ20MSjbjV1uOm6Hu/TlmDg5rEb8xvcwGRZhXkdtQqacVenqTHYAYGAQECgNALNXt1LVx8KNIaAW7Sd25jgAyMoFhKO2/zkZzl+9ANDfJLCOoj18Lc/xuTBD9ZIyFhgIR3esysckDrHKlmrQHp0SwtyaVro6FWzGq4gkuvsErscsCecAFx4IXDmmSbXEUcYdxX6uITw7o9zyPQm2AGBgMAGRWADXY036AhN2i23IBQIwqTF11o+f2J++kMd/M15bd1Ep8jWgfVi7cexSRIBhYI+seEvDxxI2Ff7M8xNfwWC+bMejdVu+P4YlJkZ4MwzgUMOMbUddZRxV8GOaR6vgtggMiAQENjECPi8YhIYQp61ioAjVaugbTkQXXbdSNpqqHomEEMR6yHgxmY122pvdKamIqQoqMFXUy1u64Vzm+5jQe4ZN7Jkq8l6vDqE24PQkPzEyo6s25DYAyvG9cURXhdusFWyeJO2CnU02NwgKiAQEFgHCATCuw4GaaImOlLlmOJEhdZ+pnj46TyiSOvL1n7D/RY6tfRqLtpWdpwIZDDbP1wThKvfRTTp2nr3F+FdlXpcHwgXVeqOigqscLjTcUO9c+Xw4i/NcMce8IAVUCifHBW/0uCALC8qlAgIBAQCAhqBQHg1DBvAaptH/lhNcrMfYXK0No6HNbyxHA7vxyZVr8qNiSMK1SWNL2llxy2JHgp3Ca7+8aWrpzgiYuuvLmhMyaJcV9+Y7JWiPZkyGr5ZqCTPKxRJc4ltequEV8X+97oxWcV5NTVj5vDvjznZ9M/iaALBDggEBNYcAuugQeZqvA4aGpo4IQJuMZow+1rN5iZmlAwT3Kj4qHOtdsBvV8Mkyhfd99txb5GGN4dDz6TKuFkSZ6QWbFt/IbZ+sCi3GK5fw5AE/kWvoYiagVZkxkJshD28Dgs3BqtIeIWds51Zgx8C4XXoBzcgEBCoiIC9mlQsHYqtPQT2B7naH722MzM2ip5+je6nWvsR68HjiIEjCqvRZiubNbyX4XA87iafxVcOv6+u6SanFEDUsQ1Ztl64JwzjxVZLKc7n1SA+rg/UQmEJKnkbOdyTCsHf2WtE4hoQ4sYgWb15lbSM7Jm23Y/u6lwD3Q9NCAgEBNYnApZWrM/Gh1YXEOAFaIMsDLHtR/GX1azip9DxNR4skrZVbG67bSjWVztn4FJ5pK7p5Fvsh9O829V1NW7xHtHGhRYE+oTX8xdyVQq6eSyQVyq/pgut5ry2539fs9vwuKxpXEPjNgECoYsHAoH9sBIeiG5t0jpZk7iai9ABgDUpbGmI1/NLa6s5Nlb29p0St7zjPNKewGLPbGUQVlu2KsPniElr+McuGqvLyXcCbT9dsBHXk9lqG81iI3JJSMtuwZGRGQuKWv/H6aeb7/GeeOLq9cWNe9FdvRqD5IBAQGCDIxAI70YaYF5UN4gmRNp+RJZ/PP3/XY2/fNcVuPFJ61BTxuPC88z9DC/7VzClk60mlHFLiHumXYHeotH2ymg/kK00Ld3kNVPAYsft2TZF4LGnIcPjAT0M63DejsPgoIOAM88EZmfH5agf7+asI7z2elBfcJAQEAgIbFYEAuHdSCPPi4RbINZ7vywJcV9pmDsow3EndRFJzR7WV+94XLjFq7loW9kyisAv+uUpaXgXJdcKyVtdtG8VLFsvnNt0FUW5xXAT9fkypcGsCbEsQ9qX1YRoVi7L3tCG5rHunxubhsdFyw7WekEgtDMg0AgC4SrcCIxrRMgG2tIw3Ypx6GxLkzdG161365DuAjwu3Am3eLO/aWNl8w0BbwPhLbULC1LXEjf8mF4L3V+W7Ve/OjcR+hENePw6fH8Dot0e3qhhuQ00bW2LKBLegN/aHq/QuoDAOkDArIjroKGr1URFmsQ0y1ZL/P6Vy4vEahCC/duLfm33uMmhfa7ouhVFI6Zsv8Qa9fC4rHbTHCEgoHhLw65rJRTM7YHgiNWq39Xr3KbrKcothpuoz5dJ+DUh0pchhIBaze0sfmUbxe/GgbCDMxulb6EfAYGAwAFBYB2yh2ZxuuBzX8PdHv6cJULPesif4aZnPhbXXr+7n7aw2MVp93yyjs9z1Y9fMx4mVm6hWDONqtcQ9zReRgbvdTlh96OGl8kBb2lY2EckC4bwJqQtrzcKy5RmMsLJzmV/k6Y4n1ejHl9msb4G+nL7Y7fjlCO3NSBpE4ngaxl3142HP0YcH8xYBEJCQCAgMBqBdckfRnelXOyvf3cF7n7uc/GCV7xt2YLv/9gX+umf+s+vY9/8Qj+85jy8SLBZcw2r3qDYfqXBrXfrcivk/hiTPkACicVMWcLbV5NXH4bxJb16x2eqkeLkOxGOALlwE64v0/c3IZtknLBjBgfPtsgXjokRcOcMjz+bVRiXidsSMgYEAgIbAoFNS3iPOGwn3vWGv8B5f/qosQP5iHPugn/+wGewd98CsizH2/7lk3jEOXcdm/+AJ7AmccWF4YC3slQDkrbS+d33eOP1yHh5XLgXvHCzuxrGyabxb7VNBWp/El5TZfO265eTXAy7+DquL5PwqyMqlG0IATcOPDbONCQ6iAkIBAQ2JwKblvDGpEE47OAd2L51/Kd1Tr/VyTjmqEPxkU99EV/8+v+g3Upw59NvOTRTlAJW23CFE9Xx/g9AvfC8VW/PRG1pCJclXFGoifqHhupvpK9RzEMI0CLeiLxRfRP2VKY6O2WfcAAAEABJREFUnIY3Q6TrVXGyImacsUrbwGSEClcpO0kZJ5+q0Ieifk5SrkweEGZaOFlKRiti5WRT9onzujKb2S2FF40D59eG37Gg6/Wk2Okyk1ohX0AgILBpELCr5Mbp76WXX423v/eCsWZ+oTtxZ4UQeOIj76tlven8j+FJj74fROGzWNfsXsRqG9DfRHWcdEtcc+Rxq96eidrSEC5Os8ucJBYCvcV0xf7tozwLabZivv3Vj2vnzUuR8wsrt71Om2iaYL6bI2kRI+aANdcvrIwF70m/bm+3NGa7bnNH7PuLF5UuN2k/F7Phvlyzt9d4Xb108I3cPROO0Z75HrpUbtJ+hHyLYJx3E26TYLG3a86Znh3+Ls2DScpxHjvtgxMQCAgEBIYQ2HCEt8dE57rduGaMUWqwuA0hMTqAs+5wCqanOiRvF+52xmlLch0018ZqG650tetYq/IHL62BlH0CNzx0bkW8ZzoxOkm0Yr791ecd26bAf1PUrlWrc2uHqwDX0WoJ7Vcw7ratUytiIelGbvtsa8V8xfbP3edumH7Fy0uXK8oZF27TOML7G5evTnzi1bFlZjIMtkwn4F9Rq1PvZiubxBJzhNsk/Z6dNfM5iekpRauFFo3RJOU4jzddgjcgEBAICPQR2HCEl7cgPP9p52KcYfLa7/0Enpgepf3lsx+Dlz3ncdAX3wnKhCzNIZC0jCwpFdxH/E3MOrJju6WBNNSr1uqOIQigOvbrHt5V65AVLL1L1CMeAUxP24QGHcKsL43O974/eAoI7MegG3ceG/6otAvvxyaEqgICAYGNhYC3mmysjq3UG6UUer0UKWmEOa/2814xDhTM7U87GXe8zc0LsSG4PxBw+1EFzdRoPX6Dl0HaHyRqcZFrgia8rRz85zS8q/qVBq5of5lHjX/BtFYTmFQ5Ab7fxQV3/yPg3yS22+B5jfAXEAgIBARqIEA0okbpQtH1FPz5Ly/FLe/6J/qzZFdcda32v+hV71xPXdgUbe1vaaCZah7Qr8Nuu8V7NZvuiBppwlqFLQ3rmvC6fjF2vp/DTRlfLuHXlNggpwYCbhx4bJypIS4UDQgEBAICRCM2Jwg3PO5I/PCi84fMK1/4xD4YX/jQ63DG7W7RDzvPbU89SZeRct3SL9eVdeG27JaGSG9pWKeYSzrNzjgDOO641cPcAUV1teyn3DL7lQa4u4bVq331JFN/+sJ9fz+yAY8v1/fXEx1K10HgjncETjgB4PFgsz+ektRpbygbEAgIrHkEaCVe820MDdzECPS3NESgp5oK6/bvoouAxzxm9Zqfpn3Zbavh5d9a05GBLGgYJrJYmzhRxpBpVRHYuROYmwOd9Ah/AYGAwHpHYG20PxDetTEOoRVjEEjaJkEreSSxXhMMdhEBR9TIbXXMjYFi0Djf/thSwfWshnF9YNm+n8NNGcKsL2q16uhXEDwTI8Dj4kwYl4lhCxkDAgGB0QgEwjsalxC7RhC4xWk9POAJu3DsoQlO2D6zRlq1BpvhtLhEDDruJsHdH6wDwjsW0Xvda6AZp76NzVcngUmVK79adTj5wZ0cATcu7IZxmRy3kDMgEBAYiUAgvCNhCZFrBYGTT83xgCddj9sdvw0nHz7+V/HWSnsPaDsUaXb/8i/RbgvdjCjRDtb1S2v3vCdw/vnQP2l25pm2Qw07TKicyECsHBIH3uWxYMMt8ceIw8EEBDYuAqFnq4SAXCW5QWxAoBEEIrvQuXWvEaEbXMiU1fC2zO9dYF0T3v0xVnaO6arCRNMwrAnrm98ELrgAeh+vP0YIfwGBgEBAoDwCsnyRUCIgsP8QiIyyEnEgIgPQV/B1Oga03287GuCvQ7QtA16h3KZN9ueW79+0gKyxjvOYuC07a6xpoTkBgYDA+kEgEN71M1absqU3O3wO97/p4Zht2V8r25QolOt0x25p+NKNHw5cdFG5wps59+mnA9u3b2YE1m7fmfSu3daFlh1ABELVAYFJEQiEd1KkQr4DgsBcJ8Y2Mgek8nVaabud65YfeqjSbrBWQMA9LufH5ze96QqZQ/J+R8CNz36vOFQYEAgIbCQEAuHdSKMZ+jICgc0XtW0uwqFHp9hxiCG+mw+Bkj12hCo8Ni8J3H7KzuMTNLz7CexQTUBg4yIQCO/GHdvQs02KwI4dCq/6yGV46B8vblIESnabCRUXWc+fb+P2b2Tjxmgj93F/9C3UERDYxAgEwruJBz90fWMiEEX2tA47GiYbYEemAuGdDK/9nYvHJ2h49zfqob6AwIZDwK6MG65foUPVEAilNgACiflIA2L3iYsN0KdV7QITKq4gbGlgFNae4fFhs/ZaFloUEAgIrCMEAuFdR4MVmhoQmASBJDY/sRZO7knQojyOTAXCS2CswYPH54BoeNcgFqFJAYGAQGUEwppYGbpQMCCwNhFI+KwmLW8kyVqbTVxbrWJCFcdrq02hNQMErroKeOMbB+HgCwgEBAICFRDgpbFCsVCEEQgmILAWEYgjc1oHpdiEoxMI74RAhWwBgYBAQGD9ImBWxvXb/tDygEBAoIBAO5b6hzq2dZJCSgiORIAJb9jOMBKaEpEha0AgIBAQWNMIBMK7pocnNC4gUB4B/lW6B93scJx06JbyhTdjCSa8YUvDZhz50OeAQEBgEyGw/wjvJgI1dDUgEBBYRwgEwruOBis0NSAQEAgIVEMgEN5quIVSAYGAwEZB4AAQ3o0CXehHQCAgEBBYLwgEwrteRiq0MyAQEFgdBN7xDuDyy1dHdpAaEAgIBAQCAsshsN/SAuHdb1CHigICAYGAQEAgIBAQCAgEBA4EAoHwHgjUQ50BgYDA5AiEnAGBgEBAICAQEKiJQCC8NQEMxQMCAYGAQEAgIBAQCAjsDwRCHdURCIS3OnahZEAgIBAQCAgEBAICAYGAwDpAIBDedTBIoYkBgckRCDkDAgGBgEBAICAQECgiEAhvEZEQDggEBAICAYGAQEBg/SMQehAQ8BAIhNcDI3gDAgGBgEBAICAQEAgIBAQ2HgKB8G68MQ09mhyBkDMgEBAICAQEAgIBgU2AQCC8m2CQQxcDAgGBgEBAICCwPAIhNSCwsREIhHdjj2/oXUAgIBAQCAgEBAICAYFNj0AgvJt+CkwOQMgZEAgIBAQCAgGBgEBAYD0iEAjvehy10OaAQEAgIBAQOJAIhLoDAgGBdYZAILzrbMBCcwMCAYGAQEAgIBAQCAgEBMohEAhvObwmzx1yBgQCAgGBgEBAICAQEAgIrAkEAuFdE8MQGhEQCAgEBDYuAqFnAYGAQEDgQCMQCO+BHoEJ6t+5tT1BrpDFIdBpRZidil0wuBMgsGNLC1KKCXKGLIxAK5aYm0nYG8yECGwlvBLCbcLsIVtAICAQEGgUgTVCeBvtUxAWEAgIBAQCAgGBgEBAICAQEOgjEAhvH4rgCQgEBAICawCB0ISAQEAgIBAQaByBQHgbh/TACEyzDJdfdQ0uu+L3yLJ8ZCNSypPnamTaZo7cs3cev7n0Suzdt7CZYSjd914vxe8uvxrdbq902c1WgLHic5PPwc3W9zL9HYcPx1925TVYDHOtDJwhb0Bg3SPQZAcC4W0STZL1yc9+FTc987F4/ds/TKHB8d5/+5yOf/t7LxhENuT7149/Abc4+49x9kOejbs87M9x14f/Of73p78Ykj6/0MU5j38xPv35rw/Fr+XAafd8ssaM8bz4F79rvKn75hfwwMe/CLe591Nwjz96Hm59ryfjb/7+PWNvGBpvQMMCf/rz3/TxYuwaFt8X94tfX4ZHPeMVuOVd/wR3e/hz8G+f+XI/bb15nv3SN/Yx++AnL1qV5v/TBz6tseJzk8/Tj64zvHgu8TnIZjXOQwf6r393pb6OXUo3US6OXb5mMm53eeizcerdngAes+t37eWkYAICAYGAwMQIBMI7MVTlMvJF+vrd5qLcSzO88/2fLiegRO7pqQ7e8qpn41ufeSu+dsGbcMNjj8Rr3/LBvoS/e8u/4lb3eCJ+/qtL+3HrwXPRR16PC979t6vWVNZ2n32HP8S/v+//4fuf/yeN4fs++nn8z48uXrU6V1PwjY47Ct/41Jvxir94wqpVc8VV1+I+j/4LHHrwdrznH16Ib//723D3M09btfpWFlwvx9+84Akas6MOPxhQzT/9+PI3vo/X0Ln4hpc/E//z+XfilS98Il70qnfiErppqNfy/Vd6tc9D7sm5T3057vmI57F3idm2dRbvfO3z9Fz76D/9Nb71vZ9gvd00LOlUiAgIBAT2OwKB8K4C5Cfe6BicerM/wIc+aTRGn/vit3Hwjm045eQb9Wu77vo94Is8a0/YPPZZrwRr6DjDc/7qzfjgJy5krzaKFuKnvfD1+CzJ0REF6753Ox13vM3NMT3VxtzsNOa2zGDb1i1wf39y7r3x+Q+9VpMUF7ce3JnpDrZQf/y2vvTvzsdnvvCNftSFX/1vPP9v3toPM6Zv+5dP4sFPeAkYVyYbrN3uZ/A8szNTePrjH4gbHHEIokjiiEMP0qlzszPaXW8Wf2WB+zTVafebzpp+1sb2I8jz5Oe/Bt/5/s/IB/ATCZ5vL3/duzVenPcb//1jnTbKetcH/x07tm3BK897op7jU50WtntzbVSZtRzH7WfMePxdOz90wUWapLowP0p/2JNeBt76wnFl5thXv/1D8PXg7DueijiKwOfqCcccgf8iIsyy1oMpex6yFpjPv/Nprtz93OeCjX89G9Xnv/+rZ+D9b3rxqCQ85D5n4ranngQeqz84/iicefop+NLX/2dk3hAZENjUCITOL4tAILzLwlM98U/+6N5463s+iX3zi3j7ez+JJzzyPkPChBRaM/bO1zxXa8oOOWgbznvlO3Sek29yHN7ynk/0H61/9wf/h4u++j2cdssb6/Rx1ic++xU86y//ET/62S/xRK++baQhOezgHUji9f+pLtZSX0s3Cw4DvnH4GT3Kd+Hv/+jnuOBzX8PjH34vvPrFT8YHPv4FfPt/fuKSR7q/vewqvPatH8QzXvQGPOXR98cNjztyZL71GMn7kr/7g58NNf2HP/0ldu/Zp+N+f+0ufQMxRTdL//A3z8TxxxyOV7/pAzptlPVf3/wB3RjsxHNe9mYwCeQbEN47Pirveo276vfX41e/u7zf/F6vp7cIZbnZG19mjrVbCSI5fJk99ujDcOkVv+/LX4+e5c7D+YVF/Pj/foXv/M9P8aJnPQqPeeg98LLXvgvuideo/h6ycxvdkO8YlTQUx0/LvvKtH+CmNz5uKD4EAgIBgYDASggMX4lXyh3SJ0aANa6HH7IDf/6yN4FJ751JK+EX3kpa2Ifd7yzML3bxPz+8GC1aGHmR4Dz3v/vtwY+OWTvE4Q9+8kI88J53XFGTdsmvLgMTmCzLsWu3ITRcfrOZlz33cbjX2bchTdAtcdYdTsHXv/OjZSFg8sf7B9ll8sYvGC1bYP0mjmz57W51UzznyQ/TWrTHEjnheThuj2tHlAoAABAASURBVCQTHdb4nX2HU/H4c++pieDj/+xV2GyYTTrH7nz7UzRGf0UadH5C8473fQr/TTewIwdig0W+4a+fqZ88/dEDz9ZPBYo3XlW6+9evfzfdrM3jUQ++W5XioUxAICCwiREIhHeVBl+SBvcJj7iPfvT2pEfdF/4jU66SH/vd7eF/jpe95nz8iLQhaZZxtDb8iJhJ74cuuBBXX3O91lg+/AFn6bTlrGc94cFaW3zOve5ERPuNy2XdNGlzs9PYRxqn5Tp84o2Owev/6um44D2vxH9c9C185sJvLJd9Q6fNTE/p/s0vLmp3lPWIc+6qH83f/cxbay36r357xbrakzqqT3XilptjtzjpBLzj755L5/F1eN9H/5Pc63HNdbtJS35QnSrXXVnemjQ/363V7jed/zF8+IIv4p9e93ywRriWsFA4IIAAwWZDIBDeVRzxe9z51mCye++73G5JLR/59JdwwrFH4pPv+lu87DmPw7kPOHsoz0PueyY+/+Xv4s3v+jhOpsd3bIYyLBM47ujD9aLqk+hlsq/pJH6EyQ10NwxJHK3aZ7BY637wQVu1dp3rXK8mTQc3T7xvtMl+8M3Br393RV9kbh/zd3tpP249ev4/e/cBH0WVB3D8PwlFIYYIKBZEEVCqiLQT9AOINCuKoPBBQMHQOxKUYpQiNYQSRJCiNJEcgnJIaAZpEjghShSP4xAF8ZBDQI6W4N38X9gYsilLSDaz2Z+fvNmZeW9m3vu+3fhn8ubtJfuvIoGBgabqgQEB9h3rPw3NzmtY6B30qSP7yPzIIdK0QS1zplrVMx+eZAo5aOHNz2HaZv/xx//MMJt5S9fIslnhUq0iwxnSGrGNAAJZCxDwZm2U7RIFCxaQPp1biY7jS3uSoCLXmYdgTpw8bebOXXb5ATdXOX3ATR/Q0DGoWf35Tu98xH97QM5fuGjmRZ239DOpW6OSeUhGz5dk3z12/ck5MSnJ/p+5s4OTS3bwoVNf6fjTmNg40Sfo77rjFm2K1Lq/osRu32PGA+pY5eWrsz8l1u69++27bhvk2PGTJojWJ7/1bqU+cGgu5kMLHR+p7dDX9Zt3mT8la/UrVSijL6JjwH879btp7wn7DqPZmY3FY43rik6zpfPv6rUWRK8zf67WmUGycbo8PUT7+uy586J/atdx3PVqVTH10c/ervjvRYe5aDs10DIZ2VxovyTa/wjRh1LHTV8ij9SvIZXvuSubZ/PeYd76HGqL1OdiYqKuiq5rMhv2YsSEuaIPwEWE95RiwUHmd5z2S5L9e83O5gcBBHJWIN+ejYA3j7r22ccbmCs3bNXPzJ17/MRJs5168USTeqJTjjW5fFcodV7qdf3l367HSKnZLNTMixoYECBvDX45pcjgke/K/U26iP5PXadE0nUNKFMKOGxFA3ed+krnxV25ZosM6d1OLMsytWxh3zU/dfqM1Huyp3TsO1aKFiksrjtzpkA6C8tKPjZtlt79fOf9FdLouX5So+krZrqosJ5tpeZ996Qt6vjtvfsOmnaoi84m0LPT06bO+v7p2aml6CwfDz3dW7bu/Mbst6zLJvZLgGvdznGtWmLZW+4/7Z9tInUfqGzeZ3qtL3bES9SYfuYJevfSzt4zeORMMzNF3+HTRIcD3VoqeZhBjWoVpE6NimaarKYvDBJ9v2XVEstK30uP6z10itz/aGdp32u0VK9STia+0UN3Oz5l+3OYgUUGu42Dvpd0LmzdeKx9mDxifyZ1XdPOPckPnXYLm2Ted9onmo4cPa7ZJAQQQMAjAQJej5g8L6TTDkXPfjPdAxZOHyo6rlcz9YE2Lbfuw4mi8+fOHDdQEmLna1ZK0rtyHVo3TfcOcUohe2X0kC6ye+1siVkyQbaunC56Hb0rameZn4jwHubcen5X0mEP4tD/itp3v/8eM0u2rJwmOu9m6gf+tN66T6dZ274qStRNHV1N0fbpHTrX9tC+L8qI/h1cm1e8Vqt0t3zx8VRzHZ2Ld8/6OdKhdbMryvjKRv3aVeXLVTPMnLKzJgwyw2Vcde9hB7xxq2fKtk+iTHCqRg0erG6y9SE1LW827MVNJULMe0Xn2bU33X704cqJI7qb+Z7XL50kGz6KkPsql3Mr5ws7Fs0YJpuWT7HTVHF9LrXeOmxGg3h9b+g8wxH2nUU10yEvmq/rnr7HtPy74wfKetspbvU78nqf9ll+nvUYJ6Tsfg51yIEaWdaf/whYvXCctHikbobN2vnZTPO+0+M0bV4xLaWs/l7TfWnTnaVLpZRhBQEEEMhKgIA3K6Fczr/tlpL2XdzCblfR+VP1T63PXb4T7FYgzQ4NRDTI1SnI0mT55OZ1hTOf31WnWdM7tNfaOMuyzOwXOhevBjrXer68PF4fDNI5ZdOrgwYvxYJzbn5hfVBL74ha1p9BTXrXdfI+ff+ULF5MAgLSb0OJG4Nz5M61fib1H7iWlf51nGzkrc+hkw2oGwKZCZDnOwIEvA7tq8CAANEHXTSocGgVqRYCCCCAAAIIIOATAgS8Du2mShXuFP12JodWj2p5LEBBBBBAAAEEEMhrAQLevO4Bro8AAggggIA/CNBGBPJQgIA3D/G5NAIIIIAAAggggEDuCxDw5r7xFVfQuSOPHjshFy4mXrE/9cbxE6fk3Hn3byXSCdg1T+c/TV0+H63TFAQQQAABBBBAIMcFCHhznDTjE85etEqqN+4sj7YZIA80fUUGhEfJqdP/TTlAv8FK56Bs8GxfqdU8VIaPn2smYdcC23clSN3Hu4vm6ZyVnfqNFZ3JQfPSpsmzlkmVhp3k9JmzabPYRgABBBDwCQEqiQACOSlAwJuTmlmcS6cnmhMxWHRuT51LVidU12/3ch02KnKBVCxfxuSv+uBtWfN5nKzZuMNkWwGWmU9226dRsnHZZNFppqLmrTB5qRd6vvcW/y31LtYRQAABBBBAAAG/FiDg9WL3t36iofzlgcpmbk/92uCG9WrIF1/GmxroMIWtO/eKfo3w9dcVEv2ChZbN68vaTTtNvh6nX2qhk9/rlwI0b1hH9FgdImEK2AsNoMdMXSQTR3S3t/hBAAEEEEAAAQQQUAECXlXIg5SYdMl8zWuVe8uaqx//z0nzql8eYVbsRZnbS4mO97VX3X627torOnWZTp6vmYcO/1t6vBYpkW/1kgplS+suEgIIIOAvArQTAQQQyFSAgDdTntzLHBX5gfx+5py5o6tXcY231W9M021NhQsXkhMnT+vqFenTtdtE08Cubcx+HQcc+upE6R/aWurXrmr2sUAAAQQQQAABBBBIFvCfgDe5vY5Yzpi/QqJXbZK5k8Pk5pIhpk7BQUXMa2JiknnVxYULF6V4SLCupiQd9jBkzCx5Y0BHebBWFbP/y68S5PDRX+Wnn4/J+Kgl8t6S5DG8kbOj5bv9h0wZFggggAACCCCAgL8KEPB6sed1WrEJMz6UeUvXyLJZ4VKtYvJwBq1CyRLJga8Grbqt6YeffpFbby6uqybFxMaJ3skdFdZZ2jzVyOzTRfm7bpe+XVrJjcWCRB+McwXPIcFFpVDBAlqEhAACCKQIsIIAAgj4mwABrxd7fMSEuTL/ozUSEd5TigUHyZFfjpukD57pw2h6x3ZB9DozB+/BH4/KJ2u3SdMGtU0NV8ZslQHhM2RIr3ZSp0Ylc5wef/bceSlnB7yh7Z8UV2rzZCNzTKfnW5g8s8ECAQQQQAABBBDwU4EMAl4/1cjlZu/cs89coVvYJGn6wqCUdOTocbN/aJ/2kvD9QTMH7xMdXrOD3VrSvFEdkxf/7QHzOnb64pTj9BwxscmzOJhMFggggAACCCCAAAJuAgS8biS5tyNmyQRJiJ3vlu4sXcpcVKci0zI6z27c6pkyekgXKXh5SMKI/h3cjtNzPdPiYXNs6kX5srebsq6hDanzWEcAgasUoDgCCCCAgM8LEPA6sAt1nl39YgkHVo0qIYAAAggggICfCvhyswl4fbn3qDsCCCCAAAIIIIBAlgIEvFkSUQABBDwXoCQCCCCAAALOEyDgdV6fUCMEEEAAAQQQ8HUB6u8oAQJeR3UHlUEAAQQQQAABBBDIaQEC3pwW5XwIeC5ASQQQQAABBBDwggABrxeQuQQCCCCAAAIIZCZAHgK5K0DAm7u+nB0BBBBAAAEEEEAgjwUIePO4A7i85wKURAABBBBAAAEEsiNAwJsdNY5BAAEEEEAg7wS4MgIIXKUAAe9VglEcAQQQQAABBBBAwLcECHh9q788ry0lEUAAAQQQQAABBIwAAa9hYIEAAgggkF8FaBcCCCBAwMt7AAEEEEAAAQQQQCBfCxDwmu5lgQACCCCAAAIIIJBfBQh482vP0i6/EYjbvU82bvkqw7Rpe7yxiIndKdt3JZh1FghkKEAGAgggkA8FCHjzYafSJP8SeHvaQuk9bGqGqcdrkw3IuKjFsnD5OrPOAgEEEEAAAX8SyE7A608+tBUBxwssm/2m7Fk/x6Roe10rPG1UH7Ot++M3zNFdsmLeaBk/rJtZZ4EAAggggIA/CRDw+lNv09Z8KVAgMFAKFkhOBexXbWRg6n32uu6bPGuZLP54va7KufMXpX2v0fb2BhkQHiW1W3STpzq+Ljr8IeH7HyT01YlmX5/hUyX+2wPmGNdi845vzLFVGnaSZm1flRnvr5TEpEuubD97pbkIIIAAAr4gQMDrC71EHRHIAYF9//xRfjxyzJwpKSlJdu/dL6OnLJBChQrKgK6tpWjR60WHP7TpGi63lioh/UNby092+eHjku8Q64Gbd3wt3cImSenbbpIpI3tLs4a1JWrex7IgOkazSQgggAAC/irg8HYT8Dq8g6geArkpMLTvizL29VBp27KxDOnVzlxqwvDu8uagl6TdM43tQLiNHDj0s/zy6wmTF/HuR1K/dlVzzKMP1zT5GvSu+GyLyWeBAAIIIICAEwUIeJ3YK9QJAS8JhAQHpVypeMgNZv2GoCLmVRclbgzWFzn262+SmJgk//jXYflu/yF57pU3UtLmHd+YoNgUzHxBLgIIIIAAAnkiQMCbJ+xcFAHnCQQGuP86CEi176Id8GqtGz9UU/p2aZWSIsJ7yMxxAzWLhAACCCDgkQCFvC3g/n84b9eA6yGAgE8IFC1ynehd4NNnzsrDde+7Ij1Up6pPtIFKIoAAAgj4pwABr3/2O632AQEnVrF7x5YSExsnOpZ3/8HDojM6LFq+TroOnuTE6lInBBBAAAEEjAABr2FggUD+EggIsDJtkGW551tW8r7Ux1pW8j7LSn59/qlGEtazrSxZsVFavjRMdEaHMVMXScXyZTK9HpkIIIDANQhwKALXLEDAe82EnAAB5whUKFtaEmLnm+EGaWu1ZMZwGTn4ZbM7qOj1ptxjjeuabV3oVGR6rM7CoNua7i13hylXrdLduimBgQHSoXUziVv9jsT+NVI+j46UrzfMNbM1mAIsEEAAAQQQcKAAAa8DO4UqZUOAQ7wqYFmW3FQiRG68teT/AAABy0lEQVQuGWKCYK9enIshgAACCCBwlQIEvFcJRnEEEEAAAQScLEDdEEDAXYCA192EPQgggAACCCCAAAL5SICANx91pudNoSQCCCCAAAIIIOA/AgS8/tPXtBQBBBBAIK0A2wgg4BcCBLx+0c00EgEEEEAAAQQQ8F8BAt6s+54SCCCAAAIIIIAAAj4sQMDrw51H1RFAAAHvCnA1BBBAwDcFCHh9s9+oNQIIIIAAAggggICHAjke8Hp4XYohgAACCCCAAAIIIOAVAQJerzBzEQQQ8EMBmowAAggg4BABAl6HdATVQAABBBBAAAEE8qdA3reKgDfv+4AaIIAAAggggAACCOSiAAFvLuJyagQQ8FyAkggggAACCOSWAAFvbslyXgQQQAABBBBA4OoFOCIXBAh4cwGVUyKAAAIIIIAAAgg4R4CA1zl9QU0Q8FyAkggggAACCCDgsQABr8dUFEQAAQQQQAABpwlQHwQ8ESDg9USJMggggAACCCCAAAI+K0DA67NdR8U9F6AkAggggAACCPizAAGvP/c+bUcAAQQQ8C8BWouAnwoQ8Pppx9NsBBBAAAEEEEDAXwQIeP2lpz1vJyURQAABBBBAAIF8JfB/AAAA///hRF3zAAAABklEQVQDAHsj/ofJtG76AAAAAElFTkSuQmCC"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "from openstef_beam.analysis.plots import ForecastTimeSeriesPlotter\n",
+ "\n",
+ "forecast = tuning_result.workflow.predict(forecast_dataset)\n",
+ "\n",
+ "fig = (\n",
+ " ForecastTimeSeriesPlotter()\n",
+ " .add_measurements(measurements=forecast_dataset.data[\"load\"])\n",
+ " .add_model(\n",
+ " model_name=\"XGBoost (tuned)\",\n",
+ " forecast=forecast.median_series,\n",
+ " quantiles=forecast.quantiles_data,\n",
+ " )\n",
+ " .plot()\n",
+ ")\n",
+ "fig.update_layout(\n",
+ " title=\"Tuned XGBoost Forecast vs Actual\",\n",
+ " yaxis_title=\"Load (MW)\",\n",
+ " xaxis_title=\"Time\",\n",
+ " height=500,\n",
+ ")\n",
+ "fig.show()\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "openstef (3.12.10)",
+ "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.12.10"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/packages/openstef-meta/src/openstef_meta/presets/forecasting_workflow.py b/packages/openstef-meta/src/openstef_meta/presets/forecasting_workflow.py
index 176cd26e4..52a4e7d8d 100644
--- a/packages/openstef-meta/src/openstef_meta/presets/forecasting_workflow.py
+++ b/packages/openstef-meta/src/openstef_meta/presets/forecasting_workflow.py
@@ -65,6 +65,7 @@
)
from openstef_models.utils.data_split import DataSplitter
from openstef_models.utils.feature_selection import Exclude, FeatureSelection, Include
+from openstef_models.utils.tuning import TuningConfigMixin
from openstef_models.workflows.custom_forecasting_workflow import (
CustomForecastingWorkflow,
ForecastingCallback,
@@ -74,7 +75,7 @@
from openstef_core.datasets import ForecastDataset
-class EnsembleForecastingWorkflowConfig(BaseConfig):
+class EnsembleForecastingWorkflowConfig(TuningConfigMixin, BaseConfig):
"""Configuration for ensemble forecasting workflows."""
kind: Literal["ensemble"] = Field(default="ensemble", description="Discriminator tag for config type.")
@@ -280,6 +281,16 @@ class EnsembleForecastingWorkflowConfig(BaseConfig):
description="Optional metadata tags for experiment tracking.",
)
+ # Hyperparameter tuning (Optuna)
+ optuna_n_trials: int = Field(
+ default=50,
+ description="Number of Optuna trials to run during hyperparameter tuning.",
+ )
+ optuna_seed: int | None = Field(
+ default=None,
+ description="Random seed for Optuna sampler reproducibility. None disables seeding.",
+ )
+
def _checks(config: EnsembleForecastingWorkflowConfig) -> list[Transform[TimeSeriesDataset, TimeSeriesDataset]]:
return [
diff --git a/packages/openstef-models/src/openstef_models/models/forecasting/gblinear_forecaster.py b/packages/openstef-models/src/openstef_models/models/forecasting/gblinear_forecaster.py
index b181b7bd5..ad20bbd39 100644
--- a/packages/openstef-models/src/openstef_models/models/forecasting/gblinear_forecaster.py
+++ b/packages/openstef-models/src/openstef_models/models/forecasting/gblinear_forecaster.py
@@ -11,7 +11,7 @@
to predict values outside the range of the training data.
"""
-from typing import ClassVar, Literal, override
+from typing import Annotated, ClassVar, Literal, override
import numpy as np
import pandas as pd
@@ -22,7 +22,6 @@
from openstef_core.datasets.mixins import LeadTime
from openstef_core.datasets.validated_datasets import ForecastDataset, ForecastInputDataset
from openstef_core.exceptions import InputValidationError, MissingExtraError, NotFittedError
-from openstef_core.mixins.predictor import HyperParams
from openstef_core.utils.pandas import normalize_to_unit_sum
from openstef_models.explainability.mixins import ContributionsMixin, ExplainableForecaster
from openstef_models.models.forecasting.forecaster import Forecaster
@@ -32,6 +31,7 @@
get_objective_function,
xgb_prepare_target_for_objective,
)
+from openstef_models.utils.tuning import CategoricalRange, FloatRange, IntRange, TunableHyperParams
try:
import xgboost as xgb
@@ -39,19 +39,19 @@
raise MissingExtraError("xgboost", "openstef-models") from e
-class GBLinearHyperParams(HyperParams):
+class GBLinearHyperParams(TunableHyperParams):
"""Hyperparameter configuration for GBLinear forecaster."""
# Learning Parameters
- n_steps: int = Field(
+ n_steps: Annotated[int, IntRange(50, 1000)] = Field(
default=500,
description="Number for steps (boosting rounds) to train the GBLinear model.",
)
- updater: str = Field(
+ updater: Annotated[str, CategoricalRange(("shotgun", "coord_descent"))] = Field(
default="shotgun",
description="The updater to use for the GBLinear booster.",
)
- learning_rate: float = Field(
+ learning_rate: Annotated[float, FloatRange(0.01, 0.5, log=True)] = Field(
default=0.15,
description="Step size shrinkage used to prevent overfitting. Range: [0,1]. Lower values require more boosting "
"rounds.",
@@ -68,15 +68,15 @@ class GBLinearHyperParams(HyperParams):
)
# Regularization
- reg_alpha: float = Field(
+ reg_alpha: Annotated[float, FloatRange(1e-8, 1.0, log=True)] = Field(
default=0.0001, description="L1 regularization on weights. Higher values increase regularization. Range: [0,∞]"
)
- reg_lambda: float = Field(
+ reg_lambda: Annotated[float, FloatRange(1e-8, 1.0, log=True)] = Field(
default=0.1, description="L2 regularization on weights. Higher values increase regularization. Range: [0,∞]"
)
# Feature selection
- feature_selector: str = Field(
+ feature_selector: Annotated[str, CategoricalRange(("cyclic", "shuffle", "random", "greedy", "thrifty"))] = Field(
default="shuffle",
description="Feature selection method.",
)
diff --git a/packages/openstef-models/src/openstef_models/models/forecasting/xgboost_forecaster.py b/packages/openstef-models/src/openstef_models/models/forecasting/xgboost_forecaster.py
index 87a956378..8717db795 100644
--- a/packages/openstef-models/src/openstef_models/models/forecasting/xgboost_forecaster.py
+++ b/packages/openstef-models/src/openstef_models/models/forecasting/xgboost_forecaster.py
@@ -9,7 +9,7 @@
comprehensive hyperparameter control for production forecasting workflows.
"""
-from typing import ClassVar, Literal, override
+from typing import Annotated, ClassVar, Literal, override
import numpy as np
import pandas as pd
@@ -18,7 +18,6 @@
from openstef_core.datasets import ForecastDataset, ForecastInputDataset, TimeSeriesDataset
from openstef_core.exceptions import MissingExtraError, NotFittedError
-from openstef_core.mixins import HyperParams
from openstef_core.utils.pandas import normalize_to_unit_sum
from openstef_models.explainability.mixins import ContributionsMixin, ExplainableForecaster
from openstef_models.models.forecasting.forecaster import Forecaster
@@ -28,6 +27,7 @@
get_objective_function,
xgb_prepare_target_for_objective,
)
+from openstef_models.utils.tuning import CategoricalRange, FloatRange, IntRange, TunableHyperParams
try:
import xgboost as xgb
@@ -35,7 +35,7 @@
raise MissingExtraError("xgboost", "openstef-models") from e
-class XGBoostHyperParams(HyperParams):
+class XGBoostHyperParams(TunableHyperParams):
"""XGBoost hyperparameters for gradient boosting tree models.
Configures tree-specific parameters for XGBoost gbtree booster. Provides
@@ -65,28 +65,28 @@ class XGBoostHyperParams(HyperParams):
"""
# Core Tree Boosting Parameters
- n_estimators: int = Field(
+ n_estimators: Annotated[int, IntRange(50, 500)] = Field(
default=100,
description="Number of boosting rounds/trees to fit. Higher values may improve performance but "
"increase training time and risk overfitting.",
)
- learning_rate: float = Field(
+ learning_rate: Annotated[float, FloatRange(0.01, 0.5, log=True)] = Field(
default=0.3,
alias="eta",
description="Step size shrinkage used to prevent overfitting. Range: [0,1]. Lower values require "
"more boosting rounds.",
)
- max_depth: int = Field(
+ max_depth: Annotated[int, IntRange(1, 15)] = Field(
default=6,
description="Maximum depth of trees. Higher values capture more complex patterns but risk "
"overfitting. Range: [1,∞]",
)
- min_child_weight: float = Field(
+ min_child_weight: Annotated[float, FloatRange(1.0, 10.0)] = Field(
default=1,
description="Minimum sum of instance weight (hessian) needed in a child. Higher values prevent "
"overfitting. Range: [0,∞]",
)
- gamma: float = Field(
+ gamma: Annotated[float, FloatRange(0.0, 5.0)] = Field(
default=0,
alias="min_split_loss",
description="Minimum loss reduction required to make a split. Higher values make algorithm more "
@@ -103,10 +103,10 @@ class XGBoostHyperParams(HyperParams):
)
# Regularization
- reg_alpha: float = Field(
+ reg_alpha: Annotated[float, FloatRange(1e-8, 10.0, log=True)] = Field(
default=0, description="L1 regularization on leaf weights. Higher values increase regularization. Range: [0,∞]"
)
- reg_lambda: float = Field(
+ reg_lambda: Annotated[float, FloatRange(1e-8, 10.0, log=True)] = Field(
default=1, description="L2 regularization on leaf weights. Higher values increase regularization. Range: [0,∞]"
)
max_delta_step: float = Field(
@@ -119,7 +119,7 @@ class XGBoostHyperParams(HyperParams):
max_leaves: int = Field(
default=0, description="Maximum number of leaves. 0 means no limit. Only relevant when grow_policy='lossguide'."
)
- grow_policy: Literal["depthwise", "lossguide"] = Field(
+ grow_policy: Annotated[Literal["depthwise", "lossguide"], CategoricalRange(("depthwise", "lossguide"))] = Field(
default="depthwise",
description="Controls how new nodes are added. 'depthwise' grows level by level, 'lossguide' adds leaves "
"with highest loss reduction.",
@@ -136,11 +136,11 @@ class XGBoostHyperParams(HyperParams):
)
# Subsampling Parameters
- subsample: float = Field(
+ subsample: Annotated[float, FloatRange(0.5, 1.0)] = Field(
default=1.0,
description="Fraction of training samples used for each tree. Lower values prevent overfitting. Range: (0,1]",
)
- colsample_bytree: float = Field(
+ colsample_bytree: Annotated[float, FloatRange(0.5, 1.0)] = Field(
default=1.0, description="Fraction of features used when constructing each tree. Range: (0,1]"
)
colsample_bylevel: float = Field(
@@ -151,7 +151,10 @@ class XGBoostHyperParams(HyperParams):
)
# Tree Construction Method
- tree_method: Literal["auto", "exact", "hist", "approx", "gpu_hist"] = Field(
+ tree_method: Annotated[
+ Literal["auto", "exact", "hist", "approx", "gpu_hist"],
+ CategoricalRange(("auto", "hist", "approx")),
+ ] = Field(
default="auto",
description="Tree construction algorithm. 'hist' is fastest for large datasets, 'exact' for small "
"datasets, 'approx' is deprecated.",
diff --git a/packages/openstef-models/src/openstef_models/presets/__init__.py b/packages/openstef-models/src/openstef_models/presets/__init__.py
index 0615a0ea4..9e75c4bb9 100644
--- a/packages/openstef-models/src/openstef_models/presets/__init__.py
+++ b/packages/openstef-models/src/openstef_models/presets/__init__.py
@@ -7,9 +7,17 @@
Provides configurations and utilities for setting up forecasting workflows.
"""
-from .forecasting_workflow import ForecastingWorkflowConfig, create_forecasting_workflow
+from openstef_models.utils.tuning import TuningResult, fit_with_tuning, tune
+
+from .forecasting_workflow import (
+ ForecastingWorkflowConfig,
+ create_forecasting_workflow,
+)
__all__ = [
"ForecastingWorkflowConfig",
+ "TuningResult",
"create_forecasting_workflow",
+ "fit_with_tuning",
+ "tune",
]
diff --git a/packages/openstef-models/src/openstef_models/presets/forecasting_workflow.py b/packages/openstef-models/src/openstef_models/presets/forecasting_workflow.py
index 028302c1b..e51653b83 100644
--- a/packages/openstef-models/src/openstef_models/presets/forecasting_workflow.py
+++ b/packages/openstef-models/src/openstef_models/presets/forecasting_workflow.py
@@ -63,6 +63,7 @@
)
from openstef_models.utils.data_split import DataSplitter
from openstef_models.utils.feature_selection import Exclude, FeatureSelection, Include
+from openstef_models.utils.tuning import TuningConfigMixin
from openstef_models.workflows.custom_forecasting_workflow import (
CustomForecastingWorkflow,
ForecastingCallback,
@@ -100,7 +101,7 @@ def tags(self) -> dict[str, str]:
}
-class ForecastingWorkflowConfig(BaseConfig): # PredictionJob
+class ForecastingWorkflowConfig(TuningConfigMixin, BaseConfig): # PredictionJob
"""Configuration for forecasting workflows.
Defines all parameters needed to set up a forecasting model, including model type,
@@ -278,6 +279,16 @@ class ForecastingWorkflowConfig(BaseConfig): # PredictionJob
default=0, description="Verbosity level. 0=silent, 1=warning, 2=info, 3=debug"
)
+ # Hyperparameter tuning (Optuna)
+ optuna_n_trials: int = Field(
+ default=20,
+ description="Number of Optuna trials to run when any search-space field has tune=True.",
+ )
+ optuna_seed: int | None = Field(
+ default=42,
+ description="Random seed for the Optuna TPE sampler. Set to None to disable seeding.",
+ )
+
# Metadata
tags: dict[str, str] = Field(
default_factory=dict,
diff --git a/packages/openstef-models/src/openstef_models/utils/tuning.py b/packages/openstef-models/src/openstef_models/utils/tuning.py
new file mode 100644
index 000000000..7ba36477e
--- /dev/null
+++ b/packages/openstef-models/src/openstef_models/utils/tuning.py
@@ -0,0 +1,660 @@
+# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project
+#
+# SPDX-License-Identifier: MPL-2.0
+"""Hyperparameter tuning utilities for OpenSTEF models.
+
+Provides dataclasses for describing hyperparameter search spaces, helper functions to
+extract and merge search spaces from annotated HyperParams classes, and a thin wrapper
+around Optuna for running Bayesian hyperparameter optimisation studies.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Literal, NamedTuple, Protocol, Self, cast, runtime_checkable
+
+import optuna
+from pydantic import BaseModel, PrivateAttr, model_validator
+
+from openstef_core.mixins import HyperParams
+
+if TYPE_CHECKING:
+ from collections.abc import Callable
+
+ from pydantic.fields import FieldInfo
+
+ from openstef_core.datasets import TimeSeriesDataset
+ from openstef_core.types import QuantileOrGlobal
+ from openstef_models.mixins.model_serializer import ModelIdentifier
+ from openstef_models.models.forecasting_model import ModelFitResult
+ from openstef_models.workflows.custom_forecasting_workflow import CustomForecastingWorkflow
+
+
+@dataclass(frozen=True)
+class FloatRange:
+ """Search space metadata for continuous float hyperparameters.
+
+ Attach to a ``HyperParams`` field via ``Annotated`` to declare the
+ range that a hyperparameter tuner should explore.
+
+ Args:
+ low: Lower bound of the search interval (inclusive).
+ high: Upper bound of the search interval (inclusive).
+ log: When ``True`` the sampler draws on a log scale, which is
+ recommended for parameters like learning rates and
+ regularisation coefficients.
+
+ Example:
+ >>> learning_rate: Annotated[float, FloatRange(0.01, 0.5, log=True)] = 0.3
+ """
+
+ low: float | None
+ high: float | None
+ log: bool = False
+ tune: bool = False
+
+
+@dataclass(frozen=True)
+class IntRange:
+ """Search space metadata for discrete integer hyperparameters.
+
+ Attach to a ``HyperParams`` field via ``Annotated`` to declare the
+ integer range that a hyperparameter tuner should explore.
+
+ Args:
+ low: Minimum integer value (inclusive).
+ high: Maximum integer value (inclusive).
+ log: When ``True`` the sampler draws on a log scale.
+
+ Example:
+ >>> n_estimators: Annotated[int, IntRange(50, 500)] = 100
+ """
+
+ low: int | None
+ high: int | None
+ log: bool = False
+ tune: bool = False
+
+
+@dataclass(frozen=True)
+class CategoricalRange:
+ """Search space metadata for categorical hyperparameters.
+
+ Attach to a ``HyperParams`` field via ``Annotated`` to list the
+ discrete choices that a hyperparameter tuner should explore.
+
+ Args:
+ choices: Tuple of allowed values for the parameter.
+
+ Example:
+ >>> tree_method: Annotated[str, CategoricalRange(("hist", "approx"))] = "hist"
+ """
+
+ choices: tuple[Any, ...] | None
+ tune: bool = False
+
+
+#: Union alias for any single-parameter search space descriptor.
+TuningRange = FloatRange | IntRange | CategoricalRange
+
+
+class TunableHyperParams(HyperParams):
+ """HyperParams subclass that accepts ``TuningRange`` objects as field values.
+
+ Pass a :class:`FloatRange`, :class:`IntRange`, or :class:`CategoricalRange` as the
+ value for any field during construction. The range is stored in the private
+ ``_instance_ranges`` attribute and the field itself keeps its declared default value.
+ ``None`` for ``low`` / ``high`` / ``choices`` falls back to the class-level
+ ``Annotated`` metadata when the search space is resolved.
+
+ This means the tuning search space lives **on the HyperParams instance itself** — no
+ separate dict is needed.
+
+ Example::
+
+ hp = XGBoostHyperParams(
+ n_estimators=IntRange(100, 800, tune=True),
+ learning_rate=FloatRange(None, None, log=True, tune=True), # → class default [0.01, 0.5]
+ )
+ # hp.n_estimators == 100 (the class default; the IntRange was extracted)
+ # get_search_space(hp) → {'n_estimators': IntRange(100, 800), 'learning_rate': FloatRange(0.01, 0.5)}
+ """
+
+ _instance_ranges: dict[str, TuningRange] = PrivateAttr( # pyright: ignore[reportUnknownVariableType]
+ default_factory=dict
+ )
+
+ @property
+ def instance_ranges(self) -> dict[str, TuningRange]:
+ """Public view of the per-instance tuning ranges extracted at construction."""
+ return self._instance_ranges
+
+ @model_validator(mode="wrap")
+ @classmethod
+ def _extract_tuning_ranges(
+ cls,
+ data: dict[str, object] | object,
+ handler: Callable[[dict[str, object] | object], TunableHyperParams],
+ ) -> TunableHyperParams:
+ """Strip TuningRange values from the input dict and store them as instance metadata.
+
+ Returns:
+ A new :class:`TunableHyperParams` instance with TuningRange values removed
+ from the fields and stored in the private ``_instance_ranges`` attribute.
+ """
+ instance_ranges: dict[str, TuningRange] = {}
+ if isinstance(data, dict):
+ cleaned: dict[str, Any] = {}
+ for key, value in cast("dict[str, object]", data).items():
+ if isinstance(value, (FloatRange, IntRange, CategoricalRange)):
+ instance_ranges[key] = value
+ # Keep the key absent: Pydantic uses the declared field default
+ else:
+ cleaned[key] = value
+ data = cleaned
+ result: TunableHyperParams = handler(data)
+ if instance_ranges and result.__pydantic_private__ is not None:
+ result._instance_ranges = instance_ranges
+ return result
+
+
+@dataclass(frozen=True)
+class ModelTuningInfo:
+ """Dataclass for model specific hyperparameter info.
+
+ Ensures that search_space cannot be empty.
+
+ Attributes:
+ model_hyperparams_field_name: Name of the field on the config object
+ (e.g. ``"xgboost_hyperparams"``).
+ tunable_hyperparams: The ``TunableHyperParams`` instance to update with
+ trial suggestions.
+ search_space: Pre-computed, non-empty mapping of
+ parameter name → :class:`TuningRange`.
+ """
+
+ model_hyperparams_field_name: str
+ tunable_hyperparams: TunableHyperParams
+ search_space: dict[str, TuningRange]
+
+ def __post_init__(self) -> None:
+ """Validate that search_space is non-empty.
+
+ Raises:
+ ValueError: If ``search_space`` is empty.
+ """
+ if not self.search_space:
+ msg = (
+ f"search_space for '{self.model_hyperparams_field_name}' must not be empty. "
+ "Pass TuningRange(tune=True) objects in the HyperParams constructor."
+ )
+ raise ValueError(msg)
+
+
+@runtime_checkable
+class TunableWorkflowConfig(Protocol):
+ """Structural requirements for workflow configs for tuning.
+
+ This protocol is used for type checking of different configs cross-package, for example
+ ForecastingWorkflowConfig and EnsembleForecastingWorkflowConfig.
+ """
+
+ model_id: ModelIdentifier
+ optuna_n_trials: int
+ optuna_seed: int | None
+
+ @property
+ def model_selection_metric(self) -> tuple[QuantileOrGlobal, str, Any]:
+ """Metric used to select the best trial: (quantile, metric_name, direction)."""
+ ...
+
+ def get_tunable_hyperparams(self) -> list[ModelTuningInfo]:
+ """Return TunableField with model_hyperparams_field_name, hyperparams_instance and search_space for tuning.
+
+ Can be inherited from TuningConfigMixin.
+ """
+ ...
+
+ def model_copy(self, *, update: dict[str, Any]) -> Self:
+ """Return a copy of the config with the given fields updated."""
+ ...
+
+
+def _get_class_range(field_info: FieldInfo) -> TuningRange | None:
+ """Return the first TuningRange found in a Pydantic FieldInfo's metadata."""
+ for meta in field_info.metadata:
+ if isinstance(meta, (FloatRange, IntRange, CategoricalRange)):
+ return meta
+ return None
+
+
+def _merge_range(override: TuningRange, class_range: TuningRange | None) -> TuningRange:
+ """Merge *override* with *class_range*, filling ``None`` from the class defaults.
+
+ For ``FloatRange`` / ``IntRange``, ``None`` values for ``low`` or ``high`` are filled
+ in from *class_range*. For ``CategoricalRange``, ``None`` for ``choices`` falls back
+ to *class_range*. The ``tune`` flag always comes from *override*.
+
+ Returns:
+ A new :class:`TuningRange` with ``None`` bounds merged from *class_range*.
+ """
+ if isinstance(override, FloatRange):
+ cr = class_range if isinstance(class_range, FloatRange) else None
+ return FloatRange(
+ low=override.low if override.low is not None else (cr.low if cr else None),
+ high=override.high if override.high is not None else (cr.high if cr else None),
+ log=override.log,
+ tune=override.tune,
+ )
+ if isinstance(override, IntRange):
+ cr = class_range if isinstance(class_range, IntRange) else None
+ return IntRange(
+ low=override.low if override.low is not None else (cr.low if cr else None),
+ high=override.high if override.high is not None else (cr.high if cr else None),
+ log=override.log,
+ tune=override.tune,
+ )
+ cr = class_range if isinstance(class_range, CategoricalRange) else None
+ return CategoricalRange(
+ choices=override.choices if override.choices is not None else (cr.choices if cr else None),
+ tune=override.tune,
+ )
+
+
+def get_search_space(
+ hyperparams: BaseModel,
+ include: set[str] | None = None,
+) -> dict[str, TuningRange]:
+ """Extract the effective tunable search space from a *HyperParams* instance.
+
+ Reads per-instance ``TuningRange`` objects stored in ``_instance_ranges``
+ (set by passing ranges directly in the constructor of a
+ :class:`TunableHyperParams` subclass) and merges them with the class-level
+ ``Annotated`` metadata. ``None`` bounds fall back to the class-level defaults.
+ Only fields where the resulting ``tune`` flag is ``True`` are included.
+
+ Args:
+ hyperparams: A :class:`TunableHyperParams` (or plain ``HyperParams``) instance.
+ include: If given, restrict the output to exactly these field names. A
+ ``KeyError`` is raised immediately for any name that is absent or has no
+ ``tune=True`` annotation (catches typos early).
+
+ Returns:
+ Mapping of hyperparam field-name → effective :class:`TuningRange` for all tunable fields.
+
+ Raises:
+ KeyError: If ``include`` is specified and any requested field name is not
+ present in the tunable search space.
+
+ Example::
+
+ hp = XGBoostHyperParams(
+ n_estimators=IntRange(100, 800, tune=True),
+ learning_rate=FloatRange(None, None, log=True, tune=True),
+ )
+ space = get_search_space(hp)
+ # {'n_estimators': IntRange(100, 800), 'learning_rate': FloatRange(0.01, 0.5, log=True)}
+ """
+ # Per-instance ranges take precedence over class-level annotations
+ instance_ranges: dict[str, TuningRange] = {}
+ if isinstance(hyperparams, TunableHyperParams):
+ instance_ranges = hyperparams.instance_ranges
+
+ result: dict[str, TuningRange] = {}
+ for hyperparam_name, field_info in type(hyperparams).model_fields.items():
+ class_range = _get_class_range(field_info)
+ override = instance_ranges.get(hyperparam_name)
+
+ if override is not None:
+ if not override.tune:
+ continue
+ result[hyperparam_name] = _merge_range(override, class_range)
+ elif class_range is not None and class_range.tune:
+ result[hyperparam_name] = class_range
+
+ if include is not None:
+ missing = include - result.keys()
+ if missing:
+ msg = (
+ f"Fields {sorted(missing)!r} not found in the tunable search space. "
+ "Check that they exist on the HyperParams class and were passed as "
+ "TuningRange(tune=True) in the constructor."
+ )
+ raise KeyError(msg)
+ result = {k: result[k] for k in include}
+
+ return result
+
+
+def suggest_hyperparams[HP: BaseModel](
+ trial: optuna.Trial,
+ space: dict[str, TuningRange],
+ current: HP,
+) -> HP:
+ """Create an updated *HyperParams* using Optuna trial suggestions.
+
+ Args:
+ trial: Optuna trial object for suggesting values.
+ space: Search space returned by :func:`get_search_space`.
+ current: Current ``HyperParams`` instance to copy-and-update.
+
+ Returns:
+ A new ``HyperParams`` instance with the suggested values applied.
+ """
+ updates: dict[str, Any] = {}
+ for hyperparam_name, tuning_range in space.items():
+ if isinstance(tuning_range, FloatRange):
+ if tuning_range.low is not None and tuning_range.high is not None:
+ updates[hyperparam_name] = trial.suggest_float(
+ hyperparam_name, tuning_range.low, tuning_range.high, log=tuning_range.log
+ )
+ elif isinstance(tuning_range, IntRange):
+ if tuning_range.low is not None and tuning_range.high is not None:
+ updates[hyperparam_name] = trial.suggest_int(
+ hyperparam_name, tuning_range.low, tuning_range.high, log=tuning_range.log
+ )
+ elif tuning_range.choices is not None:
+ updates[hyperparam_name] = trial.suggest_categorical(hyperparam_name, list(tuning_range.choices))
+ return current.model_copy(update=updates)
+
+
+def run_optuna_study(
+ objective: Callable[[optuna.Trial], float],
+ n_trials: int,
+ seed: int | None = 42,
+ direction: Literal["maximize", "minimize"] = "maximize",
+ study_name: str = "hyperparameter_tuning",
+) -> optuna.Study:
+ """Run a Bayesian hyperparameter optimisation study using Optuna.
+
+ Args:
+ objective: Callable that receives an :class:`optuna.Trial` and returns a
+ ``float`` score to optimise.
+ n_trials: Number of trials to evaluate.
+ seed: Random seed for the TPE sampler (``None`` disables seeding).
+ direction: ``"maximize"`` or ``"minimize"``.
+ study_name: Human-readable label for the study.
+
+ Returns:
+ Completed :class:`optuna.Study` with all trial results.
+ """
+ study = optuna.create_study(
+ direction=direction,
+ sampler=optuna.samplers.TPESampler(seed=seed),
+ pruner=optuna.pruners.MedianPruner(n_startup_trials=5),
+ study_name=study_name,
+ )
+ study.optimize(objective, n_trials=n_trials, show_progress_bar=True)
+ return study
+
+
+class TuningConfigMixin:
+ """Mixin for get_tunable_hyperparams for workflow configs.
+
+ Discovers tunable fields by reflecting over model_fields and returning a TunableField for every field whose value
+ is a TunableHyperParams instance with a non-empty search space.
+ """
+
+ def get_tunable_hyperparams(self) -> list[ModelTuningInfo]:
+ """Return one ModelTuningInfo per active tunable hyperparameter group for a model."""
+ result: list[ModelTuningInfo] = []
+ model_fields: dict[str, Any] = cast(dict[str, Any], getattr(type(self), "model_fields", {}))
+ for field_name in model_fields:
+ value = getattr(self, field_name)
+ if isinstance(value, TunableHyperParams): # checks if the config field contains tunable hyperparams
+ space = get_search_space(value)
+ if space:
+ result.append(
+ ModelTuningInfo(
+ model_hyperparams_field_name=field_name,
+ tunable_hyperparams=value,
+ search_space=space,
+ )
+ )
+ return result
+
+
+@dataclass(repr=False)
+class TuningResult:
+ """Result of a :func:`fit_with_tuning` call.
+
+ Attributes:
+ workflow: The fitted :class:`CustomForecastingWorkflow`.
+ fit_result: The :class:`ModelFitResult` from the final training run, or
+ ``None`` if fitting was skipped (e.g. by an MLflow callback).
+ study: The completed :class:`optuna.Study`. Raw best parameter values
+ are available via ``study.best_params``.
+ best_config: The workflow config updated with the best hyperparameters
+ found during tuning.
+ """
+
+ workflow: CustomForecastingWorkflow
+ fit_result: ModelFitResult | None
+ study: optuna.Study
+ best_config: TunableWorkflowConfig
+
+ def __repr__(self) -> str:
+ """Return a string representation of the TuningResult."""
+ n = len(self.study.best_params)
+ return f"TuningResult({n} params tuned)" if n else "TuningResult(no tuning)"
+
+
+class _TrialEntry(NamedTuple):
+ """One entry in the combined search space, keyed by Optuna trial-key.
+
+ Attributes:
+ model_hyperparams_field_name: Field on the config holding the hyperparams
+ group for a specific model, e.g. ``"xgboost_hyperparams"``.
+ hyperparam_name: Individual parameter within that group, e.g. ``"n_estimators"``.
+ tuning_range: Defines the search space for this parameter.
+ """
+
+ model_hyperparams_field_name: str
+ hyperparam_name: str
+ tuning_range: TuningRange
+
+
+def _suggest_param(
+ trial: optuna.Trial,
+ trial_key: str,
+ tuning_range: TuningRange,
+) -> bool | int | float | str | None:
+ """Suggest a value for *trial_key* using the appropriate Optuna API.
+
+ Returns ``None`` when the range is incomplete (missing bounds or choices)
+ so the caller can skip updating that parameter.
+
+ Returns:
+ The suggested value, or ``None`` if the range has no usable bounds.
+ """
+ if isinstance(tuning_range, FloatRange) and tuning_range.low is not None and tuning_range.high is not None:
+ return trial.suggest_float(trial_key, tuning_range.low, tuning_range.high, log=tuning_range.log)
+ if isinstance(tuning_range, IntRange) and tuning_range.low is not None and tuning_range.high is not None:
+ return trial.suggest_int(trial_key, tuning_range.low, tuning_range.high, log=tuning_range.log)
+ if isinstance(tuning_range, CategoricalRange) and tuning_range.choices is not None:
+ return trial.suggest_categorical(trial_key, list(tuning_range.choices))
+ return None
+
+
+class _TuningObjective:
+ """Callable Optuna objective that encapsulates the context for a tuning run."""
+
+ def __init__(
+ self,
+ combined_space: dict[str, _TrialEntry],
+ model_tuning_info: list[ModelTuningInfo],
+ config: TunableWorkflowConfig,
+ train_dataset: TimeSeriesDataset,
+ create_workflow: Callable[..., CustomForecastingWorkflow],
+ target_quantile: QuantileOrGlobal,
+ metric_name: str,
+ ) -> None:
+ """Store the tuning context."""
+ self._combined_space = combined_space
+ self._model_tuning_info = model_tuning_info
+ self._config = config
+ self._train_dataset = train_dataset
+ self._create_workflow = create_workflow
+ self._target_quantile: QuantileOrGlobal = target_quantile
+ self._metric_name = metric_name
+
+ def __call__(self, trial: optuna.Trial) -> float:
+ """Evaluate a single Optuna trial.
+
+ Returns:
+ Score to maximise, or ``-inf`` on failure.
+ """
+ per_field: dict[str, dict[str, Any]] = {}
+ for trial_key, trial_entry in self._combined_space.items():
+ value = _suggest_param(trial, trial_key, trial_entry.tuning_range)
+ if value is not None:
+ per_field.setdefault(trial_entry.model_hyperparams_field_name, {})[trial_entry.hyperparam_name] = value
+
+ updates: dict[str, Any] = {}
+ for tf in self._model_tuning_info:
+ if tf.model_hyperparams_field_name in per_field:
+ updates[tf.model_hyperparams_field_name] = tf.tunable_hyperparams.model_copy(
+ update=per_field[tf.model_hyperparams_field_name]
+ )
+ tuned_config = self._config.model_copy(update=updates)
+
+ trial_workflow = self._create_workflow(tuned_config)
+ trial_result = trial_workflow.fit(self._train_dataset)
+ if trial_result is None:
+ return float("-inf")
+ metrics = trial_result.metrics_val if trial_result.metrics_val is not None else trial_result.metrics_train
+ score = metrics.get_metric(quantile=self._target_quantile, metric_name=self._metric_name)
+ return float(score) if score is not None else float("-inf")
+
+
+def tune[ConfigT: TunableWorkflowConfig](
+ config: ConfigT,
+ train_dataset: TimeSeriesDataset,
+ create_workflow: Callable[[ConfigT], CustomForecastingWorkflow],
+) -> tuple[ConfigT, optuna.Study, dict[str, Any]]:
+ """Generic hyperparameter tuning for any TunableWorkflowConfig.
+
+ Args:
+ config: Any config implementing TunableWorkflowConfig.
+ train_dataset: Dataset used for all trial fit calls.
+ create_workflow: Factory that builds a CustomForecastingWorkflow from config.
+
+ Returns:
+ (best_config, study, best_params)
+
+ Raises:
+ ValueError: If no hyperparameter field has tune=True ranges.
+ """
+ model_tuning_info = config.get_tunable_hyperparams()
+ if not model_tuning_info:
+ msg = (
+ f"No tunable hyperparameters found on config '{config.model_id}'. "
+ "Pass TuningRange(tune=True) objects as field values in the hyperparams constructor."
+ )
+ raise ValueError(msg)
+
+ target_quantile, metric_name, _ = config.model_selection_metric
+
+ # Aggregate search spaces across tunable hyperparam fields.
+ # Use prefixes to avoid collisions.
+ multi = len(model_tuning_info) > 1
+ combined_space: dict[
+ str, _TrialEntry
+ ] = {} # trial_key -> (model_hyperparams_field_name, hyperparam_name, tuning_range)
+ for tf in model_tuning_info:
+ for hyperparam_name, tuning_range in tf.search_space.items():
+ trial_key = f"{tf.model_hyperparams_field_name}.{hyperparam_name}" if multi else hyperparam_name
+ combined_space[trial_key] = _TrialEntry(tf.model_hyperparams_field_name, hyperparam_name, tuning_range)
+
+ # Build and run the Optuna study
+ objective = _TuningObjective(
+ combined_space=combined_space,
+ model_tuning_info=model_tuning_info,
+ config=config,
+ train_dataset=train_dataset,
+ create_workflow=create_workflow,
+ target_quantile=target_quantile,
+ metric_name=metric_name,
+ )
+ study = run_optuna_study(
+ objective=objective,
+ n_trials=config.optuna_n_trials,
+ seed=config.optuna_seed,
+ study_name=f"tuning_{config.model_id}",
+ )
+
+ # Reconstruct the best config by applying the best parameters per field
+ best_config = _reconstruct_best_config(config, model_tuning_info, study)
+ return best_config, study, study.best_params
+
+
+def _reconstruct_best_config[ConfigT: TunableWorkflowConfig](
+ config: ConfigT,
+ model_tuning_info_list: list[ModelTuningInfo],
+ study: optuna.Study,
+) -> ConfigT:
+ """Returns the best config using the optuna study results for all tunable fields.
+
+ Args:
+ config: Any config implementing TunableWorkflowConfig.
+ model_tuning_info_list: list of :class: ModelTuningInfo per model,
+ study: :class:`optuna.Study` completed with trial results
+
+ Returns:
+ :class:`TunableWorkflowConfig` with the best best hyperparameter values.
+ """
+ multi = len(model_tuning_info_list) > 1
+ per_field_best: dict[str, dict[str, Any]] = {}
+ for trial_key, value in study.best_params.items():
+ if multi and "." in trial_key:
+ model_hyperparams_field_name, hyperparam_name = trial_key.split(".", 1)
+ else:
+ model_hyperparams_field_name = model_tuning_info_list[0].model_hyperparams_field_name
+ hyperparam_name = trial_key
+ per_field_best.setdefault(model_hyperparams_field_name, {})[hyperparam_name] = value
+
+ best_updates: dict[str, Any] = {}
+ for tf in model_tuning_info_list:
+ if tf.model_hyperparams_field_name in per_field_best:
+ best_updates[tf.model_hyperparams_field_name] = tf.tunable_hyperparams.model_copy(
+ update=per_field_best[tf.model_hyperparams_field_name]
+ )
+
+ return config.model_copy(update=best_updates)
+
+
+def fit_with_tuning[ConfigT: TunableWorkflowConfig](
+ config: ConfigT, train_dataset: TimeSeriesDataset, create_workflow: Callable[[ConfigT], CustomForecastingWorkflow]
+) -> TuningResult:
+ """Create, tune and fit.
+
+ Args:
+ config: Any config implementing TunableWorkflowConfig.
+ train_dataset: Dataset used for fit.
+ create_workflow: Factory that builds a CustomForecastingWorkflow from config.
+
+ Returns:
+ :class:`TuningResult` with the fitted workflow, completed study, and best config.
+ """
+ best_config, study, _ = tune(config, train_dataset, create_workflow)
+ workflow = create_workflow(best_config)
+ result = workflow.fit(train_dataset)
+ return TuningResult(workflow=workflow, fit_result=result, study=study, best_config=best_config)
+
+
+__all__ = [
+ "CategoricalRange",
+ "FloatRange",
+ "IntRange",
+ "ModelTuningInfo",
+ "TunableHyperParams",
+ "TunableWorkflowConfig",
+ "TuningConfigMixin",
+ "TuningRange",
+ "TuningResult",
+ "fit_with_tuning",
+ "get_search_space",
+ "run_optuna_study",
+ "suggest_hyperparams",
+ "tune",
+]
diff --git a/pyproject.toml b/pyproject.toml
index 15a43c8cc..b50e3d487 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -29,6 +29,7 @@ classifiers = [
dependencies = [
"openstef-core",
"openstef-models[xgb-cpu]",
+ "optuna>=4.7",
]
optional-dependencies.all = [
diff --git a/uv.lock b/uv.lock
index d6360eecc..a8c24e62d 100644
--- a/uv.lock
+++ b/uv.lock
@@ -172,6 +172,20 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", size = 13929, upload-time = "2024-07-26T18:15:02.05Z" },
]
+[[package]]
+name = "alembic"
+version = "1.18.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "mako" },
+ { name = "sqlalchemy" },
+ { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/79/41/ab8f624929847b49f84955c594b165855efd829b0c271e1a8cac694138e5/alembic-1.18.3.tar.gz", hash = "sha256:1212aa3778626f2b0f0aa6dd4e99a5f99b94bd25a0c1ac0bba3be65e081e50b0", size = 2052564, upload-time = "2026-01-29T20:24:15.124Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/45/8e/d79281f323e7469b060f15bd229e48d7cdd219559e67e71c013720a88340/alembic-1.18.3-py3-none-any.whl", hash = "sha256:12a0359bfc068a4ecbb9b3b02cf77856033abfdb59e4a5aca08b7eacd7b74ddd", size = 262282, upload-time = "2026-01-29T20:24:17.488Z" },
+]
+
[[package]]
name = "annotated-doc"
version = "0.0.4"
@@ -632,6 +646,18 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
]
+[[package]]
+name = "colorlog"
+version = "6.10.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a2/61/f083b5ac52e505dfc1c624eafbf8c7589a0d7f32daa398d2e7590efa5fda/colorlog-6.10.1.tar.gz", hash = "sha256:eb4ae5cb65fe7fec7773c2306061a8e63e02efc2c72eba9d27b0fa23c94f1321", size = 17162, upload-time = "2025-10-16T16:14:11.978Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/6d/c1/e419ef3723a074172b68aaa89c9f3de486ed4c2399e2dbd8113a4fdcaf9e/colorlog-6.10.1-py3-none-any.whl", hash = "sha256:2d7e8348291948af66122cff006c9f8da6255d224e7cf8e37d8de2df3bad8c9c", size = 11743, upload-time = "2025-10-16T16:14:10.512Z" },
+]
+
[[package]]
name = "comm"
version = "0.2.3"
@@ -1236,6 +1262,45 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/0a/14/933037032608787fb92e365883ad6a741c235e0ff992865ec5d904a38f1e/graphql_core-3.2.7-py3-none-any.whl", hash = "sha256:17fc8f3ca4a42913d8e24d9ac9f08deddf0a0b2483076575757f6c412ead2ec0", size = 207262, upload-time = "2025-11-01T22:30:38.912Z" },
]
+[[package]]
+name = "greenlet"
+version = "3.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8a/99/1cd3411c56a410994669062bd73dd58270c00cc074cac15f385a1fd91f8a/greenlet-3.3.1.tar.gz", hash = "sha256:41848f3230b58c08bb43dee542e74a2a2e34d3c59dc3076cec9151aeeedcae98", size = 184690, upload-time = "2026-01-23T15:31:02.076Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/f9/c8/9d76a66421d1ae24340dfae7e79c313957f6e3195c144d2c73333b5bfe34/greenlet-3.3.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:7e806ca53acf6d15a888405880766ec84721aa4181261cd11a457dfe9a7a4975", size = 276443, upload-time = "2026-01-23T15:30:10.066Z" },
+ { url = "https://files.pythonhosted.org/packages/81/99/401ff34bb3c032d1f10477d199724f5e5f6fbfb59816ad1455c79c1eb8e7/greenlet-3.3.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d842c94b9155f1c9b3058036c24ffb8ff78b428414a19792b2380be9cecf4f36", size = 597359, upload-time = "2026-01-23T16:00:57.394Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/bc/4dcc0871ed557792d304f50be0f7487a14e017952ec689effe2180a6ff35/greenlet-3.3.1-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:20fedaadd422fa02695f82093f9a98bad3dab5fcda793c658b945fcde2ab27ba", size = 607805, upload-time = "2026-01-23T16:05:28.068Z" },
+ { url = "https://files.pythonhosted.org/packages/cf/05/821587cf19e2ce1f2b24945d890b164401e5085f9d09cbd969b0c193cd20/greenlet-3.3.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:14194f5f4305800ff329cbf02c5fcc88f01886cadd29941b807668a45f0d2336", size = 609947, upload-time = "2026-01-23T15:32:51.004Z" },
+ { url = "https://files.pythonhosted.org/packages/a4/52/ee8c46ed9f8babaa93a19e577f26e3d28a519feac6350ed6f25f1afee7e9/greenlet-3.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7b2fe4150a0cf59f847a67db8c155ac36aed89080a6a639e9f16df5d6c6096f1", size = 1567487, upload-time = "2026-01-23T16:04:22.125Z" },
+ { url = "https://files.pythonhosted.org/packages/8f/7c/456a74f07029597626f3a6db71b273a3632aecb9afafeeca452cfa633197/greenlet-3.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:49f4ad195d45f4a66a0eb9c1ba4832bb380570d361912fa3554746830d332149", size = 1636087, upload-time = "2026-01-23T15:33:47.486Z" },
+ { url = "https://files.pythonhosted.org/packages/34/2f/5e0e41f33c69655300a5e54aeb637cf8ff57f1786a3aba374eacc0228c1d/greenlet-3.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:cc98b9c4e4870fa983436afa999d4eb16b12872fab7071423d5262fa7120d57a", size = 227156, upload-time = "2026-01-23T15:34:34.808Z" },
+ { url = "https://files.pythonhosted.org/packages/c8/ab/717c58343cf02c5265b531384b248787e04d8160b8afe53d9eec053d7b44/greenlet-3.3.1-cp312-cp312-win_arm64.whl", hash = "sha256:bfb2d1763d777de5ee495c85309460f6fd8146e50ec9d0ae0183dbf6f0a829d1", size = 226403, upload-time = "2026-01-23T15:31:39.372Z" },
+ { url = "https://files.pythonhosted.org/packages/ec/ab/d26750f2b7242c2b90ea2ad71de70cfcd73a948a49513188a0fc0d6fc15a/greenlet-3.3.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:7ab327905cabb0622adca5971e488064e35115430cec2c35a50fd36e72a315b3", size = 275205, upload-time = "2026-01-23T15:30:24.556Z" },
+ { url = "https://files.pythonhosted.org/packages/10/d3/be7d19e8fad7c5a78eeefb2d896a08cd4643e1e90c605c4be3b46264998f/greenlet-3.3.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:65be2f026ca6a176f88fb935ee23c18333ccea97048076aef4db1ef5bc0713ac", size = 599284, upload-time = "2026-01-23T16:00:58.584Z" },
+ { url = "https://files.pythonhosted.org/packages/ae/21/fe703aaa056fdb0f17e5afd4b5c80195bbdab701208918938bd15b00d39b/greenlet-3.3.1-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7a3ae05b3d225b4155bda56b072ceb09d05e974bc74be6c3fc15463cf69f33fd", size = 610274, upload-time = "2026-01-23T16:05:29.312Z" },
+ { url = "https://files.pythonhosted.org/packages/cb/86/5c6ab23bb3c28c21ed6bebad006515cfe08b04613eb105ca0041fecca852/greenlet-3.3.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6423481193bbbe871313de5fd06a082f2649e7ce6e08015d2a76c1e9186ca5b3", size = 612904, upload-time = "2026-01-23T15:32:52.317Z" },
+ { url = "https://files.pythonhosted.org/packages/c2/f3/7949994264e22639e40718c2daf6f6df5169bf48fb038c008a489ec53a50/greenlet-3.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:33a956fe78bbbda82bfc95e128d61129b32d66bcf0a20a1f0c08aa4839ffa951", size = 1567316, upload-time = "2026-01-23T16:04:23.316Z" },
+ { url = "https://files.pythonhosted.org/packages/8d/6e/d73c94d13b6465e9f7cd6231c68abde838bb22408596c05d9059830b7872/greenlet-3.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b065d3284be43728dd280f6f9a13990b56470b81be20375a207cdc814a983f2", size = 1636549, upload-time = "2026-01-23T15:33:48.643Z" },
+ { url = "https://files.pythonhosted.org/packages/5e/b3/c9c23a6478b3bcc91f979ce4ca50879e4d0b2bd7b9a53d8ecded719b92e2/greenlet-3.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:27289986f4e5b0edec7b5a91063c109f0276abb09a7e9bdab08437525977c946", size = 227042, upload-time = "2026-01-23T15:33:58.216Z" },
+ { url = "https://files.pythonhosted.org/packages/90/e7/824beda656097edee36ab15809fd063447b200cc03a7f6a24c34d520bc88/greenlet-3.3.1-cp313-cp313-win_arm64.whl", hash = "sha256:2f080e028001c5273e0b42690eaf359aeef9cb1389da0f171ea51a5dc3c7608d", size = 226294, upload-time = "2026-01-23T15:30:52.73Z" },
+ { url = "https://files.pythonhosted.org/packages/ae/fb/011c7c717213182caf78084a9bea51c8590b0afda98001f69d9f853a495b/greenlet-3.3.1-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:bd59acd8529b372775cd0fcbc5f420ae20681c5b045ce25bd453ed8455ab99b5", size = 275737, upload-time = "2026-01-23T15:32:16.889Z" },
+ { url = "https://files.pythonhosted.org/packages/41/2e/a3a417d620363fdbb08a48b1dd582956a46a61bf8fd27ee8164f9dfe87c2/greenlet-3.3.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b31c05dd84ef6871dd47120386aed35323c944d86c3d91a17c4b8d23df62f15b", size = 646422, upload-time = "2026-01-23T16:01:00.354Z" },
+ { url = "https://files.pythonhosted.org/packages/b4/09/c6c4a0db47defafd2d6bab8ddfe47ad19963b4e30f5bed84d75328059f8c/greenlet-3.3.1-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02925a0bfffc41e542c70aa14c7eda3593e4d7e274bfcccca1827e6c0875902e", size = 658219, upload-time = "2026-01-23T16:05:30.956Z" },
+ { url = "https://files.pythonhosted.org/packages/80/38/9d42d60dffb04b45f03dbab9430898352dba277758640751dc5cc316c521/greenlet-3.3.1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34a729e2e4e4ffe9ae2408d5ecaf12f944853f40ad724929b7585bca808a9d6f", size = 660237, upload-time = "2026-01-23T15:32:53.967Z" },
+ { url = "https://files.pythonhosted.org/packages/96/61/373c30b7197f9e756e4c81ae90a8d55dc3598c17673f91f4d31c3c689c3f/greenlet-3.3.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:aec9ab04e82918e623415947921dea15851b152b822661cce3f8e4393c3df683", size = 1615261, upload-time = "2026-01-23T16:04:25.066Z" },
+ { url = "https://files.pythonhosted.org/packages/fd/d3/ca534310343f5945316f9451e953dcd89b36fe7a19de652a1dc5a0eeef3f/greenlet-3.3.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:71c767cf281a80d02b6c1bdc41c9468e1f5a494fb11bc8688c360524e273d7b1", size = 1683719, upload-time = "2026-01-23T15:33:50.61Z" },
+ { url = "https://files.pythonhosted.org/packages/52/cb/c21a3fd5d2c9c8b622e7bede6d6d00e00551a5ee474ea6d831b5f567a8b4/greenlet-3.3.1-cp314-cp314-win_amd64.whl", hash = "sha256:96aff77af063b607f2489473484e39a0bbae730f2ea90c9e5606c9b73c44174a", size = 228125, upload-time = "2026-01-23T15:32:45.265Z" },
+ { url = "https://files.pythonhosted.org/packages/6a/8e/8a2db6d11491837af1de64b8aff23707c6e85241be13c60ed399a72e2ef8/greenlet-3.3.1-cp314-cp314-win_arm64.whl", hash = "sha256:b066e8b50e28b503f604fa538adc764a638b38cf8e81e025011d26e8a627fa79", size = 227519, upload-time = "2026-01-23T15:31:47.284Z" },
+ { url = "https://files.pythonhosted.org/packages/28/24/cbbec49bacdcc9ec652a81d3efef7b59f326697e7edf6ed775a5e08e54c2/greenlet-3.3.1-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:3e63252943c921b90abb035ebe9de832c436401d9c45f262d80e2d06cc659242", size = 282706, upload-time = "2026-01-23T15:33:05.525Z" },
+ { url = "https://files.pythonhosted.org/packages/86/2e/4f2b9323c144c4fe8842a4e0d92121465485c3c2c5b9e9b30a52e80f523f/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:76e39058e68eb125de10c92524573924e827927df5d3891fbc97bd55764a8774", size = 651209, upload-time = "2026-01-23T16:01:01.517Z" },
+ { url = "https://files.pythonhosted.org/packages/d9/87/50ca60e515f5bb55a2fbc5f0c9b5b156de7d2fc51a0a69abc9d23914a237/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c9f9d5e7a9310b7a2f416dd13d2e3fd8b42d803968ea580b7c0f322ccb389b97", size = 654300, upload-time = "2026-01-23T16:05:32.199Z" },
+ { url = "https://files.pythonhosted.org/packages/1d/94/74310866dfa2b73dd08659a3d18762f83985ad3281901ba0ee9a815194fb/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:92497c78adf3ac703b57f1e3813c2d874f27f71a178f9ea5887855da413cd6d2", size = 653842, upload-time = "2026-01-23T15:32:55.671Z" },
+ { url = "https://files.pythonhosted.org/packages/97/43/8bf0ffa3d498eeee4c58c212a3905dd6146c01c8dc0b0a046481ca29b18c/greenlet-3.3.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ed6b402bc74d6557a705e197d47f9063733091ed6357b3de33619d8a8d93ac53", size = 1614917, upload-time = "2026-01-23T16:04:26.276Z" },
+ { url = "https://files.pythonhosted.org/packages/89/90/a3be7a5f378fc6e84abe4dcfb2ba32b07786861172e502388b4c90000d1b/greenlet-3.3.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:59913f1e5ada20fde795ba906916aea25d442abcc0593fba7e26c92b7ad76249", size = 1676092, upload-time = "2026-01-23T15:33:52.176Z" },
+ { url = "https://files.pythonhosted.org/packages/e1/2b/98c7f93e6db9977aaee07eb1e51ca63bd5f779b900d362791d3252e60558/greenlet-3.3.1-cp314-cp314t-win_amd64.whl", hash = "sha256:301860987846c24cb8964bdec0e31a96ad4a2a801b41b4ef40963c1b44f33451", size = 233181, upload-time = "2026-01-23T15:33:00.29Z" },
+]
+
[[package]]
name = "h11"
version = "0.16.0"
@@ -2055,6 +2120,18 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl", hash = "sha256:31a33c10c8e1e10422bfd431aeb5d351c7cf7fa671e3c4df004162264b28220c", size = 61595, upload-time = "2024-12-06T11:20:54.538Z" },
]
+[[package]]
+name = "mako"
+version = "1.3.10"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9e/38/bd5b78a920a64d708fe6bc8e0a2c075e1389d53bef8413725c63ba041535/mako-1.3.10.tar.gz", hash = "sha256:99579a6f39583fa7e5630a28c3c1f440e4e97a414b80372649c0ce338da2ea28", size = 392474, upload-time = "2025-04-10T12:44:31.16Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/87/fb/99f81ac72ae23375f22b7afdb7642aba97c00a713c217124420147681a2f/mako-1.3.10-py3-none-any.whl", hash = "sha256:baef24a52fc4fc514a0887ac600f9f1cff3d82c61d4d700a1fa84d597b88db59", size = 78509, upload-time = "2025-04-10T12:50:53.297Z" },
+]
+
[[package]]
name = "markdown"
version = "3.10"
@@ -2685,6 +2762,7 @@ source = { editable = "." }
dependencies = [
{ name = "openstef-core" },
{ name = "openstef-models", extra = ["xgb-cpu"] },
+ { name = "optuna" },
]
[package.optional-dependencies]
@@ -2739,6 +2817,7 @@ requires-dist = [
{ name = "openstef-models", extras = ["xgb-cpu"], editable = "packages/openstef-models" },
{ name = "openstef-models", extras = ["xgb-cpu"], marker = "extra == 'all'", editable = "packages/openstef-models" },
{ name = "openstef-models", extras = ["xgb-cpu"], marker = "extra == 'models'", editable = "packages/openstef-models" },
+ { name = "optuna", specifier = ">=4.7.0" },
]
provides-extras = ["all", "beam", "meta", "models"]
@@ -3010,6 +3089,24 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/24/7d/c88d7b15ba8fe5c6b8f93be50fc11795e9fc05386c44afaf6b76fe191f9b/opentelemetry_semantic_conventions-0.59b0-py3-none-any.whl", hash = "sha256:35d3b8833ef97d614136e253c1da9342b4c3c083bbaf29ce31d572a1c3825eed", size = 207954, upload-time = "2025-10-16T08:35:48.054Z" },
]
+[[package]]
+name = "optuna"
+version = "4.7.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "alembic" },
+ { name = "colorlog" },
+ { name = "numpy" },
+ { name = "packaging" },
+ { name = "pyyaml" },
+ { name = "sqlalchemy" },
+ { name = "tqdm" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/58/b2/b5e12de7b4486556fe2257611b55dbabf30d0300bdb031831aa943ad20e4/optuna-4.7.0.tar.gz", hash = "sha256:d91817e2079825557bd2e97de2e8c9ae260bfc99b32712502aef8a5095b2d2c0", size = 479740, upload-time = "2026-01-19T05:45:52.604Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/75/d1/6c8a4fbb38a9e3565f5c36b871262a85ecab3da48120af036b1e4937a15c/optuna-4.7.0-py3-none-any.whl", hash = "sha256:e41ec84018cecc10eabf28143573b1f0bde0ba56dba8151631a590ecbebc1186", size = 413894, upload-time = "2026-01-19T05:45:50.815Z" },
+]
+
[[package]]
name = "optype"
version = "0.14.0"
@@ -4774,6 +4871,48 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", size = 92072, upload-time = "2024-07-29T01:10:08.203Z" },
]
+[[package]]
+name = "sqlalchemy"
+version = "2.0.46"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "greenlet", marker = "platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64'" },
+ { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/aa/9ce0f3e7a9829ead5c8ce549392f33a12c4555a6c0609bb27d882e9c7ddf/sqlalchemy-2.0.46.tar.gz", hash = "sha256:cf36851ee7219c170bb0793dbc3da3e80c582e04a5437bc601bfe8c85c9216d7", size = 9865393, upload-time = "2026-01-21T18:03:45.119Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/b6/35/d16bfa235c8b7caba3730bba43e20b1e376d2224f407c178fbf59559f23e/sqlalchemy-2.0.46-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3a9a72b0da8387f15d5810f1facca8f879de9b85af8c645138cba61ea147968c", size = 2153405, upload-time = "2026-01-21T19:05:54.143Z" },
+ { url = "https://files.pythonhosted.org/packages/06/6c/3192e24486749862f495ddc6584ed730c0c994a67550ec395d872a2ad650/sqlalchemy-2.0.46-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2347c3f0efc4de367ba00218e0ae5c4ba2306e47216ef80d6e31761ac97cb0b9", size = 3334702, upload-time = "2026-01-21T18:46:45.384Z" },
+ { url = "https://files.pythonhosted.org/packages/ea/a2/b9f33c8d68a3747d972a0bb758c6b63691f8fb8a49014bc3379ba15d4274/sqlalchemy-2.0.46-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9094c8b3197db12aa6f05c51c05daaad0a92b8c9af5388569847b03b1007fb1b", size = 3347664, upload-time = "2026-01-21T18:40:09.979Z" },
+ { url = "https://files.pythonhosted.org/packages/aa/d2/3e59e2a91eaec9db7e8dc6b37b91489b5caeb054f670f32c95bcba98940f/sqlalchemy-2.0.46-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37fee2164cf21417478b6a906adc1a91d69ae9aba8f9533e67ce882f4bb1de53", size = 3277372, upload-time = "2026-01-21T18:46:47.168Z" },
+ { url = "https://files.pythonhosted.org/packages/dd/dd/67bc2e368b524e2192c3927b423798deda72c003e73a1e94c21e74b20a85/sqlalchemy-2.0.46-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b1e14b2f6965a685c7128bd315e27387205429c2e339eeec55cb75ca4ab0ea2e", size = 3312425, upload-time = "2026-01-21T18:40:11.548Z" },
+ { url = "https://files.pythonhosted.org/packages/43/82/0ecd68e172bfe62247e96cb47867c2d68752566811a4e8c9d8f6e7c38a65/sqlalchemy-2.0.46-cp312-cp312-win32.whl", hash = "sha256:412f26bb4ba942d52016edc8d12fb15d91d3cd46b0047ba46e424213ad407bcb", size = 2113155, upload-time = "2026-01-21T18:42:49.748Z" },
+ { url = "https://files.pythonhosted.org/packages/bc/2a/2821a45742073fc0331dc132552b30de68ba9563230853437cac54b2b53e/sqlalchemy-2.0.46-cp312-cp312-win_amd64.whl", hash = "sha256:ea3cd46b6713a10216323cda3333514944e510aa691c945334713fca6b5279ff", size = 2140078, upload-time = "2026-01-21T18:42:51.197Z" },
+ { url = "https://files.pythonhosted.org/packages/b3/4b/fa7838fe20bb752810feed60e45625a9a8b0102c0c09971e2d1d95362992/sqlalchemy-2.0.46-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:93a12da97cca70cea10d4b4fc602589c4511f96c1f8f6c11817620c021d21d00", size = 2150268, upload-time = "2026-01-21T19:05:56.621Z" },
+ { url = "https://files.pythonhosted.org/packages/46/c1/b34dccd712e8ea846edf396e00973dda82d598cb93762e55e43e6835eba9/sqlalchemy-2.0.46-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:af865c18752d416798dae13f83f38927c52f085c52e2f32b8ab0fef46fdd02c2", size = 3276511, upload-time = "2026-01-21T18:46:49.022Z" },
+ { url = "https://files.pythonhosted.org/packages/96/48/a04d9c94753e5d5d096c628c82a98c4793b9c08ca0e7155c3eb7d7db9f24/sqlalchemy-2.0.46-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8d679b5f318423eacb61f933a9a0f75535bfca7056daeadbf6bd5bcee6183aee", size = 3292881, upload-time = "2026-01-21T18:40:13.089Z" },
+ { url = "https://files.pythonhosted.org/packages/be/f4/06eda6e91476f90a7d8058f74311cb65a2fb68d988171aced81707189131/sqlalchemy-2.0.46-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:64901e08c33462acc9ec3bad27fc7a5c2b6491665f2aa57564e57a4f5d7c52ad", size = 3224559, upload-time = "2026-01-21T18:46:50.974Z" },
+ { url = "https://files.pythonhosted.org/packages/ab/a2/d2af04095412ca6345ac22b33b89fe8d6f32a481e613ffcb2377d931d8d0/sqlalchemy-2.0.46-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e8ac45e8f4eaac0f9f8043ea0e224158855c6a4329fd4ee37c45c61e3beb518e", size = 3262728, upload-time = "2026-01-21T18:40:14.883Z" },
+ { url = "https://files.pythonhosted.org/packages/31/48/1980c7caa5978a3b8225b4d230e69a2a6538a3562b8b31cea679b6933c83/sqlalchemy-2.0.46-cp313-cp313-win32.whl", hash = "sha256:8d3b44b3d0ab2f1319d71d9863d76eeb46766f8cf9e921ac293511804d39813f", size = 2111295, upload-time = "2026-01-21T18:42:52.366Z" },
+ { url = "https://files.pythonhosted.org/packages/2d/54/f8d65bbde3d877617c4720f3c9f60e99bb7266df0d5d78b6e25e7c149f35/sqlalchemy-2.0.46-cp313-cp313-win_amd64.whl", hash = "sha256:77f8071d8fbcbb2dd11b7fd40dedd04e8ebe2eb80497916efedba844298065ef", size = 2137076, upload-time = "2026-01-21T18:42:53.924Z" },
+ { url = "https://files.pythonhosted.org/packages/56/ba/9be4f97c7eb2b9d5544f2624adfc2853e796ed51d2bb8aec90bc94b7137e/sqlalchemy-2.0.46-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1e8cc6cc01da346dc92d9509a63033b9b1bda4fed7a7a7807ed385c7dccdc10", size = 3556533, upload-time = "2026-01-21T18:33:06.636Z" },
+ { url = "https://files.pythonhosted.org/packages/20/a6/b1fc6634564dbb4415b7ed6419cdfeaadefd2c39cdab1e3aa07a5f2474c2/sqlalchemy-2.0.46-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:96c7cca1a4babaaf3bfff3e4e606e38578856917e52f0384635a95b226c87764", size = 3523208, upload-time = "2026-01-21T18:45:08.436Z" },
+ { url = "https://files.pythonhosted.org/packages/a1/d8/41e0bdfc0f930ff236f86fccd12962d8fa03713f17ed57332d38af6a3782/sqlalchemy-2.0.46-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b2a9f9aee38039cf4755891a1e50e1effcc42ea6ba053743f452c372c3152b1b", size = 3464292, upload-time = "2026-01-21T18:33:08.208Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/8b/9dcbec62d95bea85f5ecad9b8d65b78cc30fb0ffceeb3597961f3712549b/sqlalchemy-2.0.46-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:db23b1bf8cfe1f7fda19018e7207b20cdb5168f83c437ff7e95d19e39289c447", size = 3473497, upload-time = "2026-01-21T18:45:10.552Z" },
+ { url = "https://files.pythonhosted.org/packages/e9/f8/5ecdfc73383ec496de038ed1614de9e740a82db9ad67e6e4514ebc0708a3/sqlalchemy-2.0.46-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:56bdd261bfd0895452006d5316cbf35739c53b9bb71a170a331fa0ea560b2ada", size = 2152079, upload-time = "2026-01-21T19:05:58.477Z" },
+ { url = "https://files.pythonhosted.org/packages/e5/bf/eba3036be7663ce4d9c050bc3d63794dc29fbe01691f2bf5ccb64e048d20/sqlalchemy-2.0.46-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:33e462154edb9493f6c3ad2125931e273bbd0be8ae53f3ecd1c161ea9a1dd366", size = 3272216, upload-time = "2026-01-21T18:46:52.634Z" },
+ { url = "https://files.pythonhosted.org/packages/05/45/1256fb597bb83b58a01ddb600c59fe6fdf0e5afe333f0456ed75c0f8d7bd/sqlalchemy-2.0.46-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9bcdce05f056622a632f1d44bb47dbdb677f58cad393612280406ce37530eb6d", size = 3277208, upload-time = "2026-01-21T18:40:16.38Z" },
+ { url = "https://files.pythonhosted.org/packages/d9/a0/2053b39e4e63b5d7ceb3372cface0859a067c1ddbd575ea7e9985716f771/sqlalchemy-2.0.46-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8e84b09a9b0f19accedcbeff5c2caf36e0dd537341a33aad8d680336152dc34e", size = 3221994, upload-time = "2026-01-21T18:46:54.622Z" },
+ { url = "https://files.pythonhosted.org/packages/1e/87/97713497d9502553c68f105a1cb62786ba1ee91dea3852ae4067ed956a50/sqlalchemy-2.0.46-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4f52f7291a92381e9b4de9050b0a65ce5d6a763333406861e33906b8aa4906bf", size = 3243990, upload-time = "2026-01-21T18:40:18.253Z" },
+ { url = "https://files.pythonhosted.org/packages/a8/87/5d1b23548f420ff823c236f8bea36b1a997250fd2f892e44a3838ca424f4/sqlalchemy-2.0.46-cp314-cp314-win32.whl", hash = "sha256:70ed2830b169a9960193f4d4322d22be5c0925357d82cbf485b3369893350908", size = 2114215, upload-time = "2026-01-21T18:42:55.232Z" },
+ { url = "https://files.pythonhosted.org/packages/3a/20/555f39cbcf0c10cf452988b6a93c2a12495035f68b3dbd1a408531049d31/sqlalchemy-2.0.46-cp314-cp314-win_amd64.whl", hash = "sha256:3c32e993bc57be6d177f7d5d31edb93f30726d798ad86ff9066d75d9bf2e0b6b", size = 2139867, upload-time = "2026-01-21T18:42:56.474Z" },
+ { url = "https://files.pythonhosted.org/packages/3e/f0/f96c8057c982d9d8a7a68f45d69c674bc6f78cad401099692fe16521640a/sqlalchemy-2.0.46-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4dafb537740eef640c4d6a7c254611dca2df87eaf6d14d6a5fca9d1f4c3fc0fa", size = 3561202, upload-time = "2026-01-21T18:33:10.337Z" },
+ { url = "https://files.pythonhosted.org/packages/d7/53/3b37dda0a5b137f21ef608d8dfc77b08477bab0fe2ac9d3e0a66eaeab6fc/sqlalchemy-2.0.46-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42a1643dc5427b69aca967dae540a90b0fbf57eaf248f13a90ea5930e0966863", size = 3526296, upload-time = "2026-01-21T18:45:12.657Z" },
+ { url = "https://files.pythonhosted.org/packages/33/75/f28622ba6dde79cd545055ea7bd4062dc934e0621f7b3be2891f8563f8de/sqlalchemy-2.0.46-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ff33c6e6ad006bbc0f34f5faf941cfc62c45841c64c0a058ac38c799f15b5ede", size = 3470008, upload-time = "2026-01-21T18:33:11.725Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/42/4afecbbc38d5e99b18acef446453c76eec6fbd03db0a457a12a056836e22/sqlalchemy-2.0.46-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:82ec52100ec1e6ec671563bbd02d7c7c8d0b9e71a0723c72f22ecf52d1755330", size = 3476137, upload-time = "2026-01-21T18:45:15.001Z" },
+ { url = "https://files.pythonhosted.org/packages/fc/a1/9c4efa03300926601c19c18582531b45aededfb961ab3c3585f1e24f120b/sqlalchemy-2.0.46-py3-none-any.whl", hash = "sha256:f9c11766e7e7c0a2767dda5acb006a118640c9fc0a4104214b96269bfb78399e", size = 1937882, upload-time = "2026-01-21T18:22:10.456Z" },
+]
+
[[package]]
name = "sqlparse"
version = "0.5.3"