From 883f2960228a5032bddcf65d2cd3f4f7d578f304 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Wed, 3 Jun 2026 10:42:56 +0200 Subject: [PATCH 01/26] Add conformal prediction intervals support for Hyper-Tree models - Introduced ForecastIntervals class for configuring and calibrating prediction intervals. - Updated HyperTreeAR, HyperTreeETS, and HyperTreeNetAR to support conformal intervals. - Enhanced forecast method to include interval columns for specified confidence levels. - Added unit tests for conformal prediction functionality. - Updated README to reflect new features and usage examples. --- README.md | 15 +- examples/Forecast Intervals.ipynb | 667 ++++++++++++++++++++++++++++ examples/quickstart_forecast.png | Bin 84062 -> 279886 bytes examples/utils.py | 131 +++++- hypertrees/__init__.py | 6 +- hypertrees/conformal.py | 323 ++++++++++++++ hypertrees/models/HyperTreeAR.py | 111 ++++- hypertrees/models/HyperTreeETS.py | 106 ++++- hypertrees/models/HyperTreeNetAR.py | 108 ++++- pyproject.toml | 2 +- tests/test_conformal.py | 54 +++ tests/test_hypertree_ar.py | 118 +++++ tests/test_hypertree_ets.py | 73 +++ tests/test_hypertree_net_ar.py | 80 ++++ 14 files changed, 1758 insertions(+), 36 deletions(-) create mode 100644 examples/Forecast Intervals.ipynb create mode 100644 hypertrees/conformal.py create mode 100644 tests/test_conformal.py diff --git a/README.md b/README.md index 1c1a603..09ca71f 100644 --- a/README.md +++ b/README.md @@ -34,6 +34,7 @@ Hyper-Trees offer several advantages: --- # News +[2026-06-03] v0.2.0 adds support for forecast intervals via conformal prediction.
[2026-06-01] v0.1.0 released on [PyPI](https://pypi.org/project/hypertrees-forecasting/).
[2024-05-01] Create repository and initial commits. @@ -49,7 +50,7 @@ Hyper-Trees offer several advantages: | **`Hyper-Tree-STL`** | STL decomposition with tree-learned parameters for trend and seasonality. | ![](https://img.shields.io/badge/Local-green) | `Global` means a single model is trained across multiple time series; `Local` means a separate model is trained for each individual series. -All models currently provide point forecasts only. Probabilistic forecasting is planned for future releases. Note on `Hyper-Tree-STL`: it is designed to decompose time series into trend and seasonal components and is not intended for forecasting. However, the STL-parameters can still be used to generate forecasts. +All models produce point forecasts and support conformal prediction intervals via `ForecastIntervals` (see [Getting Started](#getting-started)). Full distributional (probabilistic) forecasting is planned for future releases. Note on `Hyper-Tree-STL`: it is designed to decompose time series into trend and seasonal components and is not intended for forecasting. However, the STL-parameters can still be used to generate forecasts. --- @@ -59,6 +60,7 @@ The example below trains a `Hyper-Tree-AR` model on the classic AirPassengers se ```python from hypertrees.models import HyperTreeAR +from hypertrees import ForecastIntervals from examples.utils import (load_air_passengers, plot_example_forecast) # Load data and add 'month' as a feature @@ -70,10 +72,15 @@ fcst_h = 12 test = dta.tail(fcst_h) train = dta.drop(test.index) -# Initialize an AR-12 model for monthly data, train, and forecast +# Initialize an AR-12 model for monthly data, calibrate conformal intervals, and forecast +ci_levels = [80, 90] ht_model = HyperTreeAR(p=12, freq="M", fcst_h=fcst_h) -ht_model.train(lgb_params={"learning_rate": 0.1}, num_iterations=100, train_data=train) -forecasts = ht_model.forecast(test_data=test) +ht_model.train( + lgb_params={"learning_rate": 0.1}, + train_data=train, + forecast_intervals=ForecastIntervals(n_windows=5), # calibrate intervals +) +forecasts = ht_model.forecast(test_data=test, level=ci_levels) # Plot actuals vs. forecast plot_example_forecast(dta, forecasts) diff --git a/examples/Forecast Intervals.ipynb b/examples/Forecast Intervals.ipynb new file mode 100644 index 0000000..daaa55d --- /dev/null +++ b/examples/Forecast Intervals.ipynb @@ -0,0 +1,667 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2e911782", + "source": "# Forecast Intervals with Conformal Prediction\n\nThis notebook demonstrates how to add prediction intervals to Hyper-Tree forecasts using conformal prediction. The approach is model-agnostic and works with all Hyper-Tree models (AR, ETS, TreeNet-AR).\n\n**How it works:** During training, a rolling-window cross-validation collects absolute residuals (conformity scores) per horizon step and per series. At forecast time, these scores are used to construct intervals at any requested confidence level.", + "metadata": {} + }, + { + "cell_type": "code", + "id": "1bac7747", + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from hypertrees.models import HyperTreeAR, HyperTreeETS, HyperTreeNetAR\n", + "from hypertrees import ForecastIntervals\n", + "import torch" + ], + "metadata": { + "ExecuteTime": { + "end_time": "2026-06-03T08:38:40.882560100Z", + "start_time": "2026-06-03T08:38:30.050270500Z" + } + }, + "outputs": [], + "execution_count": 1 + }, + { + "cell_type": "markdown", + "id": "298aeca0", + "source": "## Load and Prepare Data\n\nWe use the Air Passengers dataset (monthly, 1949-1960) and reserve the last 12 months for testing.", + "metadata": {} + }, + { + "cell_type": "code", + "id": "fb4ce322", + "source": "df = pd.read_csv('https://datasets-nixtla.s3.amazonaws.com/air-passengers.csv', parse_dates=['ds'])\ndf.rename(columns={'unique_id': 'series_id', 'ds': 'date', 'y': 'value'}, inplace=True)\ndf['month'] = df['date'].dt.month\ndf['quarter'] = df['date'].dt.quarter\n\nfcst_h = 12\ntest = df.tail(fcst_h)\ntrain = df.drop(test.index)", + "metadata": { + "ExecuteTime": { + "end_time": "2026-06-03T08:38:41.283739200Z", + "start_time": "2026-06-03T08:38:40.895558900Z" + } + }, + "outputs": [], + "execution_count": 2 + }, + { + "cell_type": "markdown", + "id": "4ae3c43e", + "source": "## General Parameters", + "metadata": {} + }, + { + "cell_type": "code", + "id": "2d426f65", + "source": [ + "freq = 'MS'\n", + "num_iterations = 100\n", + "ci_levels = [80, 90]\n", + "n_windows = 5\n", + "refit = False\n", + "device=torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "ht_params = {\n", + " 'learning_rate': 1e-01,\n", + "}" + ], + "metadata": { + "ExecuteTime": { + "end_time": "2026-06-03T08:38:41.782578400Z", + "start_time": "2026-06-03T08:38:41.296738200Z" + } + }, + "outputs": [], + "execution_count": 3 + }, + { + "cell_type": "markdown", + "id": "8a47fd4d", + "source": "## Hyper-Tree-AR with Forecast Intervals\n\nPass `forecast_intervals=ForecastIntervals(...)` to `train()` to calibrate conformal intervals, then request them via `level=[...]` in `forecast()`.\n\nKey parameters of `ForecastIntervals`:\n- **`n_windows`**: Number of rolling CV windows for calibration (more = better quantile resolution, but slower).\n- **`method`**: `\"conformal_distribution\"` (default, can produce asymmetric bands) or `\"conformal_error\"` (symmetric).\n- **`refit`**: If `True` (default), retrain the model for each CV window. If `False`, train once and reuse (faster).", + "metadata": {} + }, + { + "cell_type": "code", + "id": "dbb5135d", + "source": [ + "lag_p = 12\n", + "\n", + "ht_ar = HyperTreeAR(p=lag_p, freq=freq, fcst_h=fcst_h)\n", + "ht_ar.train(\n", + " lgb_params=ht_params,\n", + " num_iterations=num_iterations,\n", + " train_data=train,\n", + " seed=123,\n", + " verbose=-1,\n", + " forecast_intervals=ForecastIntervals(n_windows=n_windows, refit=refit)\n", + ")\n", + "\n", + "ht_ar_fcst = ht_ar.forecast(test_data=test, level=ci_levels)\n", + "ht_ar_fcst.head()" + ], + "metadata": { + "ExecuteTime": { + "end_time": "2026-06-03T08:38:42.705452700Z", + "start_time": "2026-06-03T08:38:41.795577900Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + " series_id date fcst model \\\n", + "0 AirPassengers 1960-01-01 403.564685 Hyper-Tree-AR(12) \n", + "1 AirPassengers 1960-02-01 402.666934 Hyper-Tree-AR(12) \n", + "2 AirPassengers 1960-03-01 464.129094 Hyper-Tree-AR(12) \n", + "3 AirPassengers 1960-04-01 453.348857 Hyper-Tree-AR(12) \n", + "4 AirPassengers 1960-05-01 466.937533 Hyper-Tree-AR(12) \n", + "\n", + " Hyper-Tree-AR(12)-lo-90 Hyper-Tree-AR(12)-lo-80 Hyper-Tree-AR(12)-hi-80 \\\n", + "0 374.900429 378.875007 428.254363 \n", + "1 374.997106 377.199307 428.134560 \n", + "2 436.837740 439.324120 488.934067 \n", + "3 433.513237 434.107431 472.590283 \n", + "4 451.324017 452.709793 481.165273 \n", + "\n", + " Hyper-Tree-AR(12)-hi-90 \n", + "0 432.228941 \n", + "1 430.336762 \n", + "2 491.420447 \n", + "3 473.184477 \n", + "4 482.551049 " + ], + "text/html": [ + "
\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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
series_iddatefcstmodelHyper-Tree-AR(12)-lo-90Hyper-Tree-AR(12)-lo-80Hyper-Tree-AR(12)-hi-80Hyper-Tree-AR(12)-hi-90
0AirPassengers1960-01-01403.564685Hyper-Tree-AR(12)374.900429378.875007428.254363432.228941
1AirPassengers1960-02-01402.666934Hyper-Tree-AR(12)374.997106377.199307428.134560430.336762
2AirPassengers1960-03-01464.129094Hyper-Tree-AR(12)436.837740439.324120488.934067491.420447
3AirPassengers1960-04-01453.348857Hyper-Tree-AR(12)433.513237434.107431472.590283473.184477
4AirPassengers1960-05-01466.937533Hyper-Tree-AR(12)451.324017452.709793481.165273482.551049
\n", + "
" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 4 + }, + { + "cell_type": "markdown", + "id": "34479a3a", + "source": "## Hyper-Tree-ETS with Forecast Intervals", + "metadata": {} + }, + { + "cell_type": "code", + "id": "b3909a1a", + "source": [ + "ht_ets = HyperTreeETS(\n", + " ets_type=\"triple\",\n", + " seasonality_feature=\"month\",\n", + " season_length=12,\n", + " freq=freq,\n", + " fcst_h=fcst_h,\n", + ")\n", + "ht_ets.train(\n", + " lgb_params=ht_params,\n", + " num_iterations=num_iterations,\n", + " train_data=train,\n", + " seed=123,\n", + " verbose=-1,\n", + " forecast_intervals=ForecastIntervals(n_windows=n_windows, refit=refit),\n", + ")\n", + "\n", + "ht_ets_fcst = ht_ets.forecast(test_data=test, level=ci_levels)\n", + "ht_ets_fcst.head()" + ], + "metadata": { + "ExecuteTime": { + "end_time": "2026-06-03T08:39:28.575252800Z", + "start_time": "2026-06-03T08:38:42.983143900Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + " series_id date fcst model \\\n", + "0 AirPassengers 1960-01-01 412.837921 Hyper-Tree-ETS(triple) \n", + "1 AirPassengers 1960-02-01 388.689178 Hyper-Tree-ETS(triple) \n", + "2 AirPassengers 1960-03-01 446.611877 Hyper-Tree-ETS(triple) \n", + "3 AirPassengers 1960-04-01 428.627716 Hyper-Tree-ETS(triple) \n", + "4 AirPassengers 1960-05-01 447.878479 Hyper-Tree-ETS(triple) \n", + "\n", + " Hyper-Tree-ETS(triple)-lo-90 Hyper-Tree-ETS(triple)-lo-80 \\\n", + "0 402.068939 404.092072 \n", + "1 375.984319 376.072855 \n", + "2 427.777397 432.720078 \n", + "3 402.167624 404.361401 \n", + "4 412.318495 417.967679 \n", + "\n", + " Hyper-Tree-ETS(triple)-hi-80 Hyper-Tree-ETS(triple)-hi-90 \n", + "0 421.583771 423.606903 \n", + "1 401.305502 401.394038 \n", + "2 460.503677 465.446358 \n", + "3 452.894031 455.087808 \n", + "4 477.789279 483.438463 " + ], + "text/html": [ + "
\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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
series_iddatefcstmodelHyper-Tree-ETS(triple)-lo-90Hyper-Tree-ETS(triple)-lo-80Hyper-Tree-ETS(triple)-hi-80Hyper-Tree-ETS(triple)-hi-90
0AirPassengers1960-01-01412.837921Hyper-Tree-ETS(triple)402.068939404.092072421.583771423.606903
1AirPassengers1960-02-01388.689178Hyper-Tree-ETS(triple)375.984319376.072855401.305502401.394038
2AirPassengers1960-03-01446.611877Hyper-Tree-ETS(triple)427.777397432.720078460.503677465.446358
3AirPassengers1960-04-01428.627716Hyper-Tree-ETS(triple)402.167624404.361401452.894031455.087808
4AirPassengers1960-05-01447.878479Hyper-Tree-ETS(triple)412.318495417.967679477.789279483.438463
\n", + "
" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 5 + }, + { + "cell_type": "markdown", + "id": "495f45ba", + "source": "## Hyper-TreeNet-AR with Forecast Intervals", + "metadata": {} + }, + { + "cell_type": "code", + "id": "ecfaad3c", + "source": [ + "import torch\n", + "\n", + "network_params = {\n", + " 'learning_rate': 1e-3,\n", + " 'embedding_dimension': 1,\n", + " 'hidden_dim': 128,\n", + " 'dropout': 0.1,\n", + " 'use_random_projection': True,\n", + " 'rp_embed_dim': lag_p,\n", + "}\n", + "\n", + "htnet_ar = HyperTreeNetAR(\n", + " p=lag_p,\n", + " freq=freq,\n", + " fcst_h=fcst_h,\n", + " device=device,\n", + ")\n", + "htnet_ar.train(\n", + " lgb_params=ht_params,\n", + " network_params=network_params,\n", + " num_iterations=num_iterations,\n", + " train_data=train,\n", + " seed=123,\n", + " verbose=-1,\n", + " forecast_intervals=ForecastIntervals(n_windows=n_windows, refit=refit),\n", + ")\n", + "\n", + "htnet_ar_fcst = htnet_ar.forecast(test_data=test, level=ci_levels)\n", + "htnet_ar_fcst.head()" + ], + "metadata": { + "ExecuteTime": { + "end_time": "2026-06-03T08:39:33.333331600Z", + "start_time": "2026-06-03T08:39:29.529012Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + " series_id date fcst model \\\n", + "0 AirPassengers 1960-01-01 402.806098 Hyper-TreeNet-AR(12) \n", + "1 AirPassengers 1960-02-01 398.804139 Hyper-TreeNet-AR(12) \n", + "2 AirPassengers 1960-03-01 423.079688 Hyper-TreeNet-AR(12) \n", + "3 AirPassengers 1960-04-01 429.395641 Hyper-TreeNet-AR(12) \n", + "4 AirPassengers 1960-05-01 446.548640 Hyper-TreeNet-AR(12) \n", + "\n", + " Hyper-TreeNet-AR(12)-lo-90 Hyper-TreeNet-AR(12)-lo-80 \\\n", + "0 374.728973 386.878973 \n", + "1 376.324306 385.665050 \n", + "2 382.422566 389.735466 \n", + "3 401.544587 410.783853 \n", + "4 418.092466 420.452339 \n", + "\n", + " Hyper-TreeNet-AR(12)-hi-80 Hyper-TreeNet-AR(12)-hi-90 \n", + "0 418.733224 430.883224 \n", + "1 411.943227 421.283971 \n", + "2 456.423911 463.736811 \n", + "3 448.007429 457.246694 \n", + "4 472.644941 475.004814 " + ], + "text/html": [ + "
\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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
series_iddatefcstmodelHyper-TreeNet-AR(12)-lo-90Hyper-TreeNet-AR(12)-lo-80Hyper-TreeNet-AR(12)-hi-80Hyper-TreeNet-AR(12)-hi-90
0AirPassengers1960-01-01402.806098Hyper-TreeNet-AR(12)374.728973386.878973418.733224430.883224
1AirPassengers1960-02-01398.804139Hyper-TreeNet-AR(12)376.324306385.665050411.943227421.283971
2AirPassengers1960-03-01423.079688Hyper-TreeNet-AR(12)382.422566389.735466456.423911463.736811
3AirPassengers1960-04-01429.395641Hyper-TreeNet-AR(12)401.544587410.783853448.007429457.246694
4AirPassengers1960-05-01446.548640Hyper-TreeNet-AR(12)418.092466420.452339472.644941475.004814
\n", + "
" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 6 + }, + { + "cell_type": "markdown", + "id": "d5f38f47", + "source": "## Plot Forecasts with Intervals\n\nThe `plot_example_forecast` helper automatically detects and shades interval columns present in the forecast DataFrame.", + "metadata": {} + }, + { + "cell_type": "code", + "id": "fdfdb175", + "source": [ + "fig, axes = plt.subplots(1, 3, figsize=(18, 5), sharey=True)\n", + "\n", + "for ax, (fcst_df, title) in zip(axes, [\n", + " (ht_ar_fcst, \"Hyper-Tree-AR\"),\n", + " (ht_ets_fcst, \"Hyper-Tree-ETS\"),\n", + " (htnet_ar_fcst, \"Hyper-TreeNet-AR\"),\n", + "]):\n", + " import re\n", + " model_name = fcst_df[\"model\"].iloc[0]\n", + "\n", + " ax.plot(df[\"date\"], df[\"value\"], label=\"Actual\", color=\"#2E86AB\", linewidth=2, alpha=0.8)\n", + " ax.plot(fcst_df[\"date\"], fcst_df[\"fcst\"], label=\"Forecast\", color=\"green\", linestyle=\"--\", linewidth=2)\n", + "\n", + " detected = sorted(\n", + " int(m.group(1))\n", + " for c in fcst_df.columns\n", + " for m in [re.fullmatch(rf\"{re.escape(model_name)}-lo-(\\d+)\", c)]\n", + " if m\n", + " )\n", + " alphas = [0.15, 0.28, 0.40]\n", + " shade = {lv: a for lv, a in zip(sorted(detected, reverse=True), alphas)}\n", + " for lv in sorted(detected, reverse=True):\n", + " ax.fill_between(\n", + " fcst_df[\"date\"],\n", + " fcst_df[f\"{model_name}-lo-{lv}\"],\n", + " fcst_df[f\"{model_name}-hi-{lv}\"],\n", + " color=\"green\", alpha=shade.get(lv, 0.2), label=f\"{lv}% interval\",\n", + " )\n", + "\n", + " ax.axvline(x=fcst_df[\"date\"].min(), color=\"black\", linestyle=\":\", alpha=0.7)\n", + " ax.set_title(title, fontsize=14)\n", + " ax.legend(fontsize=9)\n", + " ax.grid(True, alpha=0.3)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ], + "metadata": { + "ExecuteTime": { + "end_time": "2026-06-03T08:39:34.138252400Z", + "start_time": "2026-06-03T08:39:33.412977400Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 7 + }, + { + "cell_type": "markdown", + "id": "1a21821c", + "source": "## Comparing Methods: `conformal_distribution` vs `conformal_error`\n\nThe default `conformal_distribution` builds synthetic forecast paths and can produce asymmetric intervals. The alternative `conformal_error` takes quantiles of absolute errors directly, always producing symmetric bands.", + "metadata": {} + }, + { + "cell_type": "code", + "id": "d486bac1", + "source": "fig, axes = plt.subplots(1, 2, figsize=(14, 5), sharey=True)\n\nfor ax, method in zip(axes, [\"conformal_distribution\", \"conformal_error\"]):\n model = HyperTreeAR(p=lag_p, freq=freq, fcst_h=fcst_h)\n model.train(\n lgb_params=ht_params,\n num_iterations=num_iterations,\n train_data=train,\n seed=123,\n verbose=-1,\n forecast_intervals=ForecastIntervals(n_windows=5, method=method),\n )\n fcst = model.forecast(test_data=test, level=[90])\n model_name = fcst[\"model\"].iloc[0]\n\n ax.plot(df[\"date\"], df[\"value\"], label=\"Actual\", color=\"#2E86AB\", linewidth=2, alpha=0.8)\n ax.plot(fcst[\"date\"], fcst[\"fcst\"], label=\"Forecast\", color=\"green\", linestyle=\"--\", linewidth=2)\n ax.fill_between(\n fcst[\"date\"],\n fcst[f\"{model_name}-lo-90\"],\n fcst[f\"{model_name}-hi-90\"],\n color=\"green\", alpha=0.2, label=\"90% interval\",\n )\n ax.axvline(x=fcst[\"date\"].min(), color=\"black\", linestyle=\":\", alpha=0.7)\n ax.set_title(method, fontsize=14)\n ax.legend(fontsize=10)\n ax.grid(True, alpha=0.3)\n\nplt.tight_layout()\nplt.show()", + "metadata": { + "ExecuteTime": { + "end_time": "2026-06-03T08:39:41.198542200Z", + "start_time": "2026-06-03T08:39:34.311350300Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAABW0AAAHqCAYAAAB/bWzAAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Qec23X9P/B39rrcHt270JYCpWwpe8tUBFFARBRFhgsQ/oIIKi5AZIjCjyWoTBmCMgTKLmXT0lJK1/V6e2Xv5P94f3Lfb77J5e6SyzeXb3Kvp48+mrvcSC4nfeWd9+f91iUSiQQBAAAAAAAAAAAAgCboS30DAAAAAAAAAAAAACAFRVsAAAAAAAAAAAAADUHRFgAAAAAAAAAAAEBDULQFAAAAAAAAAAAA0BAUbQEAAAAAAAAAAAA0BEVbAAAAAAAAAAAAAA1B0RYAAAAAAAAAAABAQ1C0BQAAAAAAAAAAANAQFG0BAAAAAAAAAAAANARFWwAoK5FIhH7xi1/QwoULyWKxkE6noyeeeIIqyTe/+U1xv7Zu3arq1125cqX4uvzzU5ozZ474Uwp8W/g28W2T8P3m9/HPoVQOOeQQcRsAAAAAtAiZGACg8qFoCwBl5YYbbqBrrrmGpk2bRpdccgldffXVtGjRolLfrEnr3nvvFcVN/rucZCsWAwAAAJQLZGIAgMpnLPUNAADIx9NPP01VVVX0wgsvkNlsxg9PBS+++GLJfo4XXnghnX766TRr1izSkr/97W/k9/tLfTMAAAAAskImBgCofCjaAkBZaW9vp4aGBhRsVTR//nwqlcbGRvFHa7RWRAYAAABQQiYGAKh8GI8AADl79dVX6eSTT6aWlhYxT3bmzJn05S9/mV5//XX5Y3w+nzyywGq1Un19PR133HH0xhtvjHpE/R//+ActW7aMbDYbTZ06lX7wgx9QIBAY9rFbtmyhbdu2icv8J3MW6z333EP77ruv6MblP3w529F95XzXN998k4466iiqra2V55gqbxt/zV133VXctrlz59LNN98sPiaRSIijaTvvvLO4rzxnlzs0M3322Wd02WWX0fLly0XBmT92p512ossvv5y8Xq/qv4H8c+OvzY8Pf6+lS5fSnXfeOeLHZ5tpGwwGxX3bfffdqaamhhwOh/iY0047jT766CPxMTxz9pxzzhGX+W/pMVHOgpVmw/LXu/LKK0WB2GQyyXN1xxpT8Mknn4jfH35s+PHkx+m9997L6T5k3gbl2zxigx166KFZf5dGmmkbjUbpxhtvFD8X/n3gnw1/jX//+9+jjo54/vnn6Qtf+ALZ7XbxO3D22WdTX19f1tsLAAAA2oZMXB6ZmD355JN0+OGHU11dnZyLr7/+eorFYiPmNs51BxxwADmdTjkfSjsnNm/eLO7rkiVLxPMh5Q6GtWvXiqzc3NwsruOf0Q9/+MOsmU/KroODg+LkGed2o9FYdiPHAKC40GkLADn505/+RD/60Y9EoepLX/qS6ETcsWOHKNg++uijtGLFClGYO+yww2j16tUijHFI6erqooceeoiee+45+uc//0mnnnrqsK9966230rPPPksnnXSS+Hy+zCGwt7eX/v73v8tFNHbTTTeJv/lrMy7mSS6++GK65ZZbaPr06XTuueeK9z322GOioPjBBx+I+5CJC7bXXXedKLydd9551NramnY9fz8uKEq3jb8eF5S5+MZfk98+/vjjRRh88MEHRTGOA9hBBx0kf41//etfdNddd4nvwfcjHo/TqlWr6He/+x298sorIvhzIVMN/LVPPPFE+t///icKzV//+tdFUOTHjr9/rvh+PPzww7TbbruJnx8Hz+3bt9PLL79M77zzjihacgGfgyaHYf75cNF9JKeccooo9h5zzDHiMeMQOxYOxRyY+Xfp/PPPF8X6Rx55RPxsX3rpJVGQHw8pXPPPXnq8Mn+XsuEnJF/5ylfE/eUnGBdccIF4kYJ/v/lnzsVc/jlneuqpp+iZZ56hE044QRRu+fHmJzKbNm1Ke8EDAAAAtA+ZuDwyMbviiivot7/9rXhuwI0m/GL7a6+9Rpdeeim9/fbbIldm4vfxi+18X77//e+T2+1Ou/6iiy4St5mbCjjbcYGWcaY7+uijKRwOi7zI9/2tt94Svy88yoI/J/N0WSgUEj9LLlhzluSiLTfHAADIEgAAY/jwww8Ter0+MW3atMSWLVvSrovH44kdO3aIy9dcc02C/7NyxhlniPdL3n///YTZbE7U1tYm3G63/P6rr75afHxNTU3i008/ld/v9/sTO+20k/ie0teWzJ49W/zJ9Morr4ivtXjx4sTg4KD8/v7+fvG1+LpXX31Vfv/LL78s3sd/7r777mFfT7pt9fX1iU2bNsnvb21tFfeFbzN/3e7ubvm6VatWic854YQT0r5WW1tbIhQKDfse0s/rgQceSHv/2WefLd6f+bPOxT333CM+95hjjklEo1H5/R9//LG43Xwd37fRfqb889PpdIk999wz7WswfntgYGDY9+O/szn44IPF9cuWLUv09fWN+HPmx0PC91t6bC6//PK0j3/22WfF+3fddddR70O22zDW9x3rc+677z7xPr5O+Xhu27Yt0djYmDAajWm/K9LPht//+uuvp/0MDznkEHHdW2+9lfX7AwAAgPYgE5dPJn7++efF5x599NEJr9crv5+fo3zve98T1z366KPDchs//3jhhReGfT3ptsyYMUNkP6VYLJaYP3++uJ6zqtKll14q3v+tb30r7f2cW6Xbx899AACywXgEABjTX//6V/FK+K9+9athR9D5mNC0adPE5fvuu0+8Os6vaCuPlu+xxx7i1XbuynziiSeGfX1+lZ6PU0m4m/drX/ua+J7ZjsJnw99bOm7Pr6JL+CgUj2tg2Y4bcRendMQ/G75t8+bNk9/mo0vcVexyuehnP/sZNTU1yddx5yd/rDQ+QMKv7mdbmsZHoRh3xapFOor261//mgwGg/x+7ro966yzcvoa/NhxVykfIdPr0/+Z4K85VkdqNjyOgEdl5IO/D/+MlbiDgTs41qxZk/Pvhlqk37Hf//73aY8nd51zhy2PTpA6w5W425k7hpU/Q/7/A+OuZQAAACgPyMTlk4n5JB+74447xJgvZc6VnqvwKcBMfHrsiCOOGPHrcpdu5u4DHgPHJ6iOPfZYkVWVfv7zn4sMzKPguAs3E+dKfu4DAJANirYAMCYed8B4nuhI+OgQH2dfsGABzZgxY9j10tH8Dz/8cNh1e+6557D3SV+DC7254GNZyjEKuX7vvffee9Svm+3IP8/cHe06XgyhxAXQu+++WxwP49DGRTsOijzLi2V+fCE4HHMw5WJ0pgMPPDCnr1FdXU1f/OIXRQDlr8PjI3iMRCQSGfft2mefffL+HC728xzbke6H9JhPFP5+fAQw230p9u83AAAAlB4ycflkYh5HwJmYvx83dSj//PGPfxSF0k8//TTvzJrt+tGeh3CW3WuvvcQYuQ0bNqRdxw0S3FgBADASzLQFgDHxK+gcqKRglo0072mkOUzS52bOhZKKhMP+42RM/ucpc0nAaN+fu0KVr/JL+Dbx7c/2vceaGzXabRvpOu64VOJZu/xqP3ck8Lwq/lnwjFipA5XnWan5WPH3ySafGVk8z4uLtdwVIHW78v3lrmR+Pxcv8zGe+VwjfY70fr6vE4l/f0b62Rb79xsAAABKD5m4fDJxf3+/+P7S8tlseDdBvpk12/XjfR7E83CzLb4FAJCgaAsAOR1T51fGOzo6xLGmbKSwxovHsuns7Ez7OLXx1+VxCj09PfJCAEl3d7e4/dm+d7GDEn/v2267TSz04mUEymIn/0xGC5LjwaMh+GeQzUiPTTZ8O3kcBv/ZsmWLWED2l7/8RSxTCAQC4nhgPsbzcx7p9krvV47B4IJ9tiNnahZ3+feHH89S/H4DAABA6SETl08m5kzG+ZMXG6uZWbNdP97nQSjYAsBYMB4BAMYkHQPiTaoj4RDCs6s+//xz2rFjx7DrV65cOeLxKTXwUXrl95nI7z0aHhnBBWOejZXZncrba9W2++67i66B999/f9h14/1+c+fOpW9961tiqy8f8Xrqqafk66S5ucXoGOWjZrxNd6T7IT3m0uxifjKQ2dHBP4uNGzcO+xrjud38/fx+v3w0Uiu/YwAAADAxkInLJxPzXN2+vr6sOXAin4dwFn333XfFOAblDg8AgFygaAsAY/re974nilxXXnklbdu2Le06Dl/S/ClersRzT6+44grxfsnHH38sloBxZ+TJJ59clJ+4tNiJX6VXHj3iLkvplXvpYybS7Nmzxd88E5Y7gSVtbW3i56Q2adkYjzRQFiR5cdf999+f09fgTt21a9cOe//AwIA4tsbztyTScrHt27eT2njeKy9UU3ruuefoxRdfpKVLl6bNiuXZxPy7p1wExr+D/DPOdvRtPLdb+v3hr6mc78tf48YbbxTHAM8444w87yUAAACUC2Ti8snEPIqBceMBF2+zdb+uX79ele/FC2fnz59P//3vf4ctU+NTa/z9eclytiVsAACjwXgEABgTD8i/6aabRPjZZZddROGVgxeHnVdffZWOO+44cf1ll11GzzzzjCgOcgg6/PDDRffjQw89JDog77zzTnI6nUX5ifNCg4suuohuueUWUdA75ZRTRNHuscceE2GQbzt/zETjGVZ8W/h28BIC/pnw0amnn35aXOZNs2riwiLPoX322WfFq/68xZZnevF2XF4kx993LNwpzZ/LXbt8hI1HYnDYfPLJJ0Wx8pJLLpE/dv/99xedA/z4c1FXminMBf5C8cKx22+/nd5++23ab7/9aOvWrWLWLn+///u//xu2dfiee+6hb3/72/TCCy+I28FdG1z45fuRub2YF4fxkbT/9//+H33yySfiBQU+8ihtLx6pIP6vf/1L/Bz453L88ceLgjD/fvPP+IYbbhDd5gAAAFCZkInLJxMfc8wxdNVVV9Evf/lLsSiZ3+bnL5xp+WQg50QuqC5evLjg78VjurhB5eijjxbLfE899VTxvXgMBHffckH3t7/9rSr3CwAmF3TaAkBOuJj10ksviWIXv4p8/fXXi3EJXBA77bTTxMdwByZ/DAck7nblzayPP/44HXzwwSKwcIAppptvvllsiJ0yZQrdcccdokjMAZHfx7NYS4VD3E9+8hNR1OSiMm+z/fGPfyyKq2rj0MhFRS6gcyGR7zd3NPBjwbchF3PmzBGbdbmQyd0C3EXKxfjly5eLx/6CCy5I61h99NFHaaeddhI/b37s+Y8auAD6xhtviCItz0DjsQy8lZdDNh95U+JCPRequfuWbw+/cLBkyRJx37kYm4mv4yJvY2OjeEz4NvPv9Gi4yMtfmz/OZDKJz3vggQfEEzj+mfNjCgAAAJUNmbg8MjG79tprxYv53AjAJ7U403KRmE+OcdZV84TUihUrxP056aSTxHMkzou8F+IHP/iBeH+2ZckAAGPRJZRnmAEAAAAAAAAAAACgpNBpCwAAAAAAAAAAAKAhKNoCAAAAAAAAAAAAaAgWkQEAaBgv0uIlX7ng2VwAAAAAAJUGmRgAJiPMtAUA0LCtW7fS3Llzc/pYjCgHAAAAgEqETAwAkxGKtgAAAAAAAAAAAAAagpm2AAAAAAAAAAAAABpSljNt4/E4tbe3k9PpJJ1OV+qbAwAAAABlgMfIeDwemjZtGun1hfcuIJMCAAAAQLEyaVkWbblgO3PmzFLfDAAAAAAoQ9u3b6cZM2YU/HWQSQEAAACgWJm0LIu23GEr3bnq6upS35yyNDAwQHV1daW+GTAEj4f24DHRFjwe2oLHQxvC4TDdeuutFAwG6ZJLLiGz2Vzqm6R5brdbvPAvZclCIZMWDv890RY8HtqCx0N78JhoCx4PbUAmLV4mLcuirTQSgQu2KNqOTywWw89OQ/B4aA8eE23B46EteDy0gYu17733HkUiEaqqqiKr1Vrqm1Q21BqvhUxaOPz3RFvweGgLHg/twWOiLXg8tAGZtHiZtCyLtgAAAACTndFopO9973vk9XrFZQAAAACAiYZMWjxI+AAAAABlGpCPO+44cTQQRVsAAAAAKAVk0uIpfG0uAAAAAAAAAAAAAKjGWOnzTXjOG2QfFM1zRyYrXtai1+M1CwAAKF+JRII6OjpocHCQamtrVZvTCupDJh3ZZM6kJpOJDAZDqW8GAABAQZBJi8dYqb8wnZ2d4kkMZBePx6m/v3/S/ni4YDt37lxs2gYAgLIVCoXou9/9rniB+oknnsAiMg1CJh3bZM+k/ILLlClT8KILAACULWTS4qnIoq1UsG1ubia73Y4QlEU0Gp208+/4yUF7e7voTpo1axZ+PwAAoGw5HA7RqQjahEw6tsmaSbmg7/f7qbu7W7w9derUUt8kAACAcUMmLQ5jJR4/kwq2DQ0Npb45mjVZA7KkqalJFG7558BH0wAAAMqN1WqlBx98UCwi48ugLcikuZnMmdRms4m/uXDLz10wKgEAAMoRMmnxVNxQT2mGLXfYAow201Z6QgUAAACATAqlID1nwR4OAAAAqPiirQTLOAC/HwAAAFBqyKSA3w8AAAAYj4ot2gIAAABUMu7Mu+mmm+j2229Hlx4AAAAAlAQyafGgaAs5d4nwZmoAAADQBh7x8+KLL9Krr76KcT8wKSCPAgAAaA8yafGgaKtBb731llhEcNxxx+X1eXPmzBEdNwAAAFD5eHnTOeecQ1//+tcn7SInKB7kUQAAAMgFMmnxoGirQXfddRdddNFFonOmvb291DcHAAAANBqQv/zlL9MJJ5yAoi2oDnkUAAAAcoFMWjwo2mqM1+ulhx56iM4//3zRaXvvvfemXf/vf/+b9t57b7JardTY2Ehf+tKXxPsPOeQQ2rZtG/3oRz8SR8ekpRe/+MUvaNmyZWlfg7txFyxYIL/9zjvv0JFHHim+Xk1NDR188MH0/vvvT8j9BQAAAIDJmUf5lJgEeRQAAAAgHYq2GvPwww/TokWLaOedd6YzzzyT7r77bkokEuK6Z555RoTiL37xi/TBBx+IOXb77LOPuO5f//oXzZgxg6699lrq6OgQf3Ll8Xjo7LPPptdff51WrVpFCxcuFN+D3w8AAADaxPmgr6+P+vv75awAoAbkUQAAAEAmLb1JMwDt/z21mlyB8IR+zxqbma47MVlUzecoGhdr2THHHEMul4teeeUV0bnw61//mk4//XS65ppr5I/ffffdxd/19fViDq7T6aQpU6bk9T0PO+ywtLfvuOMOqq2tFd/3+OOPz+trAQAAwMQIhUL0zW9+U2zs5WWh3PUI2laKPDqeTIo8CgAAALlCJi2eSVO05YDc7w+Rlm3YsIFWr15Njz/+uDwX5Ktf/aoIzly0/fDDD+k73/mO6t+3q6uLrrzySlq5ciV1d3eLzX9+v59aW1tV/14AAACgHn7BNh6PT/iPVOrslY6/Q26QR0eGPAoAAFC+SpVJ+/x9ZDFaqMpcRZVo0hRtucNA69+Ti7PRaJSmTZuW9qTIYrHQrbfeSjabLe/boNfrhx2Z5I4cJR6NwMcr//SnP9Hs2bPF99t///0pHJ74ThAAAADIDXfWcoftwMDAhHfZftb3GZkNZppbN3dCv2+5K0Uezff7Io8CAABAOWTSYDRI63rW0cyamSjalrt8xxRMNC7W/u1vf6MbbriBjjrqqLTrTj75ZPrnP/9Ju+22m5hje84552T9GmazWXTJKjU1NVFnZ6co3ErdMNyxq/TGG2/Qn//8ZzHHlm3fvp16e3tVvocAAABQCVxBF20Z3EKzqmeV+qaUHeRR5FEAAABQxw73DurwdtA0Z6rxsdJMmk5brXv66afFqxLnnnsu1dTUpF13yimniK6HP/zhD3T44YfT/PnzxWxbLvT+5z//oZ/+9Kfi43gD76uvviqu425Z3ubLYxV6enro97//PX3lK1+hZ599lv773/9SdXW1/PV58dj9999Pe+21F7ndbrr00kvH1dULAAAAlY1fBOaCLR9Fm+LIb4Y+aB/yKAAAAJQDf8RPWwe3UiQWoUg8/TR5JdGX+gZAEhdljzjiiGEFW6lo++6774plY4888gg99dRTtGzZMrFAjGfgSq699lraunWrKOpyhy1bvHix6KK97bbbxNIy/vhLLrlk2PfmgvHy5cvprLPOoosvvpiam5vx0AAAAGgYjzu6/fbb6e677x42+qhYev291OZqI4fJQeE4xihVGuRRAAAAKIdM2uZuo8HQINVYaigcq9xMqktkDjwtA9wNysVNl8uV1jHKgsEgbdmyhebOnYstyqPgLl1edDZZae33hIvmdXV1pb4ZoIDHRFvweGgLHg/t/Ft26qmninDMc8SK/e9ZLB6j9zreoy5vF1kMFrKb7LRi9gqqlAyp9tfTWtbQKmRSbf2e4L/v2oLHQ3vwmGgLHo/JmUm9YS+9uf1NMulNYq5tk72J9pq+F1ViJp28VTsAAACAMsYvvn7ta18jn883IS/Edvm6qMPTQS2OFvJFfBRNRNNm5gMAAADA5DPRmbR1sJV8YR/Nqpklumwr+fQXirYAAAAAZYhD8de//nXRZVLsgMzzwjb3byazwUwmg4kMUYPovI0lYmTUIU4CAAAATFYTmUldQRe1ulup3laf/N56o8iplQozbQEAAABgRO5AmF7f8jl1+7qpwdaQDJA6vSjYcuEWAAAAAKDYerwBemvbRjESocpcNSkyKVojAAAAAMoQjybw+/3iKFptbW1RxhREYnG67Mm3aYerj/afb6bZtQbxfoPeQPFoXIRkAAAAAJi8JiKTugJh+vG/3qJ+v4uO381OM4fGwHLRlkckcCY1UDKnVhJ02gIAAACUoVAoRKeffjp9+9vfFpeLodPtp8FAiOKJBH3cFhN/y10N8RhF49GifF8AAAAAKA8TkUk397kpHI1RghL0QWtqHIJBZ6B4Il6xnbYo2gIAAABAVt5QRHRPJC8naGtveFIEZAAAAADQDh9nUkpwWy91uGLU642kjUeo1EYCjEcAAAAAKEMWi4Uef/xxsfSBLxeDP8wBmCNygvSkp4/a/DSvySLGI4j5YRiPAAAAADCpTUQm9YWjopGAWwl4/MLHbQE6bJEpObIrXrkju9BpCwAAAFCGOLDyhl7+U4zZYWkBOZEg/g7rOwMUisaTVyYInbYAAAAAk9yEZVLikm3yBNjHO/xibBef/orx/yr09BeKtgAAAAAw+lE0ptNRJJagTzuDQ29TxR5FAwAAAACNZdJEQrGYLEat/WFRJOb3o9MWAAAAADQjGo3S3XffTQ888IC4XLyuBpYKyR+3+VOdthV6FA0AAAAAtJVJSZFHh2VSdNpCsX3zm98UrxJk/vn888/L8od/7733Um1tbalvBgAAQEXiUMzzw5555pniFm2Huhr0Q8fdtvSGRHcDZ5RKDciTHTIpAAAAaCmT+uVMqpMz6br2AEVi8Yo+/YVFZBpzzDHH0D333JP2vqampry/TjgcJrPZrOItAwAAAC3huWFf+tKXyOfzicvFHo+wZKqV1rYHxFtrdvhpTnPlBmRAJgUAAADtZFJvKELxjEwaGhrbVefUVezpL8y01RjetDdlypS0PwaDgV555RXaZ599xPVTp06lyy+/PO0VjEMOOYQuvPBC+uEPf0iNjY109NFHi/evXbuWjj32WKqqqqKWlhY666yzqLe3V/483rL3+9//nhYsWCC+9qxZs+jXv/61fP1Pf/pT2mmnnchut9O8efPoqquuokgkIl//0Ucf0aGHHkpOp5Oqq6tpzz33pHfffZdWrlxJ55xzDrlcLrlj+Be/+MWE/RwBAAAqHYfib33rW3TmmWcWr2gbjlKr7yXa5HuM9plTJd7XHXyfHv7kMXpqw1MUjoWL8n2h9JBJAQAAQDOZNBShz71PUlvwBdprtkO8rz3wJt3/0SP0wuYXKvb0F4q2ZWDHjh30xS9+kfbee29RJL399tvprrvuol/96ldpH3ffffeJ7to33niD/vKXv9Dg4CAddthhtMcee4hC6rPPPktdXV102mmnyZ9zxRVX0G9/+1tRjF23bh394x//EMVdCRdjecwBX/enP/2J7rzzTvrjH/8oX3/GGWfQjBkz6J133qH33ntPFJNNJhN94QtfoJtuukkUcjs6OsSfSy65ZIJ+YgAAAKCGHl8vvTf4R9rsf4KqrEGaXW+mDd5/0Jvdt9I9H95DwejQUjKYFJBJAQAAoBRaPZ/SJ+7/o82+f9HUWj3V2gy01n0HvbTjFnpo7cMV20gwqcYj3PjWjeLPWJZPXU5Pfe2ptPed+M8T6f2O98f83B/v/2PxZ7yefvpp0RUr4S5Z7nSdOXMm3XrrraJjddGiRdTe3i66YH/+85+TXp+svS9cuFB0zUq4qMsF2+uuu05+Hw+H5q/12Wefib+5EMtf9+yzzxbXz58/n1asWCF//JVXXilfnjNnjii8Pvjgg3TZZZeJ97W2ttKll14qbpN0GyQ1NTXi9nK3MAAAAKhLbMqNxcTJG77M/+aqrcPXyudyKJYI0jWv/py+seTXZNqY7G7gsQkDwQHVv2elK4c8ypBJAQAAQCuZtEtkUiJ/rIduXX0L7TH92/T4NgeFaIA8YS+KtspX2LlY+N///pf8fr84Vs8zWPfaay/5wbr66qtFRyZ3eh5wwAGiM1RZzOvv76eLLrqI/v3vf4uC4ymnnCKKh8piZTG4Q27a4dkx5sfNrJk57H09/p6cPpe/RyF41AD/vCQOh4MuuOAC2n///dN+8fnn6vV6qa2tTYw0YDyaQIm7cl9++eWsP9fNmzeLzw+FQnT44YePeHseeughuvnmm2nTpk3i4/n/hNw9K/nxj39M3/72t+n++++nI444gk499VRR+AUAAIDi4n/D+d9dHlv0xBNPkNVqVf17DAT65MuLmxbTkqk2Mhuc8vv6/f2qf89KVw55lCGTAgAAgBYyaTyRIHc4lUnn1c2j3WbYyaR3EMWIQrEA+SP+inyw8uq0HRgYEMVCDnFctOUFWRs3bqS6ujr5Y7jTk4t8fFR/7ty54tg9z1fl4/XSA8dH6vm4/AsvvCAeVJ59et5554mj+cVUbamm6c7pY35ck70p6/ty+Vz+HoXgIi0Xwsf7uUpcZD3hhBPod7/73bCP5ceOu2RH89Zbb4nH6pprrhGPIXfOcpftDTfcIH8Mz6n9+te/LrYE8u8EF+z5Y3gINQAAAJS3gWBqDn6NpYasJj1VmaqIAsn3DQYHi9ZRUanKIY8yZFIAAADQAl8oSqGYS367zlZHDVVGMhuqiCKpTEqTvWjLxT8+Us+dtRIuzEo4tPMcUz5Sf9JJJ4n3/e1vfxMzUrnafvrpp9P69evFbFWegSp1595yyy1iZuv1119P06ZNo2Ip5KhY5vG0ibR48WJ67LHH0p4U8dxanjfL82RHsnz5cvF5PNYgcxg0d8xy97PNZqMXX3xRdMtmevPNN2n27Nn0s5/9TH7ftm3bhn0cj2/gPz/60Y/oa1/7mvj94KItz9flFnkAAAAozqIofqGUX1Tny2qLxOLkiwykBWRmN6U6bQeDLrGt16ibVBO3JmUeZcikAAAAMNGZ1B+OUDCeKsrWWZOZ1MpF2yEDgcoc2ZXXIrKnnnpKFFq57bm5uVnMS+UxCJItW7ZQZ2enOCYv4e7MfffdV3RtMv67trZWLtgy/ngek/D222+rc68qzPe//33avn27GCnx6aef0pNPPik6Wnk0gTTPNhseq8CjKLiQykVyHnHw3HPPic5mLqZy5zOPuuD5tFxc5+tXrVollpwxLupyNy7/n4+v4w7qxx9/XP76gUCALrzwQlq5cqUo5nIhmb8PB3rGxWLu9uWicG9vrxinAQAAAOrgF3K5G5L/FKPT1R+OZg3IDu60HTIQdFM0HlX9e4M2IZMCAADARGdSbzij03Yok9qMqUw6GBqkWDw2uYu2PAdVmk/Lxb/zzz+fLr74YjEKgXHBlnFnrRK/LV3Hf3PBV4m7QOvr6+WPyTYfw+12p/2ZTKZPn07/+c9/aPXq1bT77rvT9773PTr33HPTloRlw13LXEjlAu1RRx1Fu+66K/3whz8URXOp2MvjK37yk5+IhWZcbP3qV79K3d3d4roTTzxRdM9yYXbZsmWi85Y/XmIwGKivr4++8Y1viE7b0047TSxO43EK7Atf+IK4rfw1eRyDckkaAAAAaJsvHKFQbHjRtsqs7GpwV2RAHgkyKTIpAAAATCxfKEKhePp4BGZXNBK4Aq6KbCTQJfjMfY74uDt3yHLxTsJFW+6u5A5afj/PvG1vb6epU6fKH8PFPK6281Kr6667ThR5N2zYkPa1uZDLxT4uBGfiualSIVBp69ataUuxWDgcFl2dfKy/GAs5KgUXcrnoOlkFg0HRHdzY2Ch+r0uNX4jI/F2G0sJjoi14PLQFj4c28KgjHj/FJ1/4VE3mKKRCbe730vGPfIU6Q6vF20+d/BQ12hrp+reepn9tvU6877SF59ANh19LDnP6XH0t/+7ySSCXyzWuf3eRSdWHTIpMCiPDv7fag8dEW/B4TI5M+m5bP33lqSPJHd1CBp2RXv3qK6LGeNmLd9Hr3cmT4pcsv5x+vN/FZDVaKyqT5vWT5ELskiVLss62YlOmTBF/d3V1pRVt+W3u1JQ+RurkVD7AfIxf+vxMV1xxhRgFoLxzPFuXF6Bl3jkuxvHX4l8StX9RKs1k/vnwfeduYx7foZXivnKhH2gDHhNtweOhLXg8So8zD4+u4qWuvNBV7X/PDL4YheOp003NDc1k1Bup1lEjv88d85Cj2iF3PGhdoS9YI5MWBzIpMimMDP/eag8eE23B41H5mVTX7ZczaZW5hizO5Nxcpy1VDxyIe6iquoqcltTuhUrIpHlV7biLNrND9rPPPhNdrdJSMi688gxTqUjLBVaeVSt10O6///40ODhI7733Hu25557ifS+99BLF43Ex+zYbHmRcjGHGAAAAAOWKwx4vcuWZ8cU4PePj+WFDR9F4ZhgXbFmttZYs+joy6R1k1tvFIrLJApkUAAAAYIIzaTAsZ9Jqc638/hpLHVn19WTUO0iXMFVkJs2raMvzTXlOKY844JEHPGP1jjvuEH8YtyfzzNRf/epXYu4tF3F5BirPVj355JPlztxjjjmGvvOd79Bf/vIXUYnnmamnn366+DgAAAAAGJvJZBIvivOmXr6sNl8oSisaf0PucCetWGiX37+wfhEd1XKvuPyFadGKnB8GAAAAANrIpN5wlA5r+jP5o710/G4N8vt3bz6AfJ7dxeU9WmIVuWchr6Lt3nvvTY8//rg4GnbttdeKouxNN91EZ5xxhvwxl112Gfl8PtESzR21K1asoGeffTatPfrvf/+7KNQefvjh4oj6KaecQjfffLO69wwAAAAAClpEZjU0kM5URQvqnBSOhclsMJPVlNoKHInpKjIgAwAAAIA2BCJRshubyaxvoJ0a6iieiJNepyerUS9/TCiaqMhGgryHmh5//PHiz0i425YLuvxnJPX19fSPf/wj328NAAAAABPEH44S76vlEi3PEevwemmKYwpZFAE5GElU5FE0AAAAANAGXzhK8URCXHaHe6nd46bpzulkNaUyaTiqq8hMmrqHAAAAAFBWSx94/NSZZ54pLqvNG4qITgbS6chhMdGM6hnU5esivS7VxRCOEjptAQAAACaxYmdSTzAsGglYnd0u9iu0e9vJomhDDUcTFZlJ8+60BQAAAABtiMVi4k8xbHNtoS2+Z8ikd5IrtDMtqD+QrEYrrd6+kda67iVfrIPWeom+vT9OTwEAAABMZsXMpJsG1tI2/xtk1leTN7KM9puxnNb3rqdt4QF6f+BGCic81Bqpo7P2vosqDYq2AAAAAGXIYrHQvffeK3YI8GW1bRz4iD7x3CkuL+/5DlmNZ9KSpiXkDsSoJ7yGvNFtZAibKRwPq/69AQAAAKA8FDuTfjb4lpxJP+/7OX1t6eliz8L2vneoK/QeRRM+itI0zLQFAAAAAG3gPQINDQ1iqStfVlt/oEe+3GirI6PeKP7sPmUxWfRV5OWuikSYvCG+BAAAAACTUbEzqSvUL1+us9WRQWegBnsD7T51MZl0DlG0Dca8FI5WXiPBpOq05a3HE7VNjp/UcOW/HH3zm98Ur5A88cQTVK74VZ4f/vCH4n4AAABAYQG53l4vsg1zWCxk1jvl6/oDqY8DbeVRhkxaWsikAAAA45dIJMgbGZDfbrI3yYXhmbUtZDZUUSDeTaGYX2SsSjNpirb84K1uW03eyMR0g1SZqmifGfvkXLj1eDx01VVX0eOPP07d3d20xx570J/+9Cfae++9035Zr776arrzzjtFMfKAAw6g22+/nRYuXCiuD4VC9O1vf5uefPJJmjJlCv35z3+mI444Qv78P/zhD9Ta2kq33HLLqLeFv6805DlX/H8avu08fBoAAACKLxqN0lNPPUVer5e+/vWvk9GobqzzhFPF2AZbA+l1yf21ep2ObMZU0bYv0Kfq961kE51HGTIpAAAAlGsmDUZjFIq55LebHc3yZZvJSCZdlbgcT0TJHXJTpZk0RVvuaOCAbNabyWJUf8aGUigaEt+Lv2euRVsutq5du5buv/9+mjZtGj3wwAOi4Lpu3TqaPn26+Jjf//73dPPNN9N9991Hc+fOFUXeo48+WnyM1WqlO+64g9577z1666236L///a/4P0tXV5coqG7ZskUUe999990xb0tNTQ2VSiQSIZPJVLLvDwAAUE4B+Z577hH/dp522mmqBuR4IkG+6EDWgMzsiqLtYHCQ4om4XNQFbeRRhkw6fsikAAAApc+kvlCUQnGpaKtLy6RWk4HM+mTRtlIbCSZduuaAzJuPi/kn3xAeCAToscceE0XZgw46iBYsWEC/+MUvxN/cScu48/Wmm26iK6+8kk466STabbfd6G9/+xu1t7fLYwzWr19PJ554Iu2yyy50wQUXUE9PD/X29orrzj//fPrd735H1dXVOY1HUHbMHnLIIXTxxRfTZZddRvX19aKLl2+fZM6cOeLvL33pS6JALL3NuOt3+fLloqg8b948uuaaa8T/oSX88Xwf+XY7HA765S9/STNmzJDvt+SDDz4Q81G2bdsm3r7xxhtp1113FZ8zc+ZM+v73vy9e1QEAAJgsDAYDHX744SI78GU1+cPRtK6GlqqWtOsd5tQLvJ6wh2Lx4mwLrlQTkUeRSZFJAQAAyj2TekMRuWhrNVSRw+yQr0ue/qpKayTI99S41k26oq0WcREzFouJwqaSzWaj119/XVzmTtnOzs60cQfcEbvvvvuKzlq2++67i4/nIvBzzz1HU6dOpcbGRvr73/8uvjYXVceLu3u5QPr222+L4vK1115LL7zwgrjunXfeEX/zKysdHR3y26+99hp94xvfoB/84AeiG/ivf/2rmOv161//Ou1rcwGYb9uaNWtEx/HXvvY1+sc//pH2MXwfeBzE7NmzxdtcwOWu408++UTctpdeekkUlQEAACYLPpnC89v5hVm1T6n4uGg7FJCNOgvVWevSrncqirYDARfFEijaVgJkUmRSAAAALWVSvyKT2k3V8o4Fid2UyqSuYOVlUhRtNcDpdNL+++8vuky5c5YLuDwegYuxXARlXLBlLS3pnS78tnTdt771LVG4XbJkiSiMPvzwwzQwMEA///nPxRxb7tLl7l0eqbBjx468biN39vI8XZ6fy4XYvfbai1588UVxXVNTk/i7trZWdOFKb3NX7eWXX05nn3226LI98sgjxX3k4q0Sj3E455xzxMfMmjWLzjjjDHrjjTfE/F0Wj8fpwQcfFO+X8H8QDj30UNHVe9hhh9GvfvUrcX8BAACgcP5wqqvBbqwmkyE9gNdYlEVbdNpWCmRSZFIAAAAt6fO7KZYIistVppphRdsqU2pkF8+0rbTTXyjaagTPsuU2bp5fa7FYRBcpd5xyR2mu+BWN2267TXTlcrfrihUr6Cc/+YkYbcDjBXiMwkcffUT77bcf/ehHP8q7aKvEXby8MG00/L24I7eqqkr+853vfEcUov1+v/xxXABWWrZsGS1evFjutn3llVfE9zr11FPlj/nf//4n2u/558VPMM466yzq6+tL+7oAAAAwPq5AiMJxz4hdDbXWWvnyYJDDdGUF5MkMmTQFmRQAAKC02j2pupPTPDyTVilOf1ViJkXRViPmz58vipM8l3X79u20evVqMcSZu08Zd7AyXiymxG9L12V6+eWXxfiACy+8kFauXElf/OIXxYgDHgzN3ysfmS3uPIuWO2BHw/eFu20//PBD+Q+PQNi4cWPaKAi+TZm4q1Yq2vLfxxxzDDU0NIi3t27dSscff7woJPMsYF6+xsVqFg6H87pfAAAA5SoYDNLpp59O5557rrispn6/i6qNc8iir6caS/2wgDyreh7NtB1F8x1fptnVO4kFW1AZkEnTIZMCAACULpO6Aj5yGmeRRV9Ltda6YZl0ds1immk7muY7TqEW+4yK67RVb6UbqIILmPyHxxrwXFqeH8vmzp0rirM8koBf9Wdut1vMmOW5IZn4/yi8jIxnwfIgaB65IA1k5mIwv60mLupmfk1eQLZhwwYxkiFfPDKBxzlwQfbRRx+lv/zlL/J1/D4uGN9www1yJzJGIwAAwGTk8/nEv+vqs9FBjTdSPBGnFQtpWEBe2LCYdq3+HulIR3NrEhUXkAGZVIJMCgAAULpM6jRNowMbbhKXj9vFMCyTLmnYi3b0NpBep6epTn3FNRKgaKsRXKDlourOO+9Mn3/+OV166aW0aNEiMetV6mzlOa48u5XnynIR96qrrqJp06bRySefPOzr8exY7qzdY489xNu8xIu/Jn+9W2+9lb7whS+oevt5tiwXlPn78HiHuro6MUuXO2J5Tu1XvvIVUWDlkQlr164V92Osr8e3kV+p4WLwiSeeKF/HRWD+jwHP6T3hhBPE/FtlURcAAGAy4H9veU784OCguKwmTzA89GKvjqxmXZajaCaRTfhjQtFExR1Fm8yQSdMhkwIAAJQwk4bClKCEaBSwm4YXbR3m1KnwYCRecZl00o1HCEVDFIwGi/qHv0e+XC6X6IzlQi0v+uJ5tByalWMJLrvsMrrooovovPPOo7333luMH3j22WfTRg0wLopy5ymPJpBw0fS4446jAw88kD7++GO68cYbSU3c9frCCy/QzJkz5UIxLzx7+umn6fnnnxe3l2fp/vGPf6TZs2fn9DX5OBoXeb/0pS+RzWaT38/L1vj2/+53v6OlS5eKbuLf/OY3qt4fAAAAreOiKb94y3Pm+bL6ATnJliUg27loKy4lKBwhdNpqMI8ikyKTAgAAlHsm9YbCREOnxm3m4ZnUaTGLgi4LRyvv9JcuIZ2ZLyM8FqCmpkYUOqurq4eNBeBFXNyJqixmhmNhWt22mrwR74TcxipTFe0zYx8yG8ykRdFolIzGydtoPdLvSanwOAzuTgbtwGOiLXg8tAWPR+U/Hre//jH9e+3nIgR/dR8LnbrroWQzpV5AXbWli6574W0KxwK0+6wgff+AQ2h2bW4vymo1Q6r99bJljYnOowyZVNuQSWE0+PdWe/CYaAsej8p/PK757ypatXWHGH9w/iFVdMxOh6YVbp9as5XueOMDiibCtGKnMH1rn8NpmnMaVUomnTRVOy6echF1ouZb8C+RVgu2AAAAUP74BVg+lcMnb0455RRVX4x9adsjtLr/KTLrq+kI/1lZOm2N9GL3d8gf66ZVg8303S+8pdr3rmQTnUcZMikAAACUayZ9cfvdtG5wNVn0NeSPXkgGnSHtepMhTv/tOp3iFKYNwSX0jb0OpkoyaYq2UlBGIRUAAAAqJSDzTHee837SSSepGpBb3RuoL/KxuJzQnzasaGszG0lHyRFOwZiPorHKWvpQTMijAAAAUEmKmUnbPOuoL/yRuGw1/mTY+IU6m0O+HIj6Km48wqQq2gIAAABUCl7wyQtAA4GAuKwmV7hfvjzV2TQsIDvMRjLrHeSLEYVifgpEA6p+fwAAAAAoD8XMpL7ooHy5uap52PV8+sukd1AoHk4WbStsERmKtgAAAABlyGw20+WXXy7mh/FlNXnDA/LlKY6WYdfbTRyQq4beStBAMPXxAAAAADB5FDOT+oeKtkadjZxm57Dr+fQXZ9JQfIACUS+Fo2GqJOqWwAEAAACg7EkBWU9GarA3ZO1qMMtFW6J+f6ozFwAAAACgUJFYnEIxl7hsM1aT1Th8ibyDM6kuOSIhEg+SP+KvqB98xRZt4/F4qW8CaFgikSj1TQAAANDsv5GBoaKtxeAkm8k27GNMBj1Z9Kluh/4girYjQSaF0eD3AwAAILsBv58iCa+4bDNUD9uxMPz0F1FfsK+ifpwVNx6BW7F5hkZ7ezs1NTWJtzPnsEFyULSaw6HL7cloT0+P+L0wmZJLVAAAAIpt5cZ2Wt85QKcsm0fNzuGF0HyFQiE677zzKBwO07333ksWi0WV2xmIRCkUd4vLVkM1mQzD/63kf0PtplTR1hV0UTwRJ72uYvsB8oZMmpvJmkk5j/L/dzmT8nMXtY+TAgAAjPTvz9NrW6nL46fTls+naqtZs5m0zdUlX7abRijaZpz+GvBX1siuiktIHHrmzp1LHR0donALI7+qr/aA6HLCTzZnzJhBBoOh1DcFAAAmgY09Lvrr6+vFZaNeT985YLEqobu/v19s6lXzBEmXt58SFB01ILMqc7V82R1yi229esPkzRaZkElzM9kzqd1up1mzZk3qnwEAAEyct7d20z/e/VxcrndY6cu7z9VsJm1zd8qXq8w1WTOpOP1lSDUSDIYGxW2olObNiivaMn6lmsMPv3Ifi1XW5ji1uFwuqqmpocmKO2xRsAUAgInAwfGfQ+GY9fqCquWdP/3pT+LfdDW79JRdDY5RirZOc0160TYRIxPhBEvmY4RMOrrJnEk5i3KXcaU8sQQAAG2LxuP00Pub5Lf7vBrPpO4O+bLTnD2T8r+hNmOqaOsOJjOpUVcZ5c7KuBdZSEffcfw9u0AgQFbr8CHOAAAAoK6PdvTR+s7kjFjmDye7WAvFnXnz5s0Tm3rV7NJrHUwF5CpT9q4GVm2pky8PBtwUjatzvyoNMunokEkBAAAmxsqNHdTpDshv+zSeSdsVnbY1ltpRTn+lXvx1hV3i9NdIH1tuKuNeAAAAAGhQPJGgB99LdTSoWbQtFpuxhhY4TqNw3EXza5eOGHoX1+9Je/VdKeaI7T9jugjIAAAAAKA9oWiMHvtgc1ll0nrrLJpvP4UiCQ/Nq104Yibdpf4QioQayGqspt1b5ohGAgupM1e31FC0BQAAACiStzZ30bb+5NZbtbsaeAzUK6+8Qh6Ph44//njVljlVGVtoYdVXSU862nOqYcSAPKVqGjVblovLJr1OHEUDAAAAAO15dt12GgyEi1K0LVYmbbTOpYVVXyOD3kC7tZjF39lMc86mHQNGsRDXpDNWVCZF0RYAAACgCCKxOD38QarL1mTQUSSWIH84olpAvummm8TSh2OOOUa1gOwOhZJLJHhGmGnkom2VxUQ8iZPXTYQiCXTaAgAAAGiQNxShp9ZsFZd5jLpep6NYPEE+jWdST4iLzAleEDFqJnWYUzsVgpF4RWVSFG0BAAAAiuClz3ZQtye54GHp1DqKxhP0adegKNxyQZe33RaCZ4bttddeYiaomvPDvCIgJ9nNxhEDst1sEvNaucAbjlFFdTUAAAAAVIonP95Kfg5rRHTQgqn0SccA9XqDqu5ZKEYm9YWSRWVuEHBYTKMWbXWilYAoEIlVVCZF0RYAAABAZYFIlP714Rb57dP3WkD/+jA1R4xDco2tsO26vJ336quvFksf1NzU2+ntpmgiQHqdg+xmAxl02Y+iOcxG6g1/TMGYi97rMNKXd91btdsAAAAAAIXr8wXpufXb5VNfp+4xj7b0fiTnVTUUK5N2+3oolgiTTmelGsvIM2otJqKe0AcUSfjoo04nHbfoC1QpULQFAAAAUNmHbX3kDia7A/ad00zzG6tFZ6qaRdtiuXftz2nD4FukJzN9nR4V3bTZ2MxGenfgt6LAuyM8na6Nf3/CbysAAAAAjOzNzV3ilBc7atFManBYyWFJlgLVOv1VLPd++gPqC24hs66GrrG9NOLHmQxRemfwl+JyYMsyuuyg71Cl0OYjAwAAAFDGBvwh+fLes5rkUQMStWaIFYM7PCD+jlOEpjobR/w4vj8mfZW47I/6KuooGgAAAEAlGAikMules5OZ1GYyDhtBoEX+yKD4W68zkcNsHfHjGu11PK136HO8FZVJUbQFAAAAUJlnqMtWWtjF7IqArMYMsVAoROeddx798Ic/FJfV4hsKyCZdFdU7kkXZbBxctNU5xOVg1EeRmHZDPwAAAMBklDWTKhoJ/BFtZtJ4Ii5GcDGroZosxpHHIzgsZjLp7OKyP+LDIjIAAAAAGH1Lr8RpzRKQVSja8gKwjo4OsamXL6vFH00WbS36aqoy20b8OL4/Zr1TXI4lIuQKJYM1AAAAAGgvk1YPFW0daae/tJlJB4ODlKC4XLQdaQkZc4jTXw6KxHwUiPooGldnVq8WYKYtAAAAgMo8oeFdDdL8MLUCMi96+P3vf08ul0u1pQ+BSICiiaC4bDWOHpC5c5gDsmQgkByrAAAAAADaK9o6snXahrSZSTs93fJlu2mMTCqKtk6iWDcFYz4KRpNZthKgaAsAAAAwEZ22Ko9H0Ov1tHjxYrGply+rodffK18eq6uBF6uZh2basn5/vyq3AQAAAADUbSTgwqZBryvKeIRiZNJtgzvky/axGgkUI7viiRi5Q26qFJhpCwAAAFCkoi2HY6vRUJTxCMXQ7u7MOSDbzAZ5ERnrD6JoCwAAAKDFTOoc6rJlDrNJ1dNfxdDqapcvO801eTUS9Pn7qFKgaAsAAABQpKUPPBpBp9OlHUlTq6shFovR66+/TqtWrRKX1bBNEZAdYxxFM+r1ZDNUp80eq6QZYgAAAADlLBZPkG9o/IE0riuzkSAQ1mYmbfd0yZedlrFHdimLtr2BXlX3PZQSxiMAAAAAqMwTCg/ralB7PAIve/jd734n/j700EPJYEh29BZiu7KrwTJ6VwOrMqeKtryIjIu2Y30OAAAAABSfL8uOhWKc/ipGJu1QFG1rLbV5nf5yBZOZ1GRI3edyhVQNAAAAoKJQNEaRWCJtnu3wgJwK0ePFM8OWLl1KwWBQtflhyq6GmjECsnRcTU8mEZTjiThFYhGyGq2q3BYAAAAAUGcx7kiZ1KfRTNrj65Ev19nqxj79ZawmPZnJYqiicCyMoi0AAAAAjLGEbISuBjXmh/F23t/85jdi6YNam3oPnnkirfrMQVHy0aL6eWMWbZc3H0eG6HLS6/S0YpYO4xEAAAAANLwYlzlU7rQtRiY9du43qat3MUUTXppbN3fMTLp305k0zXw81dpMtLTZQJF4hGxko3KHTlsAAACAIsyzzTyKZjLoyWzQUzgW1+wismjMStWmeWTQ6WlqtXXsTluLmXSUnNkbDMdFQAYAAAAAbRVtizkeoRjicQfVmOaTXmeglionGfSjj1yo4kyq01EomqBYIlYxjQRYRAYAAABQpKNoyoDMbEMhWasBedAfIqIE8XCHaqtxzKItL1fjki0vewjHqGICMgAAAEBFjUco4umvYnAFkvshOJXW28cevWU3J+8fjyiLxlG0BQAAAIA8uhqYYygkqxGQw+EwXXzxxXT55ZeLy2oYDITkgFxnGzsgOzgg65KdtnyXeKYtAAAAAGj39BfPgDUb9ao1EhQnk/LX0XFnANXbxx5zUGXmRgKdaDyopEyK8QgAAAAARQrIyvlhys6GYCRG8USC9EMFz/GIx+O0ZcsWsamXL6vhle1PUnvQT1Z9A9XZjx3z480Gok/cd1Ao7qXo+iY6dP5uqtwOAAAAACje6S+H2UjhaFiVoq3amZRPcL2x41FyB81kNzZTnX3x2LeBPLTW/VeKxH1U/ekC2n/mcqoEKNoCAAAATMAismwzxDIDdD540cMvf/lLcrvdqi19eG7braIAazdMoQb7KWN+fJXFQtv8L1CCoqTvmUvBaFCV2wEAAAAAxc2kA/4w+SPqLCJTM5N6w156revP4nKjZSnZTF8d83NsZj21Bp4Tl9f3hipmZBeKtgAAAADFmh+W0WnrULFoq9fradmyZWJTL18uFB8j44Its+iryWEZezwCL30w66soFB8kf8SHoi0AAACAFou2w05/meTTX7F4ggx6nWYyaZevO3U7jdVj7lhg9bZ6+bI34qNANECVAIvIAAAAACZopq2Wt/X2+nvzDsh2s4FMOoe4HIiiaAsAAABQFp22plTOC6jQbaumrQM75MtVpmoy6Axjfk6dvYr0lOzy9Uf8FIom9zSUOxRtAQAAACZg6QOzmdQr2sZiMXrnnXfo/fffF5cLtd3dIV+2m3It2hrJpK8Sl4MxHwUiAYon1JmvCwAAAACFZ1KzgRePGYa98C7xaSyTKou2TktNbpnUxJk02Ujgj3hFJq0EGI8AAAAAUISuBl22pQ+Kt33hwrba8rKHa6+9Vvx9wAEHkMEwdhfCaDb3tcmXneZci7YmuWjLPCGPmCFmNqgzYxcAAAAAChvZlW0cl2NoPALzi0xq00wmbXWlGglqrLmf/kqO7BoQp78i8YhoJNDryrtXFUVbAAAAgCIUbe0WI+l16fPBHCqOR+CZYQsXLqRgMKjK/LDWwVRArrbm3tXAAVkyGBpE0RYAAACgxBKJhJxJM+fZqj2yS+1M2u7pki/X22rzbiQIxQJiz0IlNBKgaAsAAACgIk8oPGJXg3J+WKEBmbfz3njjjWLpgxqbene4FQHZmmtA5qJttfz2QGBALDSj8e9XAwAAAIACBYYWjI2YSRVFW5/GMmmXt0e+3GivyyOTOuW3B4LJTFruRdvy7hMGAAAA0BAOx/5wLOvCB6n7Vq2ArLYOb6po2+DIvWhrNdTKb/cF+kRXAwAAAABoZAlZlk5bh4aX4/YpluO2OOrJZBi7G4AbI6z6OsXXqIxMiqItAAAAwARs6WUOZUDW2KbeHl+qq6HJXpdTQLaaDGQz1Kd32sYLm9ULAAAAAOrMs82l01ZrRdv+YJ98eaozt05bh4UbCeoqrpEA4xEAAAAAJiogqzgeIRwO05VXXinmh11//fUqHEezklXfQOG4h6ZUNeQUkHlmb5NtDrX496NaSz3NqJlREQEZAAAAoJx5g6M3EqhZtFU7kxqpiiz6eorEvTSjpimnZWI2k5HqzAtoiuUL1OJopDpLXUU0EqBoCwAAAFCETtuqLEfRbCoG5Hg8TuvXrxebevlyoVZMOY+s4RNJR3pa2NCQ87bdudXLSRebRU6LkZY0xVG0BQAAANBSJi3yTFu1M+mBLZfSTJOLDDqiOrsjp8/h018z7QdSjWEZzaq30ey6cEVkUhRtAQAAACZsPIJJtaKtyWSin/3sZ+R2u8XlQrkCyQVqOg7IDlvOn8f3SUc6Ckbj4u9wNPl1AAAAAKD0p7+yd9qm3hfQWCZ1B5NZ0m7RkdVkzelz+PSXzWQgT4goGEkWjsVy3DKHoi0AAACASjxjHEWzGPWiKJpIFN7VYDAYaL/99hObevlyodzitnM45iNmuQVk5rBw0ZYoGuMNxUYKxAIF3xYAAAAAUGlkl3WsTtuIZjIpL/X1hqKk4yKsOUE2Y+6NBKIQrdOJoi03ElRC0RaLyAAAAAAmaFMvB1DHUEj2FxiQ1RRPJETRlouv+QZk0T3Mleih7uFgNFjEWwoAAAAAai7HLbSRQE3cZRtPxIcyKeW0GFc5BoKLtYFwjGLxWEU0EqDTFgAAAEAl0nGukeaHSUVO7iBQY6btJ598Io6i7b///qTXj/+1+DZXD73a8//IpHPSfN0uZDLsmfPncqfGqv6raDC8kV552kTPfP3pcd8OAAAAACicR5FJsxVtzQY9GfQ60dka0FAmfaftI3qr/2oy66qJLPuQUb9vzp/Ly8hW9l5AwVgvrX1hJv3zK/+gcoeiLQAAAGjam5s7qW3QR8cvnZ12lKsclz4ol5FxV0MikRDdt+Pd1Pv//t//E0sfnnjiCbJacx9pkGlTXyv1hdeIy7UhExn1uf+c6+0WiieiFKMQ+SIhCkQCorvBoC98ZAMAAACAFnBm+9+GHSK/HbfLLDIZtH1wnRsERsuknD85V/Nor0I7bdXMpJ/2baK+8Mfi8txIS16ZtKnKRvFEmOIUoYHAAIWiISp3ef2W/eIXvxAPrPLPokWL5OuDwSBdcMEF1NDQQFVVVXTKKadQV1dX2tdobW2l4447jux2OzU3N9Oll15K0ah2WrEBAABAOz7vcdEtr3xCj3+0lZ5bv520LpeirWOoaMtzbYPR2Li/F+ewmTNn0vTp08dd+JVsHWiXLzst1XkGZCtZDLXy232BPorEtTP6AQAAAKBQq7f10N1vbaCH3ttEq7ak17m0PNOWI+JITQ/S+/2RwmpyambSNlenfLnOWkMmfe7jERqrrGTW14jL7rBLFG25kaCc5d2usssuu9D//ve/1Bcwpr7Ej370I3rmmWfokUceoZqaGrrwwgvpy1/+Mr3xxhvi+lgsJgq2U6ZMoTfffJM6OjroG9/4htgud91116l1nwAAAKBCPLe+Tb7c5dH+XCplV0O11Zz1YxyK4MwjEvgo13hYLBb685//LJY+8OVCtLpSRdsaS/4B2apPFW17A70UjeMFeQAAAKgcyuaB8sikEXk0wkiFVIe8Z6Gw019qZtIOT6ogXm+vyauRoLHKlmwkiPK+hjgNBgdFI0E5n/7K+1kCF2m56JrJ5XLRXXfdRf/4xz/osMMOE++75557aPHixbRq1SqxSe7555+ndevWiaJvS0sLLVu2jH75y1/ST3/6U9HFazZnf3IDAAAAk48rEE7rZCh03tZEBmSzUT/isTlpPIJ8nxxUcu2ebvlyvS3PgOywktVQJ7/d7++viG29AAAAAKy130vrOwflH0ahnakTmUlHOvnF7Kb001/jbSRQU4+/V77c7KjPM5Na0hoJ+vx9Zd9IkPcQjo0bN9K0adNo3rx5dMYZZ4hxB+y9994T8yuOOOII+WN5dMKsWbPorbfeEm/z37vuuqso2EqOPvpoMayYhxaPJBQKiY9R/gEAAIDK9tJnOygaT8hvF7q4ayIXkWVb+CCxa3Bbb5e3R77cVFWff1eDIiDzDLFyD8gjQSYFAACYfJ7/NH1El9YzaSQWp2AkORbAac0tk2rlPvUrirYtzvwzqbKRoBJOf+VVRt93333p3nvvpZ133lmMNrjmmmvowAMPpLVr11JnZ6folK2tTYV2xgVavo7x38qCrXS9dN1IfvOb34jvlYlbr3nkAuQPhW9tweOhPXhMtAWPx+R7PHiT7X/XbKVoLBW0Bn1+8W+/VvGxMpc/SLFEgiw684i3VRcJy/ers2+Ams2pwnS+Sx/+8Ic/iL9/9rOfFXRiqduTymFNxhryur0UNqS2Do/FaUoF5EHvIA0MDpAxXPpuDbV/d5FJ1Yf/vmsLHg9tweOhPXhMJt/jwcXMlze0UTQWl9834PZqOpMOBlJZ05SIj3hb9fGo/HHtPX2kD9tLnkn7A4qiralWZFK/zp/T5xqjMTLrFI0ErgHq7++nhG18WVsLv7t5peljjz1WvrzbbruJIu7s2bPp4YcfJpvNRsVyxRVX0I9//OO0O8dDjuvq6qi6urpo37fS8c8PtAOPh/bgMdEWPB6T6/FYva2bPJE4GQ2pqBIlvaZ/DzjU6/QGEa7qnY4Rb2tjrYeMhuTYB6PFNu77xAtgN2zYIE468S6BQjb1uiKpI3/Tm5qoqaGJ9LrcD2RNrZ5CNJSxB2KDZK2yUl2N9h4rg6GwmWbIpMWh5f9fT0Z4PLQFj4f24DGZXI/Hqk9aKU56MirGXsX1Rk3/HngSXjlDN9RUjXhb66t7yGhIFnRNNs6u6U2Ypcikvqgyk7ZQQ31DXp9fa20k8iQvD8YHyea0UZ2zfDNpQS0Q3FW700470eeff05HHnmkqKoPDg6mddt2dXXJM3D579WrV6d9Db5eum4kPMi40GHGAAAAUD6eVywg45UICQ0d2xprS28+R9EKGY/Ai1x/8pOfkMfjEZcL4QmnOjCmOhvyKtiyGdVT5ct9/sGyP4o2EmRSAACAySOeSNDzn6YyabnMtJXm2Y41ssthTl3nD0c0kUl9Q40EJp2dqi35N2k2O5qIhqZ+DQSSi8gm1UxbJa/XS5s2baKpU6fSnnvuKR6cF198Ub6eK+0883b//fcXb/Pfa9asoe7u1LKLF154QXTLLlmypJCbAgAAABWibdBHn3Qki4hTqm00vS65qStQRgF5tKUPDsV1vgICMr9Cf8ghh9CKFSsK7iD1RpI/bz0ZqcnelPfnz65NFW37/S4KRoIF3R4AAACAUlvb3k+d7oC4vMvUOrKbk3mrrBoJct2zEIqWPJOGozEKxlzistVYTRZj/s2b052pkax9AVfZNxLk1Wl7ySWX0AknnCBGIrS3t9PVV18tHpCvfe1rogX63HPPFWMM6uvrRSH2oosuEoXa/fbbT3z+UUcdJYqzZ511Fv3+978Xc2yvvPJKuuCCC9BJCwAAAMILio6GIxfNEKMSWCSWEIsVTIrjaVriGVpCluumXq2E/mg8TjNtR5LT0EpWU4yspvyPtM2qbabdqi8iq6GeDl3QQsEYirYAAABQ3p5bn55J71/9GfnDMU3kt1yLtlW5LiLTQHPEgD9E8xwnUiDWR02OKrIa8s+kCxrm027VPyC7oYGOmtNCoWiIJk3Rtq2tTRRo+/r6qKmpSVTRV61aJS6zP/7xj6TX6+mUU04R23WPPvpo+vOf/yx/Phd4n376aTr//PNFMdfhcNDZZ59N1157rfr3DAAAAMoOh+BXP+8Ql81GPR28YKrocpAEwlEy2ca/3EALR9GUAbmQ7uF4PC5OPLlcLlq+fLnIYOPhDkZoruN4CllCNKdRN66A3FJdRTNsh4pRFg6jkYJRFG0BAACgfHV7AvTB9uTA/nq7hfaa1USPfbiZ+nyhyjn9pSzahrWRSRdWnUaxRIyWTOPnAvln/pm1DTTddhAZdAay6nVln0nzKto++OCDo17Pw4Zvu+028Wck3KX7n//8J59vCwAAAJMEd9UGIzFx+cD5U8QogcwugGqNFm09wYmdacu7BPiEEy99eOKJJ8a99MEVCFE8EScd6Yh/tOMJyFOcDtLpdJRIJMgX1ImuBr7M7wMAAAAoN9xEwDsV2BGLppNBr5MzXDmd/sq1kcCvgUzKnbYJSohMajcnyKjPfw1Xs9M+tA8jQb6QfnJ12gIAAAAUU7vLL1/eZ3az+NumUqCc0KNoExCQuSDa3NwsTjcVUhwdDIRFgZUTLhdtxxOQG6uspNfpKJqIkydEFIvHxAwxk6GwZRQAAAAApdDhHp5JlSOuKuH0l82krUw6EAgkX/QvoGg7xVkl1hiLRoKQTozsKudGAhRtAQAAQDP4FXZJvcOqyRmwOQVkq7noRVuLxUJ33XUXDQwMFLQboNvjpnDcRwayksOsG1dA5icEsUQ/9YS2krvHSwcF9hHbelG0BQAAgPLPpMmcVS6nv3LNpA6LOqe/cs2k7pCbTHoT2Uy2rNd3eAYoEveTSW8nu2V8mbTF6SB/rJN80Q56t9NLB+98RFk3EqBoCwAAAJoxqAzI9uwBudznh3FHqs1koEAkVlBAzlWrq5WisSjNq5+X9fqXtr5Az3d/j/RkJHP1WXSe/sC8vwd3L7SHn6MPBx8Sbx/dd23Zb+sFAACAyUsq2nJmkzpSy+f0VzRrYTaTw2ya0PuzeWAzWY1WWtS4KOv1/9n0EL3Q81vSk5lmTfshmfSH5f09qixG2uR7iLYHXiEaJPq6d5eyLtpqcwAHAAAATEoDgZC8hIxDspqdqRM603aUoq3yPk3E/fGGvLTdvV2MLMim09Ml/o5TlKoslnF1NbBGe1Pqa3r7KRJL/TwAAAAAygUfp5eKtnVDTQTldPpLmmnLWdo4ylIwq8kg5r9O1P0JRALU4ekY8YX9Xl+P+DtOYaq12ceVSbmRoMZaL7/d4+st60YCFG0BAABAM5QBWZo9JRVvpflhWu+01evSb/PoRdtIQUsffvWrX9H1118vLo8kEA2QK+SiweBg1uu7/cmAzJoddeLY2ni0OJpTX9MzWNYBGQAAACYvPg0VisaHFW1tZXb6a7STX/LpL3Mys/qKnEm5EB6KhcgddtNAYCDrx/QH++TLU5z1428ksKUaCbq4kSBevo0EGI8AAAAAmhCMxMgfjqWNRiin8QgeRUAea9mBdBytkO3D8Xic3n77bbGply+PhAOyN+ylXn8vNdgbhl3fpyjaTnE2jDsgz6iZIl/u9aNoCwAAAOU/z7bcOm3jvIBr6LY5rWO/EG83m0T+LuT+5JJJ+cV8HtflD/upL9BHTY5UYVXiCvbKl5sc48+kLVWpRoJO70BZNxKgaAsAAACaMDg0GoHVKhY7KDfbBoaKulou2laPsvBBYh/qamAckmvGscjCaDTShRdeSB6PR1zOJp6IUygaIovBQp3eTppfPz8tAHPXQ39aQB5/V8Pcuhny5YHgYFl3NQAAAMDkpSzaKjOpMr9xN64W+UJRSiSSl52WHDLpUM4OFNAYkUsm5VwYS8TIaXaKEQkL6hekZc5gJEieSKoDt8HWQAb96CfXRjK9ukW+3OcfLOuRXSjaAgAAgLa7Gsqg05a7ZcNDx+jGOoomdTWoUbQ9+uijxabekQIydxbwLNtaay0NhgbFiIRGe6N8PY9N8IT75be5E3e8AXlBY6po6wq6yjogAwAAwOSlzKQjnf7S6siu9MW4Y5f8pEVlhZz+yjWT8p86W53otOURCcpu2+2uLgrGXOKyQWcWHzdes2unyZf7A66y7rTFTFsAAAAon6KtRgOye2jhQ64BWXmfCpkhNhYRkBNRsak3EU+IEQlK2wc7KBhzi8s60mc9qparnRtniK/BvBGXmKULAAAAUG4GA6lclzbTtgzGI3hCqduey3gE5X3yKQq+auMX8zmTmg1mcdKLC7fKk2EbelopEk9mUruxRmTX8VrQoGwkKO+RXSjaAgAAgCYM+MNlOz8svashh05bFe4TB97W1lZqa2sTl0cKyNxpy8fPnJbkcTSpA5bHJmzsa5MDstVQRQ6Tg8arxekks746eZ8iLgpGg+P+WgAAAACl0l/Gp7/yzqQq3KdcMikXTrmBQK/TU5W5SmRSqZjKXbfbB3spnPAmb5OpmqyG8Rdtd26aJV/2hMu7kQBFWwAAAND0UTTlpt5C5m1pNiCPs2gbCoXoggsuoEsvvVRcHu0omkFnEAHZHXKLEQmsx99DXR4PhRNuVQKyyWAkmzF5lC0Qc1EgUr4BGQAAACavcj795Qnml0kdaae/ipdJlbsOOJN6wh5RrGW8d6HHy3k0OWrMaa4mk2Hs2z6S6TV1ZNJVicu+yKBoVChXKNoCAACAJgykLSJLBWS9TkdWk0HTAVlZtM1lEZk0P6yQgCy+V3U1OZ3OEa/ngMwdDzqdTl72wMfR+Bjadtd28ofiFEskf+5VppqCAjJzmupIT2ay6uuox+cSXb4AAAAAFVG0LYvTX6nb5cy3kUDxuWpnUtFVq0te5kwaj8dFJvVH/NTuaSdvOHXirtpSWNHWbDCRzVhLBp2V9GQt60YCLCIDAAAA7W3qtacXPjkkByMxzQZkjzIg5zA/TI3Qb7Va6e9//7tY+sCXxwrIUmcDB2NeTMbzbU36Gjq48U8Ujrtp95n6tC2+43H2kuvona0e0XUbipgoHAuTTW8r6GsCAAAAlCKT8ovsysVc5Xb6y5lDI4Ea4xFyyaThaJh0ilAqje0y6U3kDXup2jyTDmr8o8ikB82xF5RJ9To9fW3BLbS9Py72LbiDQZGJC825pVB+txgAAAAqOiDbTIa0pQhSoOT5YlqdH5a+iGxixiPkQppfK3GandTh7aBWV6votu3x6KjaNEdct7gpVnCn7dTqGtLpvCKU9/vCFIqFyGZC0RYAAADKA59QGhw6/aXsslWe/tJyI4Eyk+bSaeswm1Q5/TWWYCyYVjTlRoIuXxft8Owgu8lOPW6iGtM8cd2ixnjBBdZmp5Na+1yk1+uo3x8WIxKMivxdLjAeAQAAADQRkKWibWZAVnY2hKNxisaT8660ZMCX/RjdSByKEF3MQjR3uiq7Ggz65JiJ/kA/xWNOWtPmF29bjTpqqUkeVytEo4O7KxJEOh25ArGyniEGAAAAkw8XLiOx5DKtOsW4rszTUlot2o60RC2XRoJAEe8TLwPjHQsSaUQCz7V1+ey0pS95u2tsemqoMhScSZscVkpQItlIwEXbWHlmUhRtAQAAKlQkFqdQtDxmigYiXOCLjxgwleMEuLtBa/p8QflyQy4BWYXxCOFwmK6//nq65ZZbxOVsgtH0rgbGoxG4mPrOltjQugeifefayWEyFR6QndxVmywSe4KJsg3IAAAAoJ5wNCZyaTkvxs0scmp1PIKUSY16XW4ju8wTk0lFp2tGzmy0N5LD5KBXN/rk9x2wwCbGbPHYhMIzKTcSELkD/JyoPDNp+fUGAwAAwKih+IO2PnpzSyd9uL1PHAm6+tg9aU7DyIsBtLzwQWI3G9ICZS4jCCZS31CnrUGvo2pbnvPDwukjDHLF3QmvvPIKRSIRcTnXoi0fR/MHLfRJezcNhjdSmHZQxDiNfJGZBRdtQ/EeWuf5P4okPOTV7UaByNKCvh4AAACUJ85r77b20FtbuujjHX0iu1134j7UIE7llG8mlU5/cbNBLJ4Q2U+LmbTeYRHjHPLJpL4iZVJeTMsju6QTXxIeobVjQEet/X3UG1pDJtMgeeItFInvVHAmHQxtoU88d4pMauo8mEKx5VSOULQFAACoALx04IF3NtLbW7vTO1FjRO+09pRV0bY2S9FzombAjlefPyh3ZOQfkMd3f4xGI337298mr9crLmcbOcFFW+VRNMnKzzzce0AbvP+k7tB79PZLRDccdUPBXQ1mY5RaA8+Ky1Vem1gsAQAAAJMHd3r+7e3P6IO2XnnMAHMHI7SmvZ8OWTiNtKx/lMW4maeluNtWS40EfHuknJxrcdyhQsYeK5NG4hGKJWLDciZn1Zc3eMTfa913kCfaSq92Ef3zlH8WXLQN0wBtDzwvLre5Z5M/nBwJVm4wHgEAAKACPLtuO72ysSPr6ADX0DKFcj6KplxMprXjaPwz94WSt6mxKreAzJuIzUPbiAsJyCeddBJ98YtfzBqQORz/fc3f6Yv/+CLd/u7t8vvbB8O0vjNAvmgndYfeF+9rdjTT0qalBQfkWbUz5MvesEsUbTmIAwAAwOTwyAebafW2nrSCbba8Vymnv7TYZZtP0VaNxoixMmk0HqVbV99KRz5wJD267lH5/Ru6gtTuClN/eJ0o2LIljUtomnPasK7cfC2ony5fdodd5Il4qByhaAsAAFABtg+kOhpXzJ9CFx60i/z2gD/7bCktGQyExwjI2u20Vc6zzVZwHol0vK5Y94ePoT3+6eOiu+HuD+6mDX0bxPu5o4Ft8/83OeuLiE5YeAJZTdaCA/LUqqnyTNtAbJD84ZBYhgYAAACTK5NyGjh68Qz65n47yde5FHlPq8o5k/Yrdyw4csukapz+Gosv7KNnNj4jMuEfV/2Run3dFB/qsmVb/c/IH3v8TseTxZh7nh7JjJrpaY0E3GkbT5THXGUlFG0BAAAqQLcnIP7mk/nfW7GE9pvbMlQ6K4+APNamWy0H5LQlZHnMaXMOHadzB8Pj6kblz+nu7qaenp6sn8/BuD/Qn/xYStAtb99Crf0h+rwnSNFEiLYH/ieu46NqR8w7QpWAbDVayWZIjuIIxQbF44plZAAAAJMvk/JM1W/utzPtMaMxa0FUq8r59Nd4Om2Nej1ZTQY5k47HWJm009spF0w5F97x3h20rj1A3Z4IBWN91BlcJa6rt9XT/jP2F3myUNOcqTEc/ugg+SOhslxGhqItAABAmeNw1DUUkJuquFtSJ/5IG2MHy2w8QtairSIg+zUWkJUF53yKttLsXj4+OJ5CdCgUonPPPZcuvvhicTlTsosh1VGwascqemzta+Jye+A1CseTnTBHzjuSnBYnWQ2FB2Tu1HWa65K3L+6iAV+kLAMyAAAA5I/zjHdoZFSz0zZsV0E5NBIoM2lNme1ZSG8kyP3FeOkxGm9RfaxM2uHtSHv7qc+eov9tXC8ub/M/T3FewkFEJ+98Mul0OrIZkr87haix1JBJb0vPpLHyy6Qo2gIAAJQ5PsoUGJpl21yVCjm1NosckLU+V3Ts+WHaDci93vEFZOX9HO+MN4vFQmbz8CcU2QIye27bHZRIxGmr7z/y+07b5TQxa0yNrgZWa20Qf8cpTIOBQFkGZAAAABh/l62yaGs2GuQ5sOXUSFBtNYku1LLKpGkju6x5Z1Le0zDe7uHRMil32ipxU8HLO+6ieIIX2CaXhel1evry4i+L02EmQ+HL3Yx6I1WZasXlcHyQvOFoWTYSFLZtAgAAAEpO6rJVBmS5O2CAh/8nRGFXS9ttRwrIDotRLOmaDOMR0oq2gTDNSDao5sxqtdKjjz5KAwMD4nKmTk96QGbeyADtCL5Krugm8fbixsW0S9Mu1OZuI7Mhe9DOV4OtQfzesb6ACzNtAQAAaLJnUouYKar18Qg8Z1XKpNmaCDR/+msc4xEyx0AM+sNkqzGqmkn59FemgVArbQ+8SMFYcpTXwbMPpilVU2i7e3vBi3EZd+zWWOppINRBkYSPPIFwWTYSoGgLAABQgV0NmUe6uNtWq0Vb7gKWOi9GCsjlMj+M57dNZKftaPaevjfdd9J9YlYtLyFrc7VTW/th9LH7dvljTl1yqgi1PABZjYDMmh3N8uX+gIu84dSSPAAAAJgcmbQl7fSXmTpcftHJGYrGyGIsbPFpsXiCEYoPHU4bMZOWQSOB2aCnKotx3Jl0ao1d1dt1zPxjREHWrDfT+53vkzcYo9b2L9Bb/VenZVKJGp22rM7WQFvd4iL1+l0UjKQaLcoFxiMAAABUaNG2XGaIcRcwz3VldUMjHcopIPf7kwHQZNDJy8W0ULTlkQfVlmpaUL+Ajlt4HJ208Juk1xmoP7xOnvV11Pyj5I9Xq2g7U7Gtt8/fPWLRNhKLaH5sBwAAAOSu25tbI0G5jusa1mmroUzKmUoq2nITgXhRXiOZNBKPUKOtkRY2LKSv7vJVWjH9SxSJ+8kT2Squn1M7h/aetrecC9XKpFOrpsqXe3y95Al7hn0Mj2r4rO8zCkRSv7tagk5bAACAMtczQkCWZtpqfYbYWFt6hwfk5Pxe7QTkkHwMLb+AbC4oIEciEfrLX/5Cfr+ffvzjH5PJlF4wDkaDaaF3wB8lvc5EhzX9merrPqKZDbG0ObZqdTXsPW05NZv3IqdpFjlNs0UI5gKy8rbwz21N9xqaVTOLGu2prdIAAABQvno8wTEbCTiTKq/TkoFADkVbszZPf3ETRCiaXEDbmMdohMzHR7lgt3iZNEYWQw0d0Xw3tTS9R4ta6kWGFnlRZ1StaLvX1L3pvbat5DTOJIuhQTQScAZV5nVf2Ec9vh5qsjeRzaS930sUbQEAAMpcl1txFG3EgFzeXQ22oQUWWpsfxh0WfNQv39lhanQ1xGIxev7550VQ/sEPfpA1IBv0qZ9bvy/5c+PC7eFzj6Sl05NH3zggG3QG1QLyEfMPoeW1PJvYRLUmg+iu4MUPRmW3dMQvgnMsrp0CPAAAABSmy+MXf1uMerHISznTtnIyqTY7bce7Y2H4ngV1Myl3soZj4ayZ1Ki30kk7n0wz682pTKpXL5OetOhkWv3ZbDIZzFRlNIrbwX94dJiE86hWu2wZirYAAAAVchSNN/M6FEFSeRRNywFZ+Yp+raL7VIm395qNegpH4xTQVEBWLnzIfZ5tZic0LyLLl9FopLPOOou8Xq+4nOnRdY9Sf6CfZlTPoGMWHEP9/lSBtM6R+ngunHI4Visg280W4ho7dzIEIyTCMS9+cJBD/hg+nsaFWwAAAKgMvMSr15ssHHInrbKbsVxGdqUVbRW3uRxOf413x8LwRWQhVTMpF2IfXPugKMbOrJ4pRnNxp23qthrSMil/nEmv1kxbq3w5FNFlLdq6Qi7R6KBVKNoCAACUsVg8QT1SQK4aLSCHyrqrQQrJ4WhYU10N0jzb8XQ1mAx6clpNYunFeDptORSfdtppYlNvZkDm0PvkhifFAjK9Tk/HLjiWBoa6Gli9PfXxanc1cNC2mfXEzx384YTosOBOWyV30K3prgYAAADID2eZ6NAWr8zxBzj9NbFNEPlm0tq0019hVTMp7zB46JOHRHGUl5Fx0VbqtOWObLs5tWorloipevqr2mol/dBzo2A4mXm5kcBJTvE+bjDo9fVSnJJjJbQIi8gAAADKGB+FknY5DQvIylfNNdzVoLxtoxZth7qItTQeoTetqyG/gKxcvMZPdNRcysWhlLtsxfew1omirBSQ7Sa9KKpKOLxaDBbVuho4aDsseoonYtQX6CR/OCC+h4TvZ4+/RxRzAQAAoLIX42aeLtJ2I8HYmVQ6/cU0dfprqIljPKe/LEaDnLPVXkTGXazukFtcrrfVi4aTQX9U7rJVNpxwgZfHaylHKRSCv5bNrKNYPEpd/jbx9ZWNBGJcVyT7wlytQNEWAACgjHWNEpAdZiMZ9LqyOoo20iIyJoVJniHLR/C0oF8xP6wxz4CsfELAAdYTiuT1uVz8dLlc5Ha7hxV8+ejXQHBADsiRWIJcwdiw0QjSLC8eoaBmQN7oeYae7foavdjzHfqoYx35w/5h82wBAACgQjNpVXomVY7sGk8n50RnUq4jKm/zSCMStDrTNt9FZMoMPp5GgtEyaae3kxKUfF+DrYFcgZjc11qnOPnFfBEfTauaRmox6U30qecBerbrq/RU23m0w70jrZFA6/NsGYq2AAAAFdrVwK9c11jNmu+0VRZtRwvINsUMMa10NhSy9CFzhm++nQ2hUIjOPPNM+u53vysuK3GXLXfbSkXbgaGOBvG23ZAWVu0mO7VUtZBaeBxDraWG4pT8nWvzdJIn4kn7noFoQHwcAAAAVH4mrbaaSeqnLIdGAh7nIB2rL5fTX33KJojxZNKhDB6OxfMuRo+WSbloK98uW7188it5O1PZ3hf2kc1kUzWTmgwmkXPjlPyebe7OtMYB7gCWCspahbQMAABQxnqGlpBl62pQFgXdwbBmulNHCsi8ZZiPnI0VkLUUktMXkY2/q0Ht42jtnvbU9+Ci7QgBeTA4SFOdU6nKXEVqmlkzR77MXQ3caSuNQxBH5BJEOvnpGwAAAFRy0ZZPfvEcfzao0fEIfOrJxYNPxxjXpdXTX1Ijgc2UGnWQj7oiZdJhRdsRGgkGQgM0tWoqOS3JebNqjeya4pgpv73d3SEXbcU8W38vWQ355/eJhEVkAAAAFRqQla+ac57khVejdbKWAgddKRiOFZA5hEoCGtnWKwVkqwoBOd9uaKvVSv/+97/F0ge+PFJA5qNo6Vt6jfIIBe7GnuZU7xiaZEHdAvlyu7eNwvGhbb0Gi5hny50UWj+OBgAAALnrVsxUba4aXgjjDOoORkSnLRfMlLNMtYCLyVL9VTmDd6zTX1y4HU8GVBP/PKWRXeNpIhhWtA2EaUadOpm0y9uVnkl9wzMpz5rlF/OnV08ntc2qnpvWSMD5k0+j8fd0h92iE5f/1ip02gIAAFTA/DCOvY1ZA3JxXjVXCxeShxYN59zVoJVOWw7IUtF2PLPDMu+zcutvoZRF2zpbXdpRNGl+2EBggJrsTaLrQW0zaprJrK8dui1tFI1FxeIHHovgCXtEQAYAAIDK0eVOzq+vs5vJbBw+J18qhEbjCU3Ngs324vloOxaYzZy6f1q4L5yneX+BakVbFTNpl69r5Ew6VLTlsV7FyqRz6uYNPVMi2uHZTpF4chkZ59FgJCgaCbQMRVsAAIAK6LStd1jIZNCP2Gmr1RliylCYV9FWCwE5lArI/PPXakB2mBzU4fbJb/OmXh5VwIsYZtbMLMpsWZ5d5zAkO3g9kQFRIObvJ+bZhgNkNWr7KBoAAADkjrtNuYt2pJNfTHnaa7DcM6lJW5m0z6/csaDdTFpnTRVtTTwyw6IveiZtqaohm75JXO7wtYmCrZRJeZ6t1sd1oWgLAABQpjgkekPRPAKy9jptBwLjC8haWETWX+A828yier4BORKJ0J133kn33XefuDxSp63ZYKZBf0IcAzMbdGQ368Vc2WpLtehqKIZam5WqDKkjbjs8O0RIdgeTx8+whAwAAKAydyw0ZdmxUNGNBBo4/VXojgWpQ7oYmbTb1536uFiUujzJPQfcZcsjMiYikzqMyUwajPqoL9AnMimP6+KxXVqHoi0AAECFzrOttIBs01xADuZ8jG4kfFRQN86AHIvF6KmnnqJnn31WXFbi42WLGhfRdOd0qjbXUjBiFBt0reYQ+SI+EZBn1cwii7E4YbXOzgF5WtpitGA0mFz4gC5bAACAis2kLSNmUou2GwnSMqm5rE5/pWXSEnTajpRJeZRYi6NFZFJeMmbS1ZBBb6Z4PEYWU0gUbzmTzq6ZXbRMWmO1yKe/WLu7nVwhl2gkKIdxXVhEBgAAUObzbEfvtFUE5KGNuJoNyLbyCsi9ioCcbZ5wLnibcrXNLArqg/78Hh+j0UinnXYa+Xw+cVnp+J2Op4NnH0yN9kZa09lKetKT3WSh+Q014jgYz+9qqWqhYqmz2dM6bbloy/PKpIUPAAAAMLkyaa3GxyModwuMtYhMa6e/ehVL4MZ/+it9EZkamZQXfp2525l09u5nk9PipFVbW8liMItTYFOcOmp1tZLD7KDmqmYqlnq7Te60lU5/caHYH/VTjaWGtA5FWwAAgAo4itZSpkfRlIXK2nKbH6Y4ijbeTlups4EfGx4VEU8kSJ/jNmUOxWeddZbY1KsMyNzVEI6Fyag3isvuAInjZ/y/xS3TaZ/pycItH0Urlhqbg+osM+S3O32dFIwFxcZenmcGAAAAlZlJy3WmrTKTltvpL2XBebwzbXk3htNqEkvN8u20HSmTctE2moiKMQR82RNM5lHOqHvPnE9zmoPi/cXMpI2OKqpSFG15XAOPDIvH42TQGygWTz+tpjUo2gIAAFTweAStB2S3ovu3xppHp60WArKv8K4GVm8309Y+LrYSuQPhMYvXYxEBORYV4xBiiRj5gnp5ycKUajs1OZrEn2LiDoom+zTaq/ZnNMU+l358yDyKRCNi4cOm/s105fN30cKag6h3l9n07f2L1/ELAAAAWhzZpb3xCJ5QMpNyYuLiZbmORygkk9bZLHLRll/45xf9CxGJR0QmNZgNIp96g3ruJBDXTa+tpkWNc6jY6h1VVGdaQPvW/oIW1M+jb+41VTQvcCF55ZZVdMfbz9HiuoMpEtiJTlmmvcYCzLQFAAAoU92e4JgB2WYyksWo13BATi0rqM4jIGvhKJoaSx+GzRDL4zHiMB0MBsUfvqwMyFys5S4GuathKCCPNGeuGOodDmo070H6RBOZ9GYxGsFqsNKj656kTd4X6NkdV9F/Pn90wm4PAAAAFDeTmgy6tOKskvJFaW02EiQzaZXVNOapJ62e/nJYOPcbCs6ksXgiLaOPN5NyDpUyKXe0uoNcFJ/YTGo2mKjOVk31ll2JEvVidu5gaFCM63p03WP0meff9GTrJfR66yukRei0BQAAKFO8fZVxUXa0gifPqOJZY9oMyGH5PpjHCJlp88Mi2ulq4IBsNY0/IKfNEPOHaG5Dbp8XCoXo1FNPFVt6n3jiCbJak4XjweAgnfPkOWKe7fKpy6kq+mU5II9U3C/Wtl6iQeLoHo0ZiS/wLN3/bXlWXK8jIx0w4/AJuz0AAACgPi7SSZmUc8ZIBU+H2Shm+XNB0KXhTDpWE8GwRoISZ1IerSWd/mosoImA1SoWsHEmrR7jFNxYmXR9z3o6/5nzxTKyFbNWkDtwhGgk4N+D8e6DGG/W5uV3/nBcNBDUW+tFQfndjtfF9WZdDX1h5hdIi9BpCwAAUIY4oElLB5qctlGPL0kjEnyhKEVicdJiV4Mzh1CYNj8sHCt9QB6a99VgLyx0Kjtt+/NcRsaC0SB1eDrkzgbeitvh7aA13Wto2+A2cvGJRZ2OzAb9mDPa1FQnirbJ38tAJEGza2fTh50fkis0IN7XbNmL5tRhNAIAAEA546aASCyZQZpG2LHAOKtKo7DynZlabKFojMLRZEZ2WnLIpBrqtOUCeDxR2DzbbDsaxvMY+cI+sVxMmhPLS794Ge0HnR+IrOryJ0QjwWjF/WI1EiQoQdF4giJxonpbPb245UWKJpLPQ6ZZD6Ip1VWkRei0BQAAKEMcpDh4sOZRAnK2ZWQT+cr2WIVP71DRNpeuBl6QwMfu+IlBqQMyz57lThE1ArKykDqYR0C2WCz0yCOP0OsbXqeP+z6mQCJACxoWiIKthLfiur0Jsht11Fw9sQG5zm6jcMJNHb736a/vD9CBs/egg2YfRN/e5Xp6dvPTNMWyghqrJq6IDAAAAKWZZ6vs5OQXvfnofT7LV4uN57hKyq3TVjnPtr7ATtu0TJpHNzRn0ocefohWrl9JH/d+TK6oi3Zq2Im6vF3yx9iMNTSYGNqxMIEnv1it3UrBWC91BNfQjW/20zELD6eTF51Mn3fa6fW2/9B026HUpJHnR5lQtAUAACjzgNxSPXrwSV9GFtJM0dYb4sVUlHNXg9TZwBtfS72IrC9tS6+1JF0N3LHCx884KPvIR5/2fUqukIu2urbKH2M11FCgRAG5weGgULyPPnLfSh+5+fb66JA5h1C9eTfao3YhRWJhaqrK7XEHAACAMsikYxVthzIpHw7iQqkyo2plMe5YS8iGLyKLVcSOheGnv/LPpGaLmQwWg+iu7Q/20zbXNvljjDon6XXJw/4t1XaaSHU2G7mjm+hj95/pYzd3hNfSHlP3oAbTXrR33e6i47bBoY3fxUwYjwAAAFCGeEatZOxO21QA09IMMWk0Qq5dDcqQXOpOW2k0BatXsdN2vMcFrUYrzXDOoB5/D23s3ZgWkHVDAXnKBAdkPgJZbZwpv711MFlM7vclHzturlHOTgMAAIDy0+3NvdO2JmOOv1Yoi7a5zHGVTn9pIZMqO20b7KXPpCa9iWZUzyCTzkSbBzbL79clqkk/NDZryhgNJ2qrt9vJmSWTDviTBXc++GU0aLM8qs1bBQAAAKodRVN2MQxoqGjryTMgK4u2fBRNuZ12okkLH9RY+sAdHdLpwHwCcjQapfvvv5+ee/I5ikVjZNAbaLpzOrnDbvljDFST6mqY4E7bapuZrEYnWfR14m3utuDHbNCffHLjtCYXUQAAAECFZNI8R3ZphXI8Qi57FpRzbUt++kuZSQs8Tad8fMaTSV946gWRSVmNtUaebct08Rp5B8dEZ9Jam5mcphlyCZQzaSAcpwAPuBWZVbt5FEVbAACAMpQekK05BzCexVrWnbZDAZnrtcGhUFjuR9F4nlvdUOdJf54B+eGHH6aXn32ZYrFY2hIISYID8lBXw0QfReNCPHdUOAzTxNsDwQG6+4P7yRdJbpiu1saUDgAAAChAtydVNGxyWvMa2aUV5Xz6S5lJC51py6fzdOMs2vKehVefezUtk/YH+uXLsagikzonNpM6rWYyG6xkNzSJt9f3rqenNjxHsaFFZCjaAgAAgKqUywEaxirapi0VCGmz0zbHmWbpM8RKF5L7/IqjaAWOR1AeR+NOj2g8+ar/WAwGA5144ol0wKEHkF6feh2+L9AnX47HquXwPeGdtlaT6PJ1GLmzIen2926mHcHXNN/VAAAAALkZGMqWnNGk7tPyG9lVvqe/0haRFTgegU9ASZl80J/748OZ9IQTTqD9D90/LZNKRVvOg+EIj+zSidNlE71fo1rKpEONBOwPq66ivvDa5PUTG5HzgkVkAAAAZcg1FC55npbVaCjLo2jKrganJbeuBptyWy8XbR1UEm0DyW5WDp6FdjWwuqHZromhxyiX7l2TyUTf+c536LVPXyO/Mdm9mtnVEA0nj6JxCJ/4gGwWAVnqapBMs67QfEAGAACA3EinuHLpUFVm0kFFoVRTi8gs4zv9NVbBuhjiiQS1u3xyluRZu2o0EnAW5WI8f30+EZZrJn1p3UukNw1vJKix1JA3aCCLXkdNVVZVbme+nbZ8+suoS3/i0GTeTfxdo+FGAoxHAAAAKOOAzAsdpPlQI1F2DAxUSFdDKWeIcTds22AyIM9tcKoWkCnP42jc1XH3W5/SXasHqWNw+FE0h8lB3qBZHEWbWm3PKXSryWI0kMVkpFrTfPl9s6uXkEmfPBKH8QgAAADlLRLjuaCxYV20OY1H8Gt0PEIZnf5q7feSP5z8+S9sqlHla9ZLjQSJ3Meq8e/BzSvX0gPv+WjAF5NzqpRJayx1FInpRLfD1OqJ77ioHuq0bTAvld+3e+ORpNMZNH/6C522AAAAZYZf9ZYWJuTS1cBFRYfFSL5QlFwaGo+QXrTNr6uhlAH5s+5B+fLOLbWqfM3xFG0/aOujFz7dQZ5gjFZvidOuQye+vrvnd6nL10W9Xj8N9vExNB3NaXBSKXAxvsW6B0237U81VS46bOoVtK2HNB+QAQAAYGzKE1y5ZLn0mbbaaSTwhMrz9NcGRSZdVIxMGgiljVkbycqN7bRqazd5AnF6rzVMcxr4+UqcLl9xuSjcDvj0yUxKOprXOPGZtMpiEmMbZtgOpr7omzS91kx71JxHnS7SfCMBirYAADDp8SvBY3WragkXbBNZjpmNhj+Oi7YckLVyfwvZ1FvKou2nXUUOyDnMEOPH8JF3PqVX/3QlRWNRMnz/EvkI2zELjhEf88amPnquzycCMncElwI/gTPqTbSb88d0zYlz6L63eokoef/G2FUCAAAw6Wglo+U7riuzIDtajrMY9RSKxjU1skvas2AzGXI+QZWWSUt0+muDMpNOUSeTKjumuZFgbsPYXbaPvbuBXvvTVSKT1v/4p+L9Br2BTtr5JHH5P2u7aFVfqGSNBHqdThTjA5EqOqDx53T5MXPophc7eT0aWU06yrFOXxIYjwAAAJPa+s4B+t6Dr9EfX/pYhI5yoAy5uRY7eYwCC0fjYu6Wlo6i8bxVDsn5j0eIlbxou3OzSkXbjIA8ljXt/bSp1yO/HYwmqM+b/oShwxVOLiHTlbJom5xrmyAdBcIx+chclVlPZmP5PCkFAAAotre2dNF3/vkq3fXmp+KF2PLrtM21kcCiuU5bKZPmeh+0MB6BC/xSJrWaDDSrzql6I0F/Do0Er23qSPu4Pl+MQpH051QdrqgonJa2kcBMep2BApEERWMJcgeSmbTOkdtzkFJBpy0AAExq//mkVQS11dt66B/vbqSz992ZyqqrIeeArJwhFiZbjVEz4xG4GzPXrhK72ZB+FG2ChaIx2tKXLJZOrbHn1FUynqNoY4X0xz7cQnqjifb7zuXkDXnF5baBMDU5U60Cne4Y6XS8dkFHs+tL12nLRVt+fLu9AfKEpIDMv3+l6UoBAADQoqfWbBOnov63YQe1VNvo+KWzSeuUo65yzUT8cV2egCh0csPERC+lyhSNx+WiqzPHcV1aGNnV4w3Kp7N4ni03QaidSceaO8w/uyc+2ipy6L6cSYMeIoOJdgxGaF6TRc6t3e4o6XRGMa6tUYUFvuPBjy0XjmNxHXV5wvKpxTq7tjMpOm0BAGBS63D75cvPrmuj91qHBm5qmHIpQD4BOVvRt1Q4wEnzw/Lpaij1eIRNPW6KxROqjkbId6btus4B+qzbJQqh1TU1ZLI5xOXtA2EaDA7Spv5N1OcfoB53RITTKdW2tG6QicSPLReOuXS8rT8gv7/WbqBkGzAAAABwLupwJZecsn+++zlt6nVXaKetIpNqoNtWOa5r3J22JTj99WkRRiOw+jwy6RubOkXxWGTS6mpFJg1Rj6+Htg5upXb3IHlDcfEi/tx6Z8nGf1QPnf7i77+tL/X8r44zqYahaAsAAJMWHz3rcqcKSez219dRny9IldZpqzx+r4VlZLxpWCp+5rrwYXhAjpZ4NII6W3pZlcVIxqEOibEC8r8+2ipf/sY+O5HUWMGdtiu3rqSvPvZVOvrvR9IW/wuiYFqqY2hy0ZZ0pNcbqG0gdb8MBh812Bqo2lJdstsGAACgFTwqgOe8Sjgi3bxyTcnm9xdrpi1TLrYa1EAmVXYL59VpW+LTX2lFW5XGdeXTSMDPo574OJVJz9k/dVqxbSBCj61/jL7yyFfopIePpN7wB+IF/LmNpct91eJkX7KRoHUg9VzPYYmRUW8UBV0t0uatAgAAmAC93iBFhwqHEj6Wdusrn8gFRc13NYyj01YLM8SUATnX+6CF+WHpXQ11qn1dftVfCsmjBWT+/us6BsTlZoeJuj54jXyfvEXxWIx6vFHq8vKirySLvjbZ1dBQuoAsPfkx6gzUMZjsQonGo9TgMNPS5qVkM9lKdtsAAAC0olNx8kvS7QnS/725XnThlsXpr5z3LGir01aaZ1tup7+kJWQ8FmF+U7Wq2U1qhh0tk/IM5s6h5pedmqqo491Xqe+jN0Um5dNffYE++WPN+hqRdbXTSBBOLf4zeGlh/ULNNhKgaAsAAJOWMiAfutM0anBY5MLYYx9upkqeaaupoq0G54fd+cZ6uuiRN2hte7/8Pi7kb+xxyT/P5ip1Z3JJnSfeUJTCIyyL+9eHW+TLxy2ZQX9/4AFqe3slJeLJj28dTBVtzfrqki58UD754eLxYCBB8XhcBOQ9ZyykOpt6RW8AAIBKGdd13C6z5C7Ot7Z008sb20mrlEXXnDttFR83oIGirWe8mXQCTn9xN+sf/vch/eRfb9HWoZ0KUrG83ZX8neGcZzGqd8SfR2tJJ/T6Ryjaii5bxcmvk3aZSQ/8/QHqevcVkUm5a7zDkyraWrhoq5FMatQZaNCfzKOReIR2nzqX5tfPL9nYhqIWbX/729+KO/bDH/5Qfl8wGKQLLriAGhoaqKqqik455RTq6upK+7zW1lY67rjjyG63U3NzM1166aUUjWq77R8AACo7IC9oqqaLD1kqv7LMQaS130uVONNWC0fRlPPDnOOcHxYoUkDm8RgvfdYuOrFvf22d/H229XsoODSzjGeHqR3umhRFYJ4PlonD+pqhIjJ/7IELp9NRRx1FS/ZZSnFd8ufZ4UnvtOVbOKekATn55EfMECMdRRNRshmttLRlVsluEwAAgNZ0DBXg2G7T6+m8AxbLb9+36jNNdKSO1khgMujIZjKMY6ZtqGw7bdMyaZEaCT7vcdH72/tEgfYvr68TxVL2abfi5JeKOxYkjUOZlH82vIQ30/vbe6ltMDmDeafmGlo6vZGOOvIo2mnPRRTXJX8WytNfZn2t6Exudto0kUkZF2ztJgvtPWMXzY5GYOO+Ze+88w799a9/pd122y3t/T/60Y/o3//+Nz3yyCP0yiuvUHt7O335y1+Wr4/FYqJgGw6H6c0336T77ruP7r33Xvr5z39e2D0BAAAooNN2arWddmqupZN3myPe5kj0SUeqy1KLAZlrhrnO3qpVzLTVxniE8QVk3jAsbcctVqet8ufDHQZPDs3rko6hFSsgN1elgmyPN33WMluv+P7H7jKLbBYLXXTRReRZvoP+1/cN+l/3t+nT/nfSAjKH7qo8ZgarTXpseYaYQW8gq8FCTqs95xcbAAAAJlsmnVJtp33ntNBBC6aIt8OxOH2mKNJpiVRMTi4eze3F7BplJq2Q01++ImXSAcXPZ1u/l17asGNiMqmiuNrjGZ5JP+1Mff/jl84is9lMF150IW1f+jG90PcNerH7u7Td/bm43qRzkl5npNkNVaKLVwunv3SkI5PeRDNr68hi1HYmHVfR1uv10hlnnEF33nkn1dWljra5XC6666676MYbb6TDDjuM9txzT7rnnntEcXbVqlXiY55//nlat24dPfDAA7Rs2TI69thj6Ze//CXddtttopALAAAwUTpcqRDSUm0Xfy+dWi+/r1ejC8mkgMwLvHINP8r5VNoo2iqWPuRRVOQnBFKHxlgLu9S4beyZta3iyVT6ErLiBuSuLAG5W/G+OfVV8uVOf5v4OxDroXA82fVg0FnJqLOmfVwpSC8qcEC2Gq3iD99PrR5BAwAAKAVpNigvJZW6HHdJy6Sl70jNxF2fnlDyRfh8XoxNG9mlgU5b6T7ke/qLPzaX2a9qjW5gD76/ibyhSFom5aaTYmbS7iyNBMr3za5PnejqDnAmjZM/1knRRDg1GkGnK+nJr8xOW7PRIvYqTKspbU4uWtGWxx9wt+wRRxyR9v733nuPIpFI2vsXLVpEs2bNorfeeku8zX/vuuuu1NLSIn/M0UcfTW63mz755JPx3xMAAIA8dXqSXQ0Wo57qhgJkg+KIuhaLtjx/SSoq5rPASz8Bxc6J6GpgTUMdqdytK40rUFPmEUReVnf/6s/kgMzH/2YVoRiaNh7BExy1aKsM04vqF9EU+85k0jnk902zHpBc+FDCLb3MajSII5OMOxq447alhEfjAAAAtFj87BrKpC3VNvkF+UZHKhf0ZRmbpIVRV9KOtHxOTXGBV5elk7TcGgn45FfD0GOU7YSU2nsspIXJnEm3DM23nVHryPnU3XgzKS/EGymT8uE36WcQi8doWfMyarTMF80Dkqm2FaKzdX4JF+Nmnv6yGW1k0BnKIpOm+rlz9OCDD9L7778vxiNk6uzsFG3RtbXplX4u0PJ10scoC7bS9dJ12YRCIfFHwgVeAACAQkTjcTlw8DE0qfOv3m4RQZIzaJ+39MXNTIFIjCKxZEKuzSMgszq7RYRjDqe8VEsaM1Dq8Qj5dDUw0YEyNC6/1xugGXVVRZu3K+F5YsqOhmIc78q1q4G7cPix5D0CZ555JvV6eumCH11Hb28zUDjuIoMhSLp4k/jY+Y01VEr8/ysOyX2KDqFSzjMrFDIpAAAUY5a+lO1anMmTX+XQSKAsdubTaWvU60WhkbOgJjptxzmySypu8g4EXiLLOxB4bmux8rLk1c87izoagbWMkkm5gUR6DsWNFPx8gjPpGWeeQWF3mM674Hr6uFNHoXg/mY1xSsSSHeMLmkq7gLaKTx0OPccrp0ya12/U9u3b6Qc/+AG98MILZLWquzF5NL/5zW/ommuuGfb+gYEBMSMX8ofCt7bg8dAePCaV/3h0eYIUGVqCWWvWi39TJHaTjlzBCHW6PGnv14Jub5CiseTtNlM8r9tn0yfkz23t7E47njbRj0evyyPflnjQRwMDuXdaVBni8udu6ughBw0PtIXoGnDJX//AOU302taetOtnOk1F+b3QxxMUj8UoTglq63OlfQ8OyO0D/DOLU6PNSq7BQRGQeWRVKBCiFrOOT6ORmWqIYjUUT3A+0lGDMZmXSsmqJ/nnyap0+f3eqqnQ311kUvXh31ttweOhLXg8JsdjsrErlTtqTKl/t3WxOMViUVFkau93l/zf80xt3W75dpvi0bxun8Ooo/5YlHo9Merr7x/3i+FqPB59bp+4H2a9ngJeN+XTM+s0pjLO5zu6aEZNquiuhp5B96iZdLrDUJTfC3MsJH/f7T2Dad+DC9SeYLLYXmPWieukTBoOhqnZlsykFqoninIneYwsBj3ZE5GS/w5bDERexfxhO+X3e6umXH938yra8viD7u5uWr58ufw+Lpq++uqrdOutt9Jzzz0n5tIODg6mddt2dXXRlCnJIdr89+rVq9O+Ll8vXZfNFVdcQT/+8Y/T7tzMmTPFPN3q6tK2WJcz5TxiKD08HtqDx6SyH48t3l4yGpL/DM5trk/7+lNrneTrcZMvkqCq6hqx/EorusOD8u1uqa/O6+cypa6aPun2issJs43q6qpL9niEEnpxPzijz2hpyiusz24OkPGzbnE5qDOq/rsR1XXIP+Mv7bkT9YfjtKHLJV+/fO60ov33oaXGQT3eIA2GYiJLSR3gPLIhTvwz09P0+hrx/bmQ+7e//Y1WbVxFhkYTmTdHKRJP9g8k4jwzzkhzp2XPVhOpsbqKdnhSnTTzpjaW7L+vBkNum61HgkxaHPj3VlvweGgLHo/Kf0x8XT45d8ybkv5vZEOVXewi8EbjmvtdiA+E5Ns9taE2r9vXXOOkDm/yBXuTrSqvkV+ZCv25BOMk7kedw5L315rZWEfGtuT4rLDerPpjFCaD/DP+5oqltNn1LnUNzT9me82fSXWKjmy11NQmyGIyiZN5rkj6715/r1u+TTMba+VMet9999FrG14jc6OddFsVpe840bR6KzXUp2Y0l0qD007BwdTSvwXTmqlO5RN7amfSvJ6FHn744bRmzRr68MMP5T977bWXWEomXTaZTPTiiy/Kn7NhwwZqbW2l/fffX7zNf/PX4OKvhDt3ufi6ZMmSrN/XYrGI65V/AAAA1NvSm340RprNxPo1MP91pNlW+R7h4iP1klLPtZWWPuSzTC3X2a9q/4y/ue/O8qIJHk2woKl4Iwek42g8BkO5iViadSc+Zuj3lQu6zc3NVNdQJ4q502oVvw8Johl1E3cqajSZs9aURz/LDTIpAACorUORSadmZFJpKdmgP0yRWFxTP3x3YPz7CersZk1kbeUytXxz9bDZr97iZVLeD8CZ+Rv77CRf1+CwyL8fauNsLt03bibgoqykS/H7KmU6ZSZ1Wg1UZ0v1h/LnzqzTRvarzniMy2E8Ql5FW6fTSUuXLk3743A4qKGhQVyuqamhc889V3TFvvzyy6Iz95xzzhGF2v322098jaOOOkoUZ8866yz66KOPRHfulVdeKZabcRAGAACY8ICccZRJy4sflLOt8h1vUGtTFG0zlm1NNHmZ2rgCcipgFWPxg3TbdEMFR952+/W9FpDVZKAv7T63qJ3XTcoZYorFY8rLyicISjPrUz/LBCVoZq1WAnLqiRwXv4v1BAMAAKAcdbqUjQTp/3bXO5LZLaGBF9xHe5G7RpEx820kKOVcW29ofMvUshX9ipJJh/K602IWhdHlMxvp2F1mikz6lT3mUTFJeZuX/irn/iqL0yNl0hmKTMq/vXOKsMB3PJSL5viFA7OxsBNYE0HdKclE9Mc//pH0ej2dcsopYlnD0UcfTX/+85/TWoCffvppOv/880Uxl4u+Z599Nl177bVq3xQAAIBxBWQtL35wKYJt/l0NioBcwuAfisYoHE12i4xn4y13QnPxj0N2MboapGDKCwukLuDjl86m43aZJY8rKJa0ZWSeAM1rTJ4uUt5P6WOi0Sg988wz9EnbJ7Ts8GU0o1b5s0zQ3EYnaUGN4kkQP3ZaGjcCAACglUYCs1GfltWGNRL4gprqDOTRTapk0hI2EqQvxjUV1kigeIFd9S5gRaMGd9uetffComdSPv21RrGMTLoNyvupzKT/fvrftGb7Gtr/6P1pRp2Z1uxIfa05Ddoo2lYrfo7lcvKr4KLtypUr097mBWW33Xab+DOS2bNn03/+859CvzUAAEDBAdluNqa96iodN9Jq0VYZLvMfj2DWRFeDctvweAIyb6nl4h9v6y1mp23mE5Bih2PWrBz9oCjUKjttm6tSAfn//u//qN/bT7sesmtapy3TSleDMiBr6ckmAABAqfHMUOnf+ClO+7CRUcqiLeceLVHmOeULtLlQnhYrZQexJ20kVv6ZlDuh9bx3K5Ge29TgD0cVXcAlyKQZjQTSeLDuEYq2d911F/V5+mifI/ahmXWpx5dfq59Rq5FMalVm0vI4+YVWBwAAmHR4Jli/LyTPs80MPloej6AsttbkOR6hTjkeoYQBuZDCc+ZxLF8oKkKtml3AoaEu4PHeNrXGIyjn2GYLyHyy6eCDD6bd995d/A7bzQaaUp0M9U4rF7a1USBVvigizewFAACA5JH6oR2iw3YsaP/0V0QxTqo89ywUmkm5yC6NfVK7aKssipckk44wr7drKJNy40vVUMYTmfSgg2m3vXYTmbTFaSK7OVlubKnWk8WYf0G8GKoVxe9J02kLAABQbniAvjROf2rGaIRhXQ0aC8jKmVL5djVwx6M0VqDfH9ZEV0Nml3OuuNt0PQ3KT3hm1zvV7wIe520rRIvimF23YsmaVLTlzmQOycxsNtMll1xCr336GvmNyQLvSbvX0XvbvDSlzksmgzYC8vzGarFAIxJL0NKp2tp8DQAAoJXFuJk7FrKNR9DiTFseJ8WnoMqxaCuNHxjv6S9pRAJnNm4i8IUi5FApPyrHT4z3tqnZacui8bj83Eh5PWfSn1zyE3pp3UukN+tJr9fRaXvW05odPprTHNBMJt25uVa+vHRaeWRSFG0BAGDSaXePPM9WCkZSkUlrAVma+8ULCPIdns/dAHwcbcAfLulMWzU6bZXLrPi4oHpFW8Vty7OTWQ38u2cx6kW3rzT6QdkZLo1GGMmUGhMdvdRJPb4gmfTaCMi1dgv99qR9xZOyJVPKIyADAABMhI5RdiwMH4+gnUVkiURCXpKVbxOB+BxFxirtTNuwqpmUu23VKtoqM+l4fsaFSluyNlS07fOF5JENY40XmN1goZaaBLlDUc1k0jkNTvr1CXuLecHSuAetw3gEAACYdLrcqaPm2Tpt+VgPz0yVCoIcTLVCCpfjDW9SZwN3R3BgKX1ANhX+6r+Kx9HSZ5tNfEDm3z3pvnHw58dI/A7mMX8rGo+S0WAko147r81Pq3HQLlPrJ2QGGwAAQLnoVIw/Gq2RgGmpkSDIS2Vj8XG/yG3U6+UMWM4zbYcVN1XctaDsAi5FJnWYjWL0lrSIbKQdC2NmUr22Mum8xuqyKdgyFG0BAGDSLiFjU7IcRVN2NnDHo0/FmamF4I5LnuFaSBdo7dBcW67XKo9dlW5Tb2EzbdUOyOldwKXpCpA2EfNyEn4ik22eLQsGg3TGGWfQtZdeS+FQOD0g64yaOYoGAAAAY3fajtlI4NNOI4HUZctqxpmXpEYC7rQtXSOBIpNaxplJFd3Qas61VaPJoRD8uydlUr5fyqV5mXsKOJOeeeaZ9Juf/iYtk8biMTLoDcikBUDRFgAAJvf8sCwBedjiB40sI0vf0jvegFz6bb1qhFApRCqPbKk+P6wEM21Zi2IRCYdjqbshs2jL3G43+b2p32epaMsBWUtdDQAAADByJrWZDCNmIqmRIBiJaaaRQJpnO57FuJmNBFwM9CqKp6UqPo87kxap09Zd4pm2ysIs19S503ukRoLRMqlZbya9DqXH8UKaBwCASdvVUK1Y6jTW4geegaSpJWQFBmQ2GAiV/H6M97hXvcNCvPOCNy4Xq6thvD/jQikL0ryhd6SjaBaLhW677TZa/flqMplNaQHZaXEiIAMAAGgYn6CSljrxaISRRghlNhJUlehF5ZFe5B5vlqtVNhIEQiXZJSCNIOBFaiM9J8jn9Jdyiay6zRqlz6SjNRJwJr311lvpzY1vDsukNtPYYxRgZCh3AwDApBKIROWFB9lmh2VddKWRGWLKIut4A7JyW2+/P1y2m3p5qZr0GFXS/DDWophbywXpkboa+MndrFmzqGVaS9oTPT6KZjMiIAMAAGgZvzArTQWYOsK4rsxGgn6/NjKpS4VGgnpFJi316S8+XTXeufucrbnoq3omVWGcWKHS5/WmMin/qKSxHcpM2jy1OT2TJmJkNY69jwFGhqItAABMKmMtIZMog4h2xiMUHpCV4xEGSxyQuaOBF1EU+uq/Pxwjn6LYWs6LyDK7aTkc85M6xs8HlL+XmXjOnSvoIn/Uj4AMAABQRuO6cm4k8JZuadfIM23VOP018Y0EnJukbF1I5ktvJFBv7rB024x6nRifUQrKBbjKTMp51GQYPcNzE0E4HkYmLRCKtgAAMGmXkClnh441HkELXCoEZGWnbenGI4RVWaqQvoxMncfIFUgVf0t1/LBxhPEIXKSWOjlYNBql5557jla/vpoGfYPU6m6leCJOS5uX0qyaWSW57QAAAJD/ErIpGfNBR2wk0EomVb7IrUIjQSk6bQORmJinq0YmlV5w57nD3qGlwWr9jLmgPN4uYDXHI2zt98gLkTPn2UqZ9J033iFPwENtnjZq97RTnbWOqsxVE367Kwlm2gIAwKTtapg2ylG0BkequNnr00hXg4pLH9hACcYj8Pw27oxV46iXcvEDz9hSY+6w9DN2WIxpBdKJZB1aRsIdFtsHvOIJQGaRWgrIPD9swDdAvzz4l7SgeQE1OZrQ0QAAAFAGujyKxbg5jkeopEaC2rRGgonPpMrTVU5VGwkCBX897taVbl+plpBlFmc/7RqUL2fLpH++7c/U5+2jZQcuo5l1M6nJ3kR1tjoyG0pzcq1SoGgLAACTtquhxTlyQDYbU4WzPo2MR1AG2vEe4+JiL79Yzye3StHVkDbPtsBO1qYijLCQbl+pFj4oQzL/7kkF22yd4Xq9nvbdd1/y+X20/6z9yWrBzDAAAIBy0a7stK3OsZFAI5lUjUaCUs+0VY4dK7SRoDHj9Ne8xuqCvp4vHBXLdks5rovxCATuiOZGj7RM6syeSd1eN62YvYKc9tIvcK4UKNoCAMCkIs1iGisgS8fRONDxRttoPF7Q/FWtBGSeu8UFSS4Al2I8gnIGWsFH0ZSdtorHtZAuYCmQljIgS2H48x73iLNumdlspiuvvJIGBgZQsAUAACgzUnapshhHHcmU1kigsU5bPh1kMY5v3qoya5WmaKvdTKpcQlbobSsU37fM03mZ4xGUmRQFW3Vhpi0AAEwq/UOhkAMyB81cXjUvVVfqSAGZT+07zON/3VWaa8uF27hKyxLG02lbrXJXg5bCu5ozxEYKyAAAAFCeOH9JmVQ5/mCsubb8OdIc1lJKzVs1FdTFKX1+qU9/FZpJleMC1Jg7nJZJx9mooRZk0tJC0RYAACZVQJZCYb0994CsleNoUoBLjjjQFVy05XqtcibZREgvjBYWQvl+8EZdaX5YoZQ/i1LODxtpSR6KtgAAAJWBM4f0unm9YvxBOTQS8OkzaSGVGllOaiTgOa7levpLWdjsUaHTVrnordBxYoXKHIUg3peluQCKA0VbAACYNPiokdSdIIXE0Sg7H/pLvIyMC85SUbHQeavKbb0TPSJBOT+s0IDMox6kJzHcaVto2FezoFyozAUP2Yq2oVCIzj33XLrooovEZQAAACgPUpdtrpk0rZGgxCMSlFluvOO6Mhfkcj5Xdr5OfCYt9H6YyWSQGgmCmvoZq51J+aRiZnMDMmnxoGgLAACThrIzQVm4HEljlUUzAdmvXEigUkBmE92toeamXmVnA8+i9Q51fYz/tqkX3tU+imY3D593x0Xq7u5u6u3tnfDuFAAAABg/Zf7K5fSXspGg1AtylR2qhTYS1Cry+ERnUreK3ax8Aq5xKLt1ewMF5zJlXi51Js1sGuAdC5kn/pBJiweLyAAAYFJ2NdTnMT9MC0Vbl6oBWVm0Ld/xCJmv/nNILqQQrGYXcKH4d48nP0iF+uYsnbe89OHGG28kl8slLgMAAEA5NhJYyqqRIC2TFthIUKdoJBj0h2l2PZVlp62USTtcfgpH4+JrF/Kz0VImzSzaNjmRSScSOm0BAGBcutx+evyjLdTp9lfsUTRNdTUE1QvI9SXsalC7m7VJESR7C5xrmzY/rMRdDQZ9avTDSPNs9Xo9LVy4kObPny8uAwAATEZb+zz0xMdbSz7rNR/KsVu5nP5SNhuUvGir8n4CycAEj+zyhJL3g3tGq1QojHIHqqTQXQvpXcClzaTKHRIMmXRiIeEDAMC43PbaOnr4/c10w4sfl83R7PSjaGMXbXkMgRRSSh6Q05YlqDceQe2Ztjx7NxKL57ip16Rup60nqF5hvMRF28zwjyVkAAAAw3EG/cP/PqKH3ttEf319/aQYj9CvoUxa8EzbIjYScB6VdlmM1kjABVvek6BmJi10rm3aCIoSz7RV7pAYaTEZFA+KtgAAMK6AvLXPLS63Dfpoc5+nLH6KypCbS9GWQ4o0IqGv1AFZxU7buiKNR+Bw/P+eWk3n/n0lrW3vH3Y9B+cdgz55iYHZaNBUV4NHQ0fRMgu12QJyLBajlStX0uuvvy4uAwAATDZ8jFw6SfXxjr60U1XlM7Jr7EzK2Y9P4bBeb2nvo5ovcisz6aCiUFkoznQ/euxNOu+fr1Brv3fY9d5Q6vdGrRfqlae/ejwFZtKhJgd+zG2mwvOympk0WyMBMmnxoGgLAADjCsiRWOqV6zc2d5bFT1FZoMylaMsahl5Z9odjYhlYJcy05eAvNRSo2Wn7eY+LtvV7xe/Gg+9tGnb9Rzv65BldS6fWqfI9x9vVsHJjO92/+rO0x1T5JESNY3KFmtPglC/Prk9dlkQiEbrhhhvotttuE5cBAAAmG+VJKE6mq7Z0UTmQukpNBh05zMYcGwks2jv9pepMW/Uy6YdtvdTnC4n8/thHm4dd/9aWLrkLd+m00mVSboT595pt9PD7mygajw/LpNxEkLn0qxTmDOVQvikza6uGXY9MWjxYRAYAAHnLDIsckM/ce6EqR4uKqd8flF+1znVhVYOiuMvdtnbz8KBSbjNt+XHiwi93NKh5FE0ZUDf1usWf+Y3V8vte2dguXz5k4TRVvif/LPgJDxeKe3MMyNxxIR2h5Lj+jX12Suu0dViMZNTAjNiDF0wVjw/fx4XNNcOu5zm2y5Yto0AggJm2AAAwKWX+28/FuC/uMou0TsqkPBoh16Icn/7iUVD8gjP/sedQ7C366S8VGgkkanZJ9yieq7yzrUdkeOWCYX7xXnLwAnUyaVPa6a/cMik3NPzj3c/FZafFRMfuMksUcqUmBzX2P6jh+KWzxQg0bihQjkqQIJMWT+mfkQAAQNkHZO5g3dA1SFonhUE+ipVrQFYGk1J2NqjZ1cBqh4rRXLjlEFaM34vn129PKzq/t71X7hrYfUaDKt+TH8fGoZDc7QnkNF+ZA7LyBQfp/ktPQjg0awGPjzht+Xw6evHM7NebzfTLX/6Sfvazn4nLAAAAk03m+KrPe9zUVeDR9GILRvj0Vizn0Qham2srzVvlaQ38QnchTAa93Eih5ngEZSblmPfSZ6kibduAlzb3Jke7za6vSjvZVAjOt2ZjssTWnePIrg/bUpn0zaEucS7IS13AWsmk/BidsfdCOmDelKzXI5MWD4q2AACQt2xB8c3N2j6OxvNWfaHosPlZY1G+Kt9X4FKBkXCh8ZEPNtNdb36aNldVyaXyvNX6ocUPHGSVyw4KkTlTlrtdpA7hNzanjqEdOH+qqp2s0pOYcCyetuhsJOs6B9JecOCxDvz7wU+itLDwAQAAAHKTbecA5w8tU55yyieTTkQjAeehe1dtoL+/s5FC0ezz8qUXubkLVI1TdtKIBB6PkChSI8H/Pm2TF+Wu3Nghv/9glU5+yY0E0i4MbzCn+/KJIpPyCw78+yx12TJkUkDRFgAA8pYtKK7a2pU2i0nTCx/yCcjKoq2vOIsfPu0apH99uIX+t2EH3fLK2mGdrxz6pICv1tH9Yix+yAzIPLJg5VBnQ/pohKmkJuUMsbFGJPDvKP+8lVZv7UkbP6GVo2gAAACQfyZ9U+O7FtKKtoqZrvk0EvQWKZPyCaTn1rfR02tb6b63P8uao6SioloFRSmTRuMJ8g41WKjdSMC3+Z1t3eL2v7apQx6XdsC8FlKTVFgXjQQjNGIoT9G1DSQX9EpWb+shTyiVSZ3IpJMeirYAAFBQQJ7XmDxSxCFrbXt/WXQH53MUTVpEVsyuhnaXX768pr2fnlnbmnY9B2epGNmsmJdViFrFkwS1ZohJPx9puzF7YcMO2tzrFgvKpN+XGXXqzgVWdp6MNUNsS69H7qiVvL2tO6Noq42jaGMJhUL0/e9/ny655BJxGQAAYLLp8yb//ePkMXfomPv2AZ84Aq/1ebaFjEco1umvDncqk778WfuwAvj9qzfKJ6eanSpl0qHTX0yNXQvc7CB1YPPeA8nzn7bRR22ppbh7zmxU/YX6tGVkYzxvUJ78kqzeyplU3dN1EwGZtHhQtAUAgLz1D726rxsaTF8OIxLG39WQvoisGAYD6QH1wfc+p409Lnn77T/fSy4oYF9eNleV7ynNtC1GQJ5abafdpydn1nKx+fbX16m+gGzkbujRH6O1HakXFqTiMt9G5Uwxp6U8Om35Z759+3basWOHascJAQAAyon07z4X/g5cMHXYfFAt4tFMkrxGdk1AI0FmJrzzzU/lGcEvfbaDnl/fJi4b9To6YdfUc4BCKHO5GpmUi5582ostmVJPM2od4vKGLhc9+P6mooxGyNoNPUZh/ZMsmZR3hPDC3HLrtEUmLR4UbQEAIG9SCOFjUXvNaiKbySDefqe1R54XpenxCHl0NdhMRnnJwljha7wyxxNwA8MtK9fSpl63GJcg1eNOWTZX/LzVUKc40pZZNC40IHNgPWrxDPk66egXdzvsP1fdY2j5znhb15Hqajh2SWrBl3JBhRqL3iYCL3247rrr6KqrrsIiMgAAmHQ4c0oZirPHfnOaSRqxykVbrb6gmdZpa9dWI4Fy8S3j00k3r1wj8tPdb22Q33/uFxbRwqYa9TttVcikyizYWGXJmklrbWa5waBUjQSfDGVSrtdKt5F/Y19WjBSrKZNOW2TS4kHRFgAAxh2QuVjGW1/3md0sB7v3t/dW1ExbJi8V8AWHzZtVAy9ekEyrscvH/K96+h15u/BesxpV67LN7OxQo6tBOTuMj4Ytm9FAzc5UcGVccK4qwhbctKLtKIV1/t39rNslP/HhLnHpyZ3y88rlKJper6ddd92VlixZIi4DAABMJspsx0VbzjZLptSJt7vcAdrc5yEtn1jLt9N2IhoJBoYyPuejlurk+IPNvR761XPvy2MRjl48Q9WTU2pn0l5FJm2sstGK+VPIOtRgIuH3Kcd5TfTILn5O0elO3s4FTTV00PxUl3h6Ji2PRgJk0uJBwgcAgIICMlN2T2p1Y+94N/Uq7ydnVTXC5GidtpcesTvZzclALtWH+VjX9w/aRZUNvdnHIxS+iEwZMDmw8m09YudUZ0OxRiNIj6f0oxktIH/e4xKLIRg/qeNO8cVDT+6UyiUgAwAATGbKua6N2TKpRsd29ReQSSeqkYA7US8+eKlc2JS+1ZKpdXTmPgtV/Z7K8QhqLMdVZsEmh1UUuw9WjM4oZiZVFm1H67RVnvzaZWodza6vGtbswJBJAUVbAAAY90IvKTjuMq2OnEPdie9v76FARJ3Nr2oaKKTTNscANl5SQOWf4ZRqO513wGL5Ou6ouOTw3UTgVFON1SwXOtUYj6AMyNLP69CdppHZoJc7W5dOq6diMOr18mM62uMjHUOTAjLbZ/bwcRPOInQDF0MsFqNVq1bRO++8Iy4DAABMJsp/86V5r3z6S2qgfEujIxKkTMone/jE2ngbCdQocCpxEdg1tJiVF9bOa6ymr++1IO0k1Q8OWSpyl5qUhWvl6TO1GgnYkYtSjQQLm2to+tCcW7XV2605NRJ80pmeSXU6nXxyUUl6fqV1yKTFg6ItAACMOwhJs7U4vPEGVsZzTbcpBuhr7SgaF0HNxvQjUvnMp1L7OBo/mZACKnd+sn3nNNM399tJzNr66ZHLqKU6OTJBTdw5IXU2qHGflPPDpM25PArh4kOW0vKZjeJvNTuFM0mh3BOMiDEdY23p3WVqsoC89+xmsVBPSXoctC4SidCvf/1ruvHGG8VlAACAyUSZPaRMykUu6d947mhVdrVqARdGpaJtvl22wxoJVM6knKGkGjd32krz/3k8F2e5y49aVpTOT85d8rgqFZojsjUScJH2OwcsEuPGzl+xhIqF87XUSKAc0zBSpy3ve9ipuVbO/0r84oNj6PSd1iGTFk95/AYAAIA2A7IiOM5pcBJt7BCX2wZ9tKglGUC0QBRGA+MPyOmLH9QN/75wlKJDM8KUx8OOXjxT/CkmnlXGT2Z4iZg/HJXHMhRezE/9Xuw5q0n8KTYurG8gl/w7Km0KloSjMdo4NM+Wj59JIZ6D9U4tNWKjcLl1NfD8sMWLF1MwGMRMWwAAmNSdtsoX2Pmo+Zr2fnF5+4A3LZeUGhdGh2Lf+Iq2ykYCX5AWkjrLwDJPpUljtLgD9NQ95lExcbcx3y8utna6/SK38/ct9PeCi57Kn/FhO00Xf4qtqcomni94Q1HRSJA5T7fbE5ALywuba+Vu6/mN1eI5h/RcgwvkhfwcJhIyafGgaAsAAKoEZGWRrG1AW522nlBEdACPZzTCsEVXKo9HUB4Dk7oaJkqz00brOwflACkK7yoH5ImS2XmSWbTd0O2Si+NSB46Ej6NJRVsuXKt97K+Ym3p///vf08DAgLgMAAAwmfR6Q2Nn0kEfLZuRPA2mBf3+VI6sL7CRQO3TX8pxWROdSVucNlHI5AW8XOws5AV0Katzsb6Yp7xyeoyyNBKknfxS7FYQIxLmNNN/P9ledvNskUmLpzyelQAAgCYDsrJzYUZtVVpAroQtvdnup9ozbaUtvZnLwSYCz8+VcGdDLkLRmOgOziR1DJQqIPN2YPm2ZHmM0hY+ZCwfU84Q4/lyAAAAoH1SJuMj5soi34y6ys2kxdyzoJyRyzNtS5ZJPbllUj4lljkSi/dq+ELRYT+ricSdtpJsIxKy7ViQ7ItMChlQtAUAgHEHZGWBi+dRSYGZj6JpyYCic2A8XQ0cqqU6pNrzw0rZaTvFmQqVnZ6R524xPqr2vw076HsPvkaXPP0BbexxpYVm/lPKgNyoHGGR5TFSLnzgzcdpn1tlpYMWTBGXD8rYLgwAAADaw7lE2VGpPEY+vUZ5+sun3cW4iuwynkYCtU9/pY9HmOBO2+pUJu0ao5EgFk/Q4x9tofP++Spd9p8PxWmxrEvISjQWQzk+rjdjrBr/3kqNBGajXix7U+IlacnFZEQHzE9mU5jcMB4BAADyMlJAZnz8h4/b84xUntmlldmgyq6G8RRtuXOU7y8Hwd6idjWYNdlpy4X6O95YTx/vSM6HiyUStPKzdlrYVDMsIEtLyCaaMpj3ZHQ1cNfF50NF5mk19qydLecfuAt9Y5+dyGHRxu9sLsLhMF1++eVipu1NN92EEQkAADBpKLssM4tzPEOU8wifAtrh8hU8I1VNysVohTQS8MIw1RsJFJlUuWdh4jPpyI0EOwZ9dPtr62hTr1u8HY3F6PXNnfTl3eeOuIRMS40EfN+k3wHe/yHNs1U+5/jZ0XtQIBIraNfEREMmLR502gIAwLgCcralDukzxLTTbavsHBjvvFXpCYG0VKAY88MmehYsz7SVKLsUlF7f1EGXPfG2XLCV8IIPfhLEen2BrGMKJpLy+2Yui9vQNShvQ87sslUqp4Iti8fjtHHjRtq8ebO4DAAAMFko/63Plkln1iUzKWc2tV9wV6toO57cx0U9qdirfiNBCTttFZm0K0smjScS9J9PWumKp96WC7aStUNL54Y3EpQ+k2Y2EihPfmWO65LwCwzlVLBlyKTFU16/CQAAUFJjHTlSzrXlV8IXjxBGyu0oWuZSAe48nZ6xVKAc54dxIOQRF9wZ3ZWlq+G91h667dV1ittnFt0rbQMe0cnAhd6WantaV0OpOm35dlVZjKKonhmQpSVjowXkcmQymejnP/85ud1ucRkAAGCyUBYslcfRJdNrq+j97X3yXNtSFfBGzaT28WUm7iDlorXUSMAZSA2D/tJl0uYxirYvfNpG96/eKL89pdom9iz0eKL0WbdLnKqymYxpGbB0nbbWURsJJKM1EpQbZNLiQactAACoFpClrga2XUOLH/pVCsjFWPxQyvlhjIuu0s+Iw68SHzeTfGFeC/3hS/vRwQunye9bMzSTS1nMz9btMtGdDXxfeN6ZRBqNIM0KqxQGg4H23ntvWr58ubgMAAAwWSizWLZGgpm12pxrK2VS3g3BLzYXXhQMqt5p67AYhx3bLzaL0SB3EGebafv6plQmPWbJTPrtSfvSnjObxNuc+aRi6Fi/FxOBi+jSiLjMRgIpk/LjP7veSZUCmbR4ULQFAICc9SuLtlk6VpXdp1ra1isVRg369O3C+VAGPzWPo7mGOm0tRr3oEJhoLaOMSNjWnxxxYdTr6PwDl1CVxUS7TquXr1+zo2/Yz6NUnbbKGWI8CqHfH5SP023uc8udwuOZHwcAAADa0jdGJp1Rp+2RXcnZtOObs9tQhKItj7ySTn9N9DzbzGVkfAJMWnArZTlpyTHnzLP33UkUeZcqMunHQyMStDDTVvkYKRsJvKGIPK+XC7YTXRiH8oTfEgAAyFnvGK9eV1vN4rg9axsKV1rqauCiHc8CK3gTrFf9robaEhUT+XhZtmVk3HUrvc2zio36ZGSY2+Akx1BxmedycZDWWqctk24T3wd/ONlBPL+pWjOLSNSaH/bhhx/SmjVrMNMWAAAmlbGyx7QaB+k01kgQjsbIF4oWvMdAWYxUq5GAF1+Fo8n5+DUTvBg3+1zbVCblEV6hods2qz41im2XqXXyYyzNtZV+L/g+lLIoKjUxKBsJNitm8S5oqqZKgkxaPCjaAgBAznIpzs2oq5JfJXcHU7OxSiUSi5MnGBGX6wsoKBbjKBqHd6mgyAXlUpjitGedIcZPcKTlXcrjW1z03rkp+TY/8djS59FcQGbSbdrUkwrI8xsrKyDzpt6rrrqKrrvuOnEZAABgshhrERl3YkpzUjnT8IvM2hrXNf6ibcMoM1NVWUJWqkw6NLKLKXcttCoaQZSZlE+AzR7qqN4+4BPZT+oWLtVohKyFdSmTKoq2yKSQKxRtAQBAtYAsdWUql5GVmnJmbF0BIVR5f3tVC8ilW/ggaVZ02ioD8rZ+j3xZ2dXAlrSk5sJ+sL1Xvh+lHI0w/DFKBuTP07oaKmeeLdPr9TR37lyaPXu2uAwAADBZSP/O81zYkRZxSWO7uINUzVNSqmTSQjptlUVble6XNK6r0NumVqdtp2eETDrUHCJZothV8OrnHZoYjSC+vzKTDj1Gn6c1EiCTQm4mfngeAACULanD1DFKQFYufuBXvRdPqdPOlt4sM89yZTcbyW42iM5YtTptlV0NdSVYQpbZaascjyDNs2WzM4q2i5qrtRmQsyyLU3bazmuonIUPzGw2080330wDAwPiMgAAwGTAXbPSnoXRxjLxgtz3t/fKc22lzttyXoxbrPEIyrxco4FO25Ey6ZwsmfT5z7vF5ZUb2+X3a62RgGcGS0vI+DmFcjxZJUAmLR60ZQAAQM4BWSqEjXbkKH0ZWenn2qoVkMXnS0sFfEFVjtkN+EvfacsdKhweM8cjtKYVbdOLnU0OixyG0xY+lPgoWpPi+/Pt4tEYUnfG1Bo7OSzjW0IHAAAA2sEFxqHdTqMWbZWnv9oGSn/6q9+nzov1nNtsQ80TahVtlae/SrWIrHmE5bjSeARuGGnKKLzPb6gi89BoLq0sIcssGvPzJ34+wqPjpNEIlbRjAYoLRVsAAFA1IM9UHFvSwuKH9KNohXUOSEXJSCwhz8lVq9O2VF0NHBqlV/s5+HOhk7sBWgc88sw1nhmW+Tm7Kjb2aiUgO60mObjzUTQO+dGhX9pKmx0GAAAwWSlPPI2WPWbUpjLpdi1kUkXuK2TPgnJBrnqNBIqZtiU6/cXFaGmhsdRp6wtF5PEC/Bwjc6Ew71JYNKV22NcqdSOB8vtzMTl9NAIyKeQORVsAAFA1IHOBTypAaqFoq+xqKLTTNm0+lQqdDYP+0nc1KGeIcebnYMzhUlqQljkaQbI0S9G21EfRuJgsPYnh+yEdQ6vELb2Ml49dccUVdO2112IRGQAATBrK+bRjnf6Sanzay6SF5b4Gu9qNBKU//cVahkYk8Gm0UDSWsYRshEw6VfuNBMikMF4o2gIAQN5LyMZ69Vqaa8shUrnYoBT6/UHVFitIBUGmxkILZcdFqboaWItyrq3HP+KWXqVdptZR5sGuRkfp53NJv5vhWJw+auur6K6GeDxOa9eupfXr14vLAAAAk28x7sjZjrswpRem2wd9qnSkqjWyq9BM2lhlUbmRQJFJS3T6K3MZGY9ISN+xkD2TZjv91VRlK3kjgVQ45sdnk2Ix7jxkUsgDFpEBAEBOlEXK0QIym1HnoLUdA/Jc2xrb8DA1UZRzYwsOyIr73adyp21puxoU23rdAfKHUx0bs0boaqi2mml2g5O29nk009WQ2e37cXu/+Nug140Y9MuZyWSin/70p+TxeMRlAACAySDX01/SXFvONvxibo8nIHdyloI0goD3CXBBWbVFV95gwS9OS522JoNO3nVQCsoFXTwiQdpNwGYrRrApcVblsQrSzFheHFzK+6D83Wx3+SkcjdNn3S75OVShz0e0CJm0eNBpCwAAeQfk0WbasumKGWKlPo4mddpygOMFBmpugi2Ua6jTVq9LHqMqFeW23i63P2MJWfaAzJZOrZMvczjWQkBWdkPHhubZ8n0o9MmRFhkMBlqxYgXtt99+4jIAAMBk0JtHJp2hkUzKXb5S0bbQcV2Zp95UaSQYyqTcRFDKJVlTlKe/3AH59JcuY2+GEs+55RNgWjr5lfkYSZm0Ek9+MWTS4qm8ZzAAAFDyrgZpPEKxt/XywqzXN3XQa593yGFIacegT54fpkpAVm6CVWU8QlgOyJmLFSbSFMVRNA7I0lE0nsWlLOhm2m16g2YWPkiastyOBU01JbktAAAAULzxCBydxjqpxKe/JmIZGS9yfXHDDlq9rVvk00wbugblrKpGp6UykxbaSMC33RuKisu1Je4CVZ7+6nD7aftQ0ZbfP1rzRVomVYyOKKVsz5eQSSFfpW+JAQCAstCbT0BWFm2LGJA/3tFPt726Tlx+dv12+v6Bu4ilE+zTrkG6/sWPKCq9sq3CIioO2Xz/xcKuPAMyd1hwWVbqXuC33cFwyefZMl4cZzHqKRSNU+uARx4pkW1Lr9LOzTXycTStLPrKFpArtauB59hu2LCBXC4X7bPPPqTX47V4AACYPI0EvMyLRyDlnEkVM/vV9srnHXTXm5/KM1a/u2Kx3AXMhdxbX1krf6wamUnZYZxvIwFnUGW+U+6fqCvhPFumbBbg3QS8aG20cV3Koi03G/AYjPkaebE+W0MDMinkC0VbAABQPSA7LCaqs5tF8W/7oFd0HBTjqNXGnuR8KLa510NXPPU2nb7nArFA4S+vr5ODHh+PP335/IK/n1GvpzqbRSySyGcRGReuf/v8B+LyL764lygsckCWGjFKufCB8WPDy8j4CJpyBvBooxGY2Wignx29nNZ3DdAB86aQFjRMooAcDofpsssuo0gkQk888QRZrdrodgYAACiWUDQmFt3mMhqBTatxyC+4F7OR4HNFJl3T3k+XPbGKvrnvzuQLR+lvb39GCcVoqeOWzir4+9U7LKIZgL9uPo0EUlMD5/mrj91TZPb0xbil7VKtspjEuC1/OJq2uG2s3QR8f352zB7UOuCjA+dP0WQjAT9ecxsrb8cCQyYtHhRtAQBgTMFIfgFZmiE24O8nXygqCpTFCIFdnkDa21ykvX/1xrT3cbfDjw7blWwmo2ozUzlEcncpHycba1YqH4W7/bVP5KN8T63ZSt/af1FaV0Mpl5ApFz9Ic8MkY3U1SB+Ty8dNFPEkZujJGbOZDDS1pnRLR4pdbJ86dSqFQqGSzp8DAACYKMoXzXNZgMo5jbs3O1z/v737AI+rvPIGftR7712We+9gY2OwAZu6tGxCCCwhJCQEsiFk2Q0JCQuEJRA+WkJJgZCEAAk1oRkbY2xccO9FlmT1Xka9S/M95515r+6MRtKM5t6ZO9L/9zzCo2JppGubM2fO+z+dVNXSMWzKVCt1djVpZ+8APf+F5TSYtHpqKt2+arYmOftikCDctUGCrr5+em77CVGb8wvHOfzbglybmpRPXxmhJuVhDLWRlpCpzUiOFS9GYf/nk08DavV4xGhQk+oH5+gAAGBMDe1DhWiyKv/U2xli6qbt+tmZw95/wfQ0+u9LFmpaICVGhLi0+OGjE2U2hecXRTViesBIUw0jXdexphqMiB/E8LSFlJcY7dW8YD2FhITQ73//e3r66afFbQAAgImuXl2TRjpXk8pdC/zkvn1zVSs1rZ3i14iQQNGctXfNglz6/vlzNF2MKpevykGCsfz9QJFNg3dzfqVoYjerJlr5RJm3pUyQmpT3aahLUC2i2owKNal+0LQFAACXmqNON21VGWK8EEwPtdYCmaMYbl0xk35+6RJR6HF8w/WLptB3V80WTTwtqSeNx5ps4KmONw8VDZta/qKompo7jZMfxhwtHMt2YqrBiNTXaKJGIwAAAExG46lJ5b4DvWrS3v4BJV4qLTqc7lwzl+5eO1/k/nPO6m3nzaKvLZ2q+akYVwYJeBHaplMVNm/jOvZQeYOyGNcIexYc1aQcl5Cg+l59BT8eUQ8SoCaF8ZiYs9kAAKCpOlVzMsmJo2iyaFVvf9UaH/HiyQLGeaxsTlocPXX9SurqGxAFnh6c3dbLkwt/2HVKydVdnJlAhyoaxW0umleppjCMchRNja+zXj9DvfF9P1PXMuGnGgAAACab+jbXa9J0VUxSVUsnLdX4Pqmnd+WU6Lm5ybQ8J0lk8Op1JN5+kMDRE/CMp3B/t/OUkqurrkk/OVVByVGhhp605R0LvhoDxY8bZEQamrYwHpi0BQCAcRWjzix+UE+caq221fF94qJOz2ajehPsaFMNnBN2qqZZeVDxnxfOp9mpscoDht1naw0Vj2Bf6Bspp9ZVizITxK884TI3NY4mKl768OCDD9Jjjz0mbgMAAEx0deOI7EpT16Q6DBKop39TVPUUxzPpmWFq07QdpSZ969BZpRaflhRN91y0QGl489I0Xk5mrEGC8Alx8ostzLDUpLxfwZdr67GgJtWPb47QAACA15q2zhbI3DALDw4Qixj0LpCT7aZE9eRMPALnrb22v1B5/TurZlNoUABdMitTaeSqNxgbYaqBl1kEBfgpk8G+mB0mrZ6aJhbh8ZE03oo8UQ0ODtL+/fupr69P3AYAAJgsNSkPXjq7HFd9+ktmz+rWtHWyTtb69NdIgwRnG1rp/eOlynF9GR3GNamsVSubO5WfqRGatsMnbX23JuUs4wUZCeLPoNaRbUaCmlQ/aNoCAIDTUw2B/n6iuecMnnjlZ8p5CVdje7fI+woODPDq9K/m8QgjNG0/OF4msmvZ2hnpND89XtzmY3KxYcHUrMoOY0YokHkahBvysnD35akGlpvguwW+swIDA+nuu++mtrY2cRsAAGAiM5uHFonxpCg3IZ3BJ7B4mIBjtfi004Rp2qqa1vUj1KRvHy4mszUX4bqFUyjTWt9xfcp7F+ST9Sw6NNgQy1u5Lg4J9KeefssT0r48ocqPhyZDLAJqUv241Op/4YUXaMGCBRQdHS1eVq5cSR9//LHy/u7ubrrzzjspISGBIiMj6frrr6fa2qHjn6ysrIyuuOIKCg8Pp+TkZLr33nupv79fu+8IAAA0L5DrrcUoNyxdKeZkRILZrqDVQm3bUNE9UoaXHiKCA8VmYDZS4c9TDdKNy6Ypt/kZ9otmZth+vpBATTcJu0M9iTJlEjQ9J0KBfNFFF9EFF1yApi0AAEx4Hb39Ym8BS450rTkql5G1dPVSZ6+2/Qf19K4na1L16bexalKuN6+an6O8PTIkiM7LG9qvwHiwwCiNThlpwY35LNUiOTAm1KT6celRYmZmJv3qV7+iAwcOiON469ato6uvvppOnDgh3v+jH/2I3n//fXrzzTdp27ZtVFVVRdddd53y+wcGBkTDlvMudu3aRX/+85/plVdeoV/84hfaf2cAAAZ1qsZEr3yZr8vxLD3wVIJ8ptvZaARHTUCtJxtGyrT1RCGZaS0emzp7qKPHsgxN3eSW0Qc8BcJFsRo3bdWDIUaIRpD+bX4uZcVF0JXzsl2+1gAAAOBbDpbX01/2nqHmTsuiJKOzicZysU5RN1O1ju2S94unQ3mi11N4gjghwlJHVpjaRQ2q1t7Tp5zu4hNU9kMCG2Zn2rwea6Ca9CuLplBGbDh9fek0TU/qAfgal87SXXXVVTavP/LII2L69ssvvxQN3Zdeeolee+010cxlf/rTn2j27Nni/StWrKBNmzbRyZMn6dNPP6WUlBRatGgRPfzww/Q///M/9L//+78UHGyMZ3YAAPQyaDbTs58fFwXU/rJ6evyaFbouzdJ84YOLUw2pqqxZvQpk/vnZN0b1xk3b/NoWcbuypYNmJFsWjMlGroxGUC9jkzhegjcK7y6uM9RUA5ueHCP+TILv5IeVlJRQS0sLxcTEkP8EzkoDAABt8ZPOz3x+nHr7B+l0TTM9fOVyp+MGvEWe/GJJbgwS1LR0anZkfWBw6ERaSlS4eHLfkzjDv7GjR0wgcw2qzvmtahnan5AeM3wCeEpCtKj9CuosNW1suHFq0qXZSeIFfANqUv2Mu7rnqdk33niDOjo6REwCT9/yIoyLL75Y+ZhZs2ZRdnY27d69W7zOv86fP180bKUNGzZQa2urMq3rSE9Pj/gY9QsAgC8ydfYoz3hzgfX6gaFlVb5QILs61aBuWnKBrJW+gUFlS64np2zVBbJUbhoqiFmlasGYnMi1x8sfxvugA0Dik0s//OEP6b777hO3QX+oSQFgouBTQdywZcWNbfShdVmVkalzW5NVOwacoW5aVmk4SMALwAatA64pHlyM66jWrBhWkw59nxmq2lVt/ayMcQ9nAEioSfXj8njXsWPHRJOW82s5t/bdd9+lOXPm0OHDh8WkbGzs0LQR4wZtTU2NuM2/qhu28v3yfSN59NFH6cEHHxz2dpPJJJrH4Do0vo0F12PyXBOezuwfGMrR2niilOYlhNGMJOMG1BfXNir3OYz6xb+9zgoZGFB+b0m9yaXfO9r1qG3rpj5rHnpMsN+4P+94xQQMKt9XQXU9LUkeeiBwprJOeV9skNnhfUsJNtPlM1PobGM7nZ8V4/H77y78m2WcBiLXYlwoNzc3U0iIcY41TtQ/u6hJtYd/T4wF12PyXI+CqnqbmvSN/QU0PTaYUg38ZHJJXZNyn0PNfS7VT2HmPuX3cm1rMsVpck0KVbV9VIDjuk9PXGvKr59fWUfZEf4Or3GM/4DD+zY7LoTW5CZQU2cvLUmJQE0K44KaVL9/311u2s6cOVM0aPko3ltvvUW33HKLyK/VE0+Q3HPPPTbfXFZWFsXFxYmFaDA+/PMD48D1mBzXpKO2gwIDbP/pff1YJT12dSaFGDSvqWOwRrnPU9OTKC7OtX93k6MixHGtxu5+t36m6t9b2tGg3KfcpHiP//2ZExpBgQGWKenG7kGbr9/cP/TzmpGRTHFxtk9mSjefF0++DP9mGcPrr78uHmDhejgnIMC9f2dRk+oDf36NBddjclyPtqJGm5qUh0XfOFZFD1y+1KWls57U1l+i3OdpGSkUHer8cf7I6BgKCjxFHPtq6jVrVpN21nUq92lKaqLH//7M6venwMPl4nZTn+331dRbqty3mVmpFKeKTlC7Yy1qUnAfalJ9alKX4xF4mnbatGm0dOlSMW2wcOFCeuaZZyg1NVWZ9FCrra0V72P8K79u/375vpHw5Ag3Z9UvAAC+SL2MSy4q4IVabx48S0ZVp84PG8exqTTrcbT2nn5q67Zd2qXFIgpvHEXjaxcZYimC5dIxh0fRHGTaAoDvQk0KABOFeteArEnP1LXQplMVZPQ9C6FBARTl4j4DXsIlY754GbD90q7xqlX9HL0R2ZWhikdQR3SJ162ZtmFBARQfjtM4AL7IX4vAYR6F5iZuUFAQbdmyRXlffn4+lZWViTgFxr9yvEJdnWX5Ctu8ebNownLEAgDARFetatr+4IJ5FBRgmWT46GQZFdZblgAYtWkbHhwwroVf6sUP1a22xaQmTVsvFMi8ZCIrzpINxhnFvJ1XqmhuF7/GhQdThIcXpAEAAAC4UpMG+vuJmlR640ChzRP2Rlrm22DNtE2KDB3Xwi9Zk/LCWJN1x4Sv16RhQYGUaM335UEC2Yzu6utXfl7c2PX0gjQA8ELTlo+Ebd++XWwq5uYrv/7555/TN77xDbG1+LbbbhMxBlu3bhWLyW699VbRqF2xwrKJev369aI5e/PNN9ORI0fok08+ofvvv5/uvPNO5LABwKTAz+zLCYG5aXF03aI88TrXV3/YeVqzZ/21whtx5cKv8S4nkJO29k1rd/B08niXo+kx2SCnbVtFA9eSHYYpW9Abn3D61a9+RU8//TQWkQEAgEsN0No2S02WGh1O89Lj6eKZloVUPf2D9Oc9Zwz302zq6BF1qTu1n7omrdG4JvX3I0oYIX7AU8vIuBnNi47ta251zQqgB9Sk+nEp05YnZP/jP/6DqqurRZN2wYIFovF6ySWXiPc/9dRT5O/vT9dff72Yvt2wYQM9//zzNpkNH3zwAd1xxx2imRsRESEycR966CHtvzMAAIPpGxhUjnVxgczPeF85L5t2n62lMlO7eOEG6XgiCPTCG3FlH1mTAlnVbHWHfKDBk8pxXjruZbOtt7mDZqXEKsfQGApk0Bufdtq5cyf19fWJ2wAAAM7gCcy+AUuBl2qNmfr6smm0v6xenCA6XNEg6laOFDCKemsN7U5Nmq46/VXV2klz0tzLn+VhC1mTJkWFUQB3br1Ukx6uaFROfPHkrToqAYMEoDfUpAZp2r700kujvj80NJSee+458TKSnJwc+uijj1z5sgAAEwIfn5IN0DRrgRzo70+LsxJEw5aVmzoM1bRVH48bd9NWXSCrmpruTIfI+5USFe61ZRlZsZZ4BFZpjURQ59uiaQt6CwwMpO9973vU3t4ubgMAADhDPYXJgwQsPDhQnALbebaWeKCVPyY7fqjW8TZ1DMF4T3/J75VVa1CTtnb3iclk8bmjhj63twcJFmUmoiYFj0JNqh9U+AAAHo5GYOmqBVXq5l+5qZ2WZCUa5prIyWA23mYy/z4ePBAPAFQ/g/EydfYo0yHeikYYViCbLIW/eqpB/X4AvQrkK664gkwmE5q2AADgNHU9pn6S2ZLXX6vUpEZq2toOEoRqcPrL/ZpUTtl6azGulGnds6AeIFCf/kJNCnpDTaof45x3AACYRFMN6unTzLihYpkLZCOpb7Pk2bpTIPNRsRTr98sFMk/KalW0e7NAjg4LpijrtuVyWSDjKBoAAAD4UNNWPX2apa5JraeIjKLeulTLnUlbjtQKDrS0QKo0yLRV71jwxhIyR/EH9oMEwQH+yqIyAPA9aNoCAHiIOhogVfVMP0/dyhP+6uP1RqCeIHBnqlU2qXlClhdJuHefjFEgqycXWsQCsj5lqiEyJFA0dQH0xFl6VVVVYteA0ZYYAgCADw4S2Jz+MlpNqjr9Nc76jyO15PfLn6/fzTz4GoPUpLzgOMnamOValPOI5c8rPcZ7UWIweaAm1Q+atgAAHqJewqUukHnJg3yGnJ8Vl5txjTTVwKWeO1m7XDCOJ9e2ubOH/rr3DO0psyxXsD/OZpSmLTtT10ymzl7r241znBAmLl76+t3vfpfuuececRsAAMCVSVvOsY22nhpi3PjjBqAxT39Z6uiYsGAKCbTcR3ciEvi5TvWJsrFw/fnKl/l0vKZZeVutgWpSOSXd3TdAx6oalT0a2LEAnoCaVD/ItAUA8BDZrORik4tkNY5I4Cnb/kGzKKSNkj0lowj4OJk7G4RtFj+0dtKCjASnsmsf+viAaHb3D/RTWHg4XTA93W7S1ntLH+ybs3tK6pTbGbHevV8weURERFBvr+XJAgAAgLH09g9Qo/VJeR4i8FNNYfJtrkEL61vFE/ddff0UFhRoiPvc3NWryT4D+wW56pzbkfBQBdekvHhscGCAYqKjRS1rsxzNy03bjNhIOlje6KAmNcZjCpj4UJPqw/v/AgMATAKdvf2i0LOfOlUvI/uSLAVWhandEE1bLtTlfU4aZ56tlO7i4geOG/jlxoM208l/2HVaFMQyP4wfY3g7o0ud/ba/rMFhthiAXkJDQ+mNN94Qi8j4NgAAwFi4tpJnuhw1LHkZGTdtGQ8UTE+K8foPtc4mzzZUs6atMwtyOUqCa1JZEw+SmZ75/Bg9dMVyZbghXmTljn/6VwtZsSPUpAZ4TAETH2pS/SAeAQDAA9RFobpYdLiMzCC5tg0aLHxwPNUweoHcam3Yyo8LCrBMgHBsxJOfHVUmlhMjQt2a/tWCuhDmxryjtwMAAAAYsiZ1OEgwfKmVt9W3azfRmubCIAHHH3BNKqd8ZU3a2TtAj20+rDRyvbkY19FjCXVNaoRBEAAYPzRtAQA8oFq9hMxB0zY7Tr34wRgZYnJ6QIsCmSMhZEaaevmFPV7m9X+bDikL2RIiQujxa1bQnGTLlEd7Tz/19A8aIjuMRYcG22TBSWjaAgAAgC8OEvCkrVQ2AWtSZwcJ+Gs+vPEgNXVaMuNz4iPpyevOoyxr01fufdDiPmlBLDa2e1uAv5/Xo8QAwD1o2gIAeIC6KHQUj8DFXrB1anQiNm05I01+3zzBy1ttHfnDzlNU2tSuHDX7+aVLRJP79nOnDvu5GWGqgWWqHtwwbk7zfQfQW19fHz399NP0wgsviNsAAACuDBKM1bTlyC7D1aRunv6KCAlSnnAfaZDAbLZEIDR29CjTqj9dv1jEcn3/vOnDnrA3wiABL2ezr9f5+nLjFkBvqEn1g6YtAIAH1IxxFM3fz0+ZzuTMVl644G11qqNovE3YXfKBgdlu2666QD5caVmgwIva7r90CaVYfw+/fu/FCykiZCiK3SiTA/bHzjjPVr3UA0AvAwMDtGXLFtq+fbu4DQAAMJZq1b4AR6e/+HSUbEoacdLW3T0L6lqcYw/UUQISn+w629Bm+XqRoaImjQ4LFq8nhIfQf120UIlKMErT1tFJr3QsxgUPQU2qHzRtAQA8QD6Tz728pBEmBORSK25qVqqmILylrk3bY1/qBwZVDpq2XDj3WqMPeOmFfXObf/+P1y0QDVyeSj4nN5mMQJ39xpAdBp4SGBhIt956K914443iNgAAgLOTtnwqSEZXjXSKiDNbedeAt8koAh4aTYgI1bQmdZRrW9M29LYFGfGika02PTmG7jh/rqhHucG9ICOBjEC9IJdlxtqeBgPQC2pS/aDCBwDQGU+Qyvwwbn6OtDzLJkOsqZ2mJEQbYqqBJwniNDjur443cHQcrVY1RTFS9MHs1Dj6zb+vEpPJIz3Q8PZUA/JswZMF8nXXXUcmkwlNWwAAGFNbd5+YIh3p5JeUHRdBJ6tN4nZ5czvNDYv3ah0ta0QefOAa0F18Kkpdk+Yl2tbcdapp5JFOdq2ckkJz0+IoLCjQ64txRz79ZYxTaTDxoSbVjzH+dQEAGIcvCqvp7rd30ccnygz98+MFBnJ5VrqDY2hSlurZcLmIy5sFsoxHSNSoQOYFCaM1bdWTDqMdM+NJW6M0bO2b7SwDR9EAAAAmlfePldLdb+2iXWdryMiqW1V5tqM09NQTmuUm79ak3GTu7hvQdOGX+nuvGmPSdrQdCryQ1igNW0eTtRgkAPB9xvkXBgDABWfqmumFHSdF/uvrBwqpf9DxYisjUDcjU0crkFVHmrxZILf39IlsWRlV4O7CB0dH0RzFP6jzylINsmTMGZEhQTbH5jJwFA08+ORKY2MjNTU1idsAAOB5e0rq6LX9hWIa9I0DRYa+BOonzR0tIXN0zL6i2Tu5tvz/tebOHtpXVqe8LVmDPFv701+VDgYl+PGFlGqQHQrO4CatnLPgX9UDEwB6Qk2qH8QjAIDP4abib7adINmj6BswU01rl2GzRNUF8miTtpwtxlOkvBCh3IOLH7r6+ulgWQPtKa2jgroWkS2rplWBzNOxvHW3ob1bFMj8P3f1wi7bSVvfKZDZnNRY2l1cJ66hFkvbAJzR09ND3/zmN8XG3vfee49CQ/FnDwDAk/gJ59/vPGmTvcp1FR+ZNyIZ1+XKpG2ZBwcJuMbfW1pHe0vq6Wxjq4hzUNNqkIAndgP8/Whg0OxwkKBGNUig1XSvJ/DU77SkGFHPT02MNtQUMExsqEn1Y8z/mwAAjIAbfX/YeUo0/tQqm9sN27StcrJA5gZmdlwkna5tFpEKXLjyFKdeP8cD5Q30RVE1HSpvEI3vkSzKTNTs6/JkA1+7rr4B0RxWZ+XKvDI/HyuQ2S3nzhR5aAvSEzSJkgBwVkBAAA0a+KQBAMBExae8frv9BHX2Wo7uS/zENDfOfHmQgIcI5BPtFab2YU+0a4kbpxwrsau4lo5WNtLgCCUpLyHTauFXoL+/ONVV2dxJNS2dNGg229RvtdbaPTYs2FCRXM64a81cMf19rkEW9sLkgZpUH2jaAoBP2ZJfSXtL64e9neMEzs0lQ+Ji0FFEwEgRCdy0lbm2s1JidblPH58sp7/uLXBYpOfER4qcVn6ZlRyjbBDW6tjW0com5UGNo6ZtfESIz00GcDzClfNyvH03YJLhyVqesOVFZJiyBQDwrLcOnRUTjfYqjNy0tTYjecqUdxaMJis2QnmivbGjRzRx9fC3/QX08YnyYW+PDg0SwwxZ8ZHi1zmpcZo+qc/LyLhp2z9oFhPTskbnSelW64TvaHm2RsU/o6vmoyYFz0JNqh80bQHAZ5Q2tdFf9p5RXv/60qn0ujU7zNuLu5yZtA0J9BfH50djs4zM1K5b01Y2TmVRfE5uMp03JYVmpsTqOimqztbi42jz0i3biHmquMO6zThljMY2AAAAgDfxROi/jpYqE6DXL86jNw+eFa9XeHlx10h4mlRGUfHCV27cjoaftD9U0Shulze369a0PaaqSRMiQmhFbgqtzEuhvIQo3aZ7h2rSemWQQDZtfTXPFgAmJjRtAcAncKHJR9DkMf4NszPpink59Oahs+IZckdLBIygb2BQWbDFCx/GKj7Vix/Kdfyeqqz5XWFBAfT8184fs3DXSoZ6W69qAllO2bJUH4tGAAAAgMmju2+Anv/iJMlT/DcsnUbn5aUMNW0NWpM2dnQrdfRocV3qSVuJG9GLNYzLUkcjyOlfjjl77JpzPRYzlW5Xky51UJMm++CkLQBMLL51/hQAJq2SxjZlcoGPSH1j+XTRaJRFJzchuUFqxOwwuTDNqQJZFUWg1zKynv4BJROYpww81bCVR9GkKtWDGpkdJqc/AGBsvIDshRdeoJdfflncBgAA/R2taqQW69LW+enxdMW8bOsyWUv2aUWz55bJuoKjxCQeJHClJi3TqSblwQZu3MoILU/uBeCvJ6mXkclhC4ZBAgDnoCbVD5q2AOATjlYNHZ26eFaGknkql49xvadu/BlFcWOrcntKQvSYH8+Lx+LCg5UCmRc/6NJIdjBl4AnRYcEUGRI4rEBWTzUgHgHAOQMDA/TRRx/R5s2bxW0AANCf+jj/pXOyRKORT1JlWCOuOP+1s9cS+WS0AQhpSkKUU01N2UPVa5BAnvzyRk2qHqZQn9irbVMNEiCyC8ApqEn1g6YtAPiEY6qmLU81SOolWXrGCYxXSdNQgZzrRIHMMq1FP2e8NlsnOXQrkFVTBp4ic21Nnb3Kgxp1fhgmbQGcExgYSF//+tfp+uuvF7cBAMBzNSmfVJqdGuswTsCIsV1nXRwk4AEJOZHLtaOciNWSOipLfRrLE8KCAkWGrrwfclCiBjUpgMtQk+oHTVsAMDw+zn+mtlncTooMtWnqyUlbo2aInW1wbaphWK6tDpMN6gLZ01MN9sfRZAPZdtIW8QgAzhbIN954I33lK19B0xYAwAO4XpE1y4zkGNH485WaVE7ahgYFOF1rZVprUs7ClUvMtKQ+deVMjJhegwQ8RCAjL+T1jQgJFCfgAGBsqEn1g6YtABjeqRqTWDbGFmTE2yzzyrJOpbIKnY5uubM8rdQ6acvNZmcLP87slUqb2nU+iub5SVv1JIWcRJEPBKJDg2weAAEAAAAY/eTX8NNfxqpJW7t6RWyDHCJwNjs2J25o4EDWtHoNEnijaWufa8v7MRqtex9w8gsAjABNWwDwqTxb+wKZJwWCAvwMOdXA2bE9/YMuTdnaxyio4xW0LpC5XvdGQZoea7utl7cwyxgIZIcBOI+PcnZ0dIgXPfKvAQDA1rHKRuX2gowEm/fZTNqqln75alyX5WOHGtElGg8S8P+35CABL3LzxpP2GTG2NWl9e5ey9wFNWwDnoSbVD5q2AOAzUw3cZJybZtu05UkBOS1a3dopniE34sIHVwpkftY/0N9v2OfQavqXm8myGJUL3bw2advSYbOlFwUygPN6enrohhtuoG9/+9viNgAA6IdrqOPVJuXovP0T8rFhweLtRsy0LVYvIYt3vibNUX2s1jVpW3ef2N/grbiuYZO2zR02ebapWEIG4DTUpPpB0xYADM3U2aNMK+QlRDuMGJCTDTxoJhuShiuQXWjaBvr7K0fsqq2TqFpp7OimXmtj2xvRCCwxMlSZjuYCWb2lNxV5tgAAAGBARQ2tygLVuWlxwyIGOL5L1qRNnT3U0dNHvl6T8gRsVGiQEo+g5amOSi8vxhVf1y6yS71jIdkLp9EAAOyhaQsAhnZ8lGgER8+SVxgoQ6xYdRTNmS29ajnxlqatWeNlZFXN3l1CZj8dzcWxOtYCk7YAzgsJCaF3332X/vrXv4rbAADgmTzbBem20QiOIhLUTUlvK25sFb8GB/i71CDlRnSOdZCgtbuPTNY4q4mwGFfuUpDT0Xx/alXL1jBpC+A81KT6QdMWAHwmz5aXkDmSpVr8YJRcW55EKLEWyDylEBMW7NLvV09BaLn4Qb2ETN3s9jRZnPPAhvpBEDJtAcilB9O8rZdf1AsaAQDAO4MEmaoFueUGybVt7+mjujbLcq0cF5aQOYr40qsm9dbpL/5/p/zaPB2tXgCMQQIA1/4uoSbVB5q2AGBY3PiUDb2QQH+alhTj8ONsFj8YpGlb195Nnb0DLufZOswQ07RA9v5Ug33D+HRts3IbBTIAAAAYTVdfP+Vb6xVegjvS0Xkj1qTqRqsr0QhSrk65toapSVVfO7/Oco2DA/1FRjEAgLehaQsAhsUTCi3WY1hzUuNGXJrFhbPMSNUySsAdxQ2WKdvxFsgyHoGVNLbrkx/mpakG+68t49HCgwMoykFmMQA41t/fTy+//DK9+uqr4jYAAOjjVI2JBq31yoIRpmyHnf4ySk06zjxbiadz9RkksNSkoUEB4lSakWpSHiLACRYA56Em1Q+atgBgWEerGsc8hsb4mFeGKiO1z7poy5cL5LCgQDHJwcpMbTQgHyloNNXAGV6Olrp5irxeaslR4SiQAVwskDnT9sMPP0TTFgBAR+oop9FqUkt9FWioSVv1dKx6atZZPAXLWbisVKNBAq7V662RDfz5vdkgdRQXhjxbANegJtUPmrYA4BsFcobjhQ9SpnWygZ8h5+2vRmrajiceQV1Y9w2YqVqDZRa8xVhOLntzypaliQLd9m2p1iY1ADiHs8OuvfZauuKKK8RtAADQx9FKS03KtcvctJGbttx8lNO2zV29Ik/WKDVpoL8fZca5Xv/xcES29QQYD0d09rp/sqO6pVMs2zVCTaqOR5AQ1wXgGtSk+kHTFmAS6h8cFEe2BuUZIAPiZ+BP11hypfjIlKOCasRtvV5u2oolZNbjYzxxMd4jX7luHEfj+1DT2km9/ZZcXVbVaozsMMZRF8mRtk1aFMgArhfI3/rWt+imm25C0xYAfBLXKVy3cd1iVI0d3cpJJd6vEB4c6PTkprenbTmLlxukjBuvgf7je/ivntB1dRkZP97gKAT14w7bJWTerUmTVDFrEmpSANegJtUPmrYAk9AzW4/Rve/tod/vPEVGtb+snnqtMQd8DG2sY1NGWvzA22fbui2TFVMSosd95CtXlWur3mbrjPeOltCP3t5Nv/hwP/VYG7eyaDfCVAPLiLUt0nEUDQAAYPLg6KcHPz5A//Xul/T24WIyql1na5Xbo+XZGrEm5frR7EZcl6NcW1dr0pd3n6Yfv/MlPbb5sNK4tR0k8G5NypPEadG29yEl2ruNZAAACU1bgEm4SGF/WYO4vaekzrDTtptOVSi3z5+WOubHy3gEVt7c7tN5tu5u6+WjeP88WqIU1v84WDR8qsGuYeoN9kU6phoAXMOTaZwhxi9GnlIDAHBk19kaOtvQptSkRsR18ubTQzXpqryxa9KsWOMsI7ON64oe9+dRDxK4cvqLBwY+y69SIiY+OVkublepmtljnabzBPu6GDUpgGtQk+oHTVuASeYd1SRDd98ANbRblgAYCR+7Ol3brEwrzEmNG/P3JEWGUnCgvyGmGrTIs2Wx4SEiXkEWyM42ZbbkV1JP/9Ayto9PllNBXYtytM8IUw2OFj8kRyHTFsAVPT09ItP25ptvFrcBAHwFN0PftT7BzCpbOgyxSNbe4YoGqrfWygsy4kUmvy9N2pY0tmoySMA5vfLgWKkLgwQfnShTJn3ZGweLRC6urEn5cxphqlW9IDfA348SIkK9en8AfA1qUv2gaQswiZypa6bj1Sabt5V5eQLAEfVEwyWzMp2KF+CjTbLgqmvtssly9dUC2fL7LVMR7T39InZhLPyAZ6N1ikHiXu/vdp6kMutxNs7t4ia3t6kzzPg+xY0z+xcAAAB8y5fFtTaxTUZZJGvvE9XJrw2zM536PdFhwcqT7uUGmbT19yPKVp1Kc1VIYIBSZ5c3O9dgb+3qpW2Flilbqbd/kP6w85Ry+oufsOc9B0aqSblG5sYtAIARYNUwwCTyzuGhiQaJG3nLspM8Mqnwj4NnxTQsHxvj7bX867SkaAoODFA+rqOnj74oqhG3Q4MCnIpGUE82cHFqtk425CWO/xjYWPEDvISCG8WOyKN+ESGBbjdHc+Ij6UhloxKRMNYz/zvP1ohtxWxpdiI1dfSIn0llc6dNduxI992T1NO+KVHGuE8AviQkJITeeOMNMplM4jYAgC9O2aoHCdw5oeSsLwqr6cMTZRQREkRZsREiYot/5SVj6mYdN5X5SD/jem5RZqJLp4laa5qptbtPNC+5katXTRoRHOhwwIEHGOSkL0/Kutsc5ZqUPx9nEXODfaxrtTm/gvoGLHO2a2ek09HKRmrs6KETqgESI0QjOKpJAcA1qEn1g6YtwCRR1NCqNP/CggKoq2/Ao5O2fz9QRCXWSc/82hbl7QkRIfTTDYuVYmlbYbV4Fp6tmZZGYUHO/zPFU62y4Xu2oVWXpu3WM1ViQmBmSiz9ZP0iMXmgZursUZqmU+Kjxr2ETFIXxByRsHSUBjvHJ3x4vEx5/d/m54j799N/7aVB1dk0I0QjsMiQIDonN4n2ltTThdPTvX13AHwO//sSERFBvb29bv9bAwDgKftK66nC1DGsJvXEVCrXSn/ee4Y6evrF6ydVDcSsuAj66frFIp5KNh3VJ79ceXKZa9JTNZaor6LGVlrsQsPXWW8dOisWuHEt9cML5w+7f6WmdjHBzLRohufER9FO61I2rklH+5zcMJb7KfhuXbswl1bkJtOjmw7bfJz9AjBvyY63DJLw46U1LgyMAIAFalL9eP8sAgB4PMv2a0uniuPonmracoGszlNV42fcH9l4iOrausTkxSa7aARXTEuOUW4X1A81hrXEx7y4/uXM3b/uPTPs/epFGloUyOplZGNt6+WmvJyomJ4cQzOSY0WBfc3CKSMeAfO2uy+cT3+4cQ1dMS/b23cFAAAAPFATvndkqCa9+ZwZTtc5Wmjr7lMatvbKTR30yKZD4mN478O2AsvRfq6ZXX1yeXqSqiat06cm/dx6//jJb7mAVm1PcZ1mcV32de1Y12p7UY2YMmbcrE2KDKMFGQl0wbQ0m48zwmJcxg3vB69YRr//+ho6z4llcwAAnoKmLcAkwMfqD5Y3iNvx4SG0bkaGkktV09qpe/5rS1cv9Vqzr+amxdH/Xr6UbjtvlpKtxVmtj3xykLYXVlNta5d427y0OJtFDs42OAOtx9oK6odyZbWkXty2Jb+KdhdbJg5Yfm0zvbqvQHl9YUaC218vJTqMQqwL1vg6jkY9ZXulqgl6zYJcm5+letmCEZ6V5YlbAHBdf38/vfbaa/TWW2+J2wAARneookE5eZWXGEUXTk+jyJBAjw0S1LZb6ky2Ki+Ffn7pEvrmihmUaI2z4gngX20+RJ/mV1Bnr6U+5iZelDWj1ln85LlUqENNyoMO6l0Hbx46qyzxlZnBHAEhJ13np8e7/TU5HkG9NHi0+/bh8VLl9Svm5Si3bzpnOsWooiKMcvpLNm5RkwKMD2pS/aBpCzAJvKuaaLhqfo7ItOJjQIyPTem92bZOVSBzxhdHC1w8M4N+JmIRLM+w17V10+92nFI+7hInlz2o8fclpwA4h4xzvrTERSjHH6hxVAJvwW3s6KYnPzsqcr7YpXOyaJ4GBTIXkNnWaVveXjzS98QNXblkLiUqzCanmH8ud66ZK/LY+AHSshz9M4wBwDMF8uuvv05vv/02mrYA4BNTtnycX7pu4RTx5C3nrcon+Tn/VU98skvi00hz0uJow+wsUZPKZiLvJvjbvkLl49a7ePJLDknEhVs+X2F9i6ghtcT1qPpT8u3fbjsu6kSuCV/YcVJ5303Lp2vSHI0ODRbfF+OvMdL3dKi8gWqsQxizU2NpqiqujJuid62ZKxa18XDDDFVzGwB8F2pS/aBpCzDBVZjaaW9pvbjNBdK6GZbjXbJA9sRkg5yelQ1FiZcycJ6t/bIuzrldmjW+xqLtZIO2x9E4q1adDcs4h+3Zz4/R/9tyVDkGxtPEXCBrRX2kjRfHOSKnKdjlc7OH5ZpxM/uZr5xHj1x1zrAcXgDwTQEBAXT55ZfTJZdcIm4DABjZsaomZVkrT20uyUocNsGpd02qbtomq2pSXtLKjVteIqvGOafj2ZHAzWhebCZrxSqNByR40ayjyLHfbjtB/++zo8p+iPOnptJlc7I0+7pyOIK/Jx4mGKsmVZ/8knio4cUbzhe7IbCEFmBiQE2qHzRtASa4fx0bOp505bwcCrY27GQ0gUcK5HbHBTJLiAiln126hGJVR6Uumplhs73XFdNUhbXWx9F4mlZaPTVVaUDzA5Bia3QBN6B5GcR47/9YubZnG4d/T30Dg7SnxBLTwA82LphumxcmYVERwMQSFBREd9xxB33rW98StwEAjOw9Ve4qRzfJuiQ7bqjO0XsZGZ+OcjRIIAca7lu/mEKDAtyasnWUa1vYoF9NumF2phIxwfsNZJQXn676zqrZmtZ/6lzbYgffE98vuYAtLSacFo2wgA01KcDEgppUP2jaAkxgPE2w42yN0sy7eFaGzZEwqbzJg1MNkbYFsiyauXHLx6fmWY+pjdd0HZeRNakKZI55+MGF82yas5w9+18XLXQ592ws6mNljpZZ8BG1vgHLCPCSzERM0gIAAIChnKlrVpp5qdFhdE5usvK+rLiho/ulXpq0VddcP7lkkbhPK6Yk08q8lHF/LZ7S1WsZGU/VqpvDd5w/x+b9HPVwz7oFIiJLr5r0jIM6+4zq++QFZJikBQBwj+35DwCYUPh4koybunR2FoUFBdoUcxyXwEf69T+KNtTsTIqyjUKQeFHWL69a7vbXSowIFd8b56LxpC3nbWlVMKoL5ITwEFG4fmPZNPrL3gLir/D9NXOVrGAtZcZFUFhQgDiKll/XIjLh1BMK6ua0umkNAAAAYAT/PDp08uvqBbk2tVlmbKSoo8wemLSVTVseZggPdvxQmHcvPH7NCre/1pSEaLEEjGtxrQcJGjuHauv4iBCanRpHl8/Noo9OlFNQgB/ds26+OM2mNfX0sKNGNGpSAABtoWkLMEFx03LrmUplAtTR9CpHJPDyKm7c8sert7nqUSBzk1jdONYDNzOnJ0XT/rIG6uztFwvJeCpWCw2qSVu5ZfiyudniqBgfpePiXA/+1lw0zoLj68QZYurpEHV2r7qYBoCJrbu7m2644Qbq6+sTy8hCQ7V/gA4A4C7O4z9Y3iBu8yKrVXmpNu/nGio5OkzsQKgwdWj6hLt9nFSTdaGsfTSCHvj7yomLpJKmdvF9dfX1a1YHN6ryZGVzlvcpzE+Pp6TIMM1qX3t8moyXCFe1dIposN7+ASV6zT6abFoialKAyQI1qX4QjwAwQX10okw5Ms8ZsY6O7Gd5YPGDukB2dAxNDzZTABpONqjzw+JV0ws83aBXw1ZSb9e1n2wosBbIwQH+NgvmAGDiGxgYEC8AAEb1r2MlNoupHB3Z5+Ym6x0YtFlgqyWu4+QJNE/VpNOs9Rt/2SINdy3I019+1klbcdvPT2TI6tWwtT/VNTBoprPWnQ6y5i+x7l7gCAyt48IAwNhQk+oDTVuACYgnTDefrhC3OXP18rnDN7cOW0amU66tOjvME1MN9hEB6ilULTf18qSIJ6mbtuoMMVNnj7JwYmpStKYL0ADA2EJCQuiVV16h5557TtwGADAaXvy1q9iyLJWXZa2dMbRfQU39pLNegwRj7VjwxUECPiUX6O/Zh/Qzk2MdDhKUNg3tWOATYgAweaAm1Q+atgAT0KbTFSL/lK2ZljZippW6aatXhlhd++gLH/QgM8Tsj2lpVSBzzIPWix3GwsWvbMeeqbUs8rBvSquXQwDAxMdTVQkJCRQfH49N3ABgSB8cK1WmWzlSiiMDDNG09cLpL61qUp5o5bgspkdurSvDEfl1zcNOfomPQdMWYFJBTaofNG0BJhjOlvr4RJm4zY3Lq+bljPixvPxLNjdLJ1CBzA8IZEOaC3/OEHNX/+AgNXf22uTZehIvy5APaEpV35P6AQCWkAEAAIBR8GmgzwuqlNps/azMET82Rx3Z1TR05F7rqV9P16QcE8BLz+QT7bxMVoufq/wsCdZoBE/iTFu5xI0nbeX3ZLNjIRmDBAAAWkDTFmCCkYvF2IrcZEqLCR/xY3lxQGq05f2Vze0im0rPAtlT8QjqZ/i5jixuaNO4QPbOsh8ZkcDfk8xFUx+1w1E0gMmlv7+f3nnnHXr//ffFbQAAI9lXWk/91try4pkZFBkycsYpN1GDAy0PTctNHRMmsounz+RCLq7P61QLxLTYsZDghUECXhIn62zxPVl/rjIqATsWACYf1KT6QdMWYIJRxxwszUoa8+PlRCpnUNW0dupaIPM2W0+ZlhStaYaYOs/WG1MNjnJtxQKIhlblPnk6ZxcAvF8g/+lPf6LXXnsNTVsAMHZNmp00ZiMwKzZSecJfi1NSI9WkfMrMk0/Aq6dOC+2WyY6HXPDLvFX7zUhR1aR1LSKuod7akM5LjPZ4zi4AeBdqUv3gX1OACaaieWg6wZntsTbLyHSISJAFMi/IktttPUEdFaBF01Y91RAf7p1JW/X3dKa2RTwY6ukfHPY+AJgcAgIC6KKLLqI1a9aI2wAARq1JOZJrLFlxQx9TofG0LR/hl6e/EiNCPbq4VetlZLaDBF46/ZVk27RVRyOoBycAYHJATaofSxgNAEwYFdbGK08RONW0VWWIcRNw5ZQUTQtk2bRNigwVUxSewrEPnCHW0dOv5G3xEbXxajTApC0f5eMlaHwUjYt+deGPhQ8Ak09QUBDdfffdZDKZxG0AAKPguqu82VKTxoYFjxqNIGXHRxFRtTJIoOUT0h29/cqSXk/GddkvitWiadugjkfwUk06Ncmy9Jcju7hpK3N7GeK6ACYf1KT6waQtwAQyaDZTZUuHUpAGBYz9V1y9rbe0SdtJW24uyklQTy18kPztMsTkkS1N8sO8NNXATWf5AKazt5+2FVge2DBMNQAAAIBR8HF5fuLc2SlblqPj6S9vLCGTIkKCKCPWskOipLFNLA329Zo0LChQuV489HG0skl5H05/AQBoB01bgAmEp1o5m9a+GTsanoDljb722WNa3R9vFcj2jUz1sS1fLZDZzORY5XaRNc+Wj/hNScBRNAAAADCGcnU0gpM1qbp2nXg1qeVJd97LVtLk3oJcefqLJ13jvLjPQDZn+ZFHcaPle8KOBQAAbaFpCzCJs8OUxQ/WIpmnUXmCU5cC2YNLyKS8RD5mp80UsdEKZLXc+CinpqoBYGLp7u6mG264gW677TZxGwDAl2vSqNAgigsPVuo2PkE2UZq2UxK0q0mbrIMEvITMk9Fjoy3IlRCNADA5oSbVDx7lA0wg6qkEZwtklqcqJI9WNmp2f2rbvVsg54hsNAv3pxosBXJcWIhHl1c4ulb2X1+9lRgAJpeOjg7q7Oz09t0AALBRac2ztV8wNhZ5coiHCOSJoonQtOUn2CWOSBivvoFBEfvF4r148ovNUJ3+krBjAWDyQk2qDywiA5hAKm2mGpw7isaWZCXSJ6cqxO39ZfW0QqNlZOoC2dNLH+QEAk9ttHX3aVgge2/KlgUHBohpjcL6oQcymGoAmJxCQkLod7/7HTU3N4vbAABGUW4aqkkzYpxv2i7LTqKD5Q3i9v7Ses2agN6uSXnxLz/lbnZzkEAd15Xo5ZqUI9ZiwoJFfrGEQQKAyQk1qUEmbR999FFavnw5RUVFUXJyMl1zzTWUn58/bCz6zjvvpISEBIqMjKTrr7+eamtrbT6mrKyMrrjiCgoPDxef595776X+fu2OZANM9qNofFIqLcay8MAZs1PjKDzYkmt7qKJBNCknwlQDL+6SSxK46WrqtEQcjISP4e0oqqZnPj9GR6ubhx1D83ae7UgRCZhqAJic+N+49PR0SktLE7cBAIzAbDYrNSk/gc6LuFwZJJD/mvEggdaLyLjejQgO9MrirpToMOVk3ACH246Ca/HNpyvo93sK6Uxds8OmbXy4d2tS/v/OTFVNyifB1BPFADB5oCY1SNN227ZtoiH75Zdf0ubNm6mvr4/Wr18vxqClH/3oR/T+++/Tm2++KT6+qqqKrrvuOuX9AwMDomHb29tLu3btoj//+c/0yiuv0C9+8QttvzOASYYbjlUtlr+LadHhLmWc8scuzkwUtzt7B+hUjUnTpm1kSCCFe6FAZrk2GWJtI/7sdhfX0n+/9yU9t/0kfVlcR3/cW0TdfQM2ebZywYK3zVBNnUSHBolJBwAAAAAjMHX1KjsSMlyI62I8uTkjxVLnVLV02pwiG6/+wUFqsDY7eceCt57kkjUpLw2uttbsju7rp/mV9KO3d9HLu/Npf0UT/XbbCSXf12g1qXqQICc+UpwIAwAALzVtN27cSN/85jdp7ty5tHDhQtFs5anZAwcOiPe3tLTQSy+9RE8++SStW7eOli5dSn/6059Ec5YbvWzTpk108uRJevXVV2nRokV02WWX0cMPP0zPPfecaOQCwPjUtnaJItDVPFv1cTTScLKBJwSarIWlN6ZsJfUz/nKzrdqJ6ia675976dnPj1Nl81AuZHf/AO0rrRs21WCESdsZKbFimprNErcxYQcwGfEppQ8//FDUVjixBACGjOtyIc/WUU16QIOalBudcqeZkWvSPSW1dM/bu+mlXadtmrO8KDi/tnn4pK0BalI+rSdxTQoAkxNqUoMuIuMmLYuPjxe/cvOWp28vvvhi5WNmzZpF2dnZtHv3bvE6/zp//nxKSRnKzNywYQO1trbSiRMn3Lk7AJrjZ7u5OFK/dPUZM8qjXLXwIdMaCeCKhZkJFGhdcHWgrMHtjb0N7d0it8tb2WFSjmrS1j5DjKdAHv/0CJWpF7ipHlx8UVQjfpXTGUZp2vJRw9tWzqJzcpLoa0unevvuAIAXC+QXX3xRPEGOpi3AxNbbPzCsJuW3GVGFqq7KcmHHgqOm7T4NmrbejutST6KOVJNyfMMzW4+LBq2jmnR7YfXwTFsDnLSamhhNX12SR+flpdC/zc/19t0BAC9BTaqfcZ9XHhwcpLvvvptWrVpF8+bNE2+rqamh4OBgio21fZaNG7T8Pvkx6oatfL98nyM9PT3iReIGL4DeuMD7+Qf7lAVU6rym/7xwHp2Tk2yoiyCzw8Y7actZW/PS4+lwRSM1dfaICQAuxHy9QE6PCafgAH/qHRik0qahBxGMYyB6+weVwvimZdNpQUY8/fCtXVTd0k7Hq5pEccw/DyMdRWMXzcwQLwAwefn7+4s6rKurS9wG/aEmBW8oamilX248qMQ2ScGB/nT/hiXDsu59vSZNjQ4XdVmFqUMsXuWdBHHhIT67hEyakjBUV9vXpIcrGpRhhxnJMXTT8uliedm3X91K/WaiL0vq6NYVM5VTbCzBjZ+Jlq5dOMXbdwEAvAw1qQGbtpxte/z4cdqxYwfpjRegPfjgg8PebjKZREYuuA6N77F9dKKCmjqGijyJhxpe23OapkUFanYsXYvrUVjdQP0DlingaP8B8ffDVbMTwml/qWVx4PZTpRQ/L3Pc9+dsTb1yf8L9Bsd1f7SSEhFMxaZ2qjS1UVVdA4UFWfK29hRWKvfxiunJlB3hL7awL0uPoX82tRC36zcfO0tVjW3KxwX0dZPJpM2iNnAe/s0yFlwP4/jud78rrgfvF1DvGAB9/uyiJtUe/j0Z2z8PnqX27h6HNenre07RD1bPNNT1KKptUuqmCOobVw04NzGCShospzq3nyqhNXnjH5YoqWtU7k8o9Xu1Jo0I9KOWnj4qrDVRU1OT8lhi39kq5T5ePyeNEoMGqbOtleYlhtP+mjZqH+inz08WU3WzpSYN8POjge4OMvUMRXuBZ+DfLGPB9TAO1KT6/NkdV9P2rrvuog8++IC2b99OmZlDTZ3U1FSRS8tND/W0bW1trXif/Ji9e/fafD5+v3yfI/fddx/dc889Nt9cVlYWxcXFUXT0+CcBJzv++cHIipoLKTDA8leEj6HzKtui+laRMVXb0UeNAwE0XbUQytvXo6F7QNxfTjiYkZnq0iIy6YLQCHrjSLl4pv9kQwfd6sR94riIg+UNYpEX523JWAXOtJU/v7zURK/+eZuRFk/lrZbjZK3mQEqPs/z7VGA6pfzMzpmerSxL2zA/hN4/VSned6C6VUxXy4/LSUsmf2TIegX+zTIWXA9jwfVwTkCAe0tyUJPqA39+R2Y2m6mgqVPUIUEBfrQ4y7I49mS1idp7+ul0YwcNBodpGt/kzvXg+1vf1SfuL59OSk+23F9XrZkVQJ8UWHYLnGrsoquXjn2f2nv6aF9pvahJzza2ivvCevqHatJp6ckUFx1O3jItJZ6OVDZSzyDRYHC4iDjgOLYiU5e4j7xgdl5uulJrXjAjgw7XF4rbB2vaqa3P8r3wEtoEa0QheB7+zTIWXA9jwfXQtiZ1qWnL/+P7wQ9+QO+++y59/vnnNGWK7VEIXjwWFBREW7Zsoeuvv168LT8/XywrW7lypXidf33kkUeorq6OkpMtz5hu3rxZNF/nzJnj8OuGhISIFwBP4aKPj6LJY10/WrdA3P68oIp+t+OUuL31TJWmTVt3DAzyFlrLM+3pMRHjatjKjb18xO5MXYs42safMy3GcWHL0QIbT5XT4fJGET0wmpE+h6fkiuNoVeJ2SWObWJRQ395FNa2WSWr+nmXDlqVEh9O0hEgqae4WPwfZo+WFD2jYAgBMXqhJwRtLvZq7LMua56TG04/WWmrStw6dpbcPF4sFW9sKqum6RcY4os6RUp29lpOQmePIs5WmJESJDH/+fLw0lvcQqGs1NV5W9ml+JR2tbKTBUVYycFyWt3cT5CZEiqatzLXlpi1HQMjoi/np8Ta15vTEKNH85qGRo1WNykI1I+TZAgCA/vxdjUR49dVX6bXXXqOoqCiRQcsvnKXGYmJi6LbbbhNTsVu3bhWLyW699VbRqF2xYoX4mPXr14vm7M0330xHjhyhTz75hO6//37xudGYBaM4UW1SiqL5GUPPYq/ITaFQ69H6XWdrPLKU7FhVEz219aiyNdaRmtZO6rdWqRnjyA4bafnD/hGWP3C22P99coj2ltTbNGyjQoNEhqx84Yb3DUuner9AdrD4gX+uEhfI9lZkD02GyD8LRsmzBQCQ+aq33HILff/737fJ/geAieOoql7h3H3pwunpfAhM2FpQ5fYCWWdw7fv01mM2mbWOmszu5NlKHBuwjE+6icXAZqXRaY+fjH9iy1Gxk0HdsI0NC7apSXkJ2K0rZ457sEErufGqBbmNlpqUm80S75dQ4wbu+VPTxG31JeaGNgCAUaAm1Y9Lk7YvvPCC+PXCCy+0eTtvLf7mN78pbj/11FMihJgnbfnCbdiwgZ5//nmbEWCOVrjjjjtEMzciIkI84HjooYe0+Y4ANHCsaqh4WqAqnrhhuyovhbbkV4mjVnz8at0M/ZZBcVP46a1HxcQCH4N79t9XiYVhWi98sG/avra/UNnYe9X8nGEfww1P2STmRu25Ocm0ckoKzUqNNeQkalZcpJiW5WK3tHF403ZBesKw37M0M57ePlFJfQNDFbK3m88AAPYnoDgTsa+vTzkGDAATy9HKJoc1KU9aLshIEM3MhvZusTyVX9cLL2b97fYTopYqN7XTr69d4bDms6lJ49yvSTedqlAGCbjWtMcRXepG5ooplpqUl+lqtXtCS7kJUS4PEpw/LZXeO1pi8zY+/QUAYBSoSfXjcjzCWEJDQ+m5554TLyPJycmhjz76yJUvDeBRsngK9PejWSm2GVrcpOWmrYxI0LNpu/NsrXLEjHPLPj1d6bCJWtE8tIE2y80CmaMMuPHLRXdhXQs1d/ZQrN2z+fzAQPrR2vk0O9XY+cghgQGUEWP5nviF83blNQ4PDqC8xOHZ2BHBgbQkK4n2lFjy1BimGgDASIKDg+mZZ56hlpYWcRsAJhauV07VWpZmxYUHDztNtXZGujKB+tmZKl2btlyDyoeCVS2doj5y1ETlhq5WgwSzU2NFJAJHIxwqbxA/D/tJ2ePVQzXpA5cvpeSoMDIyvn88BMJxCKVN7cMi2RwNCHD02bSkaBGjIOH0FwAYCWpS/Xj3fAiAAdW2dlJdW7eSdSrjENQZW3zEinHxVNY0VJxqiZ8k+eRUuc3bPjheSj28KniUqYYMN/LD7CMSuDY/oJpgkPeL4yNkNtg0g+T6jkVeM54Q3nm2hjp6LNEWc9PixaIxR9ZMs12OiPwwADASPtmUl5dHubm54jYATCwFdS3U22+JoZqXFj9scnRJVqJYXCUnUVut2bda42bpljOVNm9750ixw0gG25rUvaZtoL+/+B5ZV9+A2Keg1ts/IH5GjBdzGb1hy3g6WdakPCHNi9Pkj9E+GkFNRiRIiZi0BQADQU2qH1T4AHZsjs07mFjggpknG0iVI6aH07XNVGGyzQxr7e6jz/Jti2YmP46bj6nR7hesMkPMUa4tL+/ipRBsZkqs17PBnJWjyhB7/1ipw6OG9vj6ywdDDPEIAAAA4Cm8eGqoJhler3ANtmZamrKU9ouiGl3ux5fFtdTW3Tes9rSvEfmJfZlpy090O4r0cmfXAsd2qeXXtShxXaM1PI1ck/JAxmjXWDovL8VmyAA1KQDA5OAb3RYADxorV4qtzkuloABL4fRFUbWYQNDaxpNDU7ZXLxiKRHj/eKnN1+sfHKTq1k4l2oCnEtyVZ93YK6MQ1AvXTqimHOalGTsWYaQMMT7WN9Y1ZvyzlA+GWJabEyMAAFrq7++nLVu20LZt28RtAJjINanj6AN1TNdnZyp1ybfeqDr5dc2CXOX2u4eLbb4eP6nPE7FaRCOoG5my5j5QVm8z3XtCFY0w14dqUj61Z1+TckN2tl0km1pkSBAttw5V8Ek3X5gqBoDJAzWpftC0BVDhKYXj1qP/ESGBNkWVWkRIEJ2ba8nx4mP2e0uHck+1WvYgpwliwoLp+kV5SqFm6uwVWbpSTUunuN9aNhWHbeytaHRcIPvUVMPw2IjkqFBKiQ4f9fd9ZXEeXbswl+5cM2fMjwUA8HSB/PTTT9OLL76Ipi3ABMOTrcUNlkVV2XGRoh50hJ+w5+xX2QA8Y40L0EphfQudtd6P3PhI+uqSPKU+Lmlqp0MVDbrk2Uo8rSufYOca+Kw1/5XJuC421+D7FcaqSWc4iGSzd+u5M+nKedn0o3XzRdYvAIBRoCbVD5q2ACpcCPKyA8YFoqOtuNI6dUSCqomq9bKHi2dmiONv3DiU/nWsRJm2lcsLWKYGebaOjqPJ42883XDSWiDzAq9c1fEuo4sODR62SGy0KVv1ErOvLplKq+2yxAAAjJAftmzZMlq0aBEybQEmGF6wZXbi2DxbO12/2K5PTlUotzfMyRJP7F+3aIrytncOl4hpW36xrUm1O520LDt5WE3K9bp6gZf90lwj43rdfp2CMzVpdFgwfWP5dFqUacn5BQAwCtSk+sFTdAAuRiNIs1JiKSUqjGrbusRiBI4Q0CK7i5uxfLyNcUG3bqbl2NuUhGhakpVAB8sbqbGjh36346TIl1UXyO4ufBi+sTeAOnsHxBQF36+qlg6Rq8tmpcSNuMDLyBEJMo93tKOGAAC+sqn3gQceIJPJJG4DwOSsSc/NTaaXv8yn7r4BOlTeIBqo9kvLxqOlq1fk2coTaOdNsZwyW5qVKKZ/y0ztog59afdpyq9tsVlClhmn3SABLyPj78ZsbdresHQana41KQMOc3woGoHxMEZWXCSVqpYZO9qjAQDgK1CT6geTtgDjLJC5GJaTD5xOwIvDtMDFsWyMchGung69duHQZMPOs7U2DVsupuXxOC1wnuti6zP53LjlxrT6GJovLXxwdByNH8v4Uv4ZAAAATA7cdJU1Kee58qDAaIIDA2i29WO4hpTLwNzFQwRy0RdP8/LXYZZp26ETYFvyq2watkmRoaKpqxWOhpiREiNuVzZ3iiECGWfmazsWHNWko0WyAQDA5IamLYAVT8qeqbM0XlOjwygpcuyA/7lpQ43LE1VDxeN4cTbthyfKlNc3zM6yef+0pJhhR+S46Ltx2TR64poVIgJASzJHl6yTDSd8vEBWLyObmhgtljoAAAAAGAmfpGpo7xa3ZybHKs1SZ2tSdUPTnbp482lLNAJPuV4yK9Pm/ctzkodFIHAu660rZtKj/3aOmCbVkjq260BZg1J3832b7UN5tpI6Ymxe2uiRbAAAMHkhHgEmrD/vyadTNc30vdVzbJp1Izla2SQmZl05ojQnNU45rqVe0DVeHx4vVY5K8TPuXPza+/75c+ntw2dFw5GPqWl5/Mwe/xx4wqNvwCyatnzsjkWHBmmaVeYps5JjxZIH/j5WWo/4AQD4qp6eHvrBD34gfv39739PISG+k+kIMFnwPoDfbDsumrA/vHA+JUaGjvl71Mu9nK1J1aeHuCa9dI7tE/+uen1/oVj8xXg5bXKU7TADNxl/fNECev9YKSVFhYma1P5jtG7a/m1fobj9eUGVWLrGuMb3xSfh52ckkJ9fgYh4QE0KAL4ONal+0LSFCanC1E4bT1qmA/6y9wz94rKlo348b7vlPC5pgZNH/6NCg8SkK2/P5WYrb/rlt40HH/V66/BZcZufbL915UyHeWR8ROxbK2eRJ3BGLz/7f6iiUSnc5QMDLbLSPI0XODx8xTKRQ7w4C0scAMD3j1BXV1dTX1+fuA0AxnO0spG+LK4Tt988VER3nD931I/nha9/P1Dk0oIqlh0fSZEhgdTe008na5pFs3i805scibX5tGW/QnCgP920fLrDj0uNDqfvrJpNnsBfKzMugipMHUrDlvlq1BUPPzx85XLq6Olz+hoDABgValL9oGkLE1JxY5tym6dtq1s6KS0m3OHHcgbXLzceFA1XxtOtrmxl5eNo3LTlh8sna0wih9ZVXFj/bscpMdHKLpuTRdOThk/ZegNPV3DTVm2O6gier+HJZD2nkwEAPLn04akapw8AADMrSURBVPHHH6eWlhYsIgPwgZqUm7f/cc4MihhhMpT3Izz+6WHqHRgUr3NNqc4+HQ03aHkh196Seurs7Rdfl6OgXNXTP0C/23lGeZ2Xfuk5QeuK5dlJommr5qtNWzae6wMAYESoSfWDTFuYkEqahgpktrWgasTpVm7YysVfXDz9zyWLKMDf+cmEuelDxSI3bcfj86I6OlPXIm6nRIXRV5dMJaNYmpUkIiDU5vtwgQwAMFH4+/vT7NmzaebMmeI2ABi7JuVm7K7iWocfx3sVHtt8mHr6LQ3bxZkJdOeauS6dbOLTUeqJ3fF4/2Ql1bZ2KYMMG2bbZtl6kzrXlnG5PisFNSkAgLehJtUPKnyYkHjyVW1bQRX1D1qKYKm2tVM0bFu6epVMrPvWL6LwYNcG0Hmjr6ynx5NrW9fWRe8eL1de/+7q2RTixMIJT+E4humqbN2EiBDDTFwAAAAAGFlpo21N+tmZ4YMERQ2t9KtNh5XdAbx09kfrFri8zEs9dXp8HDVpYX0LfVpgaSrzTgOuSY20IIv3PcSHD2V3c33KuwoAAAAmKjRtQRe9/QNi4YL6RRainshTKbWbtOVJ2oPlQ0sdBgbN9NTWY0pOKx89+9mGxSMeVxsr93WaNcqgsrmTmjp7nP69fQOD9Ludp6jHegzu4pkZhtyAq55s4CkOX8yzBQCYaAYGBmjHjh305ZdfitsAMFxXX/+wmpTrL0/gmALO0VcraWyj4sZWm495cstR6rLWyfPS4ujH42jYsrTocKWpyVELrnyfnK3KUV2DIvCL6PpFeZQeY6yls1x/cmyXOqIMAAC8DzWpfpBpC5rjYvTBjw8Ma9LyM/YcPaB3gdXQ0U0dPf3itlzIwLaeqaJzcix5sx+dKBOLwxhn3f50w2K3Ns/OTY2jAmu8wcnqJlo9NW3M39Pa1UtPfHZU+X08wfr1ZdPIiFZPTaV/HSuhjt5+umD62N8bAADojxeQPfbYY+LXtWvXUkAAJs4A1A5XNNCTnx1VdgZI4cEB9ODly3TPuFcPEahrUp62vW2lJc/0HweLlCf8OY7gvy5eSMHjPHHlZ8213VFUQ739g2KCl0+EjYUby7/+9LAYPpCnz66cl0NGxAMOW89Ukh/50eq8VG/fHQAAQE2qK0zaguY2na5wOFXLBfOrewt033Atm7Fs7YwM0QxlRyobqbGjW8QRvHX4rHgbz4vecf4cig4Ndutr2h5HGztDjJef3f/BPqVhGxzgT98/f67L0QyeEhceQs/++yp6/qurDTkJDAAwWfPD5s2bJ3JtkWkLMNxHJ8qHNWxZZ+8AvX6gSPcfmbom/bf5uRQSaHnotbOoRiz8KqhvoU2nKpRakDNs3Y3IsqlJq8aOSOAs3Z9/sE9p2EYGB9Kd589xab+DJ2XFRdLzXzufnvva6hGXDAMAgGehJtWPMTtE4LO4IXvMWiAG+g8dYeLmZGNHj8iaPVTRQEuybBcJaD3pK+UlRIki+O3DxcS94s8LqqigrlVMH7D1szNpujXawB08GcGTxPzAYKzFD/zzeXrrUfGAgcWFB9Pty6eIyQgj4xgIfgEAAONs6n300UfJZDKJ2wAwhKMBTtdaajJ+UpxzYtmJahO1WWOzuGbkqVJPLCGblRpLK6ak0LaCahGFsPNsDW08WW4NIyD6yuI8TXYGqJu2Yy3I5fvwux0nlcZ2ekw43b48V/cJZHe5czoOAAC0h5pUP5i0BU3VtHaJrDDGx7F+eOF88XLripnKx7xzuETXaVt1gcyF+IXT08VELfvn0RIxccs48+trS6dq8jX5GNuMZMvxs/p2yzSvI+WmdvrVpkNKw5azdB++cjnlxBkrMwwAAADAl1kyXS315vKcJKUmvW7hFOVj3j1arOt9KLUOEvAqgOy4SFo3I1153ytf5lO5qUOpBy+fm63J10yKDKMUa/P3TF2LmOh15GhlI/122wnlZ8TN3gevWEbJkaGa3A8AAABwH5q2oKmjVZaGKFuQkaDcXpKVKApSxvlaRytd32jr6qQtb5PliYXEyFDlvqiPyH1r5UxNJ0fVkw08xeEIT/oOWu/CkqwEeuDypZQQgeIYAAAAQEvclJQWpA/tU+DGaUyYZTJ9b0k9VZiGIgy0nvQtb+5QJlg59oBPd2XGRtjUpNzQ/c6q2ZrGEcxLj1MW7+bXNjv8mC35lcrtC6en0U/WL8IEKwAAgMGgaQuaktEIbL6qQObFCNcuzFVef/tIsS7Ttu09fSKGgXGT2J8rYZFtOzTZwM7JSaKl2dpGNNg2bR03pWWzmu/WHefPRdwAAACMW29vL/3nf/4n/eQnPxG3AcBxTTpPtQSXT0ddpVqy9e7REl1+bJXNHaJpynLjo5R62L4mvXROFk1NtCwl08qc1NEHCfoHB5WfT0RIoGgaB/rjYSEAAIwPalL94P/OoBkuAGVhGB0aRNnWyVppeU6yMl3AGbcjTaNqlWebYy2Q2dLsRGWqIiwogP7j3Bmaf+28xGgx3cu4EB60a0pzbAQvIGPTkmIwzQAAAG4ZHByk4uJiKi0tFbcBwKKlq1dZApYbH0nR1hpQumhmBkWFWnJRd5+tpaoWS32mV1yXuiZdPTVV7EFgvCz33xfnaf6156qa1OrmtcR1OOfqyilkOeQAAAAwHqhJ9YOmLWimqL6Vuq0F4DwHBSC/fo1q2vadI8W6bumdoloswdMD96ybLwrl/7lkkS6RBPw15GRDa3cfnbJb/nBYdUxvkSo6AgAAYLxLHx5++GH66U9/ikVkACrH1Se/HNRc/CT7ldYMWX6K/b0jJbrWpOplZ9GhwXT32vl0/tRU+skli3Q5dcWDCjKWrLixjWpaO23eL/c7sEWZiZp/fQAAmFxQk+oHTVvQPRpBbeWUFEqNtixHOFXTPKyxqekSMtVUA+NFYXeumUszUywLw/TATWFpe2G1zfsOVzQotxdmomkLAADu8ff3p0WLFtH8+fPFbQBwvia9ZHamiAZgO87WUK1dY9NdpTaTtranz5ZkJdH318ylzDjbt2tpVd5QTfpFUY3N+w5XDDVtF2KQAAAA3ISaVD+o8EEzR50okHna9lrV1t4Pjpfp0rTlXQ4Z1igGT1qWnUThwZaIhD0ldcrkMS+jUEdHqKeAAQAAAEAbvDNBNm05hmDWCE/W84Tr5XOs07Zmoo9Olmt6H2RkV3x4iJiu9bRVU1PFDgX2RWG1Ettl6uwZio5IiFLiwwAAAMB40LQFTXT09FFhfYu4nREbPmr8AD/zz41LdrLGNCz7dbx6+wfE0geWFRdJQQGe/+PNX5OniVlP/yDtK60Tt8/UNSsN3AUZCcgOAwAAtw0MDNC+ffvo4MGD4jYAWBaANXValtLOTo0btR7cMDtTPNE/2hLZ8ahr71YyY9XRCJ7EzWI5RFHf3k35tc3DoxEwZQsAABpATaofNG1BEydqTGJKYbQpWynA349mpVqmHriRWW4ayvxyR3lzh3If7I+hedL5U9OGHUdTH0NDgQwAAFro6+ujhx56iH7961+L2wDgXDSCFBESpDRVK5s7qb2nT4fFuN6rSdc4qElt82wR1wUAAO5DTaofNG3B4wUym5kca7PBVusC2T7P1pNmJMdQclSosgijsaNbWULGwxzzM8b++QAAADiTHzZ9+nTKy8tDpi3AOGtS3nkgFVhPjWmZZ+utSVu2LCdJLF1jXxbXUldfPx2ttPx8woMDaVpSjNfuGwAATByoSfWDpi1oWiDzFC0fRRvL9OShIjG/bmIVyH5+fsq0LQ/+/utYKVWYLLENU5OivZJrBgAAE3NT75NPPkmPPPKIuA0w2fEOAY7eYhzFle3Eoi9+sl06U6tDTerFQYKQwAA6NzdZ3Oa4hr8fKKLO3n7x+oKMeFG3AwAAuAs1qX7QtAW31bV1UW1rl1L48mKHsXABy8shZN6rFkqsSxVYjhcLZHb+tKHjaJtPVSi3saEXAAAAQB+8X4F3CsgdAvxEuitN23ytatJGS03Ky2mTIkfe8+DpiIRNqEkBAAB8ytjdNfAo3uja0tVr8zZe6hVlXdxlREdVx9DmOXEMjfFSiKmJMXS6tpnq2rqpubOHYsNDxr2h94PjZVRondjl4piPfHlTSlQYzUyJofzaFjFtKy1EdhgAAAD4gPr2LurosUxlSslRYV6vsUYjj/47G40g6+yEiBBq7OihooZW6h8cpED/8c218HLdV/cVKIvQeIjAmcaxnniPhPz+bGpSLCEDAAAwPONWXZPQnpJaenrr8WFvD/T3o19cttQmUsBI1Nt2nS2QGX8/3LRlZ+pb6Jwcy/EtV3Bh/fLufNp6pkp529oZ6WQEHJHATVspMiSQpiZGe/U+AQDAxNHb20v3338/dXd30xNPPIGIBNDMRyfK6K97C4a9nSdHH7nqHEqNDjfkT/t4teuDBHLadndxHfX2D1JZUzvljaNe47zY3247QQfLG5S3rZ3u/ZrU3xrb9d7REpvlaHHjHJYAAACwh5pUP4hHMAh+Zv4fB886fF//oJleP1BIRsRTrierLdlhvOggL8H5InemmxlivOH3sU2HbRq2X1k8ha5ZkEtGsCI3WYmAkBMNXDgDAABoYXBwkE6dOkVnzpwRtwG00NM/QO8cKXb4vs7eAXr7sOP3eVt33wCdbWgVt9NjwinehaakehnZeHYt8NLZBz86oDRsOSr22+fNsonL8qY1dvdjEU5+AQCAhlCT6geTtgZxtLKRqlo6xe3U6DCal2aZDjhU0SCOM52qaaZTNSanlnx5Uk1rF7V294nbM5NjXVpooJ4c5klbV9S2dtLjnx5RfmbcHP3u6jm0Ki+VjCIiJIiWZifRl8V14nUcQwMAAC0FBQXRz372M2ptbRW3AbTwRVGNEoswJSFKOSW0u6RWvH3n2Rq6ftEUw03bFtS30KD1/P/s1KEmrDM40kr5PHXNdNmcLKd/LzeKn9hyhEydvco08t1rF7h0+kxvaTHhNC0pmgrrLU1t1KQAAKAl1KT6QdPWID4+Wa7cvnHZNFpujQrYXlhNL3xxUtx+53Ax/exSYzVt5Ybe8RTI0aHBokHNjd/ihlax8ZezbseSX9tM/++zo9RmbRbzduAfX7TAZkrCKK5dMEVMIidFhtE51u29AAAAWggICKAVK1aQyWQStwG0OEG18WSZ8vp3Vs2iKdZTVHERIfTmwbNkNpM4av+91XMM9QPn4QZpdopr9XJ2XBQFB/qLeIQzLkza7iuto99uPyF+H0uOCqV7L15EmbERZDRfXTKVnt56jGalxNLMFOPVzAAA4LtQk+oH8QgGUGFqVxYncLHH05kST47y29jxahMVjOPI1niiGvhonMsFsotNWzmdKyMgihstz/6PZkdRNf1y40GlYZsRG04PXbnckA1blh0fSS/ecD49fOUyCgnEA2oAAAAwrmNVTVTZ3KnUdbJhyy6dnSWmSNkXhdVU19blkZq01+ma1LInQS7fcgWfFJuWZJm25RNuHHcw9hLcUnrqs2NKw5ZPkD18xXJDNmwZT/7+8cY1dO/FCxHXBQAA4CPQtDWAjafKbQpide4pF5HXLJiivD5SxphWOnv76d53v6Tvvr6ddhbVjFmwygI5OMDfprAfT0SCemmXo6/11qGz9Nz2k6LBy+alxdGDly+jlKgwMjLeGuztzcEAADAx88OOHTtGJ0+eRKYtaOKjE6qa1C4iIDw4kC6dk235s2cmev9Yqa4/dW6cfv/vO+jOf+wQzeTR8GmtQmvUFg87JERYBh5cMcPatJWnukZbgvvS7tP0t32FZE1joFV5KfTzS5dQdFgwGRnqUQAA0ANqUv2gaetlPDH6RWGNssjrAgdbZldPTaWECMsyhcMVjVRkXbKgh11na0RObE//ID33xQnx+kjq27upqbNH2brrTLTBqMvI6kYukPeW1tksvrhoZjr9z/pFIjcWAABgsm7q/elPf0oPP/ywuA3gjsrmDjpS2ShuJ0WG0jLVyS+Js165XmWfF1SNOZHqjs2nK6ilq5fae/rpiU+P2JzusscNW/mk/nj3P9jk2o6ya+GTkxW0JX9oCS7n+965Zu646mAAAICJADWpflBdeNlnZyqpd8ByrGrtjHQxxWCPi8BrFuQqr7+r47TtzrO1ym3OLOOcrj0llkVao+fZjq9ATo+NUL5nzhDjiVpH9pXWK7e/tnQq3bZyFgX6448vAABMXjw1l5WVRRkZGZigA21Pfs2xPfklRYYE0YbZmeI2N0n1mrblelBdk3Kt/Njmw3R6hAlYm5p0nHmtMh6BjZZru79sqCa9c80c+sriPPz9AwCASQ01qX7Q9fIiPl616VSFuM1l8YbZI2+q5Qnc+HDLtO2BsgYqaWzT/P7Ut3cpxbCs07mH+uznx2wKVEldOI8nz5bxA4Lp1iK5tbtvxHw0ue02KMCPrpibjeIYAAAmvZCQEHr++efpiSeeELcBxqu9p08sv2U8SXuhg5Nf0uVzssXSLjl8YLKeutISN00b2rttalI+BcaNW0f7HU6r8mzHO0jADWmZR1vc2EbdfQMOa/ez1hNvPI28emrauL4WAADARIKaVD9o2nrR3pI6JV5gaXbiqNmsPG171fwc5fUPTwxt9tXKLtVEw1cW5dEF0yyFKJ82422zRyosR+YkeUyNG6nq6QRXzVAdR8t3UIi3dvVSrbWZy7m5OH4GAAAAoJ2tZ6qUhVoXTk9zePJL4tzW9bMs07Z9A2ZlAEFLO1TxXHy6akFGvLjNjdRHNx2yGV7gPFs5GctxYtxMHS+5a4GHFmRzVq3c1K6ckFPvZQAAAADQA5q2XvTxyaFjaJfPtSx2GM26GekUEWIponny1dltus7aqSqQV01NpdtXzxZ5umxg0Ewv7jhJXX394nXOMKtrs0xAcMPWnUbqWLm2hQ1DjVw5lQsAAAAA7uMa7xNrNMJYJ7/UdaucgN1VXDNivNV48DTrl8W1yqLb8/JS6MfrFogFtKyrb0DUpIPWr1nc2Ko0UnnK1p1lW7yjQcp3UJMW1A01ct0ZWAAAAABwBpq2GuFilRcmcN4sL00YCz97L4/8Z8dF0iwn8reCAwOUpRA8aXDYuixCC2VN7VRu6lAmB3jql6MLvrd6Di3MSBBvb+7qVbLL1MfQnLnvo8lLjFYK//zallEL5OnJ0W59LQAAgIm09OHnP/85PfLII1hEBjZN2H8dLaGPTpRRZ6/lyfbRHCyvp8YOy8mvxVkJlBodPubviQsPobnWGAJ+Ep/jBLRytLJJLB+TJ9HCggJFDfxfFy+knPhI8fbSpnaxCI2d0rAmnZk89Psd1qSqBWXTk1CTAgAAMNSk+kHTViMHyxvo5d359I+DZ+k/39pJr+0vpLbuvhE/ftPpoaNk62dnOj0VsCI3Wbk90oIwd4+hrcpLUW4H+PvRLefOEL+yD46XioyxU7XuLyGTuBjPS7AUvhXNHUqGmXojsISpBgAAAIvBwUE6fPgwHT9+XNwGYDxE8PqBIvrr3gJRk753tEQ5KeWIOt5g/ayxp2ylc6cM1YtfaliT2pz8yrOc+GIhgQGiJpX+fqBINKXVTds5btakqdFhFB0apMSA9didapM1KUeD5cRHufW1AAAAJgrUpPpB01YjW/IrlducCcYTqVwo/+Ng0bAYA27m7rIWpOHBATYF6VjmpccrEQkHNIpI4ONl8v5w73hF7lARztJiwulS61E5zi57/UChUiBzL1eLyIIl2YnK7QPl9Tb3rdCaKcaL2BIixp9TBgAAMJEEBQXRj3/8Y7rzzjvFbQA++cXLwaSOnn7R3PzhW7vow+NlSqSAxE+WH6+2PBGfEh1G863Zsc44JztJOSnFcQZaRCRwc1kuv+V6d4H1tJd6UOCc3CRlge07h4uVGIOYsGDRdHUHD1EstZ5q48iF41VNNvV7Tatlx0IudiwAAAAoUJPqB01bDfDWXBlVwBt3+dl3GWHw7pESeubz4zaFLB/n4uYnu2B6uvg9zgr091ciEniL7iG75WDjkV/brByLW5CeIIpee9cuzKUo6+QBLyyraulUog1cuf8jWZZl+Z7Y/tKhpm1lc4eyvXcajqEBAAAoAgIC6MILL6TVq1eL2wBnG9uUuCtuesqmKjccX91XQH/ec2bYVK7Ey8U4GstZvJBMRiTUt3eLr+0uy0DCoHK6zNHOhG8sm06B1hNgvJhX1omzU2PdyrOVlqkGCfZZG8j2OxZQkwIAAAxBTaofNG01sKOIFzBYbvNE6lPXn0cXz8pQIgU4OkFO4vKEg7pAvmSmZfuuK1aqJmH3lFgWNWh3DM12ylaKCAmif1+cN+zt7kYjSFlxEcq235M1Juro6RuWHYZoBAAAAICRbbPmvLIblk6jJ65dIWo7P1UUAmfYyqnW7YXV4nZwoD+tmZbm8o92hToiwbo8zB07ioY+x0gn0ZKjwugyBwt8Z6doU5POS4sXPw92qLxBmU4uqMNiXAAAAPAsNG3dxBO0chECu2B6mjjCf9vKWXTPuvnK2zlXjI+gHa5oENMIbEFGvIgecNXc9DglIoEbwu5EJHBWl8wh4w29y3KGJl7trZuRQZmxETZvm5Pq3sIHiScj5NceNBMdtk4Q2xTIqo2+AAAAkx3nhxUUFFBRUREybYH6BgZp59lapaY7b0oKpcdE0F0XzKNbV85UfkK/23FKLM39orBGmVJdnZdKkSGuR2wszxmKSOBdC+5EJPDJtaNVlvovISKEZo6yVOyaBblK9qzWNSkvPVtkjWXgCIYz1lpULhBmWkSDAQAATBSoSfWDpq2buICTUQF8LEu9cXdJVhJdMitDycX67bbj9PGJcuX9G2a7PmUrIxLOyUnWJCJh48lykXcmC29eCjYSnhy++ZzpyutcpM9QbdnVNCLBOgUiC2QeWp6SgIUPAAAA6k2999xzD91///3iNkxu+0rrxGIudk5uMoUHD9V0F8/MoCVZQ43IF744aXvya9b4atLo0GAxmapFRMI7R4qVk2s8ZTtaVAN/b19bOlV5nSO8MuwGC9whc21lZIPYsWA9/RUbFiyaygAAAGCBmlQ/aNq6aVvh0JSto2Nl31g+nTJiLY3c0qZ2ZdkDRwEsyhzKzHIV53y5G5HQ3tNH/zpWIm5zXcxTC2PhhRBrpqUqBbX6AYG7eKJCThDzpG1rV6/ItGW8oZe3BgMAAMDQKZXk5GRKTEzUJMsTfNs2a9QBu8CuJuU/H7evmqNMpx6pbBQnwNjMlBjKdeOJ8RVTkt2OSKhp7aTPrFFivCvhcgfxB/YunJ5O89IskQgXzcjQ9O/A4kz+O2W5zYvRqpo7qMs6lcwnv/D3DQAAYAhqUv1o13GbhDhagJdysZBAfzpX1UiVuNF415p5dP8H+2iAz/2rJhpcWfZgb05aHEWGBFJ7Tz8dKG8Q98XVpuY/j5ZQZ++A0nDOjIt06vd9b/Ucum5RHiVGWDJotcKTvEsyE+mLIstxvfePl5L8iWHhAwAAgK2QkBB66aWXyGQyidsweTV2dNOxyiZlMIDrRHu8aPaO8+fQY5uP2LydF5C5gxfk/nHXaTEly5FbNy6b5nJT8x8Hi0Q8FrtibrbDpbj2uI7+yfrF4ntPtO5F0ApP7s5KiaVTNc1U09pl0xCflhit6dcCAADwdahJ9YNJWzePocln3XkRw0jRAjy9cIPqCFdQgJ+YDnCHOiKBt+zKDFhnmbp66ZNT5cr9cbRkbCRciKdEhSmL1rSkPo4m7x9DdhgAAACAY7xQTD7RzU/EjzQYwKe81PFc3Bxdbq0nx0sdkdAwjoiEUlMH7S627FfgSeAr5o09ZStxLcqLydwZhBitGe2wJsWOBQAAAPAQNG3d8HnByMfQ7PExr5XW42NXL8gVz+C7Sz3Zu3uE42i8lII3CR+varJZDvH+yUrqG7C8vn5WllieZgS8nI2byEzePzYNCx8AAAAAhuH6Tj0J6iiuS40nYXkPA+OhgqAA9x8OqCMSdltPodnr6uunz85UUoE1G1Z69/hQtu41C6eMul/Bk9RNW1mTcm94SgImbQEAAMAzjFEV+aBdZ2vohDWfNiU6TByhGg1PAPzggnn0nVUDmhWjc9PixUQCL5TgJQlt3X3DmsEcgfD24WIlYuCrS6ZSfHgI7SppIP+AAAoLChBNZKPgnw1Pa6iXq3HObWp0mFfvFwAAgBGXPjz++OPU1dVFDzzwAAUHj32kHCaeD0+UUW1rl7jNsQg8eTqa4MAAuv/SJeKJfa32BSzPTqaXdp0WEQdfFFXTDcumilNhan/ec4a2WQce+El6rkm7evvpZF0LBQYEilgHXphmFPxzzIqLoHKTJfuXZcdFisxdAAAAGIKaVD9o2o7DnpI6+u32E8rrG2ZlOpXdxR+j5fQAHwlbPTWVPjpRTv2DZtpxtoYum5OlvJ+LcfVm4ML6Vvq/Tw6J5WGDZBZj1lfNz9Fk6ldLy3KSbJq2HI2AhQ8AAAC2BgcHac+ePdTX1yduw+Sz8WQ5/W1fofK6OvpgrGECLRe8ci3Jk6l7S+vFMMGh8gab2AVeLruzqEZ5/Whlk3gJDx66DxzVpcXUr5b4e1I3bRHXBQAAMBxqUv0YqzLyAbxB9tnPj4llC2ztjHTaoGqUetpaVTYuHzlTRyBw5i4XzixQlT/b2dsvfuUp3cvmOJ8b5ilLs5JI3QJHgQwAADBcYGAg3XXXXfTtb39b3IbJ5dPTFWJ6VfrK4inKvgNv4JpY+uxMlc37OL6BBwyG16SW3RA80bpqaioZjToigWExLgAAwHCoSfWDpq0LDlU00NNbjynbbTnH9tvnzdJl+YGzMuMilYUIFaYOKmxoVd73aX6lcvt/LllEP7hgLqXFhCtv42NpRjzixUsxpqmWPKBABgAAcFwgb9iwgS666CI0bSeZrWeq6KXd+crr1y7MpesXOb9UVg8LMhIoISJE3D5S2UiNHd3i9qDZTJ/mD538evTfzqHbVs4UcV3Mz5qz6816eiRTEqKU+8mwhAwAAGA41KT6wViGk45WNtJTnx2lAWvHdlVeCt2+erYhCsx1M9KpoK5FKeJ5MrWiuYNO1TSLt3Gjdm5anIgYODc3hY5UNlBbWztdYKDcMHuXzs4U31OqE3nBAAAAAJMFL5j9w85TyutXzssW0QLexjXxhdPTxS4FPvjF+bXXLZoiluHWtVkauPPT48XAAb9cMD2dDpY3EPV20aLMRDIirp0vnZNFr+0vpJkpMZQWPTT8AAAAAKA3NG2dwJEDnBkmN8eunJJMd5w/1xANW7YiN0Ucj+vuGxAL0m4+ZzptUU3Z8lIHmQnLObhLspLIZDL2pT8vL5VmpcZRVEiQ4fLNAAAAjFKflJeXU0tLC8XGxiL/fRLg4YGPT5aTDMO6bG6WmFI1SvY/N23f4aYtDxIUVNE1C3NtTn5dpBoY4Pru3NxkMpksi32Nivc/nJeXQnHhIYb5OQMAABgJalL9oBvmBC7Qfrh2vpgOOCcnib6/Zq5ofhoFRxzw5C/r6R+kzwuqaXuhZTtvUIAfrZmWRr6Ij6OhYQsAAOBYT08P3XnnnXTvvfeK2zDxcf350w2LKSc+Uiwdu3n5dEM1EhMjQ0VMAmto7xb1KO+DYLFhwbQ025gTtWNJiAg1zLAGAACA0aAm1Y+xxy0NhDfs3nvxQnE70N94ve61MzJoS75l6cPr+wtUU8EpFBkS5OV7BwAAAHqIjo6m3t5e/HAnkejQYHrg8qUUGhhgqIateiEZZ9qyl3eftlnea8QaGgAAANyHmlQfaNq6wMhTn3kJUWLqorSpXWnYsotnZnr1fgEAAIA+QkND6W9/+5s4Xs63YfIICzJuCb8kK5GiQ4OotbtPqUm5t7xuhnF3KQAAAMD4oSbVj8tdyO3bt9NVV11F6enp4tn99957b1iWxS9+8QtKS0ujsLAwuvjii6mgoMDmY5qamugb3/iG6MRzBtttt91G7e3t7n83kxhfC55gUOMm7rSkaK/dJwAAAACYfEMO9tFcizMTRXQCAAAAAOjYtO3o6KCFCxfSc8895/D9jz/+OD377LP04osv0p49eygiIoI2bNhA3d2WrbGMG7YnTpygzZs30wcffCAawbfffrurdwXsrMpLFRm2jhaQAQAAAAB4gv1U7SWzMGULAAAAoHvT9rLLLqNf/vKXdO211w57H0/ZPv3003T//ffT1VdfTQsWLKC//OUvVFVVpUzknjp1ijZu3Eh//OMf6dxzz6XVq1fTb37zG3rjjTfEx8H4cXYtZ9vKZQ/n5aXixwkAADBBcZbtE088Ieoo5NqCkaTFhIuYBJYVF6EsJwMAAICJBzWpfjQNxCouLqaamhoRiSDFxMSI5uzu3bvphhtuEL9yJMKyZcuUj+GP9/f3F5O5jprB4Lybz5lOc1LjaEpCFIUHGzfvDAAAANwzODhI27Zto76+PnEbwEjuumAuHalopNmpceSPk18AAAATFmpS/Wja1eOGLUtJSbF5O78u38e/Jicn296JwECKj49XPsZeT0+PeJFaW1u1vNsTCm/lPTfX9ucLAAAAEw/XT9/+9rfFXgC+DfpDTerasrQVU2wfEwAAAMDEg5pUPz5R4T/66KP04IMPDns7b0seGBjwyn3ydWh8Gwuuh/HgmhgLroex4HoYx5o1a8T1aGtr8/ZdmRR/dlGTag//nhgLroex4HoYD66JseB6GAdqUn3+7GratE1NtWSo1tbWUlra0NZYfn3RokXKx9TV1dn8vv7+fmpqalJ+v7377ruP7rnnHptvLisri+Li4ig6OlrLb2FS4Z8fGAeuh/HgmhgLroex4HoYC66HcwICAtz6OaMm1Qf+/BoLroex4HoYD66JseB6GAuuh7Y1qcuLyEYzZcoU0XjdsmWLTYOVs2pXrlwpXudfm5ub6cCBA8rHfPbZZyIDg7NvHQkJCRHNWfULAAAAwGTGC2D5ifD6+npxG/SHmhQAAAAANamnuDxpy7lphYWFNsvHDh8+LDJps7Oz6e6776Zf/vKXNH36dNHE/fnPf07p6el0zTXXiI+fPXs2XXrppfSd73yHXnzxRbE846677hJLyvjjAAAAAMC5fNXbbrtN1FLvvfcehYaG4scGAAAAAB6FmtRATdv9+/fT2rVrlddlbMEtt9xCr7zyCv33f/83dXR00O233y4malevXk0bN260eSDxt7/9TTRqL7roIvL396frr7+enn32Wa2+JwAAAIBJM/np5+fn7bsBAAAAAJMYalJ9+Jl98DwdRy7ExMRQS0sLohLGiZe4IWvEOHA9jAfXxFhwPYwF18NYcD28V0OiJnUf/vwaC66HseB6GA+uibHgehgLrof2NaSmmbYAAAAAAAAAAAAA4B40bQEAAAAAAAAAAAAMBE1bAAAAAB/EC8h+85vf0O9//3txGwAAAADA01CT6gdNWwAAAAAfNDAwQJs2baKtW7eK2wAAAAAAnoaaVD+BOn5uAAAAANBJYGAg3XzzzdTe3i5uAwAAAAB4GmpS/aDCBwAAAPDRAvmrX/2q2NSLpi0AAAAAeANqUv0gHgEAAAAAAAAAAADAQNC0BQAAAPBBZrOZWlpaqLW1VdwGAAAAAPA01KT6QTwCAAAAgA/q6emhm266SWzsfe+99yg0NNTbdwkAAAAAJhnUpPrxyaatnCbhyRIYH/7ZBQQE4MdnELgexoNrYiy4HsaC62EM3d3domHb398vrklvb6+375LhydpRq8lk1KTuw78nxoLrYSy4HsaDa2IsuB7GgJpUv5rUJ5u2bW1t4tesrCxv3xUAAAAAr0tJSfH2XfC5WjImJkaTz8NQkwIAAACgJtW6JvUz+2AI2uDgIFVVVVFUVBT5+fl5++74ZEefH1yUl5dTdHS0t+/OpIfrYTy4JsaC62EsuB7GguvhGi57uThOT08nf3/3VzugJnUP/vwaC66HseB6GA+uibHgehgLroc+NalPTtryN5SZmentu+HzuGGLpq1x4HoYD66JseB6GAuuh7HgejhPiwlbCTWpNvDn11hwPYwF18N4cE2MBdfDWHA9tK1J3R8xAAAAAAAAAAAAAADNoGkLAAAAAAAAAAAAYCBo2k5CISEh9MADD4hfwftwPYwH18RYcD2MBdfDWHA9wJfhz6+x4HoYC66H8eCaGAuuh7HgeujDJxeRAQAAAAAAAAAAAExUmLQFAAAAAAAAAAAAMBA0bQEAAAAAAAAAAAAMBE1bAAAAAAAAAAAAAANB0xYAAAAAAAAAAADAQNC09VHbt2+nq666itLT08nPz4/ee+89m/fX1tbSN7/5TfH+8PBwuvTSS6mgoMDmYy688ELxe9Uv3/ve92w+pqysjK644grxOZKTk+nee++l/v5+j3yPvsQT1+PIkSP09a9/nbKysigsLIxmz55NzzzzjMe+R1/jqb8jUmNjI2VmZoqPaW5u1vV780WevB6vvPIKLViwgEJDQ8W/W3feeafu35+v8dT12LdvH1100UUUGxtLcXFxtGHDBvFvGWh/Pdju3btp3bp1FBERQdHR0bRmzRrq6upS3t/U1ETf+MY3xPv4mtx2223U3t6OywFuQU1qLKhJjQX1qPGgJjUW1KTGgprUeNC09VEdHR20cOFCeu6554a9z2w20zXXXENnz56lf/7zn3To0CHKycmhiy++WPw+te985ztUXV2tvDz++OPK+wYGBkTDtre3l3bt2kV//vOfRTPkF7/4hUe+R1/iietx4MAB0YB69dVX6cSJE/Szn/2M7rvvPvrtb3/rke/R13jimqhx84MbheDd6/Hkk0+Kvxs/+clPxN+TTz/9VDQKwfPXg5uB3FzMzs6mPXv20I4dOygqKkpcj76+PlwSja8HN2z5571+/Xrau3evaJjfdddd5O8/VOpxw5b/XmzevJk++OADUZjffvvtuBbgFtSkxoKa1FhQjxoPalJjQU1qLKhJDcgMPo8v47vvvqu8np+fL952/Phx5W0DAwPmpKQk8x/+8AflbRdccIH5hz/84Yif96OPPjL7+/uba2pqlLe98MIL5ujoaHNPT48u38tEoNf1cOT73/++ee3atRrd84lL72vy/PPPi4/dsmWL+Lwmk0mH72Li0Ot6NDU1mcPCwsyffvqpjvd+4tHreuzbt098nrKyMuVtR48eFW8rKCjQ5XuZzNfj3HPPNd9///0jft6TJ0+Kz8PXRfr444/Nfn5+5srKSl2+F5h8UJMaC2pSY0E9ajyoSY0FNamxoCY1BkzaTkA9PT3iVz4aLPGkTUhIiJh0Uvvb3/5GiYmJNG/ePDG12dnZaTO1M3/+fEpJSVHexhNSra2tYlIHPHs9HGlpaaH4+HhcCi9ek5MnT9JDDz1Ef/nLX2wm2sDz14OnBwcHB6myslLEh3BcxVe/+lUqLy/H5fDC9Zg5cyYlJCTQSy+9JE5s8DF9vs3XJjc3F9dEw+tRV1cnppn5NMZ5550n/r99wQUX2Fwv/n86RyIsW7ZMeRtP6/Ln4t8LoAfUpMaCmtRYUI8aD2pSY0FNaiyoSb0DHYYJaNasWeI4Kj+ANplM4sHyY489RhUVFeL4qnTjjTeKo/Zbt24VH/vXv/6VbrrpJuX9NTU1Ng1bJl/n94Fnr4c9jqz4+9//jqOtXrwm/D8uzhn+9a9/LT4fePd68PFxbtr+3//9Hz399NP01ltviQzPSy65RHxO8Oz14CiEzz//XHwM53BHRkbSxo0b6eOPP6bAwEBcDg2vB//ZZ//7v/8rIiv457xkyRKRJyyzb/n/29zUVePrwE/84f/poBfUpMaCmtRYUI8aD2pSY0FNaiyoSb0Dj5omoKCgIHrnnXdExiY/GAsICBDTNJdddpnIxpPUOXY8UZuWliYe4BUVFdHUqVO9dO8nHj2ux/Hjx+nqq6+mBx54QOQXgneuCTdReGpwtOY6eO56cMOWs1KfffZZ5e/F66+/TqmpqaKxiGxbz/794Mla/hyrVq0S14Fz0p944gmRlc55q9zIBW2uB//ZZ9/97nfp1ltvFbcXL15MW7ZsoZdffpkeffRR/KjBK1CTGgtqUmNBPWo8qEmNBTWpsaAm9Q5M2k5QS5cupcOHD4st9jyJw1M3vN0+Ly9vxN9z7rnnil8LCwvFr9zo4I3VavJ1fh949nqoj+NzY4QbJvfffz8ugxevyWeffUZvvvmmmFbjF74ujI+Lc0MdPHs9uGnI5syZo3xMUlKSuB5lZWW4HB6+Hq+99hqVlJTQn/70J1q+fDmtWLFCvK24uFgs1ALtroejP/uMn1SSf/b5/9sco6DW398vptHx/3TQE2pSY0FNaiyoR40HNamxoCY1FtSknoem7QQXExMjmhZ8PHL//v1iOnMk/IBQ/eBv5cqVdOzYMZsHeZwZGR0dPeyBIeh/PRhnCa9du5ZuueUWeuSRR/Bj9/I1efvtt+nIkSPi7fzyxz/+Ubz9iy++oDvvvBPXx8PXgyc6WX5+vvIx3JBqaGignJwcXA8PXw/Ot+W8VD8/P+Vj5OtyMhS0uR6cEZyenm7zZ5+dOXNG+bPP/0/npu+BAweU9/MTT3wtZMMdQE+oSY0FNamxoB41HtSkxoKa1FhQk3qQtzehwfi0tbWZDx06JF74Mj755JPidmlpqXj/P/7xD/PWrVvNRUVF5vfee8+ck5Njvu6665TfX1hYaH7ooYfM+/fvNxcXF5v/+c9/mvPy8sxr1qxRPqa/v988b9488/r1682HDx82b9y4UWyrvu+++3DZvHA9jh07Jn7+N910k7m6ulp5qaurw/Xw0t8Re/z5+GuZTCZcEy9dj6uvvto8d+5c886dO8XfmSuvvNI8Z84cc29vL66Jh6/HqVOnzCEhIeY77rjDfPLkSfPx48fFv18xMTHmqqoqXA8Nrwd76qmnzNHR0eY333zTXFBQYL7//vvNoaGh4lpJl156qXnx4sXmPXv2mHfs2GGePn26+etf/zquBbgFNamxoCY1FtSjxoOa1FhQkxoLalLjQdPWR8nmkP3LLbfcIt7/zDPPmDMzM81BQUHm7Oxs8eCtp6dH+f1lZWXiwXV8fLx4UD1t2jTzvffea25pabH5OiUlJebLLrvMHBYWZk5MTDT/+Mc/Nvf19Xn8+zU6T1yPBx54wOHX4Afv4J1rMtLXRNPWe9eDX//Wt75ljo2NFR977bXXit8L3rkemzZtMq9atUo0auPi4szr1q0z7969G5dD4+shPfroo+LjwsPDzStXrjR/8cUXNu9vbGwUTdrIyEjR4L311ltFcQ7gDtSkxoKa1FhQjxoPalJjQU1qLKhJjceP/+PJyV4AAAAAAAAAAAAAGBkybQEAAAAAAAAAAAAMBE1bAAAAAAAAAAAAAANB0xYAAAAAAAAAAADAQNC0BQAAAAAAAAAAADAQNG0BAAAAAAAAAAAADARNWwAAAAAAAAAAAAADQdMWAAAAAAAAAAAAwEDQtAUAAAAAAAAAAAAwEDRtAQAAAAAAAAAAAAwETVsAAAAAAAAAAAAAA0HTFgAAAAAAAAAAAMBA0LQFAAAAAAAAAAAAIOP4/xTn2Jc7aX2LAAAAAElFTkSuQmCC" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 8 + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/quickstart_forecast.png b/examples/quickstart_forecast.png index 5dda77c34b9982b765840cd8f7ed4927bfd48421..0e53b44e82919b0ceb593e776b022670d4c0ff9a 100644 GIT binary patch literal 279886 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ł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

U8X5~RPLDkFC;S|G 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 literal 84062 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%0A3#J6dF;D!ntzNq-`jZX`k-s-#C5j`wm+^^q} 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 NhL!zy`P)5D{Tt$oAtC?( diff --git a/examples/utils.py b/examples/utils.py index 54e3074..fd08f1e 100644 --- a/examples/utils.py +++ b/examples/utils.py @@ -1,5 +1,6 @@ import numpy as np import pandas as pd +import re def calculate_metrics( @@ -148,19 +149,14 @@ def load_air_passengers() -> pd.DataFrame: def plot_example_forecast( actuals: pd.DataFrame, forecasts: pd.DataFrame, + levels: list = None, ) -> None: - """Plot actuals vs. Hyper-Tree-AR forecast for the air passengers example. + """Plot actuals vs. Hyper-Tree-AR forecast, shading any conformal intervals. - Parameters - ---------- - actuals : pd.DataFrame - Full series with ``date`` and ``value`` columns. - forecasts : pd.DataFrame - Forecasts with ``date`` and ``fcst`` columns. - - Returns - ------- - None + If ``forecasts`` contains conformal interval columns named + ``-lo-`` / ``-hi-`` (produced by + ``forecast(..., level=[...])``), each band is shaded. Pass ``levels`` to + restrict which are drawn; by default all detected levels are shown. """ try: import matplotlib.pyplot as plt @@ -171,15 +167,34 @@ def plot_example_forecast( ) from e plt.figure(figsize=(12, 5)) - datasets = [ - (actuals, "date", "value", "Actual", "#2E86AB", "-"), - (forecasts, "date", "fcst", "Hyper-Tree-AR Forecast", "green", "--"), - ] - for data, x_col, y_col, label, color, style in datasets: - plt.plot(data[x_col], data[y_col], label=label, color=color, - linestyle=style, linewidth=2, alpha=0.8) - plt.axvline(x=forecasts["date"].min(), color="black", linestyle=":", alpha=0.7, - label="Train/Test Split") + plt.plot(actuals["date"], actuals["value"], label="Actual", + color="#2E86AB", linestyle="-", linewidth=2, alpha=0.8) + plt.plot(forecasts["date"], forecasts["fcst"], label="Hyper-Tree-AR Forecast", + color="green", linestyle="--", linewidth=2, alpha=0.8) + + # Detect and shade conformal interval bands, if present. + model = forecasts["model"].iloc[0] if "model" in forecasts.columns else None + if model is not None: + detected = sorted( + int(m.group(1)) + for c in forecasts.columns + for m in [re.fullmatch(rf"{re.escape(model)}-lo-(\d+)", c)] + if m + ) + if levels is not None: + detected = [lv for lv in detected if lv in set(levels)] + # Shade widest band first so narrower bands sit on top. + alphas = [0.15, 0.28, 0.40] + shade = {lv: a for lv, a in zip(sorted(detected, reverse=True), alphas)} + for lv in sorted(detected, reverse=True): + plt.fill_between( + forecasts["date"], + forecasts[f"{model}-lo-{lv}"], + forecasts[f"{model}-hi-{lv}"], + color="green", alpha=shade.get(lv, 0.2), label=f"{lv}% interval", + ) + + plt.axvline(x=forecasts["date"].min(), color="black", linestyle=":", alpha=0.7, label="Train/Test Split") plt.title("Forecasting Results - Air Passengers Dataset", fontsize=16) plt.xlabel("Date", fontsize=12) plt.ylabel("Number of Passengers", fontsize=12) @@ -187,3 +202,79 @@ def plot_example_forecast( plt.grid(True, alpha=0.3) plt.tight_layout() plt.show() + + +def coverage( + df: pd.DataFrame, + level: int, + model: str, + value_col: str = "value", +) -> float: + r"""Empirical coverage of a conformal prediction interval. + + Computes the fraction of realized values that fall within the + ``[-lo-, -hi-]`` band, reported in percent. + For a well-calibrated ``level``% interval this should be close to ``level``. + + Parameters + ---------- + df : pd.DataFrame + Forecast output containing ``value_col`` plus the interval columns + ``f"{model}-lo-{level}"`` and ``f"{model}-hi-{level}"``. + level : int + Nominal confidence level (e.g. ``90``). + model : str + Model-name prefix used for the interval columns (the ``model`` column + value, e.g. ``"Hyper-Tree-AR(12)"``). + value_col : str, default "value" + Column holding the realized values. + + Returns + ------- + float + Empirical coverage in percent, in ``[0, 100]``. + """ + lo_col, hi_col = f"{model}-lo-{level}", f"{model}-hi-{level}" + missing = {value_col, lo_col, hi_col} - set(df.columns) + if missing: + raise KeyError(f"Missing columns: {sorted(missing)}.") + + true = df[value_col].to_numpy(dtype=np.float64) + lo = df[lo_col].to_numpy(dtype=np.float64) + hi = df[hi_col].to_numpy(dtype=np.float64) + inside = (true >= lo) & (true <= hi) + return float(np.mean(inside) * 100) + + +def mean_interval_width( + df: pd.DataFrame, + level: int, + model: str, +) -> float: + """Mean width of a conformal prediction interval. + + Parameters + ---------- + df : pd.DataFrame + Forecast output containing ``f"{model}-lo-{level}"`` and + ``f"{model}-hi-{level}"``. + level : int + Nominal confidence level (e.g. ``90``). + model : str + Model-name prefix used for the interval columns. + + Returns + ------- + float + Mean of ``hi - lo`` across all rows. + """ + lo_col, hi_col = f"{model}-lo-{level}", f"{model}-hi-{level}" + missing = {lo_col, hi_col} - set(df.columns) + if missing: + raise KeyError(f"Missing columns: {sorted(missing)}.") + + lo = df[lo_col].to_numpy(dtype=np.float64) + hi = df[hi_col].to_numpy(dtype=np.float64) + + return float(np.mean(hi - lo)) + diff --git a/hypertrees/__init__.py b/hypertrees/__init__.py index 159ebe2..e6d7966 100644 --- a/hypertrees/__init__.py +++ b/hypertrees/__init__.py @@ -1 +1,5 @@ -"""Forecasting with Hyper-Trees""" \ No newline at end of file +"""Forecasting with Hyper-Trees""" + +from .conformal import ForecastIntervals + +__all__ = ["ForecastIntervals"] diff --git a/hypertrees/conformal.py b/hypertrees/conformal.py new file mode 100644 index 0000000..96362bb --- /dev/null +++ b/hypertrees/conformal.py @@ -0,0 +1,323 @@ +"""Conformal prediction intervals for Hyper-Tree models. + +Acknowledgement +--------------- +The conformal-interval approach in this module is adapted from Nixtla's +open-source forecasting libraries: + +- statsforecast: https://github.com/Nixtla/statsforecast (Apache-2.0) +- mlforecast: https://github.com/Nixtla/mlforecast (Apache-2.0) +- neuralforecast: https://github.com/Nixtla/neuralforecast (Apache-2.0) + +The calibration procedure, the two interval construction methods +(``conformal_distribution`` and ``conformal_error``), the per-horizon-step +quantile logic, and the output column naming convention (``-lo-`` +/ ``-hi-``) follow Nixtla's design. See the individual +repositories for the original implementations. + +Description +----------- +1. **Calibration** runs a rolling-window cross-validation over the training data + and collects the *absolute residuals* ``|y_hat - y|`` (the conformity score) + for each window, series, and forecast-horizon step. +2. **At prediction time**, for each confidence ``level`` the intervals are built + from per-horizon quantiles of the conformity scores, using one of two methods: + + - ``conformal_distribution`` (Nixtla's default): build synthetic forecast paths + ``[y_hat - scores, y_hat + scores]`` and take the symmetric + ``[alpha/200, 1 - alpha/200]`` quantiles, where ``alpha = 100 - level``. + - ``conformal_error``: take the ``level/100`` quantile of the absolute + residuals and form ``y_hat +/- q``. + +Quantiles are computed independently per horizon step and per series, matching +Nixtla's implementation. + +The module is intentionally model-agnostic: it only relies on a ``model_factory`` +that returns a fresh model exposing the standard Hyper-Tree ``train`` / ``forecast`` +interface, so it can be reused for the other Hyper-Tree models in the future. +""" + +from dataclasses import dataclass +from typing import Callable, Dict, List, Sequence, Tuple + +import numpy as np +import pandas as pd + +_VALID_METHODS = ("conformal_distribution", "conformal_error") + + +@dataclass +class ForecastIntervals: + """Configuration for conformal prediction intervals. + + Parameters + ---------- + n_windows : int + Number of rolling cross-validation windows used to collect conformity + scores. Must be at least 2. More windows give a more stable calibration + at the cost of additional refits. + method : str + Interval construction method, either ``"conformal_distribution"`` (default) + or ``"conformal_error"``. + step_size : int + Step (in time steps) between consecutive cross-validation windows. The + default of 1 produces maximally overlapping windows and therefore the most + conformity scores for a given series length. + refit : bool + If ``True`` (default), a fresh model is trained for every CV window + (rolling-origin evaluation). If ``False``, a single model is trained on + the oldest window's training split and reused to forecast all windows, + matching Nixtla's ``mlforecast`` behaviour. ``refit=False`` is + substantially faster but may under-estimate errors for later windows + whose training data the model never saw. + + Notes + ----- + Calibration is always performed at the model's own forecast horizon + (``fcst_h``), yielding per-horizon-step intervals. + """ + + n_windows: int = 5 + method: str = "conformal_distribution" + step_size: int = 1 + refit: bool = True + + def __post_init__(self): + if not isinstance(self.n_windows, int) or self.n_windows < 2: + raise ValueError("n_windows must be an integer >= 2.") + if self.method not in _VALID_METHODS: + raise ValueError(f"method must be one of {_VALID_METHODS}.") + if not isinstance(self.step_size, int) or self.step_size < 1: + raise ValueError("step_size must be a positive integer.") + if not isinstance(self.refit, bool): + raise ValueError("refit must be a boolean.") + + +def validate_calibration_length( + train_data: pd.DataFrame, + fcst_h: int, + forecast_intervals: ForecastIntervals, + min_train: int, +) -> None: + """Validate that every series is long enough for the rolling-window calibration. + + Each series needs enough observations so that, in the oldest window, the + training portion still has at least ``min_train`` rows after carving out the + cross-validation test blocks. + + Parameters + ---------- + train_data : pd.DataFrame + Training data with a ``series_id`` column. + fcst_h : int + Forecast horizon (length of each cross-validation test block). + forecast_intervals : ForecastIntervals + Calibration configuration. + min_train : int + Minimum number of training rows required by the model (e.g. ``p + 1`` for + an AR(p) model, so at least one training sample remains after lagging). + + Raises + ------ + ValueError + If any series is too short. + """ + pi = forecast_intervals + needed = fcst_h + (pi.n_windows - 1) * pi.step_size + min_train + lengths = train_data.groupby("series_id", sort=False).size() + bad = lengths[lengths < needed] + if len(bad) > 0: + raise ValueError( + f"Conformal calibration with n_windows={pi.n_windows}, " + f"step_size={pi.step_size}, fcst_h={fcst_h} requires at least " + f"{needed} observations per series, but these series are too short: " + f"{bad.to_dict()}. Reduce n_windows/step_size or provide longer series." + ) + + +def rolling_origin_residuals( + model_factory: Callable[[], object], + train_data: pd.DataFrame, + fcst_h: int, + forecast_intervals: ForecastIntervals, + train_kwargs: dict, +) -> Tuple[np.ndarray, List]: + """Collect absolute-residual conformity scores via rolling-window CV. + + For each window ``w = 0, ..., n_windows - 1`` the test block is the ``fcst_h`` + observations ending at ``L - w * step_size`` (per series), and the model is + trained on all earlier observations. + + When ``forecast_intervals.refit`` is ``True`` (default) a fresh model is + trained for every window. When ``False``, a single model is trained on the + oldest window's training split and reused to forecast all windows (matching + Nixtla's ``mlforecast`` with ``refit=False``). + + Parameters + ---------- + model_factory : Callable[[], object] + Zero-argument callable returning a fresh, untrained model exposing + ``train(train_data=..., **train_kwargs)`` and + ``forecast(test_data=..., type="forecast")``. + train_data : pd.DataFrame + Full training data (``series_id``, ``date``, ``value`` + features). + fcst_h : int + Forecast horizon / length of each CV test block. + forecast_intervals : ForecastIntervals + Calibration configuration. + train_kwargs : dict + Keyword arguments forwarded to each fresh model's ``train`` call (e.g. + ``lgb_params``, ``num_iterations``, ``seed``). Must not contain + ``train_data`` or ``forecast_intervals``. + + Returns + ------- + scores : np.ndarray + Absolute residuals with shape ``(n_windows, n_series, fcst_h)``. + series_order : list + Series ids in first-appearance order (axis 1 of ``scores``). + """ + pi = forecast_intervals + series_order = list(dict.fromkeys(train_data["series_id"].tolist())) + grouped = {sid: g for sid, g in train_data.groupby("series_id", sort=False)} + + scores = np.empty((pi.n_windows, len(series_order), fcst_h), dtype=float) + + # When refit=False, train once on the oldest window (w = n_windows - 1, + # which has the least training data) so the model never sees any of the + # test observations across all windows. + shared_model = None + if not pi.refit: + oldest_offset = (pi.n_windows - 1) * pi.step_size + train_parts = [] + for sid in series_order: + g = grouped[sid] + start = len(g) - oldest_offset - fcst_h + train_parts.append(g.iloc[:start]) + oldest_train_df = pd.concat(train_parts, ignore_index=True) + shared_model = model_factory() + shared_model.train(train_data=oldest_train_df, **train_kwargs) + + for w in range(pi.n_windows): + offset = w * pi.step_size + train_parts, test_parts = [], [] + for sid in series_order: + g = grouped[sid] + end = len(g) - offset + start = end - fcst_h + train_parts.append(g.iloc[:start]) + test_parts.append(g.iloc[start:end]) + + test_df = pd.concat(test_parts, ignore_index=True) + + if pi.refit: + train_df = pd.concat(train_parts, ignore_index=True) + model = model_factory() + model.train(train_data=train_df, **train_kwargs) + else: + model = shared_model + + fcst = model.forecast(test_data=test_df, type="forecast") + + resid = np.abs(fcst["fcst"].to_numpy() - test_df["value"].to_numpy()) + scores[w] = resid.reshape(len(series_order), fcst_h) + + return scores, series_order + + +def _align_scores( + scores: np.ndarray, cal_order: Sequence, target_order: Sequence +) -> np.ndarray: + """Reorder the series axis of ``scores`` to match ``target_order``.""" + cal_order = list(cal_order) + target_order = list(target_order) + if cal_order == target_order: + return scores + missing = set(target_order) - set(cal_order) + if missing: + raise ValueError( + f"Series {missing} were not seen during conformal calibration." + ) + idx = [cal_order.index(s) for s in target_order] + return scores[:, idx, :] + + +def _distribution_bands( + point: np.ndarray, scores: np.ndarray, levels: List[int] +) -> Dict[int, Tuple[np.ndarray, np.ndarray]]: + """``conformal_distribution`` intervals (synthetic-path symmetric quantiles).""" + # Synthetic forecast paths: (2 * n_windows, n_series, h) + paths = np.concatenate([point[None] - scores, point[None] + scores], axis=0) + bands = {} + for lv in levels: + alpha = 100 - lv + lo = np.quantile(paths, (alpha / 2) / 100.0, axis=0) + hi = np.quantile(paths, 1.0 - (alpha / 2) / 100.0, axis=0) + bands[lv] = (lo, hi) + return bands + + +def _error_bands( + point: np.ndarray, scores: np.ndarray, levels: List[int] +) -> Dict[int, Tuple[np.ndarray, np.ndarray]]: + """``conformal_error`` intervals (symmetric ``y_hat +/- quantile``).""" + bands = {} + for lv in levels: + q = np.quantile(scores, lv / 100.0, axis=0) + bands[lv] = (point - q, point + q) + return bands + + +def interval_columns( + point: np.ndarray, + scores: np.ndarray, + levels: List[int], + method: str, + model_name: str, + cal_order: Sequence, + target_order: Sequence, +) -> "Dict[str, np.ndarray]": + """Build the ``-lo-`` / ``-hi-`` columns. + + Parameters + ---------- + point : np.ndarray + Point forecasts shaped ``(n_series, fcst_h)`` in ``target_order``. + scores : np.ndarray + Conformity scores shaped ``(n_windows, n_series, fcst_h)`` in ``cal_order``. + levels : list of int + Confidence levels in ``(0, 100)``. + method : str + ``"conformal_distribution"`` or ``"conformal_error"``. + model_name : str + Prefix for the interval columns (the model's ``model`` string). + cal_order, target_order : sequence + Series order of ``scores`` and of the desired output, respectively. + + Returns + ------- + dict of str -> np.ndarray + Ordered mapping of column name to a flat ``(n_series * fcst_h,)`` array, + flattened series-major to match the forecast DataFrame's row order. + """ + levels = sorted(int(lv) for lv in levels) + for lv in levels: + if not 0 < lv < 100: + raise ValueError(f"level values must be in (0, 100); got {lv}.") + + scores = _align_scores(scores, cal_order, target_order) + + if method == "conformal_distribution": + bands = _distribution_bands(point, scores, levels) + elif method == "conformal_error": + bands = _error_bands(point, scores, levels) + else: + raise ValueError(f"method must be one of {_VALID_METHODS}.") + + columns: Dict[str, np.ndarray] = {} + # Mirror Nixtla column ordering: lower bounds (widest first), then upper bounds. + for lv in sorted(levels, reverse=True): + columns[f"{model_name}-lo-{lv}"] = bands[lv][0].reshape(-1) + for lv in sorted(levels): + columns[f"{model_name}-hi-{lv}"] = bands[lv][1].reshape(-1) + return columns diff --git a/hypertrees/models/HyperTreeAR.py b/hypertrees/models/HyperTreeAR.py index a374a30..348b57f 100644 --- a/hypertrees/models/HyperTreeAR.py +++ b/hypertrees/models/HyperTreeAR.py @@ -6,12 +6,18 @@ import torch.nn as nn from torch.autograd import grad as autograd import lightgbm as lgb -from typing import Tuple, Callable, Optional +from typing import Tuple, Callable, Optional, List import time from ..utils import CustomLogger lgb.register_logger(CustomLogger()) from ..utils import TimeSeriesPreprocessor, prepare_datasets, TrainingResult, validate_series_order, GaussNewtonHessian +from ..conformal import ( + ForecastIntervals, + validate_calibration_length, + rolling_origin_residuals, + interval_columns, +) class HyperTreeAR: """ @@ -155,6 +161,13 @@ def __init__( self._fit = None self._target = None + # Conformal prediction interval state (populated when train() is called + # with forecast_intervals). + self._is_calibrated = False + self._cs_scores = None # conformity scores (n_windows, n_series, fcst_h) + self._cs_series_order = None # series order along axis 1 of _cs_scores + self._pi_config = None # ForecastIntervals configuration + # Bind Hessian computation strategy if hessian_method == "exact": self.calculate_gradients_and_hessians = self._calculate_gradients_and_hessians_exact @@ -320,6 +333,7 @@ def train( seed: int = 123, verbose: int = -1, deterministic: bool = True, + forecast_intervals: Optional[ForecastIntervals] = None, ) -> TrainingResult: """ Train the Hyper-Tree-AR model on time series data. @@ -356,6 +370,12 @@ def train( If True, sets LightGBM's ``deterministic`` and ``force_row_wise`` parameters to ensure reproducible results. May slow down training. See https://lightgbm.readthedocs.io/en/latest/Parameters.html#deterministic + forecast_intervals : ForecastIntervals, optional + If provided, calibrate conformal prediction intervals via rolling-window + cross-validation after the main model is trained. The collected conformity + scores are then used by ``forecast(..., level=[...])`` to produce + ``-lo-`` / ``-hi-`` columns. See + :class:`hypertrees.conformal.ForecastIntervals`. Returns ------- @@ -383,6 +403,8 @@ def train( raise TypeError("validation must be a boolean.") if not isinstance(deterministic, bool): raise TypeError("deterministic must be a boolean.") + if forecast_intervals is not None and not isinstance(forecast_intervals, ForecastIntervals): + raise TypeError("forecast_intervals must be a ForecastIntervals instance.") if early_stopping_round is not None and not validation: raise ValueError("early_stopping_round can only be used when validation is True.") if validation and early_stopping_round is None: @@ -401,6 +423,13 @@ def train( # monotonic dates so the training reshape and fcst_lags extraction align. validate_series_order(train_data, name="train_data") + # Fail fast if any series is too short for the requested conformal calibration. + # An AR(p) model needs at least p + 1 rows to retain one training sample. + if forecast_intervals is not None: + validate_calibration_length( + train_data, self.fcst_h, forecast_intervals, min_train=self.p + 1 + ) + # General model parameters self.lgb_params = { "num_class": self.p, @@ -421,6 +450,10 @@ def train( self.dataset_references = {} self.is_trained = False self.features = None + self._is_calibrated = False + self._cs_scores = None + self._cs_series_order = None + self._pi_config = None try: # Initialize TimeSeriesPreprocessor for creating lagged dataframe @@ -481,6 +514,38 @@ def train( # Set trained flag to True self.is_trained = True + # Calibrate conformal prediction intervals via rolling-window CV. + # Fresh model instances are trained per window (no forecast_intervals + # passed, so there is no recursion) using the same hyper-parameters. + if forecast_intervals is not None: + def _model_factory(): + return HyperTreeAR( + p=self.p, + freq=self.freq, + fcst_h=self.fcst_h, + loss_fn=self.loss_fn, + hessian_method=self.hessian_method, + n_hessian_probes=self.n_hessian_probes, + ) + + cal_train_kwargs = dict( + lgb_params=lgb_params, + num_iterations=num_iterations, + validation=False, + seed=seed, + verbose=verbose, + deterministic=deterministic, + ) + self._cs_scores, self._cs_series_order = rolling_origin_residuals( + model_factory=_model_factory, + train_data=train_data, + fcst_h=self.fcst_h, + forecast_intervals=forecast_intervals, + train_kwargs=cal_train_kwargs, + ) + self._pi_config = forecast_intervals + self._is_calibrated = True + # Return results result = TrainingResult( train_metrics=evals_result["train"] if validation else {"loss": []}, @@ -499,7 +564,8 @@ def train( def forecast( self, test_data: pd.DataFrame, - type: str = "forecast" + type: str = "forecast", + level: Optional[List[int]] = None ) -> pd.DataFrame: """ Generate forecasts using the trained model. @@ -523,6 +589,11 @@ def forecast( Type of forecast to generate. Options: - "forecast": Generate forecasted values - "parameters": Return the AR(p) coefficients used for forecasting + level : list of int, optional + Confidence levels (in ``(0, 100)``, e.g. ``[80, 90]``) for conformal + prediction intervals. Only valid with ``type="forecast"`` and requires + the model to have been trained with ``forecast_intervals=...``. Adds + ``-lo-`` / ``-hi-`` columns to the output. Returns ------- @@ -533,6 +604,8 @@ def forecast( - fcst: Forecasted value (if type="forecast") - model: Model name identifier - AR(i): AR coefficient values (if type="parameters") + - -lo- / -hi-: prediction interval bounds + (if type="forecast" and level is provided) """ # Check if model is trained if not self.is_trained or self.model is None: @@ -581,6 +654,22 @@ def forecast( if type not in ["forecast", "parameters"]: raise ValueError("Parameter 'type' must be either 'forecast' or 'parameters'") + # Validate conformal interval request + if level is not None: + if type != "forecast": + raise ValueError("level is only supported with type='forecast'.") + if not self._is_calibrated: + raise RuntimeError( + "Prediction intervals were requested via level, but the model " + "was not calibrated. Pass forecast_intervals=ForecastIntervals(...) " + "to train() before forecasting with level." + ) + if not isinstance(level, (list, tuple)) or len(level) == 0: + raise ValueError("level must be a non-empty list of integers.") + for lv in level: + if not isinstance(lv, (int, np.integer)) or not 0 < lv < 100: + raise ValueError(f"level values must be integers in (0, 100); got {lv}.") + try: if type == "forecast": @@ -603,13 +692,29 @@ def forecast( lags = np.concatenate([next_val, lags[:, :-1]], axis=1) # Create output dataframe based on requested type + model_name = f"Hyper-Tree-AR({self.p})" out_df = pd.DataFrame({ "series_id": test_data["series_id"].to_numpy().flatten(), "date": test_data["date"].to_numpy().flatten(), "fcst": np.hstack(forecasts).flatten(), - "model": f"Hyper-Tree-AR({self.p})", + "model": model_name, }) + # Append conformal prediction intervals if requested. + if level is not None: + point = np.hstack(forecasts) # (n_series_test, fcst_h) + columns = interval_columns( + point=point, + scores=self._cs_scores, + levels=level, + method=self._pi_config.method, + model_name=model_name, + cal_order=self._cs_series_order, + target_order=list(test_series_ids), + ) + for col_name, values in columns.items(): + out_df[col_name] = values + elif type == "parameters": params_fcst = np.asarray(self.model.predict(test_data[self.features])) # LightGBM may return 1D (column-major) or 2D depending on version/objective. diff --git a/hypertrees/models/HyperTreeETS.py b/hypertrees/models/HyperTreeETS.py index df5d265..2f7e2aa 100644 --- a/hypertrees/models/HyperTreeETS.py +++ b/hypertrees/models/HyperTreeETS.py @@ -11,6 +11,12 @@ lgb.register_logger(CustomLogger()) from ..utils import TimeSeriesPreprocessor, prepare_datasets, TrainingResult, validate_series_order, GaussNewtonHessian +from ..conformal import ( + ForecastIntervals, + validate_calibration_length, + rolling_origin_residuals, + interval_columns, +) class HyperTreeETS: """ @@ -166,6 +172,12 @@ def __init__( # Shared Gauss-Newton Hessian estimator self._gn_hessian = GaussNewtonHessian(loss_fn, n_hessian_probes, self.dtype) + # Conformal prediction interval state + self._is_calibrated = False + self._cs_scores = None + self._cs_series_order = None + self._pi_config = None + # Activation function for parameter bounds self.sigmoid_fn = nn.Sigmoid() @@ -555,6 +567,7 @@ def train( seed: int = 123, verbose: int = -1, deterministic: bool = True, + forecast_intervals: Optional[ForecastIntervals] = None, ) -> TrainingResult: """ Train the Hyper-Tree-ETS model on time series data. @@ -593,6 +606,12 @@ def train( If True, sets LightGBM's ``deterministic`` and ``force_row_wise`` parameters to ensure reproducible results. May slow down training. See https://lightgbm.readthedocs.io/en/latest/Parameters.html#deterministic + forecast_intervals : ForecastIntervals, optional + If provided, calibrate conformal prediction intervals via rolling-window + cross-validation after the main model is trained. The collected conformity + scores are then used by ``forecast(..., level=[...])`` to produce + ``-lo-`` / ``-hi-`` columns. See + :class:`hypertrees.conformal.ForecastIntervals`. Returns ------- @@ -621,6 +640,8 @@ def train( raise TypeError("validation must be a boolean.") if not isinstance(deterministic, bool): raise TypeError("deterministic must be a boolean.") + if forecast_intervals is not None and not isinstance(forecast_intervals, ForecastIntervals): + raise TypeError("forecast_intervals must be a ForecastIntervals instance.") if early_stopping_round is not None and not validation: raise ValueError("early_stopping_round can only be used when validation is True.") if validation and early_stopping_round is None: @@ -639,6 +660,12 @@ def train( # monotonic dates so the ETS reshape to (n_series, T, n_params) aligns. validate_series_order(train_data, name="train_data") + if forecast_intervals is not None: + validate_calibration_length( + train_data, self.fcst_h, forecast_intervals, + min_train=self.season_length + 1, + ) + # Check if all series in train_data have the same length unique_lengths = train_data.groupby('series_id')['date'].nunique() if len(unique_lengths.unique()) > 1: @@ -663,6 +690,10 @@ def train( self.is_trained = False self.fcst_states = None self.features = None + self._is_calibrated = False + self._cs_scores = None + self._cs_series_order = None + self._pi_config = None # Set random seeds for reproducibility torch.manual_seed(seed) @@ -729,6 +760,36 @@ def train( # Set trained flag to True self.is_trained = True + if forecast_intervals is not None: + def _model_factory(): + return HyperTreeETS( + ets_type=self.ets_type, + season_length=self.season_length, + seasonality_feature=self.seasonality_feature, + freq=self.freq, + fcst_h=self.fcst_h, + loss_fn=self.loss_fn, + n_hessian_probes=self.n_hessian_probes, + ) + + cal_train_kwargs = dict( + lgb_params=lgb_params, + num_iterations=num_iterations, + validation=False, + seed=seed, + verbose=verbose, + deterministic=deterministic, + ) + self._cs_scores, self._cs_series_order = rolling_origin_residuals( + model_factory=_model_factory, + train_data=train_data, + fcst_h=self.fcst_h, + forecast_intervals=forecast_intervals, + train_kwargs=cal_train_kwargs, + ) + self._pi_config = forecast_intervals + self._is_calibrated = True + # Return results result = TrainingResult( train_metrics=evals_result["train"] if validation else {"loss": []}, @@ -799,7 +860,8 @@ def _store_final_states(self, train_data: pd.DataFrame): def forecast( self, test_data: pd.DataFrame, - type: str = "forecast" + type: str = "forecast", + level: Optional[List[int]] = None, ) -> pd.DataFrame: """ Generate forecasts using the trained model. @@ -821,6 +883,11 @@ def forecast( Type of forecast to generate. Options: - "forecast": Generate forecasted values - "parameters": Return the ETS parameters used for forecasting + level : list of int, optional + Confidence levels (in ``(0, 100)``, e.g. ``[80, 90]``) for conformal + prediction intervals. Only valid with ``type="forecast"`` and requires + the model to have been trained with ``forecast_intervals=...``. Adds + ``-lo-`` / ``-hi-`` columns to the output. Returns ------- @@ -828,9 +895,11 @@ def forecast( Forecasted data with columns: - series_id: Identifier for each time series - date: Forecast date/time - - model: Model name identifier - fcst: Forecasted value (if type="forecast") + - model: Model name identifier - alpha, beta, gamma, phi: ETS parameter values (if type="parameters") + - -lo- / -hi-: prediction interval bounds + (if type="forecast" and level is provided) """ # Check if model is trained and states are stored if not self.is_trained or self.model is None: @@ -876,6 +945,21 @@ def forecast( if type not in ["forecast", "parameters"]: raise ValueError("Parameter 'type' must be either 'forecast' or 'parameters'") + if level is not None: + if type != "forecast": + raise ValueError("level is only supported with type='forecast'.") + if not self._is_calibrated: + raise RuntimeError( + "Prediction intervals were requested via level, but the model " + "was not calibrated. Pass forecast_intervals=ForecastIntervals(...) " + "to train() before forecasting with level." + ) + if not isinstance(level, (list, tuple)) or len(level) == 0: + raise ValueError("level must be a non-empty list of integers.") + for lv in level: + if not isinstance(lv, (int, np.integer)) or not 0 < lv < 100: + raise ValueError(f"level values must be integers in (0, 100); got {lv}.") + try: # If mask was a training feature but is absent from test_data, add it (all test obs are valid) if 'mask' in self.features and 'mask' not in test_data.columns: @@ -982,13 +1066,29 @@ def forecast( trend_h = trend_new # Create output dataframe + model_name = f"Hyper-Tree-ETS({self.ets_type})" out_df = pd.DataFrame({ "series_id": test_data["series_id"].to_numpy().flatten(), "date": test_data["date"].to_numpy().flatten(), "fcst": torch.cat(fcsts, dim=1).flatten().numpy(), - "model": f"Hyper-Tree-ETS({self.ets_type})", + "model": model_name, }) + if level is not None: + point = torch.cat(fcsts, dim=1).numpy() # (n_series, fcst_h) + test_series_ids = test_data["series_id"].unique() + columns = interval_columns( + point=point, + scores=self._cs_scores, + levels=level, + method=self._pi_config.method, + model_name=model_name, + cal_order=self._cs_series_order, + target_order=list(test_series_ids), + ) + for col_name, values in columns.items(): + out_df[col_name] = values + elif type == "parameters": fcst_params = torch.clamp( self.sigmoid_fn(torch.tensor(self.model.predict(test_data[self.features]), dtype=self.dtype) diff --git a/hypertrees/models/HyperTreeNetAR.py b/hypertrees/models/HyperTreeNetAR.py index 0c9d7ae..40513b6 100644 --- a/hypertrees/models/HyperTreeNetAR.py +++ b/hypertrees/models/HyperTreeNetAR.py @@ -4,9 +4,15 @@ import torch.nn as nn from torch.autograd import grad as autograd import lightgbm as lgb -from typing import Tuple, Callable, Optional +from typing import Tuple, Callable, Optional, List import time from ..utils import TimeSeriesPreprocessor, prepare_datasets, TrainingResult, CustomLogger, validate_series_order, GaussNewtonHessian +from ..conformal import ( + ForecastIntervals, + validate_calibration_length, + rolling_origin_residuals, + interval_columns, +) from .mlp import MLP import warnings lgb.register_logger(CustomLogger()) @@ -182,6 +188,12 @@ def __init__( self._fit = None self._target = None + # Conformal prediction interval state + self._is_calibrated = False + self._cs_scores = None + self._cs_series_order = None + self._pi_config = None + if hessian_method == "gn": self._gn_hessian = GaussNewtonHessian(loss_fn, n_hessian_probes, self.dtype) @@ -525,6 +537,7 @@ def train( seed: int = 123, verbose: int = -1, deterministic: bool = True, + forecast_intervals: Optional[ForecastIntervals] = None, ) -> TrainingResult: """ Train the Hyper-TreeNet-AR model on time series data. @@ -574,6 +587,12 @@ def train( If True, sets LightGBM's ``deterministic`` and ``force_row_wise`` parameters to ensure reproducible results. May slow down training. See https://lightgbm.readthedocs.io/en/latest/Parameters.html#deterministic + forecast_intervals : ForecastIntervals, optional + If provided, calibrate conformal prediction intervals via rolling-window + cross-validation after the main model is trained. The collected conformity + scores are then used by ``forecast(..., level=[...])`` to produce + ``-lo-`` / ``-hi-`` columns. See + :class:`hypertrees.conformal.ForecastIntervals`. Returns ------- @@ -607,6 +626,8 @@ def train( raise TypeError("validation must be a boolean.") if not isinstance(deterministic, bool): raise TypeError("deterministic must be a boolean.") + if forecast_intervals is not None and not isinstance(forecast_intervals, ForecastIntervals): + raise TypeError("forecast_intervals must be a ForecastIntervals instance.") if early_stopping_round is not None and not validation: raise ValueError("early_stopping_round can only be used when validation is True.") if validation and early_stopping_round is None: @@ -628,6 +649,11 @@ def train( # monotonic dates so the training reshape and fcst_lags extraction align. validate_series_order(train_data, name="train_data") + if forecast_intervals is not None: + validate_calibration_length( + train_data, self.fcst_h, forecast_intervals, min_train=self.p + 1 + ) + # Set the network and optimizer gbdt_params = lgb_params.copy() self.embedding_dim = network_params["embedding_dimension"] @@ -651,6 +677,10 @@ def train( self.dataset_references = {} self.is_trained = False self.features = None + self._is_calibrated = False + self._cs_scores = None + self._cs_series_order = None + self._pi_config = None # Select objective function based on training mode and Hessian method if self.gradient_mode == "separate": @@ -737,6 +767,38 @@ def train( # Set trained flag to True self.is_trained = True + if forecast_intervals is not None: + def _model_factory(): + return HyperTreeNetAR( + p=self.p, + freq=self.freq, + fcst_h=self.fcst_h, + loss_fn=self.loss_fn, + device=self.device, + hessian_method=self.hessian_method, + n_hessian_probes=self.n_hessian_probes, + ) + + cal_train_kwargs = dict( + lgb_params=lgb_params, + network_params=network_params, + gradient_mode=gradient_mode, + num_iterations=num_iterations, + validation=False, + seed=seed, + verbose=verbose, + deterministic=deterministic, + ) + self._cs_scores, self._cs_series_order = rolling_origin_residuals( + model_factory=_model_factory, + train_data=train_data, + fcst_h=self.fcst_h, + forecast_intervals=forecast_intervals, + train_kwargs=cal_train_kwargs, + ) + self._pi_config = forecast_intervals + self._is_calibrated = True + # Return results result = TrainingResult( train_metrics=evals_result["train"] if validation else {"loss": []}, @@ -756,7 +818,8 @@ def train( def forecast( self, test_data: pd.DataFrame, - type: str = "forecast" + type: str = "forecast", + level: Optional[List[int]] = None, ) -> pd.DataFrame: """ Generate forecasts using the trained model. @@ -781,6 +844,11 @@ def forecast( - "forecast": Generate forecasted values - "parameters": Return the AR(p) coefficients used for forecasting - "tree_embeddings": Return the tree embeddings + level : list of int, optional + Confidence levels (in ``(0, 100)``, e.g. ``[80, 90]``) for conformal + prediction intervals. Only valid with ``type="forecast"`` and requires + the model to have been trained with ``forecast_intervals=...``. Adds + ``-lo-`` / ``-hi-`` columns to the output. Returns ------- @@ -788,10 +856,12 @@ def forecast( Forecasted data with columns: - series_id: Identifier for each time series - date: Forecast date/time - - model: Model name identifier - fcst: Forecasted value (if type="forecast") + - model: Model name identifier - AR(i) for i=1..p: AR coefficient values (if type="parameters") - tree_embedding_{i} for i=1..embedding_dim: GBDT tree-embedding dimensions (if type="tree_embeddings") + - -lo- / -hi-: prediction interval bounds + (if type="forecast" and level is provided) """ # Check if model is trained if not self.is_trained or self.model is None: @@ -840,6 +910,21 @@ def forecast( if type not in ["forecast", "parameters", "tree_embeddings"]: raise ValueError("Parameter 'type' must be either 'forecast', 'parameters' or 'tree_embeddings'.") + if level is not None: + if type != "forecast": + raise ValueError("level is only supported with type='forecast'.") + if not self._is_calibrated: + raise RuntimeError( + "Prediction intervals were requested via level, but the model " + "was not calibrated. Pass forecast_intervals=ForecastIntervals(...) " + "to train() before forecasting with level." + ) + if not isinstance(level, (list, tuple)) or len(level) == 0: + raise ValueError("level must be a non-empty list of integers.") + for lv in level: + if not isinstance(lv, (int, np.integer)) or not 0 < lv < 100: + raise ValueError(f"level values must be integers in (0, 100); got {lv}.") + try: # Get tree embeddings gbdt_embeds = torch.tensor( @@ -876,13 +961,28 @@ def forecast( lags = np.concatenate([next_val, lags[:, :-1]], axis=1) # Create output dataframe based on requested type + model_name = f"Hyper-TreeNet-AR({self.p})" out_df = pd.DataFrame({ "series_id": test_data["series_id"].to_numpy().flatten(), "date": test_data["date"].to_numpy().flatten(), "fcst": np.hstack(forecasts).flatten(), - "model": f"Hyper-TreeNet-AR({self.p})", + "model": model_name, }) + if level is not None: + point = np.hstack(forecasts) # (n_series, fcst_h) + columns = interval_columns( + point=point, + scores=self._cs_scores, + levels=level, + method=self._pi_config.method, + model_name=model_name, + cal_order=self._cs_series_order, + target_order=list(test_series_ids), + ) + for col_name, values in columns.items(): + out_df[col_name] = values + elif type == "parameters": with torch.no_grad(): params_fcst = (self.network(gbdt_embeds) diff --git a/pyproject.toml b/pyproject.toml index 3a7eb16..7a610ae 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "hypertrees-forecasting" -version = "0.1.1" +version = "0.2.0" description = "Forecasting with Hyper-Trees" readme = {file = "README.md", content-type = "text/markdown"} authors = [ diff --git a/tests/test_conformal.py b/tests/test_conformal.py new file mode 100644 index 0000000..e996ba1 --- /dev/null +++ b/tests/test_conformal.py @@ -0,0 +1,54 @@ +"""Unit tests for the conformal prediction math (model-agnostic).""" + +import numpy as np +import pytest + +from hypertrees import ForecastIntervals +from hypertrees.conformal import ( + interval_columns, + _distribution_bands, + _error_bands, +) + + +def test_forecast_intervals_validation(): + with pytest.raises(ValueError): + ForecastIntervals(n_windows=1) # must be >= 2 + with pytest.raises(ValueError): + ForecastIntervals(method="bogus") + with pytest.raises(ValueError): + ForecastIntervals(step_size=0) + with pytest.raises(ValueError): + ForecastIntervals(refit="yes") # must be bool + + +def test_distribution_vs_error_bands_symmetry(): + rng = np.random.default_rng(0) + point = rng.standard_normal((2, 3)) + scores = np.abs(rng.standard_normal((5, 2, 3))) + # error bands are symmetric around the point forecast by construction + bands = _error_bands(point, scores, [90]) + lo, hi = bands[90] + np.testing.assert_allclose(hi - point, point - lo) + # distribution bands: higher level => wider interval + d80 = _distribution_bands(point, scores, [80])[80] + d90 = _distribution_bands(point, scores, [90])[90] + assert np.all(d90[0] <= d80[0] + 1e-9) # lower bound wider + assert np.all(d90[1] >= d80[1] - 1e-9) # upper bound wider + + +def test_interval_columns_naming_and_ordering(): + point = np.zeros((2, 3)) + scores = np.ones((4, 2, 3)) + cols = interval_columns( + point=point, + scores=scores, + levels=[80, 90], + method="conformal_error", + model_name="M", + cal_order=[0, 1], + target_order=[0, 1], + ) + assert list(cols.keys()) == ["M-lo-90", "M-lo-80", "M-hi-80", "M-hi-90"] + for v in cols.values(): + assert v.shape == (2 * 3,) diff --git a/tests/test_hypertree_ar.py b/tests/test_hypertree_ar.py index 4f520c6..f30e858 100644 --- a/tests/test_hypertree_ar.py +++ b/tests/test_hypertree_ar.py @@ -8,6 +8,7 @@ from hypertrees.models.HyperTreeAR import HyperTreeAR from hypertrees.utils import TrainingResult +from hypertrees import ForecastIntervals class TestHyperTreeARInitialization: @@ -1145,3 +1146,120 @@ def test_eval_fn_edge_case_empty_dataset_references(self): assert isinstance(metric_name, str) assert isinstance(metric_value, float) assert is_higher_better is False + + +class TestHyperTreeARConformal: + """Tests for conformal prediction intervals on HyperTreeAR.""" + + P = 2 + FCST_H = 4 + N_SERIES = 3 + N_OBS = 60 + MODEL_NAME = f"Hyper-Tree-AR({P})" + LGB_PARAMS = {"learning_rate": 0.1, "num_leaves": 15, "min_data_in_leaf": 1, "min_data_in_bin": 1} + + def _make_data(self): + rng = np.random.default_rng(42) + dates = pd.date_range("2015-01-01", periods=self.N_OBS, freq="MS") + frames = [] + for sid in range(self.N_SERIES): + frames.append(pd.DataFrame({ + "series_id": sid, "date": dates, + "value": rng.standard_normal(self.N_OBS).cumsum() + 100, + "month": dates.month, "quarter": dates.quarter, + })) + return pd.concat(frames, ignore_index=True) + + def _split(self, df): + test = df.groupby("series_id", sort=False).tail(self.FCST_H).reset_index(drop=True) + train = df.drop(df.groupby("series_id", sort=False).tail(self.FCST_H).index).reset_index(drop=True) + return train, test + + @pytest.fixture + def split(self): + return self._split(self._make_data()) + + @pytest.fixture + def calibrated(self, split): + train, test = split + model = HyperTreeAR(p=self.P, freq="M", fcst_h=self.FCST_H) + model.train(lgb_params=self.LGB_PARAMS, num_iterations=20, train_data=train, + forecast_intervals=ForecastIntervals(n_windows=3)) + return model, train, test + + def test_calibration_sets_state(self, calibrated): + model, _, _ = calibrated + assert model._is_calibrated is True + assert model._cs_scores.shape == (3, self.N_SERIES, self.FCST_H) + assert np.all(model._cs_scores >= 0) + assert model._cs_series_order == [0, 1, 2] + + def test_no_calibration_by_default(self, split): + train, _ = split + model = HyperTreeAR(p=self.P, freq="M", fcst_h=self.FCST_H) + model.train(lgb_params=self.LGB_PARAMS, num_iterations=20, train_data=train) + assert model._is_calibrated is False + assert model._cs_scores is None + + def test_forecast_adds_interval_columns(self, calibrated): + model, _, test = calibrated + out = model.forecast(test_data=test, level=[80, 90]) + for lv in [80, 90]: + assert f"{self.MODEL_NAME}-lo-{lv}" in out.columns + assert f"{self.MODEL_NAME}-hi-{lv}" in out.columns + assert np.isfinite(out[f"{self.MODEL_NAME}-lo-90"]).all() + + def test_interval_nesting(self, calibrated): + model, _, test = calibrated + mn = self.MODEL_NAME + out = model.forecast(test_data=test, level=[80, 90]) + assert np.all(out[f"{mn}-lo-90"].to_numpy() <= out[f"{mn}-lo-80"].to_numpy() + 1e-9) + assert np.all(out[f"{mn}-lo-80"].to_numpy() <= out["fcst"].to_numpy() + 1e-9) + assert np.all(out["fcst"].to_numpy() <= out[f"{mn}-hi-80"].to_numpy() + 1e-9) + assert np.all(out[f"{mn}-hi-80"].to_numpy() <= out[f"{mn}-hi-90"].to_numpy() + 1e-9) + + def test_point_forecast_unchanged_by_level(self, calibrated): + model, _, test = calibrated + base = model.forecast(test_data=test) + with_intervals = model.forecast(test_data=test, level=[90]) + np.testing.assert_allclose(base["fcst"].to_numpy(), with_intervals["fcst"].to_numpy()) + + def test_both_methods_run(self, split): + train, test = split + for method in ("conformal_distribution", "conformal_error"): + model = HyperTreeAR(p=self.P, freq="M", fcst_h=self.FCST_H) + model.train(lgb_params=self.LGB_PARAMS, num_iterations=20, train_data=train, + forecast_intervals=ForecastIntervals(n_windows=3, method=method)) + out = model.forecast(test_data=test, level=[90]) + assert f"{self.MODEL_NAME}-lo-90" in out.columns + assert np.all(out[f"{self.MODEL_NAME}-lo-90"].to_numpy() <= out[f"{self.MODEL_NAME}-hi-90"].to_numpy()) + + def test_refit_false_produces_intervals(self, split): + train, test = split + model = HyperTreeAR(p=self.P, freq="M", fcst_h=self.FCST_H) + model.train(lgb_params=self.LGB_PARAMS, num_iterations=20, train_data=train, + forecast_intervals=ForecastIntervals(n_windows=3, refit=False)) + assert model._is_calibrated is True + out = model.forecast(test_data=test, level=[80, 90]) + assert np.all(out[f"{self.MODEL_NAME}-lo-90"].to_numpy() <= out[f"{self.MODEL_NAME}-hi-90"].to_numpy()) + + def test_level_without_calibration_raises(self, split): + train, test = split + model = HyperTreeAR(p=self.P, freq="M", fcst_h=self.FCST_H) + model.train(lgb_params=self.LGB_PARAMS, num_iterations=20, train_data=train) + with pytest.raises(RuntimeError, match="not calibrated"): + model.forecast(test_data=test, level=[90]) + + def test_short_series_raises(self): + short = self._make_data() + short = short.groupby("series_id", sort=False).head(10).reset_index(drop=True) + train, _ = self._split(short) + model = HyperTreeAR(p=self.P, freq="M", fcst_h=self.FCST_H) + with pytest.raises(ValueError, match="too short"): + model.train(lgb_params=self.LGB_PARAMS, num_iterations=20, train_data=train, + forecast_intervals=ForecastIntervals(n_windows=5)) + + def test_invalid_level_value(self, calibrated): + model, _, test = calibrated + with pytest.raises(ValueError): + model.forecast(test_data=test, level=[150]) diff --git a/tests/test_hypertree_ets.py b/tests/test_hypertree_ets.py index 8541b06..bcc9896 100644 --- a/tests/test_hypertree_ets.py +++ b/tests/test_hypertree_ets.py @@ -8,6 +8,7 @@ from hypertrees.models.HyperTreeETS import HyperTreeETS from hypertrees.utils import TrainingResult +from hypertrees import ForecastIntervals class TestHyperTreeETSInitialization: @@ -803,3 +804,75 @@ def test_store_final_states_triple(self): assert torch.isfinite(st["last_level"]).item() assert torch.isfinite(st["last_trend"]).item() assert torch.isfinite(st["seasonality"]).all() + + +class TestHyperTreeETSConformal: + """Tests for conformal prediction intervals on HyperTreeETS.""" + + FCST_H = 4 + N_SERIES = 2 + N_OBS = 60 + LGB_PARAMS = {"learning_rate": 0.1, "num_leaves": 15, "min_data_in_leaf": 1, "min_data_in_bin": 1} + + def _make_data(self): + rng = np.random.default_rng(42) + dates = pd.date_range("2015-01-01", periods=self.N_OBS, freq="MS") + frames = [] + for sid in range(self.N_SERIES): + frames.append(pd.DataFrame({ + "series_id": sid, "date": dates, + "value": rng.standard_normal(self.N_OBS).cumsum() + 100, + "month": dates.month, "quarter": dates.quarter, + })) + return pd.concat(frames, ignore_index=True) + + def _split(self, df): + test = df.groupby("series_id", sort=False).tail(self.FCST_H).reset_index(drop=True) + train = df.drop(df.groupby("series_id", sort=False).tail(self.FCST_H).index).reset_index(drop=True) + return train, test + + @pytest.fixture + def split(self): + return self._split(self._make_data()) + + @pytest.fixture + def calibrated(self, split): + train, test = split + model = HyperTreeETS(ets_type="trend", season_length=12, freq="M", fcst_h=self.FCST_H) + model.train(lgb_params=self.LGB_PARAMS, num_iterations=20, train_data=train, + forecast_intervals=ForecastIntervals(n_windows=3, refit=False)) + return model, train, test + + def test_calibration_sets_state(self, calibrated): + model, _, _ = calibrated + assert model._is_calibrated is True + assert model._cs_scores.shape == (3, self.N_SERIES, self.FCST_H) + assert np.all(model._cs_scores >= 0) + + def test_no_calibration_by_default(self, split): + train, _ = split + model = HyperTreeETS(ets_type="trend", season_length=12, freq="M", fcst_h=self.FCST_H) + model.train(lgb_params=self.LGB_PARAMS, num_iterations=20, train_data=train) + assert model._is_calibrated is False + + def test_forecast_adds_interval_columns(self, calibrated): + model, _, test = calibrated + mn = "Hyper-Tree-ETS(trend)" + out = model.forecast(test_data=test, level=[80, 90]) + for lv in [80, 90]: + assert f"{mn}-lo-{lv}" in out.columns + assert f"{mn}-hi-{lv}" in out.columns + + def test_interval_nesting(self, calibrated): + model, _, test = calibrated + mn = "Hyper-Tree-ETS(trend)" + out = model.forecast(test_data=test, level=[80, 90]) + assert np.all(out[f"{mn}-lo-90"].to_numpy() <= out[f"{mn}-lo-80"].to_numpy() + 1e-9) + assert np.all(out[f"{mn}-hi-80"].to_numpy() <= out[f"{mn}-hi-90"].to_numpy() + 1e-9) + + def test_level_without_calibration_raises(self, split): + train, test = split + model = HyperTreeETS(ets_type="trend", season_length=12, freq="M", fcst_h=self.FCST_H) + model.train(lgb_params=self.LGB_PARAMS, num_iterations=20, train_data=train) + with pytest.raises(RuntimeError, match="not calibrated"): + model.forecast(test_data=test, level=[90]) diff --git a/tests/test_hypertree_net_ar.py b/tests/test_hypertree_net_ar.py index c71f9ee..29a77b3 100644 --- a/tests/test_hypertree_net_ar.py +++ b/tests/test_hypertree_net_ar.py @@ -8,6 +8,7 @@ from hypertrees.models.HyperTreeNetAR import HyperTreeNetAR from hypertrees.utils import TrainingResult +from hypertrees import ForecastIntervals class TestHyperTreeNetARInitialization: @@ -1273,3 +1274,82 @@ def test_objective_fn_integration_with_real_methods(self, model_with_lags, mock_ # Hessians should generally be non-negative (for MSE loss) # Allow for some numerical precision issues in this integration test assert np.isfinite(hess).all() # Just ensure they're finite + + +class TestHyperTreeNetARConformal: + """Tests for conformal prediction intervals on HyperTreeNetAR.""" + + FCST_H = 4 + N_SERIES = 2 + N_OBS = 60 + LGB_PARAMS = {"learning_rate": 0.1, "num_leaves": 15, "min_data_in_leaf": 1, "min_data_in_bin": 1} + NETWORK_PARAMS = { + "learning_rate": 1e-3, "embedding_dimension": 1, "hidden_dim": 32, + "dropout": 0.0, "use_random_projection": False, "rp_embed_dim": None, + } + + def _make_data(self): + rng = np.random.default_rng(42) + dates = pd.date_range("2015-01-01", periods=self.N_OBS, freq="MS") + frames = [] + for sid in range(self.N_SERIES): + frames.append(pd.DataFrame({ + "series_id": sid, "date": dates, + "value": rng.standard_normal(self.N_OBS).cumsum() + 100, + "month": dates.month, "quarter": dates.quarter, + })) + return pd.concat(frames, ignore_index=True) + + def _split(self, df): + test = df.groupby("series_id", sort=False).tail(self.FCST_H).reset_index(drop=True) + train = df.drop(df.groupby("series_id", sort=False).tail(self.FCST_H).index).reset_index(drop=True) + return train, test + + @pytest.fixture + def split(self): + return self._split(self._make_data()) + + @pytest.fixture + def calibrated(self, split): + train, test = split + model = HyperTreeNetAR(p=2, freq="M", fcst_h=self.FCST_H) + model.train(lgb_params=self.LGB_PARAMS, network_params=self.NETWORK_PARAMS, + num_iterations=20, train_data=train, + forecast_intervals=ForecastIntervals(n_windows=3, refit=False)) + return model, train, test + + def test_calibration_sets_state(self, calibrated): + model, _, _ = calibrated + assert model._is_calibrated is True + assert model._cs_scores.shape == (3, self.N_SERIES, self.FCST_H) + assert np.all(model._cs_scores >= 0) + + def test_no_calibration_by_default(self, split): + train, _ = split + model = HyperTreeNetAR(p=2, freq="M", fcst_h=self.FCST_H) + model.train(lgb_params=self.LGB_PARAMS, network_params=self.NETWORK_PARAMS, + num_iterations=20, train_data=train) + assert model._is_calibrated is False + + def test_forecast_adds_interval_columns(self, calibrated): + model, _, test = calibrated + mn = "Hyper-TreeNet-AR(2)" + out = model.forecast(test_data=test, level=[80, 90]) + for lv in [80, 90]: + assert f"{mn}-lo-{lv}" in out.columns + assert f"{mn}-hi-{lv}" in out.columns + + def test_interval_nesting(self, calibrated): + model, _, test = calibrated + mn = "Hyper-TreeNet-AR(2)" + out = model.forecast(test_data=test, level=[80, 90]) + assert np.all(out[f"{mn}-lo-90"].to_numpy() <= out[f"{mn}-lo-80"].to_numpy() + 1e-9) + assert np.all(out[f"{mn}-hi-80"].to_numpy() <= out[f"{mn}-hi-90"].to_numpy() + 1e-9) + + def test_level_without_calibration_raises(self, split): + train, test = split + model = HyperTreeNetAR(p=2, freq="M", fcst_h=self.FCST_H) + model.train(lgb_params=self.LGB_PARAMS, network_params=self.NETWORK_PARAMS, + num_iterations=20, train_data=train) + with pytest.raises(RuntimeError, match="not calibrated"): + model.forecast(test_data=test, level=[90]) From 16acbc1755d195fbd25a93e25da55ba8e74fdb2e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Wed, 3 Jun 2026 10:49:53 +0200 Subject: [PATCH 02/26] Exclude macOS + Python 3.14 from CI (numpy upstream incompatibility) --- .github/workflows/unit-tests.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index 04740a8..6916407 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -14,6 +14,9 @@ jobs: matrix: os: [ubuntu-latest, windows-latest, macos-latest] python-version: ["3.11", "3.12", "3.13", "3.14"] + exclude: + - os: macos-latest + python-version: "3.14" steps: - uses: actions/checkout@v4 From 772ab3e00a2ba4a62601627011f868cfeaa89d29 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Wed, 3 Jun 2026 10:56:39 +0200 Subject: [PATCH 03/26] Pin macOS CI runner to macos-13 (macos-latest numpy incompatibility) --- .github/workflows/unit-tests.yml | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index 6916407..da0e9a3 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -12,11 +12,8 @@ jobs: strategy: fail-fast: false matrix: - os: [ubuntu-latest, windows-latest, macos-latest] + os: [ubuntu-latest, windows-latest, macos-13] python-version: ["3.11", "3.12", "3.13", "3.14"] - exclude: - - os: macos-latest - python-version: "3.14" steps: - uses: actions/checkout@v4 From faf46be7e9bcf3bbd698403f14f1c07cef93ef60 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Wed, 3 Jun 2026 11:48:36 +0200 Subject: [PATCH 04/26] Update CI configuration to use macos-latest and adjust torch installation for compatibility --- .github/workflows/unit-tests.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index da0e9a3..d1f2f02 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -12,7 +12,7 @@ jobs: strategy: fail-fast: false matrix: - os: [ubuntu-latest, windows-latest, macos-13] + os: [ubuntu-latest, windows-latest, macos-latest] python-version: ["3.11", "3.12", "3.13", "3.14"] steps: @@ -32,10 +32,10 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip + # Install CPU-only torch first so pip resolves compatible numpy + python -m pip install torch --extra-index-url https://download.pytorch.org/whl/cpu # Install project with test extras (pytest, pytest-cov, etc.) python -m pip install -e ".[test]" - # Force CPU-only torch to avoid pulling CUDA wheels in CI - python -m pip install --force-reinstall --no-deps torch --extra-index-url https://download.pytorch.org/whl/cpu - name: Run tests with coverage run: | From 437e9b5a8bb53717dfa113c843105457d323e520 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Wed, 3 Jun 2026 11:57:59 +0200 Subject: [PATCH 05/26] Fix CI torch install: install project first, swap to CPU torch with --no-deps --- .github/workflows/unit-tests.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index d1f2f02..42dda9b 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -32,10 +32,10 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - # Install CPU-only torch first so pip resolves compatible numpy - python -m pip install torch --extra-index-url https://download.pytorch.org/whl/cpu - # Install project with test extras (pytest, pytest-cov, etc.) + # Install project with all dependencies (numpy, pandas, torch from PyPI) python -m pip install -e ".[test]" + # Swap torch for CPU-only build; --no-deps keeps numpy untouched + python -m pip install torch --extra-index-url https://download.pytorch.org/whl/cpu --no-deps - name: Run tests with coverage run: | From 684602e56dbca488cb3446b87cacfeb4174b80bd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Wed, 3 Jun 2026 12:01:57 +0200 Subject: [PATCH 06/26] Fix CI: uninstall PyPI torch before installing CPU-only build --- .github/workflows/unit-tests.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index 42dda9b..c67ab10 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -34,7 +34,8 @@ jobs: python -m pip install --upgrade pip # Install project with all dependencies (numpy, pandas, torch from PyPI) python -m pip install -e ".[test]" - # Swap torch for CPU-only build; --no-deps keeps numpy untouched + # Swap torch for CPU-only build; uninstall first to avoid ABI conflicts + python -m pip uninstall -y torch python -m pip install torch --extra-index-url https://download.pytorch.org/whl/cpu --no-deps - name: Run tests with coverage From c35f572b7edbbe461d95eaf6781f4aa943e67a9d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Wed, 3 Jun 2026 12:07:05 +0200 Subject: [PATCH 07/26] Fix CI: install CPU torch via --index-url before project to avoid CUDA deps --- .github/workflows/unit-tests.yml | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index c67ab10..a705157 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -32,11 +32,10 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - # Install project with all dependencies (numpy, pandas, torch from PyPI) + # Install CPU-only torch first (--index-url ensures no CUDA deps are pulled) + python -m pip install torch --index-url https://download.pytorch.org/whl/cpu + # Install project and remaining dependencies from PyPI (torch already satisfied) python -m pip install -e ".[test]" - # Swap torch for CPU-only build; uninstall first to avoid ABI conflicts - python -m pip uninstall -y torch - python -m pip install torch --extra-index-url https://download.pytorch.org/whl/cpu --no-deps - name: Run tests with coverage run: | From 4a90f6833f044953bbf182213c386619572c3d3b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Wed, 3 Jun 2026 12:16:55 +0200 Subject: [PATCH 08/26] Fix CI: swap torch install order to avoid numpy ABI collision --- .github/workflows/unit-tests.yml | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index a705157..ede8a92 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -32,10 +32,11 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - # Install CPU-only torch first (--index-url ensures no CUDA deps are pulled) - python -m pip install torch --index-url https://download.pytorch.org/whl/cpu - # Install project and remaining dependencies from PyPI (torch already satisfied) + # Install project and all deps from PyPI first python -m pip install -e ".[test]" + # Replace torch with CPU-only build; --no-deps avoids pulling numpy + # from the PyTorch index (which causes an ABI collision with PyPI numpy) + python -m pip install torch --force-reinstall --no-deps --index-url https://download.pytorch.org/whl/cpu - name: Run tests with coverage run: | From 1ccc880e57945122f608a0a84b752e4c9bc6569e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Wed, 3 Jun 2026 12:26:27 +0200 Subject: [PATCH 09/26] Fix: Revert the CI workflow --- .github/workflows/unit-tests.yml | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index ede8a92..59330fd 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -32,11 +32,8 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - # Install project and all deps from PyPI first python -m pip install -e ".[test]" - # Replace torch with CPU-only build; --no-deps avoids pulling numpy - # from the PyTorch index (which causes an ABI collision with PyPI numpy) - python -m pip install torch --force-reinstall --no-deps --index-url https://download.pytorch.org/whl/cpu + python -m pip install --force-reinstall --no-deps torch --extra-index-url https://download.pytorch.org/whl/cpu - name: Run tests with coverage run: | From 237410bcc67a22d8577cbabd2c13ba28c2459611 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Wed, 3 Jun 2026 12:55:26 +0200 Subject: [PATCH 10/26] Fix refit=False conformal calibration by re-anchoring forecast seed per window Revert CI torch install to --extra-index-url (matches passing main) --- examples/Forecast Intervals.ipynb | 221 ++++++++++++++-------------- hypertrees/conformal.py | 14 +- hypertrees/models/HyperTreeAR.py | 20 ++- hypertrees/models/HyperTreeETS.py | 18 +++ hypertrees/models/HyperTreeNetAR.py | 20 ++- hypertrees/utils.py | 24 +++ tests/test_conformal.py | 50 +++++++ tests/test_hypertree_ar.py | 45 +++++- tests/test_hypertree_ets.py | 18 +++ tests/test_hypertree_net_ar.py | 44 +++++- 10 files changed, 345 insertions(+), 129 deletions(-) diff --git a/examples/Forecast Intervals.ipynb b/examples/Forecast Intervals.ipynb index daaa55d..040fbae 100644 --- a/examples/Forecast Intervals.ipynb +++ b/examples/Forecast Intervals.ipynb @@ -19,8 +19,8 @@ ], "metadata": { "ExecuteTime": { - "end_time": "2026-06-03T08:38:40.882560100Z", - "start_time": "2026-06-03T08:38:30.050270500Z" + "end_time": "2026-06-03T10:49:29.856557200Z", + "start_time": "2026-06-03T10:49:27.466201500Z" } }, "outputs": [], @@ -38,8 +38,8 @@ "source": "df = pd.read_csv('https://datasets-nixtla.s3.amazonaws.com/air-passengers.csv', parse_dates=['ds'])\ndf.rename(columns={'unique_id': 'series_id', 'ds': 'date', 'y': 'value'}, inplace=True)\ndf['month'] = df['date'].dt.month\ndf['quarter'] = df['date'].dt.quarter\n\nfcst_h = 12\ntest = df.tail(fcst_h)\ntrain = df.drop(test.index)", "metadata": { "ExecuteTime": { - "end_time": "2026-06-03T08:38:41.283739200Z", - "start_time": "2026-06-03T08:38:40.895558900Z" + "end_time": "2026-06-03T10:49:30.269936100Z", + "start_time": "2026-06-03T10:49:29.858888Z" } }, "outputs": [], @@ -55,11 +55,12 @@ "cell_type": "code", "id": "2d426f65", "source": [ + "lag_p = 12\n", "freq = 'MS'\n", "num_iterations = 100\n", "ci_levels = [80, 90]\n", "n_windows = 5\n", - "refit = False\n", + "refit = True\n", "device=torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "\n", "ht_params = {\n", @@ -68,8 +69,8 @@ ], "metadata": { "ExecuteTime": { - "end_time": "2026-06-03T08:38:41.782578400Z", - "start_time": "2026-06-03T08:38:41.296738200Z" + "end_time": "2026-06-03T10:49:30.300341100Z", + "start_time": "2026-06-03T10:49:30.275909200Z" } }, "outputs": [], @@ -85,8 +86,6 @@ "cell_type": "code", "id": "dbb5135d", "source": [ - "lag_p = 12\n", - "\n", "ht_ar = HyperTreeAR(p=lag_p, freq=freq, fcst_h=fcst_h)\n", "ht_ar.train(\n", " lgb_params=ht_params,\n", @@ -102,8 +101,8 @@ ], "metadata": { "ExecuteTime": { - "end_time": "2026-06-03T08:38:42.705452700Z", - "start_time": "2026-06-03T08:38:41.795577900Z" + "end_time": "2026-06-03T10:49:34.012034100Z", + "start_time": "2026-06-03T10:49:30.303454400Z" } }, "outputs": [ @@ -118,18 +117,18 @@ "4 AirPassengers 1960-05-01 466.937533 Hyper-Tree-AR(12) \n", "\n", " Hyper-Tree-AR(12)-lo-90 Hyper-Tree-AR(12)-lo-80 Hyper-Tree-AR(12)-hi-80 \\\n", - "0 374.900429 378.875007 428.254363 \n", - "1 374.997106 377.199307 428.134560 \n", - "2 436.837740 439.324120 488.934067 \n", - "3 433.513237 434.107431 472.590283 \n", - "4 451.324017 452.709793 481.165273 \n", + "0 377.535822 379.354170 427.775200 \n", + "1 379.954555 385.697925 419.635942 \n", + "2 440.362885 446.374410 481.883778 \n", + "3 436.129435 439.099078 467.598636 \n", + "4 449.567804 453.618077 480.256989 \n", "\n", " Hyper-Tree-AR(12)-hi-90 \n", - "0 432.228941 \n", - "1 430.336762 \n", - "2 491.420447 \n", - "3 473.184477 \n", - "4 482.551049 " + "0 429.593548 \n", + "1 425.379312 \n", + "2 487.895303 \n", + "3 470.568279 \n", + "4 484.307262 " ], "text/html": [ "

\n", @@ -167,10 +166,10 @@ " 1960-01-01\n", " 403.564685\n", " Hyper-Tree-AR(12)\n", - " 374.900429\n", - " 378.875007\n", - " 428.254363\n", - " 432.228941\n", + " 377.535822\n", + " 379.354170\n", + " 427.775200\n", + " 429.593548\n", " \n", " \n", " 1\n", @@ -178,10 +177,10 @@ " 1960-02-01\n", " 402.666934\n", " Hyper-Tree-AR(12)\n", - " 374.997106\n", - " 377.199307\n", - " 428.134560\n", - " 430.336762\n", + " 379.954555\n", + " 385.697925\n", + " 419.635942\n", + " 425.379312\n", " \n", " \n", " 2\n", @@ -189,10 +188,10 @@ " 1960-03-01\n", " 464.129094\n", " Hyper-Tree-AR(12)\n", - " 436.837740\n", - " 439.324120\n", - " 488.934067\n", - " 491.420447\n", + " 440.362885\n", + " 446.374410\n", + " 481.883778\n", + " 487.895303\n", " \n", " \n", " 3\n", @@ -200,10 +199,10 @@ " 1960-04-01\n", " 453.348857\n", " Hyper-Tree-AR(12)\n", - " 433.513237\n", - " 434.107431\n", - " 472.590283\n", - " 473.184477\n", + " 436.129435\n", + " 439.099078\n", + " 467.598636\n", + " 470.568279\n", " \n", " \n", " 4\n", @@ -211,10 +210,10 @@ " 1960-05-01\n", " 466.937533\n", " Hyper-Tree-AR(12)\n", - " 451.324017\n", - " 452.709793\n", - " 481.165273\n", - " 482.551049\n", + " 449.567804\n", + " 453.618077\n", + " 480.256989\n", + " 484.307262\n", " \n", " \n", "\n", @@ -251,7 +250,7 @@ " train_data=train,\n", " seed=123,\n", " verbose=-1,\n", - " forecast_intervals=ForecastIntervals(n_windows=n_windows, refit=refit),\n", + " forecast_intervals=ForecastIntervals(n_windows=n_windows, refit=True),\n", ")\n", "\n", "ht_ets_fcst = ht_ets.forecast(test_data=test, level=ci_levels)\n", @@ -259,8 +258,8 @@ ], "metadata": { "ExecuteTime": { - "end_time": "2026-06-03T08:39:28.575252800Z", - "start_time": "2026-06-03T08:38:42.983143900Z" + "end_time": "2026-06-03T10:51:41.107698900Z", + "start_time": "2026-06-03T10:49:34.112062900Z" } }, "outputs": [ @@ -275,18 +274,18 @@ "4 AirPassengers 1960-05-01 447.878479 Hyper-Tree-ETS(triple) \n", "\n", " Hyper-Tree-ETS(triple)-lo-90 Hyper-Tree-ETS(triple)-lo-80 \\\n", - "0 402.068939 404.092072 \n", - "1 375.984319 376.072855 \n", - "2 427.777397 432.720078 \n", - "3 402.167624 404.361401 \n", - "4 412.318495 417.967679 \n", + "0 400.981943 401.406482 \n", + "1 377.327919 378.808121 \n", + "2 429.340707 433.964496 \n", + "3 405.167220 408.106351 \n", + "4 415.029961 421.563461 \n", "\n", " Hyper-Tree-ETS(triple)-hi-80 Hyper-Tree-ETS(triple)-hi-90 \n", - "0 421.583771 423.606903 \n", - "1 401.305502 401.394038 \n", - "2 460.503677 465.446358 \n", - "3 452.894031 455.087808 \n", - "4 477.789279 483.438463 " + "0 424.269360 424.693900 \n", + "1 398.570236 400.050438 \n", + "2 459.259259 463.883047 \n", + "3 449.149081 452.088213 \n", + "4 474.193497 480.726997 " ], "text/html": [ "
\n", @@ -324,10 +323,10 @@ " 1960-01-01\n", " 412.837921\n", " Hyper-Tree-ETS(triple)\n", - " 402.068939\n", - " 404.092072\n", - " 421.583771\n", - " 423.606903\n", + " 400.981943\n", + " 401.406482\n", + " 424.269360\n", + " 424.693900\n", " \n", " \n", " 1\n", @@ -335,10 +334,10 @@ " 1960-02-01\n", " 388.689178\n", " Hyper-Tree-ETS(triple)\n", - " 375.984319\n", - " 376.072855\n", - " 401.305502\n", - " 401.394038\n", + " 377.327919\n", + " 378.808121\n", + " 398.570236\n", + " 400.050438\n", " \n", " \n", " 2\n", @@ -346,10 +345,10 @@ " 1960-03-01\n", " 446.611877\n", " Hyper-Tree-ETS(triple)\n", - " 427.777397\n", - " 432.720078\n", - " 460.503677\n", - " 465.446358\n", + " 429.340707\n", + " 433.964496\n", + " 459.259259\n", + " 463.883047\n", " \n", " \n", " 3\n", @@ -357,10 +356,10 @@ " 1960-04-01\n", " 428.627716\n", " Hyper-Tree-ETS(triple)\n", - " 402.167624\n", - " 404.361401\n", - " 452.894031\n", - " 455.087808\n", + " 405.167220\n", + " 408.106351\n", + " 449.149081\n", + " 452.088213\n", " \n", " \n", " 4\n", @@ -368,10 +367,10 @@ " 1960-05-01\n", " 447.878479\n", " Hyper-Tree-ETS(triple)\n", - " 412.318495\n", - " 417.967679\n", - " 477.789279\n", - " 483.438463\n", + " 415.029961\n", + " 421.563461\n", + " 474.193497\n", + " 480.726997\n", " \n", " \n", "\n", @@ -427,8 +426,8 @@ ], "metadata": { "ExecuteTime": { - "end_time": "2026-06-03T08:39:33.333331600Z", - "start_time": "2026-06-03T08:39:29.529012Z" + "end_time": "2026-06-03T10:51:47.231785100Z", + "start_time": "2026-06-03T10:51:41.694186800Z" } }, "outputs": [ @@ -443,18 +442,18 @@ "4 AirPassengers 1960-05-01 446.548640 Hyper-TreeNet-AR(12) \n", "\n", " Hyper-TreeNet-AR(12)-lo-90 Hyper-TreeNet-AR(12)-lo-80 \\\n", - "0 374.728973 386.878973 \n", - "1 376.324306 385.665050 \n", - "2 382.422566 389.735466 \n", - "3 401.544587 410.783853 \n", - "4 418.092466 420.452339 \n", + "0 378.169183 386.027768 \n", + "1 368.787185 370.377720 \n", + "2 390.252195 391.159035 \n", + "3 397.351015 398.413260 \n", + "4 415.172470 415.726870 \n", "\n", " Hyper-TreeNet-AR(12)-hi-80 Hyper-TreeNet-AR(12)-hi-90 \n", - "0 418.733224 430.883224 \n", - "1 411.943227 421.283971 \n", - "2 456.423911 463.736811 \n", - "3 448.007429 457.246694 \n", - "4 472.644941 475.004814 " + "0 419.584429 427.443014 \n", + "1 427.230557 428.821093 \n", + "2 455.000342 455.907181 \n", + "3 460.378022 461.440267 \n", + "4 477.370410 477.924810 " ], "text/html": [ "
\n", @@ -492,10 +491,10 @@ " 1960-01-01\n", " 402.806098\n", " Hyper-TreeNet-AR(12)\n", - " 374.728973\n", - " 386.878973\n", - " 418.733224\n", - " 430.883224\n", + " 378.169183\n", + " 386.027768\n", + " 419.584429\n", + " 427.443014\n", " \n", " \n", " 1\n", @@ -503,10 +502,10 @@ " 1960-02-01\n", " 398.804139\n", " Hyper-TreeNet-AR(12)\n", - " 376.324306\n", - " 385.665050\n", - " 411.943227\n", - " 421.283971\n", + " 368.787185\n", + " 370.377720\n", + " 427.230557\n", + " 428.821093\n", " \n", " \n", " 2\n", @@ -514,10 +513,10 @@ " 1960-03-01\n", " 423.079688\n", " Hyper-TreeNet-AR(12)\n", - " 382.422566\n", - " 389.735466\n", - " 456.423911\n", - " 463.736811\n", + " 390.252195\n", + " 391.159035\n", + " 455.000342\n", + " 455.907181\n", " \n", " \n", " 3\n", @@ -525,10 +524,10 @@ " 1960-04-01\n", " 429.395641\n", " Hyper-TreeNet-AR(12)\n", - " 401.544587\n", - " 410.783853\n", - " 448.007429\n", - " 457.246694\n", + " 397.351015\n", + " 398.413260\n", + " 460.378022\n", + " 461.440267\n", " \n", " \n", " 4\n", @@ -536,10 +535,10 @@ " 1960-05-01\n", " 446.548640\n", " Hyper-TreeNet-AR(12)\n", - " 418.092466\n", - " 420.452339\n", - " 472.644941\n", - " 475.004814\n", + " 415.172470\n", + " 415.726870\n", + " 477.370410\n", + " 477.924810\n", " \n", " \n", "\n", @@ -602,8 +601,8 @@ ], "metadata": { "ExecuteTime": { - "end_time": "2026-06-03T08:39:34.138252400Z", - "start_time": "2026-06-03T08:39:33.412977400Z" + "end_time": "2026-06-03T10:51:47.623984Z", + "start_time": "2026-06-03T10:51:47.333884900Z" } }, "outputs": [ @@ -612,7 +611,7 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -632,8 +631,8 @@ "source": "fig, axes = plt.subplots(1, 2, figsize=(14, 5), sharey=True)\n\nfor ax, method in zip(axes, [\"conformal_distribution\", \"conformal_error\"]):\n model = HyperTreeAR(p=lag_p, freq=freq, fcst_h=fcst_h)\n model.train(\n lgb_params=ht_params,\n num_iterations=num_iterations,\n train_data=train,\n seed=123,\n verbose=-1,\n forecast_intervals=ForecastIntervals(n_windows=5, method=method),\n )\n fcst = model.forecast(test_data=test, level=[90])\n model_name = fcst[\"model\"].iloc[0]\n\n ax.plot(df[\"date\"], df[\"value\"], label=\"Actual\", color=\"#2E86AB\", linewidth=2, alpha=0.8)\n ax.plot(fcst[\"date\"], fcst[\"fcst\"], label=\"Forecast\", color=\"green\", linestyle=\"--\", linewidth=2)\n ax.fill_between(\n fcst[\"date\"],\n fcst[f\"{model_name}-lo-90\"],\n fcst[f\"{model_name}-hi-90\"],\n color=\"green\", alpha=0.2, label=\"90% interval\",\n )\n ax.axvline(x=fcst[\"date\"].min(), color=\"black\", linestyle=\":\", alpha=0.7)\n ax.set_title(method, fontsize=14)\n ax.legend(fontsize=10)\n ax.grid(True, alpha=0.3)\n\nplt.tight_layout()\nplt.show()", "metadata": { "ExecuteTime": { - "end_time": "2026-06-03T08:39:41.198542200Z", - "start_time": "2026-06-03T08:39:34.311350300Z" + "end_time": "2026-06-03T10:51:54.457534300Z", + "start_time": "2026-06-03T10:51:47.834860600Z" } }, "outputs": [ diff --git a/hypertrees/conformal.py b/hypertrees/conformal.py index 96362bb..277c314 100644 --- a/hypertrees/conformal.py +++ b/hypertrees/conformal.py @@ -150,15 +150,19 @@ def rolling_origin_residuals( When ``forecast_intervals.refit`` is ``True`` (default) a fresh model is trained for every window. When ``False``, a single model is trained on the - oldest window's training split and reused to forecast all windows (matching - Nixtla's ``mlforecast`` with ``refit=False``). + oldest window's training split and reused to forecast all windows. Before + each window's forecast the model's forecast seed (lags, states, etc.) is + re-anchored to the window's own history via ``set_forecast_origin``, so + that residuals reflect the correct origin — only the GBDT refit is skipped. Parameters ---------- model_factory : Callable[[], object] Zero-argument callable returning a fresh, untrained model exposing - ``train(train_data=..., **train_kwargs)`` and - ``forecast(test_data=..., type="forecast")``. + ``train(train_data=..., **train_kwargs)``, + ``forecast(test_data=..., type="forecast")``, and + ``set_forecast_origin(history: pd.DataFrame)`` (required for + ``refit=False``; re-anchors the forecast seed without retraining). train_data : pd.DataFrame Full training data (``series_id``, ``date``, ``value`` + features). fcst_h : int @@ -216,6 +220,8 @@ def rolling_origin_residuals( model.train(train_data=train_df, **train_kwargs) else: model = shared_model + window_train_df = pd.concat(train_parts, ignore_index=True) + model.set_forecast_origin(window_train_df) fcst = model.forecast(test_data=test_df, type="forecast") diff --git a/hypertrees/models/HyperTreeAR.py b/hypertrees/models/HyperTreeAR.py index 348b57f..e46fa2a 100644 --- a/hypertrees/models/HyperTreeAR.py +++ b/hypertrees/models/HyperTreeAR.py @@ -11,7 +11,7 @@ from ..utils import CustomLogger lgb.register_logger(CustomLogger()) -from ..utils import TimeSeriesPreprocessor, prepare_datasets, TrainingResult, validate_series_order, GaussNewtonHessian +from ..utils import TimeSeriesPreprocessor, prepare_datasets, TrainingResult, validate_series_order, extract_forecast_lags, GaussNewtonHessian from ..conformal import ( ForecastIntervals, validate_calibration_length, @@ -492,11 +492,7 @@ def train( self.lags_eval = lags_eval # Store lagged train values to be used in the forecast method - self.fcst_lags = ( - train_data.groupby(["series_id"], sort=False) - .apply(lambda x: x["value"][-self.p:][::-1].values) - .to_dict() - ) + self.set_forecast_origin(train_data) # Train LightGBM model start_time = time.time() @@ -561,6 +557,18 @@ def _model_factory(): self.is_trained = False raise RuntimeError(f"Training failed: {str(e)}") + def set_forecast_origin(self, history: pd.DataFrame) -> None: + """Re-anchor the AR lag seed to the end of *history* without retraining. + + Parameters + ---------- + history : pd.DataFrame + DataFrame with ``series_id``, ``date``, ``value`` columns, ordered + by ``(series_id, date)`` with each series in a contiguous block. + """ + validate_series_order(history, name="history") + self.fcst_lags = extract_forecast_lags(history, self.p) + def forecast( self, test_data: pd.DataFrame, diff --git a/hypertrees/models/HyperTreeETS.py b/hypertrees/models/HyperTreeETS.py index 2f7e2aa..5267ba1 100644 --- a/hypertrees/models/HyperTreeETS.py +++ b/hypertrees/models/HyperTreeETS.py @@ -857,6 +857,24 @@ def _store_final_states(self, train_data: pd.DataFrame): for i, series_id in enumerate(self.series_order): self.fcst_states[series_id]['seasonality'] = seasonality[i] + def set_forecast_origin(self, history: pd.DataFrame) -> None: + """Re-anchor ETS states to the end of *history* without retraining. + + Recomputes the terminal ``{level, trend, seasonality}`` states by + running the full ETS forward recurrence over *history* using the + already-trained GBDT parameters. Used by conformal calibration with + ``refit=False``. + + Parameters + ---------- + history : pd.DataFrame + DataFrame with the same columns as the training data (including + any ``mask`` / ``seasonality_feature`` columns), ordered by + ``(series_id, date)`` with each series in a contiguous block and + all series of equal length. + """ + self._store_final_states(history) + def forecast( self, test_data: pd.DataFrame, diff --git a/hypertrees/models/HyperTreeNetAR.py b/hypertrees/models/HyperTreeNetAR.py index 40513b6..c65aea9 100644 --- a/hypertrees/models/HyperTreeNetAR.py +++ b/hypertrees/models/HyperTreeNetAR.py @@ -6,7 +6,7 @@ import lightgbm as lgb from typing import Tuple, Callable, Optional, List import time -from ..utils import TimeSeriesPreprocessor, prepare_datasets, TrainingResult, CustomLogger, validate_series_order, GaussNewtonHessian +from ..utils import TimeSeriesPreprocessor, prepare_datasets, TrainingResult, CustomLogger, validate_series_order, extract_forecast_lags, GaussNewtonHessian from ..conformal import ( ForecastIntervals, validate_calibration_length, @@ -745,11 +745,7 @@ def train( self.lags_eval = lags_eval.to(self.device) if lags_eval is not None else None # Store lagged train values to be used in the forecast method - self.fcst_lags = ( - train_data.groupby(["series_id"], sort=False) - .apply(lambda x: x["value"][-self.p:][::-1].values) - .to_dict() - ) + self.set_forecast_origin(train_data) # Train model start_time = time.time() @@ -815,6 +811,18 @@ def _model_factory(): self.is_trained = False raise RuntimeError(f"Training failed: {str(e)}") + def set_forecast_origin(self, history: pd.DataFrame) -> None: + """Re-anchor the AR lag seed to the end of *history* without retraining. + + Parameters + ---------- + history : pd.DataFrame + DataFrame with ``series_id``, ``date``, ``value`` columns, ordered + by ``(series_id, date)`` with each series in a contiguous block. + """ + validate_series_order(history, name="history") + self.fcst_lags = extract_forecast_lags(history, self.p) + def forecast( self, test_data: pd.DataFrame, diff --git a/hypertrees/utils.py b/hypertrees/utils.py index 8375877..0d32bc5 100644 --- a/hypertrees/utils.py +++ b/hypertrees/utils.py @@ -17,6 +17,30 @@ class TrainingResult: training_time: Optional[float] = None +def extract_forecast_lags(history: pd.DataFrame, p: int) -> dict: + """Extract the last *p* values per series as the AR forecast seed. + + Parameters + ---------- + history : pd.DataFrame + Must contain ``series_id`` and ``value`` columns, ordered by + ``(series_id, date)`` with each series in a contiguous block. + p : int + Number of AR lags. + + Returns + ------- + dict + ``{series_id: np.ndarray}`` with each array of length *p* in + newest-first order, matching the convention used by ``forecast()``. + """ + return ( + history.groupby(["series_id"], sort=False) + .apply(lambda x: x["value"][-p:][::-1].values) + .to_dict() + ) + + def validate_series_order(data: pd.DataFrame, name: str = "data") -> None: """ Validate that a time series DataFrame is ordered so each series' rows are diff --git a/tests/test_conformal.py b/tests/test_conformal.py index e996ba1..91c99eb 100644 --- a/tests/test_conformal.py +++ b/tests/test_conformal.py @@ -1,11 +1,14 @@ """Unit tests for the conformal prediction math (model-agnostic).""" import numpy as np +import pandas as pd import pytest +from unittest.mock import MagicMock, call from hypertrees import ForecastIntervals from hypertrees.conformal import ( interval_columns, + rolling_origin_residuals, _distribution_bands, _error_bands, ) @@ -52,3 +55,50 @@ def test_interval_columns_naming_and_ordering(): assert list(cols.keys()) == ["M-lo-90", "M-lo-80", "M-hi-80", "M-hi-90"] for v in cols.values(): assert v.shape == (2 * 3,) + + +def test_refit_false_calls_set_forecast_origin(): + """rolling_origin_residuals with refit=False must re-anchor per window.""" + n_series, T, fcst_h = 2, 20, 3 + n_windows, step_size = 3, 1 + dates = pd.date_range("2020-01-01", periods=T, freq="MS") + train_data = pd.concat([ + pd.DataFrame({ + "series_id": sid, "date": dates, + "value": np.arange(T, dtype=float) + sid * 100, + }) + for sid in range(n_series) + ], ignore_index=True) + + # Build a mock model that returns deterministic forecasts + mock_model = MagicMock() + mock_model.set_forecast_origin = MagicMock() + + def fake_forecast(test_data, type="forecast"): + return pd.DataFrame({ + "series_id": test_data["series_id"].values, + "date": test_data["date"].values, + "fcst": test_data["value"].values + 0.5, + "model": "mock", + }) + + mock_model.forecast = MagicMock(side_effect=fake_forecast) + mock_model.train = MagicMock() + + pi = ForecastIntervals(n_windows=n_windows, step_size=step_size, refit=False) + scores, series_order = rolling_origin_residuals( + model_factory=lambda: mock_model, + train_data=train_data, + fcst_h=fcst_h, + forecast_intervals=pi, + train_kwargs={}, + ) + + # train() called once (oldest window) + assert mock_model.train.call_count == 1 + # set_forecast_origin called once per window + assert mock_model.set_forecast_origin.call_count == n_windows + # scores shape is correct + assert scores.shape == (n_windows, n_series, fcst_h) + # residuals should all be 0.5 (our fake_forecast adds 0.5) + np.testing.assert_allclose(scores, 0.5) diff --git a/tests/test_hypertree_ar.py b/tests/test_hypertree_ar.py index f30e858..bb35f1b 100644 --- a/tests/test_hypertree_ar.py +++ b/tests/test_hypertree_ar.py @@ -99,9 +99,52 @@ def test_invalid_n_hessian_probes(self): HyperTreeAR(n_hessian_probes=-5) +class TestHyperTreeARSetForecastOrigin: + """Test HyperTreeAR.set_forecast_origin.""" + + def test_updates_fcst_lags(self): + """set_forecast_origin should store last p values per series in reverse order.""" + model = HyperTreeAR(p=3, freq="M", fcst_h=2) + history = pd.DataFrame({ + "series_id": [0]*6 + [1]*6, + "date": list(pd.date_range("2020-01-01", periods=6, freq="MS")) * 2, + "value": [10, 20, 30, 40, 50, 60] + [100, 200, 300, 400, 500, 600], + }) + model.set_forecast_origin(history) + # last 3 values of series 0: [60, 50, 40], reversed = newest-first + np.testing.assert_array_equal(model.fcst_lags[0], [60, 50, 40]) + np.testing.assert_array_equal(model.fcst_lags[1], [600, 500, 400]) + + def test_reanchor_changes_lags(self): + """Calling set_forecast_origin twice should update the lags.""" + model = HyperTreeAR(p=2, freq="M", fcst_h=1) + dates = pd.date_range("2020-01-01", periods=5, freq="MS") + history1 = pd.DataFrame({ + "series_id": [0]*5, "date": dates, "value": [1, 2, 3, 4, 5], + }) + history2 = pd.DataFrame({ + "series_id": [0]*5, "date": dates, "value": [10, 20, 30, 40, 50], + }) + model.set_forecast_origin(history1) + np.testing.assert_array_equal(model.fcst_lags[0], [5, 4]) + model.set_forecast_origin(history2) + np.testing.assert_array_equal(model.fcst_lags[0], [50, 40]) + + def test_validates_series_order(self): + """set_forecast_origin should reject non-contiguous series.""" + model = HyperTreeAR(p=2, freq="M", fcst_h=1) + bad = pd.DataFrame({ + "series_id": [0, 1, 0], + "date": pd.date_range("2020-01-01", periods=3, freq="MS"), + "value": [1, 2, 3], + }) + with pytest.raises(ValueError, match="non-contiguous"): + model.set_forecast_origin(bad) + + class TestHyperTreeARTraining: """Test HyperTreeAR training functionality.""" - + @pytest.fixture def sample_train_data(self): """Create sample training data for testing.""" diff --git a/tests/test_hypertree_ets.py b/tests/test_hypertree_ets.py index bcc9896..82d3895 100644 --- a/tests/test_hypertree_ets.py +++ b/tests/test_hypertree_ets.py @@ -69,6 +69,24 @@ def test_invalid_freq_type(self): HyperTreeETS(ets_type="trend", season_length=4, freq=123) +class TestHyperTreeETSSetForecastOrigin: + """Test HyperTreeETS.set_forecast_origin delegates to _store_final_states.""" + + def test_delegates_to_store_final_states(self): + """set_forecast_origin should call _store_final_states.""" + model = HyperTreeETS(ets_type="trend", season_length=4, freq="Q") + called_with = [] + model._store_final_states = lambda df: called_with.append(df) + history = pd.DataFrame({ + "series_id": [0]*8, + "date": pd.date_range("2020-01-01", periods=8, freq="QS"), + "value": list(range(8)), + }) + model.set_forecast_origin(history) + assert len(called_with) == 1 + assert called_with[0] is history + + class TestHyperTreeETSTraining: """Test HyperTreeETS training functionality.""" diff --git a/tests/test_hypertree_net_ar.py b/tests/test_hypertree_net_ar.py index 29a77b3..c7e9d19 100644 --- a/tests/test_hypertree_net_ar.py +++ b/tests/test_hypertree_net_ar.py @@ -98,9 +98,51 @@ def test_invalid_n_hessian_probes(self): HyperTreeNetAR(n_hessian_probes=0) +class TestHyperTreeNetARSetForecastOrigin: + """Test HyperTreeNetAR.set_forecast_origin.""" + + def test_updates_fcst_lags(self): + """set_forecast_origin should store last p values per series in reverse order.""" + model = HyperTreeNetAR(p=3, freq="M", fcst_h=2) + history = pd.DataFrame({ + "series_id": [0]*6 + [1]*6, + "date": list(pd.date_range("2020-01-01", periods=6, freq="MS")) * 2, + "value": [10, 20, 30, 40, 50, 60] + [100, 200, 300, 400, 500, 600], + }) + model.set_forecast_origin(history) + np.testing.assert_array_equal(model.fcst_lags[0], [60, 50, 40]) + np.testing.assert_array_equal(model.fcst_lags[1], [600, 500, 400]) + + def test_reanchor_changes_lags(self): + """Calling set_forecast_origin twice should update the lags.""" + model = HyperTreeNetAR(p=2, freq="M", fcst_h=1) + dates = pd.date_range("2020-01-01", periods=5, freq="MS") + history1 = pd.DataFrame({ + "series_id": [0]*5, "date": dates, "value": [1, 2, 3, 4, 5], + }) + history2 = pd.DataFrame({ + "series_id": [0]*5, "date": dates, "value": [10, 20, 30, 40, 50], + }) + model.set_forecast_origin(history1) + np.testing.assert_array_equal(model.fcst_lags[0], [5, 4]) + model.set_forecast_origin(history2) + np.testing.assert_array_equal(model.fcst_lags[0], [50, 40]) + + def test_validates_series_order(self): + """set_forecast_origin should reject non-contiguous series.""" + model = HyperTreeNetAR(p=2, freq="M", fcst_h=1) + bad = pd.DataFrame({ + "series_id": [0, 1, 0], + "date": pd.date_range("2020-01-01", periods=3, freq="MS"), + "value": [1, 2, 3], + }) + with pytest.raises(ValueError, match="non-contiguous"): + model.set_forecast_origin(bad) + + class TestHyperTreeNetARTraining: """Test HyperTreeNetAR training functionality.""" - + @pytest.fixture def sample_train_data(self): """Create sample training data for testing.""" From a5525424309f43c32f0c7d7076189f3239a59448 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Wed, 3 Jun 2026 13:07:22 +0200 Subject: [PATCH 11/26] Update to reflect code changes --- examples/Forecast Intervals.ipynb | 82 +++++++++++++++--------------- examples/quickstart_forecast.png | Bin 279886 -> 0 bytes 2 files changed, 41 insertions(+), 41 deletions(-) delete mode 100644 examples/quickstart_forecast.png diff --git a/examples/Forecast Intervals.ipynb b/examples/Forecast Intervals.ipynb index 040fbae..409d040 100644 --- a/examples/Forecast Intervals.ipynb +++ b/examples/Forecast Intervals.ipynb @@ -15,16 +15,17 @@ "\n", "from hypertrees.models import HyperTreeAR, HyperTreeETS, HyperTreeNetAR\n", "from hypertrees import ForecastIntervals\n", - "import torch" + "import torch\n", + "import re" ], "metadata": { "ExecuteTime": { - "end_time": "2026-06-03T10:49:29.856557200Z", - "start_time": "2026-06-03T10:49:27.466201500Z" + "end_time": "2026-06-03T11:03:41.442314300Z", + "start_time": "2026-06-03T11:03:41.384622700Z" } }, "outputs": [], - "execution_count": 1 + "execution_count": 9 }, { "cell_type": "markdown", @@ -38,12 +39,12 @@ "source": "df = pd.read_csv('https://datasets-nixtla.s3.amazonaws.com/air-passengers.csv', parse_dates=['ds'])\ndf.rename(columns={'unique_id': 'series_id', 'ds': 'date', 'y': 'value'}, inplace=True)\ndf['month'] = df['date'].dt.month\ndf['quarter'] = df['date'].dt.quarter\n\nfcst_h = 12\ntest = df.tail(fcst_h)\ntrain = df.drop(test.index)", "metadata": { "ExecuteTime": { - "end_time": "2026-06-03T10:49:30.269936100Z", - "start_time": "2026-06-03T10:49:29.858888Z" + "end_time": "2026-06-03T11:03:41.839362700Z", + "start_time": "2026-06-03T11:03:41.444279200Z" } }, "outputs": [], - "execution_count": 2 + "execution_count": 10 }, { "cell_type": "markdown", @@ -61,20 +62,31 @@ "ci_levels = [80, 90]\n", "n_windows = 5\n", "refit = True\n", - "device=torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "\n", + "# LightGBM parameters for all models (can be tuned per model if desired)\n", "ht_params = {\n", " 'learning_rate': 1e-01,\n", + "}\n", + "\n", + "# Neural network parameters for Hyper-TreeNet-AR\n", + "network_params = {\n", + " 'learning_rate': 1e-3,\n", + " 'embedding_dimension': 1,\n", + " 'hidden_dim': 128,\n", + " 'dropout': 0.1,\n", + " 'use_random_projection': True,\n", + " 'rp_embed_dim': lag_p,\n", "}" ], "metadata": { "ExecuteTime": { - "end_time": "2026-06-03T10:49:30.300341100Z", - "start_time": "2026-06-03T10:49:30.275909200Z" + "end_time": "2026-06-03T11:03:41.854418700Z", + "start_time": "2026-06-03T11:03:41.840363300Z" } }, "outputs": [], - "execution_count": 3 + "execution_count": 11 }, { "cell_type": "markdown", @@ -101,8 +113,8 @@ ], "metadata": { "ExecuteTime": { - "end_time": "2026-06-03T10:49:34.012034100Z", - "start_time": "2026-06-03T10:49:30.303454400Z" + "end_time": "2026-06-03T11:03:44.301176600Z", + "start_time": "2026-06-03T11:03:41.856437200Z" } }, "outputs": [ @@ -220,12 +232,12 @@ "
" ] }, - "execution_count": 4, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 4 + "execution_count": 12 }, { "cell_type": "markdown", @@ -258,8 +270,8 @@ ], "metadata": { "ExecuteTime": { - "end_time": "2026-06-03T10:51:41.107698900Z", - "start_time": "2026-06-03T10:49:34.112062900Z" + "end_time": "2026-06-03T11:05:52.872430100Z", + "start_time": "2026-06-03T11:03:44.519536700Z" } }, "outputs": [ @@ -377,12 +389,12 @@ "
" ] }, - "execution_count": 5, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 5 + "execution_count": 13 }, { "cell_type": "markdown", @@ -394,17 +406,6 @@ "cell_type": "code", "id": "ecfaad3c", "source": [ - "import torch\n", - "\n", - "network_params = {\n", - " 'learning_rate': 1e-3,\n", - " 'embedding_dimension': 1,\n", - " 'hidden_dim': 128,\n", - " 'dropout': 0.1,\n", - " 'use_random_projection': True,\n", - " 'rp_embed_dim': lag_p,\n", - "}\n", - "\n", "htnet_ar = HyperTreeNetAR(\n", " p=lag_p,\n", " freq=freq,\n", @@ -426,8 +427,8 @@ ], "metadata": { "ExecuteTime": { - "end_time": "2026-06-03T10:51:47.231785100Z", - "start_time": "2026-06-03T10:51:41.694186800Z" + "end_time": "2026-06-03T11:05:57.077793500Z", + "start_time": "2026-06-03T11:05:53.483648300Z" } }, "outputs": [ @@ -545,12 +546,12 @@ "
" ] }, - "execution_count": 6, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 6 + "execution_count": 14 }, { "cell_type": "markdown", @@ -569,7 +570,6 @@ " (ht_ets_fcst, \"Hyper-Tree-ETS\"),\n", " (htnet_ar_fcst, \"Hyper-TreeNet-AR\"),\n", "]):\n", - " import re\n", " model_name = fcst_df[\"model\"].iloc[0]\n", "\n", " ax.plot(df[\"date\"], df[\"value\"], label=\"Actual\", color=\"#2E86AB\", linewidth=2, alpha=0.8)\n", @@ -601,8 +601,8 @@ ], "metadata": { "ExecuteTime": { - "end_time": "2026-06-03T10:51:47.623984Z", - "start_time": "2026-06-03T10:51:47.333884900Z" + "end_time": "2026-06-03T11:05:57.460488300Z", + "start_time": "2026-06-03T11:05:57.213149500Z" } }, "outputs": [ @@ -617,7 +617,7 @@ "output_type": "display_data" } ], - "execution_count": 7 + "execution_count": 15 }, { "cell_type": "markdown", @@ -631,8 +631,8 @@ "source": "fig, axes = plt.subplots(1, 2, figsize=(14, 5), sharey=True)\n\nfor ax, method in zip(axes, [\"conformal_distribution\", \"conformal_error\"]):\n model = HyperTreeAR(p=lag_p, freq=freq, fcst_h=fcst_h)\n model.train(\n lgb_params=ht_params,\n num_iterations=num_iterations,\n train_data=train,\n seed=123,\n verbose=-1,\n forecast_intervals=ForecastIntervals(n_windows=5, method=method),\n )\n fcst = model.forecast(test_data=test, level=[90])\n model_name = fcst[\"model\"].iloc[0]\n\n ax.plot(df[\"date\"], df[\"value\"], label=\"Actual\", color=\"#2E86AB\", linewidth=2, alpha=0.8)\n ax.plot(fcst[\"date\"], fcst[\"fcst\"], label=\"Forecast\", color=\"green\", linestyle=\"--\", linewidth=2)\n ax.fill_between(\n fcst[\"date\"],\n fcst[f\"{model_name}-lo-90\"],\n fcst[f\"{model_name}-hi-90\"],\n color=\"green\", alpha=0.2, label=\"90% interval\",\n )\n ax.axvline(x=fcst[\"date\"].min(), color=\"black\", linestyle=\":\", alpha=0.7)\n ax.set_title(method, fontsize=14)\n ax.legend(fontsize=10)\n ax.grid(True, alpha=0.3)\n\nplt.tight_layout()\nplt.show()", "metadata": { "ExecuteTime": { - "end_time": "2026-06-03T10:51:54.457534300Z", - "start_time": "2026-06-03T10:51:47.834860600Z" + "end_time": "2026-06-03T11:06:03.607815900Z", + "start_time": "2026-06-03T11:05:57.608386800Z" } }, "outputs": [ @@ -647,7 +647,7 @@ "output_type": "display_data" } ], - "execution_count": 8 + "execution_count": 16 } ], "metadata": { diff --git a/examples/quickstart_forecast.png b/examples/quickstart_forecast.png deleted file mode 100644 index 0e53b44e82919b0ceb593e776b022670d4c0ff9a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 279886 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ł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 From 695dcc7eaf08096dd9011117d911df2fb0ffd46e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Wed, 3 Jun 2026 13:07:49 +0200 Subject: [PATCH 12/26] Update to reflect code changes --- examples/quickstart_forecast.png | Bin 0 -> 279886 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 examples/quickstart_forecast.png diff --git a/examples/quickstart_forecast.png b/examples/quickstart_forecast.png new file mode 100644 index 0000000000000000000000000000000000000000..0e53b44e82919b0ceb593e776b022670d4c0ff9a GIT binary patch literal 279886 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ł!;L06_yj|MJ7fL!O`A-htc-^YJ6dk0{??m~y-Fcw5&EVjv1U zn3$V3vGi|U0Ngdt;#$=^OV?TeSlj6iDUyp<+RfmSDsf4UEmwQMS%b=I7;`fE1RbC< z$6SV3T01Uqr;LQnN3t7r*p|3n-aX9RmO=h^>4W$i#sQDB9(|p4d!BtH)nBkRsH_z6 zghwv!uYC{;rn==>BZ`chkt4H7VEZ|t8+sXT4H)~eFp{D!w`UvfMd^~4`F45zywS|W zPJ6!ziSRD~8TM)2tox74QPG99>h_A5GH_@N{6f`;qpIn?tt1w8GIaoF#5R|qgI0ab zGAop9CYMo1+{DbJ_iYQBKm6P|lKGI`!B5|N0@NMh^0m|EK2eg6+X+EYu3`_oQG3sa zH=%rQSS2D^ay(<^(HX5H6;3vMI%i(5Wgnr-1cny7kxa}bS?1%0T#owYU$vt^S7G0bqD+y$2hrGMS~5y9a_17MNKP!cqw_v4G}t zf2SEOP50Kx{`y38a|wu*Jj7gNb)VBKNLVNUcxl^uVCS1pxto<}p{kifr*GeI6kzJ) zY6Zh*ty+(Y3X97&E`TS0B+K|u#XEI`g5A@;>31^iCGTNs<|ui?6hVCG<*D7*zP3&o z7>nJH)6HrdSV$)k#OomU5wrh7|7dC8_JdEUbGYk3@ttC}xIMM$7z78X97mo{zDtwT z^pBLUr(2LlcCCO0?-Z4-TI zPOokS&ep#0Y6;SCUA-hBA(5Gr?*Sr45BMDXrxtf)b7qJDHD(s(_D}vqb2o-C3U@r# zLcf32LDg^p44%y!8JJ>wY9;fH>v?xG8*0UtKg)vUYr%E9x4>|GZHGZ8_Ljrbdu62E z2!vj-H-11&5{FozscJQ!;P+H=SCWZL3h-rJ%x#dOs1cQIazp#m;3|e~5Gutrl1g`yMf}!J5}asztbH@tqrH&3l&D93EJE>_r5l?dJwOl}F9rVYZW`oDamdEd0E|^oS%0 z(@cV=0&eo@1-tyNXpaT|jZqb*`9IAgm6Fv`Q(+$-EsEFA8M?F#oRf>MAQr*#d&o5m z8ZaN7!Sg4ouV{h9bCB#SXjuBO!gk98;`nt^a_z_gD!T{z7qg-AEqTgbIUQQ^3=(5L z@&R=wf;O){%Bmlm_$W&|JEeDE0{#`LEdb+hz3^m_hn0K9|_ozIJ>3-)}eN^1>r)ZlVM zW&3uB?NwV&K*XxX?{X)N^?Us-88xho~U-6SB;)iyO5WrT;KIyBzbZ(j3ieq zmI?hmTy12#^?PlOT`r=n`BV2HbLZgTAgS(1bq6T#G+sLU)2*wbqT2VFZmoM*#7pO??+#$tNDN+-FV+HfDdxX7zZ$!`n?V&eEv$IG&dp+oq zPTwRb5@BOC?z${=q-d-N7KN_P7ys)7*4lxzvi^wS$VE0Q>W^OdZu#`er~=;r5Ujq_ zYU(`+=4ROInPl|%=y`mU0>Pmat(u`fxEy%N(59G zeFZ$~S$peMVwE{&7u1^Qz&FEV0lJ14v|c`9jlml1?oKe3Et$X67rT<+{6Ta5IVrgH zlFnddn+Z#|35LNQZ>r4`&^|r^X6N`juP$haD4DVDx%!pv@?-I}@9Z;7#VBJXh#dX4 zj-LqUZIWWyCA`iOgBwlz8wK7!GLpO&28%6)wDs$d)o7Km4E;6#A#C=EM2NGkZBK?owep9bH|RA% zome8J)3`op&=ym zR(uArK7;mI2$qp7S#1!w>Fop7GW>~xOBS?$Qs-{NW7pPOlq?n(~7{oeK2!Pu#-2Lmzj2bfy>iQ7)rU6U`$X#I5hB7iyxr+wv1L+7VaLVch|NHYU%*jP z)Yb_d^ltuT%vy*GcqBQ`OibK_ScwlTfS}D3WMq3L2D|Xp;6LE87|j-0fcUM`o`3er z?BC!hY}NZjn$KuoPh}eZa;gXs5!LIb5#;ivmCDV*%$NV3Gm4#>nmU6PdaU{oTo}F` z@bIs(E&>tFdUWnPTk_hrb!Cz(@Tw8i(`ZsbX=lqDDluz?T}#5}Dqwu1eDH-E zT>>L>q63Ez42jolVUN=l;?jt;f1EHzRx`H8qn#C>7wLAC*X*Mw@4(b4p`j{cAA%20#3 z%UT_+w`Km>rok7w-l$abd*chK_p-qiXYp5mnX`xm?6OuwN(HAY#XQxO=wzhbaStg- z^xk*FZ0vxu9vAfV$eNh3TP_uKww0EaokE>F(gS^Z3>YIXI9B-WU5L3oB!wi@iiVQb ze=!JIb}j$rb*FEqawGqVV2#_9(hLb}N zFj02L(#2#2W^+qnHGFsaNXlxb!vMDX^d9ho`$H#E7+qVih%8TQNEZmd* z3nkP$pF{IMerH#jySFV~M2#z!=G%<>Uo3MOkv3B5vSSQ`-Ydxn_Z_%AP8sD^Q3*uo}2sNbEa@@?TOyzREgBI&_=;g+3 zth-S;FK^Wnzfq|>K~>6swy$izr=*06PlU+`<-+W0|DFW<#^dRMuPIcPcKI0$w2Pk|&p|6P z^oxPMr}{VnsKi}4J_;sjsZtL@md;f;k2s-}nZ1QiU+3K-^piiL_HW~8 z!)36hVN8y$=Ch+!jg<(jCF8NdVw0f9N0{GRnLxcU5$&qHX#VvS^9v79 zAGIZGL2VYePBmQsj&~$_wk>8-ie?|L zyc&0UQg(A56c9sDiRLt`%v}xAXOF%pZ!8I6Ix+hzCD2LB{Q#s`>pDsZcxGp5X~kkO z<*fiD6_p0Yhe$IVzCCVyFivoLCpt&HSwdZBs~^Hg*4~=A#~_dTfi$a7mYrMITxl=P z_gi~si~m=J@sUUPzn0uvk!_~9gUp`$`Gt)mgF*mMP~TdST^$h)9iV&bCVsUH<%qyS zII*qsh!iG6^N0k{1=ao9ZOTVYMI^3Vkw?I!#=_!;<${LbTe1Vvkc{IlfDLBCzB0Hc z7ZWrrigE;3!IEtOs6VMLcD@a3eZ7nx9Efse6a%L|#TD{h<>RG@Vjz0_aK2ib!HUsY zZao`_|3yO*B|WTrGar)D@EkZ83D9c&E$i=r+HbO!$SH+a^OTyoC0AD>Jn9@~h)vZu zl;Lj7*D7iZoenye(j!mv(rNV`E+l}FTE}fSVF8r0V{^CAx!MBq*^3scB4T2?w^O|J zBb!HzYL49nF=INAJKr9!RSx{?zJkIBqcfJXroYcx_?3V0@5&qsty~hHPm3X?k>vZw zAewEg8}TixLCm+O@Z#Z}XkSb6UZ*Y8>vg5Nj4wFCU!WaP6$ zS;*GXkXi@4$rDl?Q@Deao;uz|msN0>?p3XE#{&cJ8H92m4!fhYD&yupc~fV~OHEWf$MEfBz5<3 z2m1vhQ5kTyz__VVsH50`e|d1f5PZ82)6P{br^j+j0A)~A>xH)2c1_2NI86cH$Gg{x z8g*b!P=)@4VYd$uXxEY~gW;P;+^lm(OTgK~hi+V9!kpBf)u`QF$nlBd*784Z z{4SJkumm#u>->4&Mo2Rg)8T5?e79uoT|#xM8miuU40oSqU9C-uPP0%GxDf z(~rJ2qy%=1OFD{~&wcE3-HU*U6w=%dRyq?LD#6UMV2b-N zDrmGb2oA$D5H%ll^MVS4Y2YW#8|8w8tQXaszxx&5%HdcXv+Kx{Y;g*9<`Fa3Qamtl zcUqdlV%t$sze9&UueEU7P=3`1a#L*FOj9?LGoAyn6v|@rztl}|aJ{y+hrtTPG>qyz z!9mV#ds#kq^e|k6X)vB)F{;I&n@^-@xF&K zpd)?#-G?SZBzH5hJ~1E~v_PJK$$K1FajcBe7|9ksUNWSf27X{PDT&(>q(6P7hO34q zbHkM_!QkP@aTqQP2UM#VkN?JKr$rOrvtk9(tb(T}*w2?GC2PMp*Z5Tiod1~wgAG4; z%155=MANkNDx9eG@=ii7Ty+DyGIZ%H9xk1-7*?=#qZphu5@Bd|A%!)DX?D?*-H>hi zwJkcZxk`#+{J1&!;;eEZGuh(&Hueq6KtbgK*KrL<+{8~i=N&mWS8u|cn~%A~&8-;! zAu^H!Y}(psW0(_jUh-`0BWXi~K^RGCO&dn(yPQ*L4frW9)kiSyfCERGkg|6ssw9Z^ z;SdjVtPEh3D>8(npYVfccGlcs81AyU-_40jk9WVP*n@}cS0u&I0y+|hS(0a2#WA0N zI`Nlx57v_owgv65A2I5uU|gd4D{EzfZRI=%x?dzK*ZWmheV)3vLT3}{j_(MmU<(#s z*2Y^#WdK&)#VU6vf7FjKw+nV5S>Ed%Vx4P65Y$q#1s#$9IClQ)kVn=}GgsU5-;a*{ z0R?pb)*V%@nwIUAi6$OaOqFXvyu&woQ?@uhe+|L+s{mznBop7iKaIK&P4a+Fj+9j) zQ5vE>(t&45Y7a$fxeZ2xlvph=%%G)M%06X1jQU~SDNW&O(WOj@AIf{x=saGy20{l$ zqkE0SV6QKJ$&$HGlCbIZ1fPC6wgVvNaAFe8%pSZg8^+rkcVX1md9lBJ?MB|c7)UO6 z@!u^bP4&PrFd-28WSpSyBC-fk8Vubs4PUum+=N-i?&){ET<)Z>HN*|NH@9y(OGnyg(v=+D=T4q5hMj z>KWV#@sCLh#2fM<5ey&D?_Zy#JLn3s8>F7v+T0d)TYHAq(CvPYznT&MtLRZ=Im$4z z**hVL#k-NGkWS%uN8vj~%9aQX-y|i;XUhMQ*h&;I3vQl0_4jpYNzm|NR?T5aYaI?& z>sxvOkJu=RP@!Z~*Zgy@i}#stbGt2w1khsZq7V=1awG}wFUTs{w_nxiRt|9iEq`1z z!CbeL=lE3B23XP2wVAXMn%y@wWm|oFoX!*9l|hQ0BOW>RJ=CYO9i<~iSN{8$+!6gx zKS#d52XM)ndo>>1=(S<1f(VA>uH;CXKqSmTS|@$O^qt_vH?&b?oiY&kx%k_HH==T$5O4$B_nFIyBng@)GfLi zq8LsT5;`n1btyv@$)pXrVGQuDXF{2Zj?fg`o6W3?iU8me6LSc~8p9>Xq+k99I8uDR z;zU6R^ccm$?hRYbA2K0oFd!4v%;K&Dxj`POgS`@P6~7g~0|h?=>po{(xlGDvXQN3l z5&T#W9c53u(Qk;p4d+@!-(R7#kYO%nzOKj8x1r$9mv>@v(a8M>fR6NG1bXr|I^A<8MpIU8QY2v+gi=MvB3e4(jMBxfj3IS)wty@r==tES@ z;3&&R_nf@hBcsZ2 z3@x)Sx~)RlVUcM!(-vbY9iG9xZpEqSf3zVNFc`nB&;NQV=CeDP%GC#qww3vXf549lJD#>@!bpb?4MsrG0yI_6joh^G`+f zV$%3Bj1ONSjk$P?Bq^Mncw~ZuVfJzlB}!RunBHMAEWk+Tlv|2Dk;5nx^UW_G$?H$H z$snPToiH`2%G+XQ6rOuq*qQysN9 zT1p!BvOIc+_~1^tlf!VqfTv!Qjxr|zJ;Cjq3lAk&xs}J&_y$ROY@AC9wklvokTWag z2~pnx=Ic%MmmqB5I5sSWva<6?!l_VGEAxJb$Giv~P$`j7%LX!ufPL z%US1@G@8w_kL0IZ80YdXsy~ZMaV8@IuWDmc;uig`o`XSV+v`>{@4`)JN1V9Jz}Xc@ zmw4Mj8I61Hb@X+QpI4&!YdP6<(PQ+R@KG%cD@BCFxv!VNgyZSYuGjFdFMWqr;9__y zJ(rTSFn%NBIyKkg1Ma63x0_@j{T1cd?J z$77+g=!Dwul6m^ae-k%#P=2p9<{d@cCveEitEwsL2*J6Vkd8X8LGp9xIkPkm z@;PYq~&T71ovwkTE4Gx!*B$uDC0 zl+FfkbX0est!^GeRs{dgm;i9CFIipBsCGkkN*|8T)cSqhZ#~FyAUvwbyOqb5bBH$& z74#iu>mcrXX;WS{X46~fT&V?`!|BP8D{|-Tf-9|+z3l$n1Iqv01A&_1 z&l+c;6D!tRsZjQb6Y*%%6(sm;w{5NF$gVPTZjkWSkNR`e6{C=^O>YdZBYgl0`04NB zp*05c>Sib>RD0P%Ic}Gn%!-W^Mj_k5V|q}JJ}xT7oQXw&79Fh+COX(RzOzVnv!=0D z;|wWM&un=2bvz_L(z$xThFU_CNfGmiNERF3d_X{9g-N?xk@2!>-Qz)kraL z;hAKc(ik4~t)Iy|ncgq~pS=+AgJ2QXmy*p*2ZdS?AQcA@Zl{b5p_sTiXN*=dpW<5b z^lJ~1`*s-h6=R}$bD>6Zag7&VIecqUWIL~2@ImzfZ0~P z*K?e6u>4_WQc6ms{&P}#OI*rJvkg12VA_%UOkJ?8M(gv8O2 zTBGChAW#EYI5;@Sn7QY2zqkYSqy2bs&y9+0>JdPx=@}Rz79YsV`}eNk@T#elKG~~n zaAfai;#(rrt={En4w*p`&@uuBx5*PA85|uA8e;oBAAyH6!8@GO8(%@O#YK4|FW>E8 z|M~sJn`ib^+E<5e40geJh$0fu5|Vqzx)0!A*b9(kMV}DpFX=U(*9zH4iL&CPh=y&~ zMZm3k<%iH+c)nrN=53Jm$v+^%M_Np)w^WN>cHVF=stsrADp+5Kg+ zB0B0%Js@-f^A>7Ll~N@!TF`m7#j%r&B5qH{Cr$RZJD5oYPU^8(O;LP&`1un6Z&%*F zWylpt!LQFEu%9+rdUVkF%AM^sDa|0%l4bKCjy*2jGMf5ucq$uV4`l3?M++=zusG3j zPAkj{e8y!wc}}`bTo`mnx^rE6@TAbf)P^d))<9@da&p8C_kqw;RxO2loxb$jE^r8$ z_u>ont+?#mx{B5CPg8MriUy9@xpmjJ2+%5rNjxzV3RTd zzm0Pc9gtei&PY!mjsX?oyZLhTTFPuu<AufYE7|^Kxz}sqT{(?iY>#M84l(A^a&;mVX)$rg^!LGxuWw_% zZ8|Nax*R0SghdvMSF3|$Vo)0Xhx;bE&+m>#Nj!~%jAOL@P`cv+@vzD28hlL zdlh&dsQ1A)R7DfmzJ*@B&I#L(IKVFFnywW^x zU%}#d;m?1g2qg+k+Cu?Lf8MPyucZr>epTkHaU?xrCi?rg{QvSNL%Bb<_1a)JrD&pt{s5UP!nhm zk{}x~+Lc1y(&W?aKSV4j)a2i$n372+ZrKCZQ`PWeG(RviQ-hm+9A&=f-$zM4|GDz7 z5A|F_OY{E1P?_f%^2~PQpU>0%{#O$Kg*wCy(@o8)Nc<)$ndc!m34hv-gtdfdKZ zm;!t9&)-7@he3#L0bUY4Lc&2p3BuRwbp|~cJ)lTAh(iSe2yWUS*KOSEuXjRS``bH_ z_AVIIH6cz<2wMx-<4u6#8bS$f1A0^`1%)u!n|)rsgoDhGMAQf%NU{0qb4eQNPsHmj z41%EQ>TTo`os;Eo0*p@TbGl5_dt2my(oxwG5_@OkUn=U=Q-q z@lO=y=U){21Y(zQDDc?BHhkH_9{qV||NIgZZR_7R@6SJ|!Fwy;dYI4znwBg!ZXnzS zRsJB6HVsPD)V5;S=5r0+$|B?ek}4`H66|Csl=bfo;Dc6o{_n4J_zlkRj5=g1;2$@7 zZV{4-yD89zZF|vw_Nu-+aQu=JD1SpKe&7Y_2{f$25EDx#31?^Lz#U)%K$fiu34ire z(*bmR+p5oUn<6Hc?pN!-)1cg!8vg#;Si^B1p6S6lJ@Vf`xfA`S%W?m2XTHCWO7!vH z5%TY6VeRAprBV9%SrqCs>hBQv^G~k1|7G6s^Rp-v>0c_Fe?I;H`R!?Yd?Nn&7RbL2 zKLu33A2QX_VJm1JbK*KXJL#F3rGfUy_V%s#Wr$PH68{XzKm9i0*`}r@8=M?pgqw-6 zabz_}+$I(wQ)B}jS?;HCe3WO&&)$+h{U)jo@Bi-YBAP|c_3t%FNC5JT*TDKv0L#j` z!IE}a#FGld!BP+%m>s{PPzL@rG$#)gCQjLuwd$cn9~VwDgS|lXF1{#JhdqmcK;-&A zuKo?756KWej9byJq6&*##wSpUG;qOhNaCM^=AI3hSn)fqrj1QZsIAiBq0R+^;&7iv z*g1TSh}Q7^hY!*q_eZL)-L$5FUoXqyb@#Z03s~6iWWb(4f*m1!E6zwT0_(`o3i58H z#9JibjwW3D2Z8^8C--DWTHeva$Ec?&fkowuK8_OQS4}?TZk<384`O+_=eaAR9Q-#420urh`<9}Wn(R#RfRPqpE zP`FyEJaxKyF3kl}6d^87Mi_1rF;(b40rNl;NI)!bTA}OfPd7gZTXVAO-u9}=uW#mq zt)F%~iKWGZYd92(MreIYjwTp$1ONCOeMJ5f@|Z6chs z4B`orH;%mbF3CItJ^iVO(4e5Y=3m0+ZXYGnKHm=aSn>t&#q8ZO|RJ8_(KHn=i3JJVV72+b>3Rd#l_V&3WA@NN5Hm6 zzzieia!ZpFHU2H*%pBkh=uH7>fcq=M?y#bnm0ynElMAlxkq+~V?z(d^~@B|9{-;kj?0?7ya-5?)tA@y`lvz9~oE`!};StOlTNE6+OX$ zLN$~9M|?QR3vM2W-yo+47QCV&%}A)YuOhE&*0PJJM$Y-a9>4uxj;H@`Z!a2tR>ZXu zq6@_ku)}mZ{C-(GaDFxDAg}(-5-7Gxuw~I1uwmsQIAQA|`PYHaj@7HJ!u4WC_$(Lu z`}-MEs=*|S6C8$*8B;L}f|*qyvkkOWvp)U0tVQ3$wi*-@gI-dHn=zv9G{6uXZg?mr z7FZv&Pk_ANX0wfOexZ8oEVDH^Hc>MIATp+q$t`K z$nJ6YI}vWi(Y(eT53wulhw{HH_RSks#7GQOwEXM)NQ(?1e5KTlLR*NQmsicaC+jkl ztFNKHx&aa3Vjv?QpE__i40~FDU&p|}AOZGJNzl4d%0&wy>Q2zcmnKmDa`({EPyOBs zbgf$uvCkA_KwQ+mDojo&ZY-Ztf2%=S*6uh9nL7i7&XWd+nF#FCmrHYRMr;8-+;$Rm)E>X9LtV=381M zXB}-oy@S{(`^w^Wy!3j3PY7n(ew$*w0c@G68;GNoRRq6n3ewa=_#fn*D@m}zY=ENJ z1O*i0LYs_SnhEGvB6wz9Hn|(EyrYN7dPg9hANoq$_pYS&w$IVwoK|mP#&pZv>|lkv(;E zF&iw^&E z((5EJUSkXogVGWQk^jft&Gc% z>~G9qfzO;zW`IRZ?ZDhyVhz`#QM zJw2a5eudajGa`_k3c@Po7tqCj38bT7P#HEul9Y9tUk*ozxK*XssFyAq ze8K!98-UdlXIbaiU)FylVDjijTK>@*BG@LMpL~!1h$_LND=lz-#ZP@SO30}=y-+<8 zOr1-`H}7w+PAiq!7{!L2k>D}wtXCmx4GRo3c=GDkwHW=yrowPC@C{>DYAtp*FGj7? z&&Qvmy<^%J_KF|Z=MV%(1!%{A<9MY$1hz^^kQW`z4Y|-jX>aJM|2y3%r1~P%abAexhf0ysLX08crm#qyXQ|00+s9%ASRBdb@S^EAmKQOSLPJ{R@ja+LZA@UwS zpTs&ER4(8t?u2nSD(VpXbl6-kuRZ*6zx9DhX$TlZD1o1<<<>4(C7mjBL!bw+SKCD| zScip%8u#R?vF*Z#+>300@Jy}8_S4^iZ`~EoCn6RizJv1!5kATc+!|hi(fJu5@xkgW zf-3jI$)1+xHckU9fe(qShQhQ$#lqixtpPWEQZ5FWaaLxnu({*sei@OS`C832P)>n|D(gZm8M3?}@ zw47epH_t%9uAbYS`CJE@qRW7+pO*b8PE}@#pR)g4<3YDE+m-%p!{%85!aM)qPt8(R z=Ahm~C=Lygi~j;O#LYDpO+R+f8DPVw!pRJTD99=9?JF6aaECs(`^nRkq;{VQU<4nrf@f9tsp zQ4-lAI}1z{%%FY1ZQdmb6A6;QcbD;6#QoYQN6<&vehp{AG(9-CMY%!k9}788Ttngg z`}&AUajB8bk#p+)rNaw!-(2vJl+yDpLc(GI6pzcvdriqws{rwmJ`0f?rWa7H})SoNhWfgtj=>*KxQ2;EdKnNCc%-RDvCj z2eyRep>tT&i&HJb-dw)kW;^^fbZphIKdM-rN(DoE`OM`B2mYLBqFr&+liwh25-Niy zn*Z3?E^aGRDcKjv{Gu&4zm?DCyhb(&$+fDl9#~MIY9blMlO1qT=B4<8v{vMCM~D$Dh#1x}N+CKHWaOLOz=@tp+d#7Hcd z7#cQ)vN|NEW8)E*XXo75SU0aw=MZKJ)-c^j0C!ptt)%0xMas$P<#&!|{bolDuzzH1 zY-Bw+{gDizOv7Q1hm2WasXC)C!G2UyzRp=pykhOf>eyBl$5%8_<6NG7I$TwIy z=Yh~nXc~j$5eW7B_z@&hK?_>LaDZGv@WRfAvx5tgC8}Vfzh@LYoO%rMY?su?M>i(N}(5ol8PlCK+s6o@?CEsTZ&m73z}G#=fx8 zNDW^+OKN#_BavQuMkVLozIpP8bC3MT%5B)SaE0wfS6=x0 zhXQe;y0H+vD%JA~{OqrSWNv|Oqv*vZQhG#0IH(6(OZ%N>g{53<8KJi_{bSE-7utwU zKduo84DDu+rA*+Qz&atmaSuF%8WEoK8m|k;;hh~te);IMK_P^*$rL2B5I&mxgQ@c^ zdpXI+l%H{uMl7L~9D|N6FsMlf7Z(jmCz`*c=M_-9OaDQo+t#N=Wfc`GH3D(|4 z;&B-0U4PAlwCHqMwQ(C&8TeTVRT%?{fpiiYVLNki%mp1?7~woZ)@R7La607@0Z^c` z5Mz(jpC%#waeQ|XD9k{2VdSLIY@DO}p`xv=_H?kHabDt4r|*@@M> z@Kq>}wzRWlWkf2$ZbCw0>o@4w1VzZ`pAeOLdm4vAT>zIM;n$#}q{Fe5em-=20@@7s z&3dvT5R_X|(F(}b5-}T)yG1E#e?bj{%ry!6u{J>cZ-Sd82^cm={e|1=9^XSG+lq_O zlnq6gpj}2Cil0F`cMqLwM*~SA_YDD;Scoi9R}bl;VPmVh@I2Dh-|p6f4bL^R2JO{qXh#&a#>z5465 zrrGh&9hG0Hsj6@dD~q$XGpgB_9y0fG9I#zs6Zk00V}t)OF-SdFg$TyByTY0 z7FE}Pi#ZP5WIMx=0iScgbP@#5&?7kD#bU%vsH#|YV-OlctsqI+IG|ObAoyq*I@Ari zpfVV1R)#u1-I=o6a%l?? z{`zC`hj+CPWTX{1OLWws%xLqB?2I$VSC(q`l@ACtZL&A=YnkWt5K4|0s^~>M7nDe> z0z|ABCM9fv>KN+UnMdEhJ1~U5x$3w&MYq92pGq<5YcWumo}R%6;sGE3^*w9yv)Ya+ zNZ!Urv2!TdpbCrxC1JbiZApoj$X=Rc(WRv7yAFDFXCi4(-V84zMxML>zDC!axn&k& zv9dHV6>1}U4gr;whM9uZpWS!gZn)1~%fGpvI?rc-y{LKH@a8f>e^hy|=NfZ^YG_Z9 zmJDu2PKaQ!ur9`bzI(=zS?D?zX%TE8Xvyym0Cvz{N;NfEgh*<=3Y4Fz3y>@>Yjm^g z!LC{P{lnROxM7twb0FR)d-nqcg%KeSB6mlZ5g<{%Kdd~Qw`|HFNlyk2MrV=~`ASt) zXmHP3;obK{XCP+OgQYFoDF0;iMZ~Ud2-I0$*|SB{DAu{H`v4UfoSe3q+S!8^(K594 zlo|h=T=Bo_mlrr|)ADUJCs<^i=G4Y0&c?=;{_Ij)68^# z%CpoKVvgAs#i7g(RHb!G-f}odNWmD3Ex6&`Lzqf#J;m$W25wRk0K-Q%z*dt5Dk$d~ z3)!2h(1>8?%m#~Pv?>L@SO|>`_o>vKePH^IL)wp&JBUAG|A7LOQ|W*nNU*19=6DfP zHiJPRQRtnUzQ`T~%~bv>dG1f8K)@=HFT|vQX*|paQgd9NGwUI#^Rrsn)z2>8s`8e> zqt)oBKH^KW2o|Om`@BFI;90)I%8JmLF5qqZDFhs{iiuQrp?##W(* zV}_Eq?7by}!}ZZ2o7`r&RlZ@a*2n$=A+wTL<~4f8f%3j*6eLp^fzqZ{?We9hEWN?C z*#t7!jI|{D@d2alE!5%LG>vEJpF*Sb*7aiDayyO^{gex305*gS3h;lgCvW?8$M(R{ z5g~S&Ti}4~y%hx>4Ew^M^Yy2+7PZ#Eu87`HRL-0a0E8nJJM{->_YB-ZZ(2X^)**+GdEK zF)#ItC%Sgi10K~ZbK~VJ8J8pTV!Y?*n^iuvgxS$+^(^|V z?6}B=V5gWMmMBA2fk18ldJt;%m$C5&#~3lsmg#JHU@JKtJMJ(fa%C2)26eq)svePH znVS|Ys*CZ)hcElxzOE?!0cy2hQbFWx#ky-(Wgi?+ciQ?~UmX3KPXeDx+;!x4_I<;- zuL%dFbK?`?%&uqn9YXdBztW)6+|2)@W$RfAe8Wais97+_FkHG6WrmDDf=Y7b_qukE z!pcw4x7N7DQ>6rl_wQ`$1wUlKx?JYSf1sCDhW7PU^c`^Ii zuy7p&mX-DX!5-C6i_|9W`RXXm7Hr={|& zFYm8C@)BBclQ36(C{@xEk^GT`<+fq}#HLa#B_*{9^W6B@#F2GQo8{0O_|7P#9QfDc z!Zchtp)hTh*)nmz*$5)1J6ZI81c zwtpm^gV5>MS4ki`_Fvumx?9j-MToMy*SWaZTPe<;zrP;?_63L6>tut{^Cm-eASFu{ zqDT(JG6gb!w^~tWsQ0nML@w;Xq%yUzR>WyuMthK^{U+2L-Gyo{piEvH2+D6S)!OTG+ z-yBA&Eq%iryK%`%S>X=V<-4j z+Ip6`2**bgqs-fjHR$fU9zv>RLE7botydn7oaw)l54YS_2?2`y8#x0Hi)s&OWfpne zE;%W0L}oZ@b+dC_dJSje_)a=juavWG`Wt-L7xy0((AJA#$TxohZuG)uNqCwT?{|dZ9Q?K+n)Pv9ti;}j0 zIX%W&U?rRWDkb28^SQ3P7;Rav>m`H9<7=($) zU%qZAzVlmW_QT*-w5o)SbkqD^J_q{aOfXxUIX6pqibqXW^p*aHhGAVVa?K7om7jC; z+uyG{}brKua3Y14#+_SFy)Z(k;Y>=3duB^zN~1B`^%Wp-b=A z9-kCCYj}_{pMMDx(0^&!%rsZ`jlGRhi!6C#!RvYH*Q;3>`8L{>cIF-RbGNtRMOnXw zMaNi_E_v&v+`kqM%G1zGDBC{OLx?q|&gkmMq9pTWu4> z9SfU+HD)Vg>c!tTZLdBuQr?!`GQdiHGjH2>9fk;+6$D`|@a2DI2i#yYFBE228f5gS z=Luav!(+*|Il=q_S{-$s5!N@6CR)O|N_KK9kKB4}wx(-r^CuOv%3}2l*oCeS?+QiQ zc6lC!VEobf8tTGdM&tiD2Cy`V%*c{hZsgFUVB4z9yOnKi1Vs5x%^r%W1SyjiAW4>`H{v7N43In}4!&0H~FZ>(8NvA#TBF5z!1;j^Dg zYC;nVrP;AXvvFZmAS*(l`1fN;0=A+uGb6ZNSkL6(9|&$f^1)8+DmlIH%2ra3RK3rL zF)zCOy^rH%zLAqn7Cm*7%#Nxro2G$+k>PEracK^^uR+1BrwYz#nXzBziy}EDe(jLc zg$Y2Jf{;ETWcXmRhq$C)fiBo9Wb_V@&gg-|DYYMF!#|F%EqgXwEa3K>>(J z+o8&zpPK9|eUP{da?}Z1z)_^2wnFd&#Mcsb4(nCyzm7)qnp&?dl%1jH9+i)k2SiS9 zsV=J6b%`)+_~$;Vw96X36RCEeS@mm1-$y=X>7?6H$0I7reM@!L;p#?EU;6$4Qr}6N zGI}mP<)N><-RpM~cv_FrlKs|4j0e<-K)|8Y&`$F_{gn;{^DEr?y?`9>1EYT&`0&e) z`+%5*0h3e@8FVEjBU9ik4@J`W=)r!;@w2?Lhd5w#@fH~Pvb2P;mpBW85#EP@^X!N( z0|XDgxQ#=!oFJ86*<+Kvo?OeTa5xs~Cj^9OncpiM?sXxixYrzf*=D7Uk22ykCFP~- zj~0TFnrXziFCADb2*If`75zL8tj!UW+N?9lN5zv#=$m~b^kUjJeu<#hE?#E6sgnR( z{kb-|d}nz(bf93OIu6}gs&y}SLKmB_EpHmhfF#l3Y0_k8Ro{Ca@@si0;nzaVaGNtA zJPr~_P|EqU073L*E#cgeGGyiwqI&BG2q?Y1Tlyg~?g~ImC+a?JFei9H#UmXQlyyRW z3+a;}TtOg6HG!F#d7Vd9Blw&^pQv$l8Yd*o&cmY`^4&Tg2_)5uQK1{v@1K zwiGq;CTY{5=CS;;PC0jeDaZnEYs3OKq}a#+{ZGZE=IfxIAWXlUq3 z!-(T7D|rU)>YEZ(lftZ7pdXKejRPyE5KJ6JxPs7}x*CFi;=Hg<(#$Ag^f>CelZ^-* zCfk8^R9OJXfhM%XFt2h2@txEP&m*%9nt-;1*k{?)9-&m3T1Lf_^|7G)gZ>$F>7<}n zd?qnQ&-oUx%_s%Em(uf6Rp*Bo^GfuRX!9vm>9W*$ax&=a88^AzTwDTpBbK{onw2hR zcqcXGkhOP|Sjz+_86`*TY*DNO=DhEA6?Gw?2K~wrSPF6y5p~=(h(krQJ03of0Pz-_ zZU#gZgG@mNSEfm&$y@_Lk`4;e*&=WQjsYiqz&}iH{C*z{+mMD;Gl-XUmMRf<7|&yV z?6GfP;!T3M#v-6ep#cAlGCmGJKZBbzWzruk#u#e>YxPWUwf(#n`3ycPI2MMcLFWcr z>ADXMbtafiabyEH0;U-W4nR(H6=uKKoKub#CRqke3erfNo0_QtGYQtz^ZYjTt7f5W zy3B~1_j0(}NCk`$L8gKsuG#5?5RlfK^t$~{{Su5O=_zvZ!klQ?b16g4_mcY@iz`Q0 zMXKs3RbVp8t8{L%VJoUfzS19lP7uv{47j(BxP+?W8u<^9@K#8C|K83UXpv|$60 z#~=g5B~pYy3T*@Sa1;@zsi|2(LiGwXYT+JB$oL_`X%mabjea4|AS^^RkcQDrJ|g&&AlRD~oXeO=gO1ma3D|~_YAd+UFwM`p2h1}rNJ$+; z$1yT8HY1*DWBgQ8xHuh$PTB+LPRezE{u(mPdw=8#V!=_y_Dh;hD7>Q_;M?-X;)%_f z9I=R})hs~TG;6{N7Lf@~UJ*=JYGU|q50z&nkyC$;CHX*0h)z>$Q}Eo-GPTn&+R~GK z#GGIjoDLl8>d*TCd$qPnX&t!?19&8#Tfy858a;BD)(mG}FVGC^ws?;6Ds(?UnqYJ| zAiP;ljQg;)fDTBR$JL<|) z?|&{?TAQ*VEB;q0uqPOn1w3zgW0Z1xJatW0e=&BlH~pNc7nW*W!Fm$g5#M@~@pfQD zl$4hcZ5`~5oVj309=P-Vrj5MUA>t^|^Qq?|{BQ_t8K3vT9>);$oyF}3U>(v*d*BRx zm{8c-oYv6q!=PE9iN*rI?D6e@4w&?DnNtp62c!Ei@`C26%eWcnz?4$uJ6?~0F|cai z@;^WDlURSRim$#bt);7QcZY*iJ$3pXq03Pm7entnZ!Px45Pi#}IHh!JSB}p0xSAM@ zmr&bm#4G*aB*PTRoauTso*Z}$M`ZkT0X6`2K287+=%wBV& zO6an*APX$1P7XS#tg(8PRP8WpS8w^jf2J*B|i^!FVnE^WUqm$icSp z&HuVQvY#EJa103qlb2>t0~o>I4}z)Q2;qn8fk$Zq5*j*L_}0#M!h=z<;)x#X^ih?J%VOd_n5W1G+)10OBr9a4a9Lm*`<*B?L_ zbl?PpNJG9b0c*~6Z%w@)`cnM?{xm}7>w^F^A#t?X?z*XV{QNiYlN$q!*LZJs2Mxpm z#D{HW_Tk`xaqnIxzcE(-?z$=u&il6bxl@J~`lGVU#(W9?(=sKjq4Lj1j!?FFwt8TBYU{-6R>#At68siD*DKK?e> z$@((M7K2LD%*hx!zMc*nw}rsWAMMchVz0TmiL9iQ0qAiY9UQLJ?Czf=^x2=czPa9e zT;OAvi0OzFcnoO=)@})G_J(;>!%o0T)`vUk_2z4U+0{C25CVrnvJ+X`D}8j_0+j$n zadbPr==;t^47A&2`{+ku?D0h~0#DRi!JS-!ju_E`#ne66ygDHWkl~Hi&6_|olW2g9 z#0H7sDb&}&$$ost^y(DYtRT}>rD^Tw`Ys?=RO#j!2gQl;1>o7CgiLlNPg@Bs4x|!m z;e+wPPnc6+$-PB_;4-Y}kjJ{fJbVI~u9>!(20~Q3I>>w=UX};OxLOb#4X@wdn*;CQ zBd7Kc#&ZF|-juT0r~%NM zXnGwqJC{OKuV!s-h;+deusi!OWT+XgtW_PbYa5X6_YaaH!tv-c9{Dt>5XGA<$uJ3~ z(ot@?(8QwwhwPORuN~j5!kGkbqwJ{_J;=Jb?vpgm1dyn45AgyGcclvGW+9@8#~2U| z>5xRijD5~DO?f95{1!RY8#__im#9c%fF#)pgRl!Ps?E~H<~YqqAqICgkZwd-C*-b{ z{t)*9|4aANz5_Cp9cMMOW2TMXY`E#-^2NOGeaQOFdtdf`&K^;yC%Q@*1nbZfnq4Gv zvSPI{VICd_Y#_G#Yo?Tr>@;QehKd0@GqV=6gld@V#sxo< zIsFsQ6-NS=BqDHlAK%}k*s?oW03I*xzcE+X!PvxYH#_hp7*@a1%6kT^2;3l^oz5t{Qt3gkQT^YorNCS#_uCa(5MLm$MSb7^4q{gWjI-0NhOGjQq^ErF)g|xL}2>3kvVJ9 z$Gg;S$84O1Wccww4;6E#^j&DG?QKW+>W{z00!c$&`G)#vMFI?w(SdQsy0DLSvz!y} zw0@oHuIJE6Wc%Jhd7f2esw(YgE>S}@rp2sN$ zdJ1?vEJ*sgRRx7rQOfXJ;@Qh2J!a##T&k*TuV#z!S$`HKSB!z#o(*|u*T*{eZRO5X z0;}SK9}#ZvLiK?wxQ|Mu&x(m;x=tWQBq}F{s$41*VkI(fnGfb(kh@>!DE)M%JRln8 z<)(aP`o|6;o`G)`@wM}D^dQ4+-J`PTTx*?n@u~ePK9(FzouxlNi-&$5U@$k*@b-uPfA4olv0lLk>`eS%m%L-QqlT+Se}? zujK`rJPC=RJFMe_`Ieq)h#QlzL_ev;G;lG>f+1J_VoB`!wrH*c71W}>8cz&?vnwXBQ3G^sn&hkEax51 zR^r+dx(R^wzPRD^4=SQ4{a~zPmr5_r*FJ(RJ5OCjHoj1HzPSkBF}Ke&Q2H%ZU#7uU z>BOO7$ei2cc{Xr1%TJsDnQEla?jUw|J9U08>jEXUXSQm*bRu5aZ5oGq&wcK!JK0)1 zEtBAkn%lSsCb-*$$G}&L76u|f5vY81Ni*{d@Gz4aSAZ=ldnCM0)fxs2FXEgiVokmq zZ9Mz5n%r{Rrs{okDm+ZAmr*!e0-yQbv{HL%@NP6C;LXAC~o);P&D~g){He*AO29Z z!YJaQ-VA5N!5Q(TFczi??O5D`YipXZNs*&b2u=rO6Ok5`8CO!~4a+#%Odn6)TBF!6t^&CU>-tbtM#y{mq?SClI;p1mo8AbQX+%Z<~p0R zw9@5ojygtLCy=b%GFw#M{l5EI$@Tq}VK-!Q$r-`Nd71&BfMT3Vnbj!K{nBf(;|iqo zNNW=V$QF3wOdHkKT}SkI@Z|euDKefc72L z${k``=VSp|msXQMeebqAkxJmb5&&?HQE$2d0fr6-^YK1B$pdLw@R{8#{B)krZ|E)-b3>*?HrGmzi}fW%)S)jk2Zu)3K@Dg^)6a_iiU_=4)aDa$z*z z5#pYMMRO~u>-kBE3O^%&@?DPszKlsVw z?B&DWnQQv0`*iwBZK=NIo{PVb{WYYFJ3OJg+fI|`YJB(2mFX28_XNBf3XodV(tTmY ztiS|&`7JO#)TJwppHCx*11C!+@Vv$zGaY;Ov?v>QGAuWQaOIsN6&cQ2`a4Pkir!W^ zkyvt!oSEHV@VfB(l5VJMTIHsTAH!WCeRz@^m3o6y^_pPLY?if#LTu_6S`tA`RqO6S z*n02xgb>Uv2XIgwuYm3NhbW|AKKn*Bq=*ECSp4`{&6|E(+|L2nVQK-Nlg>Kmt}{&^ zIV9*67;W`zwN%%cX1wV9PJ!OeT_6oJh^bO_brQu=J!X-8XX=QH3nR!aRCuj$Gal;L zx6V*0N@PT8vAP*-g=`hZ^15u>0e!?)di6aOjQM7xjb9e2@NUR~34(O(-L%EtQ9MIx zI{O=H_@98Ja5M1aDtMj9?PPpWyiO(EwP^7@FD8dLTQ+TlT~;K3U~8b{{{2JGwUV{i zO}_(f>onvF^W`G9_Gg#-vTp+=AWq?34HZ+5a7nTH0G~P)LC?eV!FT@ay~KJa#dbW( zogH7~JBsXG87Q{6s?0(MhUrp2>V};}bl%ND#^m_AuRCh{_hJs0yUot7C|IpbCR4U7 z73v-OB3(^9;5xpt=KMP-X@9Uh5PrwcT#qjn4IVdxqF%FTmRPP9KU+2~o`WkuRoqO=$0t_*(vl;5*g>89yR-;zJ}xVf6WJEXls zQ(#gu)V4jbftfA+w2x6WX+2p%#B7RSHqC?gI-MH5OdRU639R$EiHAR3C-XYt;=yuh z=NP88QP#@b$-C3<3D5KIfC@$uKjkS+#XF1@-GX|Zn-Z7WN$kp_A0%fym0ds(Z^`}m zl|=-$j0WX}BS`8l8@H`>VRzgA$1A%SM;q6wg@D>^n_2{t?}f ztur@nN>eel-Wsf1N42a-}J zZyRf{hp;JYlXBr30LoIl3uBa-H~FW_a!C>+46r)j`jllT%G%Mo4$jhsB(p}|?S)3F zH=B=b2avmM<6;GbPH-oM&YW=De0nU~$a^inLo}Ko_aT27!gpunR+lW5jrAi~RWj4K z76t@57L10rXo1(7K*G)zP>i`I|B;EHj;pQhKX%fk&CjThOZ3KSJ(@Sq&8GhRwPuW${zu33_q89 z^0Y$gUhJg+-^uluZHW(Q+$)u#q-okUjYV+fHRaer`N-2sDrxwAbf9RP#a zU2`!nWqK%LN+>h{ugBWpulyw$SXnwJYM z%MUVx&vAw;POS*Iu#Lu17-OnkGQINn*tY8e3Ot*U(rzVo8z#P%EwkC}tUlj@2(McB z&5Lff9=0p#Vjt_MKEKoAbQ*=465g#kii+F(z5|{GwH~9uD?26PI!bxTjp<5lnq(^# zxt?WNeW8-V*|pW$;uh|#;&2C@s10crndI()a;;gr(E56V+%9HpR)9qSTBB~+Wz6Zp zz?-|53nZl+e2(X$_vY~2b2?`EcZk&G*U71i2+bOk6Z6nB?|U7;tiYnb*kM}9rW&=e zDz*gGgz%)JmNxN0GWl_W>%;3KS_<)qIT?8~Q$1{67^-lxRk47o#`~ ztRX&h$k5uBllFbgJ(F2}7|<@urAjxJ^o0*Y(b6p#Ldb)Rr!xEI55w}JXIs|$z#NPD zET%AUY!(^4jaLpciN;EibowwS=d^9}aSF6uhs2S^9RNyuJP(t5O!C`KghPL}FEq}B z5Ti4%Fll5m7&QNYB&xToYYa!kwdJ^0CyU0b}MWNngOTnELGxjDKU*Lf+9U=C(LC}t5J`mG)#zb z?z=!qal~%+8MVDeg&9w4*w&Gwz3`gcBb_U2etNrfXZmC+A)R+^T}wViRX(?{vEVOk zvR-(1*O@rWzrL(}7U)r5-!B3Y&G&ruA|C4ZbDM8YphUla+i>}wzCj=-$xh{0%rp0X z;E7{qj%t4Kky+;9kh>+>u67^3`TDeUK6r<|k}_K?scfNKX}~^UPPI|$N;GxdWo!Fl zUax|wGWzy~Fy|L%`Q+_EQd$^_we-NYt{L)v8NXOC%{ExP(c?%2&U;sF@d*n2wcahS zK@||Wo+)N(5yX2^Xlv|s(}RJSZcTj!?TOlUESmZf|hvl^+1qG zD4npms{MsT^2%u*zGp=`f<3==Qe}sQXO&m6e8(>F#O(Uf+gyI|q2BoWbGc};K!2i_ zS2};U43^}kt5vM5VLC_RH!N*;^moh0-5cbN9FFFSqSNocd+CT{hwTTGkF0a6yt>S_ zI>_yO^$;nBqg`lJBe(4!XC%NNLo+t9qRKh4S;(y=s_1WN(HYc%0nkIxv%_rKKf1t7_br0hbT-*yYZZ6=L`j0Doh8 z{X^SLPLZr9^Aejc<(3?B8u(BQ!to6U(7c6RoO1d+)7h>R>$0v{@yRqEs=9k4d`R>9?Qg)dKiYR9`uc=dc<`8S@h`8~EM@#p*(R$7=G>p-({3B-e`2$IQ|)=NP`LP9NE z4B2oC;ONG6xjt@(yY|xLK2Z%taT-a7l~DhT)QAoNjy?`V06vkUPix1Do|r>pIJoAx zb&K{c84tA+$C-rztqe=tdpflTeRX8dyQQuwT_W$@y`x4zWvJq?&OX8(+;FD-=Cy3q zuK{c=oL=t>=ZXr8!!Nj9i>UzC*m3#8>)XF!TxGDIwb*4#81D`{d`fa-#%}Tr3MlPC zE_4Kw=uN4lEn&9<^GG|b1gKN1UvMX-u0Amwjsb@Z$}ZC&i$T2OSE%edHi`g9A2@Cy z({V9Ckgj@f{(gacE^9pT=_`^>)zhW}I^6mtpf)%ysAsG%79}=2J3EM_1Ys@{W)muf z#p0QvdcN|pn^7an-%G0ZvWIymZ9d&Nx~BEJ;=8Dj5NdTVlh<21NLRpiHfJyPOyBJM zx8XMpECsp>gWcS7u_xft5v(IZVq}I=#krp5p4IeRj=kvkdGGWKmq`?;fpU>DK8M(9 z-i?d(QL0Y5fyt{S(A5h47`DB|u{OEjI4ap_&t~5{S>Qji$SIO}nreo%3(Pl7#3Hth z$TN2WT&O#W`+(Q5VTR|p_a<$!WMs9d4D`W~w;EtxLFc(|Rau7rP{+CN8=DoVCk*8E zs!1np@cOAn7ZW{@_6iQpVXb%()s;Pa<-x5sEKaNchQ30{d%6+D%F@POs%lc!Q^$M; z7Z!Rjc%Ke_>zloe%;>NWd?+Cyabv|qJ~q4mB3D-`Wi2J0ts}<%LB+7<;N#W1-ynVD z#f*p@a*CKmW-;CvB#LwE$g71(*0hL{NbC3X#FHc7H5S5~MWStyQ)XN{+r9BYtgii- zs;cVzhv^-2<7>&U6m=gF2y>2~wZna2BDpysGwS5TlBaH}k;}gBc0V__!e8COBGar$ z_F8bvWjZkVd}3?Z zaW;FN2G`pU!Q0fzXEG~(1HRK(2XyhlwR6MyFMqyeP*)XME!HDyVoWvIPm}xYhuO#( z`f#BIyWX7R{Vj@zrmy8g5aC==@sV}9D#Ld)?zPWq&>{!{1(~e%`kl|ru(KJLTn3X%>)0oGIw|DbXeW`Z>T$1YP%XdS#d*T{&Fc z>?cl}G#|q$OwG3ao`;koWlMF$uNUthKsG9;43bpbz!7<5zI!2f0zA?Q>xr1hUOf-i z8S@{C3hP-iDyTA8RE+V}P2`^7>#E1xybnWPY$}P@V7g@yv9_7t@cI3vXKc?ZxMkBY zhC;v53_u(iLs%fNUEHdI9{t#3j6&BEEU2tCZW8nHm6+E7ty}r56%}Y(tjj(h504S% z>)bI%VH58)?l~;Xqi=$~IUSPtn0-LhTBSNU_Ieue0A}ghYmUs~jApk<1(!t2U_yZr z_z5%_&&X~M>_Gu#UZn0i>d?n`QOJ3Zucq{t z4`vm2Yo)TGpSrVI6kTHtVJw}@pK%G<>NiLazA!GVc~5fJZ{z8gxMLK+t0hSFaC_+X zTT|txGc;09CNI^jmlJf@`Gx?S;Y#ow&uFCxb4oR{9SFjj+iQTYP(N2ntI~I zThPYuJ|XGCX)zj*Bh7&fN_QYxSZ{amGST?jhw9;kg1G0rzQ$GU_7AnWFo69H=SSa7 z*%2x7m<_AmO-2w-?a=I(HvK&%mdkG~!*LFyC4pUk3PC z2E1iOrjOn9J{}0Z;myu5lAg}*zT};QK_HBCQTMOwyQ!ejF}+Um!km*W#d8Zm4*QqH zf`=bm$>%w4Y!UVGbTnFb+ffjzA>0Q!P`pLEfj5?GzMH10u$61q)F?fj+Wj|I_z_pqzpg&!@O(*34P~XQxI!=!erEZmyBudOLla zd`g+uPwpJ=vtx@9PEj|b)l3FTKR%AWb7p>|c8GKOQL$5&h#zhNT0N57cg39W(}xH| zH!kG$2F!ue>O|dMy~OUQ^UBMv-d-6wIXU!-8;m+LdpDb1g03)IrCR`bq8hj~hK!Yl zp&h0CVV=Ic{K{dV$os-C)b@Sx4OFVA z)f`A04rGYu_TVn#W7SQUdknL%)hmpva(ElfZoaO{o!Ob4;gvEX4mM3=>MnioZ7k9v zCvaa{JKEQ0;h^hu&YMRgnlPcVl}2}ThUWg>|HIZ-Kt;K3VS^xwI(P&H1q2IJI)@Mx z#XwR;x{(@SNa;{SLEs=LF?0%uGz^_em&A}m3DPN@!oNTNfBoy~y{vWCx}NI+X6AeM zyZ5u7(E9X+KWWM?bHs1Rx@_$@$v#B2NGTj9bz#fKne>)J2;w*-C(7@Zt%4il_$|zO@-tm@0H%U#cscGvs-bhvNKMjB39{mQmlqzrO6#b^gVlTM8XLdk@t9Z1s9T( zOw-V+q7tC<6|5S@k*TBbF3%F67y>%(@n8B{Cd~S@s$T=EqscVmPZA>qJ!)2POI_|7 z*Kiijq))>x!^(%9O-3U$q8_iNP;L8O_3ow7x8w#&sZwm^F^Zlp@&lj$iQP9ZB>wo3 zPDMjL|5lrd{@9ILHs!pEPj^|)Qg%W&@Z?PrU3(&|wplf>`AWnhP{{FRIjw(vfhB#I zggxI6FwIR&H3$n^%+4dRU6iL-PXHSW4IeF43X&&4;F{OQn>-%=0WkOf@F^IpNPj$EQBl)y+=m&Hwv}1V=HcPsbP685AnHPf$7qFG!if}L!f z8JwNpEdvdQ4Ob)yCvzPq^wk~}N=$ObUX_byp*~S4ZFa@rj#K#8Qz_Tab=X~{-}u_$ z;ZlD2WhM+vZBfAF$5azV&%ihwtuXK@ltb+UW9Fw%fzWhw&fx(q&JKo1BX7v*y9^Rr z({B@V+_8{}k*@VaDYK5vZ61tZDAb?%f9 z8z#QO%|hihO?%0`mmK@>$-pRnTULY5DB9#1d~727i1ls$+R?G{0q)Gj`cCxyoQ1YLfjs_uoO z!U?kX1m`F{3-YM2^G;`fmR8?Hf5xmKJ6G??LTV_Vad^=@SB`r6a=}fFD)PgE|E9#3 zTirLw5}ZHnrwSwQO@FWB)zL=RNKP{!a{1MA(VOu@k62R1Bl@xC?wI)7!QjSv6+4L7 zs)mGwK>f8O-x^wS$D!p1(rg4jYC?btYacGI84<)O)qfEAHdUqSwrKk{pA2W2DpJ+-P$7%4Wr(^<{=>w z1G&d|>&mTKZqXA#aG#H77r2W94MJ=1$!Te_=+v8A-^pkuXRnhjIL_@im|N_&TDlV^ zCPbp;`+>k?OL55MD~Pv=g7sR^fKmJ459}j6F6Ak0Bj!FmJw2~N-*a*l*V1Z8DG)&n zO7LQK8h_8E602@>;cm~=` zvz7p$4usSifu$KcjWuyJ|D&PDiprDEpe`k0H1D(x*biV0zrLny)I(Wm!3`*0P~l-; z#$Ww>r}PHDmC~n{s@Q@P?m*@048rTpLtdUV17e@n46(yk$do4C%}q=Kfd_GUX#%;`4$#IJLgVp^Eg#$9&PxxAsO)4((ti!(%akl{c47 zb&sgQ%^cK@DYw)Q`~22?{fue3r3oJJbiTnJ8z;JU&e5suH=fSV&d8Qr*F=CP2UWQmstnt zdNc5<e>R-^Oh7vQGA{D5dRdo{C+d;`cFH_|E@BKEBUHj(t^68;SP>Ln~m z?d|HSRKx{rbvSSq3M{R6bq;Z^^B-J62!-de^PDC=nv?%$e#d==@Xg_OnvSDy^a}?F zq1Ir1pQ*gt3y#VqVoSOSq_jf^sRA{2@T567g%j`O15cauMcKNO7&sVXeylkx%vL0? z+4}AeFD`_NyR|i(NW?U2XVQ-CGohnJ?M#V9eq1F|$naG*c?*o6#({w(&)|S;>lC2d zUoe1jtH6*#I^T^c&@6e5@eY_VCIVlycxY-23chR!Ed9ToaGJv@Kfiwv|3D+{xZC2+ zy>nXex4(k*Sc*TPjnHqB&7ButQW{D5$2pGU=CE9jtkM?aq7!^9ZYHhwB$b_Q|E-RG zN0_iV6-_&X8oHBw@$36+j#aLp*vJ>5y24>6`itkeQmvH2Cd(1cF{L1l!7shJ=C#KJ z!)C$4;MU$gO*DP+d)adp_BKpsEVni8d3wfYUp_ZZ@Va$R_vBgEqx0*E^frX-+mrX! z5$^rTn_ChvuUT@{DC7g$)`&D4NdGZR=X(IV71Lg}go|&GVQf-=tmUVNb|CB{yC|w$ z)ybG$=6OZ7zIzht=5hgdk&xoh_t;L z;%?Nm_v&>_LhNH185u&v0D8cje^s;rN5MJb_ya{yEe4ouGHL^A5IU>$DVPg@o_p2V zf6iF`7l$*DW{unsf`;Je2syT855nZ5`HRwY!mJ^a8PWW*zv=7^pkR)Lp|)&5#EzNS zy5|It>#ia|lyk!&>_ZdnV7N z5Y*a51vGgqhsA6=R^bk)nesch(?FZvaX-H0_}XfcoI7#F_PfWC2%Z|ailgjA%eQu+ zwE?HA;u?XYhpt)dRII}i%5G~v_*^?QdO#Q2q(L1qlTwQeUi)PiAifa@tU&^P(G6Di ztS#~W3E`Zs#Ha!|hjt}QZp^~`?LUBD!PncYDp zcw|g6HulakT51I_Eg?Jp2LTR7bI}FZ8TV-_`n}S*%+e3l#GRxpZns78hXXB0I0(kX zMCu)(?aWRR$Epv9rsawE~zOcFlo|S-WyNyCqp`Zq9Jq8L5f-#{~IoDx>OVvc1N0 z5tkUJ*!H%sls?>F+5=-LcGfoEaH#~eRUZ7Z%v*%H>U#gN3{=;)*8{uQncX+TYkiC0 znDhJI?!jPN(lRsAI>h*0S;t8&X)UAHQjH-d3E6NE`MOCiBP%vnsVE#mIsX zuY2pDF8PnIUuw}py7U|BiJa6vYBi=gDQBodiu73nQwBG-?4B@r*ORY*7Vmzt$c78q z59u5va#RE=KsytBqggJj%}8r~VyR!)-2S??ucPNOS{&Oc^O_>$9luAps#ta}Jw|X; zoPOi~qEabzn7P_YB2xlg|LmK6=Vc2uwQ!iX1~vQATAkA*afx&d)*u99a7OP}2i9l00YTwu@|E{UmpreAScOTENnTR<2Q&**o=v~L**@3TFz<;CM{(#-I)D ztoS(!H5do~R1Wl}aJnMl-z~TYA1QhT9Cu+K-#@5aj~Lb<*-Ng#^lP-f1p(gP8Lp{I zhn*LVy{@fJtUH&k#l-L4);V5m!e8KC(c3HaYM;p!?!;XAtk^Gq`M*rJ34H4PjuqVW z+dBwMZWkKED?jwXesVOItih&*%=R3!R#)+D)rZFBbB`iBG^LHlMvn1|eSH4*X%YL! zFC)5lT;#s6VldeE(hf;aOV|j9UWPXfDKAqb8qpJ0t}ZZaP!D|8E7!du1sB+B3hgtE z7m`}96D#5~9uc3X_&a+u+BBGYuRp=uXn?3&1ESgU^GF&PMrtNATboTQnMulAGA2 zIbY3PmCC9+WFFvJ*zDru%w($iG?LzzbR~FA zC@DU&oJC(OmiQ=tSHF|qEHL?JZ!UgaYrE%wJACzr=gQZwbmM6|Sv3}Ukv(GAc7joP zep*jxJc}e8H;ir5&)iYI1oPM1{jW)Xp^#CVwXFC3F^4j-FKo+ZMNhJHx_C#k70vbe z^~4F}XE7{*gWN%st!}dikhe|rC;T%qOHQBLQS}Oa%kcQFfqV+-3G4+nPR@nS5@ZLx z4b?*K2LYCWmz2$>DlG)BBw(?`;G~5_dei%(0&xI~6gD89N(cfDEHVet048Q}dHPo! zJne}72I)-#m@ToaE^t@7j61eP2&QSBO)Ztw3MZAozLCK)%wO;B?q;2imDU+>8!{~t zU5o1Q62f9`fU>F8cK)pwK3O4_3(%HAS7`hXN2iJ3?#;@Igzxr{dcMGo8sO#ltH?wWBSNhnAg^$jM|sLHGO znH|Vc=Ba1rFN!!hw2x@ck}oP$muw5@P$4N{V#{~KZ#ZO%sH|X{yEd!9^I(L$ecb_R zyiJL`HwG;Kqj-{#v@>&JE#7~sxk8PSzSh%)?x9v_V)5eOrAbJ$Q3}_M8CaxE8453> z$Ra9o!ayz!lRAg~setOsiR|~A+dJd+3yE??7R3(5dwpw(Tax?s1CP|G4_3BnaG5FS z`P4^!EVOC&?sPnYH8W%IqbpsuHx5fw8u*~PM5*I&CPyV0%&FmJ@rMHm)0A5!G5~3m z?djspY>)ATnY2HH3rLEg5J;!1&eOgS2lcxzW9&)B*ZR?=$PtJ{)1EXvznvXt8qKo+ z5mRcc-%T@l_AIdsR(iPxjnt`WX*5~AW`~$zr@|`B3kKRWbrNk`VADJSe!09J{tFEege{O&qR!6RtH-U7=v* zl7{*i7UPV4zkl#kL1f}|YI^$ooZMZyvSO3>nyZ~DPv}&y#0u62WHAxC%=o3XGN^qi z40^3go9xXjjp^6y&sF*b3riC@6+EBY?TccL)m6VJDXY^>6riA&yAjj5EiexCe|AQJ zu1RKvLqmR7_Amk0|RIQ%!GK+dQ5vA{&w}_RaGtg*Gb1PU*>4+?m`Kc1s1`RD`_U>U`zs9Bty(bv5bTlW@N0zL-8m z;$X@g8ILfconH%2PG$u-=0RuO@`L}Mg!BJ?$(ORo;@IyV%UP|9ygvE+0*ok!^&A4o18dhOi08BdYVqNqXJ>etzV4bW;>-a zkZ>s{?sY9L=P*{1*DqYzNmARE+1Cp^WIT_;USA@%V9u$0`DDB)xZ&9VmSA=Fk9P|G z@KJ3P73NhgfzQz6_N3TYv&J^C=itJu&t&@IDatgZqm!PDUE^(ah9`mFLUo3RvgFm1 zr7Rqb189x3*9m&o>g+15pZdQ9E8VSS8d1q|IQ9jda2-j^6iaS8ew=bJ2Pw~#N1Q7Q0cs~kmbDwVMRSa9B_AY@PF zmKqprOA+wK@10L!PM1E#E6nDjYV~QC^XmpS_w)|ARO#LYTbcH&dgTZR2eR1+Mip&s zF5rmLKloDy3Kkv_JyL01E}qncDs6#b_g*dzV;>etXLOp}ymBe!lHD7ad59m>X@=8Q zyB|Kw=IyUinbl9tXfKEJ%U?eYN-WLu1c9~G)06^aqsRN^||i$5x7r4obS* z8OCkYC+EQ*i($Jd%8>eBayiKhFTZ$#;xMj$2s*+QSXA0?Z6W$z*k?{i{q;NP=7->L z%`hh$A94ZZpdf;bSsZdX8#e29lk#2y^}p$Cs7A2}TAFAYnoL4mO#R}il-7REx!#Er z?B`kiRJcNYsY`|D*ar$O^jMgIhsFVheFW}|WWxY}hl*5po#C_a90@g z&qf2R$b9Zz?xg?SI`9dA&5UzMw`s`d&urnMcAptxwaE9Z?u2!*CgY#*7`%2h&fj>+ zg_28VXYDp<2@%=rMynQ>XNCTIBf3T%tA+(gMO|YW~AZId91? z-?q*255S8Z@+3n}TYyHHqjlB-Vh1qn8us@O;`up~|AoDb)Q5%4W#NbOj;(CMli75h zR_D)O)jAePMX>#8*R3NYVhHNj_f4v5j&Ppy5bvfo_bEK&wPz%J8s$TnobOp6ZNH`V z`yKr2QzLn4u6{Wqx08Wyv``msq4Y)jn3;xtW{VmtS84N}=4j^h#`)Q7k&gvW$vkMS z)!0?U0}JG6eSGezt826ba?kT`j+zt=6dsW{K+e#Aef>gb7k;G+HhIdhF-xpV7MfDy zck~p{MRUV(jl2GeLC8N}XffLelX*jU=#ID8<6e5-R{RsZo zcizG3W(_k0KWbrrud3Tkc0F9&kHtuR@$;Y(ROgx>Kf~I!9c)$4KT#X|$FG*{TbEb) z35-X%l~^{N@9Ppb7m_sv;^lYE+ z7EI?3QKc1`&%nf2_q-$Q-l5T#m~KK<{4fDp&)=o%zrUlC23aTdzfu=+#hCtWmYoZK z{Ma_jLp-vU)xvuKKWbNa_h|Ouvok44xrzR~z#P=E%~nGmlIq(~nJ(xr&HcF{`ThN; zxquTmJ3D)Y*00g`410^PU#-4Hety1wUVmRdSwpT-?A>P_1zzQMaa#8ueWN~uYh{`E zW&_)hC;HqoIbPyQ6V_o~;zPcwp;+Jib+e2UnZc)WP9+;EL>?kNLG?f07>SPd?BB-T zZC`ZT2TL`%Y;W04%7WFnYODqG3f()eq~TsRUNF}Z$i}f`8n4)#x^AZ&VI;0J$-)1n z9N3c>TkRysaKK|9UdqOm$Srf4pAe9~LjPX(wU@Xq&&<99Xxjh&(iOz;4@v7tUCQ}H zp0CFpnxxhCuWxvuc7jsY*Cf4?nE3eeS?Uy3PO2OY={$KFKTLYtrPhqrL>!^&na$B~#e!@X_ky(vV&O@KXyNt>Y0*xd+C0zPh;k|->nj{@+z(n7Sl!OY8t)7y<0mHQ7&gJN>w?OVNMpD zH?+{XluhSXi*yG6mS+k5_iK(T?ds`4h7Y+%2s^@P5R}!m`Z;0sJUr9Oa7iZKy7a|F zOZo~|`Lni5k7+vD?Sdn`#9<_mkIbttkg0x|#1$!Q4nIvG+jvHImy`OP*OjxB5mTq$ zd9j>Et@qiJPT%?;-gYk&^z!-*kjT}aNkU20^nKM;@uO%d^rzs%`F*rc@00%-wyf1&wsSiEE zk60eLRn7iUP?=j#?fMrJ&zdWy#Pv1hiB!IeCDacd=8|Sz#YF1l*I!rm>&DMx;vQ9d zhW_gXrB9@f(US7S5f)ZnxFq%Sj81NoUi)9w0nXGR7k1a%IlgjU!swv4;`-`qn)WG} zAv1rpRKtpAQS(U1Xi~M@QF(?90oh&xv`SsUn4s8uQK8b5QW|8s(xwWDuXidZdyHth zR=xL($_f_1T+a7@S_iJN$4g1kmu0Y$rFaMtRE&L6M$>5{i?EU(iP#Y0=cFeyp9L-o zWBY80QQ{R?;+Tr!7=-nczZ6fymZ9j{A_*d>Gobsu; zl-tQ1s>)$x(L|)}lgTFTP4c2<`Z=&Dm!4rvU)oAv>qc0WHf>1~+yr~0j*r?HHdx8P zV4VT=KTJQTh2Wx{tmt4qS%|5QQA$rXEqv zJ_Dk%(ivvH)#?|SH2jOOf@8VLzC%wg(%k0?@%;d$z2Lj{HTv1*1+sQf!jaxvLmirC zC|~vfTZ%uwC=_+M&mQv;I&0ZOgYCet88Xtmckc~G{|4-5lFG`;vV=}Kk#B_NZ^;&F@6qD= zvyJn1aZn_vaY`8()el;2i&bT5jz@v$-R|F}C0_EH`j&=Lq+opTMs-BTG0S zp!Do9o}g$g*Dm~wKs$$A$iU4&u-2KC+&E|YpoQ}yt)FiztyIBWh_LjB1$%M1Uhtlm z4$x9|yvM;SQ)#Qf}pQRDV*vY;i zIkhTUb|Gc3@|`^S-dv0+0O@3HfT$i$qT}EQOR!dF9p@Pqm^ai?!om9lNJ`g{m8v_8;?dm=HAXUSb}#xg<@{Yty!NjuRDifx3%;{+?W3B=yqwoSZH zhE(Xxu{YxgKnJL3J^@p?zhfo>u;)17nW12}bO#tm(XZ6kfte9E3 zs%AU-T?u?I0l?Ep5N8B8?VFP`PY5>zb48H|C@|ytN z_n&C=x;Us_4#RGFQM2DPEdzNpkvy>p!8QmJ_(0o(P(YEGVLppNVZ^a~95yFGB_*P( zeaNN{p3e|iFJD{2f+JT9V#^Iw1U@PTbb8#BVBaAZ5SvId{I@smcDq%i7jf1tgLN;| zq%Y5id}Ds&rIW0rv-;$ywWI8umSqRJa+X>}ESgRuA6v3On^$`&=Rxrneq-rayt+7MWb=ut_#+A}H*@!m|PF)BBo zM+(0Dlq?_3hT!WlE`RLE;lY-;h<_uWvF7#UkX4VtQTcmY_-4%C6bbr6$W>4jGlOY9lcot z^lXMuI^_$F%({jTgth*rBe^*O_qP3KEvEosm1(77=mMpAOPQcY7@qPu^M_(<7rkg<0lr}Up^j<{)QBfP} zRllw$Y8-aC0zcF>G$!Ex4uwV5tt>ko&~{uQF?;1#%$G72}~vM4U7C9Cjl?NQyK<5Rb~rtBP5y?lSsPO?4x^8Ukwn_=sff6SN87PVD$3w$b-2 z`r9THxMUQhTs6Uxa78^ObLk}+l@!A!fUXY0zkoy)j23g>+lp$A<J)ARB8Y>4u!fb1=GJ0y5YnB4I1Hq_ncQ2T1i~P27{s^XI+T-4 zq)_vwI{%vsx@wv=&k0KgJ_zZd5$ld!FPh!Xs<(}{>*3A1>YeCNdGF7~I7u8oYZt9w z1B|bSIz(w+&b@7Adoq#9hjIZ}nXzEF9Q~x)k)D{g)|WJ#;v?>tye?a>{aLC8tG;z7 zC(y~AUg}Erk<&uZlRbLV5ypEl?|T~9nn$ENThnTg58P_N}dnbFI2 zP4z9Jydn3w6R#xLcCgc1nM<)TXyHJ#x}=L^HxFt0v1|}6@9Be_JDV+F-J4Y&6>5zU z*RTim%J@%Mgc>Z5)rw4Y{6b7>u6hH}Rh!25DG0(sfW)JU_;EsmvoP8H&mgn{T)=yi zOPLDbvIYA#HD*WwY;NJiby-r+yp5qj7I129upHB&32jbJNVv1nZ_G^a4eS3L)(mY> zL_zd}^LD|5@Yg1dQT*E0wP%uVcP?!fMmj*H72Jew@-cA>;8hM<8-Lw2&kG+3xTBU=Xe-Gt z6SHweOr0Ni4P~Xzvm`6Qv(Ct5t?F{%tfOTdQmbHlloYuPjMKy8n z?9Rh^&XMM=+2!1A`bZfb*=nXo^XYEoq$DpFQ(ASx^`bKck_;oK!0BbdYR5bPo8PT` zI789%E?kh-L}65@p`wOHBsv{yR%~!nTTziJ3+ zb3O5-AA%gI^_K;U`sslAZ%BCV*!l2kxL4`Bug*S`_pq3*8Nt_uB?9B0Jno^686BTv zF$cW|A7n1$t$nI=;@7stAu@$rhGYr@!LYD% zMt^~$)5k%bIa_|4^8OsL&h#|bJ=x}YePD0Ur3_)1ICF4o&ebuUUVswe`s=dXPBs`1 zr%fCm$yhOL7SC-s__%l0@t*sN8!NDrn)sIZ2-$Q1dLL)zbdgv_(s%D&(@=fDjyoQL zjd@33(FIG{_h|FN0Yf-M*B#5jA+M=;@O6HVdNV$i#TB;dBDge^2cpL^+Lu+)akIZ(jk2yghvD=po_-F)Lm0+l?l|%DX0y)zlL|1;d^Jf}=&37%nTgN1 ziW>*cPY)1MXBinbJYEzw;>&>Q|Vhj~v?vspq z0qQH(;E(Y@mzamEwGLmE3NN=7f85CI8(4LQQ{HBob`AHa0YAh>kmTVQD?sC8=r7n4 zsJ{XYNh9zVG44ITQg4?*kMjt6FR<(b?WCONkk0-JofC{JL93YW3y88%q)t91Z^#Bt zjRHa>+ExqjE+|VX;IIHWj}}oI8x927ADwkGJNesIP!G@xFF>QiJ5`T(`A2Nw4Y>s8 zlbgffR7ODn@8Jv$&xF+0S36wyI67;TpD=B8}2+L_R^lhQb6S+FAKh>_V!M-L(%^bP0^cH^Eizj(} zfjJO5N?}f=a|3-Fwk@Xj5!kS=S6cVvHG8C$Jc@~X$S^M88uAm_jg&=owJUu^OlL>e z5V`TU?^+dnkxQ?>#C3IdH$v>{!tEpH4J>>D z)n|+Iz=am6o9aIcOoe}fG)9)85E$oSJ))>&!_OHRAt<52cJoaj*BcO*skw^Bsc9l0 zd@AWn?cMBU==FI#YFl*EDaHgEa6Dj}N2Bcu^opP#P{k`=9dc=HZEgI~_1IR&$VzFG zfG8xvBXZ74RJ?#*VhG`B&fSfq%_1Wgmm1}GCBh~@g+^Tlx=Q`~} zcbDYa%{RSFq$CutLG>es-9mr@PRw>E#x6#dlXIDE(wvVu?Nj^7=r_%1odkT2#hbabN(-aq{fOce)&zExaGQRDgTh1Y+Y>WZA=Q{k@ziJyTA$TRBRB8 z;pYCI+f)NxuHdCXfRS4d`3`co2WdqnA-jHix!Cpq;$VS)J@{bAVMFSxdZc1~J z+kN>s|4?7fGeVsXG!eOwOg&zbuf{bXWN#9NfrFadVF~q+zxl>w*fZIp$IQ$}1*DLs zX+r!L$VES(%Yf^m2EmzYcpzBk4Q-1VwS>J2^>Q)cB04|4|0*E=8ZyxoLr?Ur zcz@~0HZih{ca@n$b&zc0kz1w1ox+hs)nnU93U%sh) zm}FXxc;z?88s7Ox#*}zG6kODFJX zRzPo4HanNZE?|J8-$U4phWmTleBjgy69(ncA6FxUj$&ipfEHhgiY+>nW|* zLzukN*Koc{^VIJj@tKDGV>UNndIJ4>za}gNjb9D&pq)aX01ogy_N7c>f#JU%Uyby0 ztW^aF?6OSX4n4=zIJDA29vp`G>T=l%lCG5J5C3|K!C;717yg;?Y1AVP$3I zMz{1)~aDPW3JeBrCgx`SP1#5YD&ZC%U>Z;?Db=A!(QS%~SNs zq^@+1uH_lG$(t462Not>o4wJ~=K%&xK4%G@6Iu}P+8zF<1eHYB?vTrVpw6rtDP{fG z8^-(6F|7vQIe1gSpre}=c+dh1>nvI??0ggj9H#KfM$z}dShP65UjQ1G*$uS`4_mAf$lsniy)BvSdRUliZ51N>jBZ)|?m&Ow*^^sz=T z3HZR+Q*gUHsk81jwnau5JtzdE;wBM#i$J(_d9- z__VKA4fBRfbk;?YOt;M_bmzS!*zQLxfNVh+>*nH?Zt)f6$shhMAd_MN!pn)u(W50312`QKvGh5l)R=Z^X+eOkduHb#+Yl#So^*{+KQ=aRNoy zp2&VsVYk^LSv+h!ZyE!|5b&Q9)KuP*2)EQ0vHX;+G6oNTCptQocf`Oy8Hbo1+z()i zjxvUYajt%?uf0FGbLc+$3<%d_SZ%0gyg5_i4(~6h%+vGU^_in*xJtATGew)NDBEwm zZMQ=9JvP8S=88A01|A@Z3q2E<<3x}uTmZ1()wvjc<9FdY2cINI#h4UIt)2fZdG=z` z^zA$)RFdcF|181t847(m%_o_40G#}K84k!e1m}ChkvtHiZ&BfB3lM+s$OVE((+Qi{ zhI?}EPil+Asdnzd5db4w)}x%u)9G)z3isM?Jj;0RXnh~p8xgPA<@z`o&M#$)B(*4o zLXXtP_$yAYjp^ikxL3InZ~1r|F`F(gjN&%x>JA(yA)v6=`XF!H9f0Ts3%{AL>msmx-Y+sG<{ zOWkET)kjdigQe62#aoG8=@Gw+l3sWQ2dM9p=OyM8kQD>Xv?j8@p&~y7ROEmLgsYzn zm;CPUMkvr;&aodUS*)icgj!lPkk@EwplfK0+@mj?D{hm5&8Mg@B%#NQmS zAQ4Z=Zn{iT755ttM_J-K?yFTlrGz7e6Q!F1$gV<`;DGD8LXkK9jKqi z^Y^-FrR?T&>S<5+5bVo=Bs?YlXI7nrY{R6t7wz`+?wOTpY3@?;>AI@nT!3T}(lV>% z0?KNYiljje>C>uDgKIVX>f-j$(^JX98)MZ~rTsvk*N<`~pIk#W4^pj7VEaLXkiEQ- z)&f7;qMR*Dye8zdGHy>=dP91wk zrdw?wd|<(XPK+^qEx^A!p3^!!z8q#8MT*bBTolD_A(t*xq$}PKd+xp(Ae2hl4Q-=v zmf_WiUFseXoV+SnfIf;p>rcxM33pi4P0Z5W3eAgkSIBhPrV-gqb(nZHHH;Ir+_Cc} zIY#6ATGqreN$AQKgfVj^vmo6D7YVt7qv!?uG?xWahfiGAey#dvQu5hEEV{enm&f&F zfopMzT|-6sX~N_-ENuVp%U5m_Tm2WaFWpXCf*|dL@_cyal2NzdS%WC{51ZQG%$YSn z_iqp+hn@*dThHMvxXRz@WJ z%y0|Azcpnali)XOIvsw~%^8rand_)o7Wc(#-*JAubDY;yBQS6&9+vy_NPG6T`QI#_ zj%98bjGZOaajSQ5;0|^rm-AN+&q}CZ96A4?k}4nJey?iPO{SLXn9s6Y1q{ZSRr_*s z+|b1di_$($SOJQC5X`6ZyA__S8+7;5DM~L-)=x*{K-o%0f=^tq0tC>RSOl)s4?lla zcKadufJ$^a&i-~G^j%k%3bNsp0cHxWZ+)B(q;PICNjO$-c(-KLpvS)v<^KOIvWoY> ztVwig&-0;CpLMP8{D{qm=A3$_Nc0}`Zq4Aub%m@OvIPj4<$U!1O)xwfbR^tsT>gK@ zpbV#>s2GIagCOro@g!1glR!{b?Z2(ikzC0Zpje}SDurcNus0_R%$)>}M6yu( zN%2q%Y^sxx#uXuN#z#sDPlQ&CbnZbv5Wl-(fMZvPipW|XSp;H!a8+#SZ$l?}BU(k$ zgPvB_s&vQ(Kv{?8Q=%ZJ`Iwq|y`Sg+IO}ATdqdzwKFAap{|Re(TloXv(z3jWfwe*D zg>GFwm~8N)&{t)DH#CPyHy1*SQ~Ym$pVtkP{A4bqmd~(*Vn<4S^*j8f3y9r9>HS7z z!~iFa&`q1G3NcY=SGaj2F6bJsGuQVHx71I4mMG> z`tJetl9ZN_S=F8bRUc+j#>Ct_7_c)O5}jZetzCI$3^q&UNJ2N}2janS4%83nnXo|8 zK)i*=e?rF{+q?P@#bnCR4_ovQJ5lV5Na#sz5ci1CFXnI(1ngR`fu6oFT?>0m=-IM={_!k9MT(?DBuRjr>@%TZh5>qyG&k+sD;2D>9$Btu$V> zfw6M(!~*850}NLJgg;G8ZOm2*o0xUBq(aeIY*(gXA0g&S7WdP>{BB?dZ_yL|^BZ$M z!dRy3cA?OZpyx%>e_hT_8F)NX;Mc8x##maHJO2h4285+_cM|oz$}eX9MlzWZB=cp= z@-xLLtkGG<{jK_2O&}GxtYMz>2D8-3(+vtM<3o3enMoPX=m(J`u2#-GYniDb7+{X6 zPa%wFSn>#bDe9_#y_F?SQL zI@Wr`(g>M+A~j&h?lUj2pHfRkq5C9YaJ^|;MqRJac227YAwp+YQw71|h$tX2%eOw* zZS|=@WLD%CEY=$k;d65+C;uu~K1l0`0uV3`HA05!7Sz%O_4E7#*KgzjloHu1ZMym$ zz6Beis%|yIrezfHHER{yB*9=`^;#c_vjrvjp+>KYm6a9ytXqFP_b;Vnc&@x~U4F6h zLt00>G%=6jCQ1LBgm{>Fij^2P^syf0!R;}{!2+x-8#XlW^3>qz2iBj?yfStt?I-^5 z28U8VnKykOAx_&&>{E*WE1#*QQwrRcyf0%AGBE`ycA(R~=pFr7ZiiPHVnt>HR1P~# zG<{X)%XU~~;}{E(9P;S|zZOn9)LBeeDr|0)aRp&+prvZ$8Pb8BQrT2ApuJA};0Kv; zu4gLoA|FZ{BV`H|(FSnYu&EHD2@>&et_7B}NJhm1aSV@9uC{F9AY1O4!2`JZePC|Wp(HF9Ql8~doRCKF&}Hr=XT>5>8X#*Ucvr2elKAxTg~P9K)Xo!S3)%aX@6;#47-;G zt!yEd`Q)z_~!rE05fC7Nrp7frP`FdZ)F!^Z@&>S@Zl+6Nba77$0 z{&oVwl>y13021uJ8lwQ(W+68dfxpK&y-R(Bz-Pv6EptluD#myiEu@5NjyykCoN;<2Mc@}HV_V;j@@7WMou!#3z$#}QobfNZrgNNo`5Ez1oLqh z$Og*n>9{zo9>Sym^yC5j{z9w%r_LkWSY#8n0s`hNjjztX?VJS!YAOw%!Icf$YTWY~ z5tHgj^eXDSsKA^+wHJ!N4Ov362EQqSpEH2}$JAvQ5I4hj*1&eaZM;V_0Bxsq1%6}` z{EtYLU40PXsv*`=9MH#lia|AXb2q_9^F~6DS|fsYa<5(*j#IhR@%DAXMap~1S&U>72a@oJ zk((<={+q=#(i_S9Y4gPkdpL-Zk?y-+UmZR^4pVP1viyyR7#rD1_;M8mzSat!#^QPa zpuIoXo4WNxMdd2^ue?L@aR3CZoq65_p+W}G;xBIee01TTK-jghpX(&h@}aEk-cX=k zY?h8R!o+;dvSRypU=BH{AbD!5CEQ?kS>)>l2!V_7I4@-2b!%s#PuO?Uo26ewoO+7w zj%395YFwdyk3@`+A6hT#{1HDD6w^j89VvkMfbnfPL*4ou8n6fr1#n|bxSRNx(!08m zRT|Z7-?F4~&uC(l5QAP}g9fyvA>il>MK>!08M0evMe$o4Ave z8ae8_8N(0Yb2TZAS@9}+GKFms$)FhW3h8C`f1&pL@eslvDC|_1EG=7c4i#zz#OBYdFeDs1ozFs$;~DIgoD(2h=}1^cWaUI@Q`xE?$4NSXOPWeRiIU3b82C;CniE zT+nxDJ)*3sH=%3Sq;Kw|sj2BW%t7dSM?h4J z2BD9@@XUGNc@NkNMc<+LPJ<%Oe5`yxV)xhwHiu#-j#E8^`=$GL3sVy~v#0P+lWW$L zeQG%xr_x;YVvA2cs76?b`V0RKIl zAv_ZE(tQ0Y!jL}l-wf%Ow25WQ9PHX@6Py{* zB9^`W2CcJv{F;hmO(Jd_tiTJO7w9`8afRM5B2N7R<3E;FmvX|;GZ+(Y@t^cqvrp`{ zK7Ci+S&WLNkKN(l_tXOs)IRrGvIm%6EWNGMr+z1Tmt#3j`@(4+j~b9W z*K3@NyP;NUhxzOGAt6~)%zCjNG`RW==Oj0mt1)r1)Z*F?ucue)?P&WH*N4BGVlVTk zUb$lmqR%ajjO2R?iOxO2$mSR=R~=gNOuz8|Q1;&ORR3@MzcP9&RFvviNmf>wnUztt zqU;Mf!rGBO%Q$V_EquY+td%9djs$EeKgtRqC<>(%@Fx!peX>G%8He*O3UqxZ@2 z9M|)@9*_H@g@MRews!)rg&KHVPO48>nppIsL|vr{V&uqu^ID`QlP>^7x6MKS>rzPl zTC>)vS+SP41s`3gH<_E9(OTJ<-PahZSZ5^fk}nLshh5L zCEw*daIZ4QJKdZ^Qxiv-kHI_+@Rvx7H+Q$htl-@g{lor*do(D5Ru-Rkq>WTxW}X-5 zzaB)Ix|ops)!v|Bx1_P*g0pjFPq?P5AtahJ}B{vKP6 zvL3x*{n?x5NyDcuT#+u99#gk2C#2U=5YLTx6hWz7EV2;Pn18!5C3t=Rm+#)eG^Bt3 zQLVp(aa0h~pQei>nb`F|;^S-^n7HO4VWh@M?d=XL#8YfxOYT1Cs>U7rpQkjRwbo)F zzRHN_=U}#O3S3u)0be1p8y4QM?vxU=i?NRQLqW;Y6&$FIdwDXh8lYET-WAfM`g4I_ zKEa1xZS5D>)7bw~(HO^4F(grp^Lo9OP*x^>xeT+V?^r}>unI=bLGbZnNRlmhM2ikC@c!Q{452H`aGNUb^^x%ajQCa=-mLoVQ z_F1cB(ve>q{c*VGSN?K`aiO5r-TE;TT%9rMI7cY{i7g`MtAnr2Q~*VXUN2X6=WLKM zJuifDInxVMEtZ5>MY+58izE3X-Q7W*%zsPMoPjMpf1}x|sF{J7yIUTtZos%vTA=2? zGGl%`6kRu#4OVBX7{xx08=(*BNniR=t|MCRYtUZXwk(`P#Zc)Zl4VSO; z2G(jO++5>%4kQw2{2|ZuhEH#p+^jB^#t9zV2ou{5AbZ`O*7WbejmQl581O2AULtQY zyA>Qcax;J0wJ)F}0NEHKw$Lp9uBdQ`<)w{O(?6!4*+8E4#~&_Kd%|wAddWoP>&XwD z0~av5LD{ouW*YsTq~ro8PO1tgW%!FY=IEdTcwALa(LK$(x={8UD1@DM187%eU(vKC zHtn@B+B)_zOIkkf?dum8j^s2aj2v!Ij0l!a4Z;7-J^PhkMUrv>y@PBN5ANJd(^G~wCp-qq=!M=@hf6grM}n9Y?Y;_ zcNOHkzu4rEy>h30BC2H3#AAkz9r&uewfAtD{k9(eM0QJS*Mvu`>2tVyRkt^*{!DHr zAsNLNiWR>~%iGPi6AsbR8joUEV=8zE+ve7d8?5jOsBAL70D!3T6WKXAokh6!J)4Mn zS?+$;X1|Isy{~k_PdlXMce<4j0c~CShn=ju$?Z$e4wf6~KhWN4`T15jaHdpbQ4el- z7kOFp@=|5F)GP1+K;v;4(lzKcWgC}2 z6w!q#O*n_XUgtsyZUV@)Sg=rVs4z}xXCrs~8A>A*p9`&B@Jw%dYs&>esu{Y?RsY=Z zxL46_i_}wL%@a~^$5w!O_}xdR7xqGaO8~O_V0_Vp^cFZ>17)WIzTs)?O_eN3aHqS1){EgJwRa42m2RFkxN~cuf5NJO z={po004Dv8^I)O)#fbRhvyKI&cdqmxA`x3E19K-_n*Z7rA7~XS3G_9D|_6R z(W7{tRwn$RYZkqXr|*)w^%b57z1qaGsuEClVP1IUt(~gjfWEWjJ4AgM4wZPK>*a-; zK2Hnhi26BE6Pj$*9NojB@8Bpj&Fbu>0hH6XQXVD^Qq^S!Q7Htf`o}_ z=^*JbHcTXVZ;_pJLK)rMp;NW)7B2nUx$sfM?_$}lS!GZFY$7F+S;W(AMxbqxma3D5Wqy@qyf zM-8|!Z&~u-RqXJvF=)Yv36tn;m_+~0*Bo%BP^>x;qAyl&X^nS@tJMhf@XhZJ%QMn| z&gUd`iURBNqsm^Qnf+c z!llq=b7b_}(%;wjJay_S1LiD$T+ZQg2d6^{6Vxt1B%#BrU^~*uK@0aaX#mCT-fS=j z#L$bmq@3`O(w{9-sS&6#6WE&^@9vknqas!P=8Cj0*WP_F3acp|t*?ju$F+a^ir`8E zxzC!J@}=rOyaB1pxi*w%U1VyY1aD>9&fc7&Is9rySXA_vM4M_kOI{ICNeF_l-oy72 zY#T79VZ<^9*@e`+uyddg|g~0VsQewNJ z(EZK$KyP5rDmpypgKI*dZZH+9+#0eiZ3CB7Kif_g8z@3z0kY024*IT>5IN&qkjHY} zs|)gv%Z!{De>+IF3BA*I@yIqO6wY*Q-K`Pp!NBTK;Gz|LSz~&Ui`u^>7uQsv{3x_t zpUuHqUfC$U^~lI&Gw>$2O~5?~FK^q%6zrh|1!$E7lIHC9KH7HA&;JQ*2dXoWksb*W z4K+lyMM);H$96pcgQAiI5zQ1Rc?=gR8epD)yQk8M%&sC8&&~_eai~VX{8Isu5IA2v z`15=o%T3@I(o_H!(Go-hi_9#b{xt+0KHxbX@k_H%pG3y02*XJTQDSe}>i%&kPnKba zUaUFiD5RA|M;Ni%s{A@EJ5RhSSaN@U`NGG-lwceTEKeNF4=dFrTqBOevW`1nP4D|i zk1wG~s!yq1%8^npf@ArXe@)+$8u_YJ7}$uad7t|z3*`vXeu+PPe>=56%&h0RjBO>= zF#-s4-omh#t6)~-<|f!P5{I=7FzjGTD?pFUD@T7iWu3$dkwSKvIEX7BbOB6sD~xaX zG~h?RGLO@)0VTL5Gc=KDGC!swvQ|zcVNUO%=;ZPLf2PG$PQLlGg<{waHc_=j_vnPE z5&xP2#hcZ6X56mSNfAeTaIznN6#{F6O2V=1IdSiRlP7pb6<$pEJmS6+_n9>3=yQ<9 zpN)5H5f(Z-d%kBmE}$vPLM|=D+3+G7S`2T0yq_5bc$>>2d0F`G(pFfvhN#`w68K~bNo2EtT-Vd{+j zt+}(P&Kf&qCXsQE?*I!4!A&zd?cDgp21~$-`)Fb__ZQvMKKtng!Vhd=%`{YWuttuj zMJV@wfCYU$ZGfe$7SCH&JND=mU8urjiRFvd%Pt^W0-xICbp ziv(|RJMh^BDge`lOfJQD!OCL^5dJ9eH5p2!{Mgf#hQ23gd?BdEJYf&92P3Rv)sQ8~ zN{IkN#*H!1&SE!^+5IYvYvVEPmJJWc(U?2PMu9YTxvP&(MlvG6*melh;6v0Pr)r^9 zKMA(k7%)!GY#9FLYcyW_y+raGE5SzBk9~8XS?KrZEzE>@<|!?$vAlVO8EhyhX#0NH zmkdP>c5^Vxefmd1cDhy^&&w0QGYs9eyJ;+ROqe)L?mOZgA}j1qqV}CKXV9eg?S>+E z9DB12h(Zm<9cQ$|72rOe*581`#Gwk3J3`_Q*Vn_Chf8z20ZN~{EXvz8Ayiz5Y!mS< zqbG#9HUXnnWn^Fs=uFCrMVNIVlfwkRl(JEFB<3AKeSaW7Vc0Y41@Zy93Xn!ang$?C zksQ}k(q3*ZhA@ew#P3dv)kQ*Vy_Q4eY{sMoa=NN{_(CXzYyLbKx`aM)L^{DNC@pBC z4`~pCg!&l-N(@mwlw}n%nHIHLd+Pf`&KQ92li!e}fgg=|)VxM z4)~mJ7eN!Ecs50%ExU_hVZi;&CAo(*F(CPCN;>f$GLpJ(!Be!i;hA5mR~ufHyTyxB zlh}cf_ooi$q5UwYjTtUsu}vce&F5(B(iPqGR=GJ|cy^pKf2^!!7ma3F54xv0oB!;( zFnoh2>;JX&qzKs!wsywwBV9~Dldlef3Ex2q|h zha61hx-5AEBGywNCU_2@^O;HW2*xq$k|RVb6~korcCrI7u%f_VY?)lZW?Y~HS5@xh zH?xOK17B8uUqF{Xp$`V0J^6%a3o&j*wi4)}oJ}iX+kFAggL~Fd7LIs36cKBrZaFXI z2G!`|qY$7!f%X!bLKF!uaVkk3n4XdZI9#=jteNb>H?U*|9W~|siS!O+=g8yz~#7hIHjKd*aC@s)b{pv63ztTOI9JZ?5y0win8Bj-z4kF>7BLe znWx4&{iSbd5%dtK%IPa|HeQEyNXH(3Zh;7_j`9?Jm?Zv(NfR ztQlrD@q)!w<9P;gmo!G0?4T!@AzFqevwI{K+0BM~fs}N;!C+yTp~*A?x5)_DMO(ih zU}O6~6tG`?!4@f*oKeL^{nW`^9FzkVNZL1!8-P2eY6feNg`@1VB|e z1Lk@@<^@QKv0qGf=X5fX`AtA@hm`{C1DM9%?m#A)B`68dVi+wgErOGt-VX+0iKq%D zl+s{uHMs}l%HNw zgL>9XYhErFDaKgxe=CZ5A}u@plO!`o79(h_H%$z*4d#&2=-&n4IDc{ zdGIa}Ri-?(a{FgS5}4p$+oNi+o-plG-prDkOM zU3~|Q?!>^jU#ARj9?p;XeSxoYsw7UZ#yz3pncwrMxyL|U_u>yvf2~V<{-TX{QgE+u z!~g`f*l@-@sl=3OPTSHy9c81j`(*Nd_?AezdXa7}a8=ST^~4fX$cWEG4{yuu-DY52 zW~#3j`F5s-#IG6&)MCv+d_<`=apE;)`Dn#lHl)C*az?oFSLXXpe}w8iNmM<+a!Z)R zc37W3{;9PcW8e9Kc^XUKRs|&R z#b^ns*|ccYMx$$HHS%k(%7o|EQSS_lP%eFgQ558m_)9AaDcA9$7=6N9`OgK{w|_uV zfj>AWQ!UF*zpfR%LqK!V@%KlVTJKZzVI~A;?bD;?unN}u?Tk*vqlm#VGY;?OvlG-& z#0OvAe3u(4z>!i!%Uc*i-#ix}U^X`cY(t07d6B0zYO;Fds3;o^0GUzLkJOvpp-7*1 z91BK5A1ASF{~CNYbW)CRynFoeYxe$QB&3I+XUb)cNT~?lKzs7Z>^mP0et{$W_QFu1 zC#@k?40I!C&_Ke$#N7wFRu_ITGl=aK#Mn}@_^jXPnu1#QVe5;W?Cg#o@%cb@y=`ZN zMrRqqdepSfuU=IahdhK{eJa1~@N1xr%#C}#974#0J`Szu7%CG3>H#`k$(5%-;NT2>9Hubn-A1^=!5)FD0 znNtfxP&Q5?Rztv4Oj6AwxfO^cl2OcKL024PJFfYTU?+j(pl!=i`V?vt*G>^!aNYJC zPst)mUpc*f4Dy0i4<&g`#ptBf*2>tqjzKDg>ObeM%(UmmnSgc25QK!SUw{~KeL&ZO znwtZPo+L!%J8eDs0@Wl5)*nl-Tv*lR8CLWP<9DY7e3k5U`|5|mux8-;D7lO1yN*PH z37R+kvsS`<7~`pe(Hntba}~CRAP7qA_vw#u8+L17z>tn1{6uQmuEWyZrJ))I)0&MA zm5*SPw}Cy;1PC5n2?X9Z-EyR!+lB}xQhyHY>9?u0~l}IVv$ZJwAedXx}{6l$= zZ1^j~zZ=g$~xa>velnggyBHajyD`-s{TTYXgU=j-g}#rZ-OQ+3Zjn zuCOk0s!JlTU6Ut$DdHJkr3tjYjS@}_#NcNwpS%H=bTKam;F0Q9be%CB+rGlpHldJl zlfLt&HxGv}iq0W^_$I8+5@@fYp{Nu;Rg1e$0L2CuP%Nq!>VEDahQ7qhPY35k_N5~= zDaT}HLpd3>Ir^WRT;5HV@c#$>K|3;tfE^v zN)9VO=nP}WH#sXxu5xQ+<<*Cak>H1p)YJ+t*4 z(Yhd1m|Q?#dph#`_r4@qKhUl(;aJF^JpkZ+uy)({Ue3)s#hcjmF0kJ8$iEhki>TP- zmZh_i8LYHnO=qppv8K7|`y-E!hx4BByp0L_pS4_R4c00i6 z+?ezG0N~DV~uA}vI81M#M z%oOZTn)J&455 z$-EE{&t04K96KtlA#&T`pX3?nO^C4$UIH?|RZ^|PdTGkZ-_Q_#{^oimbvU$FHp0$R zEPWp%^h{@FQR;fgQu^Q`sPcTn#41aT!gclaZSx;XgF1J$HskQ5!60&zX0QEy|Hye_LJL*0BS_lukp_f{6cwMHbn}kXgR;+1+E@DInL^>i(6DXL4XU=gt z0?zRSCE4nZRa~E_@RUcDH>im~xGI1|O{%_-k)Cn+1uLJ0XJJ2_A=U}sY3I8Jq~5UH z7wLejoC^09$-$1F`sFXX!nblj);IHtAjY6$@PDnPLYVL1EqQjqV*FD|Q~`KU(n|N) z28=+nQoBb`U3%jtpv0JjHdhcA*I;!xJ)hv?=kbqyq|>vr+X4-=K5?!a1pT)4Q=dZ( z^Q=OR&iDm6v6`uTd0&7(MK_ezz8?f&hM(Z$L3abkQFHS~Xu_=9JxerFk6*MWEjQ8_ z%Jax_n_nvpY1alqX3oX*5j}o6<>2QO?_y1VRHAqFHc$BZzaK+jfM4~#IO+0Nemz51 z9e(w7>k7@oMzRsCe|~YXCaBV;kXIu(xy4TP7*x7tC4qQ9V`u@MFM;KCR4y zjLRTOX0+uN+)}D`h`z6XDPR}=A}4}|aQP0F54#gozwA*Y^Kdnw%Z-gPgNuZ#H=$=! zdWe)L2BK~Y{nz@|>svNeiDgafxw=KN!GL#><`&XL0>0eP;*hzgrf-oP{AHDzch2rM zxR$>5dWrmhxlgzC5n##`Xv1S5$#JN<7E;K!nIj_LY;vEsyC#?Q+joAQ*T3e=6uWfg z9-()H{D6Dyk1#qv^W$MHiQ@?d6P?a{SE#?}^*+E(ueO#YzCU`rywes%WE}8k!fW-j ztFIYK4;&R7sVK##-Ao!d$L&f*7gwrzRhwYhRQOaaI+fxWX`~;en5}6M#40k|?Fb$t z*+sCAT;>EWkFPHuwpl!tj%CdBFGbqHU6+2|J0)}PZk4BYz9IU-Ro@>IENXa-&Sc3! zvYN5`I~b(v^KhPrk57%Et2|yH8lE19XMnt;K2xHfR}5{jc!S!mixX5UTlWCuau%sH z{>!s^E#L{Xsq-iUj}yoS6EoBjwR_g58I;fQSPm6iwmL()93- zk_{J3rxv!Q3q`7$ZV?Z{4TE-F5z>Qhbw)8(10O>o=~|=9VX1HRwvf*1w+?2%C{WtI ztB$RD5d6FHNZ|xN=j%|R3Px$E-WZWtQHW6|XUV%JT{>AOqh&BdYu>A^Y|Y8fy{*U*(~6j+J*>=J#W$uXWb;h}Ouj$Y~X#Z<%&q zfnJf#|LqmM&hv^llcpv^s=QXz0Jyntxqzpj6;6s}EQcuO)ehWOiLO5JFDvaEs#2&H zj?aN2ISSxog5vkU#GFo!h2j-$0*~^CkQYK41HtY?;U$9GPY@>9A(Jk9+cL1!#1D1|MS>oAcP8btGv)K{2^m| zj$GkK-oWkiH#W5ZRE+Wobt5gU9|7hsi#rEL{cEms-A9p6$N`1*+i(%-I~{08r! zNl@(yH`D^??c%9QFKFoulQ(aN_Z_kFy`}gjpR>`1!24DLJGu&ifKdYj-&vHQB#fpE zU4n;$UZ#e0`7?Df^QMsMcU}^UNL<<|Yf;T_`}h2jTo8fSrRBxv6rhL_lnYrv6TYhB zymjA^n~yI>jz+vGupY(05Isn4YpTp5x7^zke`!I?411Z2<4Xt*tC4rGFjPL;Upi9o zPR_H6;P@}*HuxOA$8`tv__RYq%4SPH&e(sv{5oWGE*3#(>FU~>gFJ)E32yJpk-ew& zY_*c_ry>pRgZjY~@ElVCAKskP_Knw9|3yNO=M}sLpiF*QnRX=(d?Z|OA6mL>0qkKG zz9jWM;5$r#A-26Tm%-sJE8jnNpda8qUq&M;J@hR$=L>(d=tv%ov^6w+maB~~@$vDk z{xY55TB`5;*xRggJTZXtRqgTkfFN~{Lt-tV*VpMEkm#_mXgUsK%8eSje{bY&hj$S+ zywc4Innq`Z;i>S{fi!K@-EF&h$7=`D+bkVI!Od7B0BH3~lW~f?XCBKeCWM;|SD(x0 zq_x}8;HBqweVE>N>aey%E@_>aqoT5DcVU{?LY6KxbfKI)cHqo5$@MhsEMGs=zXb9* ziHViFs?TSjKv#Q$`=)V?Lp|xa=#Pn~mlBBLIi-d7zQe5nE@$YzhICp*FTEO$A;{eA z5})}1SO{Fk$J5belpG6?@+Ii@wI{b7M~{V}-xZ_@E+l2$#VF)ESAIXW5K{Y?UoYWb zz>ucKiwj6)U$Ljh;0nMzaEs#X+tADI4zD_onELE>v9-Vu0&N<=p$Lz0a-tJ?U;T!8QnH4F8P9qe7fv?TbtMeia zu^xj#S1ndDRC9FGiqD>7C(_b6mFQJ1qsD6mu~N(}CHmvt>?`+Q?r;bdX6`6@%8lK| zN6tt2`y-a(V_D!j$fSM>!%LO+)+CKa2PR~GL~sJu2{JE&xkt@|fh^WE!z=au?$Bk3 zzbYgG_L|(z066zC#rusgzs#}XKHKYHPXK{x^05Bj5(qXEqkta60MlF&3*qeMM>Bg^D+(dN%@Up;ryA4ncG!9y1KIq0@b}>7PYbp0umFU9MdOpv>6$N3ME0+kX zFK2##svNUxG!7bOWxm#JEb3UUpWZw1EM{+jCiA7);eZ&59;~bQr6U3x48Hb+G2XQT+E!gpe^}Z*_yP84ib;MT3AjKA6%uGO3y;%gDDz=m@ z?V|UtSQ|8sWnTkdBJH!#L8k$DNe2+Bvi_$Ay2EVD0dS9*TUhxu6yh zy7Jh+1?vN2)_?ovz%#|%h2z*rzYFGQxL`XwNZZwBn1Wh=g#WZo2t2p0=^NlK-GpIA zN-q<3W%-$wx)RMY9GJymd9qH{PVCWiAMlv=s2V0ed?2SIY*iMmVrXT9I4qv|Bk7;& z42b<4nX$EgK@gLRhxw`BIKT<-$tU@7B(4x1?I*ApaDAnC8vV8 z4i4%J`MJ5z8rr6mf5xVEkXXrh04EsxrBA!b-wL|4g0Nq(&Zu53RG-R^ksI{_Ckh4) zt``d9zyotA;dk)!cB17j9Ghv;!O|@L(p2gw(L)Nd5F|3S?8*|Wk?0T^w6`;5@KXq4 z8P(ALbe{0NTOqHe*m)*BUz@u$F5!A&qdssKZW)a~yK5+LRNLO}xPAM=mVVxNS##qf zl>N=eS0G-`KkV0O0HZiT%-h;p<2^`}qsKl1E7AE=PAYh?<+yga_FOqodZ=;~ZfDQ( zAh2^ld9(*^z?WR}F}SUx-jV~uX_3Sb4G8GsQuN#7IQc~J^`*_Yw!`y?oObMTf&GD=Pc~q@A*w(sOpL!3WphHB`08Wc!@D}Q zhol4!RRgn*&o{DS>{44>k0Gv5XX%{Snr*vrQP1@PfSDUq8CPpu7xG?_rT5KIFeKjn zCdLTbs*_(q?sPel00$EsYtTAOFS@X&b|@LK-GTvgrgY@yU!1l^Gf3L?{h!&6mCjY8 zR*6-O06=2{d`Ig*Ei?_!&#VJWEfS0o91pF#Q<7b`L43=%wFaXo0(lliGz=TChwjtc zRxOrA!{|Z=GXkg%0@_J14#}r75uc2Z>rFV|3#Fkazzl{(l;`H{pcM2JxC87DbR$CR zHC9X5)`#9K+u37bgB`!=crITko6mxI{{4@IgS1pCb{EGI$f-cZ1P?#=T8U7s(fIR_ z+&o&L29bxQhHZwRZHSF8qA^$zUSOB48F+M3BR9{y`-I_fJgANa?}(O*a&EHv`6F`o zV_Ar`^8Qx4NycLXcrc&Zgj;bcNoV*wz@jdB!Y1!+0fW(WF|^t4R4zd_PjBCKP8-GZ zgI*f}(=ej;_Jpx?Z;PF&6A(X&E0Gf8UkE4?+X+eT9ug+D->wgTfM;`FE)Kmj3`KHO zBTQn-sjL$1ic_h!kCd(~94wBEDb+_P#v4sr!;%A|wN3#A%c9+bq-1Ki7nusO)-xc(X~L zIm=&+S{40VF+c^u|4>rc{&L**@H1Y#|Kl#MqrCD=WC-ORd##UbfHH_I3f2;I7=8jE zOtgdwK|3Vuir@SGZBiK0g)i&~HaL_gZczwP_y0@QPGr0T2SqEQzH)#E5TvK{PFKK_ ztvFa6fLDLD+Ug^2^%7M~I1Vw}+MZlQ6dGU(HAaNr(|N$Qt93(?b$>lu?}KA~xKzTb zOv}Rx#tdQwF@4hwP^aA517=IYAOQqHma$bXQ_5@G1J@T2^^gDM(?dNFJ~g(q@!Q!! zLfU{dkZ2MWvL(^A^GoN|`Q69-9=+k3jafXk0KnCIa9>St%kfcN_ma+|*UW{=X4*?* zy;@!?NnkSC%eO|}Jha}}%SoevwlqvGTSdye{OZ5L7v5|+;k4Ydr|@=<^N%^+&VoEP zc3Rum5bSg3_B|cWb|017H@CQkyhm%)Op7k`aLK7WO!#bkf&8Su`TLyXT$(TVc5(~E z_U-xwCkUU$!ssvIyp}Amp#k3QdjVc=Z*9TrxEgNq+;N#}8S1W7jurhbve?R&!V84WztN)Vx^ z2$wtaS~V^I+t2$Ef<2X$cFry6KoxsnoC(;>a{FR(Vjr*+xPBej3fuQ;C%+?Vn_n#i zMGru);!Y0Tz@^hZ^F%&D5BqsravEgUq!p8kx4Kwml#&~V!`s27rrs2K+Ah6SGoomsJC zFnEB7jf;VkHz9Ir+3iSXsrEVPU-eH}RkIn-LPFb~gAE$JDlz;b!1cDm*E$59O%ztl zHm`j{8SiCKlW{|X)C_|mRALZ-Len1$C~!>_dL7!0%;|Z((jpy>WczU|F+SiE@zSriiP%41|LjVvi%0k&0YuYZLBf z*~z?NeKyOK2=o9BY5~JptQj{rBkU{((65T_-qm2Bgmi#YnV`V)p)@s31rf0z?wZ>2 zyxQeU!amz>zi?_GkBWhJFfQ-~cCLzTyOSD@*ig!JCXfe?uedE9)~2>Y%=pl*efR+w zz3d2_OaAr8T-*}|F?FOTDGsC9O7_Wg1ns2=kq}#+|JTNQteR?+9&>jXPBJ8YK;zI? z_OIo+hEPqc`u^PXZFPL>_W|B;m?ygkmjS_+B5F@CwOXT?*&@HQ9Np@*l9P7aV65C2 zF!(j$&dB)Aa+(R@hMI|D$|S$02Hb86IqGv?7n^(|;88qupg7>kYZe#h4eh??g*hn` zsAr2dKc6s56RKOFkM)SZF8{Yyh-oSrF<57P$z4+<-2r{DiJ`eTYm>su-P^C0J`8eo zXcBh3Of0I^1iTwkF7lOX&e15vmq^IiyDDGccCBi%ELTqJKa>Bg-gu5bv_*bFJBRGd zK9F;2&T+*|o0fQjxb=J?06hGzyqk4P@DQlkx+k-Rs5-v93o3?Vj4rj;BOkKUASdFH zedX-Wk~=I;Px?2u-`CB$Z!b{UTb@XJlX_bDRyO(Z!j~b`&0`yLQw3Ze3N^+%{XDO9 z3!N~jug)l+NdM=be^iEzGc1+8B)95n>+Fl8xjEyLRXL)!s+S)tsjEjto2YlS^3Jrb zxzTxK$63p)#s8vM1(qTQ|627&n?7C~5M-wy?mJuM_1NvKo5}t7;2b-xTf{;_8(lgKuGm{JbZrpIjRl!`9(_M+x40r)2x*1 zS+8HqA(O`7->QwvDhz6A?1|++S5|7vS}2HKvNFTNY?S-Gb&ZR+a?h41ol<(DIChTW zqgB2*mttbM+(`ZdtS2FM;R2!G?Ldv-`N(50C>LfGZ#p#cwzH~p$KFy+Fk#Q|ca+g6_bV4;oI(eIh}LYOUBCp2-T))kfD8*oWYH5>$Tl9$ya` z){98xUnl9>$}&*Jo}ISxXat7Wn%dI*+}i12N%Sd)N#dettUvmqZx?G<%#vi ztk(G&X`JU;j$K}3OZY=|4PQ!Dy|J(Ngq-tegZat#U5Zlu5tjSt4Mbmv__ykca#bPf%-83~jCr5^96Wc7G!unyH}DjaPT;55K^E-a zEW1&H*VzjPPZ$T*8&gwzN6J^Sw(sW^rH)H?;clHS7EC}1l+UVZC!|q(vzlnX8!N0> za`#L>p7)Oi{7jNWRX$a_AxJBO&6IS@9v^Ond<^wpe1Iw<3mc^(GKDj)Rc9w%hr8%P z>F|xK5v9dZ9qjBWk5$ga#kwSqjOkan=<+Qr9x2Z`ZKiRdaK^dJrqTGKFn8gg_=J>p z1FO1of-^2wmg$w74BxCF1frQz{w1ePS1@WQNj0swY;9dY)>LC7_(xg!HQKCTzC(q0 zYVTHi&0xAlbG;|CdNsul+_r{0(?v}TRKyla4^)qPNHonlg>(-YrN~rRbQgzFduumD z$&0d{;$idTaYSt%)Z{8(+GpbcbHYFWsI=4v`c$RNIhrKZ8{g@%_TKr2+FO_6V32vC zDuCu&Lnb%Lh*l+Mj?u^A*!O8%W*k3Kj;qab$?8othNFh&q1OJcv9^CEQu zx>XJzjY=teAGrP?CH1Z$Go7~Gt>k?Ll)ttVEeD~+|m z+MfQG&^6Q6laB}oh}906Ze-QPC;vShph0!&gT9_Cb9>Y6i_D`!w=8U<7nD}E7^QpZ zKZLh`p{*MhV9vazuh*S|32dLGuPd=8EW!p5PRmpavONQB8C_*qF@JuOv5)-E`Gaw_ z{*{QE`vHiKZ;3wDs;Au;dq9_pus^PRmA1RZQdrzUvY>m2jn!lza06@EJ+Gfsh&cyayDe@%UqDRP~v40Yi? zm4(1++o&H?tUh^~R6nNd9XoO>Jqoc@dpfsxD`Lzv5gl!}#`hHQ9!H1|)+c`&lAMs5 zf*f7BSMhHsFWV{#B=DCh%(;_v{>}QRbTTyatch|-$1BI9q~80U8ayzLTa-Gw-`mCv z#oMkYt~4Dbc#`3`U9dw<>vp4=v$zrMH!{_b&P6vBo_Wfx&X9|Y>XdK2coH_0b7h?q zw30Z|GAFV)H0h?3>Y00f{B6AjHrN!;Nrev;W>yBkrFV^%NbO&*8QW>y>B&nM?fV9GzH(2lD!>yRUPq(iW-VzZHe=A z@u6WCD0&c9^`Bp6Y#^*}>BnSw{|LC43QU&NBnL}li#2x)c$uOVU0(fY%?+7fq)gjN z8tt7fZ<=yas%JV<(9VSpU#^YT$7*LO=eE7b*B($Uy%;@VqP5}Ln7cJI)|{UudVbUwgSzI8!mJz z)*cY9PhaIerSkYhqi4*NmnG|+%(q75lwJYjE|swgrUlr?CpD~8PZylT59>O6zf2|7 z<`P@bi)DxPW0BaFuFAmbH+}UlOPcoAlEw^bNwe;pS38?xi~K7V7Z+E@HfsmTh!hkQ z9oW6S`*eQq-T~_RjVc_19r!T@M%+PSTIZlumt0B&tY)e9@x_m(D;be*E{a^X-S6Gp zz-`Hp_ioHsmZ?2y@~nkrlZEG5xKn!Q3`b6oq-Hno&i?ruAR)08M((}AGP3>Np;+A@ z&D)eVe9)@BO$S$AOp;|h8Daf-TK-S+*@J;R54_u(zXeuQY2X<-OWyEHUxS zxSO(fNkaZ!m$7q*9if^>7BlX4k$rL$(zgxaFqeKg?xAc_^{LccKh@dAw3}N!{)4LG zz&VO_j$XPcXINY#;lB?pe|_{#It^>~lrChelKI!9MEIB%^cCymg&x+m&3(YWC2Jg2 zk*2%lp*Jf%>ek|!0h#}P zxk)wuaLJ6n5DnbX{Jo0A&vIX@?)jFrN^>jL}*!T3#PQcSeGC>-B5E-<(K-yhtx zPi8WMwL|F9Me7GEMDEaxE$+lB;Cuf5OZ4;-JC@fY<1B#ex>v{N0*~eY|9nB2#5i%a3DEw+IPi4 z?B!=?m7e)1T>|aHMs7?#b#d>G;fkb=Vxo0AnPIZaWMvX#Wiej&t*3nndPrpkM~i)6 z^=K`q8a={Ow!Y6s^e?56nxp9%w70j3!Q})6jSr6Al2E895J=+M($7Ygo{h$(rR@1y zhLok|d22>QTw){CWKw&#O&I?0=(t+G(A=v>_x8}+?WT#Zz4z6HXi(!SR>UWX-BUbZ zNf+cu6N`-JdRqPoQd!KfcwJ}>>g*zB3@t*vVh;r*B z<#}s!*p7=r7Fl^-=MutV0nL*@_ZKuzMr`?iF3mAj5M4qw`SLtpN8t8J6ezI@~$(sgY;c-I3>^Q&zxC1)5%81Syg0vw@wOjU?FnR#$l=17=B39uUt!j-fm3Ib0)h*A;zBSeKx2n zkHsjUgsXTgkMUVpSVXC3vL8FB1UFr-QI+;Ufr+C!6vaf5(p)qh*xFdT z+s2*wtf0W4TwT<0tU9&*x5k1g`s5p0JgzautMNXXUi#%+JFQZhrJP(Wh3;L#c5GKB zdtA2)Z`RwfrK80fhVB_vqvniYn3}JefIV1*B~~qL>enduRNG~ zV;A)u*qE&d=y|x@F;10(&B(~e1<`*Yz|s4@Yxk5WV$V>Q**wpT%qDlbZt~)L6X)av z%g?)8UeKa=^yrbW{d1Ge%E9>0Y;)ECzH|Y4TN@bnEL0x z>y5A7`pM4m-;0X((coR;90`D?tY4PK7tsx7RWR9W-1=#yoSS7oD$|5SsLmM`r$_b9?7@ zim0=Avbi2PT|W;6(d{1N)R8eoH%HU%8Dc2UqToal@(^fJV=x(L<8QBL>sk0`LF6d4 zsm+nsk*r}b7g7!f<+uA z5w-UgELft)#>PCQPmo}IbejjNmkj0J zn-+Qz*?pf_GVPK_8yYwQsXo)|=>k4V5|WZ?`1=*T%O^k^p|Q0M&2anQLW~}Nd)gVW zdP(fk>3G8n5w3Am?T*Wz&N#|^IWN9N$>T}qCxLo2BnD4r@&wyz5qlidYU@(yP@MPK z{Fm&hA~sIE@oH^LHp(rW{_zzO zznU`4FbC*8?rd$lrmQh0C~aOS6su@eZ!~&Lv%ns$L>D;d<1Ec=CyuKhJAD6JKp6VB z>*6w-)LZYHwO)-r%@gySALoC1w+FafcdW`?IwyKy-}AZ#n>HeGj{_j1OA(($0i`iq z$I)T2P*pXRW3rn~84~j(Zcy_SUD`rERpd(fkmo!beDb>@RZxDWJw7`LlIKtA#{|>!q>vSo$uwEOCp|w{Af_gbqH3K9XK>wU zWZCNpoD){HrX3L}v8?&vgE6X?EbL+?q-f;Vr&Ds%HJ<09@s+_jD{+#r@yiVcISI->% zl^X#Q+qn6HI%9y2K9Q~y{O=0ZulamR$A>}3YF~X_$6^EKPkb{ni>X)n>3fRT?`AdF zm@C1Twq$z2R47sLL2ymbxJQ*GpgOHaDTBhyGWPcN5}pRUAF*-jIHw!+f#Wt;#*p7Q zP4Vg2vw2rsqecSEj~^WOc-y?}nf^A}0f#C#Z1kE-J-)a)_z-lOWJKbzh2u?+qE+Nw zJR?KXt|oF#vTRls+veF~WJoK$2TS9EmZ5CgtQcY*)QEdLrv zknQ9fR(A&(Vj@mc#M67uO=2oY;ND9RAHTz<56mI+ZUs|~pC^;sB?7jpR@-={04?p) zjOCR2Ldl`(3Bp&6L=(CA?Wbf&L!5Gr+vjj;Br);RkBkLEX^!O>{V4H>{C|^hJJk=r z`Z=w3_=C;6J(8`52R36*kvxBKmxD93W9&>+{Cd!?nplVQOK7BA^q0m4YufO}hPK++ z+IRP9nv5`e%Pw8HlX%z2*je0=cAczqYHE(sCwbcN{VQQ})CXLuMQGWAJDDp-U#3Mm zU$Dejg{=B`Jp7MRl}hiKY7E;Tgyvu7eB5|O0|j+MGN=TLZTrumtqA7WBQH-;e_R}? zD7k0Euz_`UwEe7+=u^A9=$M$12SLhjq;{iU{79>YQKeYJX-PIVw$=FVdl}}08JSJ- zE#IHZKX0kxdRk%hY3|t~l)?(K-&giy)fJ2~xRa^lfT-~11M*n!t2`pa(&X5QSKy;8lU;Zs=>pSU{p zE{{^lZ_>wfWYkIH-Pp#Mu!oOcrR82@o59waWwrlme0QHcn{bLJc+HAih-!z>AyGi> zEfc39)ipI-Sf0(syRSe?(9;@z!@i8Ex1HWanL3p}I(v2U%ZJ8d-@Cp_Gq|Yk8MW7} zz#?999H{|DBzWZKs5=NI;(3X%nq8T z&SgZ#1;CZI1%f2w3yZxf0;QN4obxsu3unbf-J&b<8?Iq~CZbvr=MI^Ce*lBI)eYpr zMg}ll5_J?@bvvWWZ6HuHPRYRBU%tOtm7bZInK5{PB<~k@_qL$7Z=?#tjiPlVXEsCH zLlBdktfK2ExJ%Pm`QP__&&8i(BIkbI*_;sRWKc?@94B#yk;5Aa4POJ(R*?nEHS*Am zlHMhgT51a$Y7|PvDw?)?l07o}cv%Bf8hUwL&H|SAz!vRfWu;U0-ip8xdC>b0W@lYtq~=J@sTG z#vD!lL)5oiXg`$=ec3FnrwP$?ySbe8Kko;Y!|axZT?aMZVnuUm#)Z07+~B z5)C)L4Wr5$oAw7jcOW88BhdqL{shzh`x{cJzbnXQQnhlwNc>*0EQhtynP`Kr&HH16 z8g$|AN*!cpbzE~Fa?=4pv7*!{($&`#eGzk;pPQ5p-FkeS5eJFM>kIKp+x@h65lEKkdy##;muH|EyO@bHx4_9v)7UkCV4}&0x z3aE$y0^$~s78$x!+|r=Z4N46#bPs8Oh?3GR-9vXtm%t1;Lns{sNDU4Db$P$_}_z@7K8$~}w&o^czxUDq4;+jzU1A5tRg*ATXO9?2V?i(*^2 z>C=&3+nZM~9m7O8FaxO_{3Mrp(9;YkU3L2t(3hRP?46b1@Ch(-27(BzN#Vv+z3wTH z1NT7p((JL%5pG&B-mnW0^mB6&Duv6{PO&yX<+HUreY_wfP`^PG7vPU@rr!kmnr_fR zK7PaM-59u=EjQipR(Y=YF=lGX{gm-3i?pnYZf6&lxXiwPf`y+_N$d<{=6O$7J7!G) zmbt`z+e|JCW2QY?sBiUjF!hDSR7er?Hl$?nJo)*KItr+-pT#u;(Y@`qHzgHS_tH|f zlarIIp<(hJ=b@JlKzutgFS1h%L`YLxqN#80TqXk-o)UB$B+2aY_f;75niv@wVaq^A zuwmSjN3pP@4Ujq0>1nfDKSVYKL?|N_fqyqY8Hu1SoKxn8iQe~7LVc5}3WDA$=B9=f+}!rc;s{C?KsB^jRj(Z$yvkJuGAczb=0 z)sd+;C<6UNBG4^h_M=BM)}~hA@i5n#2XtdY;SBGacDJmPe!pkyjGx+Jbsw#rV)6Fb z^>K>fO74#r)I{_o=0w`$uCLpOK-owvyzYUwx9zI-^EgZELsX@gT`aX#7Os7YXaAYY z-2cI(a^32u+UP7WOulZPcN9%@07YosY?7OSaV>jC^3m|Eqts-2%I_LDDy7Vx95yi* z?&iPWZ~lY6`uO=%{WM3$1lfDsd9@rNro<0jNz_S@j$+RXUSf|K?Zp@}nXLq2_*7bx zfxCDilur@`qoj7V)2qAB`H*RZf_MkQN7o+4l}NWp^6Q{!5O5_ ze>i-^sXv@mw;Tq5cNeV#7@YvN8yBh?7gMohJyBKcsjnMZR@@ovPcCm9f^HszWGhN( zUl>CR{Q{st1&m>wZ>=NVSrn`QHBa`10gE?4=(47{eWD`#>;0!yu$T0MzjwWo^!0M| z4JJwrMJi*CTZw`=#|-(!NahtripxC|*&S zCaFawd4MsrR~Y_Jir|$I`FGCHg4TOl8-+^x^z0t1?5V#{-4hVta09ME$CZ$4VBF-j zxhQp}odlNGIHNg5<9hUAVd|i&io`H%YUO__SWpS#D9(G0Rg0TmHAQ3uB3Ozs??gi1 zE9C&`nzxcT_vbU#Y^XB$pK-K1!{mPIdD@IwOU_F^PPrY+kuHX{Rr)rYwI?(7JR2?& z!@sCyZO7hRyrI@KUb`4o-@&%Hh3t3~6&UMYuC9XH1+ZIRP7VnYXlU(3NK@CW!MdzA zd;~GpoQ5Mu7VjoN_wL#j@s?z=%G7q!UW`$oq)U$J2Kaz;VE-UUK)MXM(*94Tv;6=l zoIYIkK4H0d$DS2Kva|SlMylMcr~9WtfCusH8Zw_leGExhlh-l%CCgr1G+t;UV9;d0)UKZ`{0&|;& zXS;^1w_aR)4;SlK>=O!_XV`EHfT{;EZ?9shviqdzPTjyQX7ioCJZ3^88>sB~v*u$( z8wKw!mmHi#8r~~UH3ut~vsYnG4^@i0Mau-xx9c^Wf~0*z$TuzmN}hukFtxHn2PxP>+&|p`wV`MnjuUVjtT9s7$@i(4i;2MP*HovfTW^$t#7#K2%Uvx;5cmX|~&w+PMy(cDqN{vsWd><-x zDwgtWzGU#?^!%6SgS@-E?p+GKk}f5~d73>S(&;YnnU%oBheoCN_>AfF!8u^q4FX+k zbjTEr$n<$Zo(~VEN{AjYhw+^@!A|VgjMo3iSH+gmU;NPPw&Dm6N)8U=!2vIk#oKlM zL9?pC!IzE)y3>bI)wY3x;#h%wU_yJc@~`2$V9cDe)+i#ekg}=YYuz#9>dx-!Do?!> zHZFTwY==KvsgiDBXdc~<3-R9hrj;~@m;pDCxc&LskJ6@?vm!2T{AchV;rh9$UO|P(Kg(HIV0Yhn4 z#|FIpamdloo2xIG=hID+3U3YjO+1m~?ctD+gHOq5=5Sqs6MQ%ehZrXv6pR>hvVHXi985YF~P&K_2(BMr@v z^^Pxrmw_`-S z!*GDqvGKu9mXrj-K!4ilWUzQ-5$*h#o}RZB|7dx6IhGIyyP);0pHBpp^+cYM0h==# zvs$r}xZ#-vKTK5g5q{hl4N1)2tCXAm26$=tiC%Bp&^(9?s_lse>Q>K#k%TyY@5?CQM z{PZ0k|9SH1lXce~UM zr!sp6I2vh6rdwGMk3E$EPApq3L>$9hK$BadNrOT$gWG zL8hEvh?38$TUZMZqj?9IfEo-Gn7qi2OsBG1p3-Ta^yMYZt;LabLv2ASfj|& z<$3#xLoYKbL88PXnu4aa$0Tp~wp-?pE9Vc=_75!$TO6MM z31TRO`oyqiWnM=vGsBY7VLuUIbGlt3dg{|~WUCRPybl^u0VegOb_Irb~m zPCOAUsju82ttQL^BUl1(R0lg{oKLUvR`pG!yEB5^p5%oDJ4N9)(R^dUw5-ag{` zo^fzW?Jq{fefRJ(M*N7Ibo<1_NVZ`0z`$B2UdgqIlgE6U(Q4%O@3E<*F5U3XAKsUR z2k;ID3F(gTaoXvl*>-+=(TgSb2Hpfy?$(~n``6Da(-WNND@rDHC2dAFmJ$UGZTiig zl7ywjzH}5Z?2K0xO%`mHBI--askBj*rih52Gy_COWelYncsey^0#EwWE;TA<(Nq)Heit9Gql)#sn`aj**8@~C$- zXh+8=+3f4)FKTm1NJyZkr=>PJ28nuyLbEGa*AyJlCZ*?jExoKMpZ4wCIuywP=*d(p zqcjszvL^*&sZW;Z3clIyb>)ga#}E>mIbPoo+y1X^ADsj%=nwl|c2}?5G^Pgcs9mH` z#;^gxgp1ry0n%9gXKwa90nvzg2OSHv%u0( z-ye{*k0tk;siXF&u^01-dS*Ar{L9O8O0TY}7vMg4pzqE?L1iOfpiN1D98;bn6HmXJ z{v{R6qGv358U?u?jj@uIMIOU>CTrMo0p8Mztd+gbuhJ3=nIOxC64J6D7a?ViW$oK_ zl!*2^?|aC(W-gE02fgXPV_QpL2Vx1QCu5(ao)Qr?Idq&d68Vn&`8x0CC20mgbcf~S z^{B5IXKR?#Tko@qRwMq=-0O6;@v<9n508@F_|%X|MMK=jbI|0wwrHrvHGv z`rJ&ldF`6`x?RAI>j(M@#U8)YN)HKEudP#qqE#n}%#5NU+n3Qrk&0Dp_ak~be+-3Q zFO%zk`S8S}?Tj70*Ziw9h;u1CU5GukFx08cx$|`Lh<7GjDC9jaGd)3}OZuO*@Jg=D zY7f)zSZf;(T001ZvAMSNK96$rC~&5X##UrN zITYe25LrU;ob+8Yd@mO3Bs5AUol)N85;ESoIDQj^a^dCy+7OHJ0$#(H?t?)FY7K>} z@)A@P3CnydyJMvihTI_%IB`eqiUUdiN%6jt%LNWi2#FDC%3})}o%*H4GjMH$0(+|= zuuv%~D#i@hl&@@(GkKy`9Qp|!i!<*1$f<<&Z2(gj&v@hrI9m!MSh4wn?jm3l&Ofic z2QE**N$1_;Dr$a+(23{tDuCi1DMq5(AJfkSi!9v275}Nb26I(FHB)MNBwBN(8$#~<=xujYg->$=Uo8tb|ty?R?7R2 zqw|r@65jTr`u8*pjtgn;jiWnhJF-!1Ws5E!TTA$8MtZJ43Xe#*UqaEPquovuV`_-H z6(@>v1xTNU-WfnO1y}1d^_|t*e3cOfaRnJ>B^4DJyDT!&)>6m6sOLefBR{uLhTu1l zp;K|sNCWh2BjSHs@|7>!tU%{K;lt^*bB+E)L!+1^knAeuPxcjZHpU^aU^$oRGV2rS z6&bWcku{rL6;!O7eT~TSZQ3s!)LKjh~(BT1f4*6DRTe7X{J04j!eK~ za#ogdG87uS-oKOns|W3odc;o|RloVg7S>nIFM#59#!lpNM|#lRzRl++OgTI4zL>ZL z_(Vq?`c)G!W(qRDN_1V>V->?b&0_AZM(!~+f+M2TtZI#^mHbz`^FL<)n{8B(#qMR{LqIn zL?#Kahw;u27(?RWsV_QBD0c*hWLOQk_HGAvu!PZ%NANnTweJ%0kBkkq#Fay;7;M1K z&YJFjk0D4vA8hOi3pLXsjwB{L8&@h-=`S+?U3XjZwgOLbgqxs&H!l$^Ad?EuVBdOm zzNaQ_h@=%j!NzpnnTJr)giBJ!NF3<*%~_e10N;qd1E$0zBPTnGOju zgO{-!T|5~LL@yTd8wv%PJi7HjxxZqYiP+K;KmOeUVU1IQU-daDU-LQ{71h=vmACt^ z_vW#59z%f3H^dGI(2RPH1l@X^g-{Bh^HC%*WoF+TU=6|{v&QwFl3r(tMv%VQE7uZ2 zhsC^Ts6b23-tO1hahdpVVWS=Z>Vj+;M=FSTNIAd-ZS#sG(~7GnR)$A9)!=rs@=kJI z9f|dEi^*e?SeBz5bzPqjS?u`x0=IY`_DrY29YZp2a96CzyPd{F+P1cOf;Qj#SpI%e zILTfwwUN!Yoc#2XgWNCCeZ9+eF^CWP4^%3jWEX+VmxGB#NzKb%RF`AmCnqPc&|z(0 z33yWc%fbLX(%a!5<+T4clS{b;?y*&MK{;y4&53jZ&1k3ai1V5qLEf~{;N=wBs?GX2 z7Y%=N2hbTo^7cp3`dBo%(O`AF7hBGkryx--U_8Yl2(-lNf$(P99D=Ras_qs@oL5sD zT4_EVo&Yc~Pz#|IF^T|1Dg(mg_Am723AUD{6NEL~;*R*?zZpYwnwE>pYuxJ>STXR7 z-|6T~F2pH@SGXK)lsQ@Q#wA+cMZ1sNkl!7EQruvGo+w+kab1fKf{65aRG-P(TKUO4 z2vQN5U5!zAu_Sf2EoE*E&l5-~aaqG^cQ~Yy7%M2r$aF|f?*ZbbGQpvn-HiSvHMXR3 zpl+)DIId%EK`Y}I{&_sNnkKcXu8jf|UvvP7KsM;N$vRKJD+!=E+rFG37!tyNA@{J{Lm|~z z#W~=(!mmEeZTB8g%5At7FVJ>a)ZK-1mhAb<1$f=u3q8L~bt7b!3K?W73B#{tyh-i& zT)0Zr-SkXRJebNpP;)ChM|N$VFc+OT^A(7=^!<3)WuLqn|LV@WbKOpvm!5dQO$o$G zL9ddMkqVqhky_0M?BE-}{ji}*4kPxn)1 z!$@js>g`1_U_|FAw4JPRR_^C__C_oYqFNOZujpLj?ywFV{a`@}?N&oHjtKXvgW$AX zn*ZPey=**tr^rpZsshK$=8 zH{+mwIwM_=or+VEOpb;ax%pL5DxIDwi_#A(E4y^&+Yn+!x+w|Xylzn0EMoOfs&XTM zwR)FHnD%|^z||N55zNM^-EF@U7R5U}c|`%AnI&)+qFeKUFsTT45c{;hSPNM4{(395 z(BAfYvs*vcS30_PD$mdLvE9+Ip9nWtr#dvfD~imv;41zt^^B@4_ep%ehMb}9c7Q7I zWx2O55I!o!P+OR3b8>d+y&`*UUwq%{ttmglu;wz41OF{lgeK@t(lC(P09=O)i;2#E$mgVT{St|+LEUMASOpW5$r?yyY zft#Z1E+Im@6>ya&}=D&b~5Jd$8`N>&c)oHh8!z;<%9F<|uGk~+g0Rs!hmt7DHjeHsP z#!@#^@I)UdOepoqD5oHG#X>r)Gy5nFI)EHN5JV3^5jYkaK?J}&u%t-4OHJqQAj1R$ zl~3>BC$tYZIWBD;#A0i*QWogg~lrJywPuyLK{~I7qmW=O)9;6{ZAJk``5kf;M>5tgUV_y^A$7t?h&C7|HAr? z-te*zb6s7AUwy12b9LRv4wh?u*Xar9gR;2-aUd7z5;mm}2FYK2etTfGV>QyeI3B5- z0jIO50^uNel2gBbqulGd==T>THrz|pln_H86|(R1c6oVuS8392{wFxN5R$Dts2B_p zTyc2NCZ6DYno}U_$;n~^Q za7B&Nt0!O&aX0X5)JXMvK>1B+>TLPch7aPA@~gZ7=Pu86Bf>1T8Oe|g?Y5cAAVG?| zh<~z(R*~|%RZOu4;0wW(&$qZ(2P(5U3#Gt_71}n!vBCD&5n+*kR(r(fZef(a;(4-0 z>^{30FwU4ZpwIG=Ms6VCJU-8l;;6}B`Wgk^nLLkamNC_oT0wE7JMPVG*I>5$reE+~ zk?=*_eI%8$H7NIz1qD&Cs;plywXNz;(`+M7wEZMM8no#Ny|Q9=uJyEc`_)5ZstOTT z0}IWVDi*aD7UJ1@hpUj=ec1`f1R!)K>Bh6tZRn+42av&*9JQ8V{=-&Jub(7L4^!)} z6^(M511SplWWl?7?c#^-QCq;+(>S5h=dq1F#{)yCj420V+dpgL!?nq(A%f zIs?mlbdgoe7D#@mUh^X2lGt?f#KI=MhdGk_djNmKQ!rInIhG1C><>JVXMB9oJzc!s zo0s5%0CR6D`&lp8*=M$8^(wX(eRQ7xNd8!GOg>7WAVdNI zNGG|}esgXQNcF!dFRVAAoeg!sNS+<^&cflCFR}_J@;_(1(yhS_9OK(=*cGYe62bJzcSYHDx%MvC00rP zzCmc2z;aBx+-i-te`4@kr~ROg!w(W|o_-z6@ck{G$fhY~Amf`@whQbZSFN+}ZhvSl zqS#^pV-Q%x=123+u_OWGElFH!$z{Ai8t9@AaRAE09tyUEyHNE6BySW-t;+#!`*~<* z5(fzv(Gc7Xp8Yx?M9Y&Lg@}HQvfmcc{Xk)EtCPqo^b;}NFiA?pTeI}-)6wc~>~}#` z_`o`t73|u|pgCm=+=KP^?q-vpoqa2fESMbm0i;0`Whw&E6~?q*o+Q5UL1Mk0#Bfc3dwzP9rLKD2jJ3F)dS)$(3jR`KlyW<#vbDI%$m+afH zkDhl93}2lhJb%8J7}ACh*Y5?>M_x& zP1**iRearE{YE5cTbU@sFgOi7*(%GDP)geTY##GCiERE)pgBkef|~k5()_lei7RuQ0CbAqKW}>ilm$|AwUV~@ z`})h`3&pmz4N?oPui#{+{76n?I?4f(aI4Z?oToKX@8xB zM5-sp$st`W?`GA>%^C^5b({OrN^g|7EkUQ>{R=ZhjsjXN!0uL+G%z)r8n5r#>8*P; z5Ywuy;&EpN3eAU*U!}k=NjoLVdAqm%9m5!D-HQkfYmGtBXSNv2X{IRXDMyov6Wf1m zd5?LRNOn7sDj?sY=rUf3VR|CT`*UFL``ap%Dhma5AilvA9FMl9$`OK;N>n^`cvD`Q zqDrmp>O1KeIL1V+4;lgv0CK|X<>e(HMF5i$*8zA9cp>TjvwO%@^N#lRIS>Mxv?)n< zeF*h$fsZdo7KR<9t(>tH`JAlIn@b&OyVnTv_ubeTAWCMmD588uq%#UgIZ2v}JObtL z(l{IQGJDm^+Yk)~EHklEpJ2Y*VB}~mi-@fIMQQsGm#*H}%nh>P1$GJz$Uj48aIY%^4>aRsdZ6$I=5J21iIRW9X&N2> zg|~9HYmgvo=oa(yK_F15LE#JQF_0|#2Z4*k?#Pp;K)c9S4QIe}#oGD#)4|+c96owT zkC?`|a7a`ckdPfc#f3rVYW!V)#?M8>AIGUy&Y+DElA92g-OIXEbW34(H~(`x{+w%S zhV+I9Kv650^_$r@LyrC#gpI|m0g*{zPL?HcVv*OH6*uh|27&S~mWNrCdF)!k$!eHJ z26iDuUp0W-x-rg%P#zOHVMU2aSK8Yn?h;}t9!n*LsmVH`M~rX|KKx~Px^>erPQJzI z($%r}<0&hJ!lVWHy+pdEQQuWPV9M{&Y&=w_8Nh7lVjpHd>C#!^y{r!kRM1>I9mG4e zy->=TF@^!0F zo9%_Z601=jj6+(VAodDoc-Zu95Z02voZHM0(vWB*@p>&QYysB3uWZ?ZGhFbtWlKL4 z_WYJ|_cuDaVJM+YVi}T^;m3+w-jnV)!?j-0@4_a?jSdE)N&^EaK<~Ab;kH-OUfp8s z?-;U3oi5Ot!kMF%yNunHFI!uK=moeR1~t;zIVDxN@EXL1vR;skIH*`^_<5f9A+Zy} zvS0x+Cmgihq5LWozTW8UBUNp0XD9(A69PrEV5*zQI5f=0d)V!14Ie0v4e(|$);T06rExAr6r{QM)z^2B5oh-q z<+q(fs?!lJ5MHwn-Vn+&>iYRiR6nIyAE^!_fH*TF4>tw@>G`N+KB5k7t4nBUs4bP;=|wQF&& zR3+pRm!^mKFt9kIMjKntA%UqMB*7#`s0s3Vt2mydh(4sD^anXIx0OEbCorJbsba_^ zDCZ(wGGaaDOG^HwTEb~jrMc@dZVH=A246?g69`tTUwv&$?_&%$MMdwc-ntpUXePRB zB@Z}-#tvrSvA=&my!cUg3P~ggDrp-Y@{^Fr){i{h2T}7q_js=ol|_LtD)%4F z={>xS6A3HJBK_{cB4D0SvZ>$I!0_azvLgm{D{T`0jJ5(+BZ{@tdeJAx+xED;S$g5Wq3L(b=r~u`B&f%MX<3 z)sRS}m51Ks^eVD|EwX1`ku#5Mxx#kZM(3wfoTRs_Yb89v3!rMSA{PzHw?9VqD?^<; zAvaiOp2051HmCv7G|Wl@0}zLS6%tts@CvjiFBS+JRvNet$03e{cY42FND;RVp!U8a z?8t~2)&yKCS(<`i}n2tMW>i3m=G4k=3PYR>e-lhi2ECuG;jnckL z#rCPiDx+^32K<>2#u$wxrFg;ERgiyL0Cy!ODr2Rj`r{j#u#lCP)?tCnY+STJ|Hx`x zePzO?@(#$JTNqj?+f*TO&tT%zx=hzP6!pCtM*G*HK~(nCXu~&2P#edPH0tPd-b-Ct zSR?iB4=?NABvJ9rF;F1SrAm#KB)Y(?3;5y9{dRy4cOHNAynl@kQ^xh!$HdUK<=A9f z8#5;uW+$H-DkLWnAk4YIew}O6T@?fe+EOBej&#l;f&UcdIXe9-H1R6pp&oO%k2Tg) zBh{^Y?h(ku=tYL}&h>yxB`6PQs#c)I)N{XuNiZ7x30)jLfQhMiEa*JZds|FHER5BC2s*JY-uvr>AWbo z{mf!EpFX*t4b(j4Q{X8t|A!4?MFkvS9*@a#v5ePAUj)jI?&9GEiDV&Tomtq6%mRBX zX;!px>3WS9E2=UR!|59I(GXN{H!NC5q~sZ%`yshmt0CJo%*G~_s#JrUDS>-Nq&r3e zSNjc3;6H#SwH~mBbB{N8)sAa}ecUz@n)kl{Iykc@C3?(XwUV3H9gV}`=7BH7U}*kt zxQs~WU-87qUs~NRN#**8ON?Wj<#-U3Vab1`oEl$#BysIG>?HL!tvF9s8F}5Kq~0+> z0Cy=nG5}n?met9NJ7)FUiHGVrr0C>oaL_32b)a}7cJ+0sr~68GLDQAIZCO!1da(<= z>>Ykvrl?1i&-PwoWaOkf&=IqyYhJ{|-Kd*pa`AT%Pr;E6RiZ`MjkfLrZwM!^Tk|Co zfa?a;TM!WqwLxze6N?8O6VuI*tgRl{U-KN1?+5s(s@3WMYE)g?C}e>v#pNCNQ+Xj2 z^7M<+*-RP>KDJVfb7|6{u&^3A#@p`C{AZ-my|DZ&GFJ3AZ3&6fVHjTNQ{uKmJqXK752JzGX z@R*yH4yb{n6HD0+hME%v5NlWPg+DyS*tVKZ{&H-S`jd-L0t&Da!Sbvnt>Py9-?%&K zM{Cb|=nSX<|8S!aH&0f~!&n?hbHb^#Ox-z$Tx)PyzL4o`viG?p*fB%4mz^g|1}JWC zZ>vd~zV*PCWNpxZBVb3O2{NemL>m%75E`T@E#^{a2YU+0&5sK4!oT@rC;;i1EMTcY zPfhXI>^0PLd5Qo1Hvr$4`Ey@AYMT0lGJHFAz@)tDB%IFwGxBP@Oa34!F!B|UvFel> z7m3YP)=%2dza5F{rfrFX8Uj}IP zSd08_5tCSP1q2k$QOaowbLs}%X_Ga{>9a!%FLH-%zE?fwX}oRaWeZcxp+tI&FBVP_ zT{em(BS-=uMbr9)yi=Tw_0A61ReL}S^`nhN&~N>}KmLGdg$4z_U@gg~c53b}m7j#s zDZ0AuGYdcW?XlGyEK0`6Rs`)ES@8`n`1(HIJ>W2`vnjgF<`2{{ynWB#8G$>HHJpe2 z`c~$d(l$ecD%1Jm)(wTgo|l*J_ky-tPbh6-O{9qHHa?imqZ1y_*Ds$CW;Z|2Sv)=!LYAZI>Ya!?F5eU~4>Y$_KLZge`5yLgsp{%v-`tA1Pt;TkE$J zEY$i*J7HnJ63~a4Pb7=jSQ)cA%0NyGv18#c3AIJXn~kbY`?!pMVt9n`v==drqnE8f z_6JRLRWCAvcTUNOH!-c4MoUrQwUy8`K^(gaDYRUG5m?icspgkI{S9Q;-_O8}i745! z74g-Y)!SpG)H9!1MeG=}+l(TcfI>L5kb`*KOr3iy@7{Z4v~!Dr-2JOzfTjNef0M%p zzu|HDn_v~?bAHyZ=5z#@vLMUHtma1{Z0wBDGI~7Gq!Yy0T|%mHQ6J9i9FisK_J;gm zx^%(};P~kdhfdFd8j$sDcySMu%!_z@+mH&wNs!WE27(WfnYT5UzTEGvrmaozXo`>17;CY{RG$5dx23=br` zJkg}=v*T6TSvwL$18zZ$ZGUrJ(C5Blt>r@YOg%r1ttN1 z0Rkvu2d2D#o!oGj`!{?%U3+TK?a94yBugCb-i+Nx{8O^z2Dh6*|@mayBAq!wtF!{xkdgTzO47(iD_i}7D_S`Uy>jX4fxiZ zW`44X{{85H?*|+zo_(vRELx=+-94yzcNzy2Fbkuo%C98I+*eoWvjE4_=+X1Zb zzdxaG)HM}z({y=-VQgVVjifm@CGzT9VP9@w>1YOrNRdwJK4X*~v+-LGRos*!NkU6F zm0>`&!9}KPWAXG1MX$t+Wgh4=E`CqiH7N;;AtM}v@XcP)NM681$`^bgqU*1}(EooA zHm;b0wBp?Dp<3hq4SP8dc=U`_YE>NYY=j;D@V=Wmq9C#>7mdqe z(@|`KwM;1dR@mTNHaw?C_W5(wG&IAK&AtN_c(fxG`hAh95kU)0W;^niQLlQCFeq z(YHnnu|A{pJg0T%fATS)4;zI)hqS6$p@)VjmPdiwwrnW!vAmJOtivdf1u0Lzc!3hx z^9U8)%VK)e>Ox~@wOt_>&?t@dTDzts(wfhvwzW>At_nXsb!E==v*_Qts*ovUzkrSc z+B~>xS-kUe-K!m#*^=iY5AjX+?0DKE{+`jHpZb#NpZD+{K02lH)HtBf*Xs&fc*-)F z7Wj`Rg-#O)fod8h?s>*NnA`;AtexH6E+8aGudEzR0Dvk67srjNggZsxgVzL!^Nz?i zA~uJrVyEcw0*l3pia_deJ^k*x&1Qe@WWn-f2X=i{%8U@!XOBJ-qEN_hS{~=5_&nTrn1OVJvR><~gpQL}u_SMrFn}^las6LBH;Q z{@v(_k{u!t$|rYiM^z`mdJOJ5-+CzAGT2ws(?%17jz(6{DoDgsjloh}L62B$RI#5Q zF@Hg0W8-qLIXkEwU>2wBTz+JGXZ(T8x@$UU%QRAmCp-`TrvzP(e!o|?%QHvGy;QR7 zfd8}}?#ax%tf%ul0)+XA&lgyX<=q;5>(9bnYHg6E3Bc$5N$<@n@k=%N1)XKrKDB(# zz|DvMcwyi<$S6naZ@vT@a_(U6vbLv>>(1ys%50X$f1Ng$KAU$IGpv$Dc$#_3$uQ{jmTf311;C zFld%0c07eV0)EkVVob?ba*i{6Erw2SdVyct*X-0jvTMS|6?1a$?~lQF@4Y`A7tVde z<-<)tE)-~IyfGwJ6uPA_PNm>;>HSzPf=%tdjTDsyr8cM4k8(bh7InIb($;XqEKX6_ z1`LQ|tS&K8H9!Xw>&hiywtzW$9v*gHSCH~T6r+zYpLG&u%|YSEmV%&WXu5y9eCC~d zb52_5bt|Fhat7shNP}qC=BV<>Fx3MP$e|}cf z9`Ij12?qQPh^tW*NzfGS+og^Mb_Z!-7iEhqvK=q^7s>!QuVvX}psPF2y8|L^wgZI0 zFCLYiBPDs2inrHi;=c!iuVuya*XoPfqxBEZluB#mugJW6zo}^RB#GYQJPA!;6gB=p zf`{T@qGJ2=KzlXU*SBgkITVgboO7+rRC4pLO2le#ia1zB7wI90ilVTA>8b*ho0-b78h%d z+PoCLtn#K0%U=PsbO;47`Sq`TZ8(4NWC)#*!Hp!!R4{XV6viPK+-H_5S^GtUdxG9r zteETTcb7rM&43baD_b$Vtiv<#N!k<=c|PK@`TC7+-OMMe=!+trD+{K zcgY>Zq-D;lI3J2Cx!FC8iZJn(&37=d_Au%H^+2|=5eFmj7iXqI!lzZUe0Kb4Hh zixI(tFH4lN73r-B>tAGv?~mJ+(Y;L!n+m^xuU}CwdW4|NuuHUoO#wJ6&a4h-9c2DQ z!2q;uaVG`gI?&i@6hz#@o#dzlqjE!RhoCYYh?~tv(C}zQ-`u?rU zJlIG7okF#yDuO}8@QBlgw(7;0ArCNI;A>MYc5h^BSb+GwCyi@sVZvXudUB0<^{vM+ zp$QIRL6o1xzKMaz&-*|$nHDCa~fkVym%>; z&wUx*@vDbyQ44xPTOLh|fNgAW57?Clg8Qtlg}(S6@b(zp0QNO-Tc(RWFZC@zxDKS0-u-`-pMOS9+&1V6I`2s?NJ>U*rID+*Y=ts@SNoY_|NrU zVF7*f&HJH>_cdj)z*m;0RV<|aq;k+HU^3T*&6RXkhuX=8~shd#$nVIunQVqY344wB#1o~-HRC0-fTg$1tI z?^(a{0-iI51MS~AJ#5kqx#zv&*ox>MYe%Q1uGW>>tduVBeHHkv7t(JJ>kf}`9Wret zdf}0S%f|H*2~-N-8&L2gjBhMYp8ph3jXbz*U!1_q9?plD zoQTT{q#`5`rKnfw@hq>ev*!PIFEJWK1Of!LK>KHtfo3S+^O!-}H})JiKWb9Ff+h|} zr*Lf@VVXfS{LJh-=?08T^I~;%0*|9^K#_C}$>hRTa3F&jBjrB)qjHv2`_mS!O~ncE zb|X)_tj9TFqdR6Rg^Z<#SacG27rNLBlvmnL5@0XE2) zS~dsG%MAjZY9u8eYW}htOMtar4QlHZja6i2N$%&50r!gqhfO8U({-3hoq|kv@g^R+ zbN=&>3!w{60zfdcEIIR9UI_q!`DP@8ty>g$b@-SnD0diUmF(rY7T5_0Kl_M(2WE@a z?_PP>QMKfBV!x7k0iVIvTkXI3wO_xQdYrc|nPMK$Ipc!GN>oeYO=Z8F_r=mDM|oy* z>@g)-UyxmTXz?WFqDaX?!F_hb2xcDLlp?sY{Km@7wrBqa&2h;V!)uX<*Im6I&ePF3 z33Dy)xPFqplL=P=Y%UW*k4u0t_`XcK*sbu6*KKd>V}r-Kb*Ta~fFg0ADPu~7{+7ZQ zu*#(YfL)b-l{fINKb*+ICC6Yp?)Hf&p=@b7qIi@tAGJf0^3|>Df zUQ5F0QE&|FA2cANe-Xf;kJ$mzb#qVm;Az9X1odwPNGt4U=bN;U*oCsx*3g~vM<8$T z&DPh`EZGU#Xgx{u@6JGuj|t7{bIFL36r*d$(N3DabtzWteZM2$Awtzk*4^h#cZgn) zay9;tzO8HSC7z`k;>;UEkn-}T{Jgw1TEZ2h&;EO?B1_x0u_Cn7h+XrcL`hbqV)~_P zzduqS39=#JxUk3v?iy~VyqL@dHlclIXJ_uEZQ>*OQI+T*UJjyxi#te}Wf>A!iqg-& z(~(oW{gT(x?7{r$e3RP6u(xUI*`t2|`M|TNSTEePmEIR2($g^Zt?|P-D2DwUWAy#f zQYK!Ns>*UeXw!XF#Tr4XRYk`m6H}c0xMXqtolXp4pK6kRG~2=|+Ya7(%66Y7h{8_FV7t{O-%^<%@nj&)MhRYp-=2|AQ*N>3Z5- z8@|LIxj-RXecFUDUJr)5ViYhHt4_nXFB2)fU0v&G>kn9$6@7hu!3z0*AHx6r*Y@o! zHAU~@1MtZ15B%DVy+HN#EVe5a9Gr0wr2$4Ucqhn4c!_!=_8 z_urhG!A~WXYtGE5PLdkwRKa;NRvO7iD|{*ZVYID zYg^N=YQ-C7m2kr4mFe|z)^STjUrn2C)}#?6$nz4Z^!$^DzuSAwD#f6iqiR{}l=I=oBMU z1tcop>D{8n7SVh^hki?fl%;o(Ij-1#K|uL6)NITG2i(%btofZJ0zJYp>Oa$rpsp!> zR`kkIo#j(fXhY#k=P}!mL^@M$(B^z`*kJU4-xgf75uI}BTQWtXR}%<`(;r~OpK2Hy zR$lcOApmXD$CP&s&?(DWvGAJbNlM`BDBKF{R&rX5B)KA_;~UbQRD*H;|Yk)gAr+~g|5iu696G|dg6I_ zVS=Fd2b{pcAt_aYn9W-(r}jTTY~uTp4|wwTWosATxT$_=e{#`x_Pd8D>jy2FN)Ym@ z34O)p5S~*;Y=(OV_Ao)RXWy&L24z9gFM%$TCuHm3Frc)txe1#hZZ6RyK`KbQQo6jF zG!ma#_BvI5QM z@o{rByX8dMoSKv+zV^w*cOh@P(nlEw(ma7!qwy_^tRm8fxTQPiVIXL8o!xc&yJ<;dyy3 z{JS*hsBHy+FDvZ0>ZNkGT&U6XvNj*eU7>4KZGOPaJ-u)4*Wr^lUri^3 zL_wP{VI99cA-wh->K{;#=v4Ja8Lwl~KMuYI&422lvBPt1pE>cd0=$sb<1?h-h1xma zq9$OQm|E#>1f$nQ{xTosPT1@&0V$L@>H5F3?w=jO)TLuo?^Xd-h{5FSgyv&mJcfT-CG7>m|r&+KZ@OI|ZK<Imn>#0+=iXSB{`|dhlD9z; z)Ma~8GEWF2BS?1ZDO87BfoC?k>J(V<>;mW!YodRC?Joh?a)Hc;P6mTDUde;(D-n|h z%@Q>K+4Bc&!1$^Wr9Wxpa0&-;4{b9fwO=$nZwYK_1u9?r-24D;*NzgH9n3XTgaT1%%y2a-&a>I~OZoWjn9KN`oKj9Rr^YS+ zuF(b1rUvt)wBbH)Uqh-Xnb|~&pypof!?{8YF`=ykY`#d zLf_6s$S_;`_IkDKGdxn3_V+b`Y${W(afk;3G}N6P-^oUrt?K`L6Q%(*GKGZ8H9t3) zVCR}eU8O`%F0@l?g?}hRIN>H;|EUM#>9O{=`#z1n_aTF*uE~eG0tZ5xL%Sgf^8PA? zLSUVVXSZj6DVCdhd9U$|t!nc2x}dVJh^qeUl2UMqu3n8~k!495PJ!dtY9g%ksPJKf zX9}^m!e@S%N~uqo|7NzD0wXx8y%z)f_WNlld(u1WvfY)}v6y~DOZ3}Z+1#JoO0>h2 zZ>$i}#r$kQL{jVq-839;d0l(nHi-2acK`IubzDoQm!RteBAy4~c=v91g7Y6^>5Ie7 z;cH%Ru;!vsDx#a{_C;CAljo!+|84uPBNTJ6%$AcwH-6Nmf&2pndm6PGc*pPkqVPaL zK4;v$$7Ke7j$jNiQM@nny))~EzAQLA@)`kq?6WI4G4t#-=336p_>zcI^>+ZVl^3}u zgDvWA>{~fiba#5$g%T{TMW+YEt*Gm&?R-G^oy_EwJE_hw$5GesK5m6$Im<6?3TGsO z6wFJ&VGCD_ZZq~@^IosBGga-b$Lu5_QoSbX1}+zf`?pr4P`Y?O8$8M02nFKPGkpCD z4dwZVUMhObgoNFCVDSLXCl!v`MP{P0MH2*$?bt{g;=^kB)+|%tILM?)RFbe5>eg6T z76ZG1$K!V0+@^NJRezXmJ`*>@9F9SS{du2aE8LURm!~8Le5{Hq1EN?7S0X29ce zb(Cq88vmv}=g`_(UYkwb(M2SKkP#NwpM3a)hg8=a^ds{@^{|KaleQEWlj zUq|{BO>0NY8(ofCeh_1D8{h9-#b;-JW6!+zAgg}(!FLbZ{8}V#&<9J)9e(w>WUiVG z*5KE*5bnTyxBwS6EP&eDXk;W$fJY^VUCEic?X!WaB!3oN@}FPBf8q(e6jv}F=mi#K z#ba<+V=5TiY-P-f_zFrSeL^deV2R<_+UoqvrAB!E#2TXoieB5#ZC%sbT>`*TQb^9j zyjxYgd4b>3C&-#VW}wG;pyjEfw9^LTsnLU(A{<4Pttn44J6Z>zq};ZUK;QkUNN|i( zdY5VH#w5*hS>@DS; ztm^g>F?7}J4rjGt1*R;yJ}6CVpj^W=xuuPJIK_F-<3=R|lOBzkTAy^-=C}q2QGs%p z$Plk}*Mm-_)n~ZCc)7WEY3T5Kw+OSUs@g!@Zx15@q6b&8oD}Cs*!=SILF|Fo ztVfc=e2Wp7&sc&X^voPE>i~m10Q!uNS7YD&t4&0BDM2DQ5onRfa6>6bSZpY)vgUx| zi4c=%A4M+H`5M#${fMpuf7+njjKshz8e1&qKr2XR=fSc^IDCFlQ4{GD2brboVCBXX z(+qbhR~m!3CmdHlA5-gZwLsxwuSvE{2Zr*f`s0N`F1=$y&>7U=O|mM}piTF?xl$c@ZeWZ6_G5#GEBv zT-*52rZvxi<|iOZQM>9q^n}vePz8R3v}8`m@L(iC29e=kXXj3>Zo3(IZGhZKP(iJE ze!hSGCu8}Qs_V9(QdPfqU5O(a3VOLr6$HzMeM)=KU^Ai|pRFC_jG`Q);aR(=w>KdD+DtrQ zD8G}cUo4Lz-iPGHCz@BK>>@29LttsDwPBcF8nrW~DL-mzk z#cLON6tGVX@L;BTEsbM z9ibuM=;Yt>-P^=-%4&3Sa`J~&pB@M=R1Ni=F3o2W2^U(YLG9IvRTLr;9B$1s-;KCN z;q!zrdI61kRfCDD0tC49QlF^PdHF8Ri;D4!2c)&$VP{CZK8#{{O~$OqB;ya^&hLk{ zt+{6Xc7I#ltJbZ@Q+rDC-B|`!s)y=kQrQ)5Wcj)o7mcjW8QlVqhqSBtEjn!IBt?aA z_a8LGmtOs4aR)C(WA#(Fba_0*3jAK#^%1&=VR6&_q)5@F)oKv4T7B>QnTGWhQ)$)mTMqRC1RnQ;4J5Qe$kxe*Pc7dMN zz|tp|{F#$iCU(bUo1PJ1yHcMfeR<0yu7wg3Q-IE|8y+VU8Z&_#Q6Srw#qlD|R0o|( z77Gsalre@iiXHs-!NzzF4}+x+u!3gP|8M1)>V1hGu=(R&>u~#x;HI#bDho?mZO4ME zz@~8UlBrvcFCi6Yp9~KgaOu7*;^@ob5{3@9(jqb0kdzVzteX)1D8oU&6ij$SEJlXc z;pGG%?l>zP8+M*O%~pH3AtT;yMDD@B5~JC1Znfc;(ef^k)67)y-qGgevF%^G?lZw8 zzeYJM<|dLvqsX=YbNUC(UKp4qhL~QGk@n3q8)kU8u;t>@u>!=X1xk6+evhNzGGm7$ z=kOKs)SyM7M2ZBx7EFkEP5)9X9`Cufx*82&(-h&fD_8jbw+Dm&NiF>P`A!xJozMVB zVCinhdwzf75BH8mBz^6xex5fQ9Q=KkGU1XMTv+nfXqnA?p_{ZnRkI;^Z;)V!i^>qZkS&ZQFt z!I3)(9&kr3=l>)5kYk=jTfqr>&wse|=N8GxUeBMMoSxDpDkt}W;^KMPm~&o#E{5^8 zzu`7rQ<>PjuAP$Oyi21P-`=aHlUF*5`K{Q=`7dj?dzI zCHx=w^rn4Hu4#qurx|yB{_?B~2nc|5t|@=xdE4zc2Twf08n%{nmd+Sq^*-+gZ-QdV z2&y!08cUw_J8?jja+MOEtqSfL3BY)ivY>rbnuE8$v-4=!bJIXeIasgjh;>hRqot=)mK&-*#v~3~0FM zAvGKjd3f7>dn;w#_3c@&VWB^^cA5dd%5L||Ot(Z-XcrVGqm7w0#L>wESNcAr@bnBF zL|W_Fe7JQPus-$Jgz`S|AOb#^l@UXb+d+WM1p4vHk&jIV@J{JXOYwfCKkt$Osa!D< zWXi&}iFKEQ#g!`rziVFHVWpy|2PB3iFja~sWTuy!Nc^>;vnUy%H;ej(*0YB=MMGSF zg#`%jtcEU15Bn6-k66qvJ~h4av5Zh*E^krS**DVipeL7)Ug6-k-@anmBvq6unuZyQ zzo^RY3#is|4+qspjCUXX{JV(@n+YV|AXLOt#!If{Au=>03?Fb%b~`0{-p|sFSy19; zv~8iUE{{o1PmssUIzx`*jl9;rVaA^+9giOUS$z>kc}X248$c&8ar0a3=*gfq)H}C= zaW&O!DZ`6=$hy%clPMMIABt8Qd223W;@rLTKx&)K6|voy(qgJq`o3i8l3dBYYKGIw zPzHhikvuX7>{E}rS^xe?VR4b93vMky{SwV@WTrQdVcTfHEe351xXtdkXbpJb@`$Iz z_)dw(!3lFRO;x~XIx@Uz{>4JQF+}3l>s*IWp*Gh8UC?6=Gx9KLq(6A^tESfep>X0* z%GHPZA3(o>a~3SzX7_LJ~cmN)K0FV?O83jTow4E4j{si3|ITc6NVzDEh32j>_gUybHIa^twMK z>4_QsNI1nYP9ReeR8ABI>kV@4jOe$dNC0y2Ki&h39j||=a=`mV{}J>C<3T`%@;k9T zIlb0^W?-p*HM|lB3}d%$-HHLmQIq8W0-d#9wLpFcWCg{&;c3wY+S9l1-t__R`=B2I zrh1u@GI2#?&0XJkFE*)1{AlJbCx|D=`AY>$L^L1^3RLC0c;a9XiLrs4wlea zr*oB^=(6jSi6sU>DrGM zC&JJ8gq|PYrLJ`OxgDR4HNxa=@csE=A{ieynZeavCOijgNHC7mLMv6Gr0JKWvdQ|; z&Ok+V%gu=PpyFLE*^lWEj+9r!jEQgALr2G#1eltEwi>9>sHR>lmNfa$6ZLbUy+-BP zQ}zi^+5|wt{t!ECzg~NXko`m;h3^rZdgl%bfqPkYkr3PBw}YI2Gzoe`0>=cmB>_-H z0DCAQ375MRrDxo&zg+8q$wzs$Oor6o1O!10TKx635+$N!!@358`#tA=53u)QCbn@` z8q2mXPt6(Md$ma)#bdWXi%thSpv*=w(}nWn$LZxVyluo>?7m#y)kJ4uC{I1^LjFyT zv)|5ASLSc)-$&alSuyiJ*DzIubdkSNMuxXOBSA@xA0HxDwxW(LS8NfFi=AzgW&~Xl z1{ZEDo(xX*PehcsZpRJrXE(b`AVR{SH!*EV+(|0zzp8(@50GvLQEUUtm;90j6~5bw zS>n`_IdSjxhp!1uHy&+R0G1gLAI@NEB!~{HSpq!2f?7Mf3A~0RLvEW=d)zD`@#CLt ztBV^2gyf`u;_5R0{Ia14f76RV%p$klGC9k2i^Vc0HxdX2a6$vE2Xqk!VY3wLl+UC? z0m9_c9`x_#*d_agHr;U_%I%Grm2ML)pv0<)ni32l{y01FrMWwB$kHfbqW{?{<<#vJ zsQkcO3wc#xjJH0Ux*pC);D9?5=tV#%@8gxqW@$GJS4h|g7)$QAd$}thpFZ8~mHXum zvPJfzKRLf{dTvjBPZ*T0J{0wMsb0Z+tXJ%bF56_;%a?>!65m4C*1!2ql`CI)Svly?0(s?VC9;AumEs9ROl+ zd@|kADvitVT`$PfQoXIHdNk{m3CEeq zTprK4@zJ&I3=d%bQsSUzOnp*bS&G~xMH&U$0iMkyQ59&HRBaR-_J34XiPAAKU^Q*x ze`4yy0j7I^I`%!K4nFZ{(0VO7MccmJxOZq(g?d_X#d?t92Vb{B9Cg2Ewzh%>hjvxGEjIaM1a!Kie zn(A~@{-?GA03{a^1}O4DF;+rN*My?`>jN6`7VeJ?5AQ;(2gC9;zYpWxW)i2xTV)H%;+)$>S z^oP_xee^}RdPBL!!aV%fL2%{}bQZU)L%XVd;$Qy6M(*~rBA&9u zTueFEIMysT<9P&RoTE)qM2XK$dE$C|2%%@LbaU|h3^tH!P}FbHx~A;Jw{lW<>}O2C zmJAAIlAS8-7l`gORdNsiJ#Mp2AH4g#cX9KIjCfV6+Z+J0`|m?;5r1@agM3Ti*CMHk z93d369Qt_ljF^DKJi4~DQF&&c%UjRxfL{lvVq1AH(bH75{kZ~eqzkj)<~W(=fcq(M zd`v1Sm|fHhBb5*`oBvt-3l&0N9#Hhl3d7GYK0g(n{vhM`(Cf(@NN}Pq8!WE`0bK{x z4X=Cp;iB8A5>ukJd8yAL)aM>vV+wUr`POnL!8;&dSKaVPlTY$qZ`FL04irD;!JeTE z8nK$(<5{faiBaZF_3~!`J|3;hr9F2o0}ul}keh`5+2?Q0_02l~f|Nvv*}yD|etSXP zH(bW?=3jqVyaJTi+KmFxlEKowVpC2_?5=JKxggbyh`>P)(EW-D>3!+1IZE~1Hwb) z5rx7&X)45Ac-3kce z8yx=S^=uRxFS9KF-P5~2yZLPb?}im~T67jWHY=ArF}(ASVh4e&U^(Q$ULg7bz*;5_ zcL{kEgrK^?g(Q@HA%Ib?ZEYod`)1}QP8Bic@juPcKdg5(vv5k(YOSH1da^p#Phafpf%Bf5eAcao_7Bnfe<_QA~n{J zAos%)5SXrCNZ{toEUQx{Ag;I~H7Pf(-rs;ARZ`}!2&LEju6m6|73Lc4q=d69?KGCg zWOt~I`{-1c#A-}tiY(YyTucOU?JgqeRCt=BM(DJ(g>9p88^c3LxUb%PXvEm2vQNP; z^szyQ-s;s_x6iN*ct5K2O|L_2E#zZm-tP!h!8f6jwc`BVC>z=i%!si(htc0(i7xa& zc23J$Cy z(j+r5dJ4f;0H`;d3Js(p-Fao%3pPSX=0*@uys&hNV}h*nl_me={r4V(l60^YW}DPopbyF_QaU zi>~dcehZ*fQEhwCH6kQ32aR_JIWqniknVKmgCc?VC0SmEu+|%Xq{m`B)F);AB@ab{ ztf;WKz&~e$J{-aU0O&NaRqh0A;_@t17?eHR!U8f-kK?*N%7o~zdcm~7mw+V`JG8@M z7G||Qrf)m9`oAUJ4nD?GMQCT(AiNAPmtA!Li^-O7!6l}_Enhnw-XWeve0Lq16Pf6n z@YMP9I}7qbS08pEmrb1- z49jkwTD)}YSZ8s?`c~nWu+~r{WsScP6pI;22FAW1(L0PQo2&{SB^i(qh4ngnQ-a;m zV}QTEFd^x!lF4g#u{Z8kpo zua57y^u9(1_QEzJ*tH&>X*wnH;HODKVj7oB3-0|ax+>Fkw%>KI(=`}Pq zR$~0z5nMRhEY!?s2MVAQ`avufJ1HsfhRhJ2z5e&fM(57_kz~$4x@J&Q!9#pcI#q{< z0lfRxia&^KVoe)N^*N{tI6LtVF#hYENG%|Wsj#9sWzy;IPO6VJFa3eY#KjI8e0SkL zblN6WwzvO(UbNwZCxU=;SrGQ%5<1!aPg2h!Vr6Os!`(mL08M>d`|N#1!#hd7kv@{( zpxz6%#-`@)ZzkG1ISHl^HJ5w=wc0}sa4n17-6=3$gxG8+ z%HdVkKB|YTc%3fghBuGBAS-HS!z|~S@#f=ZRO#ly_kkB#7QwSE-nthimO)vfm+oUE zw-j#4e0+|gArx3;6BHBZ@CU9OCZt)Nz>oHrkR`-zaymWP_pJfv)M`ZF=~CAjl$&>^ z-`;1JJdPm50^gv!23+X`Hi=ETiNP5gvQGn5ai#3vv86x)eiQJ|ZoQrgH>2FzDco?= z7L9KCe}_Y&)0?XgZyOYz!%ukNYBl){OaV`PnaGFh(*L(%9ya$2g0+)1eKoaj8A10f z%4t>off0~V@8t_=qp-ZkQM@+y6%$1Sm@jHi~ zrT49L(@+*%c1&B`h#dqd4`Yt2e8hH4W4_j^XD}1k1CjAS~txTk{3}r41r=ME`P11EUoFoF{U#H z5C5TYqw)49P%P;~uX1;7=7{euS^Mw;yPRzhsLqqdBPaIg^wXhKk+)wR_MreBq^M-` zLZ54HcXe6G9>aTm(_4exFK`#nM_9kv2m}`_gmoObLklUj&kcM( z&R7=9ypn=YX^9qOM@+u4`5rsKMpt(rWpBR@bab<`4+z+b#isqCq6=GKc9N1c`;^v* zMV8Sg=bxO$Hezx)S=n&!X5)xwANctAnE$!1Ea94wwe^3-UJvC1KI+~-!CotKHGsN( zSQhv|(&pavSR0A`6o~KAUoR}^cv?uv5!ncuHHYGdi2b#T-az%L_?a!JG6Oh>Rcj`$ zYU|;w=3S>8Ajtbvs)|_I5#ka;D?P0FP#p2y!TD6L@=MrAIHIL-tO6nfq~`_&)k*+q zNR>@{d(V9B(orwy)`U^F-(b%O1cIhe>PNL32>IVCRNCb%y$EWo!BmYp;WjhK)X|i{ zBhUzrA45`$NJpL*fD9BD#BMrAUWT#%97oyxqZsJIcA`PEQl{%J*tTGI!EL73w=(be zIo(kM$syu4d16r>Xh-WbeZRq$bp)_#vxYo~9*=N97g;1ED}iF&ZQ?Y^(?Meg*>O#_ zhrsV)93BY#3Nmcwuhk-Vt`gXGguwO>e@h@n=ozOG^JuS;*Oa?;)=olGw7%)n>qF67 z#7DR;p|6ZsT7zdrfu0j%Bd$~K!Ob!X6P|*TuB3;SH!fDdS@ikQwKHG?zgh_SFbz{^ z^Ma3jz%keSAcR+Vg={x>6wJ#b6P9b}vEf@_YI= zOorB44#rw^5H=6UQm%xp9mL++OsxDG%a>s7wXE=K0OTp?&)0t)??n68fQ8i{!Ff3Q z?2?<*M=%K+0Zx=O0(St!+)9z4me(s+FMH?euZ`$d+*~KpAK#96kyGIVx&dSLyPh2S zI?`Y3rai9?(qb`p;zy&?fXI2uflVbG^CF>&AHlts*rQfOFlb)sTZk}8C~LIg{`zQ0 zF|y>I(snbr`RV0NpVz_S5HNvz&`F(W}YcEG<;nDYoiX*KKwEA^X(v29K&d>P;m1nTXjC+)2}2! zYha8lUAK{n&K+8FmeXmI@Vgcvi2v%H^@Z^^H(BDQ!zwGfwt>^~v%vlo<$GaJa$4yv z`_;6~wLl|;t%jxPQqyks{nEHtanzXC&A(s!-9nq;ZukMC`o0@Hi__kU)oJNXuy}Ys z>|o6bh9cXBdFOwU_rDT?GUcsWNv?XL#EbIRWTT>dR2C*vZKV3g_I0iWThrufVslIf z@H%@GUjIs}|0(w3CI_P9bfUI}Rn%)co`5TiNowA-0x8vndbqp|_h*E_d|_aD*%xiqeO zGxWZF+Cy}{NT@LmcQ-<_J@LHmWl-|eem*b8z2?g*ln>*engy zPa;}XlZ!q@^qn+?EV87`8}SZ`17ZP?QVV;W6`UTV!t@G(clGTTbZuQ#%ya2DZXMpL zN!oSld<%T$gWl_1Ru3f{w(}nYJBh||JcYR(oh2Wxt_@Xl43|=?l$=KAU(^b8J+BK* zE!sy?PESuSmN@wr2^Ro%6rr07nA0F)cl65_Gw1<0i8{87D|o2?+ECF^j8I^bFWGR6 z%bIMy2SF-?%90;cJ?PmdEwP=Hc~aqX8d^80P0`PtxSgfSm^4MI_#r}^_=0JQ0Fcul z1QGF9^(Jp521iVhJ^};YPi@9Eb!Wr0uOa3ENv);Bk6;|=Bp%Dfn4eLWVn@0@sr}iA zvV@~AL6eGCkOdSogHM6*_5qU7ru@08!8Gh($zxpb#jEKxtiA0h(3~9Q3Sv1ayFZ)^ z4f|$hkKK(OVuVj0!?N-ReH&Wrz#D^jeJFVD#yH%?n#4nO800Wl z2&ELN3jFp?c;m7+>!O>YnD}XMKCb)wCHyZb&S_}5)9U^6E@{sJ<0AcBA|XgxKx?TN;hE;Qh#JW+#&jgF#0UUh!E-lVg^9M!GY z4SmDMa=%`KyQ=GOG)`pWYh?~*UU)^ID)?uRuDLvxP5{Vb1z9Lv284fxi;&~Ri1!&+ zm%vp0=ZvwumCc`+(A}B4RLbJYA#>pS?pC%{ot!KmOQuL%_iY?uQbMG2Rjb-nW=_hl zQkQhrWB+9{B>b#W&Eg_3ZXoE7*cka;&yXWVOBpV$?SZY`M9{GUdsOGd7qH5KIK;R8 z5b>bU=GCMM3(5{#K@?fz#>JhIZY4S#Hir*;pjuf(BQ}xu#c07V{39Ev+rNIz5{6v4 zlBTiNFjq5Dp{;#UJz9nhc=dgaLJ=nn<*3IWW0EzB#c%WYZwAb}d`})NUUtz6V3)8S z=XI6aVRG|jgpfK$ISOw1PG7|?ZSWx+IdR&frL`cA*`(aeN!3(!z9<24R&x}wEYNE! z=0xaU7ZQsbnec$vuPb|&54V$~8ynXxTiX|WX0H^j`KNX4LP3dFuavro<+te` zk6Yauovm?Qk1GE(pX0LfEBd>~Ta_M3iYE`i*OKQ{Dg;@#5H7BAl0q@@N{-*?jDxhx ztMx%@icdQy(9bVRilYL=QsCGik0-;g!=24f8b-JL-_t__LVuxSElG^6-t>f# zK^_HPYDDUh9}_&99|V&{XVs{Yl)MT9xpx2hlTs|dc;3f*q{VD!YoIsV?Xe>_GohZU^ zi69+c14>AkAmYA8x%+POsB`RI!v?J*;UZC<(w?!k4RMvhA#?NH8jFp1nZd$U2oKzj zglm6_-J-_j-Z}5~N5v!`DBBmaN<)=wfz`>t5A4j!;f_fLAV!DcyT?!MUxD~-Qi;Sy ziK9PW$T;oh4Y_<;K?m}OSTcu@PgPPEx7dQO%6<0u8k?5(BDzh|nc7aSIrtn^-%^+w zDc1DD%}~0pVTc(OCy~+TlZB2veM#QW&;|HU}7&Q)Ig= zELgj5rHgVi^TbE9vsCu#MdW{vRbsc|li*l$n0~P~Q6$bw6_sp{*e5LnEw+EXS#aks zwEy-xmoJSGi?arpbQ@4E>c)YbWSm+T1ldoqIdzUISRuZ5d2y`HqkV2@`A68GYVK+^ z{Ib!I7jxfTbUwmrV;n6gu@Uc3bFi-xE{m`A>GRZp7_3rhfBPiTA0b&J+zUK>HuI?0-cRiYZ`Xs2JI(lvlIzQ8ig(k+3o4wrK z!D!ioTi7O%BcuEC39;sf*ACb>-3xnwm8A*hZJE8_+QY5v?D`DV3&x&iM0^F%WJApH zUqug*LsPrJmam=3#tAuoox~W}(D{<&lIZgST^(mvNI#P0vlm}kop3DOCOeJZw5ISj z{O%^o8pEAY{OT%J`o?-@dV=ONQ7gr}Xs>L>v@SKs&!G+t^$qrWTBWe)9HwSlKD%vu ziD3o!5fx7_+nRDE5*1%0%ENn9IaN&Y1+M1A&Cg!0sr0$!2QbpC zZ4i$az6XplpsyeV)wY2AqP~Nw!xS3rCz#f;dw+Gdr96aS4h+~!r{bfGl*Olh$)RZ* z(yrd#g^LftaC=D@fq6CsrIc&aXbJCJKYA=Z!Y+-;#o5_nrTImK9p_P1l~W?=H8&pQ z^H%Zj-A(d@IrjWAwSs-rxgY^oQ{7SRVqf|ld}^iB&JCv&pyg2x&NJ7TRftqFAjjLC z2~+r%kXGjA@No!>x=qYX_+0jR!ghJWVBS7N`z0C`_Vd8Sfg7@REFOUI{FoUTwli(F z-oe4xtFUHX+`iDgl!_RBxX_*95|O_^HE?dwhW=8qf4ebrMzrmH{mU;10jX7);2cEZH~MoUVp7}BJq~Zk!TN7r$FRc7=xQNEtW3J?22w; zOT^S0%3243#x{WQ`1p*yt5{LLim6n%$}`ep{0W`3hid12I}cy;#5UB+ygatJ$0Ppj zpvv0URaAU4MLxDN(P*Tq+?~(LE-Y`Q!IloYkr|sWo7wVkWXtK{w`P;6Kb)O+(leB_ zEgdFA?oH~~o_LBwHsDw_I%1sN^ngXPM{}Ns^0A?WTl36u=gD5ZKb1TA8wj#trg4^+ zqS33z@?t8ru6D*%k@sWmm}ETHjqiW03nGUHcPm{|-Y#8<<+cj6KLcO1SF^_}TT3>! z2=`}xj;ZoN>U>k_2der2>;vtWL{Huv2&YqELWkSAn-4UYImv1~=zO3!(xrx=WT?4t zjGuxDe4;-C=X>t^N*a;xr~OHo9-BfCJSsTv*vZIIU7GL9>U20P1!eXs<+Tg z4+Q~xaV2|ik6`hP%#_8qDf8RTwL%?C%AfqGvuZxT<;r-IoxCoeelGHb6hAm~cw!7W z5n=f{Bp8wJMgia5iS3;l1(&Eb$k63wX}4VtFf$~Y_jVWi<9DB}x}_Tac>FL6tzsLR zS$H^#e!Z>*iUR3y%3hEv=jn$0-BphMa{1+x3XmvTP*g-6749zZ*K%>N3J+thX}4{k zd-f$voYR+OW~xAV>PyF`At{bf%yW6G;x`PwboQL@&4&AAVC81}Bn~e$**N{LZM4m) z)C49DW^03n9#-1tJ{T+>;m#R~M zrQgAxq9$1zc1EWkTEaF!dvGpyuGQsq9G&+~-Y5(p<3Nf%#&lAzQSqI=pO$4Mr7)u~ z_wcr_C$DC{q*`9wahN#dphU|QWY|}^s3-A4$kv3{{n0BP>#1NEW8zn-4xAtgjrzlEAmI703E3F7>_09nN8PmL#cJ%WLo zb9`EGuP_e1HMG2U1?NZuVV3mvtyYoGt9HKSPI0Y8H)Z|8J5fuZ5lR#P&q2uN=54ta`uq~U zY7DU&yyZb$_QKCGMKMQ_5+f;GYqn3S`M#y67;&{Ww~J?~l-F_=O{;3flBfU>;1l6T zB>kR#4%42=8H2Ea#8HebgUrOk#jj)O?mAMYK1K4DRBWdYllpcR;8*3_k&H>*eCYgz z)xc?Eo2Sy+3zZY?RTCvmMoyNF9k4=RRR;&cNh6c$aGskIUmX&BhZ*Yw45E5B0h6A3;!XZ{YZ1bRp>A;G zo=Pi?W8<$YED8K#IVPsPQub)_1p95b9jNIAaBP$AMsCl`&d0y0_#M`?({f7SAtjgy zN;uXU5E#3keg9e?L6?*|WBG&QdNJd#`Bn|M=VCp?&)f4A}+zVB_=J6OCLAg$Y-K8~CuL)ei8bsk2?5e2#g}_f=40A--7onx4J4RdBQI{reVQc-E!d&CQ4wiNp3DMFqI90AR>F(bPLNuvh^GV9WIApu#)>P?Gg2fh zp!6OouXD}$9zMF$2=yxYBue5?S~2%Q(rsC3x5hEu7)T2Ht&)st3ikglK<=q(XV-<0 zBIxJ<^W=~TU}!vUQef9l97vGO0uMBo-t*edlL%cKZ=366xPB%6&4R_F#Niz~N*x)j zXQi#1ZQDYu?tP2nGw<0UNX7%~NL$7zQEV6rFtX~mgpN!&M2g84;>k*?7)mPhDzQ%l z=6kCAaZ?IFshBk(IqMXndHCCx;&gAr+Ti2hK%Btu>KFP07EG#gP}0bLlz_lHvaev1 zLU@CC#8EB)M1XA?>F*0r)HigN%ODrrXE>^Z-yS=7+)}m~?TpUgPJ%8sB?EC@SxMZ> zABCekWit=*5CkCze#sC4kuGj59uR|wXwwM&jo!|a~ zR6yS=^pLpp!y^~@9G!^}5{Da=5%Cn|dTa3F1O+wP9>HGSl&WKcV1<}I%O#}_5r;+# z>YCmJnfB-60>PGzWajfJz0BiBYeOfH{V8Ki%jTN71^n&@Zc%6h zC+v>3mA;rt=2#sv@$yDNitg{-&vnyeaDC=SE|^!eiro`AMrBvc$B(%N=GS^LZ1)PY zTWqHrI2b;{tboM1o`$VeRAkTO_g^0m5tk=6&&a zfS4}JfKx5o8*chCf}p}=tIEl4);B5HbeQ2N$=0UcOM9!@R~})(wwc4H7qhFkk_vNWHB3C#=QZOhC^xHX zd6Z1L7c>q2wytttSIk`kTLId}#C|rf$pe>ojcq;ZDwZ^H)CR-2r2FiRl`#DB30EdN zC^=kQxo!`jpR}XI8_AxZ4JAk9Yyapq{Xl}OjCj(qa^X?ZvQPi9X1d?6|ivC1F zNUj}G)kvw%g+12MbTrX;cf%!*I3tg7t>p%^3-snq?4t1B4<7%);sYkOl6x=a3~?Nq zEto1`H~w>mFYVr}ql$=@}@=6NDV8vGx~y z5v0Xe*AT^e+SF@S8Ies!Zw3YidXicWSbLXT`NaK8r#R^ard~_}ijlg3K_e3c32uN@ z@o=?*_$Ld=WQ!L+i9-h9-gcm9zm>`m8-acCw!6#9`!mm!p;S5zaof^4{DJ?iUAnwJ_Ua16@FK~%+vqB36P_u4Bgt8WIVum(>+ei;D&4bG^r>}?rInEV#~ zsRg3Dfky4%{bP=^udw8tZ1L896W4Tor>&4SV~eckzU#h=KYp4~d#@L7!5-%auMtNK zoG8>dNt5j3iz`9 z-;U~X9?;i)G<_tXazBobIJbT=ok9$*IOSko<4qE-9x`Xj>yQg`25irM1D>P|h^X@2 zl&}-eiJcf-=GN^TKDc~N9Ggw~sAsdc2)DGG^s*;7aGFX5DsFt%^k@;G0PK*C$>%t; zDau!S?}HT~vp1l4*QxY6LwxHa>*4CnH6iG^@m&vLP%ZJrCG*zO^4M#;>p~W8gdi1? zI5KL&p7Osc-016>=_&l9oi&qiCb+T#qOAH`{7(nS?q{g<6S4vaQLKM$xKg*|Z7N+I zSOV|Za-13n<{LQ$n2z*e9SpzgBZ#wXo$XZAZ*7FOBk3mdnc$Tq$Qa!x6`VqM81Kn~ z+Qhu}=8kP?v4QF9`A;3B-KZq;ogSN(jkx9wd%SF1 z?89>^pBh;XaWdxXG;v4S9-0dzC3v$jt!*Cr_XvQq{~ZRL$s}6S)05Y2`92kp1%^^A z!`0ACBc@>pit1PMMh&;FF3B1khHPh17|#GDSVfcp;GG8<*+)-k1DSsVjU+P)|D6FVXZ` zSEh;E|Mhx;_?%t+p2gnUu;|0rB3w<&=0wo>^>E6t;)TKbHt@F0hoilWUf{)=_2EXxv;j_hLuMdARu@ zS|@AJa@aO7EGKply6|YrCLl=_;6SG$#zr)lKOm5J2y)ss?-M7)(qr6nDSw9|#T3>5 zEp|e!D1{brP;}(9{ri!2{*Xznsc_%oa>rK1?{~=&nI_LX#2~+Je0GNxgC?HC)P5F| zWNv?J*qQtB=n@hplIoN-VD%a^t}U4bO#q>*1P%v5I4q~35hp(uuossZzfsm|ybXx) zgDC#L-bfppC=3P{9r%qOq}-eee|^FZ3{d+SC^RJ?NOQvrc6GGcQK_%k1T2k%4qaWj z=DD>MGUbFu zrUHk)bDQauNj_U@rq53D$Z|f--`V2dVk_3l+UI*HZt5s_4$885DNV}E06qAEn7@kl zU^#7E#7=}uI_#d)iLl*O6}nx30Y2V5o6Avps%V3-{=OpVglOmF3Wbg-3TyDirSoFO z4tpKvi$+TGiJu#F&2ZPkUFcI8_{=0AB=5Sr1|K4_1yWuq7k@FKj86i}*|Q0!vx)PZ zRdbU!jCf?<(Z_s{jVkT62k8j^US~mlv4cyCKhT7x6mGd@SmS8Czc z*Vh+8=xS6i{bew`=?3$`3I5fRY+;COXDqK zAx?dx#OP`r25rn{fb|sWSi!&H+(?uW;RcM4V!zSZRldMXvb<$=w^1z|E0a^tTNh7! zF~v{#ssgExaBs@wh;w2M9{y^$NfszkZfbHP>0RkZ zA6x_fXn^bc%nM;2czs8e0L_!Y7+o1~4YBr_u*$m*h-_-AYkS32k9pGiX>f` z$9dtx>pq3PF4$x1ef4$QetO?uW3^zv0y#{+kF7J4;m|}ZwD8wJI9-W0{ok%Xg>=sw z`RW>}pPJ_~o3(BXZ0Lc!fPWs6)Njbi6^n#tL-4sT#jGj7Q7`cI-Z(y5O(!KFR#iAI z)`Hb?e2b4JJ44J%LDC75C&C>|ez7kX=gw&hQn+{d_o~p+?Q=Zx?hrarAvfhj|6V3T z{(EUWNM#r6ss#F8!#`H5e2x#Y=UD2~&!iG@w8t?1Yl+C^)`c+3P1ld{jsmPIs|!3a z;;bt9nE>RQkm)C>*taOxN_a~uAi3keTH7Psr=JnCnK=OT-S<{YVpO^eVPY?pcW zO?eXJ?^FNNmMp@a=wC?6|8U7e-LE#7bfW0Z?0J1Fe2XkJTHLk%1v$t>1{fD)cF^o` z;}91RU&hf#Ud`>GURPj!wJc+_dsX<9 zmOIu{RpB*wha&Z!=`*p-I|q@hy@?uhXl^(PdS7u>(Ls<&)x9|MBe(S++h^4qICt=W z`)hfs+E^pOBl01j0PHt6lzL^}RU*F@W3X=LH6p-)(2`A!Rqb4fRY*#od^@IY>!Y;R zG&~v5b3fKU7zG*Lca`mxN< z_aX+#aZ@{AcAR?gXIMd2p8+#xATne|Wz_h$tBejx`xS@Tk+4Au)Ce^jL-cQ#U)WNF zvsQ{^>7~RwJ+f%;hJE6GVsHQAup7VKS))Ww_sM(6*e$|B%;$OH5_w4@vn@2$T3l^p=ny}Lx_#K9L?KmlT?-`gG6`o?L|oPMY;`G}-s zf{cW@9ue;y$~0!SplFp#eF9s;zax7%jvD&H&UA~~g}iZ!OJAV}%J z(jqgjy}@4KrTHa~BzjDebPpit?xF(30{0hV)h%A4o(&&?@X3B?p7doO;i(L0psTJv zsxYq0lrae@r7kj52JN!Arbvy4Y@-IYs=ibuJe!T!V&I8O=G{}{qm9wS*U4e^9pGc4 zIRFo!e>rZMX(Uf^$;nObma4ytx2^IW7M}*c{&JnSQQ_$8#h8G;Mx>;r5ZbRv)ICh5 zZKCmp`c0+QaIq12(mQ{raXR&DY*4l_UCX{JsWSO^G)N3tp4qGM9J*!k9fzNg$87Yx zJ~1ID11c;W-$3pt=%vBxdOc%Cbs15`(>=?0N@@=Mw|O>@H_1rqFm-Cw^@fbzfpM4Q zhkCkGk92HqB@Lu{PlGG1f~Qt*rIBH6(u3;(GwV3O#_Q?P|9u zsC2RHBoi&k3_cwB)HGd_BSN}(?>Vi$kVt~SBW6;ArQDTgMV{leD^BjAaCWfC~`P#8(f8LV!iapuaibW?u&{!37=}(xATdu zm7yV7dgMC9{}b8qLXC*vT=}_efwiP%u@+lIj-XEom1U2yExmyFiMo9ln`ccrLW@ay z2oJpO_`!30dml0GJN!?ST0mkXrz!(2uvLhc|n1sK}2sK z#9cc-n8X?hL`0r+CNDiZoLEC{)K8)fr{KAL3LLPa3y8!95^R$`KzL&zjjBJ1E_viB z0~YeKhe#51wC;g(?~hejA7Au`g?qncQ9(z--@D9An8c08^nnaq{sAj<4d|OfL~@X= zi-|p`G1OhDajt)bolcE~Cjih-r6o9y zp-f*$CPTJ|W5wdE5Dzda_zf}2khrc?12cxLuUgK0@Hm;=p0c04p{%jr60Au7+|$PA z%&3G~LzR3$O?)N??ZLf%Y*g&k;MuYY8m*yFYiqq7ppjc+v93;%kqbioFvthXbg|O| z($~;*h0E%cR|o-|H`ni3Jhb&NPSG7KeYYIxu*`2BRXz^@PDYB(_(S(WcyvP;(Nz)! zYf=D&LP;v)W8c(^Ew4qv0K~ZID8afu#&J1_p5p;?(!B^z@8JibVKP>EYQTS8BSA+i zI9lo`x0cmcfrWnOO8u6Ef03KiYi9abz=)2kVtth-7x^3>qq=*?XSs*!KdQvRcl0r( zrQB5X^l_T(X6oB#(%*9P|C!Jf$jG#a34F-%+{)thX<#Q}GirPXMhk!axFHE?5i$gV z7Z8s6w#G|Uj=m$}#?9GGYdA`7-JG-?{5=CdeS7KH>3w2#0O8kSb zt*2N)z%^q%QGPvc^l+Ow)~;?lf(+2o=?X3GU$*A+Lujg?#lNyLGoCl-S8T~8^?`JS z3MWM_8J#|1D-kx~-LNIp{WsPsH{CzwgmTXkzKy1QmqP=er>v!}*!-O|lPB~RY6+9S zp*MSO0-`_w$D&v4xQ_+|<;mF_6sgiSD$48CJ{i{fIA`v?zq@=hlejQU=pGdYco7PskLevcx1+6&;5~!A+R?6((}R){fUpcu()AuzPFYK={+?i)??W_5J# z@eOxp%ncph0&7>c<_!2ZkL9Z}#gGd@T{*cKw;Yc?eYEtdY`dlR=ubtp-sYdYfXw@h zdG~9wyo@p(AJL3Fu!shG0c4%-Up5s_;-*rZ{e-2OkxG3-;N; zFN9oJPiTCH_9qUekn1r1rTvoIj5lxI>?}DRFX;l6#+o-*daEY0_5k_BM1M3(9Nd!j z{3Cc7&YeT5UrmG=m|^2@30%UiHOVlmyi(Y;C-A@`m<5xWNDm_5yJ~Iw_x^3rWShsw z41*Aa*FN3ZRUgj4n&yL#RTxfLO0Mw1>yn52S!fqFI;K#x4m(y>1uX$iyad@^FfPEF zv-@0%@qG#8>-RSL$-~WGHa@oZ7E>+g>}Dm>@YDohVC%ARQ7x-^+qG;D zD%7+3>djvQ>x16&2F_95E-KWJ#rXCw8>;XyS;_R~&lh5dc2$AB@1jID*t$2tj@T0W zA?n>#R_(S{RZ!<-RCBOaAg@_+YZw*Ud4#mD2gUL+xQVKy3E?7tV)Aa#-BxC^Lw4?Y zXo_@n|W-x()> zED%`8ci&6B+G1|MbBN!5o0++9Dwfne6TY;`W>VUq}q3<=L#HH)1VElVqPS zV#xy*x1#iT#B1bpGGBJFU%z=NrbmmV*S&F9w(&`3W+sziE;UCzT2@alMfYRdy*oFF z;>5&qQBVkeS#bBP)mA^Z=DfnNkg>ol;nT5o44^K}<8EtT`Z+jTfiE*yaF7k{XBeTw zB!w{Er&+lkT|V|&=B?R$Y|A=~%oglI9xbUUD2n~RHw6L$qK6$lYadt+{qhGEa4ngv zN6fS!iqGa~`BFt3XW2n$-~Y`Po<_eRK4r8r9q zv)xI!(f!AyMAXf)?r25w(f)V~_kK4+$5K!^1%erRv0LlS?)B4l+oOP+q@?!*HEZo> zKt$*E>9Nmgnyv?~a(N51|H{z$9Br8@?tnPf&@;g7slpDi#6Q1;^Pg9G*<}yhobPbV z#|f!Xo=YC)kITz~?JgtI0pF|d;ktj7e5tS*s6M(EO_(Ag;flLDk_3f;{s!vR=G|k`yoB%G_gYoq>qVP~+#p z)y{I0-XMF;vmKh27P%=p!hA}=ay_%Ut`yWQ4tF_AWSDZ9(SwbkuzU5JUX--ODD{T0 zFfuT5u8RMg^^fc_X{Q!*o>+`nn(`CcxV-4Xv_@lZ6sGn z@}dLk!#M6>R3a?SZnob+rJjbFcSE&d%|F+{|*V*v?;6=jb z&JWRHcPmDK6W;IW!bDf6?9Zsy77FXxj0S@1GTvs;`}^->()h-Rj8V^MrsVqv~l+YH*-={!}%Fs zVQpKK_}6=m(mO-5EkP!G@y}qU6_4JzbE)azPf~o0E33~#N0vjj+1aIy0MB3<7IT23 z!tsB&QxK#cP9wK5R=Q>&s3!p2RY)RH(-~eBZg+?kY%d1>@f&E52c4p%CZJ^dHPh*F z@guP_c2^I@M zSsB*)w#SJ(osyajf$e2n=~<}dd_5oWp)NH>bLbK8N9^DA6T z1j{s@U>o(zR}I{jVs32Ei+j5E=KOyxCuhG?(}Os$Ak#XlPTXYQ^YjVvgfVsy-DSa3 z&Im-{CPo_Dd}nCFd~3B+<^13sLniXKaoxxowLCONvWQpymqRT1E{~+}< z`t^aXVSfa<^q1qgtA6#GtQ;Nhim0=>tZg+j8!zbi1-#M$m!=eiY;l*Jx4X09bQ3|W`*=FhwpKknmdSxe6Ad{LJcMLEt}YZ z7LdD?Tv5I8P0DAee*LS%cuATYRU}(T7EF7_x&BKxa5Qp#j?6gt&uHq)+ z>c&&Wxo>m(1rIpdaE_fDvBKiUsuh64PZ4r3Yd$_p7?IC4Fi2CJybn1tGb`-hIQPRMF46W-)8)qRR|7ha#zks5_|6I5YQr3eRR17`5!#7+XZZVXHqG2sGVj) z>RW76>RM8IzDp*sM>>8O|D0Cg)w62%tz(IMG@D@VBud+$+A@ujL^J0p5syRZTekP7 zyg!Oe4QZoT@y(ufnI!8=Jdrvea~Ph7*zC8-Y zU%kwLo~;kuOTteK#tpb<{Kb+hqBi;WNnZlpU#o6|AIVd5=8mEpDtwYN6HHU$sNW6tey4vSpOQ9g;WW8>nB>L?kQXlx?ej1 zd3A>nX9N1Kl^2R4(1rzkS5o$0c0*s)E z7heTPhp1i0?ov{xP{-(y&sd@*W2A!R-lqJ&cUb>%1pFpOuP`Vm=&E1StA+o$!H#Gk z2yxe%NV1JWyvLLEJxwwceTEUaPB5Tz-svg*4AL{?y2A($+;;f@8%MlHuOP_cj7%$} zt8<%$ueb$xefDnTETK$*dDx6i{%Dte5q#syQPR;(dqY?B5>b9xe?p z<_B9&u@Mm>_wf&tkcn0W0RV?svR{;xtxWxbbAK0*8w(Rm+KeOvpKT3LTEy1jNUi6c zf}f`pe=t-Ofv<_y1-F=O2X9{zUjI7@Zyj3M8+9BT{aX+q4-PcS5QmwB!~dv9Q|0@* z<5G_zJy$SQAW@lELzcgM16s7e@V1Q&EQeNBR$J^B*8a}5SP374$~%|l|KHEY z(I5cOYh5HLe>>(!!GBKX#r1&R8}KnOINa>T@U4FVjqB5nqKx_3Ve!P>ttNa%)a+AZ zuMKU*b}^q%n2n_q!j@W0bo3OWq*i`AnVa`@H|_dDTTyl?;sT9MT(M^}K=d_?gOe;ba9uWxtl~DNrF+#rpTh$TF!`j5ty*6xmK-J6 z%hQdxlIrZJ&`PPr%(cl@s8o`_DORIr5Km6$zN1%N$!5ci9ET^{Uq!i(!+Bza8x}ng z=-MZVeSPo`|D&Y}>t%U90>7-)gJ z&-kppZs8jc-IgCPz#c)JCM(4rv+Sz|BZ;th6$!=KX?r|>sKWx!&G{e=E#9*2Ji5RJ z$dXz;MI5XzFanNnj~jgI3CPYkVo24x4t?m`r8B2*X$`lKfUBI@Ja6Q7PL|Lxd%yQ| zIpc$yGN7&1Pbh7|Jn{GL4|$g}&BWpFHl- z+aZ1IbLMWX5QZIW(ZKd0OGLO%>fsEe(N^dKN}^0((AYB#^d##lq5ZA$*A(NH961@p zH9|k@rtriG)tR(_AT$7rb(I+8=b13FZ8=U>5LUOv(ufXhL_Bp$owkqMGy8+GOqI!c zy|l;cM`e=sa;~;G@<%&yQ7O^-)q_+K8C%4|A8v z5Reo7Fsgr%UhCa?4jq0``COF86p-u)_xvZ|DE;YUuRy3!RljvxGc*H=b*{IBfeGiW zq3vS`5P_9BfdgmTEmzXt6vPNfx_E_JoT@d5*g(A~%I)1&(4_0VeSO`H#}kcRCZ5V> znLsIL`h-QAB6`BB&1Q@E=*BB|2pm+`w4whakPsX>#4^s-JTp&k$^W2ZAOOu-dcKz? zUK|${#Y`Ep*Ii%22lNEY*>f+lchZ?HpWBq{>kYlvI;?xj^-^)*^R7GO_xA4C=jv9* zd|jEcvBJgV584EotAt_L2Q;5dU-oj(b`jqdtTSf_)0ER1XE_~5Y#%3V!{NCuC7-f0 ze>7S5rI@Vs%v`}4&vFv%J@wxb`%w}#f1sA-so>9ta|fk-?jvs$DbF2IaPc!$w)m#A zu!+l;s}l%*Ox40oxjt)vA}3i79cqNY0*xn) z9gNljMVVe8W45*EVN~zkk{i|rQ_?cT6b>ozY+bHq>Jl1KG(2;kBVdw5EcnM@LS{e~eL;nh!k zUiq!x;qa(UZby9tvEc(HXIkff*B$GtaeuANymVxQqsWPcTUkW>8<`Y3ew#HM7^)wo z4rOShN3!eIA_r2%JQn3`-J?90dDB<~=Ap>xRaEYhB>lnn&#y8}<(WZ4n8ZdIJM09aRb~P8=lC859 zPKG7*=vwKY%KTTncr0$KCj)bhsZ3n2bTBUNF}$h)Y$l6-Dh#n4^{X)T$-cGgA_j%7 zOg50;mef|JqQabms;UIR%{V|)kUW-W&gnG{a{R5!^noHLh->{u@FK)c=5caTz+X%q+=)&X)A)bAv|t6{g&CDJQgemC@QcK??P zB3^=0p>>C!jI@96u>SMCu0ikPEw%jnK#W*W4C+Tj4&sCo`vqKHIgU^$NxH z1nq>B6#j6^$&VehJmTUupS<=a9l~os)7u9r#Z^52s4l~%Tfc|ER>}E`MpHxDS`cl$7u*uZQ)=)luX6&0*fvB*;(a6 zJI7_cX4OSfNq-gOlD}KyCtfQ*4kwr3tb;g9>&Pbor6!6`ASsz2=aw(mt&4r*?*!4m z4vs=~ZdwH>R-ccS|51*zrP#jHD{6dnz=ar48%4qzHc_YnM(xp-HWZD#F&v%D_o5}A z$=HF@H?hk!Yr5Q^EHd&k$Qf@Js~@@pt9kfU`&v?8E@?D*npgEA){JL=K)-W@CFO)V zmL>pbH>BTy%ra`~B~Wq^w<5k*!y_c5brUBqFW+^xE+!&Dr3T0=@@zK#`S(r6-o(Vj zQh~wo&+4grTjzZ_O|gy^u0z{yVyrM*s}$8AHc9?}I#%x7kk3Km@fjRh>#`_jMXZFi%Fr|d^>>i% zt#fuVoN+OZ0t`hB<_WSI4;hLw{*~qA;-Y87x2=&z%2a{R+c^I3r#;kYt!>$__V=P% z`Umgk&8a#Kpjy)h$us&4#N>3kw|?n#&v&dayW?w+T#dSC!3UtkR(nP0Jl0ZZ4lvF~ zPx!?Z+XU9fsN$2O#O^_)uEZKU3UDUCY-GWIyh;E%;~F6EGv5Cd&?;K&d6^3R&Y_d* zWr^&MF1aovVC?9|*CCdf)3aZm{tG{S>XKHgb3k-pVqqhdn&=@jZZ&S|aqPUBw83li z3ot~ehv++&5n#tg#k-{M`;rjyfrpJVSZ6PX0=4`jJQoC(B?sW|3r6%(Iue6_fS4Gc z+5X-iRVb!KdoZ>W4FPcuZckFff@G5;yG{9F#tK=pj?Yb)^xd`e*TX1WI>B6HAMc2M zq<3NvonGM8wQ_m-^OaxwPQcT7uaeTSi!rVf1l~Qd^_ZAwUD#SI5Tp$=)r%(Ew69ro z@m_HOF1h`nT>`;|kak`|3;zzx2ADj2bK2nqYn8Q$77#bqkS0(Xmfw_rV;u-BDe7y| zUjP_ib~lG_?+@f6pj-m#Q+oH8pB2)Jy=};CKJeNI?%BT0-n_8g8FoNB^uU4-xzjoM zH91w-`nL;j5S5$BpW8vLk8iZIRBS*Q(gIHS{$}Ca4}>gc6TcXtHP zmDBcZ{)r%)*^v>aCmY`+2jd1Xjj}$t+087zMFLK*&qs6gCmFlDyYZn}Q`yGWh z+MOX8xEPgol=b-);q?5tb^)Ucxh7>=7=Cw3quEbP>~AgSY$eU|P2!2nZc+su`gEM* z*NWi-Q{c2_1U~F+nJV*(Nk)$ozpuK2KhghvGF+q|wN?S)Yfh#46UTQ^v|bFrTniBk zcVs)Bq(~#97!(r;_1Ujb}S&;$wPrXaZSam3dvmo7qWY+?}zftuw+tHp0@ z#h7)ia~I-;!T|tuIM>VAVpJy9Bzf-1#(FmRL7uHAKK_4An=(yrvL^$OT5d!(ti(^81`!b0T61rqeeBgl^~ zTA98xUZ^o0VAyh$OP-IG<1FC+nM0x+w~`RA@~UBone1PQ@hM}u^r7Kj(@?J1R#^Gc zv$F+&R8Yrr(CP!B~+K zXKV8Z0I@Mxhib8s)I1VR_Q^C!rJmD3v}jF@Hc<2j4zQH4p6(?-&u7H4sHW-S06k!! zGECei$|06>h!^-P-^#RDn$fZN0(miii_^2wI6uAyZNy(up_*5cj@Gd%zLC-J+lzEv z%(Rp~k4DYz)Ai^yf?cT4qgTRgplypWMK&o`j5OS=jOt@;G7qhbOdUHd#=~-##i6vk z-n)*kHjTmmev7Lv$(Gv?<<{thrCeb}!T=u zGwq$nrC({%o^y7=l;>Bgk39dZ@Q8}&dKLf-1iGlQQ2Mb;x-UdSW`II>08}h~3HAfV z2J~T_SSY{p0vj#S74?<{dl@Th@0#7(9gbu&il@Dxv+*{ES8^yvy`0qxd|gL_)gh$T zv++Yen<=c_eV_CIr!(Rw(~^4Y+!UP7{^o-;a4{B$!>f{)3;m?E2}&u-356kj+QdWS z{j_rWp?t%t*gcFl<)x*&ITGA9wEu4mJ_h-g&>O_;fkI+NQ(wRC(2xaIT+zv@Y8btO z<;%;>s0X%P69+9J9`Dy-Vf6e}XL7qql-76-x$hG_fjdudu7?U-FsI7)N=iQ1hW^S zv&)g!@^QtVl$z}SqwG}5erxt25_LU}1LQA2B)yR<41=uzwJ>~l8R2Yn0E{3Pt_cJP zK(tqb2jEr8{L_%J5jgVmI-u#2Q$;x#92j!m*a8b~1@6uK{`b^?18^~|_$$c%eJ(Z+ z3>yQ|{=Va_8Y>07{V9;}2^(TADA+~ugK8Saud>DqH7tC3s@8){?5PsM^s03w#J8(S zO2)^gs&$HCb;@sZ^$;yXz`s;sddXwURW~3okTI$>X!-n$*Zq4eKW}M=?DlHmr-z`5 zoB=?JOV7-igfMg?P>XSQF%29r1jQ6{|0(zM{?J$JcMBuMY@OIN+?Uf$j?##nZih_7 zPCE+J8SSWW02wo^WQG$c;v5WsU~3Zf7NkoS))awZsobCD^4sFq-M zu9r`SW3CW>ZG^Z^u4B^=RDq!rtP*uI$2MbiE+wB|0i(nET@V=ML^(|&OhsN9O46& z9E7!_eF3pJlp5?WYObEML{#inDc+!M zv+86E|0grNn@xY~Iu!)MV{r4T`(b`=D$mP?|HQ(F+ImV7HfI`(ea=t*h9KQu82gj? z*1(h!gCf~m_KA+_N9bBBsO{kCLZyQeO>g9TrP?_LbB%7IV)qloNgCNwkEUSzvv_+aN^ z1BLNN)C;qvA!h*O&UoFj=2bA)i|oyA!*&xBpmUDMRTDw$V$pu9Yw!&O}#ER*i?bK5}Ud!7U)NxWsYwK$2{SqYGS#ro9@;o9_ zdQ9Ev$zkxEFgQOzmV4CFUl9Gd4eTo3FO~XN9lOC+Xt|G)I972(B~3r6tgKxANc*;g z|E}wd*PeCf%=vE%E@(k9|2{=+_}55%A+TI8JXC_-Sq-s%<|50te)Sm9@)|bHY*;VG z{p^vXKxllO&hN4Up`O4}5(GaO1S*Vd3#3iU%x3a!A9F;+OPbxG3u?zcN&Gv87#{<9 zCrH8pE=PzfH7p7Ko+VN1n(HN|DkY1#8;8FmrOcN~{iKnjtJXhbAZaV}X7}NPx5>T% zuMeeJkmO|F5l?P7OWL|7+QaqD#J#dcH=nJBV)JYWVOPky{^q`U>&mu_Mzt*PnP}w# z{p|v;q}o$JFah|+6tw+LqGL|adP83{9muhqZqc7U%2(~4M29Aloo3P>OPxiJBY`~O z<^EZCzM|;X=k@7&k7n0{=jX=)(d3je@?0mi_bvLJD-pn`kGv0N-40_iq2JSdX5k?{x(|3lb4Bev|IJIhUwOQ=RZ0~XVO|Y!vj00)&p|1c=9}`n>$Yx~XLa$d7fx%h zu(v*%x(DOFX9MzliLp+^2Y#>M-|k&2j43zDG^Vhg{ zh5p~10nY53G&oGR_Y$xDuzhBjdRw8Vr4NR~V>t6fj9ZSuqOvW?`S2RQZ?)Wb> zutF=T%A_>*>3Z~4#zOt$iT3E|;WH(5Hs*)pJx|~vUPZ6|4r90DlS6axyNz;84=1qB z+6{pvlZP@C)k(IF%fG*;y;Y4G%OV-EeDL>$PCd!B16}d4nTnaRqC00kb1@ti%RBnT za0>jDIRev?lcV3!dsVp3fUkw4YO-t*KC16gqzn3$+vaj}auzYA#*}=U=b-ot-6cjP z<=@8f*K5}#w_C@8BKyhZ?qDRHsFEAt`xfE=JI1Ts@6r24$1rhgx2sd`*Wxo!O~&hW zs?;=qF?1hYag^R38w!Q*eO zL)_BY%8|fQ9wEOxQTOYj5Pxix7>+V-9F^=3*hQegz`l~yDymX9qkszW(A?XrxizCq zs6b0wS10Iul&qwOwhKW5-dX0fm8!;*_*(aAK5YFN3)sHVLFdDrY9xkW% z0E5~(i%`OT`K1pnKuWPD#Q<-3>k7h_hKN;KYx5rTf^7rP*dXUNfeG-a+hd~xS)Ph# z2jdI7&=JTjun>s63cjD#H~qZl-kaI^l$39r*rp*%5zI7*e|h8(G#t=N4j&^0f+0T# zQm&B_?rM098TTa*4EvVq+YMo13!xCyqwV0sS^-$9-J`S#(+R0@!S~0c9^uJUG5wQ1 zm`P{1UqjwqBSXJVuS3UOYWUXc<<gF;z@BeikUjs>jyo)@CcCf!p77w+{XVU6Hq! z+$5D%aQWDx&lANOfcNAqsR(eGckoz@T$a6t&0vjjYSCv${Ow`k=id)iV*&BuO`qO2 zB-u8M+5c+`^f_bi&mJ53xAFH-?qGl4cd6(p7G?V47{M$KG~`7po~Kk@!c z^Q1E5lm0{#C!A_Sg!{>0meY+f{t2CIZYka&Gb}W(^hh5UtmTX~LX||Toi8uJU$Z#(Q|b|-XX!aexE)QPLcXXK$0y^!*~D$>MMvU3wOlt1jYWmH z>ZUqadkB5}rZO*`R!yU|k1O!j0XuWg6LWyrTR{HB-jNqJ5!leYg+`k2G8KXtzg}0| zT!=2(JprUtNtYuO1*}=xne-C6RWmZdE_$fDkx0 zVbQg|PT#3D*%EVCpI7x~zpV9aXg7N0vEM-xDRp4N%5A!FI4KV9rZ|vRF}S*ebI;#5 z63gAw4Nj9xtuwBJu3rAB1_<%rbALY_0!~6L4!k$?soEusQH_cIGJqq z^FK5%;B84}ri#72r}lh)k6Aw%JUazk9@$Q6Mmy@AE2Y*?hXTaXAr`?%$H{~0-lDr0 ztD6TLX@DC@nwuTS+MT%4Rwan;oJQA@CNXOYu8$p03yDB!ql;hjZbf_k3+sSYvB<7c zyU6~oeK9m-;W)hQW{q+XnPSRYw6E=1!q|zcT8zM5ruqmY{deKlcXUE;ycD(m%}YZT zlzSA}^Mo-`d)lS*kE1svAErG7EMKcaV)ORPE$;jczUx-j^X0G99Av4iU@%=cx3J?M zr7ok*x=nEqPu*t3RkzMVLR91fifg=_t{F=Bl#k~EMG4-Xo>Jncvk~(zQ!Bm0 zf30ofwufY^63V+SV>Hck3(2oIiO>!yQ-8P2>h)7^rm35~qQpXEJ&sq+z?rgHoJBT- zo#kq6?1b_+x$CHdGLQ*&|96<@XIDo{a%y}8T@q7+OeDY@ZN2|FP*se%u)n!MtQhKQ zVz9FI&8Iyx`$mu|usG=gw@PYqGeu;FV(&fbp4j=1LW>Dv90iH=hLy{k4p3^7w>lQz6hZhtccK8OX zqh+fDHm>uj?)lRnr7yzILgBx)tP-sQwjvd``|cej(>NBpL;d={-+ve_c`_u{r*St8OYSwev&-mey32m6fJHw*Nz{@uvgl*ZpmMb__ zft6Utb`De!G-|9gQYt89k@^>6pb-c|jD@J_yVmGaz)}e{Kd=?8E*NQTrc@JK^MV zoprVzN&uU)`Qv#}Cj|&-G*X=MiXxpxbxy5;LvVTbsb+dNHQ|+b74+8>D*!JhjF^nU zq4v?+u6jnG)p22(b8F~8Q(#x~KtGA_3q>(PfjJBh4C^{(e#hx9%*!1Z(pSi-zGW46 zl=#bjlWnPHsy{|7)Z@$m9p+~A3t}r@S}I2>zwG}90H33EHq4JSVZZv`G?oCtg|oiK z$>&S8y17FyQHg>{6(@8;LUd88Os5`a4`u(t&wdp<$l|SH1eapi1>!xhnme>qf z4EDPh9;)R4Dxc@{yN*dZVmZXD{mWbY+qTLXP+vm&Uqoa=7`cwUcXCEq@qCnv* z#vdDQ8+{;8wOhN`y|H|+pV+Q+d>M47#kH_db;X;B>Uo2KLJFbqI>(fio3XNCoG~}E zKZOQqp*s?S6{19=X46)5HTzd@twJj#-d|K&?XERatjAf~vQ48&QJtM%f6ZRy`hI-4 zhjbd%W7gBt+XhZneECBkdiz;3nu94>${((lA$DZvfh8v<6L`IK=7@~ zDY4(J&jG#4_1`bniyHUs_113zKGn8z(_Rz)_8(wiKmb`=>)<#x_repoebTS8MxCuX z!eSc^7Q$viJ?d5%6=$sXledQC)aBmZn}&@zJ1!x3Xn5vLya4BvJO9jT5LLeFyLUN@ zr<2E7njM?l+MjIP^yTHk#I`D~bdYxq=Nt1ltX0dU2{Vli|9=ZO4k68b!ab0@j{b;~rqZhX{{&NoKWwd~5fk8T{Fam$f54mvIFyg^@P7#zBU zR+HAE9LFDZnS{Fbf5D4#ZhnHNjt|OVsC6XAhzY}>DS@iyXd6lSnQ)yS{$&Ehekgja zshs70i}Z4NZw0q)U2lHz-;V`G3wU=jGR0!oUxQ=SM{PKABsm$L>-iv`ZzcCL)2Z5Q z;ol<@@Z8$9qSJvaJ;i9DmJN%{#)UNW`hOp9pGVHX~*{(4Z2&@#O2#p~P{WsMDcf z_GXyQ(mHtqgZak4*sKN04O=>DLj3HswzSFi%oym)<3ofijKrJOdy>unCYPS*C95dc zH`;MTbBJnvLVyH#B&h1

U8X5~RPLDkFC;S|G z7Mio}b9yl*@9`xMJRWZkswj|2)4NO#2B#SgTW=)Y&+fTJ&_Gd-+okjT`_c_0>faY7 zl*QG8_YgG+vUw2wpY{WV#8;4qFa^GewQy;O~6O*ZU@ao*?Q!uPmv1v z)k`1Vf0dq0+RM%mU-u_{t0-N(8t!LS8uZjptgvyZ0$cy@g-faD)upx-XAaA*+JV)e z?i=g!9g*8}B6Pfdwj%mfDkqCMY}wh%o=-b*!?Dk>Gu{p)fj8xgro_!2r=0dV3+eK3 zFT^=A%{*V$eO#EET9;X5vO@>Iec#8Wnr1&+%|8dy5X>kx@3Jyl08sj@awv#VwYOZ0 z1_%~N;hFDoPF$ISpdAccA79dItrA?OPg9UX0*541MebaaFEjk%(`%}=l{jm?m4Rt< zi9@Y@WaE)+4GuA}*cwE^!^_J6xO@9v{?SfZ{p~wjheiGD%73Rey){y|Ld@@OR#jD< zW%8guZv6M6sbrHXN)1#_NB>&k$uwyZ64hJwV`!yvrk$%WCv)Z^f6)}D5gJ%H^9_8^C@sD+7JbWUSiTlxE6ErY^1?Y2lpGMV19}f5l zD-&E}0Mw^|Tvp^8`30_%d9I#wSywuvQT`NG_k~^itLP%Dbn6UK8|#eab4XyOKp&@v zAEBQI2n9JKnOt921LA-*f!?ra>k*fPDKJnqD(aK^Ho@@321i zc*^zF$w;g@<0>>S;!rV6QvjdC18HJ8yi!zDeE2D9uqxIj1mSHI45EW3yRGOh=&C0g>_ry8Uer-Zg7cLs&vCEkC z-vZHRPc zvK}?TJ~FD)QIm%%mqcV~rKQxQPCtKH%rLWJ_==qDk|*RR8+#QbFPP~*Vr73)d`!P_ z>dL{LAoxGsgUK(*vf>;0Fqt*0vr`K7rx3>;fL}Yt59!RvYLcscId9WLB)7CgEvLJ% z+5R#s(M1o!f2>YBIVw#b;sQm zul3Pt(XT3(*Z05|Uk!&|;JkZ1Na7ErK@+onqsCE2NcFD+Jsn{hmk$_*nqYPepsB$z z(Vp{rd5Ld8HNND=O5^do{w>YRb01B4eclxB@y*#Nefni3c1mdrX0PWzp7wOsq@BTaR-8-asZ<6uaO!s=Wwk&HgT5v`FQ5wnV zyC^7fhJ9(>Po-shlblWu4JRJQF6|XJzD^GQWXHk5v7OE3CA}f;RJBXG+chxxU6g+> z`t{@fXbbk4waRFVp-1M-dP5`MYx0^>yG`qP1SoFhK9~P1-QpfhO>h<%z4Q6a*nk(j zjal7JSP%H3ny@L3Mg7jy3tbP;4cceB~)TxK(?k9D?bXk9L|C!y+QI}NL zitQG>KDxh_#W?&*iCiuC8tZ?5Fo@(_B4(IB4@j;R`m-}yJkH{CFwd5a-qa%OF64)t zp)1`h8xrjKawoHV7YKdh6)HsaoaHt)SEul3`A^4DKz5nH_cc*Y$Ci4cO6r*l_tdCe zETm$o=?SASa*org8Rhwe>YCJK>+iaKk2uY}Pwofe@8aB_GRs!x-A~-y ztz%5Mo*2ai226@yJ9WqQZrG)HN7uz&S6G+2nBH2Y^yUkXOsaRbE+c2cHfkd=)ykh_ z>)9yif6A`U=AP{OdOgst24pRrYzF%>U{`4<8!P{B9h9&9vm~jmu2L$b5hvC{*Uo@k z;beeIOoxC#7ggsk9?$G2g!FNWN{ac8@UJ_ezx4S1&}jyCfXg_baNqGFQcY|t;*cHt zN$TPL!xsd>*vEf;v%~b0Vc=k&IJ{G&kzl-^X?ryMIkw$wr#TJ3Tc3-Y!0Z2NJp4q& z8(l(|bo>=Xfo=>Ga4`65>~f;3Om$eT@72V%S-UDjvaf!>xS%8q(Or+K`c zDz(yB(2M*Ei1dbH?cTCdB7pTg4rW zF0QxhxUK!{h8IbmV_e#)?rmSic0b?@acdmYYfQ*4cLW^$**MnR@ygwG2O8xG2H0Gk z8D&6`mgZSqa(F^5scRdGl-F%2Ax`|4nR6V1p4t?%ALt?_D+T<^%k2x+*v=;qLT=r> z`5E-WGCL%S^iI1-$nabI=?AY=g0xt5b*?GQ`t!Ooi#LP<&tdbEGJgLlA)v3`N`5agAuR77_;@Y=VT-P2gRrReXlc?I(kyz(ECY`P zdgsu94GdObgIb+B+_$G3=;`K^L5~x3a1_&Ra>rGsaDGwLvT=nGt=_6FE(R}<;L=Jf zb90rK$HWQ*#xcmsr+ff#adIZ_ba{*0Fv3hU$K$A> zK-Q2jW=~d`bl>rH?;mm308Nh%^OOA3DbhK)#ku~XiSdi~c7qO0o@ud-ea`4jjuBit zS;e{~VHs15%6v#nZsYkwSkM82O}MygFqE+CiU=Hb&~>X@6-X``}KQglC@@z zDj&yVDdPF%{_d58Zq+pG?3e}2j@7pulFh=1ZPfK7S{ z--aHbV5+`T|2yJ>%d_;Rov!!iEgN6kNDG8|tuF3h8BDkbXNRj-N{+I!>|Lk(GT`-! z|7~%ZclX4Nq%e6Lhxz<7=tJ%#m3 zv*|h9Y71rf26iE`)(*bPtSo`vt=0e*{uU?Rrhjqk(_rNd@<2wDp24GE?@i(H3+xF= z+RgAZM(O?^{i3q;fCH$Z_dV~YV-NBxklcbG&6Vk9pIY4g+4f~qLPP;2~)E5~)bcuC2v?H#_Yv{F=ZssACZE~={y4KfQyfubi!|jpQgdZ zoy4)$oxd?m$WN_}fBlb7X6 zOfIwN6_4)fAAPSoJHJ~qTrPOXMZL53Bo%8`i%S%hpZ!dWf$W5FNhr+!_LW{TY!ole zI>stC2Ma7c7$`^^R@Ed5`a~H*YgF zvy;9y6Vbw4kUO!QNm$G5lXW~|KlPTi7%^o=O$;8QO+kJa+TeGq(u)LO5dG*hS9V5y2YP_)q-)^(yKj zXTNTqO&Q+#;KRO@#tlSp7OeH9kE7BXZ>b4*)wc$J6V1s<=4$4Zt*wNFHxybiJ&0h2 zh~KcC-oXiBsSVTAp?@3IK}=r~tr3jsMh>!)ZV=7%5>2}9S8a6o^<ca5hRT6e)SpSqTPd0<{2U8Dfgdd8SWsx}^=U5J zD-(zty5M=Lupdl`8lfH)%fzdLjD-qjC4|ec1EDi5Vq1I(7cLUidaj+Ys6bF8#g&s7 z7Q8}2tH{67Gb9&}N^NRNN*s{@wDl?K=%%BMcv8%psAToa)gMhwX2o^?_$Ql!>jO4d zj*bDXaq46RetinSO-VZZfuIY!Yn6VO3Cq_BQ3^V)CrFDGQe66r6W3E;3t5gViA~`p zjCL^?4l8vJ8ITX?q!PZ~oa-%vu<~PLGQpO%=vgxS@PV*!^VTPNj~P=W4S+nDaKNh& zm1U`5j);&0J7{kc+7IRvfp3bg8i^bnlPfJTDJax(mmHmdKEG&d=^8KFkr7%bQ$gY$ zN13jXqv69`{rp+E&t&?YN3W4=O_&kwbMZ|nU>>kdBmtcKM zO`cmP&zi3PvZ|;IN396~>g(UbB~}*R|2OM7I=*D|2yJWiqv>Y9R|b_}KP@^B?OR=P z=za#J1Dzddt~D7rE|-n+v1xQ+>__$?M{Nv>1F|kFN;D* zQ0s|6am_E^G!YOAyJDmtLXAJ!*d!EFCina8kLjnrGPAtdNB~QA{^gArp#8SBuxOc~ z34c_Op~*>ikG;+Sa~v}_H)n=lk!t3nr>Ezh@!wfef%yDOIG)=)nS1R4c+@4m^Cz?O zLPu4E!xEwq$Q3}Hk0A|5H!@x zY!GTfGwJMQfz~dbofKyCU#_q*M(jkd-3P7W_jqn{<1kZW6JX18vo~bhsa~m`6lc@` zc?CeB8F{9s9e{sF4AJZ6d3s4j-vN&y*I}|iUQzNPsvX={l=uZir?6A#j=BvBYjXqi z1162@K`NK{dz&QD-|J5e@2$P<&EoEG^(*P<0SV-j~#&%=GQ;ZK{qFP)u@y0+A?~p1xY}ZhsTM zY)-Hhqn*O&56#bukTwSO|C&$d5n9O0U0CKzeG^v|{>XS&FRMbBGZg>9zMBf`JwXH1 zPu5-@^0zI{Q$y>bT_sHSzuBG_ex-WPp(3N82n@Jy0@UiK3fkvB7joCfKef9-7b=4` z!Z^6MDjDZx{5yQVFl=s0Qp10$_d>3A|M{abi8*PWeCyMjnQ?77v}xIdR(C}Hq*CxNtQdHBk$%&+-qb_X1O&Hm=boATJQn8_xTlEUHhGf~O@#3)A@bYo|vOKPtB%yd;g{!zfs?En`Xm!wRopTn(^(B56)L=ZojFZi03 zf|wT*qS~}0Vjf!o&q%D@9O&-zv*V=i|6(Z~<0Q3K_%3^-mzJsB8UQPAR%nQo0ATVi zbM)@;C$#UsyAJ~Xl^)D4d)BERxbefpJ_RD5=Vl{?Js@f&$`n&YUJo8r@dFdIc-_m@ zit1{Vr$5M!V{}1^gpsZj7=rEoON-W%*4Br7N}Iu((B*^e#T8!=`FuQPelnJyyH9HL z!M)D#_HW2GL+G$4bFc`5)L}3%)Rh$u4}j|iR0Y1R)|=4zBbWGLX^}yItNMVG*uo{2 z1hsoIpSo^dE&DsY{N?+lR~ohQpqvTk`(gaYnT3O!VRBzBxHClitdWC52O#ncLIY(tfF|?OhP)&%(H{ruSBFA} zfDMQwZ+GSX*7$}?l2Nn$*lzevDe$W7;KBAjZa_G6($LvAto8Gt5Kx&Hr1 z=4y_l9sG7`hH!J}x!}LwB9}<`_9&bJVLL`mqyL|;^k@-$uI@L%cy0$~`^j(dlT;6| zX??&&Mnrr#)2;0qIklo+>b0s_`zL}4wr>=*x|TYByi(qA`q?hsd8=U|^4F&uWYwiK zyl0f0n6nA?bUF)d*_qzgT@{^L$$zf(W`El%80-*VU)F3F%yciA4b(_co1AuHDTRoN zIvUo!>Y*x9ieHOL>3Ea-blE-hpoSAk71L;@Dw!nKALQ#MU%LK%g>u=_yujxfckBRA zlkw4p)(@P0Sud_@FBifuP@bkkZM0t+G19$F?1P~TV;fnghmw?w;j)J%tLg;+%RH z=hyZ@EVMHuI7uK=PehrMPFqv_>(4(`k6vz*@I)Y5y2N0AuhMWc1G-_jH34#h7i>Qj zY_3L`?R`HVLqa@(1BVob^qT;V9h>Q5sn7{LsoG6WtsqiBPCc?@1?2IWtRD@U9#Tv( zp_VL$UYiP`{xs8DBkh{V94rQ#41aPoNW78t4QmvOHEdFQCP58l@iF$2Gk1y6XyFEM ztOJt(mfa6y^`1V5{}wZ2 zN~LM!_|ClHD^;+NX^e=t;AMI-kOkt|R{q{C#I+6u4uc<#;ezTzgy z1`DKJ^eeu>!HvhD3|)Mpu?h6rMnl>^KLxC>_s;(|_nY;h+EBnwSaU_19;cc5djf#0 zCMY|h+aaRK3Avdefs>1;A3Q;n)I9;<=YEqU0&0Dvlp9>bIJ4UDvbraowFQJ4O8v0p zTw{(gYrdgY77)#6^mKjcZ{2tRQMN4?6?I0IGSHA1!k!4TZ??3?Jf*8;1w`pppq~la zg2wc?EF5qDiW15--Q=REOWF_Q4Hc3I0U0ShqW>MK^(Fm;qn8j++04I|_uDWbnmWEu zP%N|xK1}0*PS!&4d64wt^8pu6WPPX8CeHtS+mhi{|I}_#^s2^02FN1H2Tz*c@0PFy zK;?8q8u6JE567e6K5u-10%}?_G$;rZh%ak`BtsaV9ko!%KWiYy#st|s`BRs}EbITW z^+Zj$*5=8g2y4jpo+P^J^izb9_3-_lgAeaME&EBYS$eMGui_w!K@VY|j9(&$ z4tU|JK-AA1c~7z_y39?BhUSS&ZiSvu@&hh@v<{6a$TC^j_UBC3WH6rIXeNe$#dJo6 zMU8r6aW|n4mtQ2JIH>+s+<s0~toEjEE_h)LSK#V9gPS0+pj zvF_bd3@de169{iH+rL>3zyU*TIV_)cRz+%!y6+47Yf;!=tOJ7Cj z@3BYIyn=U!?+nBGrfBc&{LZH8K>S*FY#eFw21YE?Tbma35ppN2fDe*X1biU@2&TE) z6iT!`6K!9BA0=C1SOoY{YVkd(?F{$lWxoKj>210s85%pz^z?XLH|)&*@pQ#P*T9Ey z36AbQ{DZ=XU18@&b*GAw&ti*i^cVq~9g`?VEI1FU|20!gDEsm}f0rY=(~>tbFVM5; z(T)8vC6OWa)e|JZX}z%!3FuZ^BE|pR`-n?z#;5L_Y=)ZqVkVwnhMy2NiA}%h<;XXHh6_H+cQc zucJ6K<4g5*bvG_cNlI4#7NlaVb8$7DOqRT%<+a^V0@Jkj_V#|V$SmXQ(i(g+Ex9O2 zNA~L9-B6id*mK|?ZCFb;P`Vn3-5wr0Zk?OQh%qQA4_+G>BWq(C$%?ScBN2XDY+8OG-ri##lwRH zdsi`zc@-|j5K<>P#EK(;+=|6QdhsLp zrY|R{7Iz)aLP-YUfy-&J-)h;npEi!LIx%F@4cf0i0jCbH^)EAYWxZ({q=W(cm{mPj~p7G0m5oTM6HETub~yKwdl zsj`Oj=ddEv(-SYyFbqy>msBuj9<=c+fk%n>L_<;W0|J3?7F8g7RiuQ|=jIvAy!9>+ zgbe1>PLn>_{`d3fpI1UhTj7AV)@q zCEiBV7V=Snetx7ABObu)Il554)OEX4yy(L8@h2Z|i#E^Hi6va`U&i#AW=8RPG1z8O z;6WGPB+{h9a`$aj63Cb6J4nc`$f4z?UD0lL{p!0syVJ*t&&^~_>aN+Z)=B@=*OfVY zs1wlX<<~o0W|;iGT_`g2ss0o4fm)@$Qcdy4!v>GdIK+l~S2uYDY7>!nrr89!2>bl@ zvG-5{VZ~cja{UT?NpZ9|O~AY&>1ww$$w#zQ&P{~PWj+a4ncj??Si5}RaHVWboLFJl zLoh!K0WGIt2KaV_lqI<1RY(brOKRqaacTEGtXjRM$Z&JGrg7go_*`It<2wOn-cX=S zP=*}L&Yzejry?uPzoYzjGMRZYnW6#p_^Xk6Q6DT8^pG=MY$prGwOSss z=d>?*PAGF6VRo2XX?S^}F2cTuyehx3gU8s=e&XF&PS#iTx+^&7G(u_w-^FCLi;qe!>^7bEP z?dyR7%|prVJ{0_6^XqYe&8y#kl-0kFzhvPoa1q;=VV2XBaN6o ztNFSZCyiqxnc8-{z`pH{p;YG`3$-YkCqm=To2P}K(0ceDu{qGNgJWLWiltKd@KJdY zq``7mmwIBwy)bX@UawEEpAywHB4CfVJ>!S`t+Z%Z&|m}|eo^aL?b88GgJOn%58RU~ z$3!j*ujLY2QF{2_IJWo-9qhvb8%@sS9-}7Iz>iXsiqKBj+?-xTf$!tx1DmzQG9J2H zl%o>L6V3Pjtc67m8VJWsr#j`p3%oSU(9bZRv+YN~SrpHHi%zK38Jk3t>*nm!wH-UM z3mZjEOcr9?df_qcaWuEmc9oxs#=+D>SUlg=q`7(2f_U_rrSbtgNU3HsBy4|VTJ*M; zV(bghsX~^Mq3|fc;$gA=>1l0kor;|TF}>5kpfUrPTsvTBW(aEVVy@7;&K%Pu^G?93 z%)FyaBS6=tSfsgKrdn*q*a8rs`2G95p?gZ9x(!5t!xS#P5EaWubW;-Tic?MEX-7pXO3hi}wFPH>$sOjMMSy{-P zz6_X8W|EDxbqKj({~)0{LSmZx+F9@Rq|{I-W&N}cEKJTPsEwn3YQ&C3PVA55e7j*c zoJD3pW5&mg_yUx(>FX|w&pZIqcxP{DDZgWO+DOCw2p|y|2_RxkN zD3W#uf~2zq950XT?CjL1CrRX%66h>CyRk8NQp4BBXO(FAsIz{jN5EF>zv@9F!>m{u0hn=sK$AmJKAo_=|^r%{E=yBVrl|W-5x$1q8oIGxU z+|C)QROq0sVx=KzQ&?*!^dnHlLfk4A;SS1W!9Ss6HNiW-Sk*~WmnwwP&3){$pvx2xVfDCf98Jx0WN-jA=j2Hq=r z^Igv>uEs`5XJW^OJu*UnJiAJ}Hz2+LGA3`6!pE(PVKy*d^q?NTOh1OUvt{%7s&R)2lK6kvlWr z0dhcHtUHhbi(zKV0X?D)XUb*(MHWiZ%^uEPZxRj2Tj*%?B!Biy}RNhlM;lX$1UYn6a>&$AI@jp9uef^4w zm&t8MLANArqg8OCLh;H;$)e=4x@HEk%=>5^o?4nZy9^p2le?e5P}=-%ACQJuTYUKs z$u~bf4*!lfkqrX-(t{HMRRqYV9zh~2ew0*&5((Eoou=a7rPu0qOzp^1lR?2vwH)Ky z8@$*=y7Sl0{!Wn3>uPQwQPp|&j$|`0S%7AwB6gw@1NLbA zI{fj8z;m#CmqoxKV>F_Hi2o(9R4a4iM$klno>r82xUeki%`y8-jl~yW=}C`1u75n8 z81qrxY&6L299+!?ss^AY>Uv9C7VM>d8|SXAR@-XQqrBb?uEzm&bvZ%oa^V}8QS*AU ztsp?UP6!^g=qXvaQyDS`LJ!w+^~DLTZzzOv;f5ur^?#)axslv$#m@iA2ReL0cLCnm zr2tMd#mu&70d>(Jm+XHO_{w4W(yvQnh43axr+7|i_t1-py@q8wGt^hBt4H#!l-TZ8m2SZ-m6v|TPEQ^_h5#=XFm4*G^=w?& zg8r?gjyBkD#;3sV4W;YaR*?n0o}W z%$MTL)Z`dl_2m&}rgWHzuu}b%>NK#u25;o6pOP0I0?38U*^jHy6y|Z&AIyfw+NQ(H z#T@7dTuZo0^?S^Kr{GcV+>6=%fQP5to#t`n*AeFyd9ET3O>auN5vo0m%gd6lVJ z;bXr(!CST3$Y%D-3*p>%mHU;HCYIuS~x8^gz1B zN-HD1G)Tv{YE-4A;$Gw+#)+mkCOSVDaLZXNaFfhpGCaxZ9A13{#~6e1423 zm_n))$s%pQiGqCKM%u~PKOyJjWjTaXp;=kjOZDGl&R$_nQe;$YdZA&g2z3v_nr+w5 z?(}yKCOHUV3-mXZ-d;8C1A~HI+s(g!vmK+5whm$-T9V&HBWpZx7}i*JYrdQb+sA;d zjcEKj&NX;j{nMrKVvUlM#a>o3{V)*rx_hqr>{+NSFjDxpe(3b5X9)2QX*LJbO@_&6 zoEiY#Q=Nro683VFu1_41Qe}CxGEA;qX#gl6RhrQCs&Q2>uZoYKJ|!O+@dS;V`Xz6r zv!v(Z&Gz&4C!%qwnrp55d?1t4(&*#0{iCj~LrE)3FC)8YL~GO~4ae>dbckirxkfkq z$Y8XJ@AJRAPmb!AQr3$KGUWN=tH)=9y-SyNhiy7AT6>bHV!X36KFZX>-Q3vJFkBff zk+U4DBd_v9jW%8e2VWEFtc?a>3od={G3BAf`I_YOsE4bUQqA`372z^u{P#=!{tmI% zf++VT!qH|D*svx8XK-F#-gT+5>whCoz@|fc-3$!*dO=&1**#+t!b1cT<5*Jm#?CK> zrqZSRb>!Ow99S1xyNB$iwyz1AZWaulfMi1$>2ep4|ADLlLwG^I@8atIz(6bPa6V|= z*}NXpeEPVyfB=}~&Oiq>v;we$0K$VSxf{m30<500_Da(c{q&`iD|CFxAGm}f*Ya~M z-J4vgC3cYU9I!K8-jV`tQP%aZK1l+2bjF4FXH#?Fv1yqr8|Le_@mlbNX?2~)Vl;)z z^d6%0&E^F3-JK;h0EXz7cy-gk1GvfLSX*c1`E}!`yJLU;5R$? z7-IR_zVhIr#0Elpk%jq<^CbdO+vI8TFXA&)PjvPn?JaT@?QXH@dm=dt= zM7c9QXyt7}6R?5eYyEBj9SHj^8o0+l!+9VMg$whGE z9NW>+(Xy*MH1!ytNyNY2-Vd?PI=QtX?vU#mvfFqxy9ooBizfpaa>hY|sr@}t&3Fwl z+FZ?ae)-}vzli(Igz2E+A$@z9Ohie(%Gcu zV_PtsG`q9yKO^f4M!uwFI~VY)lv{VwkX~Ex_IBIc*f9Bfmvli?V#Y^cjsIPo>+YfT z2NMd!U4>p!`@XimF5w!?cyn|-RpiRWE^sMa7gIR(HzE`8@a5-^br|vd(krvBrPqM+ zl`^Kl#;p|sj%?!c!~B-Oo28W74o7O#MaER5^q{R8P8fgiP))VVnPnRX>FOW-LdMV4 zKAHa`H%tDQIM+<#RsyS(tKuqEfmF>$m?4U~Fe$ibe`jcIIBqazkjutJQn+7&AQ5a@ zfBUQC2xRblOl{F;@56!WLdB}=i@Lgc7pQOgY(xCDB9ULeL=0B{Gc?Q~9p7ESukZ_cQghcmv6IP-Y zG(38HQm2Y_vY$M_`#YM$Ld`_5TX!mR?}Xfw*RY^9?f|U{5WEIX?cYFJ!^KCT{{Hz( zM=1EmH;!SSzIQrLosW08YCKn0@(@NLbXHR7scNXm*W=5RZ&5FlzO3IyfdRX1r7w+^ zs+Y!5O5=*Ipd-_7Gqj!X$;RdIM|2l2v@vYGmqK6H>fo4r<=1}eb#cVU16hblwlK2@ zNK-W%GN~F3%+4B6v!H#E6`UN_c(R@#ab{PjIn^_sq$HIG=pB)Z|48xmJ8kq@T?kqQ zL9jh!$jQyMZ@r&+g0a`Qul^>eGnys-+c$Q6Wat6KWFyq?-l&wEoRIxsMq)GZs96eu zwk-$%c3EC6g_Fu-9FTBv-4qOtU<_^sPbpCc7-&V_4Z?Sv%$n!j<$0+8n1Y-Lu1F-y zcksHm_aUjJW=a?S&sgr67WGrX`FCJxJ)NqD`dNCz$oW`%u|mEXTlSo$x)bGus2ov2 zqv8S?3ytp|fx_fgvPw2*iuyF`IT|R`xQO;O2%hVGEZ%Bt$c}kkSl4XyUsfkDh0H%P zOY-^nd+41H)0`?xx#PHTOv{|n2;A8oJu+R9=Fq{;6Ya$U)pskn7jQlky4*QSzO2lI zg)Kg~Rf1@-<2{OKB+*NSBQOb)|4z0d6~w6nddH@w_%}g9yZYUApeV>B$$KS{4Z8y} z%b;KhoADZyqoaw;iF5c`bj70KrmL&#&U>w(M}!r3!c$Txbr10VCB6o7BJoT1xj(GlWU?FBsRW- z$Cb_nxxtMI;FnbOU7zA|4@MjJTThMRI;5JOH-VR~NAJePb4v`N+YJ4-jgDk5iypl? zeW>lGGiJutzV(S81g~5w_6OKyfKiI3k{ws_z`ODFsUiGX$*Cc4^>WEoflUA-&i*fN zLYh7~k$gQBXG(GH@|3tEKL|6Qf4A%b;Y{Q^Sq`wViEA-SEMx-p-W+!F8~~Jgi6$wl zIDFD1d+E>xmhu%4kXaw*bPQShIoS1k36B@Nv6UvnuCAl;bm|xTc3ngJuRC8ygzQsC zfsXyhm1T{VAe3o!DhAlfMWv;U8s?Em4gkE}eWHcycMqu`RS{B5%8fxl`V%+p-hA>s z_q5>mRsViM`@`JxNj^(Vw33M88)(!;xw+lZwmuSf#Be~ff071isD(yp*P++Rp~10} zFM@?z0^fQSy*&YhjNT^bcR`XUbl9em&BMmV39&*^klQIdEr}7T=)Y)CbRwx?z^EuA zT_-uuSEf6Km5RP_QJ}Rcdi3=Xq#NWgkA@8#FEUP$=eK)Ss~k-iHS4@8`UxaWQz80a zDR&u~588VfOTOsBx0;DKA}l2(#me(!ld!QVY^8bnV0=cCabLy~AEY=Wke=#KwkMoQ zzCKnqyhb9ciltXM-q@*26BkeT`sWA8LUcv2KBKwFRaDd{83qF}NpU?(2o7FzAmwk< z0n=n)NC}*t)z;??7g*ccnmUIC1FmHHcmv2YcFRoc;YW;{4BJ$1#t~w#$mLS!(oXTQ zy9UTL?aQ*Cs>hD1MsG+Vdc=0!Bf2&3VuMw8KQ6bL}m0wU0pVYLM(++E_ z-)u7G<|!)h{Xf4)(;nGA0)grb1@>3})-rA;KIW~d3$D>IS0@zrWn>`s(+j_6+I*^J z_Qj3hnDh(~a=CNY26+d?`s0a<5IGb?p=y@0J>Pz)*IpO)>He7qK#xLb`x9FQsV02x zcNedMS9$)D*LT(G8Jmt@z=4xUKv>_X8vdzQtU5+@Lf<)JyEZ6QF1014&dok`8P{C_ zH4f+uQw14^;!;u~khH;7cz6;-1 zw4hzK%GBV15t@vmP@47Nu2$?4_kVFINyo-rNi}5cA0%L1q~9Haw(#yZIkM~5CX5BITolCn-*4DryGKDmktETG#bVFnV%QWy zu6msw4ZiB%Ynu$`i8Sl6P5%UbbO}(#08z>R`2EOIuP)sBQtmc^F3j>lg9PmN-g-~% z7Yh!9URBY(=jtza2)|L5m`CNGQ{=m5?MM|}_?+VgYVfOugDLsdkeH|#GPGN!hO<3? ze0=;O!#JTROrf4W4g;s8ffc9=3r(7!Fw=o)tRB*7+Kc_0S>QXba?GRbIx;7y*Ou3- z0B$mUAgGb%wqL6)+a_UMu$VKpd4<-6QE&V!Dk^#zH%J!$N!z4J&E}z=)t5`nce#1+ zv8Q=%&+;;uKN`r-v(hN*bcrmpPUwK7IueqAWcn0)B)hHK;rWGB%@zXR1O--izU`xH zDFt9_NPgpdf|%=BcPtY769OVf7Hy$Ef&@cBfWZizT6Ib7vrIE zfl|`tor&+WUz%vU_g?*p4fj0`#cp=Uq728Z`(N0D{`PgAb|gNYqb5!GY9ttNi7`-b zZnJ!J8Z}u=BFzvvM{dz~6lL3~TZkq2Am$b>$j&+l+m08T0_n{07NR$W0A@fp&f(Gq z%0o^o7s#GH5=?|GX6e8-2W?qW=ZkZF#lzb-ZXPaLGmP7uNvNnGjq^T4$d$Qr35Xjf zj4&7;p2I(=eH*81{N>r2k(8ANP#IWV{fk&(DyPDPJ0`bx48A>QV3Axo@^mKF=f`G2W?-|LiQ@N;~3^0GP*eXs(NGH+X}abiX)3!SADOd z$YI|K>79;nn^NQ9Z}DK2oW#5VD8L4HXJ|vV-q>mof!uHI^$~DDGe|U_zKJH718+M> zh7PR60af{D&);CAY~1K0gQ5fnkCnZv5qyvLF8IzMEHrD?cvcb$IdX@FOCr4TJujPQ z%g(x684cz-z_VtEPJ;MBV+wxoo|!CXhXV=+cihJ8!fyJ!1q;yQbpOfNON%u z8`E%ijTNTTKRXk;y8=k7(O2&zRVFDRGN#7j6uwj>SZ5(u?%({%NUd%tg{c}n1bMz_ z#p#|$T3H$vF%fbJ0f-FACssb_rU+uul?efJ>xz5yQx(7J!aOfw`ngA{d5n3Vya@q4 zrBsfoI|t_o6%+Q?+_AfCNpF4L?s+m^THBKnMldZbu3cf=jfn{i0HQz`v)k%GI!XH4 zJA)$2pgB4mZ#El9gH$YSk#Kemf2iF7!wC$DSN@OC=vhDpBk8399&kYENr*D-2VyV) z#^_jC0E)?$r_um9G?8WM9snvuawr0MPbFJS;K1h9ComMhT?+pf(LXDBboCsTU#ctL zK&mtr3!j4fvQ|5GS4^#ftZEVdy9Ut!-n*xTQv)=}v?XDO2@bHY;5}-|sN3#fih^^* zzLN!yyc!J-?B=Tc_3lwGu*e1K3O65n;@OCcpkKgt%34h3-$Pm6}`R0l#`&k6&;3XttY+LS^rxK@X0Dm6LYnBYy{XQ#x^py?)L z#6_#P!&*JR)xH6POlB4Z{`l=4YTN=tvjJf`^vL}`b5mUR(re$wm-hupB8u_-&C|b6%b~wh z7f8l2of>|o=T5AS_)p$73y}xljWHgWDk#z|A?p8KJh>_4(ELH}zRQJ4U{0T1fv1bm z1`C!TvVux@yY%nxo5y9(kG@_ef$ORyfzW@FZSE7l^LpixrlG6zDtqd@ql7%JZUcuu z3Bk9UA3v!*tSeZKvp2g_Uos=alH{kn`J!=QySVVL()6C@W6iGLn6D%$0hDBS4px68Z2xr$hLqP~UJs-u!u(K3m% zcpYd{?LnT-@doXdn45n+)%4q z>gsnSc}xs?*i-GA8jJR+RQ*vYu*2h4w&Spd6}UNvR5R8tV6H?~OE_SeYp2jW0Cvs^ z#=xj$kM#6i0cgDTk$b?jKk|HNarf(fU7*gpmEnA?^6vhwWHA*U7J8Py(T>%clxVGA>-|f zQkk%oqwnVz`Ri#d^}P&eXtfM4V8KyGi90j4fLTggzx(#O9;zJoxX{}nxrMc->WMn- zx{INm!C8h&c-fJ$D{%znwN2f#(8OA|D>hFcz={+bt5RzRo&J!b*ST7#7;==fU6=Z# z;zInk%B>70$!~HmHcN=a$$HwYnqp}p(Y)VbRN`NwQTuGPHID~#-2KEWXDKlw?4|53 zXCzy0O#LG8)eDvia_yDgZ;2Tgp^Lks{D_gS+Pc#t-t~F`ZZ2n7nYe1gq2wvM`Z1f& z@9F0FZlAS^*UH>t?8?ALZ+RRCo)51VmGOOQUwc8jZE;`O1d|-k+XmU^0Xz3X)~i=1 zjNxwSKHHru{i(|!lFJhept}JdSS(;A+1_lV3+}saBruB8BJOF$#R4W{?&+$tB~&hp zUT^Wuz>l-gVp?zoq^~6#Ix;cGkMt#c?x(!yhcHtODy*S5_=_ni@4E&WDW=5i#~4rz zyqPp37tFO3k>Yx8qDkR5cd4*f19<`aFEGN!*G-dImf&g~*x`Kn?)4$jsJo3K?|s_3 z`Y>sO_ju|eVAm#O9394WP^;5orBVjx?y6xcQ9_wfs~ zj7!fr1@|w%G$hhZkdr;uwQ$d~vbJ6(5srLrF)_tsvA$qHmAJHI!^g|}IV~;irPkHc z&&ZjVg^KgV_FyEZnd0%$X%ZyzIE=_=yH5zHDpXuyB=B_)Q3NXG+SyoG8HvU()T&+8 zW>Gx6D<@Q@Jv1W|?0-!CWBQZ6Z}cgUoSs~iCx2~*526BzOHAOpM`s;u7N>XTN#2u%cOC{j zPrkU%dqF5MXUOy(TDY@cA1NpD_#ADc4q5*y3QU_T3$9I^B_ z;l(?i!(L%U?~GK1HFglLCU5mAfA4KRXnpS%Y*E55)vu>f@FxDv2xKZi@>LS-GxvGE z^K|I@yTpFY9@vMEmkM0nGwe~;;aFY&7yy^}ZGsJe$;AABm(>xb0@eJ_>-5k6;CU2B z3?m~}a>;hWiT&@Rd-v{XCl}GuqxLUHy2w8$4X|JRXc_+K^(D3MjFi?^d)7u5_KG4N zd<|%*7?D#&n3XQq({oAuQO}AO$%Re43;!)DN72zK&B<{u+MWEDRd5C&xO*mzxT*0p zS5^;^8xp!Qxpx(3AiW~utP58d4y)@gcF0LfGBG64ma=p~tXeDv`j+R)D^6e`KYTvwM+NFR18A-Oud4dWnlLhN+;;wz>cd-5+)hbZou9v>rEY#8L`W<|-oQMt(l< zd~Q@;NfYfD!|{N3|D&csD^2=YDIu${iv<1E?Cw^W8E8*2S;!&L0#=59N0%n5s&;M0 zzq;`C?K!7)*UfBIe;ot>Zkz#p?-Q;&t?xbJ&*!vk<^mOwr&fiihPX;PK3@i7w#*o( z2_2JYF%V@$9!&OXtY0#hmI-);;h;G1T+2!70U1u&IXUgpR8zGK*B9!KHtLtldxhhr zfTluJw$HHb^e?H$p;Mo+F!*}pWqzNBbBTUf%kSsz}w~i2Ve|&AsmtjrVz| zlgY?Z&tn4v18qQMy0e=}GyzVUB8v=Z#kVEBLH?Uy>Yd|Lzp=6Ll6YDgLw3bVN#?L> zJh!cr@r~dgz2qEP44;o&+7RRLx7i`VCC?6JO((0a6?!36(Y?;v>TmawlhdgugI*2% zpM)N;Q9<+VhKo8XjvzfGB(@+EGq+i_bx z(8kWG!wFe1kPjQJ(G^H~1`f4ps%kYoZPa&H{|44u>8w>#2S$;`IRQTn>z>xzIB176 zG)BD!zy&fgs&J7M0t4uDa7$ox5U8T8CHL@9RKZui5|^uR(mgfc3ZK2Phd6@;0kk!RNmu!bBv(7A4~Nl0#=`Q~)B zS50GKfaY_JL2hBUr!(S295bmH`N!kiwe0PQ2mW~aY#sLBA6({z{`~W|arz^6o}3)a zq?O#7LDUe_X8ikZ%H$o*?gLB>XKkF#Zmy)-$2R4_M|HY(dPe3twQuv1`3fLfrlSY= zXLFB)bJgh5DCyXk+)YPUos72!4n7})9xj$0Lk%SjyBUIuGyX0tE-sUXwL{2UD%DqhW@!j+EiOLI&<(>GlPeI-wF!_Yk|bADC*MsEJ#Jy*4OvL9;T!) zIzwgrHZJ3drw7ku-+T%i=Wkkc`|+r9{_NYHeRi*;$xpfZx_zXL{DZrfwE}HioSw@3 z;7yNcTz-b$R29=+dTSTf;50%0$Pzrq!PYuc_X6I=opo~6OgT0)3NqW=9#GLCzSCX) z`zH9J`{%Lr-*E~44D%P>o=Ai{O+vBWa8RPuM-=)HciC&a(*KSEG9I+D@^LWl-67rG z*~fitlaPX^;O$P`Qa4Bn*ZnCncinx~uIb6<3=tjlj&#kuFME&be7g^B6{m?K5(oG1 z?&zp)Es=0!PKT1wfAJzwLYRx|N&Ww+WgoMR(RqywVM=T7B3AEc*YgdkUq|Yqp^=Ib zEVp^p*8^3bGlDvvzu%+*wqYV9j$wZ+9mzn!Hjw+d#q7b0)s#2>xpk3e>vhh_mMYb= zVysMyn@-#utc>cE20{yQ0|P3qgP)70_7e=03c(XyXp!#JuJf<~U(SAgPVJLgA|~5~ z&yzvLF)(k5Yt`^mAZ4+bYY=~15?#_AP{8OR%)r5%kez4%SBX~RE~FqUHMiIVT6k3R zF5eMJ;I4Obkj-g^G{bm8d4gX*{S@C0O#jDPIc4Q7$zY?Jt^5*FVXXcb0K%{TQTds99({>QYePHG@Z9)T2^mR9$!&(+dOSoeK+$^ zN=RN~M`y=Ymf`PvRfsw5#dwL$AIqVhm zTIH(#?^guRS|{(gmwJfV6IP`uwyxeN% zSq6{SWT_=0&aI>aAXRVOx>Y96cJnS#^fZ@+EOy;NsTq6tt1|l?6}hfm{qnHRx_k*+ z#-8%v-|VFyBdTw^M&*Cf@?Xp0iF6Sj{&^n}M3mT%>4`Z0__>dwAW7jHXUhAt?yhci zvR-x5tNY}O$PpPH%!IHV&WygFi!WBLCF_`CNgQ;0pBd{XTx6R;qDZlt5dM{L1Ns!144s*pHgZFyk{uWexreh2O_>_ zWx@Yixu%R!9uI9Qb;7Vok7(E-8*V>)Qg$?Vi8QLI@QTGz!@^q%}KHdlu_;`v7!$g2sI8!&67WVhiK zT3hA&TDgLk+q?5Tf~)%!7a57TfbG^H$fKu2oc=;_rb&0e<0m8&R*X@rSVKlD=HxS z+OMAi&k=Mae#;z=I>!v+v3S11PA@Xl4gz`g# zQgwk8JPJ1T!IOMCS8G6@Eob~SyqE-biDG&R^lwB2E z+IiWNXWyzK!i7=PpkGAN48%U^4r^@`$Th8By(zKo5nw9~VwdPV1~y)JhVQZS>ALmA z?Tv`8EGCC@mNMACMG>{l{JaNd1hgB+e)zEGA4GlLV~@QsL-m%;nsnRa-&3`->y{}3 z(MkNu6!Qz%%2N;}6cbnegbGLsu$wmc$S`!Rz;v*_l4L__+B1~T{)B>CCU)sJQAj(S zYy|D}5Mu{*zH!dYySc7&JZBVu>X&B-h=0Yo^`UaVU!bS>zyT zDWd{)e$5TVEF1}GD#;Pq_b6Mi$>DC{3F&khh!dYma%y^OucDonxXjJKVWY|2t@xnL zIv&PM_`sk9Nb^w@Z3{#oh1!#~I8mc6?}A9b9_yODASXGM7=u`=&vL#p9g+r-TaWw- z^^To?h6sv~$Zmqhyks}MTW$IqL>v#2TxcKRL+o@6f`a^fJta#=ZSF>#`3JqxzWd{MklP7itiVML_JdCsN8DqAxp3_1VjFaRIM z^%Bf+PLP5h(lK7t*giWapJ(zzcr4?o1BhBD%yf|Fi#*QRt%ZozraWqzvCkZxQ#rtBR z(sAlOa(U+;U7g_QyzdY;JtOXk^@85)36adndhDqF&3GC0-zU^$Wpkm{(wESo8lMaG zo+By;7JB+_yVHfm@#>sOx?VD8B&1SR-NkFrcSkU->F(+gi|5)&u+G=VlFt>l^ho)i z+u4ZbG05&>G$m(IP0<{It567Luue+Mv-h*d!7bocE#kN8pb(I;!LQaZ9eP!}W2Bo# z9(z${WfZ`rQu2VaeGeL+0Ggt26r#C_AR)cNl=;qZcU>TD7MaS$Wt&y9aMIcB{p=&F zf2-)fuPVEaT=w(NY7GG!j8ReHw=#}|sfx8j-`qJ0N~2k25Y(p!#7$lCP+?dXIBYhF zCPdkuguo$!Fi3sQ>=pjA2S`*TBkVYLf0F@ea&n@XS)tWU|pI}bZ4SnpWBw-{_{THN@M^);|&%f{W= zQXCqPKMJ}CMb{=;1R? ztQEZH+62?f^`T->^ItjtHrEL}HLH)~-*zP>DDF6$d{1fV-sApC3D)smAlZa0+_TA!rY6#kux*23o?b6+f`~~`4?4idU)s%_9b=p=#-PkOkif3V<73)df?z^T&TT0oKMDYw6wcO0oC zukC{DX+WfJmEZ?*Eh+%~MhNY6%>n~cnk3=Oue0LVwLm&&26rxPN86wp0XD{>Z zEhIARHe-iw4!pgqD&AdTpuYp4@k+9~WSnMRNzVkDEy-ngSE*eU66s-KOC*>bu)va5 zy{<3*rlS2dal<|55Ck@TG~nowkTWv_kR&J#NN^;)N*q%76A#1_OXtB$^&c3ycEaBGZ++p`yZjT#8r+g) z%PYj=Wk@w@LB}BLAs=F5zVez}+lC0l&7c3Zy`E{~Rn}Se5PkOE4Bc0y3~EpL%FWx8 zU@5&Xp$el&PRVk{E!)p02Akc=;i){%w4pXLNL1R-Yd$ObNbpdyq(cRnamnlx*+mXR z{MLWGJM7;eweWJ8(e|{Q%@Ro~b!liQjsSuDQ-jn}+}q4O(wHq`c25Jm1p^OaWM3|o zXOGG`$u!o>2j${)(O#k=wQoNq-Mibo#uRN=a)o2-CA;?ZMX*o9cNQH0LP>J4n{va6 zNC=~K7VU@!2eC{1%Q$9P-|JubMHRz|akkQs0^ecYfQa_H{Iw00BQa4zBr35VvxALW zAIy}i8{ zaPW~wB0a_LY<}Hc@0&1VdLiSBkyed4YcX`L(?}v{`~|*jgas3%a7^e0lLpsHyVWJM zz{1B$Td*6)EZ0USEraD{_)Dexmrpf9qcJ;JAHoOW6kp?qMBQY&3$1DAT5osch|`97 zZ`PVHHp0h1EykvxF12pKG|jCe6#C#-=M|RD=GtR24uX?Ri$s zV3DHDOjVTfQ2Y_Bf-qM*RQekxD0!&ghl)L~!M?!P%yMU@1#$jo)^rHviN9L;FM%r( z-___8Rg)LkN{am%*2+Xsy6nMvQt|vdfg2=VBz}5~_6En)-Uz%?G3|nu` z)x1lx$1r;y=mU%;DK3_ZjX~i%zBk#+msP*sDC)%}*pc7fL(<*#s=af->z<518_eg? zEVhbUY##o;y)Q_mJKk|H7T#{`t!+0Rcz+J#ZER|ZGkzJI7<1YWDX<0?Ancl@c;cwO zD5v^p&@v>fo&37lwv|iVGg!D#O?gIU+m%}+*lwTA7d_tA=KXAv;9x(u!kk20guWKf zw)Z>aqIGVrTdxlX8KV2mYss}GS0^b&=`;P7_(9gNc)!QP8y2(<`JK+7W3pR})rSLOzjrBinmG+z~Y$$bTt2idKskql9&V33`c|6p!Gd${QN^RTek3?k13 zxMuYNHmUqMNN1>?eOvxc2s$?m1vIxJZ~P!`C@}jvNNX2!JU^87B`~nd zBO)RK#cO-lLC*)jvi!e9#hEDG&i4_51- z;nAoMoh%T}jdPjQ;67B*amKiWkFwYWu_S<1SyTK6LoD|hl>w`4+z!tKv zjwXR@jU6RP9MoRW&p0rvK?kSq_(2}AVr_jXG+#M5wVmQwlAYYm6gFWW;jNpl0Ac72 zXWZ|#`;!jew5sj&^-~anr0N+npePwyCmKJ>Z^S_gD#F^q#=*(B_VUub?LGwkGWoCG z0z4O(STAC1&)s?P(joPyQsC5bRi&tee<>}o#k+@GTpXzB>t9A=1*>t>A|g3me+QlY zsMFd*rppLB=H_}?POcH(DnQZX@g+6o`P*+erE)5SQ?q&*q@&(HcnR8#?cmEd1r*+p z0xhRGqGoLx0*~`w8r&QryMo8u`_3K}31zFHS%atwD<2|aw$r%yM+4}~sz^vr_e5t{ z3PesQ_XOz-FgeR#jLN%3D)ywAS%af^l)yT#$J%*;v9J-X{LHb7xVMUpcOKJWR?g3_ z*$@y|CtP)PbdpYL5s=p!fV|LWt8?TFN*P2S!&-R*Cz8U%?`lDi^8-+Wh1Z~0pk=&V zR381*hT@@Ep8fVD?+!sBL#3Cvd){*ZY}fip*N+!eya(SP*GPp?pU%vn3B_H0RHLTS z9Tb7@*}m$AtDpGP2tXZcs~&XH6wa)@N!@RsZ2r{mvU=F}H*4Tte?5;5C15ZHA8ZlN zhB+dOhxKHZoy}M9s&I!1do@cLx8yrWUBStCL~%j8Y@4hU!TP6`dY~rwM;-sjKq0Wh z|IXK9f#pG&9p9NVH?Bw*TCGBdU@jZ??~U7_?<82}SCn)?@`)L{!-d;%Kqfv^%!L)E zZCh}2KH^}*C1q2Lbn4<|y|G#vO`b5qsM5ZXN75NkvmgI9O~AWrw`pR`&;rQ(eiI#e~=sJuJ;Bx{)0YZX;q*07_ z25HJa&s*kLuHN?$Yd!(2>bwHiAYTG>B-kGSaN0Vg8z}t~3&EcGDu0NS1v+wu@3eFo z(le?Yr~z6;_8pv$t1iSU>wImdJ=Fl>>vuH-y?^QV0t9KE*B9Rv2a_j#N+8DiuMOKz zBiq#mKY{DbUAX^tx|-SD!FSUF9;>{5IJU8^T{DCu*=gJ=*lQ;WgvMfSSPG`>!ot@( z(Ch2SS*p7ZnxtM)A(6i&VT1>&|hhR3GmUMQQEH? zqiPp@3moSw_#EDnq-)!A|1^K5D&Q@|SmaNC;oAEvyYha9JyEJm?>||`k<-jY(>!1a z<>OCb)jkqM_EoySzQPuwg6gl?zaxL`6<9w0Ad6K=I3v)beU2wF<_SZf>sBMdKJE{# zgmf#1sZRxU#``;I1aC~DD0hS{QElFha2b37tTrT&z@RIbIs?tjC*$!z;6IHH<+?NP zFCG{&RcVw5YMJ+-O6hg`?o7TX$+Ncz@qLQ^y3^RnE(G?ZI^{`Wp{!w9K(UJd6P}f& z&!XveN#JgLz9EeUpyD2xy=i9ln$zju73!?j1sm;vq(PmOvJ^Xz=e3*s6xp{|H4CPyIhP#!;SF#!=fvrooR}(o z8iE6A(CQH`dF-U2Di|6>g3QcsPt8nNgIbLm+t|4Z{Ci{%>7vt@l z3u$INx4ae;!8&J$KFqmmc&$OwNy_m8O=N&@rD1iQDkxvFdtafql#uy%W~fhcvhXuT zJi;DIKO?u*AK?kOG)y-%OrhyjK+i2nRD2u)2QOEOShCJOW2vhMkHO>9(+uq0-P!t~ z#qH=v!@LgM&x+qr=DfEPvLhcBr61pBg0*{A z`O5BncZtg*of!{7;Ol1;PFzvU@+vsJeh^(b>8g{jI)e4Rbf36{zk!@4|g5Nr2T;-vFL^~=e9sW(z@$#bM>{xQ#2C|S@_ zEdm`sdDvUQ9dk<|%{|O>8eMUIai#-~&U%xoiTzo(bNs2?e-@7Wn^5yY;1-NvzNKUT z9&GE?$;|ZC+w_}6JG=uc=o%@OQ*RGV+gHtfYV{Z^P-i@)arpDDrO?7JP?b!JU)d(-Jq z!S#~$_Fzf;Vs}~kEB2w>fEGk1ELh~C{oWSI*B4RjZVVCcPV~*xQesGk-#ka&cU%0B zOi`u9Z)+{O@FkPFvJKMl-6)~yYTI1K(qeRFQYgTGv&KXet8z;B87UUW-x>OyT&An8 z%?!XmAUVd9N3XH+XqLtr?5*S%u!pLDdsl}-<*ii zvzM365KUR0c`kSt{sl%=mF{YkrIp2C-+br;xD&j*z7NO+R)LRBk;4?^hYvnURQR0~ zt9?87#@GRKN9!CNT7){ReK(l#A%}p6NGf$tG36fPDMby{1o24$m{BH6hGg z`B=}+R7Fi8CmRQKO}Og9B?H*FuG}gM91B>PzzvI)lp@;CSGUYq6Ede@nJw-I_l_812dS zd)8-Pbi#qmb+_@goXW?fdSgRNGGB1E;M5#n*6!m-nzApZuTFY^69Vs|V?oMTSNAzW zcTv{Axmi?GSJyW@{6&ki^o9@7RV@wsP)kcouNU#J|MO^<1p4*aQS0~RY=$kks3nlu z?8S@}6K9%_r)=(v_)FXz!3f8mqp)NXNEHfky2E(lif+$RSn8XHCpKIa{c)+6ZN>!n z>UL%+>~`a#7n*by0#BY68xIfEK4SXgx)?)$(RGCVTMH(s@J1?ue*;sVCg(T)LJWxyZg?JzsZUC?2Eu_%YPk}`@7tZSb3i$Rvj6O3a=zM3wzHI zwQH&T*l&HE`xDCMlr3$cJ2kqgU^E0d@u7Ki5~WNAEBLFy(*(moF&NZ`!5nCRf}ou~m6wx?Ie|~wS1tnOsqDs`)|elZ z?WjxS@(Y4H((xFaTfXb>UAjhkkQQD^uSRp1TN8#M8VkOMuBEC_B+WRvKAvhY_7!g^8&WVi zZT;p#M;zWx0WK9wOv5WXX$|UD!HOA{%$w_b=2LrxXxkP>#wlfk{#)h;8))$Sc|0C< zyUA1& z&6X4`5@cU_fA-)On{T5YEv~!vJKyv}Nv{6h600qT4v8Lz?0B!|DYCy5(oIjL&up_S zG^`J>91K7Qt>PH}%<|aaq*49R%>61?OKowo&1&f)u9j%B+>Ti4c7HVKg*YcR3J6lR z*Y=Nhi?%EiNjMA_(}zg`4S6z2Ld!z}_4C`#6aL%cQMEB6h{Rwq9!} zSk$}X*TxBX=X!XbkY~=@he7Rc`N(2ZQ<*{B8=Ic)XfzJpw%-;&LJE<)-5z})auA`C zcFiX$Dq7}xCwO>;Rx8$!?d&DRs(thkaI0Xc{bk*#=`E3na;^>{jwpA2c|bHk>f4icy**YK#}}p-D=TtJAaJZ6i~nm!e5=} z`VJ+KuH~NXR7-dZ0DN(^l}5?sXu{>9_eNlgn44Gp_M{FofG6iwg30o&+4Qyy(m0!@ z;O2gGJxha;GbkATvJ1JssV=Ok4{XdB|YRcb}<5_XGqf5C+rbyv+T1Eaz0{i z?oL-jnQ*qZx2swclainjw4m^U4@mNN)(UdAtCwMSVGFZykH9`RVSK*^c6xW$FGRA_ z`e){0M6~;5i=!#`KgAiafj$o=m5N(N8C-Vz)O_0c2Gn*S%ULTJ%&+3%Roe60`M}fD z@C7Q!aCn;gKuE>2Y~|??NFsLq$|jmwjwOuQXvG@0p;M(}K@U*5hZ< z0xu&z+Q9=}Z9iiHKBu1m5=UzAadIR7s`;kTz3Z^2m&cZP`2AWSeFjgW_#ks40;omF&t9*CyxJuZBm0`!1@NGhm%1E7ufqTpw?EZWlNeeowpfYt z)g-CJW7gB8HKyI~iQLCewaAMCC*gR-^AwV2jJ3UE&4Y~i`))laoE@}3h00!-S03#aCMMS>jH)x{^upROe*#dTNH+5L2k}c za*c$Q+X&hxux4+wx27{A3y>D|kJ#cWuPDZbG{HqU@YRmQ@%Kfdu`TJisL6W6+b)X6NL2Sq~(&TKgFS*FY$nPy?);im?6;e)uD0R%CqN}PSw{G0pQ}^Rx)?6J&C4fdr@-d_6gBrXS zEH1peftuu``EUknqGx7~>jDufdX2V$qwZ-Ve2BY0Wy2l*X_b{wOD>1`cT!F{Cg4h~ z6k*!qs3?9Ce930vs=urGqR)a6fSJ$`Pm_N_3F9r&RQ*!~QM;F!H-YWy6vBSOd7|t1 zeh3abdM^+o;Z$;Mu)HTY141m2540`%ww(NCVn*THJt5B{Pfdxr^=%b*YC2ZzZ)~ho z9GX@TrbhITd}i?TCUJH7J!N8L;5GbkGdH?#v*?1bj**ek1(-qgk$cWj1IrM1*>&{) z&KJbmTrC$=%sG5*S?P~J!DJ2GXKMg+wS}f{lEgD?3#^uGcUbPCeUOg4UYGu^PIAfu zpiNNS&U1_dXU?lSE72KU1^*i3V$dRRu}Y)$@>~rZ5f3|dUU9_!UfnmTQ)5F{{X{5{ zOG`6dnb|TJff68@UuP}r+amabu7MFlVF4un3Wzl1V*EZ@*<)!IEs(Y>_+LmXzrfG` zYwHN`?<#*&72$w!U*<7$Gf%DH#n}Nlxp*CC#yAslfpYS*;Rx*p56763%Nlc=f$#Ik zyoj?f2=gpY4Lh%CtYXOR&h3^(za&cx!|bdb=+;YC(2%c+&NV z5NF}(bxwM|Mvy7UF=bjH$Y@h`xHZ6DBu@NuAdwcQUZhWKk>?okvryKY#WBi13rG(aF^K=f4(# z^Hpc}Um*@lvAoY7EmBO_gM0|UpHGC~gEMwVUKd`9x*3+n2k6#^7~Z|2cwCdf;JlyE z3NPi}gKygAljKdj3i8eNU9*y##aV@zVsN}EtaJd7+H!`vGP{my*F>lCB=nue?$FI! zDVP-))>qg_U4^w2pRo{3$B^IblTjpHD+$lM1X3nOSg)PmzR2*d-_d$z@*U7im|NYWI zs&+t;IETUJXdWXv{(F-2uP)K0m(lxiH=HsX6EUtoUe=M0uh+h=ulK=z*7O(`M+aGv zolkIN1uDkpF~As%irxE1MtS+EIsvX+C0J0OM`^!aWBRvK%az{f17Jv}GH3s7tic>|Al z4pn}%3-GkW?w%*MZMuO5U`Mzrfqn7)U zEew9(dhA|5ZvDo{4=WF3*=Rz@)sV_~zP)xW!Pvh~dEP#)EiC1qmYK*D44EV8ni@7!@1Hg^=jEZnS#~{U_|fRvEJ(C4qICoVK(SNO^djiPT}Jqp{Bo3QT_Q&sXuq09no6jsuHIc=j5U@>?&z0lz z&!4ZDC9_&9FoQwVR0}wu{FR{lq61AvqoL~{x6ALJ7~X(*zUSHVYt5w>w5qY22kf^B zgYmjaU}^<4K=mQ#cO3zy#LWS^f@zN2K&8d{XkI(blFSp5&ue;x@=Ps`8nU7MMo#(} z!)xR119{Zbrxh{ctE$-6^mJQ{%sv5^JA+BG4bfuSWi--=d>_^$qsx97e=+h)cZ?ek zu&AuI&mHWhIJvV}VUeT?h+@l;F@P~>1JA0k@7bnETc|31{2IQlsZqpb$XXLvX8RHm zO;rW$?7I_c%gX=l3#mqR3fULq8yFbq*%~X%|MqR9kEZC;rLMmcU{bY%-ns~`pYYW; zADZv>lWg8g!Dv5sjTb0o)ipHMKu^BvI?lzJ!kcSgmrT~KcV~I*^kmi*e?$WM+{HZS zCb#tOX_sL`K;t|ENa`fBC+K)AE%QcgCSd1$Qb!7m!j8yUDef zX8^gDkqVJZiLIh5>i8fq+dd$0{uREB(68<_?VmPj4H3Fu0qr*;wCaMN=$i<7{mH6r z+u7Mc8U*S1e;!j_Y*48NoL+EFA-6scP%um6iT5naH311?>}J(T=0R|ls=b8fRlf4q z=%*0augtK`6JbfNJgKb2;Fr56`2k#c7o7m;GjT5cl3E|%KNTU4k6 z`C8rMM(H<9$AlF?`B*)5la(gylVA@_@0JF_ZvOMWi2qRvnj&)6YOzk9KDzETx3=0? zmGuo&J;i<{(K#HtF@TZe4+Jtmp!ZBp&8G@5ceUqOFt2RM$I*~K-hVQcTG%15C3jGV zVL^4yvu+KT@4H&%;Y-g$t{OGN{N$1U>YB)w_YNq_QI*yAeI+@KzofWoPMn$?cWm(( zXH-^6bd=J&H(zO&<`2#9H)u0lQqEx{0R;+zDtFV$rY7H!jY*S0f3f;NV2ICp*<4!6 zoHcvrXrFp-7rsf7F&tIggQ;SwGQ$1m-bmTEe;BKl_)|xPVq zw!6u(pI3pXa>N$wU!dcCzf{Z_nx*-vWDLKv9!Xp)BZ28X7C_swMtu_m%L5!++NT?Cvea1V{_4=g z$42i&Dn;jc2fopD)I8jzd@TRMpdR8wA~27^Mx1ecPNp%&PX+MYN2A{5Pbv1xxK6*` z_Z5TCHNMWL6_!fj9ulsdKed@E-6G@4_&`O&sBEkqLs`S$e38TCUC|&@U}cpw4nd<5 zQdd`BHQM({N{}KV6FSOZ6c(QE!zlt_u5N9xaN$_P<`HO_5#+Q8KVic}$!NM$eil0} z;zc=qeKYz3pQXf7rM_L0HMw%1IB|QfCTs8>Bp2|h&0jKe>92}v z>_Xq@BhH%1Xyw6k*!hS2Qov?0 zIO6;>npw-W@-55W;#rwzn!wYR;fX@>xFwgqTKLBhkt7fifwZjM-bWRCOD8! z^$(dCDqLSJ-il<+27;E)K)?9t=s#lv3v6@T6um52zeKx)g;NS-GPULak4ACF37Q9# zm^^@L3l^|&dJQIxQ1K#YdMC@Qu!V>oGfde83*d*-K9!v5MCRJ;`lU$_efuHQ@+3u# z+xuSjk_z8=<`>%+^Pb~#6`u2r&*VO01!Ngc;h4;Dm8HGaVRoOxjq&Q7y&&4_SwwKD54l02NsO!wDGIPa;dM~Z^5l17cog` z4aR|&4klJXK_L!w|Iusvpx$Pf1_B}A%4Q@jJ)K#v(_Cl5vlAqE~<@dnN< z?jsvAQDiaj$~I#GLBXWjf5^(G?{Ubhj9-+#$T|dOn!;4To9F+YDU}wpU|SG|$V(3E z)&QN%@7E`RC8EQMrnsdtAWvo&W$m3hM|K5KvddZFAl~vMM;7ikCcsdk{)(mjKJwzS zeE}p*CZb7zMtXS4vdB2Y+Ax>aRxdce3H(J<6*5a8vvv6`-97R}w>pK=eu^{`sEEvJ2PJf!1?XJ3L zp&g${78}H`9i3A{`%hUUdkt?jieIHH_u2w_paMmuV^TrDtpPG_-EnX6 zp159WDn-0E>|_&=`rxj9EW1_ci6px9 zuf#=1=leXzH-C2~VQ)`ND(0E^88>i`5bNR+tcyZJ-`(1OoK_G%uc*7@mN(G|Yq!It zcewh5>0#n6VVR}7#vr~IzrAxsA$8;eVs&@Hain{;!^;K;Uq9cvsRAxQcUlsI)xHX= zG>u4Da_wA{b3j=^DlSsVi<*Q_jP2V+3{D)#xKAUX%pUG+Ic1vLH9oLJ7_9{A`C3~q z08z5AO4u&_w4M#({b-RL3>BPT>?iDCdkLR&5ET(=U?w` z7+gKGG82Lr-qesMj6pVd-3_NJF?MQkqkzW$GYsXvuR7FUqtjT6W z-|(C$)0*C?qp%}_(`P5R+S`ajoR(~SaH`pFY`!Slemj)jxzhbut_X<-4`S&&p30Bnf*TAARKvAzN|{&;zfm(%sY302=8I z2R*zD$rc|Wi4DIRcU}Vhq_wAO?UR7Qc|YboWx&+sOvh3NpgQa$dT@`rQ+7pAftW3sh9fwu239 zwVDA7kzOM^4NxBWeXy-!XbcXi5Yu;*yPBZJRfn}xjCWWaX{4=MS!ci87egbniZI-?7);^T z#v5`|TUof?^E9aU1t9?j{J$^V&IIWF25|`_hxAS4bkp50(NcURIS8o?Qves0TaW7@ zt5g`JcnT;Z`bYh-dszc#qysk=^&iZ!*s?D*zrOvtH_N3)u}}2HS?I0e!u1iuT41IC zemo>2M;}cvy!(EmlDou%^gO=8lWU}o?7nCZnRz)Ge6d#cydrZ2>>>e= z_m{M2N5FjJ@O{ctAR&|l+A+y06_}^@P>l4&`+nXB4ym=_kL5J23d43q9%vd=ULK^T zj@7?1)^!lM=#ei{HC5Wk@=yd+kev#qhueraAxMjO%HTOWyNXluLH8S#JNwU+v;18y z$8LHpC`_|{UQ|n=0V(?le}VfOMSvusTT?Ned{*qqgO-v@nmTWlxQx~W3zMAglzWR& zzGjtIq3?N@HJw}uI$|pg%DUbb#b1rA6WaiJNSSoYvYd)oy+M2it>e4P2Q3V6fmQce zCR#x{v#zVuj05@VY@>9p<_Gek^DwYnIz9AVpV^ey)u7M!k&f35LE>M*miRk!s|io#lK71{3j zG=Iz@xg%yztIAoV?kp#2W$+u0FlpFTDZdfwBBqj;)#~&Zi00U=KhHt3X>I;7H9`)) z%X_D?<0eA(1<_qEhM0Mu3t@MvJ~a-{StzhIdd^Ku68`%&dF;M2;F9M^S$f!sg$$qz zM|*0|ygyblK?E?VxZ0V>p0Rm!-P6DXe?NvENR{+PcwWD<0I2NWl|7}ya$aNV`h9(8 zZkE#Sl}QIy-i4bH4aa*Jf|HjcirNGPkL8eV!lkul3n~UZ^G~@w`o}-FQu}*qWgmDU zVysXDhkxny#318mo9`G2^sJxSzkdfbDdk~bt15dvpH~*x59{Y;Jb`AO;Tw@$Nq<&) z9rZ$(hepras)XT8q1??;pgG4hG-aV(uzp#7d-Mf+=cNNXuZ@^X(n^45r z%%*kZ{#ZgH`QkB2Ih;5)q-H5icln?ZXC;}G=LwqSB2tculT*dtJXFlS3B3&6syIH{gsj>XZ93?my8=G84!0KX?9 z2cKJQ2d{F(Mx45Lw_GfyX}3c;Qm4pB5WppiG8Wb~{aT>%DmZZgZ}0(nBv`oSNVzPZ z+8123NJ4sm`hi21l@8m zV2t1}gBf^S{e9S$io{&4p2x(jCulXgk{~)!)8~TySw(I!`KF;Vww=O3OxTGDdp|~T zd2G$6Bif^7UJF%xniq^0&*oneD7E5N&!2qVHALJ~pthgKq_bFnDE(VuOj3R1B2HmX zI8;p0NbG;|isCE6NMg0BKKc)kqvjRLe$HH`F>Sz{1GwtrbaV1-jGbcBg9Un^-2$~6 z07LZ>-fpX3j4Kf$yv*oE2%5^STjrt@ThO9-`$Mg*^k&Z(mY(dbTbmjuPz#l$#0oD= z2Q8RwUq>;5eo);#72NAkCNN%8wEu6s*`B(-{^0C>tLF0@gfA1uq5|ABg^lmVUf&Cq zG|v=KEai}+BStw*EPdAB@_U6wqH-EI>7->l-y#DRxdbnPg$*=qljLD<1PaNeblxN$ zo3@exs2Ry)j%nYVPko7FvVRC2`c_PQG1hx(>DX2$6F3*?{!`YQezyvOrr|X%D9BKF zg?y#|+Y1_W@G|hNUIi_*3Axb(43b7xDNH6nLM4@#oNQ0aPT=2YE zW?cq#@cH9rH6lv;caO&cP(M9Yj|?ra z($L5y#*;4z6Po>V^Ye*>5hei&kMKH>Us$@DS+$>HfSE!e{nxe`x83CAZPT=X-)GIv zAu*~W)jyqi0L{18r4&PX_T%`o&P@36a-IvaFSC^$p71>HYgAcN+`;>ocyK@0XLy+4 zlKw{-%D=#mcWmkjT$DTp=++v3e~7@?41k?Fo#tBZFLXx!PCvONn&AL~FV1RaC$9Sv zy-%KDTXZgf(2K*-rlPs3glZ|;8}S{J|NR}Kio0I1o*2eiX3{?fbshd;iGGS_CjCpv z$u6%Ek%D%~=o`P(W3T-AXl>q5X?PYOngGH#;{jVMIr?-23eVF`gHvTUY!vR}rpe)& zd_(;V(s+Lp?HFeVkv-z{co3;yFBFLWphxzFkZO=N_>etRQAD#aiH4;B3yptVFFw%z zYaf)dL3ENcXh8w_H6dWP(EeB(kKzY&qLwuhecBJ|C)#DtX31nLc*z*>1z7K2{-NFV zL9hKMt3I#MNx2+^9<3#(rdH3?xq+IUUS?tDiVHvaO9ahk<-2b**9Eygs1}bJX98BZ zp`w`0+yh=;&Bm^TIU1|o%#N6__?@H4I}j-n^3QP#b+cR#;VuA7 zPvj_0Pfo440)Qn5c)Cn6*`Tu|FfL`M`~+vtcXOTRi|IDx%;PU5fgZ-lsK?*&J{WO$ zORSqdgIOimIL+oSo;!9iwa@SiWs@VoeS$KqL~x=VmIC3U>KMfY;O`G{pY_mLHZTVm z>8G#MrC{F^1Zpv+Z8ILh!rSQu+H)V#t6`$5FNkLDmHS!Zc;PpuMw3{oBu? z)C~z4vddbj{hwF%_~&d;k=!)jG&-s-=IDKu)I~adObCxxmxO;~{A`z_&y-mP=Njmw zPO8AzGp7(c26p+eExu=ct^QZ57aN)NY}@81-0tK^NIzcvvs}P8K|FX`e=)K(i9%SG z0jotpag7Ph0DXtrrC4fu5Lkb>bauQs9|8^;dz1vxo{3H4>p=D@2drVx{WmAat8~Wr zZOA9@JDTKzCA=(w79iuxkx(|QAUfV3F^Y8t311=*zq#*kM#Xk_#Q}5*4 zkrO3ocbfms86}HwM+uzH#YAs$F)w~Q=Zwp1S6R7B%puZU3Ut;=Upw+v#*DX!NK8&o zDJ$)Hqo$3FAUnH=t9bLWrB#r0L2w`q`|sIrzl>_A5z>)ZTO<8Q z_hXHV2Rmc)@Oq}~*PAp}MU~h*zL`!_m77pG_`_^X6GZZ0Sbg&{GcMNjAueKM9+pFG zVt>0phcX64dyikn#s?pDdXA6Xz8Bts+#tmb4gBV&m7~K?@RetQjDF2j!5LUKpy-3L zL!kt|_ui|$b0ma}`*R-OZt{c9gGWEC?f6-;jd0CC<*3l;T zKqGykir_-TKqm^V`2EfyLZ?&akB*WE=PLbo?djN*Z$G^PfBnBt`!-Biz_xaHOLKjS z7Z}E5u>8l-X&^Y!*c;vjqfRHpLyz>&?LJj_YKf)|JXvwLu5d0=kbj}G5v<#ilZ{0& z_R22L20>Kqffs2ZAm|y*c<=*h4Ieo(?syGuq+EZ{&A}TrTaO-tSmzl{CR_^Vi3gt$ z3JFj#U>wq)do;@_z}Oi_v3pwTg0b_XbsS#Rw*v%r3vD}35WU#|oUD7DhvFQ$x&P{iG zbLlzf^;>_=k8^pk_KIiCXUs9~3GQ2P1@MD&_`8YzJs<8Ip7B*l{bO;FLBDNo2eSG_ zW_0jlDXDis>3t-PRA%ah6YjP<1qWR{8esnK&PrAs__}-bF+!ZF*0w!VV^tpe zQT%wJI)!t?|4M*xN$N`ztPE*W)3k%7v7^jj(b;*v^>BJNHjH@~boahp9_(smescf* z_c*klU+d=D|9+NdPjkV_9iiUqu;+PdJS3I(UjIVT&V`>?4xA7tfP!F<-7t*P_f$CJ z!}z^8MW)N&;|)c|_)#)#w_pxqS_4o2zG>d_>FSIN|zB8YFtzyMWq~QDW zsE(2er{Zx`Y%M2i@4cI(z(MW`iz4E!_|bPMpwIqF{bG_9vcbRD*6Sr0tgG|P$cWzj zZ*yzEPKBP{2AJ9Jn!D3)LLV(~wv$JZ{Mp=D0DnFPl>$y~@s#>2s#Y0$!MzE3?_@(= z>#sAKvSRNhyOQ4CZju5x8xn{LZwo%NRq9ipn5#pjJMtuuh1J+8gx@Hcwt?7ZTv5@KB+t+rBbA@+WF3j3zoZ-GB4%dr8oL}9rQG%j(t|5>WpHnSb+ zQxi6tACg6Z`%B_couAbXmFr?|PTOA}dtDvKR&sFNAtOE)UrcIjmK_s8<0KQeGhrP@yu&XkzCHJ>dY9&{c}itp`QrkP`y`L7nA(c2)!RXM*vFKw z`YqSiTn!Qr8gACZTLgq})5;IdZI3stEp6)eY@>dirzFL#dcQkY$6n8WI-~;CBi`4Z z?&1FxbY7BJ%bq;rHC2nU^Zs%YTIlw-4<37Jeg2+U5g)`cS#RbGx*e~s6G42qSKrj5 zI#+HuTk5ALU7KDDALvO)N(O%Zd<7KtK#!vtj|P~cy3q@Jaem(zsq_^x;ISc5AJj^54O*E+_``qZ|ekes5h51=;lC-JFrn8 zf(@oN|FqN0+DX^_@Y47CAkF(yq|DqRrtE%_=>h>rZf^h7eNHA`4((9vqnA>LXH$iG z+Uc}wY{!<>Hq8*l6F=eN zPy@4Us+j1H3R=^zaz(xtp7(!i5-g@h?^U6DT3Y(GkjFL2i>jF?{CN4w0Y0*U3{iwhgflSnh0 z>^s3xfwZVRQrveEfgr`y(QS2sKG-nnIl~zVw+scz&dqJBlU@}c?g$zK$smy8dS=cW zcVt`ClQ7sXoHx0&^W8U4eMchoy9vz?KJQLI8V$A@FbEZW&B(Woso1gDx+-iJ^glQDWt!D>ae&QiMjlHd`wRD_|d<3$;7MTdjV~uErTRLZ_w<}Pn_zN z>h-bHu9oN8oO?hXCb9ZU_RWMpejI?ExT%w{@66K12~pvS1K>BUA*C!`q`JRp%9B(ivp! zdF|&vb@%pWISHFa+_`gyY4k5j6!k_o_LCrSkjbm`(?cr8sLWP*li=|ld|j7tn}s*Q z_GHNS?o!2Q(K78EC4;}nmt*~x-&^8fVqV$}s68~aXix{L~u5xobB{D>*eIk}{*vS2GGdqG01 z4R7mvjPtT92^*zr1=3WPPoMs|C98REp$iTn1I3$<3aQie7i<(oXBXr%ERl`7f8UvB z3odO`-%$YE`+CTfelA21QL3u_X=rjtQ%(zpBjW!*2lXCoAjS88f{>9&wIuIwdEq&d zg8sc^7}`mWsh)T#1#CiVX=f7PUfm7(?EMiRI6cySvGz8VUgvU%6ks3Q#XGyb1ubQ> z>;M>B0QVjLwcic;N80&`0?%X&Jx5Y(-ldrzqAf?9)zPo%lio92VU(0xOUJ(gC-H`M zYr#*rK0ZL`+A`z6X9fQ?mo6;%d`?tGiCENvbpI3co+x z)0K~FW`ust^$4_S(zU3z;t%e6x>gRBZFsTNJNT}A&@}?lc-6u)b25qcPlG~cm)tf( zUj%puEniuPfAZ?#ZdBHd;5*?7875Zv!-h$>V2$;BN+f_ePzfA)VjghSc(4b zx__Te)D8Klprnzu(MMyg-`4Mah5pv1vsoFpKIl;Ku^diRMw~(8%MmGxC8V|V3KtRg zO!HIqo6VAaRDJ+_+b1DFA3S63kCpRSSvdp-h}Po~Zf|U;>NGbt=E^?&0y_ih&pR?; zq5t=wP9xh&JMUL_J?3?03hXV=YyUZS1H(+ z!II}KeU!2mzjQe#|5lfoZ}gpU4``)C3ymaFM1bZnbm$a=6m}2e`k%}F?_{w&r`8xW z<-;g;@wHExNI)~@6QKNK^r1=9lu4>01#?@)XMEb%+u9llwxU11mMvh}+oP;MTav;o zh9n$&J&B2+JNT`rScw zv@nY+upT?PIVtmYsojq3(w6A-1PzTG+VJkX9mSGP`s)bL2@5}Fqqx2kcDG0HX3YM? z_4Fs`F_@2e(^psZS=co(!BJil3eGc4gyq%IrfgDgC&(9bvhjDX4lXbVYV(fp+l(#% zQ^BSnUdMG`=2TeVC5(Z-IX*foSH@T&R%pX(g*h)9L-CPIZQ5Ej8oojk>m<6yWQYRdG~=l_Q&}LfEb{xo zvr3Onr+H#iE~Q-=tGdj)xXtX z7K^=>8iK>DtUWwUKqb8)xOT?#&%{sx1H_So6fS{xyXIuZhL1I%6yy@kL#I_fml;GyETH^UNL_ z85z^{uKv;o!s!jM!F~LpRzk<8kq>We?k${DvHHj+WTWasTK>rX$D4ziDYC?uBCK&K zxhkancb)|JHZ!fAD|gs<@YpO{^NA8+r}K3?Q)R+_ zjTD%~f=7Ee_U-h5=4VC~CDMjk!xFZ$^r`m5=;E!WYyz%pWGph>w*sV^Y^UspdfRD8 z9wk+4FZ}%c8+>fjWcp?BbQMqzW)63iEp$f*)OKggicTk-O6h6ON+z7WNBj62ACi3k zA-C->Zf`j_kexc=@2Ff=gy~$<^!0f($#%SHi0r{O-pNRsmP@f}1c`}LJW0HzAy}lL zvJp)mSX1)PYvkkOGpUsA5**2A-?Zm;M5?&K7 z_+YbTwmobc;5Pe!3a{zl@2g^rN03UA{p_5OIkJCev|AVU{4px6LYt)? z0g{7GbZJS^b9tShiW)wKLiGZD!%S7eqcqvWilx5}3(vp1O2s4!J8Eq62J~%z-d^6E zn>pL&`o#|A>K9YICpxGBJZ^cun*C&sZOy1;N?$ng%M1M8RF5J~GOnL2=jScJV+bal zBN=V@m6DGh`Di+gzp~j`(W@%ng|UUBFa^Op#bX?7ZypPZ}i zq1n}^sMP2MC6g$?af?pI9Zl&f5ug|Sgi@AW;_G@~+FWrEVk*HOt`$oAmpt=RJo@96~kuLcI4`IAGXM4EY- zcbRUkV|&`ZfA_8d8Ck~UdRxG4IzbMU(AjSVh$$qAzz5S-S(hpU2D!D(3Grtl)D z7EN6xia;lYI6sJI1M;7*!i%zF%7^k8J81#m&fuVmytHaO)5($`Y(BP(NOj$qh;ZtW z8OL0zuL3+7A+8(oR&hhPlg8Zsxav0i@v z@#E#NE2g5iUO~ZF)}4ro%IeUynWY$k1L6cP>1?_mt;gtW&>Z`aSt7FoGj3+^AT%gt zajT=VC9$!3wL>`n{&MJ~>Yy+=EiLn;?%B=n+Zv> zT^*N#)W=7(=b1BDuXopUbm%=ib{~Cr;Z7nMSO6(loHINs;&*)~D7R158_~zl$2jJ) zwlh%psCmF~q589fw1i7jUJ?Gw8XvdAg^al{Qn{?0;?$w96@Jao+xeJa8pa?tprv$W z1$o)A91Iq!k&)yu258p2Ecze&>4~AEt)(GSl>6Fbqo)Pg|9%Fc07Kd7_xivL7M&^< z;R+#6T+nE~z`4!JuZX>$#(prI{vpj&*$opMF{xoydLQC&dxmUD+IYaNu{z+X zQF55K85j|MWdrrp@D?BF9pj6ty~C{=BabEgfhCUm8;1)gUZsueF?4FfWC z2K=tmV9@kObW_mv&KLsq2zG6S6Y#l~FzO5|BE$L^d&_kWQwUBQjDU`Jp zNFTzyS0qZ!l#|Tbr|p`Vp_WgtJH*DU>6Qf8G5`Pn11qbw;Vae|?=-#*zK~AtS$?}t z=sSRRDlffr!*l}%hT-cR6;aUD)*{~h3@KQkp@wIb>ve2u|6x}>ouGb@rJ+L$WF`8m zPY#?k-UIXrh0f7@97)&l#lubVXl9&r(r&CN;v~GknZ&GV+D~tmJL>|^?2|q>jkv62 z+++f+YBsN3YmRfOFXBU_d2YhHhKOOylVSj9-nqHf9W!8izA(Gh z)dh1e3gf3_FjYfTA9A8O5CoaNSjezQKgV4o^E5?0Tk3H2Em;Qwu;oY9EolPjoUQ7=zYWx?c9zuXn!;$w>>W8{M#6r| zf++pA1!TJobT!8w4#2P#c;7xBEEJMPYB?HonmR=iCnmqCL0g<~$YmFe|S1&VBOo@)GqDDR!MB9{Jxr^=#)GFtog;5gJP0A^nOE@E^@F3#j5=P?bLYJ3xU4 zr~WK3I|d^;eeLfaj7Iab%W9XTDnd?%=KbLfkiTE|cyl^L6F!sI%-~vv>QVI>g(%cw z0Jp-d3~+IMoF(95SwomymTgt5^B&F%bUij|qLpqNqZM`Squ)Y=N-)pz%Uz_xbcU=t zhWjKXT=G1KPMQBu$zPCPOwb~Dqk8Lkx~p(rJ8W#fpwD2n1&4&tQyuTrXKr(8X=(NL zt*x!mYzbZf?W&(ICp0*?aCZIMy>%+Bkhu8x2Y<(jJP#wGK_gG3DgRS8@L6%@O{p>w z2V`UAto68M?E4L^vHk?R_p?J%+?NfQ&4x^4e}Up`?+m$eq>@;)nh$|lGU=ii?>OcX z7mHZp!3TD!O%7%exzPDf^l-cND?A$pVNAZ>mu-AeuW?u@11a9+{)z$9<0swq2y9Eg z9|PQ<49}fGP1G|m&jCyVfKNASF}v6fAA z)R^XH6LQ;xikRxrTOjIkPiB@+HGoSai_5w9R0k;c7Uc2jTQrQ&Y7G0BE$rTHTD7k7 zNIueSw$wsCI@o2)3=Aie_y9MUIWrG18n4Q1AqPbv*L7JY=4B~pMzmb}?(y3J%mMDZ zb{`LWz!lQ*aIyci#U{M=yQNuV`914@d+V-n)IiuxZPgBDWnm&|m1fZc2*ZyuN$6eFm z3;3>Y6eHF``&QC^KWWeA4G5;xrirjXI>T*rL#`)(E)30X4q*ulb)3$yK=!GVL2{C2 zW@eC2YPE7#sDm!ByZg6Oq~hw=s>+ey_0Pf2|NGUV@=VGV&#i6G>jUic1EMalUU^S^ zjn$KTwb|`$qRZHgmR6gVdSQC5XZztJUBIm6{KloEj*-8MD6XK@5L#`b5F*2&U}py> zAh)EEe7Us-)cB2uVi7Q)g5yh!ihN{O_92!-!ZpTFGr(qw%wSV*q}jqyh&1xz%ZXhy zpzeD1)NfT~RvhguWFm_zKU2(Jcd~MMD-nZi0}}UFTXHcSnjed>EM>&X|I1&1)77|q zUB9b;H#|_;3>qbp&Dsyi$YTQiW387yzh?qwrF}XlbDq^KSuc0}z&EdH%H7G6XAE?Q zkDsqGafdWiX_mn#sN6y8LkT zC0d@%gKsKPYb}?dk#WjU7VG}Z{QUi;O&&`~U}++kl|L7yi#f!2RBdA1zAi)LHYDcw zV5WIgTVFqZ*ru6SE){NAP&8M4v`&jNNIHS?;Y6r+Rr|q6yw`_ zz)gjt{hlf_kZeswE}a%TokN4FpDbnz>7lS-918tsz4TkxYQ-)z!yqi3;wNEWt4i!L z5rAm=Jv3EX;ik+G)8XfU1{ErPpjUNCS@tuvim#fnig3d8jr(Pkgv1D83G)0xL*|Z| zjpueFk#phCIn-fvSnR)!m?O~K)az;}@2dEPChGtPxEn0hfd%wZW z(akJJ30Ya$$H!Fv{usEU!Qe3dX!KxKPiuJ|kF~a*&(I?J=-4eG(?h~T=XC|>1`v|< zYMqZPKw_wg-w6TN@4DHVH2xFl(HKEjc}T=79|)F0XKO8Xf%O9!H*>|@jFLu^frfR6 zwI;L{+}3?3{M64f2;6}+DYZh&`q5h83{HPzk|E9(D+|MqlMnqg*s?-^XB6~yQ89hB z{5FdOl0ZlBuqGeiDXLB*X1e$j8DcK5*{#so)umtI6cZNq5s4uE4%)zINcvDMhcIb5 zHX(i`3yVzX9!V%D1PQGEAhH=lZA+M$Eew2!jyr;cU8dXgotU#-#|W+EpW|ot;PUnK zZ{o&Uqx0ujEf`xqO@LgAC9&WB^>QK+uJ1#j$tpK~RW*j#$!r`+cRKYDg0g|JCT}#g z)u-y6s}h6zkR>f;ku<(uSmg_Jw{;?s8JN6 z5mS7@|7tM|siYaH^G-aqCCL$(2r1oX>n8}+O<9(KXOr3dovRd1u-cU5qE|&{r~EEN z7nmRu{a#u|Cd#5-A+|gKwWx1g-x_oA@nMKw0SRZ(4Th z)G6hf@g$iD+7I2wGhxQjx!*q_n%uF(DF!x}FR$T_Soi)p`fD03QO_j~xtx}6ne|5y zEFK<+R5-MB_=9$H@fl1PxUx0yp=!^4`r_SNZ;I%dl*rC!VknA~@<&4{d6~tyu20#f z9>?G<7}C~eKO0+qdDr>4Ct@myfc&;ky@z{_HWbr{aoL38_L;4>U21GE8bW|^0d*)e zFUI?JqNYmj#SnR}P{Zs&PxTeX)>di=G%UQK`+DDw&&0%}_i*(HC=_%jL_H9g?2OPh?{05#CEelS z;S5E-b?Li|X=KOi`lam+(sXtVAmD-5Y;vpib}a2bfHw}o>;NjG-k8reBIHY19{$i*~Hao+%8Tbcma zD~emPGC(X3M{dU>s0c?z%RU&v)F5^-)!4G#d2qI3q`}i^%m|7Q~7K&goHAN+~I9oz1pjQNK_c0p-mZK)G{%kK13)mUV$qwNy+;u|Q_ClujYOTEzL-%n6Whf1dt0 z^)OWE^W>Y0scjPH2HXgveh8)6%pr90VV}e(!#|!LKVQ^H1-xgEXEFE?O7`Z{>A1L*7PE449$S{q(IY+t!@ex7JfqfY z)^|x}ZuK0?9gYbf&dF&U&p11dp^7!#cc&0Ej>&fH;J)_pUZ0c|#;;1cwWZ|~o5ybR z+BCe&=8xqHmr-+4I)NYv<#X(Z-eD11Z@HtaF{)Cvr&M($T(winHo2g4ycd^!xT$ko zSSUk`7rEVVBcMU}cwM-8yykT#xhvzyLd9?~QkRLSE~DMOX{*OZ)Cp+y{Lw znB(*{YSyOdOx7rk2LAQwVCbne?q?6u{GRR*r7=(>34NVU2oeBXSa$e;j9Oy;XXMZu z_lsox5u_mLyc+7J>r9=lX3;1rPq>HCM3_Rw9{a^>rF|7`ruYI*D?bMogtl@6)b17A zK5##msyhbn8i@s_ks;>Odomu@YsvTB5CoG6>M+v^wJ?zFv7j*)2$N6rpZr{QOG-}u z11!outPwtV;kF(z=GJ(;I%t+1%n*Z3S7h~v3)a@f~ZR{lZXc46?j!ZqxMt# zEyVSYrFzOOxs=dGqu7$mXOl$!UK!QlteBr=S4W3lA^!Y*yIU`d+m8>>$K|vc#qAoS zYa~eIv?wJOgYb5&-Ceg9KSGI}ACvAGW4gM&=^-s8mH*w@+S=Nh(Dp>)d$vL}N<3(mN(Oa;d;DrxW8rO=inR(13Vj!`GW|Y0b;Cezc`aAal>uPjbDB?~2#!p9oQZrEzX4Z#-}^g!S_6wRKr z{npLSX(>oL3mSUhV+AvlQB>`tMp-rO8Z!V!th%3}X#_LOf{jqx*_|Yr#OpCcaQ`Zx zaGR<+TBw@56SMoS&|m9+pi$py?aL_{8JZi;R@oSx52NsX_7hUk6ZB|PPuR+J-CoX* zaTTCMfIx2kRu&e)FU}A|A0k!G=!y@|8)3vevlRK?;&^{xesi-vpb0R8k`Rb2e0=b# zNN6|U3_;U&j36WEvXxgwa3dFc&xC%mFJUei{2arWRCPpYf+6VNKJ_g=oG@ZftU#Z8 zI!2iA1oLYo66e#NZHhXtB9)w~C8uW6HDZ(aqihmVwj{~=bD4T{R~hex5fQSQQVdpU zJ9=q831d4)b?MfRZC{mT7&4BX25uO;U%!4C!0xYCGs~+YQe`AeF%dKo@o~ ze&B{Rq03Dlb`N}z6DRgE#4Ar-znnru`mzQP%XKqe^TV8HLt$KqbF-+DRHc>#A4r`s zJF3a$GfgsUBgM-ha$|NMhc~C0CiS!XS=Abw&EkHG%hZ=@C11kEHpn;zrF?<>F7?RB z2*=&KH~++JO;7dN*xDL`C~Y&B7%KVX$;XEiYFgWvv8q|K`D0fhP+~d<2AsFn5itrZ zYh(NJ_ex(~px~RdT`cL-au_gl$1p(BoV8@~5;9eW#3H-2bP!|l@3p|f`A+3ue1$Z? zW8Ui|Qi%kYp`}zHyl&cpwc(TN1s)Sj_Kl@O8zpPj)(@^IP1bvZSow_t_&x^VF^Y^_t9WP)HT6r&HzGx2X5eC#<1s)Z{bt}0=Yt@W%! zUTQ#U`QQ**mUE*h*v-xLSx9m``)4xIn@8hI_F52}!d`6LHqS7^^-QAylH=m#h(}y?Kx=t+1AG7;Y z+ry*kcU6J>m^GN}t_Uu^T7TInKDyS{R#=vu1R!Xxdx`*4GDFGhey}sJpr|nFSh-G7 zvNdRiviyUNs;#Y+idKLP3MVHg^PrKv{iami=Eep<5Jg2r2TRyO2ir<)?>v$5p4sQc z#?s{_5eiswgZX%Nzji4By;Hw_I3Ig0<>7Qlcf&TKHVm<51;UfcJcm)ma^oN1`hsGv z<0F?3Tbg#vGR6d4foW;1uZQ*v>Wc>k)ch5=QI*02T+fDQ_J-|XvvwIO=1Jo-B-ufC z`#_LcxJ!gLpZi7q&<=f)Sj`d;8|LeuQyL_Li?tQ$j;+QRm%d^<=GnItHJ5w!yxrb` zt(b5$=7jEM__+y;7WnaaczGF-p|S!8D>c1Qg)0FOQYGtc6;XHFMczENo^y(>Yo+ zF4>-gk~@{yB0f7?uC%lin}Z5yO7Yq+&R?i>>U~0D0Y*xcQ{@=|bga5nxhz^eBMmS% zYAoI#?c$Oj8fD2I(_B<3!^5f|4KFPSsQuMKJBLXev55^dNG5L|HbzBXb*?Ouc-wht zcQt=}{jgGfeO)d@KfFrg#?7ZQ(?6DM#K(3D(Cl)3g^l)!%OBj%sK2I9aD67tpTxn^ z<`D4OB8-*yLlpCCJ|7r(mp2X<=*?djXntWG^|VaaRvhOmgvcgiUsI}YNUiK9>}P3} zO`g-)@fKKXxB*Udqf=$wVOTv?^Xo|A+`DNy{N1j6(0@<$6;{vIjUK3bU3UBHg^bQG zM6qpzeE5(vc}Pc3f9-|c%>JPK_7vLv-?scjK?40Nh#Xrr z9JKm^^Y6{-6^)Xf7f0)(WYboKcnA2u9~vnXqV}o+NK1)md0A=N(C=^)db`XU`(Ce> ziX|tw+HugX^Y#jwljk$CagKjW91XA2t@{O9{j&1rs2HVk#< z{bfM zbsRv2l(N45!t>=s3jPeg@UqgFw6wGWnOEm(Yom@sz4>OiFQ#z|cDaY-vw3V0v8t)5 z1%`%_E}HQ#Lj;v;F8m1X$@RR#sO1TNeA(qlh4}AYmh<2`I$h zes5%_Gij0fJjV3bKEOFFN8HERx_jIgN&5G}3Gq~m#HUx0VgjK!gB)Tt$soMjI6yrV zBqzj3s^ga1^U$e7lr+lGb*5-oMsELT;vJiUg2JH1-d^}%pS=3k!2sF@VVvZupAC)6 z%97Py5ATaSbQ4-U3wVZB;eeG$Sb;YFU4c*={DY&}m0e7uve1JB1sdJ>I%|wRcwo!S zq!R1ZZ@R&B;%*v8-0c_8BieD|SSNRbr)x zq-{eDYpLH^{jK_5uL{`GGU*oI&Ok6vwrYA6ua4G*j}>5X$uO$ewGc)Yu_F!+jvrZ< zh=>xue(i^`-(51w&!4|!myC?&*c`dd-m^0^K#u`-O!`n_weBN|+LlbJ=YH+=09U|abs^RLU>{a^7 zNu_;y^}a?7^UX4W>~ntkwaYL^RxN0%2@${!LZ&6@kVvMY4$}d%u!RwiVr9GyZRXg7vMPSKvBI-Y{&Kmi0Njp9Y() zzz}h9;%~(xgfA7?j1|AIe!fsRU!1M|de=7NA3xpwRtWbH3q>S{uOQ$(;FkjePH9KZ z!fKrAA?Y%kyn(TCGx7-$)!7H}&to)qhP%12sEF0sV`*t=(4q}&xoRDiZHLm z?$^d(HHUahmpEvBblaFBRkv_G+H176U#pUf`4BcRK-_lejXN@@(d1d4W~i7hIy7Sv z2c`~pj(Xs1E!INUj_-lEJxWM;9rwLO?LZw75zu7t2ag~RG5I*%eIGEjbi8lyJ^n1) zB8sQCTwGi-JZ2u)lWN&L0mkHNEh*bxc`=VumH7E2m}6R~{KZ-?B`Y;`j&1_Lp~bW7 zFhrDYDY>jngPwr_?M_Kb%0Ns^JVQ~|iHhO}#duSy^goAjwGD+yUvUX-EpH<9@lYA+ zT0*EU(ZHa#+YT;B}M*_H5}zVV&)auIkZ+xo0t^Vzc#|M*V6*TTE?J=k3X0)04zE%tYn9PB`PY4?W&{YY-VMpHpmr+qkoEHCMG62Ztkseee_7*>O}qF zD0+8G^nan{m)=0?0sh6adNA8wPM)X@VkChfh92efPg9$CiGHou!wA{kA1Bcg+YLY7 zPM>?2AB1$5U7kixvR-E{yJo=!Y|Ikd0Q=bhXIzS|^?*Ef;TynR__Rc~Co&9(g~<8N z;`^+jcqhX(RU?T%q5gTgo=_mUCbf;-pI>&*zm;OIs@OeU_3PJDUlP{P1v;H(G`g5| zJt-+^vfAsUyVW}AX6hTeMHWMD{({@3$uaJOm_vk#3xVu|(fHBD{3!h7lf1qhFZYlcrxZBBSFR{icL4E?5#b>v_L}PLQ^I3d470CNje`S zIz~3OQ0O=;#0e?utShOX#1i?^zZYf%d$!)Hbq@pHVtb23&`YdG4@JYl!va$Qw$tCQ zBt=*Tf{q+{cmO3#AhcR`3#qsqVnLhh5vor+j3nzPBO^n`v{iX~!4hmNtOMN``~SA> zxJ5VIaa4+So@KoCvu{FXR2)0z+;eyR+L3*TFXu8TOeJs=Cj0~~s@on_VX(ld45*)X za%3l6+ob@^2G}<6bEeNdwZ|@S3uSm1R6w&$=)x3rTUa}yIJtapccNNLE#(o$$&4DGR(>=7u=$ssla%xQSRt?apa7Xrb^V&YD`ngHurpM2wlmLjl|;R`m<+o?%yA)X0=yq zV*Ow^fOP^}Vm61cDR1L|Cr3)gi|QC3^ZzM5v(j#5ZJEVKKw4q|7L6>iATaF&;3k4Khr~su1uVL_$bv#}1}> zW;|4m{T-|JN0Qe6d2>OQN;|v%E|S}XM}EmAE7HqZOf75JzUy@SNRv{P;4rnYbFMP^ z%Pp+b1sF#eccUipCd)^zDeoS7FTqzKf@AzWT)KQo9Q-{@wkKE>4KMX8TqxWqu}`G1 z=o*Wmqmfpg`Yc@h&l6txYul@08%img9wn8ldhDBEP;_jBGOQ$F-)%lM`Q3h)Ro@US z3ryb)M;%}jgg~K5>>`ei+~e6XunC@F^Lz8A-G>0SLQ^22wTOnIV8Y`Eg=AUYiq_*J z%yAQ3EP15y5S+wb=FWfGF;W35(&*4BYAz1Oc_PeozelBMP3VyYIQn^=~iS<-2z z_U|KyC8gBGbu-_e7p9V?cY954S2_e4(A9l)i!hdRY#?G#*Q6xCNiVfTITbPAQKQk! z%sp@2d?$#u?ouqp16{PR_6xgiGYOaSg=_}TvQHWcw5*cHGa5vr{ByV{biB}GNbpsEPzM+qEmbdhRh zV_Tc`W^}Mhy&_V{RJT9chMEp(O-y||L-h$z!G73Yzv1*$N8?nirH5yPR!-x`F67qkvd%3cF*>TIvSfi#l?E#yK73y?lvNvOVf56Z+p%^z#A(-{u(zk&^aL z2Zml^+pciP|71v4<`z*e%h~*{Cilw});Ac0$qJUeq!X9E(sKxCDu;9Cr_Klu3ZldW zXJWWbg2AFx>2^UaG&GAsVMy?qfMeMMt?e(;gT{sW+?Qu({`q4&>IpcWFnnbIh@%(D zU4Qv9yrUkP5k7WCMq`?D=8d>4WadGa@&>g7BiB}cuKw>KBydU3nV6Z~xo?%GhMA7A z;%1eSSdEF|1s5Vu<>gIGV{`MJ>121xt5-ilOJ`z#s(e8U6NoqqlA3c=nb*q34%?ow zD#i+kqEw2HXFQIK)r!o+kgSZp{shzg7q=95z{Juu<$;FAA}d<>xcs0G3?aMC?#KIM zWY=3@M>kw z>JwGvb4hLUS#Anp4ild65R%U6GdM)~KLhXUTIngzBsGpJ&)}sTZxBwvYl5& z6u%?uUJ;BJ<>2Bne7UT+v&^Kk`*xN1>Q%;9uU>%&%M7C=Ik>s$A3S)_+1Y7R$t64T z=!u@7y|8HubbagALj|E9^-E6i#TUHRFoz>>Y}@rm zVq)(-C#HsB$$Zq##?9?;;u!BE#^ZRuZtn;5xjKu?@{H=X=fn zeJNElyjB^z9gBBFGtff4rh7{v&x| zy?m%^1-<~*GtH4BI$J%RLluU`3jAnTcz#{n`B{}k-< z$KrZ}Oq=(SW;-Gjb-YWtw#_P5h+8?uV)b! z*9DH_)zNEV_IHKn55cEfZnl6IgQ>xGi_Ov)%TWo8zL`rBvp9c2)w$6+kc1QhdJ2Qp zqnT!Y6?|-wwrNsTt;zLbQY0tnb{^j^5WSVb_~>NLo%%rwj)~{u22MM1p6wgL&-8A%caQQgJ2pTrcmC#9ULGln3s-R=-nnrQ+?j@#hV&Y9v%vjz0UMFfK?e z4sQzQH5@-bKf{T-_mA>N8BmY!wPT=lyphMa_MY?=(VYsj116C(DGUyYpo!717_ z!Jr=LpZi`$0>F%b>nb%26Zw*Z=7Zr=9yVPzJc1+-d#+!~P;30xN*xIxsv zo)?~VqKiFv;HBcYD`;AQQJ0y3#wuG+ZaEj^(XUyQqVKKvd{Z&>2nWy1w(G~Giu@0K8 zpQSggh$}e7g$3(`#KU`v#0hm$;JxS0IfF@?>x6BG^^-aWf*q;mQ6h#Y9vsI2X>l+( zO(y?f+o@DiMGK`{sg69Z{#JloF3p+ecN3D6>vx<@O`CQoDJW1!d{|flzFo5aEke`@ zQMb>g&^{ECe4-vV6k3*gyUVTxOt{5tq$?`^CA_J?0P|-o?#wE_46`3@-4rnByoSxMyQXn?1UEsE3g1t3H%fDbyx;_JZ9^L=$sz!egv_{Sbj_b`r3m+7; zP7boC+jhNsBp`=l97nTRwgBZ;DXPS?YW@m&5E702Y-9GeZ<^>W~SC0MPK(IEM8XI6aa^MlND9vBXQ(TNRi+^hPv@lYaBkND5uIpO^m%=5l73iCm_ z^==6HbG3IV4Y*xNSBUA!qw-u0c0H?7xlH;Ln(}cM0b$FfL{qbQVse5$GyZwZwV>*+ z@)F|2?zA)l(!CMoj=UpxXm13abH#K5pr+ax=n1jExH}%hRbwu0Q2YuLoj{~k8W0|+XEiY9ASUmLa zCB1yrbLC7iKcse5vb3Woa(S`5F7-1NCyA?muB5o|OCGl*sd=|lnMDO2{lEuzJLAc1 zZIkd_nQY|;rpFx>`Ezc~+dYH7ZMvk=8L6U^n+L4V=BsA=EJ3{07i<)8;QrwK%|bCRCb-04|5d>Ui_hK^=9 z-u8rBBR4nW@2v5Z8l!fE+-(K48C2?DC=^EYZsg490cU}Oj|(D#CNi5FoSvur0*b^% z9nvD_?I`aG_FCHRR`|IHE1O;F7b3kxn}g6iboHJ-eLA_fkj;bb3a!dIL*?|~pb0Fj za_4H{=rg?Jo>8(#PufiY$yOeK}r!amud&=Sx;SgI%PDwk(#iw=e95 zb|0YQ&*S4?4P~hvaU5GJ+Wqf!tF8(=C9n9g8UB1RnG&&46Wdlyhd*zBCrmTiJX3$t zD+AKCt`)H7c-uu(!5yQUq@LDoJ9IRyovg2D+nb>;OY_~NVC}M2{=C~sGi}N8`Va!< z+B)y^UE8d$HC(k!ZwYk{8t=KATfk!c=U3x|c;YScl3zfEwlNS0tau9SFXnUHxiitb z&+xx^86jT_wrev-Ag$2guT^JNBK<^aE^Qdy7Kxl30|X`8a0jts`*Vr~?x-~t2_KmsF` z-K0OgAW8fRdUr)(K*Bl@Di!z~!y;@t7vyNE7CYik0T`r=ktD6&w;2W!E8q9o|NIPU z+LNv@Z6FY7L2{~ZP77B%FbK{5XUoH-Ktb@03-EyXeD&qTbz0oSMyAlf6|gC?Qf=Z0 zs^Dg*)_`b7f}yS=f0Dq%7y8k^Bo~75xL&L4qG3@=mMv_mslR5}DRjeOza$9P@j^he zN0poUR<~o*>nwG~S0-nr)cx^z@#O{!^>5_~j;-J^7aC^kr_|1E!eiVibeDcNwT+4m z2>3|>r>^<@x#NUyuzy{Ci56IYhtT97smh(&><-22FIo5>Vk5RT1KbD^GZod^N_t6i zpI?M?GgE))*}mXAu&dsj`BG_wk%?WIgXn32zO3CW*-vj@zSHAVNtC-kZtPEb5cD=D zptkZR!p(2k^y%-v7a4K*XQwrr=4?DOKi0E};)V+WDpjZc9 zV`sM1H8iG*hAe}iAolZiS^p;J_&?S;bpbi1or;>0_$q62MZb|sc=SyZ>yAP8*Xm~% zuixzne;L}%sA>{w$5x0Q$uPv&p}$BU6zZ{lP9+>g$x(#t#|W|t-Uv#XFs6VocMbkp zN&N*tOgF@ZsC6Y0Jg5^BV=bvASmErcPA%$5#M$yMn9EkdyvO6hNBz0uo>gnmCy8<# zWz^T#&&Hjv*z3s-0RmpK&20O1sIoW&1z9e<*6+~C&kq%T@Ly9I%iB-iQdZV(zUESJ zuVU^)Co7fkK>}r^6st57D)P{_SnKT8vnwH`(NI~RNZq#H zu8)Ku41xiQNC*Pb3eu&bAT8Y>(s2Rl1{Ir7x>35jTU0uvyQHMM>)S^`zn8Vff5usJ zxc52x+51;p5o=%hzC(yvT~DQb@)C*P*xQ*#EiQ;rz<1sKG56}Z&A7mE3>=}+dSc0H zHsEZI6CXue+_w`1i&`2Q{J>|!%5eAT^b_$ZR>A!q~GfgL5P=~yZ z?GU026a<0kJ>FkEmEg#jD<6EDwMrf7QSb~)BeaCJ zdWg$S8?7!4LI=Zj2J__hX~@Jt$h%u%Yg6GHR8&+GGVZ(nW`jj-J@Wr9Ko8#Gw#tbq zdYPmq=|B|;Pe~(m2rnfxgHy^TkZM5(_mKli@bmRsHBT^`uAo{-Go*`_T}W^txNokho`y2Ajc?9m3y0FCqp4Nm`8v{c!e+{HZW6;; zbik~C&*wh^e?=ZoW#rXkLKyz5JXYVfB|lXj4H{krMX(5`&evD?=gG*LXR**c4IXEv zr!VZc&c0mP$aELb`8$)KIoyV@OH!I0`V}qhMuyRBK_Sgej!kYd>jcAx;Oz0{LI3gz zrV)tNBkWzfOeEcng+$eUgZpe|<<|MSE4!~IzZ@iL_74+FUML8q)&Q|R6 zfsET5rw%Du7}||I`P*h(N;4LJafLCn{+E+t*EMSwjz`C~JohyWc>}h=>3Qw95kRmk zvFY_XvSv>VVn$@9vC(kMTV&>@u&4az8M-p&2a7vu+5h&PcPQnty?X2jLQbo6)?atk zk=IFpXsn+3hw9NiQy30vn!Xh%CILa-(XUSq&GPY3F?1Yvue$dDnkwXS7~ry*jX{n- zr}ciSC>t%Qh&QdAI6`8F+fMgp8wIzuRR>-}z*EQ3-;s*0BFn zygOB^b5&X(`gl;Oo~{(#{FfF(dzM+?{AfORTADZ+Z+@p?cmKb)I6c@L;P7-p33|{a zFUx5b3TBCxMj0k=n7+kPmt#y83X2L2eC^B8P)p$?3zhha&h*Q7zBzU3-4pe-nGF7e z6WdsY3j!{AZ8*4`nm-=*f@8HH+uCs5UL-&8)HA)<`ufuW!s(Zy%|@4LDz#fq`%_XP zpDY^MXzM<2mNMX+ZA;YD?t7H~e5finl%Lb3TDe>bdh`C>ZG6+KOIai+jys>`AeD4X ztkihmGJoy)b1XzkxziDD)EXo>o&4Hnzx;fK%4FQ^i|!^Eu$UKFzig1Kbkcw3vL~h7 zkWUjT7e>sg?RY@!co0UVYP6!+Sd}!m(d)LeFqSJaFih_c+kdE#WBonsGUE>Y?xR%P zUz*$eR(Z_{WYI9Cz&&XmPJR5~sE$Tgr>|@%6dBDwe>}br9@H50lWAvcEzxUZj3H3gX+p&x*_rSyblmiC3s2%D#N-se z5}0h^TSC?#b>S?KA!}ckhMD>7=9f2q&so1ee!|Dnc4zB~JMQxq(sC)fNO9~Zzls-; zDtbh=E;twB|Hkqx)7{Y&_A~PkDff^YTgEZMq)hzx=sGkLGP~(k?5Oy8JG|hT?9QyV z&pVWviEN?F8=rtea}8QP<%!~bmz4g^VWoUYP9psV0&Q*@6h=njLTGYRg6#Qc#*PL# z*K1Vt?yvD%73Iqy71O6+Ba~B0$zbpB07pFB* z(TF?^%u#ld#T2bGR+Vku`&vAzm z?~P0mf;RRQJ&j#?<}57yLc{%FLrz(FdhTDeBjuf>1Ib!|QuI~p&zruz=$@5)2XX)* z-O)*(#e=T1n2r9FZuktz>rQC2gpkn=-?b(DVPrBx(+7(|yO;Y1L2Pe* z3z&@0GAP7d*{#?vX_otNr7~{s-8-CMKqqO2utz0GrG`tBg2s<{9U^;fb zZOmP#<7r8^mc3ib%AAd|c%a0V{shO!bglh*dtCY|w2U2lsut~?$HX@#`VseoBs^G^ zGKuKT_m(QPLCRweTgvpIF$tRwo*Z`-t}(}?c~xxDG%3ZOs@7Y zZR7rwg;k1aRs2)2Tf~lyHTpT$4>CMiIi(6c3d#XcTKzh03cb3`-NMW!>5bk&G>b>f z-%a?mj6yc=Jup7wN1iF9b6hwGanNbA67vcRB{Vf7pC&xY_qRIq`pi&fKif$^p7TAV z@}EcnlP>o~tuFJq942bj{rahUz+1q0Bk`EvlwrFdqj!PMLdYu9krV%`=lPB^?Hq$s z>$?b^#j79e`RjY+{hrAA+_T9`U9SZdJ9<);iR(za10QMxY@PMKAtvL;I-H|Qo^I|Z z>dW!&>vyWohWU#!GWg3yDb-#ySet+0#w?s*v=u~K$iTpWsCeE=N=ERdM&tHrZvVS1 zH6Y`Z4#)^8Ntn!GVy@ieLh2Ua9vxNWghnl!_@S>t7}7k0%TTsH6=PD7GCf^Nd@}Mn z0()t0)Vqlbfl$EpwcsA_E!Yaek6(>fFSzWjW6)`Ruqt^k1;+&z#s%5z;qOS49@pkk zR&=VYEyO3e`i#KkPEBoXYvHWsL(PJKe;zT+%vTjUU^Hy=QS}d}Jru#h;R?H2H2i~$ zsvuhox@ybUKr69_$%%Z8>Pc@9yO6s!!4l8Y7^!jQY{uq`=?%bWikED|C#B{j?gyW7 zKbWPWp1{T|0q}zUp|^G?>P*I;CWbP^;Yh&>Z+*3qwGsM%<9!#M_roqfSRhge7Y~o- z)-72k;`gmnf6-I4qY3efjXShGh9fgz47@7ho$}Pnq|BJQcFl@4K zbv6)7Fq~r4ToEg@o%d$J=l~d*wn__h|Gd4FMi|b~;Ggxf9ClHWIf#IWON3PYy(>8& zAYj|+-QTx-S=Zo{|N6F3z1X`8?sree=WB zfhz7S75IiH+GZ25M$CoXcp1t5JjC6v(7!V?Gv~lcDC#sWivH5sl++1WYR&%tGZrJo z_R`Mz{7{Vyw>zBpct~4wUdNN?Y+*lu0ew7_0K|##5sxmZ?TUKW#<#p<+Qiy>=TzYc zJ%KUK?(Qo8O5pDBHPjo`D$}UxRPo4XX znvH5eYRcrHx(+_MB0|Pz;P!lX@UHM>TAK?v84r(aNJzjdbF{`*WXPyAf5|U z!Q)%Al3{HZt0gPsg96PkU)p|dfZkgM!UUYeK2l_YmI-NWRx+emi`T zPu{W+`00JCBa%M(5l2ClizMWlr39n?F6~?F;=Rcb?Ktl-&pY%~7O&S! zR~p8Z8?9ZXZl4%ElzDXkITV+;iGJ@;vRQ_s^;gm>0isW*_Cx!Z)B$*7ETko+vwpdh z#(t(nve$4@vh~CEbJy-`iBdtZVz$e4?bK*lxk{wRH$^Z3sRaHxe>ekv3wP@FQ51X^zd}M2>FE(nv%%BmQLxTq>lqA6o0!&aDLIl4|tGHCK zAP&~H8nPqGO9oV~df76)J>AoxT$(diw)vAkTc{*R4PQ!cG9X2FVeURppQ>SYQ~Iqp zoAjqY4}pexq4Ml}U|=B0$aL$c-jPfp3?$_3_s_G(kg(ylUQNF`a zWonJ_y#A@bUHKi{c@*23-zz%H*)BcKUT{j(a1dZDJYTTNVJa7)NB7;N_UfAKFc?E!CdwdIQ_uEe5fBr3uu5V2`N{{-+ zVR7y3D(WnF`_(S>o1|X38>1^c1o`U?rG*)zpX?n3 z-f%&4_Tqv(+f6|lh+lU<$Z(71tRV1_X{`DdAldp$c((21m|Q^6ul!~^T9pWCRTuyp4JTP)-H_o21xM)7kmf9sw zdIi6B%Vi@lAR14$RGf7tF4()BFZdE3sGw#qRg7pr}Qv?j7*+8*lYr zVJ7%c)A%S0ULT`t`K`PJy5z=lYbK8~+c?eo+moj7t18ttZ6I*k=IW)%t=BBa4G`Yc zRL+uA5!#Y}ZEmTs2_xQBYpN+5Al? z!NgSv1WESzSvgXmuafHD4&wnMobqta=g!o%dyh}otDhE$ujhP{$JX+Ct*QD^l*r>& z_oU6Xz&>MuYNu?P-uk$O+BP|+6Rju&S7^#4U(dqc4xDRTn^?KfEd8}IQ&n|z<98en zJjd|p7SKAN8fP~#QY;+?V=U6guY#mS6j?jD>tu5Bu-vvq`O0p~`}8E?VXCWYyo3F8 zFv=OAFj#oo#`yJOzKM!LI?R(h>8;CIHJGv0{qJVFqn)KRMoe){5}$n z2Nt7QO2Mm8<|-e`zrAW)ysmGkp4??LdJJ?um%RhuC(Gn zO^}jIwQl!9)A$6_NGGrq!eCAfQ+x@i-~MZ-NQjE{6A3qImLDsVogs}3xMR7IbMP4e3$vFNVDII!K`mgsCJ?Dkle$%K3ZNBWgj8&vqYD}}T*^)SsByFtT^ zHR^nfuU8SdRo0GMo#NkkHZ(XGfv^~fLI=i$Ork^6O-=2smM2LII4C5PvwVmyu0Y-W z(N4Sqp$rytgsk^P*!ZFcx+_wHGnj?D!#bgPttPc;EmHn>@@ToFKy;;VQZr`LbPC=1 zT3^go$0bvJcWd7fj_G15_G==;MHSzAI;v=_{Kmfl2r@){LAs|IsIPs^E-T;6QpmJi zSc}SOmymKtBi=fE;Cg)WKT~P!N8nCr?s8CMg%d3P!___Fxrf_WqYu9};+>rvQVC_% zuCz_P?>R?G>yx*+f{m`>!W5=T`U%@xovIqLMN90woX*OfV(~n^2N6Bat661(7aerU zp;a5_Sgz} z7q=*S{!Oix7z+va7xm$25Ei}SP0O$RU4?4mV1PkS-MC=IIiBNzv<L2#!Hg z)me}4*qaKv3Y4#30Ef|lP(MAXKZ0<#waWQxQ`eqb%%gt!!7kZK)dQ0y)Dy1H zG@NR3KVz>uV550rk%gxg#uGdCZn(68!K%|~=bfA1BMgofK z&J9o$e1tY{A*8D~`FtHDB)#EHjL(o-cnrdoa>DE_vtZ?**n;9ltR;9b8V=5e?Wpsl zH1*lC=Sifq_*K%Hq=_W%hx8gwyAbz=Kjn_gF#Pd5>-qPCY~xiD%)3Ge-qyy&<7Y!F z0x`_po#Dj`5O0|OiNgk^>QgrT&g!j?SJAK4l;{6BE>Cv!50IPBff3sX603fk?hD{3 zen#db^`_vVzFo?>(Jm|_qly3AE^LyF=hqD>V3<8si@6w2^AND`6>BYVes70s56hL4 zvl2{XBp(e8vx0{1EspZRyTu+O(p%DMpX5JA{`{!_`|bCr;$UZ|hDKV%@sYN6^wT~l zW1cTxih=9vzR0d?06H3B)&8L(Y;8Gy{Hl?p$Wq^EqmSBTDO~ucHE%FbX$)KI7k3bc z!P%;pc^eGt7ZbOhCdDfcm)pL~7AC1;49(X}5p79{sIqv{ukhhB{=8H(x0h{pHsx11 z2KHSx_;p^or&#X?e^y%oQ&aqXthM$FUeR51vfP>M+o>BnGyT)uI|dzAsfPEg^EIbF zD_r@rE1)WVcW-Y}mtrquWv#Qb_yQ{knMg;#$bi7h#Ekf8ge52BAsX6#dh@S6XX%Eq zZfiqbTSb`S_vdU)<8LzG<&%DC3YXD9Z$RFEURR#sqTvxBOFgdO+dj)kf!l7-U4%~r z%jL{GR-x{~?!rNPRtg7wH_lXY4`EkWV*i?-ZY)2qD5mJ+rAxG}Tma#d# zJx#5Ld;Gz9R8szBDLvi;TaA>SiHG5+yL0mmeoT%>o8oWtL)@9P6+^DM^AD$y#a2JZ z-1Jb+@s<*whIMyc5MxR3PBF2X9$Sr&?7yZpv$Zzn_R{VvB^9H|+VQV=pU0o=$@Y%YJKbO=`+Qx?&RV?>QS?TImJpELfTK%ypJ98bFl4tCKGAhmqLZa-F1lmCAH z9Dix;yN>fT0)lFMQ;#Gvq2*j+!xM$#_?+Pr?uc4wq`_@$XFg;|hfNXFRcW4=L6vfH zEaKm2w5K0m186v>0B_{CE9YA>~^gUq(O4(L+#h0P0(_x&6y1cJy;&qKAt^CK!dAS@8ZD;fnD|9TR zGMt#tM0qf{NMPMzOry8D*WsW%)W(W*aLm1A24vQ9AoJ|cC=A&89ZH2p>7Z|5(2(hV zU>X`8?ho06<2jJiGoI@Sn6kDE0UF^%ukdjTf#&gcdX^8e;>7uA>1(L$D-*=cRps+0 zFaV_bn8QY=$R|Q}F%z8>t;I3>vqULF=hxMSpJ|`eHN$Z?ydxSu6JOzZ(L57%H#DrR z@^o4=UIsiR%o?vYcR@vyyhLU-unI7SUbSEZ4l7)QzlaChtg^B%+u&w`0(Et}SSD4|TJ`AV|g?tt=VNpCi z8G3fh{Din>y8dz<@fJF2fsqXKPutF$G30`7nBiVcV&rQz*jau>=Lx2-ZdlK2M^ILk zK`!apF1g)C3T4pqx0l|-jX9A{8th1u z6-<1o+3rO6wk$Dro)XMB{JST8Tva?$k&^HhoHDiLnSyY(+$N$z2^n7|p8;#W+TOMo z=}mNJ&HjzYFt;&3P`z84k%9|TY^s0`1dNu$d*2O#@Sq2SPN`X9x)rTZo~~chA_v8> z?tS@`j(r(+>H_&~)a8xtdiRsxAE%)zYWLHSy!Oebq|wqSCD6`uJ42I)K3mpm=$(dd z+MTYPL|syL0uo8j%UE|61 zSeE6&+?2LG8`k=A;p*{kHJS+U9LU#*4>*A42P4ty{#t7zVpgMPVG*PleDCcYh(w1> z*S56Gw*Fm4g~JS=dYtWJNj}fm6VT|u05Nso?viEme-LA{8fi@h`IbmMIuf?MP8D0v$LS&BEsVK zB-T85%W=z2tnuU{WY(XGYZ&<*BKHI;_Q#6mn2jV!0X>)Sed5NQcL&0cCK6*C*@nFiy z%8tz?pB#GhIL)OlMm(<{QHkmGQkVX8j*u(^GbX>_rK;$p(+RHLKoH7#Jy4qTly)$d zmrW?>G67IuwBIZzpSuw{roF4COFdfA3Z+>&1oYQ*78sCP4=+3CHPc!QKPpMu z6GEII21Lj0&toKr63JpF-E$QYX^D&jO}T7!b@c=of-j1EJ|485(jB4@&Hnfid`e^eedHF6mC(` z_ppi7P{M6n2U2ji{_&WCo6E9mcIC>76B3}HE{jjODeQc(o+b=}8ueh0$GL@{8*Q34 z+s)3<04*&S5tT$1dxb}_gB-oJzQrxnTC2cBB{-2l_SE8&g7jpm{F1K)Nt+6`tC*2M zhdfU{`A8~>a{#GHNtxYmg&jpB6|RDjCx^7E5I(Agx6-bu5(@W=%Ip+BJ9PZs)*|SM z;fV|L87KyfYC$|(x7u|5499?YTK`<4;Z@*0d*JomyNc>~9j%Z(JR6~)#8dV}Q93My zC?pJ(8{7dJQm_~F-(s|0Z~l7nAlqsWu{S{t$GTgdkxs zN&=ATfF0e$pKlITWIc8FCx|Iv4^ddb+{kFcN34lA+ePxV6jw`bT;IO`M#bJ4UU7YKeB`K2M<%^dzn%#>G&<~)T8|QK!aZ|c<+3Yzne>) z?%IC~u06l#6pQ%(43vXZ;w$WXXErwbco1SjnYDFgwk*p*bYSC|mA)p36CHy4rw+G9 zi(MB>JeJumjf5w0R>;%hJEvO73Fip>(eW~AKu!sQ4v8o|)|(g*^GKyjJ9;Q50-O^R5b&PAZsd9#D&*sqBTBWhy?w9Nqa8+y~muu1~zaJ4B+DC4(BW z{bx-6f-lS|s|gz!KF5QbXI5=a^-Z}c?&qXnvrJ}i@a*DSy9oq zVz!j!C0VkmArF&3Z^A!GG$op+#$y?piAp5a2FYj82=HkIRYq5;@}7k&e@?5Z zsRh|MmkzOf{ra{2#}7&*Tzv$rG&Qa%qfxLE!Tku55`Gr^U9W;(OX0&+KN#V-OjAp6 zmQXt~oE9t;*{!_M%VR-W#h>|GQ`gYTCgJ<+sGWnFWg%6YiDGW?!`2o=dFn^NN@`{V zDduKm60t3H>=omfKUI-cV`P7^O<&x%pieS79K@({9qAUmsZG-5zv9YHKAUYuz$b_< zT`JuWwkP@_&r;Sp*%;hNW|9yLSK>5rX7M#**3AH!ItPhIX(;^yaJ2FfXoO(>ySn)f>}-sdkZ zfM?>;yZ7$`tWpn)MP5oPQnG5~j#Ro@N{Y}f^aqx*@dXB+R8bt9vGZsObuF6O3`txR z-SU;wQ&SCyvivu#bs_Ug%UANtQqd zdmLFVL_I9`VHE_bHx=+P()+>6EbD;SLecEr&J`A^4+_4E(bCvv$TWi(RRSR;Ly373r=gC z6XDqGfKEGtYJ;o1HwlzW1;MizCZ7!?WP^-w)Bj^F&e9s=O9^dia=N5-2~8Vd(pcJo z9M#9HFh{}tju-V;(p5odh41X>=(vhVTeRGE^brB(HxvC@=97;hrd9^*ePZQNylCaO zsm1oi0QCjK4KO+83m0Cew4gt)8-B$CbMm<{IsNuKBqn}OVv+CC_@Mz*6jST!>X4Ta zPngc-@Uw?@;YKq6$?nEDRL}V;qLekl+KMR;M55!J}IoD_->Uw ztC~wr!I_CC#~g>vowtvwBlm0v;Wxl6Rzwlr`E#r{q7!xkp|Bn_iVN|5TA>o3`ZNOQ zgbnqgaZG(XrunSdx>003IvkRS`m8V^B!aZ)qvK~R! zHk+WJ+hHj<_Y5LjZm_VlY@bC#=8}^~v83x-T%GRc?09OSG98U>;?=R-IH_CJphcw+uKx|T0hsaEd^5P)?PUJaKW{aeLeIP{iS;b z3r_EZ3dv7^6ic3esMIwb==)_N%x;lwy+T7OFBMc?^Dw)nXA8cQ z7{%J8#iu!q_*Cm%PO3?d2vt}S7FIIDpB(^*_Dym|W9YI}OtvO&sI7)2eOO=+Ol z?DByzA<%FAzET<969AYhC^a{^c(fC}3(n14ArGF9))&>*-ylBa=fk z5ip?vrlh=Ik6=o3^e4~D|9C4D){8}R;vXixsKpR7(Z~xhxGpX{@}>hpO}q*c?%-0P zBf}<;NYG;^zhE2Gxt=m4t5 zIYVCaMZ%V{vDDKg%-?U^ow_%`wL=sJbrurLs$r0?wj)V`M!5g197*eS+juVeH-6-K ztJl|S?n&lsWcKPF`JkW5NrbhtQ;4roE+}*!l(Z56KsDNU;m&`tom*qS&da8eU~pBs zwyd)k?DMsVj}vBMzi6vPH0r7mD5rWL&WxBLvErRl32)|pw5R}4r4>J8sR2X(f{}Z2 z{Z-{weiZWOq)35OEh?(ky5q`7+RGk42D*DQWR=( z3x42dOk2l#h$Nj%`Z=lNw4}p@5EG!4IbGd10gVTt7MR;kt-qYay}5))K~Y*rW|XS zE?m7t1a>3-V?jL{8oECSlLiVcw)%724(7BQ4Tbhpjm^yXDZ0lg>5d;W735(%(Ju_+ z3QT`&msf{TE%j>9s=m#xh`K^}^U$HJ4=3VR(q?cZqZQ4M^cFGyq&mycsHfay!tf3L zjIS}jHD@=VC0;r#r=j|!>-6RnsrZ@sNOq7d3z1u}g;Ah%<^2K)88g*2Zwv(MlYY5w zZ%lE8Yf;-!lN{n%{+nCfcqYI;dnB~z^4C5zD)r2@;qfJYaMI@(chEZ4@(o|Z$H&j) zrY_zU5E9Zx+zdMo34flyiiblJV|7NTf@v?@N#CK}+-1RHF;M1UOy4-iJ1Y$B5`}1` zfJ?W{;GEJWF&n-6k8T^JH+Q|}R?zM9bgeP9Mkkhd8Dm3L{Z&swmYC7uO!q{Bn2SxE z@nZ|OO0^qEaU_+Y@E;*JzZr%Nc0Z8TFbFw-*TGpif2FikAso=kl>Gm2Fae#`r*|w> zu7diD1+*l};%_ z+RGK49JDf{OujFm6CDW3`l(UJs&4@CxLCBFxz!k&l+}Pwr99p`nKa?H*QnCjcTQ$GovK=a_5k%=Vn2n!EKqDQ>;Vb>g| zU5qA6(j_u7W(wFljs(H`1zZ&T^+zS_;eHv`dt@F=CV9#5SyZLKUP8_YJ*kogBc9?o9g-t|b7JGIcw+qd;J5^&uWGDf@AEdn8VR*3_xO85EH zLr+LwDPF4Bn|Lj>{~3Z)v^kS5k(0ChPO=B&F%WVsC|VJjJp62jgH+FDVMe!|i`TeB zZIf&3d@n}CHc%kQRsON@;hT@)%0#EToFsj`{Xj6&k1)S3xqcW={E+|!@1NP|E{p`Ly_-nSC32Ma5L8k6Rd{_#3py} zI8jjUH-N9SqIA#mcAtpGmCDNE+Hq@ibPkP`QfmB!@#?Sl1)UaVKbiD|8xrfueTmo| zwl@5TwJ!x*wn40C3MpMp0f3cfHq(bZ@O)h#6eGD10`@JQfx>0Gv^%gx?%LLpAj?@- zw?!)dP1T*6j@pSM6SYhEO(vJBr{-|xuT=%a(TU4>>3=DNF?*%%FEFwk;^8j&RAX^*Kw95N?I*!{SmKedWPNVT^NH6c$j9hW8b(p5- zi>i<}&%X6csP#3C6%a-P+j%u$t~GEf`;WaO>ydNo?C(RWq?ASq^HYW3R%jmi>G0%G z)g52Ml>FuwElE9}j<(v3cb0vQ}c|eMDF{RD^R`Un&(Fs6m z>G4k)4JC%NFaPSBa}|3C{tq<9C9I8$8_ue#q5F&WmHxq6PGT9wQ&+TQj(r0~X`-p& z6QLzOSecPv)k~8d%~ZJY6ZrSbp9O%YBv}m$#JXF$h%0~Lx_}nNFK*-tKHTAU%g&bg z&3J&VzKk>R(WB5v24K1RZ^4|!#O*?y)G1g4n&t*>o@zOM+Z3t8@lahho#>~dIJ zz>AN&gT-y%v9jP8+@O!$L)tZRCDZo779SDim;hiF6c3x(8CPku50A|W;qUnTtl!Gic zGh6-n&_{?ZZ~mNXUM|zsxdle0hX_iN@tb^v-cd;}zR1?xqwxCo`(nl-?a#x6{(SU< zU!G*w&32{gccm!GX=$0eBu97YBSK4ldbxcSQPJ0fu3JN^BM>J4(~{fkag>$LBbjm) zw^0m=n>G4+Arzj+XK-6>t}4mJR5`zix5afh|MF}QHcY~=R{0BC@Nup)p;V}Tebnu}>oVu6>zv)OML>BBSF&WMQjpzCevH6&Zj5wlJ+sbgxy^{&k-Os^9U z$}2L86>AL*4s)7_R9D7C%_-LY2yq$t-s8UzuO#O6)(?EuB{m}|JgaN&yf-My?KbpD z9~oXfOYM@8%Rnc^bnetsa-}L`;fcNqo#2t$KhInw45kxESku16hCMViEiDfHdaEJG zmY1(r4(77ozI`3h+sCD)Ng{rr(8$R0Bt;9sqOF3$@@AuvJ$SJsRE}}5Q(s`1*FIR2 z4gG;>tdUlBm3JpCJGxGS7at48yerrAUWQ@(g*v$_xqgb2m*d zk%qTh_yWUlmy~#oBVVg9NYA(yvCW}+K4DUCXlyqdrs%u$@0Y6@i^S}AY>GSfbQ7&E zGAg}+mw4Sv7+y1zosRmTwLKnIGbv7I?IIS|p?s`UZYG))rUO~LV|PG-RQvaKzVnb{ zUP?x$5t7gZsOtr9-n8r!5zwD*iToX`3(>ePyvKd{;nM0?*i(RVHE+6m}uMhSZ2Z9)Kzx9F_m@?{_q<7+ggbb0R&8c2lej=%YgSI|kY%$}vmo~1L9h5epe&EzyoI04gk z^@@)hb(WzB+44d5T=zp4oL6dGkjA*{dGM1wQTdex&it1i+Ie=Xq<9%VS|JWC+>Y}| z-Ob~tuE*it@{#5x%dIRHg?$Pm&keqe+P@~9uuN^XiP+^z&C+smX=02r6*>xI2$re) zv>#uf=_Eos8Ox_6p`j3W)wG9oB{PK4nC?sR*jwWrBzY<9X;EH~0*(UKS&cJf-yS@OAXrcSP+J4p zTOXnqS13n7ui)a|dIm*^8XmD=VZWkz?<1}XORIPgSVtko!EA;j%CJ)fGkUn~jAKSc zheK1+r-hbPe$bZ_yIUv4_uwSWnZ=%IAMdOvPXDfo=wB0cU(qdylrHs`*_=7e%3;?S z+a<-~t$6plm1%>1CZn`W0644qa27cFMKnr;h}!q6qt7;AXQ~-HkrG*|-q}cE&bAGrku`PALgplUc*}yk%M&w%3cG z^^x#?!>>F-Gqchr@=*GvAj^JPkLGWI8dTIDZ$gPS|ru^lQyj7>4NTaa{B(`?T5@&;h$msE;-+j;6YJ_J4^At@f|}IaGxEDUfLBU!LOJqyeC^ zi(c)l^3}K!MAPrGlebxb9px}5(;I7t>vXNhymer?L77A9O+?X1XQe4oB*l)pCJ4{9%-wmw#vywI&&K|(H) zRc3F~Zj)x>T|QpI@#L-L!G7YHj?U_qdc$=-9%;9V%x;@KPI+^wk1BYXhB)LF{g0?H zF37L`q*+KowBlT^9N5{8-zUnV?eFAKc&)>!Zf>jfbmbK;=zm5pG|NQVfj2IDedGN< zzLhn3UM^mHWg9F&sg7kX&VD}rv&FZW1%kpT(^A#CQYRrc;%If~aG_UmmKt)xhs>>?K_vo772w#5(ek=2Q3 z<$wCap=?m)WzgwBAn{yn9QKjbIJwbOKws{~H#F>>iZ~E(OFQ~$MbE>4chtK9F@7%_DinnRTRlbOGpTxSM5VssJ+5p z34Get35DhHX*^hTISDP2tMd4Bu?K}|Lr=7z$?b^Hx4u3BG8HD}ao-;Bk>&Qq30Q!F z%0vUlh%zs!`?mW{HsfHphXPv#-0rljpJm?O1ZnZkVbldSeq%1OQjn+MP>fkX_Qpdw zuZpqd$pmwfa5nAAWp@Ug9wTe=<%%C*%{m;BNSt(bmag-36)B5%cFA1Gj^*Og@ zT-{L0ygvp*UL~Ts6SH2*rvpNJtQPN|dS(DPEA_+0cLW;wa^mg5#D_}wiCblM{!dq5 zejgF-_nSi7rY1TM4%? z36m_ZE#2JX?wUv*GQZ=vrF3ZQ9N#KrvB{Om!^J}@Z^G!;VYfx^&* z*5gMPqqp4|c7`9p!RP4~ULf&CMvH-4TB_H^JOh_|lz4MFOXnJ_CIys(8euYB;V^QM zA{p@>sZG?Y+IAE_U7M)iFNG3!p5^oQmaLDFHe+V=%wwCh~dN-9z_%mj30tUAcrUzRYFjkXc*Alpz{ssMwK!>sTxw1O=PS%e~| z_5S>>kKgjV%+9vnL;VIHa&vR1Gm-Q!7pL`my0LDC$HOn-jZW!Eily|A&|b25yTccs zgF3aq9FCV8=la9Z(ikwlyjnT~pdB0{j?8 z;keeTwM#E)iX0OxLa8I znJStv!xw_|B<`A&<(Wv|u>>uCf`P$ML8QaF9&TxhcMmf=crAB=O_d!dCa_HeT%nA| z-rDi44c9Db?jO8e*n0BvK++vyFCzoP>g3Pko2C%LK2AH1nFYfIp4JrHlg^^?czVYg70$G-7nj1Z%IGd= zVm9JlSu6?EUn>`;n|rHR@N*C4AiesHNk=?&OB^}xcO_L(Ide9AV8cN5mVUq;i^|7u ztkfzL0bTPYSE1RJy()?PoXl*)FNKPyIv{jYb3G^922t$Te)=-A!En(nFI}d9SpC4x zHZ^Ofb+b#{HPi6}N6qph0PHmjA%Jp#)AJ6huwv#GGm9GA zh4pl&47ssa_S&*6+O7vm)Oxv>O$H7i?aFI(1W~px)~O~ha1xLi(0y+ZGEdc59;d&E zh&qaHxL)W6mJKK)CzP}$E0GP#PWZ8mG3jN02ydz~s#X7wXrg4TEtvRfw>-h5dJl1Z zqQxL3knGOvsy1V z>uB#aB2k%IKcXAKR;683EPj|_QmjJN>pE$gf|UW>2;Y=ZYV&sZUaWuQ!RqK?2Xx*j zA7CwhN|{=9OhomVb3UIAcCOs+#&0a+{flg&6{j=Pq9f{wP*zC;8I$sg#3(0?wm+He?-$kOEizI9-^2 zO?FmyEs!X|HRaZ(JOjJvn#w_p?it1%K7F<&!q6(PtY?g2UorcdpeyKZ9k@UH$rL|m z?NDxjWuyG7RjsY*b;gyzu^7i$!K1ky|8{mZdOTa<2T^6Z@}b{Uh>xzE*#h{PV|b1` z7Ci>^0D8{G1={I{K%E4SM5E{%0tUK?-m^jlXzZ~ly=NC`9t<;$$W1#btrCq~rU4w) zFO;f^@$hDbJt6rQEIFWNw-ov#JT z5kR*a(_wk6?nfP|%X2`VmDy6KGktCfr1VKdcV1KYH3efD6m1{=q9dASByzo~1AAarMJtlV{I`Cf}#H6Vm{s@a~m5k>D$1b}XLtSd|LKq+#g-(=0$3 z5?aL1xqzf4qX!L-R_J>U`j*~9p`8?4zsQNQP}6Ij2m9j%xONFF?Y4}olC}KK3A)+# z1QhL9w*sNok3YR|j-1wFBv0e;;8lLj+Ot$d=Mdhi&bw!2mBbSS~Wz|tz&?!(h8>u8IvE(yM%_*r zL=P;>rsjHrC_dvWUXMD9Nse~Hx^k!*T~P+%@4<%*#HjB;(CaFBL-5MCif=lF|A5RZ z>X6ub_flLfvK7!ap^+iXQh5%<_S<)zOII9VTsD#t9({DGBWg!o6PiE*smx`p1;M*lK!NXuR`D7{h``7GB^iiuU8IMW#$f+xG7J@ ziKU5+)_3h(+wQHQ1v!QsUqW>lLj~9wf{~8Vy=+AsYSL!R;`oqqfP`#+b@hWH6@W2} z(F|=&M9vm0^PhjHVALX*x>UqiEO}FgBgu7aN(#o}!{PnA?@nv6^s)HD8nOkHJElv@`@MZo|QkTyX{C8ZSvgHpOfq)QpP6$B*>ItEFR?q(>-p&N!$ zItGw#zCDQEZ+>{!U5f?pd*+;dc02(Y6in6&9=VzJS~h0+cvG&iII2I_?)AqimByWr zptdU8FGv-hFVT(!T#>^|@${-^-&vJ7*_$<~|wUAR3 zwX(&$gfb<8{@8cwaFEMfD9us>40;JynU(?^_|4nD0SwBw6|esiurihH94lZ>4VpUF znUWEJ)<8L;NpDM72|S)XMY6Uvld3un0v$9}M`oZ6BWNUjEHcsYvl}lGB{#uYO z9l5E>p0I$F*{zl@=4FQAB}u~X>@;}jaN!1pNd2L*5-nIDb(}UG5v?no>vio8JTs;V z2A685ZiBEvy;C}7tbI)z)b%BXP=QZj=w_(BU>!CtUFUQ5PfY@F!$p1?CK-aJ^d|8h==D;7 zrkhj8nYX~AQ13rclcNKZgJ1q|l$M4V8OInwJPZJ$H-KjZ4N{+T!=>qiOm=jpuapXs zgLEn1Fhs&AQ@1-Xj?J+F^cI1Xi}PH7=I2;co+7lUk~ma&$VA@tlA_dkQ-Z?R8z~>Phe2$jf}f)2`Ry_dL3-VNMSE&i~#d+E@0%;gu71?ni!9YS8?r zlO0xZ!bA)y!8Ej^fvbh_x5Pm^ndd-d82SZsw^Z%LFC47`O4wa*g-v5Ea}B7J97mD@ zQAn}JkG(#82BasXezns$%?F{eUdP5MTdu`QB9mRz2q4#a9?%{C2n7sV6Xe|%lM zA>qHEngSn?e#NDVGJr%ba_-cg-gm?%9p}8v+y!L8>zAYX?(g15oP~rHNCQdOcqT@W z6MM5?Y$l4tmGZoU542iZID5q;Y6F;-RsoCs0A-8TgI}1t6!XME1vsgW8#D6!E%@JI zqO2VB=?3%~BK-_!XgSj~k<+C;6u3r#Ls8Yr>H^f5z@tB0;{7{7lmK5^&b4jgGiNRb z$0sCE&{Jc;uJp$b+sTJ1p!M?bzjwe*<_fo1g1ehQ50BEpC=_mQV?-nu31I_X1 z?`8|ZFggCAvT^y&rOwqehUu(Q;xARpfshjS6aYLc&=po^Px_9~a(oJ{J7ovwqz4zj z%E-KkyvQ%VU=6ajy}<2^3=3mJJ$e+iUE$?x`oZw}`PQ=uln1mmvK&mMT99Vk)Y%A8B*4i3ZT7}P|7=h#ACXx2xHGc(g(dY% zAkTN)N%Xnm#wtgm7v{&)Ism#1<@o>()LmmsRU~6*xt8InSOkjsAp-BPf`eCy0|(rO z0Rj#rFcA9XxZY-pMoUY6^q*I{es*V<*lsbBZ+zHXi50}l&5B(%@?mmaXb)L+BXC@h zLbEC&zhyv$5dCIC1ADoPr4R--jQ@tAczB13Mex*nNj8?ksLhqTnJr-ivY;U~u9>cS zJ&17F=|=*wFzbP?ce@_@QEEc7TmiQP2rT$(i%&rz6hwGMij8n`Zwbb(U6Y=G>iBUZ zc{a#HKx>F-e8SYKr85^DK_-j>^cP#dyHy%9`qTSY!x2jVQV_i8e?`ZYYoNxovZ zGujcRJdlyFtCJx(EaI1`z0e|f# zBcnL5c5Z_F{)UWDGWriCB<|4y^`D<2!~-ga3eY&!D7K|BjPY!I@;mQ1Z%e`898~2x zak7%7Vu|AKh|W90`uos{MlPkigpL2^kpOohX%Zau2*1$RjrFIYMS#1;BPmw^mGh<) z(r<;U17^mV@_XCk9XN$@0p)UNN#CfpO&IJ7>~5J=GdO$LVn0_RcYguETA__iO-~Nl zAb}Zo){A}fL zUZuZq!lE=^Lt_*M3KMQ?qbecb5QK601nS+eGZiGH4toFU`dG3K6p+9u7RcIx8D?LP z?feLZ{)L$9y0X!Brw`Fd@OMW}{>@>}W%=c-k`vuc>jn0Ud7l!)UL8{g_pqhg$V<{1 z319EeK)N=UBslUk*D9@{jerkxq9$%Au8nBOw1)#N9h7jf*G(Vxkv{K4C~u3qqb7iQ zKvdD%hqvPGDboKAH>w=T@aKKqH(xA6&De*+?TJi;&PhY6$ zlO=^wpl5H9g(%0Oo!2ajr$c5XC~yu6hac%{hZ+K|AKC8--qdv2N`wnovNoai5t=?t zlm7Xq^S{#NE~8U)(}9akVKVWP7@w5H<1#YG7}ul%f>%9}>N!gq18O-G3e4!IK|7uJ;7RfKLGY9a|EAo8w>u7M zq9nkZ>+*6zd&OobL*ui~uF#?uX|L=W_o}Tf%OXuSn8AUL6bXF4f8tc9kH{LQb++*C z{n#gj#T=2=0=5b`<#30%V@(1zA1(}x_pwu(8J_+-=)oC2{OwT)d%)-$r>MhY-2ODq z{oMx~km0t(X&;XuoJzq9i`JdJ2^yfSF9VU&E_d))|LkbYwRqQ{t4ywp4}$fj!wK|8 zl#|9YfOCQit{;Ss@iVaTtEDk^24UvmOps$joS|Ok5FChgyx|sgG zIyr9e9IS2<>Hq`tEQkh2MQxQr4AB~(CTduItfDJJ5gBM=Lg|_;SB|ht5S)@9=3`>s zjZKlGHJYa-$==`u0$CLd2&(7g^%T{MU$?u*%PjnaYA;s@SJt)uWhuj67yq}{FTk92 z>@04$So)n!(=3VU;r3(|lXh{Q=CgJOCA-SO^AdzX|lA`eT^`6gVwiQE=la@CK)^*}hMeLn40J)3EwJqQ>A*dj$!h-eN*Xpe<+s*RT) z7!*ej@ZVUs9BdaxL7|MJ+Xpf~6~B`BS11Dyuk5Rk{oxf)c)?SpDSZ5t%;>>j86Ye8 zF?EZta3V>QGsO`Hxl#WK`Rl|-Rn=QQuGs^j77*CDKthul^tcZ|dg|XI^Ob!io9gxw zX!=l0m}Ep14^iHEY|=>PS#y=BsH-^Q?{YFb^id9_uf0`j(mE#Il+7xPJylZDLU|tM zt|QL7ySq#8SREe#b^hgx7nKD}TwL87RL|9sK|wV}1bDV*hz=)8g!a@TI_;c}X7oPn zP{Y7LY4rjbN$+Gqzf1t|-?Y5#Y|rndcgGnT0H#{$+6Lie@7TAjde)JzX{OvJfslFG zREIZy+TH4>z|2DeKJ;n}IRbI5#YniEH>qj4a7(J=ejUX{w)0KO8=Kbale(XJ>l$JwWw$v;PFqMfM|8F z|0XQgKLQ#BGOAZ)9i<{KNbM3cF7#IY0+Xx4&aC|28YZS8sDV4~-sG68K(~+T#3fx3 z;Y)CFY*-QKdl98?U9{-$4zAfEEv~TO8R;Gy&Sxnmx%1Z)^K( z?q>O}QSk~U$B2gk{Zy|@=SiAM5OWZrlWsS1ODgpBJ*5tfPOS^QXy6(YBtC{KEW}2{ z4mI6iTa@SYfHB4V;M62w_^UxBGQxA}u<|MJ0e3GpeHl>&`H$psvmjsT0m@Ax zTyQZ!ATEefCd>uEKkxUDH{U8i>ia8 zJz{Dq7`|foc1oa7igfDM?$40dj#ocBAN}?YK+$t`th;j236&$K1h*MiO9ll}&hiD~ zE=F@4krTS|OS2*XrF#CeSp6Gjd?6_)d?-rCteJ3bI{3Cl(^7vn;&79l8HW0o92IjxqJKQYLkjmkr+;Noa6c@d7`Mk=Ru5M z&wC|1tmiwCvaJZs)?!$CU|&c(&`)#IF;_ zX!vJ9TVZW0V(i|B+=okwuF`|gkdVkgd4*jSx!7URdZQDnY-S*rkns!sJC@}gf7>Eg zZZ$PE)&C3D|_yUrXR9kBx?mm<8-AXEwy_LosMbtY92fM_3%erh5qGCUoGS0 zadrnJGnBDM)%Ao^0z%xmal({7RX>4$Y-m)p3S_&Ra3z<6xCkJ9z|yF7fU)XgM~cf? z!<=c%>LrS`5!N(iB-BSv+k^94#F;IqC4tAFPyrEAx+sH-Rh{j^iy(gK|CagUf6Gj5 z)Wuy}4W*4&%827doB=sG9}`z@y_2If8(k7Z3!{$I3Y2Vtm8# zQ7(5{Ge8)5VAkyv`$Z#M_7)FLsI}><`q{mBF#81hTCNTp2&j!$b`~IZRSPD&NJ9{! z%6ypN{kJOuwXJul@}H+6BOLgN9y|RUPPbSxbQb6GY(~awfR3X>xdu4wAQvficTK ze_8*)9U$eV@Bt2w);+=Z9r=q7gdJR3rJbG3`6;(SLiDY=nud#e%;}f-z2y;8k6Yi5!Q3Vvw7oovOZD!!f@0i$F-vuF% z2ED;3?$R!chZpqL~*X&nYS+8ZB7P_ zTjWU(EzT^%$L=<2h8IxJHH>C{H>e4VibSEb)34lo0If?nQ(9Ne66?6BW5b-+xhz4n z1oDoc7tOYZ84>)={eN`12Rgt_gbt)(?HFC{6Kk0W_b}t&$q*cwILL`;P$Ts000tt5 z5+DruKqK(6T%7ZIB}xn_KJYzL8fWPEX{vkt$b1gd^?HNtF2i}+z>{A*#*%}^A9Ga5 z{W}o&c>m%a1sH?1^YMPCzGwuI4@|OjlTW8|l<~^3%Cc`AoA~MSMgVfz^Y8IW9vs(8 zl0b^fZzLcLB81+DQ*dq9e#_CZ-KiQ@*F@%zZ5O05^)UYv{D3lvxqVc;Jf`KuaA)U@ zT7TN$ygV-47e6&+08aCP;BeVjVwVl3=LJ?+KOdjEp;Cu&@bhKk=V!{y%#@Lny8*Vp zUk23H=kW#Xmf~;>cV0d|U2AIvfR*X4&U9s2%_@BGd3i|r^F|~>R3&SGNfGoD(a}K~ z&~V_P)&bdDoN*6jPoS-pnUV_bl6b;&J|c=}2-nXCCz_DFxzg7HEjPuxv^w%qM7SZKdj;NpN$R2`-K~RZKPdshhBG228a~&H@CUJZ>?**UWkSM665@{_ z&l`UTNDkITYZ_t5thOV~45ki4#5t9$tgHjoVL$DK`FSpuY?aiS%-?W0D88w!UEJSk z*=OqO>stap=^n!7=}LRAK{M`3Cou5%Xj3|?E_QwBMWXI^y<*M1rQl$q+1oRc4fBJ= zzPjJ9L~c1n%ZZHOm|tLQx*g%MdI`ESnmfP9bg})pVyFKM#9fm;=o8{m`gI&yF>i^Y z=kju^VZ7Vs2VmMd^RrQaWBdxku4j#cpPj5xd#P~wGtgEYP-*Bvr28r|I7l#!R$ zb?*f$2hF<^I8$WB(iwR+-lB|Sw9f0r!}T~XUvO$CQ%8aY2qm`}N07r$a(uaG(z&Bf zJEOFktrm22bUqnFxYze)@dv>w5=Mo(FivBQwuBy#;Q)i{$j+V~R)as6!WBzu!&!DB zPE)43kI%>;M49&$G+GWI^m!#kt}Xh31;9CZr?+GcO`jGcp(!j;ThePg?~_|mexPmd zF$T6mW7+=HAN}{gtITgLKiOO~*Z2q&xwXfyq@7q?^2{GXYeAq5i$2aDeT(^dLzYHi z6uL36T48keKijl(w+QDpqai)sT=W!TlIH*I4mf5XXH2PJb)w>*!-=`LBEj6U5rpwY3J-;VlKA zBUl}pA;UtMVLLR^y;i%&;~h)|_e>_e)NVg6-N1huEc3Hgb52OdU35e>7iSB3y5j;N zTRA-t7sJgQaJZ~3J5Z}pL8dPREMR%A(r$DiEY>d)jQ@=FZP%g<+H~pe%~414_c4H& z^8n#$p)8PO?h-_P_PLSIa&a+^lC&)=Kbybj`v1qbcjZW0P)|GXP-|~%ySl#_wSSv? z*fIMC9UUs>wRx={wV1&|)ZTOyOVNC^Ck-2m&AU^L5D_Bxot7t>mVhloo@!0Tz{(mt z3^K>*O5I@2aGRZ-JpuhaH8n75XN;aqeGP1bW#&uQhrBE8l1!zK6Gyr1*XT+H_Kh=XXf_<7eosOF?(B`Gw8B8=PIx&7k>2_z`Qb0yGr+b+9#dwNO#C(-HCUvN}H83hIF z=OR%?KiHQyTU_>HJW5bc7{n-o(hiwDh$m<|@=ToJtR%l5te zmMbj!2aLgsgs=rb{%5(SVqf5yxqHnBB@DA5Pcxr`d|b0AtJjEEEO%~`y-O>9Qo;(Um5kwRU4Oe z8yRKg@1>HU%j7sC8>RB>-YYGw`!voQKbOmrsgpD}D#;`!*OBWbk3ig|d4CA3!li|F zbEdHeuX}%rx3gcLS5GGzb)4Z+sSYC4J)G*;Fjz7J$Y;4b;ME6^`0cQgkpgFH19`Kg z8zDKmAniCXARKFs#3l655x=gsJ}opKe0Fck4kytM!^}rD5-KZ=5~)-IddZYc z*UY3>eks=U0xhk}-uf{D;>SR@>iCTdGL4Np*bxtEKI_MZhTo?xU=rcmI`odlY2|tF z1mVFu3j3dWL&bG+Zv5L1Z_c~j#)wmw3hRI4Bv_{lJpDQAU|66y;qKjq8^#zFOZj^1 zjMmYYI_5?c*I>V*%65JtS%{4W% zb283>0^@1Nm!J}=a?FyV9(< zB*#1b`ksCKnY)P}#+}LVg5?l!<8+*jsSto90(1xf^C+-$+sr&JHzKV{~!tQ<|sS{D;a_4&y3{VJ~t0=xGB9>Q`!<0`6@AE6Yh2g|? zrth*pg+z&aMLi%qZir=;GY6Sg8!xv^S|t6PCHL;PDYhYt;fV%18GPLUQ|NDM9i>a znp)x4adqCk_U&-}dqRp;&CuVN1O?D+O5n6oG7^I z>(x?`tV(gr8~`a$`IGLy2gXm{{q*StNY`yiSrXSlOZ(;Isb#uMwBa0On}#`{wstx< zaGYdg7)5N3bTN)I?%OKXQuAf){l;mFR@Fdar4^G|A;$z^5g|l zQaT*N{02{`Qym^&OSCp?`R>l75G)0V5i0Yc($eN*hEJb5MVeD0UaM*EvP?k%-n$d# z1dKmwYMzRTc{~dG)2tNk0nBs+wu}2*YK!=!tNBGRMp;@9M@#gqLzzfroXtGv?=G5* z?FJe3SY>M&CgaP_KfQi2b=-w}wOSRKW*Q7FSIj&s7(0U&O#>enD?pF(mDd)ASs(dP-9>e_%&=L(OcMF9N&{~jT%T^V2&@l?2A6IRE_4q;={p%S zyu7?jmeW{L;@yHjfWgeRTdq9vEgb9r{v_+=xaq^ONiwch& zOXa{X*Xa2Oaz>qBkL08@^clG;j`U4_?q?zCMWCD%m0CChf4iLCIJUZnLkFIyiCh?Q z{+?M&NZ?S!X$;mVG(v4DPCEtHt_zBFkAI`ASbz!r1>;Q&3(0Chv6JbWosseE8kx!n zCUMT)-IwOR19nxsqdui+GV8-y_-hgSluz3)+U;B)ktcb1dEtQv{kNMEl|FheSE(wD zDe+v&_ZN=f5fYV59K$@&?D zq=VDnHe`lsw$X6h8E#gY@e;4aV68{b90O3InR@fM83NX^=B)GLvBF8DLy#pcSGZ(R zaj6ZR0p9(^(%+O+JF4O}!o)y(*eDxS7g-uT=KE`Uf6|7?ui>6Q700KDv0S>!zWF#Jek;Ejp5=B1?5|WG$>-*Sy`=c%{D3 z8?Zv`50&u`_e|5O^pvOmU-UgA%=1gv$nAd1xdrInu(hOdpm3<>VndB!L_y$jX$4<7 zH1HN<_U9jA=XQJc^Z8yD4AWHwmkdolY--qQyvNfIrSZ=GIzf2Rc&12hmer93jLE1h z+dZym>Mx{s(FnY^&2cED3wR}7`@^t?6t+zSphu09<*6-9?%56vEyKzxMC~RYy(~p_ z0ngtfTtPW9nZ%W^> zOj@8V4jTacx`6U?ejQgms$FX5$Mb2Qr~jJr?>3pRyu~kZcopRUiV7P#j}6IM!H*5S zkXA447szdb9&LtFMr!rc>)4f1Ij&SE@Hq!lX{|XpW6znx8*yXYXOL+)KKr7CzPS z+ot55o~r?s0r!F@{{vIuEzcK*vLHVHrBPAuJvEm>n*ZDTc z$?%SJXh_JbZ3~wC6f|=!8Px98M!8$|6nL(9RzH>PI%iM9wCWuH8kHcU^~sCg!Bvc9 zJY6?&_MRVZa*T4@maZdl-RIM%$-Hk4Oot>loZfKRIa)dyc8O=NRh-SPLYa=0Q-FTy z#biN=4x&$Zfre!!Z2>xlKOTxb?ecnY@>?#Y^9@F0DGMpfr^CI~QD-%$;!K6v*s^_2 z$VvCg_ps<>Bl>HlK{N>`j+z3%$%wcD(cNLky;VWchk}--K|8f+Mp)ZbpRJ8P=gpqk z?t+|>H{Iv4Wmg&4gu7W7mwN4?g}$>-gXj9JLVpW}T&$~hCA>7dl|2rt#YOz=?6Oc# zJMs$Qx!UwAIK3;^aDC2fKfKkQ&r&pp^TEU=M=XPT?Fq#|tUS)F*>yC0@EczcqEMGP zA$~yy)HpoHna%CcZ_Q*iHCgiqtudR!UEv&+BzUgzAuiNEIgjJLt%VNgUbFTo7H>lOK*}D?49~v`Smy~+-vXF-zvZ;eXQRfCA-DRB4(zp$W+E-slYe?J&X(I z?WXj_z;?+UGDhqgDBgf6d2>~gYr4ih?ur|wSBdb0&aJrQ`d7e?BDR-sF4Uf*O$q5l z=7R+|+F22H6$Lg0FuS@A^Xhg#A@Dh8G{BVK10s#pKvgS`@ z+K(#TcJ-U#&lf~>fwI+=kN7b*cY3v6ap!&M^@|+fsJ+cyFS+^oUg^*csfeL)>R}GP zrcxbBwJGWw_(waB&j^=_5A)XEJwh4D{#j4#`t-i4_-T&iMxJyHUoqiEB({40=P|rH zH;)q#7HEtk7rVTw|Frd`;In6PyX!LOAQPn~ z)RJl(POMVAEr(f~7_N$BWv!T6J<8wmG`t+Ct*;y@e$)XYZrr8yyFmB-$&;-{1V<6E zt7*E~mIVn5bFyJ&mYL-RJ!djm(>Pxm9G7G^XX-+hreCw-%L+}0GdukVE@)M zT-?*u6&if=#*K5G$M6b{zbSq4>jOQq6^i-!(+qaQOF{Wl>t*}9iOvSLI#a3H*$BB= z+tHHr^aauIg&GH>_h1cBYyQ0U{N51(`IozKmNpyMycgp?L~k+N(~1c`S|BQl@C@U1 zVAd!7R=w1B`MMCT`Cy){hx3}ur}2S#uM;FadAEe_8uepye>)USq-g|l=Z3G>dQDj8 zTCS@vZWm|HyuN}D6DuSGBb~%a;HeqY@>mun$7n35hcar?=RG7QIy?KRYCI1SKA{)p z|GJr!bn4rBYGa3gK2>G}JH?5GVJo$LMBl)9eV@|VnQUjOI=_>Y%PRk6j(BOJTILse zvvj@9P@8&0XU;?vn~c`@+T&VrqoeFeI;ENFX+=f$a{1}szZZ_|g42L!^KuQwcU+BQ z6!&WuAGXjYKi6My*(>FG&TCJw60YcN)l;)sLP3@AZnvu&Ykwlv?!u^Xy?sJ~3jK^K z^W~THq+9%BE-lpdVleeGX|MdGPqGr@n z-nMz8@B5-w2A(ZoL}<)<($xEN48K5Erdd7DsEa{hXR&H&eVumow*>;hYFn0NVaa^X zJfZ~+_ph3@bzUE8-M%iPxL6egrmmmZsX?&dzVVP-PRHErV=^kO=lgl4pPo5O(Nn0w zYbQoenG#jvl$h|Og*v%AaMN&$1 ze=J(Bhy{OizILr4h&Yfk)lTeQdf}jBnYq?uh6m5%2eC)K~zCO?~-jg zk58;!ge_T^G)XI^t&R{r$jC%%+8@| zb*tTf3ji47?}z^~Yt>w|&sR*1FJ)JIyTyFg&W;U{{pID?WK2r0Dz?F!o~P&S z+iRiGr9C%q-nRICH%&Il4J$EzOvf*OV zXw};l6iFd*im_6eZDE}n?HzgQM6;|&<&cSpZo0?$%=MqjB)?9W*hJCTe0^;hLqtqu z{75+xwO@JFX=NdOrnwB2VlLot-=z=He&(h^)ap(K@@jB74c!BgNv{-qbZ8pt0d-oY z3x7U4KYxlRl|fIjo>UP=xH>uOLe9Oxz3tZIZ$`OgNxvmc-&hkli2a2g;}&3~kZ{iK ztC!a))832+kk3uBpc@+6Cz`@x9M7GmL&(X6)nDiEbB5|QX zl|-jNU!$2E=QHbaVk7T81SC!{Qg4J-6Sn&G{0!3zbptH+bFy}#O_R7E)_cun;JQ5zA4aPJN-eHv$92zz6;oGktUeFBumZ;@|QI6eB zFIW>w#g=dSWK1vD8e0zg>DX@>1kPZJ>6=cFV?RBT;#O^Ll=71K80GZ%s9&+Ona4G^ z6k3O^6P_z0C|R1q)S88G=go%a*$>RKirIv^qR*YX(ABOf?w=g` zIkW1Vd`(zQ?&lRp?0d38iJhePmXQ}H!HMc5Ek%~je;z0}bkOyT$p;|hmiu~CERuIM zik^$y*Io=0(UvjEgd0^f(%YftVHhCy`gP{GDTGo>80%=h>I0E#ZM$%oX${(r`jYY6 z{lblMuv_!R3xa{c`;#Bi$;rv}Mz7%3#nuZOpKCOgVfM-E|4y;uyI&? z@WxWT^?RF3?UNMfDOJV|{kkH%_L9UTt%I8-+EvM3O0Tftd8Rf#%_tc%_{{fgkRvS} z`*}+NqtKA7|IP4PO4F0}oq)@jLgt&_tO_P_o$hsY>hVyHO~$$}Uip>^@<4w-BaS7P zvONvV&3oh()#GDgVi3WiVq!B;0LnT$qhwp;pFR7kYF1cn(#XEDx;j0$;GB-v^Q=N>w_d7~)v#Gh6%gx0a1-9w4&=3bra%1T@Tp1q+eM1#oVkrzPs`}pK&SWkUuI8|!$WZd+03(}JDdYfS$roK4V_seM6 z`Q^BDvGkO24-;zScr0CitS6(Iz2m4cJty14&^GN;CtvNQtHrt<<7B)l%#-<(CO6$R zGBEVyR_&e)Iy7?JN(IT2w;*tqI>)>R6B2BM8mV}A2c@x~7WqwDsH9^@!+6{V<3H`d z&6020i}oT4=Jr3Fvf<(NQczLJ0ak8PZKI~922obbJ@n$m3&=pKSdQYUd6XkPd*Rx~ z$*xrB;v||HX^DNV3>q+Llqfxa{yc~s3e5fFT3Q!1b#?WL?V3Wk=aX^%iA8f+=;o%t zfPg9JHJ6YV@kO=eO-}0X-|+0q)}IAQ&NAn1%rLTe4oo7y^-ZmV9^BFZ@AmfgYH-<3 z^-f3&QozB?dZ@%sFXVs+#9y7ZWFKkhgdLW-{(*3*r%1V;MZMP48(}$SnVqD{%RH&U zBcJ@vFf)&cJ7mizubS3eU@0MEXx2yEWlts=W!ZJD$;&^0o^9{?`29eui?a4|iNAym zX)KOkzp|93%f9OSZC$mQ+*FYdJu5Kr`ddt)y64`Y+V~kU)!_4uXrGhv9>4W1Lu9Ur zsFAjxpv#VXuca&InN(7!^MgEgx1BJXTvIjnbqq@WoxTc_{*F_L6*j_BGA`uf{ZgH2 ziR`}a`FEsyMbMfup;*h(sf;KQ{=2mk=&q;O)Kc4oxGZ3?ocm`83GeKetPeSm&@S|` z>Yc_58GvizJ;XZHbXGb@XzB2F2QjO%5DuzKNJ;r^y4Aoe&`hwe>D5&0Rro2X*RNkc zm6ld?aw<(qPHs`(FYX-KGnkJPI2cmupvE?qK%vF<$aL-KISH?wj*=dmmA+u`=v0e;PJ~W4Z=b`(5IE z+^q$A8l-*NvwZGh(=yC>9kmvoFhB8Met!;g@m-(}%Jk*OGB%yc=Hn|qLZg*$4f2nQ zRS+(y9ADcy;gM68^dLFw;-lPjza5D@LGEhDtM5KoZ>GG&G9+gcT^4jHsaaD}{tLIk zt#bLOGxVzgyGawo2;nL*#;hQkw^J?f!+Phef2a4Td*I46mK;1>>N>`e(E=2~`svO7)PI1g_K^z37@Z4+hq+`w%< zK8#8Kc2~M{yrQO)JiS!JGY5y_qsNW~B9Up}puu=kcL#fJXlUr5e&xRYG2dn1ITFmE z+}zx}K74ro;K7?9R!uWAvRr`h2%GzwLs-M9tgOxIydws15QKfQ;(y39C=Y3x^sh2VsXYEm_ zg;0#1H;yDW3yb<5EFJmWL3;l^yTGp7*5n(R!Au6}ixo;3@0*-?2=maW_$xxrlBWvV z8&dGu?+bq3tI)YI|2S&|LPg< zj?sZE(#KbiINM|1n(S&%zD8qhqvOOBo26upUcSfVn=WS>trDG4Zf1Jw{hZ;dUirAf z%j(${hZKy4O;8WdrC#=aK5R}WDmzDQT|yC~aUYk0~H@A_Tg<9sGZFQgG` zQfC&nG(Yj;a?5@NQtGUwI);AOi1Sp;yrV<45y4Usu;I$a8yhzWp$sfCl`OZ+XJf2b z+Ny}w#-`>F>kHY(4V*cO$=xK6z9((n6k$33Q^*;}Ohyhc&^<5~rlASroVQgVE)p#;adPC3ye`C6=r}1vMZp!5r#C{j!qb5>H z2?5hVr>*I3Va$EEpG9vipZbRp%oSfIek8$3!__Vp1tK*(xrusRy#Z>KUqSp5ILV0V3^Wrb(R9BI%KykxtXKR}d&ljrmDWU`Vc==wZh@WZ1SS81| zCG>Z9*tE^k@X1794Ifx&_qi7@`p$^$vG1uaRWdz3{wQinsk;B5#&~om|E@Q_1hE{q z^1OeW&x@P@yU(hmP0z$~cE5Dx2X_}T-#@l)3z3)HI^!ZW)mQ(tNFA=7AMW@w*_5QW zT3c$@tRqX0ZOu=(8DUYjA(ir19~PHu=vgLizSes2@}Z|8w($n0una2{k9zYUI87Jq z*8FKR&3kYql-)kThz3-~OzGTS_txb&N~SHYzenYcN#!lB5-8UEV zDmeZBqczpxeSW#3%Co^_eIhHgo`&qw((-SvDkW#ZHSK_HYZ}>D$%`a(p0Lw#ff2)V zJ$5A%ed?0424mcL(v7jA!X@h~WiL5`ofbCTW~OaS7iX+=C9%B57tg5$&`bv9YQ5xU zZ44?)Urnb7=XF?JX=4aBi#@NzY(Ae6ahKwzqCS0*B{d$4nX*{Prc+%*b5;?z`r1S7 zcYP~Hy3S91`h>YdH|!l|MS{opR(84hx-+%@oXUeOqxI_$emrswvelgJYecM*?8sMU zIUIH|or%u|^Ij%k)f9)nI&VJx)c3-pJ~=*FQOMzYs|j5e0`rRsP9AD{3D@00SfNBF z8BI-kr1NRozDn9wk{^W9_800XVkP#s=$_^$Hi^fxn%)ul`a$(6z&Ch?>)0!y>r5IS zFPZYl%3&-Xd`bQt^1CvV0;5x=TQO$T!&er+lCY^9#4d(37gKY`bpMCO$Gc361ac#M z$_b+{@EPmhxGl(3r?bA$up`$bnddB15?!#Cf@DguM2C$yiWxK$&gQPJ@Le(~&bu<0 zb$2QCbc)Eabg2B|wryy7GQ6vh+l;Ah*`FTlHF!l^)m^-NWMc8Y5SlzT^tUE)POzV- zp-%XzmK>#K{LRg&rGZPq5wxy43VJt{G|U}U`{XrT=6C768M?Udy|fGGdGb7rWPjq$ z*2~vbB@(dpeQbB(42TjC6j(_fEc(Geu9=62wVX1-5Zk_%#fz~P7_IL@HsX%B3cKpn zBdEM=7mUl(aY?M1GFilI6v5M`*7(TY*85JjO(x6E+SP<}>b&gr(Fh@z5;1?CRs${t z$w&bP*ce1t`<*0S`Ck#z94s;Lzz!_eCRr8bc1%yY#I)|A3a+xsSM06%f520#C5*De z@S7|!xnL(V{DzzbY*PByLb#jO=c4N8E~iHAoA2^hzdM1N=DnUcS*OGJ-}9Fv4oO2J zL^J|2W_iWExm7nr@f~)C$fcK12zitUvnlkp9z$mo_w=J$Rf(YF3Yqk<(%<=vGy0#!C6n7byXA zb=6>NWKW&dUDS|9k-c@8Y|Ck_6`uvsWtkUD`hHzVd4ys*l1D|C3!xH9P8;3#;rW+6 z*-z(aQqncDm3kVV$U;XF^7ovp+@iyMIgM+t|AQsrjVRml7#_S{v+VFts-hG!bMOnL z02nbiqS;5S45dD6WNj8CwOG%*ar(A0Kb}31$K{jm)J&+%`zumhpMjpG@~6%=9JGtG z6El?33$pJdt0I3Yrqjs3%qW|$Dmrm*6OmC`0prpYx0 zuB3uI(M_pSef-LDhLkxPU%td8j^KTZI9tAPnbq-CMv>uJ5BBN&T6&um^5&>nbYPWkP0n z+E03>3uamSQQiK!2`%Rd#>NW7uIcdY$VBtpNO8im?F5P~G>GMoZ7a)#jHI{fS_Cik zba5vZbJKE^`PDQKn#29qnJ1fDWL|rB^{mS9S+ay`-%Yhw)T4WAe(~&0A0q-gqfg-p&;B{t!gr%Jvlw}3%{6ixc`K#W zRkC#GZRcg(S`TBk2FdrGLNLad9XSeP{3sCR8QH+`^H)kWI`D+8HEn8MkK_A~<9 zFnQ&Z{hD3(CNST`-Wj~+tuQ?}AP4`rPG0@PbasvFo);{Al~NN;7hFG=dOF*3!}3d? ziSBr2(*W`U=c71Vkl=;yL?4j}5T@}J) zmsgLw^!YSSPjI40o0Clp^G!vwKa*Tcm>O}tJ4};igN`BBb3=Ab7G}miYN1MPU)4F& zX?mL{wRz|WI&|m9<0c>P%N@Uu6g0=ID6y*vb}t;~ZbAoeW9|QYZoIR9g*Ki@lgKBT zw-)soOUVR4pFnD6m+hz=tuo)EC>P88@mhx!32!ORJj0qBrWYf;d|ENmc{I-zqpa@L zzpD3nm>Ly0*SVZt|3pSd-+vEP)@j{sV89{lpnb%d!Q4o(t4|7JjcSWgZ&`+9cc!0* zJTDdLPsP%q%l?Igbc#D^^z0d;Q2#;e8j2J6BPwDSXDd6EuxSRDS4}Tgx#e7AthhOQ zaKZg~a;=iXEuK*NCraBlElQ2M#dP*g?_i`XvFkJPog0f(>gF zXOhmstyEcA{q%7O6}k7MaX)-!3h)N>brmW@jylw=U+-W2yPmFruC92@km-Vt;>^_4 z9oExCM4bDqg9R{6Q9Pt|g{(nLjz{i2Ks$wy97JVVz4WxO$OO1DJB999%=RIdPDC1F zWn>;^sP=epW1cH~oAknp#P6Yowtna$n!2wk-q{=d<;1w$Inb5t)+HHs>-(px4L-!- z8Ov3#EA~+Km`anu{LzB(0YtTY(KXhtpS6^uLR~bBDH)N)s4G=Bf6C)EXWn5}ID#6Q zq0TVl5!8hErqJ?u3>Yn&r{Cb1F`_`RIpVl$+d=fqmhuQ{yr~ryA1#q`r6#7&E zIs4r=JfrAEYH>tDXV0iyzL`SSXVbT~B312f+fuxajc%NhNoLbI5g%ZT-7tsm>3_0( z_o$;&&Mi|*-|yiQx(z+y`~82P6#i?=vZqLi`~N$srh*El9&0HtAzVVXmk?%ry1i-f zOCU^L+WOKoY?x1)x3;#WE|k5h%RAEks;}`zYSR-7Gz|rjvyEv;IwTW?vM_`fEY?Pm z#`&=fy!oJuZ)~RdS%)vbIOaj^Y%{NAW37L$=ZEyjFH(sFA@~YCWPB|@jjJvPW-Hv^L z-f-;SglPo@4cC^yBWq}GR_AtC2#z}2^)bzoKF32=5NcEUZ~7IOnR)CuZkYe8_Mk%2 zM>Me~9V}!Bz6R6xgA(#!kAJH*OzP+07J<5kSs%%#kSe*%)~LW);Q5Kjy}>ZtUwmoMcmIXClSxrYr|M7u(4=yZIdcMhkeMu`yeZi|ljwajnNhRS3xsWl8E4nRM_*C9ZIqgX z#ipx_^=2noN$NkJD-;A!>Q~*7_Oi2d8NQR&j7x| z&LOW8Xw3Ge?R3%(M;>j+L!Xan>RJm$Z_gZ;xPK1-iGM$?ZDCt2h!dK-mqsQo#pg&lipXN%dtE7XyoSQ(>%u}FwJbt$p%4uNipFOe z)^o-cC5<7kM2~M?Y!0t6Q|A{cW}NAQ@Kcf<9s4NUUq1ZE5;xn?RO^aXG-RHRr(Dh+ zONc3~Z}U2}rYNpB{9ZDJa!F?3e{6kaKvZkjHj0Xh=rL(fQB*`ghfWm*l~C#K9y*2& zMZq9cq)SA)q=pVf0jZ$}7)oh|P+&m%TN}=E4xaa$A2|Nnd-lF#t*h?xEsp!|-&Fng zNw?DCK)|f5FX~f2AvGPDUjH$2)_vy1UinPbCX)`=oMgE`CXR~n8qvNUQj_N!HwpXk zqQtK+uijK4+(S2>J`|OeTc9o0Z~KLp-?4j(7OUczGFla`Ld_U$=&;f* zF0@eKp2TpF2=%`i$?v%phaCl=wYi44rl6<6MqS676roPe63Mq}*Db?YM$Ovz`$|-H zn6#rhB~^|n>5ey(5eH?AXT6w26)>L+?=xq#R=y(XH@|3bI{##E_HyMp@Z!lbt3+pg ztlZq=;6HobF}<#BuHp9q&8?;F?`ItUNvai@4VBz^W$8_r(MRqV8b|Y?H^g!V7{EIwJIvwiWK6cv0(%hCQf;uI3ih4{1`jEMu}+`;P_wf=mlGp@##huoB(@ zanRubBPe4VixR zHa0c`qZuZHsWiZVngQ8Qd$2P{jraNbkOs?xprx`Sef~w~K*)=yJ7X9B{b=Rzso}AD z{QrVe$!H2zR$ThPd^bAa>gw7kM!tJ@gV-zpcVBC2a_h;+Lc`r~gBdeqtxy^OS-L>k^i7+^x+ez|FHK7i>$O7X>vGp|Yk;mbX#PZO8Csm3c0 zybBNG-rpW6xvW3 zj4g``68ek<^tp*A&)pWVark@4ZT(Z(wcX!(nVve;qu$MxN}yTSu5e4Z6J54Gr*MHz zjnt8}H~|Z0N=mMybdAc}Q}M2rYH{e%4`{)Xvz#&;<((BAUD_SVley8B>TL=wErcxS zE!w3nH1WGd{{DE~eW>R=+noT+M32|=!I6;!NA_q_A$*^hiIAQ9jbi65>f(Plr1O4z zbM-PEhCbSbVZUhU>!XiXtD1)9xS{1=`C5N_rS7<^!~1dv>6$yRF^y%Zyu+ERyc>S@ zmyDzCBM&vP`tonn&u^+NO2lVoNNGFU&L;P;8COe=N8&jY@10wclGa2GodtD6Q%zeM)Lcz-+2TM<+k;6yi#*2~-HPa`zV3 z7nCsZ%Cc1D7AG1f)Ye2QCC&rhqlr7EjP6QSX7~is6NmZF=1>*~m~JKo4LKN-)~OGt zKx_G(K(j0HNLD!L;G4P=57k=AX9EE~3G zM<`oUfsyzi@CHz05xcy5vnqmZAUZS$iffWD>r^1yGlO0}f36Rq)Hmd$V{4*d<(+u` zx$fZrFYMEyqvwhYG`H^s`OBJBTYJYH_~Xu>KR-r9L^RX`XWg**l5aoJx_jMxMrRGgI!0(vJp2YXWF(Z|Ii-&N` zSuOta`$e_9~(`c#rLmJVD8pTc(A!m z7{n=CozzGh<(qHI7l+HQ`jT4T-&}ZlnR>D<6n7zg?492@SL6NX*-;Y{%-rIxg%36d zUu`(Ole^ED<=}+Ax!aBO^)mIb&Z@kVbc0C+O*py^i`{Nzh(4!&C#(mvfA6-4GHf68 zqW154OjhVrG3H^SWxD0G3_1FH#_J+`Mgj)gIJG%i0dwUM_96IEtV{$bIv20{j6_5- zOg}y;YXR!Vt|nnc1yhfhpAm~O9`36}dFyaIyIU{w~V~86$46 zC5n8U{m`Fp9@55Fo|0R0hzJxMP&*(2v0r_|aQ?}0FFM%hIV~b0Q<$v;^aPdwP3~;G z7ZdX7PW;1JfS*LvH4>WoTSS_)udzIY9UM2rXB}fm`zr!Kx8tOYkX0ze9%jcqn%YtR z!E`;m^=d0`gQBS+sNPM8r?E%0&@f(6%pS^Q~-bZ0i-H}55cuT|d z0ofZ1stPS(?Fcb0KeZBd*zdta(CuJEV7#(VVu0Hj)}KCZv9?3EcmF;zga!c5ZlUAC zlB#7r$SBQsmLFuo$4)Z9v-YAqbmRyzH0wms`E=uClbL3GY=6?q;%joAuyR1}Oms}T zY>l8n-aAXNx;j~bZ+gw5`d+(C?gO;z0^Timmh+Pq1K853nZ}K=Z{1znu6=gl(8(Ls zBwptlg^@6-KcL_U%v(jDQhMN~T?wrUqlF3%Pmp3Rvk&OcIsNh@6W3$aU$2eGNACC$ zTjRyM#r_!%@Wtue7KP$P$&hT>3IezSz7>Q{kfoH>o$Pw3Wb9n_`df(#N=@tL2g|TX zQ`fbSOwo0Z)odHzd_Y}0`XY~{mUuRQA8bo3qFrfGS2pcSH$bWE!xwU2_;yG_O`xO8 z2zyOd5s+wLxmZ>_kIXiQylJD$JMc+MTIF3VvVdhYF$p}|GsxqZStoCK^GhU_1tiL| z>f!agJI8LN{<7=>QqFm$RPVnc;+AZFvq{qqD<$Uk>!YaW*PF}BKUWxD(GCi0v>6ng zEINSb!Ai#+tTe+C#Cc@c&}Id~)u6aRlwD}sH`NO~`gyr9n%k2f-;XVFD>tgH5NOyn zhGM#(855LQ(d`xhEY#HzwZs02?V!6O>g1E~ucJXE)0eMXe(bY%G?rI~ZGMT=5}Ku! z?ygAHquqT`o0)T@S`sSWTf29*++;sZw#&K;mxbHj2T@rZ$7V@Xb!2H>YL(=?GI(IR z87jT*laDfLUF=HwiEd?Oq}Ta&3r}k>X;#*?bNoxw!j?XpAa-ZyUyl2(iwLrKnbT~3 z^MZ`K7(KKbMYeaTI}BDKybC+sU;fs{x9v)=B~|Z#O~+gh;;V+rekUkYCWeTk zY}}Q_34c{Sbt^4{D!Sk8AK?_4SIhY1BqG;r93zVoS?$?emz0pGtFM;=JHCQ77fxsw zS>fLk@f&L@pxZ)qlPBq2?iFx;3m;F=c?^JNZfSqL6r#Ho2s%dl-jO3RWfj9v5QTcI zfz&_RMK0Omx-C%o0>6F}X#BVFMqhl0DEiUMXKM$(6DkF6?q0KBPCp?6NH(%|B+$-9 z`T3De%*?r_HqiB9HX5y|{)2jDIza z&f#P6H`^H}%{1qM63}IkdR$iQar3?s9TG(suShVL*k|rucVj50iXu)5n1Ukxp7*JI ze<(8@>ff7xeJa?W$KSF-;oIOqf1?Z*6&q&GD{KnrwzGL$m*l?PeLkAD!{&?pj6{m< zc^F9`0Wc4p8DHi+jcyXmHbRlulyK(wAlVh!KzjT#m%wypGX7_65nI~}b|R(>Px~nT zNM;k>n7JBGi(ThGJ=`15fs^TURUZCU6FJy+3+6`q zdDJmd>vI%K6U|al(hD}y%t+Cky~O3=kT-O>CqEVu^Of7^1H*qEEw<6}0U$5AyuAMs zdIymPH!aQa_rQi}o>;}xX<_6cs|>NBLx^#NS5)By`RhO-=8|sNrPiD!1KosuHC0H78VyPSw4nLxwDVgG|NT*d0fbs%HeHmC5>t490Oy7kYN);rBd-+U`Qq=;uSfxL81d4f!AALFS{G~wGd#twnyOL zPsUBLEB>o9&~EZ)c8V2-Lb;piaQfm}*Xx71-InjE1iCV*>FJV}(!&yB`$~JuTy7_t{#SlR){F^tM)q zpvq$W`(-GlqMT>v6|}eORGujwm0oL~{=DTO(A8)gm#Jhc=tV9G2{J?L+F~uMhid6S zSoap!#O?A}ney5D!uqs*s~CT}YmC?jREDOdD!qo4uZ#|E0I&YC^+%M8EY$7pI*R3= z$=4am{o!qimRn}hzWO|jz($YPGYI1#V@PgKTyE*O(K#6+TOWR1j9F9YLX`!22jmR5 zA}zDEDR^DwCv>C%M`S)`88KUqDVzW5yLTcN_WDZvhU7*-|1NjO`5XC|r6NNMYep6) z)&5>x`m;Qb?=~6by>T~bH1{m0@B!u88O>q zuoeJG^d#Qq2ABxnyto~&@xQ@gy?gr}E`ox@6qJ8~7I;^EugQR5=fjOL<|b`8Ew-pv z``GzwV1iV}w4@hs@l+=e)`24CL2dlF(UBg;g-Q=)IQpZNr*i$QH+dfKg>RUdEZ6%8 zGdgpPpF7=?F$aW5*wdP4cI`+8+`4`>4u7Bq`IZ=L9H5lqs8egpDt1+F`T4`SJ)vWX z$-sjGsaO!*r`(;q36`cM_So~BlBvssS3%CB(AR1zkjsBXX`@_}LsQZ#E3n-9>&SkVw)*%*QpoLYv#F^TfPyTHV=rea0Ubx1`FS`yzO)|$ZPa7+PQ52{{S|E5KpLk( zsrmHx>M^qDeQ(Y_&WFMd3?M2^Cu2-oLXIcpdnmn-!lQr*@IBm9K(t`1eehANf@#M% z(qW^eqmy%AN8^$v{+6=yJ3?ogIXvAOj}*@G4R$rDjn!P2q48w9Gv|lQ`K&{vM;*%% zLxaT|Ib$C%Z##5RU)1d^V zjndU85rW#TBthkFmmhv~g6X)UOyf!Z%PAb1e*m3iIxgE3I)8GB=XF?Wdzz4*l!g4B zgwv!vaqJQg+n2cIEfrzUsn9ISA?5DYIGFSyD5zZ;R>=nM-S8+k;_nJL>b3#ggHc!e zNvKs9YR{}<$^b12L+`-*;a66wI&C3(gYU)yJCXryvt?xwRG^gC7s1^32JE}YpYp`X zDJvl%F79;ZQYRG<9>VfcZE37pHr)WaT`Y~IF1LUd2#zo_Iu1cvB8tQ}Jmx^YCpKx- zhd(>*Y0(g`d1S}%0OhsDc4bMi00{E)&j$%bk)y`W1||K=h-?Km{uAS4`a*T=mN_d8X-qPUa6I}cjox9!K9_Ex;7CUGnQ)aK*3O$Xud~G+vg@u zhOCED%CRHTu*vWaC-RTD?fBW1^G|$ziN|AqKUvo6x^m^ps3AB~M(21HVpkz^R-G)vl7MR?rp%U5L_cO+hx7ewhdzr;UQtKq9Y@8QE$XAP@>0({ z`q;5!QHzg1Lp=KTZba$i<-cXkQwEm*rV1$e{l(0GSb{*k6C6_AO%@_HJ%>0x=h9R> z=vCFS5;zWH7z9A^=~VRJe10l z+w=bvLRBPtTgZs^2hDec`c?M7&r_)nhYbWO7b{zD*JyJSd40*ik%pXx-*;UHz6?`u zTbFaA(X$iy^^$-%&;iXVVp=Qv?vcUw>w+sI*)C#esZbRKHtpZhX2{$>nr7d#- zvyg2K!~Hq7ycoB4g8cxyk)DxHy8z56yMj%G_9Q{VN2Td)dqHYW5p1Q8*VpZo!yO7Q zU8~gw48#09YcDiy(6i$)GyT&w?Ja1=;*u~RW<|c=Dd}HhUv{}aQ?rGw|1*xfjE7W_ z&bV?vCKyk&M~7ORHtS0tzFXldQQz-VdV)|yeb1zO{sb`esgSo}Yjj(ww6v_W7t5-1 z?&ysT7x20gsLY5HcxK07KNpr*QMHsUk<6E$r!}v6V?_SB5c0(fy4H9sSq`fVPz-cf!3Xx9Q}dF5FB?>a2$Alxz$ z2!cK>xO>lz(@T&`XKq)yPTt?Y>xv9tFX`VlfuIr=t;93k$$kO3H_D{@gF&S2Jr)}8 z@RQ*O<`&<}9Ev&5#(#ZQjkgVxS(K&>y0y=k%(5hHpfPizU5Ss`%XfImk?UCMZsx%0 zH^5WcZ5u5>w<_L#(m5rOkkMMi;pde01huBkOoXPSHTkYGrB3 z%lR@OAS5(2^c06ivX__FbFH&vItRDqrG9amvyonc=K65P1c%A-X-7iDPv+Z6>g_E;I;#TQHy?T>ApnO^NK;-kdTP7{ zlrowN#XvG8Tj|u!Erz$msYNjHjXL~Uw{od%*RAuy_8%MK_7yjiRa`2uk~nPxBe_1j z{L`5-+c`f%=abE@hg!xZjF)qdbzO5Rtv5cOcKT8sW~S(e8DubMSgV2rAx6juD)ssI z=AYBHp87w33but!YlP=3N+)BAxK7MTY>4(3V`Nv}4&+i5UBaRemIgQ=^-gcR0@zys zhaSP4^P#xJBKY=-cMVGIG?*Z>$h23rW!6SJ^uU!7nO7X&IC*afwwD9h>A?BZPD8tpNu*)m&*>U=E+5ZGN< zBJGWfI@b`o%Rn`_F|WRxq+5mqnM+zn|Cz9 z49W)!vfttF*)nSV@RyU!c(@GuGWnp(pOY1$d zRwF@`h@)9QE05)?3TuI+?g83yAkT!+J``Zr=`1sDZr|NRpTI{*!HWZKakNpLpAI zNS@?~4o`;>?Z=OTHUNP;p#QeiBq$h6jRfSV!Q;FMa>yEczu-Kg?wcJ(9JQv7f~78| z%g_qgy)oJN51w~u_JANKR6rb0Yyj)*J=TeeO1A32$Mhy8%C26>Cx5l2k>*oX1(EUZ zj}z37%Y^xEW89;mthuWGor`zfTij(sC0}$oYZ{nk$r^@EN`N$cdQXT_h2)&N-eZXpBIiyoxhAE3!BbjXS0S;)cPOUT*P zdBQtwegv%$5dhIHZ|9Di{-+L*X4rZeT>zqiVpibHss>ceKx4gs6c=|uK#YslT*OAA zjJ#8u1!Ud9Cyu61n2E=@qY0z>JeI2U3eBBuNeK2DxZxhTQM~j4xTpG?_s@XrjXoU%;nlpP~qItWktC)eE;{y3-w!Y<=EBP^JVrKtCcKty|#rNzw^-Z0AI*vfnodsJh*TF z5_MN+zM8+hZ8srO22OXHlpFlFQghmBs0%A$f%I6fdk7k`xv=$h{HJTEJjd>aVF2?7 zuY$_bR0!2aAZZy3V`u_dB)F{3so#?&LgCl&k;(w;EduT?^MkoPe3E-smQBPhUjX4_ ziDld^uPI?41{A-c=nTIepeI00l(=dB`82waw#$oB_@PQl-$|;&`AWA1&N#Jn@adFy zFZW^fP~%rQ&l~lQ?O`neQz)p5V9z>!>>co%mg+$lUc#Q#y1-vwgU#)8?}4^^B)koh zMbPRCO<-bX>Hat{w$||(g@Fk6ZZmwh21YWr6!uP=Ahgt>u^s6_t(+k ztP)<1X64wPv?eWLVi{Cx2-}EI294G1I)Y|1lO0GGN9(C=g<^lYdGStw5_A}_>qz#7 zfS*pVttSD5@}}7iAe-w^)XD;CF717hes2wG(Xp-cP)7J`1D{~82@WA%4Jfh0GJ>h~ z4N?arcIxQKoV-IqPPs$=1WNl^Np5aiDf_u|x1iKtnKBkjOHRJHc!+H98d3{bgWL4X zx>Nm8z;6gmqpY{a8KsN`9cJaviZ4vmj}ZyD8RgA)4tgIG((XHoIX=)XF@iU^7FB#$ z=USJBh6S&zS`qh!yK!#r8kL0ldh_m8q89N~3v~c~Ji0z=m1gXD;Br<>YKOjLog#tP z)~n?q#L<8W*eAr8wRv)X=_hEX(oz$|SJNW;^Y{=vBQN;@+}*z)jdzeV2nS{StIcWx zq`>PkQj}NT-6%}E1sfKFS=B1Yyhe!AYoi~a;{Xp3L+%Jp7U=wS>-wYamP5PMqPQ{^ zz~Q+()Pc2wmt|M)!Wt=M%sMf0BBgnaTtPRLdT zh;=?7S8gN@GAkqD5I4O(VG&J*6lK{CpoXvilAs^yJp>95-THs;8~Mic6glxr_9N+w zsR&ryF--)il`q9bFAjQ4E2?QAZ35(7Erg16QmJeucn~bUuFUe}9(bYC!==^&`B3b} zem@m#Z#^S)a)&>mSV21*m4f)jpT7-I0nj0;!5)?JKE6O3cT$-+5g&|QVwP->dd}F{_(czn3Kj_~->{GC%m9*I^7u?1&!1%|*|t4OhoQ%Hg%nR6nCxlYg~2#r9)pA2 zq27buLS|M?wBEdjpx$jFv%-fV{{kMk$U-KlCH?n)yVz89iT-*JUZjH21C~G5ctG?;Y(CuNj2515 z)-Tm8Nj<97%gyIKDuFzle?MNA0+6?-&&@5I9$TT2466*GJ1_aKGEc>F+7EWrRsbe1 zwC-M?MXfsI#5H32O%C{hLLK(1g7hOX#t^{j=X}pD)U%if{V% z063=HkUv1!N;p#XnPtf|FV&GFY5DmbrR-Rud`Uj7!svQpRa5<0ROEYD{YjfG!Dw~`x2`jW&p zU;Ge!-film#+M+1Cdj`f-7z`wn=LEo9L=kql<}b6AYQadMjASs(GD;Nx!(d230IKN^>p%*v0*dDY#bUlSm$feqC73>L!JHP`oZwC5a zQyErY;>&9nP z1yLy=`T17O>zoP|DnMf{(giZ$ukp+Z&w$(qM39~ky(1TB>(Om(K5tw8B9%;kO|{HE z!U{s_$#^s+Brn_%ZgLMX{6ee?RXN1NjS+ zPlxo;r(ENq@Cc9ZSoug>7}LznS@SyTO;>aU}R8|inYy9ZNoXjAu& z0g)@%*JCIYdg7>X;t+k!M*pZd=rwL2$rkV5w#VjE86X<^yT$sulr(xr03c9DAeg}Y z)-khRkFENAgM`M8B+l5ZaGL-Tt^aH!IxYy1vLKx*^D68! zfZDZr$ryfs@dx}4?oiGZoFD#3e~w(il^ET9VG{NG-9#bU;{FEO7Zl>$-f}a|T`lpN zBcu>ibq$JE?dk<@s>9eR=NBR;Nt08IAEO}0_#GIX3o>>j@WSoc!6_Zd5X0sM#UR&! zmgm5hCGAId5@<|y5LvKYUJu68PcJi2Q|(>Yt8AWEGI>uvo_5C!?RFnZaW}e%yQhA? z!eibnyWDByrgO_3-b-aFwrVgd0PHlpfd%FnS7!C(As7tXVX&>QUr)h?M1?pE&o&mX z>;qrIg}h~z{QfexkW(M3>w-a*ajojHlHW(Ik78oSgsNKooSssIgasaF>DJWB%GE4; zap>@?3vO4sRQX`JOo2U!_u1eaoSS$GvalXj zWh#iHvXtxYjT^AMj4@fneiZ<1d8Yv{3oqn-sy?C>&6BrJye(v*RzDaHQW#QY|8cCH z>BBRCjIY1P)80rslHPi+_ofTK|J3aF1<>QEe9$??5 z8w7{+ShyCBateye7fr}-2&U?pb6>(zZXV1K7?XG4tKqX5{EioumItpV#Blc36I z2+t=0knWg-k~cn69!@ed(s&|X!#%SK3z`E?<}xCg-3#tn7tQ-8lqLg9?(_5H89({7 z)xbJVN2MIalFt3oy#a)wzCas{h`~N&KM&ya{<0#K3<(K6( zVeW%UZQ&bf{>1Q@(8%H}BrYNPjOkwa+rg=#gozLyT{l18FNjJn`XyNNz$*fY%*f)< zJTGabnNV*R#M5(#2vJA&o0-Rw@-u05xk{QXKzloP>}<5HsD_EY){E(oQtMKe&)8{j z7&Kv)Al;_^nX-vj?EjtlDc;D;-&E>v&lH=U^=@t=4Q;du88lQH+pb~Pt&`a@FMs`3a?C^97F^d&Qe0(U4`mZtef-!}KR z-G-Pk@AHn1TIVPnZ2jyH?4+XHX{J(>v{Dk1?KkMUdB zxUv%FX}L> z^|+x0#2N5w#ei$517uO6E z@&0iJ;dj);2>8?R3oAV}bTogc_y%eH#y&oM@+1s*)LrDAajBKYVF*n9C2dGn8F>iO zjD0zo%1u;o51>-Je@bzZfMaTo_H@6yB5Hz@9rEc<_O49m zgAl03)n!e;aesO#)Q?l5JrH~YYU5s+w9i|HqSO#sLJ=XP!Cuv*Zhy6=`m4;%0*~@F zH-^<7XCPQTe%ZdJ?WOmJL^KGZ%~uT!1)4WtvXDk(Xd|yZF*_UbcsKJ*zT16W!a_*o z6=T1Fue7>`J6<00RVN+cKKq9ugz+Rk#=*qcg#w9*dk7;v6A^iD41mY31`KQ(Z65%m z2ps5xfV6cR<>%tL%&I8Kt7jfX$O6Lc;0%+qH|XifQ~@;eA@9|8tiyyhg%qQizlPZ5 z?h)cuH5##8-A8MT=2(K3S`s96nPB$>u)3k~KMFvH4{YFJ=HvPWXK%D2eX++gY*}~+p%gr^!D9r@TMHpa0MC4z{C{1(^Fj_1d>|R@)vr(y z{mmE@o%%g9bK_22&XJ3M!c}BsO31TrqGh1#1W9%d)iQr7+#(uEo$}7|rEi`V_|0jy zmbl61Rs*QrGKkDxkmB(ZkkTQof{ZfAtBT#fNfU~ojWwz~czhOyYXk39AxOYdfXuI6 zQ;ghOQOB=00V3e%u7JMgP-l;b(G+`{JlZjKqyg$I!&|=oW@R)&Ai(M?Z{NrsdLR?j zT{n3T`obPip9vtLMaysyd)R+UV6v?o1^%%XmJvj`*Bt<_7pbz504g>ZIc-;UJ_G6oADyx$)I0I z*%@kH`*JWNV`Vy=q9SJk|63x{h#?TWJg8td9Nx8Cl(g{ie}HYR*s%sZ?dr$*EZt6P#0NA-MD=OYT%Isr0D^^Es;Yi=Gj_Ln)_UQ>x|HCloSTTR-|K zJ}05d+{b<|OLI}eaNdYtb}7{BCBtj~8P#E0$QWtpOoa~iT;$xDP~OMuKfkiLSjVF2 zLk@xcWaV2Y3sy$T2h;YMcIa(ov1yXux9r-?w&5`jFrn9u8AmdbB>#ML{n6l;5TX!5y_ zl45MWhcuLEO5hW3!~JJWcun}i4tsr5P$f0>)T&nph`hn;&7E*-Ux@*pNkk*ABvvRH z8zUN;&%Qp|5ua)`n;qSF->;o;%BaMEF{m5%|BLOc8azNMtvZH;tx_$4EvvmuD4@Fu z^1z5t9L{|>Jsz5=Vc=TfqWL}i6e8ktSgPnetAg*(C_70NQgBsmtrJpf49jTfhkn6~ zUWsM8qUr9EliWI?zV==Q6aanfe~@FyvmRs!5JAzAaT!9!3gDq^=3{SI9s_+Nyu7+H zUU9Aiw42s4L6Gs4GA^A9i(ym_Q~ZrBngFUhl(%rxg1JpThOo!=5Hu4jT?u>hY&35{ z34)}P4Oj>ntvdH=KFk^kKcK()M7RAD!RPQQ*QBd*gWMgjSjlNiBk8bmw+=lpmal{I zp&*(wQv~g^2yv9x!F%|PgRU5)VvpB;XFHy~y_aGfvIYS&x>jEV1l;(X>LsI(?W!56 zLUrlt7piuz=baO2y0qggMC8}e_Vo1F54bOdkB~#a&Zr?A9RL#J*46$c(WkybO9Buq z5EW?5L0-v?*ddWYR&tgbW-vJGBX!I0pqw-Xzu9u982<+#!yS@~?*i+u;NDrDfx8D` z8|91bTMaNrBp4~Ib^IX=2Dn5Tlv*wU7nMVE|l}@ z$hW(;u$E01Jw20a{$g!Aun~8OzN{==)}8m!92BJ^W8%O5a9eT(FDxu`K#VD88O@c2x|@ymm8P>dK9kolc@?De z>=)OJcL7I?uF%rWyZ)eyjLPZW-bWhm+0^Yg^=o^%K*Y#li7%SCkyRLLN81utZ0gaO z9ANQ8ABuo+@H^tItklzB%0IxL{BW7)nn63!?fY+2_w^Kage_5_Q5*$CF&zdc0eAPs zHFDRFe9(mv?WPGw{5uQUGKSC^Pk4rig%HhyiL}(@7Ke?VsUrH)>oZ0soIQ81gd$mK zbvA>Zyt)z*607QPHNQf#kYV;&zXV)_&eFPxA}6V^cF5ct z?-4L^Wni!)zGry4?{^QjqOT(N%OTm%%l9U6lRzhQH$j>r5vlp+FWrHFNaai|2o?VI z6hefnxZB<{o|rKft}fR{cGPu68GV-qu>p|dSr~UV<{V-A@75iE0}$NAII&sLI0*{6 zG0>N&)3)eB<=OHR34lj(dJ!+qBB=SYti&9z2QsHv^REFSt?1c}9%wZ%SP;dSJ~|uS zKF*_wlz-DN?aapz-M1yh%^;fS)@oibSKJ^`9ae2}cD)N}>wFWRlMj5CFtPfT%yglD z95Cv+2m|INdoD2^2^g#vV+g3>Q%$otO;6LFmejPB`(|?6=yO=Wp907KJ#!RA8a+wx zo2f5dQ6^`tb+;fQHJp~I=N3C(4W{NI|B4wA@KTECVfUy_j8EesN-KiO3e#VFy54-( zmvP!@1(aSDToytvAVAeTJ4hklK5Q4<|Kb8HQ?f_;i=|+npzQ(5oQ`Axu8Dl%%l+qx zpMN8vm{afHjx;j%U{W#CH3Pt=Wr`BB0z0~&A6%HHg)pS;QN8`w30qltUDIQEM6JT3 zjH77y*nH#f5}WWX7=0LQh2&(yFOKT1HX@@3F#*BonY)@=qyaVE{n$Q!?M>kaslG>o zh1^Q|MyOH+N+cn3=spZwtKxo>!BtY4B%|3;_B$_HW#)4w$}pwXCKj%jOBeNmrdtL zqxqMFgO8ro6hhtQjQ(i(30e?&wHR7X&w-Y`L~IoQ^n<}2S&|?_Xg>kju=m}593Qp2 z2Zs+f)PwGEcx0q!ta>+@&Y)@otWv#TzJnIGyNNa~b@&+{#dnR9zl#l94!Iju3GZDM zVyaCRAS7^#WY?HKbcs)Tk(!s4)3Qhdg*1XDkJ52rB&zyXG*$=eA&V7|zi&!`;_j{m zv>IsQgrmvE`sH~EM*F#2Fs+T+v}|vE6rYzE{|!3~fQ8j#qffi%mhv~oo*i9uUoq)O z7SH&aZ+yl0+I#WflPH163xB*X*mSy~W~t=X-9x|zmoFYXqcnG%#R1#{MZmT2yAxLo z@4d7YzSz|!mW*f|kYV;I4!_bT+g>mU67#P9&f4*HT*6)>lOscp$YkE5LcK&68;_I) zSxVk5V0CFJi0R9M_Q-cM>+&7t8@3B?yC;(e$xwNrF0Yju`P3qVK770`24d79NB&U}DQ^?~j5X$CVD=`(Ng3T&8Pd>m z`iRVEpdx5GrkTX#;-IalG`CuX+H1uTgKLE%291$x@1lN5N%K9KaB8e;rVb)0dNf-q zXZ*jTe?tfOz}+=ad>#q&w~(3=V-E5^`f+_u@#R~llV;tSj*yB|kV&a;yhp0a;&ZSB z|Ejic9fP12IMTI5ovUrD3j_TYS9kKS$Q=(}L~i&it%Z?M(8Bt~Qu0Wi@w z9Z%=i$1N*%A6TiJTsuJ7U##Zzssik??~l%+XEk3Z4ezgs6ub(NZEoN=q=jR9AcrQ- zTnLz`4x{;XOJ}3UH+P%p{AZy@&Z!{xx@4(tnz6_asgIoJ)k1OiLN5G-Vg%xY7e>;k zBmLC^=rHe8IoY}f4(*Zc;A*>dZE*pR8H0jciR3vztS!|#hC4g>-XWzVM9uk*QYY0+ zR-sul&$mVU2WVGdo`XX?5m22I$B*go8ujPflygLebGOu2T?D07_nL5zNckqD2odxl zfXzZEw_m&*|DUm|V}>Y#^z1>dfp*Vyr$N+@(Ka8iS{6g!(+&dc)|6^q-%^|sn8I-*UW{>L#OmI$Gv5H*r!u3%$P{|wIuXV^gLIdTG@NevTt5hl=IlmC6iQoqtI$->@4WLt(fuZ*}42-p!AUbyTov9I0^ zti`z_V%68*w1{FLWHbqm8beNcD&WLg)gwthC70>CKJ(E)Xd}X5EY%zZ%3!6zXZhey zk}l^}Q`*L75Og7rS$_tB;5`r3mJ;jz|B5}@mHT7*Jj8?1jotgtn8Vz3c zXAB3F`m(QCwdPT2USqjCP-yuaA`~PXO2)wfYS75weE&_L9h-{S_G|!jN%K7jL<-VP zuW{X!tZ*y3gUEy;`AN zbm##e=4c{%{+fz*pKTM4EsZgDV8Lv-C7izGCO`7;X$s6@aYS-5X$x*x=1^rJ)z%3K3{I4t3`byCml+v=>5ps2%p4Uh=Q@Xk!rGUw_v60)zsxl`3~ z&hdtGK)juO_Tth7)^iW=P0RQHvN{J&A$j%tvCB&k*f^bG{!zfvYc$~tzeV&v6Jh&H zB^=QVH)C6zFMni8$W(}$b~tM(y|%-^${Li<=0K6S?OoL_<$@s4-n~@P)?)DjoaZWw zn;iiJt#BbF@ADN-(klnm2pmszlXQsNs3Eq&ww-+ykEOgYzM zp9qh_{J?a!IBLL(V8_^OGJ{NL1%nT)P?0VoXT(l#V&DO zUk{Gqg5wM9>}MDCL+s!%GSWEc+6+BHSk*wQSPqWdU|wu&NqR<-HdI(}z?U4bVQf&} zthK9Lk@mkz|EYQi+-nU(f@jaxYHJspz5a32yV^mvG6)!fN!aND60xZ-8heojNhcA2 zTpuoRSr>ve@y}1;R?9K$SDhs`BNzv=58qLIHukkT{csN9TpFV#j%Pp z-!l;Tx}y56M^4V}2HA|>hVwgx`8V;w07E?2%j;XmsArF;xvo&;7v!|Kp*~3XnA|Y) z8%_Fhk?)MH!crOVsSTAeERY>e0=q8TRpGAhL*zjn#j2N(lZF7~@aNahn_M6KDxPXV z#0qzULi4Ln0H?~IB1a%6ULehe92jU;AYFCrrg#9?Zb~HRPQEDko0GTkRkgzdC1;hj zo%OQ1z4+gJ*PWo|q@Do8Kk^FZ`1hx8+F(P6P$h-fY3>0ntAWU%6NbEEO<+wk|Lj_n z{_qHM+PdRrXg&zU-G9~HzUP0Cv7^W9TU`x73X%$1mbCfJ1(fYD!`BCvZ-7Ynk58rM z9UijEb8WD@L9rU%DDEv$)_l=z{0$7-`Q{@_D7AUs;RF+~gMd^05(M|(Ti8%swk?

l{@R*I4Z(Y8S1FD+TT>iy1srVe~n>(*uLK`#7zG!-*RUD zuAoNHy?_QAvP!1H0>SKMyz@v0C`lKNF*0T#ht|_EF)8T}p>Y#0{r!VMurvDCgM4+lR*#tC2MWDv91XAVxFA`1%$ zR$log^%O{P&HbGLEgOcVB8m!z`)2*JKD~XW17LSu+*T|fL-!zf{FEYD*dD)EZDUM? z1d!%3%d6l_MqO5aFodR4Su23n1_3D;mJ4RAw5})tCQ9I40*7aEaY9?d*f=9iD;&Qh zqNNh2OJVy6X-nHzoFk%7jI=uJieU$pUueS}hWTkc?w-x0%O9^2{)42cReD1{Xe&|% z6vT>fjdHah#5QdBu%FqitU$6LXyyy9G+?8l0>@hwF!E@3S9f5P+tKijosY4!{}u~9 z3DaQe7U$kD>jI7lU93z1Y~vrmPpFy0`kyQ6oGWM1A}0&uVk}#C8GjHSBchfNcXc%Q zy*D{R_GQ#1mea?K_!NZ;s`Pz8;%@9f+P84?o2f;ugQmC=2zC(_c+8h)=aKCY;xA*z z6Udm(@Nz!@S_==b80?h}s36V%!;|Wq+xn@84pR|9!iNZ&92O4yP0(zV_ao7i_>%_B zsT6_3P}~5f8jqZW2F+qfF0#W4Jb%bx`i%}2L7X<5ToSo98n6j8piLkmnS9_7^a9|1 zE9*O%KQ}s@)kIiY&e!Z?O`{(*G^>B!W;P35i)hz?WIgIY*?-grmFut-c=>YOyp9wt zh#1|?55OS@;tyIVj_fCU$czygcS$I&)k-VhvVcfW(~8sPXvb%1p4GOpO3M5m=WQsc z0mmrKaDhKo@1tPC0&=Cz;eQg<AV1N4*)IB@WFw{I@KzLU>$O74Y?=k{uxHhmoH^M^H3$SPyKbe{-*99X`^#M$bxh~oN+@Lh# z_a2n+MMo@n!U1o^9pyIYa}cvO5%Lvvf{|gcJ%876Lk}}Qh#&8Oh{g~*(zM7Z9_Pyu zE;4FYW?d@b%0_2C26-6>XlUyL)(eYTDV_np#j-amxq?d0K!Rt4M`ytCS4mM6VH}N7 zvs$83+U{mqaDY?4y*qMTg!{3b_f)yi+1;HY$?V?l7Pkp5r}>;`&-Tv?+~MoB_P%-Z zCacSHGOtU1uoD(ORFz*1t8$TuZ}x=Y2ln)&EXptwiF%Fi;YJ-%`5P-v6JKbdXy|~1 z%ZIV?Ab#}h)zlM0T9wVBJRJ=g52b0>+~e^lhB}PP|6hCW85L#Lb&Ec>t+WwE5e0#^ z6_6~7AQ@AuAfQA60R@o^B01A-n}`Y$lu)Q(kxO!{!az{6WQr&VC9xzFnX0okXusNh z@A$^}#yR(%Gw!WFZ+E{?JYns%=9+V^z16<#+D)vEJmht=3!P$f0!}T&XB>ucU2bCb zt0n0l2(&}QJ%13HxLjW?dDz(z=FJpeS()zPkg!Ic@*Dgs&lC2DmgFG8Hd=d0Dllo? zogsb(Hv6j4pEY&Pg)0(TB1-;Yl0EKM+^%#Y~OEa=lB`A({l>$RZ4KgV&mp{ShP+KN075g z#s%i`;KVEE&ygVT(?BuqD1bvA&{+y6e%MS4y?CSbOV)(M&AlrTc7RMu7_z?}#~fJ;Kytd9wP0aD@Qg48#=2>c z5~c%3!VRBMGE`L1|4@^B=%-GXh)-ZhOYN>g0nMQCq?DV0$&({*bT3T@8S zMx~><(4f{Fa;)HL9v4fe{i9UWZD(aopn6hdzVo#jZ^3-^A8cLYyMYDdPh7E0PC72? z_$6l7wf(Ht-Fb)WmZUSL<{oZbnYnvBK|cwnsMvA9fFLXhU&8VK+|KGh`D!5IW5cNw zu0xqHS%LPK=n!TPpGM=mrKDMpxZ3%69+I(?lOxk%gQcq9s6O~G6 zYSKhIsJFMbt9Icv@TwNG<6X(=>Dop{I5<)AQA7k@D@B|C(4hx)8?fG=z|{ln{7+sJ z6J6}P*>gK%V1y;NXf=(bDjxSPw*6<3#9kG+z9_t#oRlPX(x%9H>@cIV$b~@e=%_Qm zJ$(2SBrJOz{^`@>MvR44C&uz@O4d|g&1ru&(H1!K(6sBu+b#Xlt^0#zpV@g&MUhK< z7^ex$TedWNbWd@4(Nc`GtgT1$Yu90sdax~B%?l!IKQA_J(nUIOMpq1ub7TA0Q-D*7 zD93YcI$m%u^)g*QOPwBS6jA7DNz-?ls*y~|$oO#6wuj_ZI8n|)OLrkEm%wfk)icBo zpJC(`TIi=GO9P_e4xF5v3-fh8=_Si!b_)~*MpBMdE1Z@NTd0h|PF`RNO?-Al*hIb@ zj#hxpM{AP4-%Nk?ih7;8DfBxV^33YE(5cV18%Br=!zqP>PprCkw)h7GG`+dKDeUoM zer|5uru0Sd-z9d~7O4R5uoY)!Zhkhe+kGSoHh{{=%FN8Z^7<#(KE61KMjcKev;=X= zluu`@!Cvqp13l!Ib&J7cwDqtD58^tBEoX$|G`XXC(!FEiY+XFCyT z^mjzKi6Ho$@;i6xxF(up{_%4oEJLg5Rl=J$Z?at{jD-yfHLJpfk1)i4avW(%bEupM z+}1TO?EQOV%!mAl=xEQ^mn|)my_ZLfqK+4edQbRML>T3gq^Gl_S)!kxU#6@Y9PUY? zrP&$WXm=q^ae9qA;EH+=+u7N5IX0>cR=B_CiHJOY{G^jpj`!SK?%@##&U|@8B8g%@^K~d3}ZajMx+vZA^kg8Twc>3Hg%Wu2g&R$ z>?(8`c@!4rG`>tG>y335IF!!AdDl@k-h`^!+7{CYgTeZO?)(>LxZFygc0lAuER`NK zkZdiyJp((lD*dtvhC6=@C-}EUjz5SNrRFUj^8*oZO0u6|`i;-IzaQzovxP$>fAl_I z>~4Gddp=xo?{XlABsq5^M!|ywCy733ev4tnA8Iyb<%sVef5zd^xO5)Gglnri*M9$3 zY)@XXW9JtTQ1|g+6wC&e7nh!@xV1S&hd}CGzQx2GbZoJFL_1Ay;EP*GXecaoxAA2X zNgl?7n$Wr3FPNcK@iOkZ+?9DyABcUB(>{zs+vzyAw=2`U{FLZFr9kXZ%^YlQ*(+aG zR>oGW0Ox~W?4k!w*~!Lc)oB?TdcU3s7cr1dHbL72LSg{uUggQb#pRs;f%W^VMtd)9 z-@bjJkFCU9p764upuJc~TAJ(`^z>_J*s)7_FU_r^;u8`AhiB}f35kgp)YO9EU`WyY z;-W=H-YoY8XD!qIImY?OYwG*tw*4afM`_&8#@jZB`0hNu;gnlh{q}9~2jfU*LwVJA zCL|s-|6JVAd_mI^yFY#5)*pZEJaJC#>4K*Z44XDOQH@mey+sY|j8p5NTZ0%s+#3|#PI;He8 zYejCl_i#ViiV(O-wD<;*eD<85m5wgvyRh^z&-}x)%uItdYvR7#o5e27efwM4TaD#c z{$L#KiGq)JD6Q+od-oR~w9dO*K?#fLIJ?24Ij22x`G@x_&ga}_by_?1(nAefIF~r4 z;~+o(dwx+PQt|r*3jsOz>3i~C3*xjx*g@a4Fb&y^w_MmxF1ROjJJ@ZtVkX~~vhdct&%6V|6Li&#}~s>9|yI(=^9M;<^IOzTq5SSss)~>6jy?m5+AI zxjX7g@o1k-$F6v#2JScBi0u^lzxiU-(+q}GhsyCchJp=nl&Yo6o0LF5nJz8sEV0F; z;BKOandtX7W1b zS>4{OKsW1p^UxBUzFhI-s8wa94LSRMtel6ov`BMUkHk&daI+X3$SzHz(HE(dM`M0J zaHrxfWh!zQd)=!));d%kF{@2&oM#R0G4>aJ=CwEz7Bo`-^rSUueo)M$JRsU(ae7FD zN?N~#T@#=29jdFBPP>%xTddpQAm15??CRZ+1Y{;e| z{+yFEBQ38xIhW{14O44V_8QA>RNd0>J;q6;!TD4ba2$BpGU?_(<*3=YbLVEJ(5bY4 z!KG?O-LZ)syjC=p>kkMhJPfaf|&xqW)57Za8HllSz8GY-SQ2eNAoOe|7M zd{m`kqR5GXce%Zf;fpJ{JWf$y+ixe4@4g9B)Oh%^wQ}!`S8JpOGE6F3hKu=PU4MI_ z5~Zy@-iTKlEuN~?;!^OO`|=syk?wq#OHbfLe?@CD!Oukc%d53kPGAN9&qq-s1imd` z&kKQ@{01jL<%i&mAbWrUQI9&%>|<(xgDJ4*=V&j7KhTL4%`B-#^Uea~$>Y1ye+K zTIJw#yv~ALvsRw{7VOhWdqcf_b|^3|kv!cJ7T^rtqxfRuGCx;%$gS5JO25;l69x#eZk3kIL;K5D7Cla))w$djE9bJBO z=6lRIK*?1x(oQ3U(sfo{n z{Gx0NlPVoFGP`12y7wTUkXc%Cfaccw2h;D6h)hz_a{W&G?=pSwfb(9ks4W z*r+88?^L}UfkNjocHCkoC6kk;ev|wAkXBSaa5eb+-L0I)b#k-ShFgSrutC8MD~HN| z`?0tJ^Twv{Upnv-Cw{&9Bkq_~eDlK!#6JB2iRSyyyIXyp;@@RFtbVW1rI){o?z7m`Bwf0A0e2Uh=pEN(vX{olgs zmCml7EBNid`pQ1|hv4P*uUm*a#vS9>%Vce|Mdf3`;TJx zfT?WW{CnUZCv^!*_4!y?DRhH?dvv>^r5v8Y4X)q1clQ`X*YLidF1-5jYS*DBVUN;9 z3E^_V;YD3_^^oPgGS1f1<6TAPDwq_nTK#vz<+!~(`yVHAp;kptKH}GSVl9MadnP0# zi22Z$MrYlo22aEObsEeYuy;rPFR((`;E=Fx=7B}8=434?1qQS~<o@PNhyRRCDg#mglS5V3t^7`JW&p8j6f-al02He(w#m0F%_1)-)xKFAN~ub zxbMGS`~RKQ^#9T``uEFPS=MnmuKj_Mea$*Xfq<0DGfk_WS+%B%nb*hdmiKgp*x0A{ zj7K@V^hllT4rG`1T$-q8r>vCEx~4q4o)=tPn0Vm{zghoX!hWqrK63t3o7hAGnp1Sn zTky_S+_zZUv}>o-jN@d>|qOmW12c1W60K#BEF(!gJDWpG%(JnmdmLTk~l znCY0vB&P&7$~UP1CsMD9hA{PoPnl z571Bhu+`3;KP_3l)owHMm&a_z?zR&+N+ng;^^1;#i(hG{8R8 zi!P{bRD2F!!#1VCLbvl-?3ioB(RZSQv%)HXaTFoV*VvU0;c>CTwM>}G(`|jrh4I(s zdzJ-cCtTpFE%UW2Kyk)$#gzn^=Vbpxv zl~nxY%_cGT>Cfzox&S#lA*^&KJGMx6ZbOJz+{_}n2k5AN=&F*O!{Vl2DX8?y^amX2 zYfu)g37Ny<#O}?~q8{M-JoLHpNl!s@yl4$9&h;HrU=$X3%C6xVkWQjMI$7qK28y}lN#rSn@ zRKPp=fYtf|1zx>uU&h*QTZGluZh z&OAVzt~|qSp7JxRz+rnK80gsXNh2eO4WA9EF@$6fF*eHr)vql+jFX> z%?#%yprU@>f7B-PJ?{r-&CDBLs353xy*l#Z5M2QiUoYmf970nM@p9)i5^KR1Y#8G5 zQTja+YR`;A+RmxQKRuxz_t&>0I?2ISD>)kPCggdB6S|fJlWY&i@u#H^Ij}2>HhpkUgbnit6|h~EH5<=vRp&yddz%l>EaWpr5<4+ zG>H!DtWhp+vc<1Fqgt0gGUh3`U*sXV`WEh(N(p!VBGq?q|IH8@!sckr zqj3BH2qAOfs8vhpNoKi~R*nN@%i6uSyk@)dREridMN-ZuS4I|YIaNK=a9FUc4>bl2 zs=3gn1_SeWU>q)DZmvJrYW3*`qo-Ro+>oH`IpJ><5aUedCru}ankwJ{$A-FU8&RSi zR1u++3VI0Db@Dx*NqyY$upmwe>r1)BWwDCAJ0yEN9oqkzJyLsYKNmm(>Dd^O$-K^+ zRp!484W7_bF;AO@!`D7P&-i$U16ZpYy|3~qu^xQ@g1j&LEYnPBLq|BFvA%eDwC*g% ze%IAV(&8|E17Gwu1>o(ImpzO@@CX)6&;JcFc1g6BN8{VSvTCJMM(x-!b0K4IdVGE? z?}10*;nxRX%}b$va4dH%rgE;BfSVqD>X~WyB>R~2Xq)wIhSN}6hDolgn!ADfP(sMe z8goZu@2+^t1mYHIz3AeMUxi=jUvyW+#kS(5AeRQ*(=l{Q7$y3P6rKf;68Pdl-*Tgx z0%yrwnP_FD1(yN&^p_N)Wy>&1yxBw#OgLq>f*fMi9E`$N?cxxbFBijvPwCn4s>my| zeY6Ohn=B9J#yNZ}DchxgO_1E=lta$mq@ovNo94JZRy#RORj-*ZtyaUEr^p9DqV7+I zPC-xsqR&kX4W2%EV3Y`@AY*x^BVsH)!gdyFZ@C)z47DG3zw@#s@#6DL3M;G543qDmVl@Hx$TfmxU5oTkd}!Zn z3BxOpBDXl2H8CLSBZaq}{PaF!EVrY@;Q&^@(C4)vBs2Q*9EpL_Bjw}+sfxoo0DBqkYUFbA?$$JiOv9T{y~=^-cr8mb=ppij+2WQ2bGl zhQjLi-6)`Xf&1{avuP#I10}nUxzCOpXdC9=xGK9m-B@F+MVd?*O8B|>m)R2Q|`vxPz!^`1_(g>ANqoU8X zkS8BRmAwo?DQV1mJAnD;m^Nw7b9Et%vQ-m=yCqI99&T&oWSL|SutC83_ z(o&8K`7yPe!!7_4xkxwsol$vDGEubVX$R0!{SQuVO>*iyYR4Q$3jtQ+!tpZyAt{H! zrXd+6=89Iz?~FA}dmqFA+xH|IE~=xVR)!i)WDu!dqJ@q_>LU_-YO&E8a0HG~Ou6R7 zoZr{CNFpKq&^qL`9*1rI)r2mmHE{`+Tf`X5K657}+xu~hBNu9ys68KA9 zjqDqGp)AKNFI5@QS%9%M7BVb8Mp*`q){Kzt@Cx{6R$vm%E_;mS?E17OE^eoBwVL|P z?xU@jci0tA{I0F4P!X_ahh&$dMwm^46$9$PK?;e^s&n}w-g`}4PQ@adk!MCjj>|9= zfJ7kJi{ct4lp{m}5jp2U?R2OM#4V4SO+4pbPAnH&iQs`3PuF4>W_pW~nfjXng}JoM z#}$hh!i6hI&WC2J)1ij#QJ_x*XZ>7=aBPlkR$q;OjYLPPs)LYbRf@rPRXwR+lZHeF3zYL7U%}NUvI#0x9 zmb+Z;<_Qz&%H#wJJe8ZWQ`JXu#&=*(icSQ~Te0=bcl6N1r#3TyYpjx|CgEeBjHNEt z`OuHh7g|fM`!H|jlonS#_VKSw&b#h2qkB*`GzLmES)&B2f6~7U^)HKav`X2(a~w$j zk@GDnAPSw<9aR7*BQQ3s^AKg7h?T74++mX!Jqc(;zyCH(&%&w0DJ?zJZfNig==Qgc zeR^=RW&T3k3o!tvNvg|QvhrTsf;#D`8XQ=C^iJbqLNKCT#h`KuN{n_`##m{0W zF?tKFFfGuN+1E-@K6!a!^_{H7#cDekmCEO^0Ya-rX9;u={o_T{Ap8Du)1u+P-D1B{ zqStNORSKof7!t7C5|l5;jbej@W-xNNg7TWRjz-R&_tB81)I>#$6}v$HR{`89ThBsE zUgiir`?+lc$O1z4RDgZ{kSQt4SjhNx{9n1hEMo0U=xp1PetsXGPsXh@569U{~P(j6bJ zU{SP;M_+qb3Z|7tI1?X>nfwmnCf8nBFqA(zp5GrdddEjaAm}MbJQvx3w@l1X!OYKX z6zgu)a=$Wx*lGMYbVPxux)DV&bAj7?ry5WBLU0^hBm%>RICxOpl4$eTg@f>GI?=}> zc~S1UUV`(QX$RYhT`7bw8)Hg=5y~@=(B;x_tRcsnoPb{nS_4<@7`P0{_rg7~64aBJ zwl1)`bfj2b26e@H>C0V(02PV$c-3W0(V^wigtx&44}LfKb44wr$x1=pkZu5#p@IB7 z)a9AHl0bycfs}si&>f~@_;@+y0xPPxqAL~Gx^U=)81x;{h1u!`g<^(b)Ab(HpFbc{ zPKk;N3z>Q>t@a4WWv=fdqf%;y4OF@UI%ffo+##18!cr| zw!nvlHOBw(aQ~SWS5PCL!79~KIfzg}KU>M%>4bRSoQBy4+6+-D$oBU@E70uV#I>nfn*d^|SFgx!wI==0KQ?J_8Iybq62C>OdE zfgPh7o@!#QY1yw-3$+P;e=jblvqe?$n?`d$xMxK%+J}SOET&UHGUM$FgkI7=a$mU6gkOv_}f2YGs~-hs@Mz==!X1US~+!C7i7<-hasP z?Q)ZbT8(W8L5_-SU8?%5c0Z>QKx!?=(Wmjzg@|}E^rAHj)Fru2J?*QMJF44idGe^- zE6jH=y}r-O#uJuz1`sdTiY8N=2}UKZkSVh6`(PLDZ4@31=8zOYMJ#g?Dvy@LMP^Jd z<%Iw2NFl@f^V7S7o}^*a;z>HUU9iS80L)at z`rB&*yM&c5CWw0Rixhr-hUhipwwG5;ZO%Ut=ie$n*IO*Kz=Wmk>n4m87O6x@*pFsZ zv{(jM>|M*WwK_@p{a-mlRlrrXoP^d!krlPVt_wr>=ROR2&O#6(y$~FF4&`i%`*VeJ zDgB^ciQ`37vI$CMn-~CPnv+WWD%jZAI<7MN{(0f-1c`UkE}?fJv`WHggf{Q_l;wnY zIqcxI+bmOTqK11>_0@HQ2G<`j{3oyTSUn4?QZd1@@5+LRyt-frum@266hx)hGtRL0GdKcBJ|1x?L;6 zDkN=zv?W-o$=i(SC|iw1M#VSZZag55#l7tFY5=lC$;l!$CyaMOCwkj4knHtv%vg=V z)6yl>{Qy?e)8>Mev=@}>oMFCY;tj|t15H|;A0bjQ?*zZ* zAjzU{l6Aq0li1=F$bM9yR&KU4a}qe;(6N@h*Xuc&EUK}3avxN!v8=@rU?a!f4O}90 znw|3gPHoa>*%puTq!8%~BY`)cD|9_LXb1iWEiQfgYF0bdrUPl(ng$-&g|m8=#YPd} z2`xL$#JN*Vj;5(=049T_F*_fBU__4E_5bV}p7;QqDHosufkYiPtet*Y7f)ZYoT&QG zVv0{Klf-<;*%nd*X}RQNRWHCG!o3k8>jZd3;c>llDOPLk9@sI%K3v#=){&r#s1Am; zRQG5;O;3k zpbgv&LV6RTJ-^RyH!MS4H)vG}4pG>JU!Is0t4TY4-Uf(V2h_^7rcR>7Y4x=6 zAwB|W!Ls(+GT1pzK^_=6YKtBGx#sAgPIMasjDJl@1faPU@X@gY$_-3$ImuSV3cbE- z`=0rW2nec09~1MajqS6ri65Ds1o1GxwjWWhL`1oMI!7L)qx!7cg?yLm=e_agAG09s zOtlMehwhlv5bs-9%(~iKpdzMmjrRcV$ykZ)msj7)wlT#uTaHh7r)j84@z@p&ghv-z z5r`5|smxe*XJiSGA=e3o$@wSi;7^pbp`6vZ726py$WCot7?dn|9QrbXmn+tLVJK&q z3Xrsx-v{#3{Vfu0ajGWkeNTLdHlc^>+dkIthGdMo)>J2-V7Zw~s&4+mxrtLEURb?e zzgMAJ?5?aRFh*z_W}9E!rQi6I^wGy)wc3?el`_J*ERd zAd27F%K2p0yCFFrJRmm#dAvv!NehYK%Gco=%hd2*7bi2GzaMzhGrUYJOY&HQ1V>$p9BWYzUbp`aS@E8J!XiB36&Surg%OGhbvk>9y(d#;4 z4z*Hz-2mA27#yBJVcM5&KT`^@;&M_9U>_}yaqvdZN8gs zvRwg<+_V*m=lBI7Vc~8g*cc=%WULP4zqyHEpUWfkHF4Wm^{Sb$jSAg%ko(%7$qpoV zEC9+RgNMft!cwGYAF0QCQLFGG34+-b z07&M!i5+~ZLMe8@Z=hyk0^UMad0oapxPCeG_z`K2vyeSyeh=EaXYKmU@5l%3#ybn_ zVXLPyf;TNCQrgL~)lxXu1mr<34p%e3NCc^|$tit_j8X+`A(e@DjCrQtUgF0qrd zYp}Sd_h)JTvx3^G_Ygm0c9;%mC|bBJbk}EODAb;X>{~WB(Vw->!w@KpOcQ_bQd4$= zAY&KHIKAddSLsq=#S-|ud6X+fMaQZm#>Y@X(rq|Ce~O5pwFea#dGH^B!1FswLUgO2 z>U%fxbQ7E!RV2$?K>Ud=1Qb)cj_vX`1g0LBxYQhNz1I4PpEpA76$DSk^ZfjLvNy^x zUMsSWdfEN!w1>9t_)X)<)1&Q22J3J}+T-AEvd(S4-oEw=&?BV)0UnI0>lo_sQ`CGG zG!p#h3O$3siD@dyBSAKQZXHnsHUq7BU8XJUJCO%WqJ>-t?vK9ulgu^bbl2zmyE@O} zY@n)ybu+;G{-Dbd^DY0ayH&Uwe~tJkJA(P>a?H=z{DHw%273vqCj-DRdz7mY!&Ske zA%3@*@u}J=zj%|1pbSt)&5CB?j~PuYe?o~d7fi$AyTnSo#Tdv!gxHC&VU334ezO+o zC-fe7hc2I|eQCa1$H)rEOChovKBj4Lv8yGJulGT*&sfou4Za0a9Bn{L8Pp%)TdD z>L=*P-UQ6)^&(1`(I;;p3EHg;NbsjCkmpJ0DIpiVY=c#k#*>unVe7(|=@vx`Yu2v6 z_TD;_Pc41wGy{mEhhuj_$p-}lk|*XMHMP%mHW*nrJf7 z;VU7=o@b~ApJ$#!;^gcpw|mn3!-!=;o6I^p0ZB`Zl_i$PtXw|00w@A49E+n z83lz_(`b>^+0536#D?6$a2Lw?@%&1TQ{MB;~xa@TW#!vWp4~*r3yZgv@<*(d1zlZ z)Z<6QZ-E8~9~d&vJY z7lI62UwtZzj(kyF?isw6MR*X>SJ z2r3%i?1|dSMGv_jIXozzAcGBS|B5(6DjZ7 z`;be;uJ$u}Fc=VKlWItmwk6V9R+QBcWs&=^O48Px`MQ787Uge&dO`HYQP)?BrS5*-nSBAY`bB1}xex2Kue?PBxE6tJ}pZRyDpz`sNbcnG4Q)M3wdd zYI2iB;$NS?XgRPsT+k1M1uY}89hBy4p#fiSxCIfuE1$TFUPxtzUi>HsV{Fi~Trz9u z1}>9>A+Y)r*~h-cgD)@YEzF9>02`$=c&zBqkz&u!m4BTTrDW@i_WQbAYW z-YEkd(fN!%1_K$K=$$~DED4!@2QZ$x;h)=}eQ$#yo@Za(pDWk<+cVfcKf6it>vd?F zEldw(G;8Y*GzIRJI*iob2+?t516hLbs7V4dfI)7Rp~`zFtCrOJ72H0uuyyroYgs}G z-MwjgcQzz4dq85>m%*c%rEOB&`{$-UWbC2YH(fka1}RZ9#e_}d^6u8l4k}Arp zuB>Zzh;+mZ#gU+}d(;7*T^RT~0bV zV4ju)*VG)jl@!jCM}&%Uly`&&A}tV2b7g>3U5ZMkxoU&zEf7R?ts%~ILwZZ^??_ob zZ;?j?4MdCtPqqRE4EjNoux^@I_0fJo#>Ula5HHB~=z)+CXjT9`)f_7ckRuY3FmZAD zQ>fYs6~04FR_w_w#HxTiw9PEWNm~f$hFXeRl!WjM5E_82IoPj#JwsTNkbeg%*UE>z z4BE6k;5zELIgDBeYnK8r>FVV?bgu3Ip$ys2Gup35orVB-1{yJH-R9tU!anHf?ys1h zK)sBfqC?YN&PMuj`xpq@$<`joP`2;noogldnFbNB0UEVOLE2^f^4Oe2kLQ$SC=*CL zvq%{bBu0>tE#DYa#TBK}-rhbuaSmSEibDgmH(?oPh+un25vP$)8iC53{?%*$wZu=U zvGMChTfUa(aq@B<>j=fbAeRGvothyMryG>TtlM5H(EvgO*+A0}L%Dq8^|}?*ol(KX zfzXFZlud3@1};ocr<~Sm#0{F9EppG9(m+|%W$6ZuQO|^9$N~Rz;bg39-+iHv=_F(; zK*lnMVfDU`D>4}L+hOPYt0F{$kq8KqT(OX@T^hnD(9VYQh^)TS`eS5q^>1_F%}PbB z2&t$q7g0(215!v44}atgq)>~1uAPl>HxhCXr)ctai)8h=Pm2(+JqH*{DC!cf5y8q* z0YPK}jB~p4-PhT-dLNs`?qQbwqF6hdcjM!md~o-$J9e(VTuA z>#Zh1*gJ?cOKrmpIGU7^0!uewWf&Fe*G)dYxg9nv(Rt&oW!*gTEbv9&I061O8Bvq7?|lM! z#;{8l7xvCC2)$pLpPFjfwR*eFq5pZ+DUhYi-WYZ;&%O)i0)3} z;pJyv=)=Rm^)(y3V(kBB{WsqQQxv-)&n9Ui!zW>C4m_acfVegIbqNr*D?B=|#eFb# zbRzsqD?Bw&yzT?deG0tXwG#*lpnHGvrjTXl>dl!Kpl)vEQ}YIyPn4XH7(Gqx@rkLx zAvYv4h!+B?l(dC>)pjjZ#j=Y!IZ*XHDgNg-e%=d>xN@i=v9ii$iWbNFpyHhZmaH5)C3OoIBAOuwE6t?=w-{-sWGxmWC**fP6y|ez zv@VlGc*xBaAQ@arLTYE4j{fTRi3|Vd67vCMnBZfa{Qwi_xKk&qM1zssUg>~}qLPzS zdzc8%FI*1QVl*-uyzsFI>Z$cr~(Zui-8Eu-f>=L)C&nANl{?S^c=G?^51jhx~5zAr}v>IP}u^3 z534hMe{*H((@a1>z)uvWgQT3Gk26O|b!FTzFM?%+1V-4wrZkv)S%CnEYbOwA^wP-4 zs*2>5_Ss@ESD^?Vmi@ZGhY1KXIm&?qfR~6nOAz zYFR$EKqc_c{Q33dId6-*C1|>p>*k|9~^5UoH25{@50AVH4) z!p(aQA3$6eYG;AN-Vfm!>QymCsSB3ucHM6X7D7Y~K3m$~J52;uI=j4XHAgFY|GlV( z!(K)(^B0JWiOj;Hkwv~wX&lZuyJ$4CYPfk8L1qNBX9|WxU#_rL@{6N85WSnWn3^>9 z=yGJpF2pFlWBL}Zfhj8c!IZl4$-W728-W9%4lhJhvDaIblt68lz?%x+KZ~hsp*Q3l|a?6h%cybA5B* z*$x}?%oBki3P8nvk6H9~#0M%f;GG46nNtqI43PO``p`OoS|hki=+ZW1pn($Bn$iV> zo93wl>1gN zAFK@P*+5ejfaX>=SV0P{4q4{{(wfl2mprI{IuH5)xCpkxyRBpSNyGRWf{OZiwi%EJ zO5={-dIl&?MNV_|4`~0Z>pvd#0~V09)W|>;M1& literal 0 HcmV?d00001 From 321c9060312d72115098a81d1b734868ba42cb77 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Wed, 3 Jun 2026 14:46:43 +0200 Subject: [PATCH 13/26] =?UTF-8?q?Fix=20CI:=20stop=20--cov=20from=20double-?= =?UTF-8?q?importing=20numpy=20(fatal=20on=20numpy=20=E2=89=A52.4)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .github/workflows/unit-tests.yml | 10 ++++++++-- pyproject.toml | 9 ++++----- 2 files changed, 12 insertions(+), 7 deletions(-) diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index 59330fd..ef5f862 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -35,9 +35,15 @@ jobs: python -m pip install -e ".[test]" python -m pip install --force-reinstall --no-deps torch --extra-index-url https://download.pytorch.org/whl/cpu - - name: Run tests with coverage + - name: Run tests run: | - pytest tests/ -vv --tb=long --cov-report=xml + pytest tests/ -vv --tb=long + + - name: Generate coverage for Codecov + if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.11' + continue-on-error: true + run: | + pytest tests/ --cov --cov-report=xml - name: Upload coverage reports to Codecov if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.11' diff --git a/pyproject.toml b/pyproject.toml index 7a610ae..9ce9349 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -89,14 +89,13 @@ build-backend = "setuptools.build_meta" [tool.pytest.ini_options] testpaths = ["tests"] -# restrict to models and utils -addopts = "--cov=hypertrees.models --cov=hypertrees.utils --cov-report=term-missing" +addopts = "--import-mode=importlib" [tool.coverage.run] branch = true -source = [ - "hypertrees/models", - "hypertrees/utils.py", +source_pkgs = [ + "hypertrees.models", + "hypertrees.utils", ] [tool.coverage.report] From 75ca4418dcb736e81359542053cb84fa2932e077 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Wed, 3 Jun 2026 15:13:57 +0200 Subject: [PATCH 14/26] Fix Run coverage in dedicated job with pytrace tracer to restore Codecov reports --- .github/workflows/unit-tests.yml | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index ef5f862..71728f7 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -42,11 +42,13 @@ jobs: - name: Generate coverage for Codecov if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.11' continue-on-error: true + env: + COVERAGE_CORE: pytrace run: | - pytest tests/ --cov --cov-report=xml + pytest tests/ --cov=hypertrees.models --cov=hypertrees.utils --cov-report=xml - name: Upload coverage reports to Codecov if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.11' uses: codecov/codecov-action@v5 env: - CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} + CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} \ No newline at end of file From 2deef5e67a041fe3584e724bec5f875b2ac15503 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Wed, 3 Jun 2026 15:23:45 +0200 Subject: [PATCH 15/26] Refactor coverage configuration and enhance tests for _align_scores and interval_columns --- .github/workflows/unit-tests.yml | 2 +- pyproject.toml | 5 +-- tests/test_conformal.py | 53 ++++++++++++++++++++++++++++++++ 3 files changed, 55 insertions(+), 5 deletions(-) diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index 71728f7..1225755 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -45,7 +45,7 @@ jobs: env: COVERAGE_CORE: pytrace run: | - pytest tests/ --cov=hypertrees.models --cov=hypertrees.utils --cov-report=xml + pytest tests/ --cov=hypertrees --cov-report=xml - name: Upload coverage reports to Codecov if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.11' diff --git a/pyproject.toml b/pyproject.toml index 9ce9349..ff0d85d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -93,10 +93,7 @@ addopts = "--import-mode=importlib" [tool.coverage.run] branch = true -source_pkgs = [ - "hypertrees.models", - "hypertrees.utils", -] +source_pkgs = ["hypertrees"] [tool.coverage.report] show_missing = true diff --git a/tests/test_conformal.py b/tests/test_conformal.py index 91c99eb..366a97d 100644 --- a/tests/test_conformal.py +++ b/tests/test_conformal.py @@ -9,6 +9,7 @@ from hypertrees.conformal import ( interval_columns, rolling_origin_residuals, + _align_scores, _distribution_bands, _error_bands, ) @@ -40,6 +41,58 @@ def test_distribution_vs_error_bands_symmetry(): assert np.all(d90[1] >= d80[1] - 1e-9) # upper bound wider +def test_align_scores_reorders_series_axis(): + """_align_scores should permute the series axis to match target_order.""" + # scores[:, i, :] == i so we can track where each series lands + scores = np.stack([np.full((2, 3), i) for i in range(3)], axis=1) # (2, 3, 3) + out = _align_scores(scores, cal_order=[0, 1, 2], target_order=[2, 0, 1]) + assert np.all(out[:, 0, :] == 2) + assert np.all(out[:, 1, :] == 0) + assert np.all(out[:, 2, :] == 1) + + +def test_align_scores_noop_when_orders_match(): + """_align_scores should return scores unchanged when orders are identical.""" + scores = np.ones((2, 3, 3)) + out = _align_scores(scores, cal_order=[0, 1, 2], target_order=[0, 1, 2]) + assert out is scores + + +def test_align_scores_raises_on_missing_series(): + """_align_scores should raise if a target series wasn't calibrated.""" + scores = np.ones((2, 2, 3)) + with pytest.raises(ValueError, match="not seen during conformal calibration"): + _align_scores(scores, cal_order=[0, 1], target_order=[0, 99]) + + +def test_interval_columns_rejects_bad_level(): + """interval_columns should reject levels outside (0, 100).""" + with pytest.raises(ValueError, match=r"level values must be in \(0, 100\)"): + interval_columns( + point=np.zeros((1, 2)), + scores=np.ones((3, 1, 2)), + levels=[100], + method="conformal_error", + model_name="M", + cal_order=[0], + target_order=[0], + ) + + +def test_interval_columns_rejects_bad_method(): + """interval_columns should reject an unknown method.""" + with pytest.raises(ValueError, match="method must be one of"): + interval_columns( + point=np.zeros((1, 2)), + scores=np.ones((3, 1, 2)), + levels=[90], + method="bogus", + model_name="M", + cal_order=[0], + target_order=[0], + ) + + def test_interval_columns_naming_and_ordering(): point = np.zeros((2, 3)) scores = np.ones((4, 2, 3)) From f0682a838c5c17d5af7ece8d4cb45fa5cf86cb41 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Wed, 3 Jun 2026 15:29:22 +0200 Subject: [PATCH 16/26] Update claude configuration to use new model and increase max turns --- .github/workflows/claude-code-review.yml | 9 +++++++-- .github/workflows/claude.yml | 6 +++--- 2 files changed, 10 insertions(+), 5 deletions(-) diff --git a/.github/workflows/claude-code-review.yml b/.github/workflows/claude-code-review.yml index fb48614..d5afcf4 100644 --- a/.github/workflows/claude-code-review.yml +++ b/.github/workflows/claude-code-review.yml @@ -37,6 +37,11 @@ jobs: - New or changed logic that lacks corresponding test coverage Do NOT flag minor style or formatting issues that a linter or formatter would catch. + + Ignore Jupyter notebooks entirely: do NOT read, review, or comment on any + `*.ipynb` files. When inspecting the diff, exclude them, e.g. + `gh pr diff ${{ github.event.pull_request.number }} -- ':!*.ipynb'`. + If no substantive issues are found, post a short approval comment. The PR branch is already checked out. @@ -45,6 +50,6 @@ jobs: Only post GitHub comments, do not submit review text as messages. claude_args: | - --model claude-sonnet-4-6 - --max-turns 10 + --model claude-opus-4-6 + --max-turns 20 --allowedTools "mcp__github_inline_comment__create_inline_comment,Bash(gh pr comment:*),Bash(gh pr diff:*),Bash(gh pr view:*)" \ No newline at end of file diff --git a/.github/workflows/claude.yml b/.github/workflows/claude.yml index c50fe6c..8f020dc 100644 --- a/.github/workflows/claude.yml +++ b/.github/workflows/claude.yml @@ -41,6 +41,6 @@ jobs: actions: read claude_args: | - --model claude-sonnet-4-6 - --max-turns 10 - --allowedTools "Edit,Read,Write,Bash(uv run pytest:*),Bash(uv run ruff check:*),Bash(gh:*),Bash(git:*)" \ No newline at end of file + --model claude-opus-4-6 + --max-turns 20 + --allowedTools "Edit,Read,Write,Bash(python -m pip install:*),Bash(pytest:*),Bash(flake8:*),Bash(gh:*),Bash(git:*)" \ No newline at end of file From 38aabd95ffca76e2d4fdc860d6adaf3c7b08e474 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Wed, 3 Jun 2026 15:48:20 +0200 Subject: [PATCH 17/26] Add NOTICE file for third-party attributions and update README with Nixtla references --- NOTICE | 27 +++++++++++++++++++++++++++ README.md | 2 +- 2 files changed, 28 insertions(+), 1 deletion(-) create mode 100644 NOTICE diff --git a/NOTICE b/NOTICE new file mode 100644 index 0000000..9cef0ba --- /dev/null +++ b/NOTICE @@ -0,0 +1,27 @@ +Hyper-Trees +Copyright 2026 Alexander März + +Licensed under the Apache License, Version 2.0, with the Commons Clause License +Condition v1.0. See the LICENSE file for the full terms. + +------------------------------------------------------------------------------ +Third-party attributions +------------------------------------------------------------------------------ + +This product includes software adapted from the Nixtla open-source forecasting +libraries, each licensed under the Apache License, Version 2.0: + + - statsforecast https://github.com/Nixtla/statsforecast + - mlforecast https://github.com/Nixtla/mlforecast + - neuralforecast https://github.com/Nixtla/neuralforecast + +The conformal prediction interval implementation in hypertrees/conformal.py is +adapted from these libraries. Specifically, the rolling-origin calibration +procedure, the two interval-construction methods ("conformal_distribution" and +"conformal_error"), the per-horizon-step quantile logic, and the +"-lo-" / "-hi-" output column naming convention +follow Nixtla's design. The code has been modified from the originals. + +A copy of the Apache License, Version 2.0, is available at: + + http://www.apache.org/licenses/LICENSE-2.0 \ No newline at end of file diff --git a/README.md b/README.md index 09ca71f..2a71b15 100644 --- a/README.md +++ b/README.md @@ -164,7 +164,7 @@ This work draws on and integrates methods and implementations from the following - [**LightGBM**](https://github.com/microsoft/LightGBM) – Gradient boosting framework for efficient tree-based learning. - [**PyTorch**](https://github.com/pytorch/pytorch) – Deep learning framework for tensor computation and neural network modeling. -- [**Nixtla**](https://github.com/Nixtla) – Open Source Time Series Ecosystem. +- [**Nixtla**](https://github.com/Nixtla) – Open Source Time Series Ecosystem. The conformal prediction intervals in `hypertrees/conformal.py` are adapted from Nixtla's [statsforecast](https://github.com/Nixtla/statsforecast), [mlforecast](https://github.com/Nixtla/mlforecast), and [neuralforecast](https://github.com/Nixtla/neuralforecast) (Apache-2.0); see [`NOTICE`](NOTICE). - [**sktime**](https://github.com/sktime/sktime) – A unified framework for machine learning with time series. - [**GluonTS**](https://github.com/awslabs/gluonts) – Probabilistic time series modeling and forecasting with deep learning. From 412ab1f7a623f2489864988f0aecfe8e71fbca92 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Wed, 3 Jun 2026 15:49:59 +0200 Subject: [PATCH 18/26] Rename NOTICE to THIRD_PARTY_NOTICES and update README with new link reference --- README.md | 2 +- NOTICE => THIRD_PARTY_NOTICES | 0 2 files changed, 1 insertion(+), 1 deletion(-) rename NOTICE => THIRD_PARTY_NOTICES (100%) diff --git a/README.md b/README.md index 2a71b15..021516f 100644 --- a/README.md +++ b/README.md @@ -164,7 +164,7 @@ This work draws on and integrates methods and implementations from the following - [**LightGBM**](https://github.com/microsoft/LightGBM) – Gradient boosting framework for efficient tree-based learning. - [**PyTorch**](https://github.com/pytorch/pytorch) – Deep learning framework for tensor computation and neural network modeling. -- [**Nixtla**](https://github.com/Nixtla) – Open Source Time Series Ecosystem. The conformal prediction intervals in `hypertrees/conformal.py` are adapted from Nixtla's [statsforecast](https://github.com/Nixtla/statsforecast), [mlforecast](https://github.com/Nixtla/mlforecast), and [neuralforecast](https://github.com/Nixtla/neuralforecast) (Apache-2.0); see [`NOTICE`](NOTICE). +- [**Nixtla**](https://github.com/Nixtla) – Open Source Time Series Ecosystem. The conformal prediction intervals in `hypertrees/conformal.py` are adapted from Nixtla's [statsforecast](https://github.com/Nixtla/statsforecast), [mlforecast](https://github.com/Nixtla/mlforecast), and [neuralforecast](https://github.com/Nixtla/neuralforecast) (Apache-2.0); see [`NOTICE`](THIRD_PARTY_NOTICES). - [**sktime**](https://github.com/sktime/sktime) – A unified framework for machine learning with time series. - [**GluonTS**](https://github.com/awslabs/gluonts) – Probabilistic time series modeling and forecasting with deep learning. diff --git a/NOTICE b/THIRD_PARTY_NOTICES similarity index 100% rename from NOTICE rename to THIRD_PARTY_NOTICES From bf646c832f3d5c72884316e2add2c0e9e58e3ca7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Wed, 3 Jun 2026 15:52:34 +0200 Subject: [PATCH 19/26] Update README to reference THIRD_PARTY_NOTICES instead of NOTICE for Nixtla attributions --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 021516f..b63430c 100644 --- a/README.md +++ b/README.md @@ -164,7 +164,7 @@ This work draws on and integrates methods and implementations from the following - [**LightGBM**](https://github.com/microsoft/LightGBM) – Gradient boosting framework for efficient tree-based learning. - [**PyTorch**](https://github.com/pytorch/pytorch) – Deep learning framework for tensor computation and neural network modeling. -- [**Nixtla**](https://github.com/Nixtla) – Open Source Time Series Ecosystem. The conformal prediction intervals in `hypertrees/conformal.py` are adapted from Nixtla's [statsforecast](https://github.com/Nixtla/statsforecast), [mlforecast](https://github.com/Nixtla/mlforecast), and [neuralforecast](https://github.com/Nixtla/neuralforecast) (Apache-2.0); see [`NOTICE`](THIRD_PARTY_NOTICES). +- [**Nixtla**](https://github.com/Nixtla) – Open Source Time Series Ecosystem. The conformal prediction intervals in `hypertrees/conformal.py` are adapted from Nixtla's [statsforecast](https://github.com/Nixtla/statsforecast), [mlforecast](https://github.com/Nixtla/mlforecast), and [neuralforecast](https://github.com/Nixtla/neuralforecast) (Apache-2.0); see [`THIRD_PARTY_NOTICES`](THIRD_PARTY_NOTICES). - [**sktime**](https://github.com/sktime/sktime) – A unified framework for machine learning with time series. - [**GluonTS**](https://github.com/awslabs/gluonts) – Probabilistic time series modeling and forecasting with deep learning. From b2924a0d9fa5e20dd7f518beb0fbafeae9e4feac Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Mon, 8 Jun 2026 10:53:20 +0200 Subject: [PATCH 20/26] Refactor README to enhance layout and improve visibility of project information --- README.md | 59 ++++++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 48 insertions(+), 11 deletions(-) diff --git a/README.md b/README.md index b63430c..50d5dfa 100644 --- a/README.md +++ b/README.md @@ -1,14 +1,51 @@ -

- -| | **[Release Notes](https://github.com/StatMixedML/Hyper-Trees/releases)** | -|----------------------|---| -| **Open Source** | [![License: Apache 2.0 + Commons Clause](https://img.shields.io/badge/License-Apache_2.0_with_Commons_Clause-yellow.svg)](LICENSE) | -| **CI/CD** | [![github-actions](https://img.shields.io/github/actions/workflow/status/StatMixedML/Hyper-Trees/unit-tests.yml?logo=github)](https://github.com/StatMixedML/Hyper-Trees/actions/workflows/unit-tests.yml) Code coverage status badge | -| **Package** | [![!pypi](https://img.shields.io/pypi/v/hypertrees-forecasting?color=orange)](https://pypi.org/project/hypertrees-forecasting/) [![!python-versions](https://img.shields.io/pypi/pyversions/hypertrees-forecasting)](https://www.python.org/) | -| **Downloads** | ![Pepy Total Downloads](https://img.shields.io/pepy/dt/hypertrees-forecasting?label=PyPI%20Downloads&color=green) | -| **Paper** | [![Arxiv link](https://img.shields.io/badge/arXiv-Forecasting%20with%20Hyper--Trees-color=brightgreen)](https://arxiv.org/pdf/2405.07836) | - -

+ + + + +
+

Hyper-Trees

+

GBDTs as Hyper-Models for Classical Forecasting Models

+ + + + + + + + + + + + + + + + + + + + + + + + + +
Open Source + License: Apache 2.0 with Commons Clause +
CI/CD + Unit Tests + Code Coverage +
Package + PyPI Version + Python Versions +
Downloads + PyPI Downloads +
Paper + arXiv +
Release + Release Notes +
+
--- From d8bc8f0aa938a47d9423721c199161166f13c461 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Mon, 8 Jun 2026 11:18:31 +0200 Subject: [PATCH 21/26] Update README to drop 'value' column from test dataset preparation --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 50d5dfa..f089dd1 100644 --- a/README.md +++ b/README.md @@ -106,7 +106,7 @@ dta["month"] = dta["date"].dt.month # Split the data into training and testing sets, reserving the last 12 months for testing fcst_h = 12 -test = dta.tail(fcst_h) +test = dta.tail(fcst_h).drop(columns="value") train = dta.drop(test.index) # Initialize an AR-12 model for monthly data, calibrate conformal intervals, and forecast From 8c186ed38e6288c04e5fa1bde6726056e71568b4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Wed, 10 Jun 2026 16:44:29 +0200 Subject: [PATCH 22/26] Fix training-state bugs; add analytic AR Hessian and ETS init options - Fix HyperTreeNetAR training a hidden model copy (lgb.train params deepcopy): new NoDeepcopyObjective binds objectives to the live instance, replacing the class-level network state that leaked weights across instances - HyperTreeAR: add hessian_method="analytic" (new default), closed-form grad/Hessian via the AR fit's linearity - HyperTreeETS: add seasonal_init="classical"|"legacy" (statsforecast-style init vs. verbatim pre-0.2.0; experiments default to legacy), cache the init per dataset, validate seasonal positions - HyperTreeSTL: make the trend-smoothing window learnable, fix short-horizon crashes - Reject nn.L1Loss in all models (zero curvature breaks Newton boosting) - Mask-aware conformal residuals; reject duplicate dates; docs and ~30 tests --- examples/Basic Walkthrough.ipynb | 112 ++++---- experiments/models.py | 22 +- hypertrees/conformal.py | 28 +- hypertrees/models/HyperTreeAR.py | 137 +++++++++- hypertrees/models/HyperTreeETS.py | 387 +++++++++++++++++++++++----- hypertrees/models/HyperTreeNetAR.py | 71 +++-- hypertrees/models/HyperTreeSTL.py | 73 ++++-- hypertrees/models/mlp.py | 9 + hypertrees/utils.py | 95 ++++++- tests/test_conformal.py | 67 +++++ tests/test_hypertree_ar.py | 115 ++++++++- tests/test_hypertree_ets.py | 184 +++++++++++++ tests/test_hypertree_net_ar.py | 113 ++++++-- tests/test_hypertree_stl.py | 41 ++- tests/test_utils.py | 14 + 15 files changed, 1240 insertions(+), 228 deletions(-) diff --git a/examples/Basic Walkthrough.ipynb b/examples/Basic Walkthrough.ipynb index 5d90be3..c7cc27d 100644 --- a/examples/Basic Walkthrough.ipynb +++ b/examples/Basic Walkthrough.ipynb @@ -13,8 +13,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2026-06-01T06:21:25.499778900Z", - "start_time": "2026-06-01T06:21:25.490665700Z" + "end_time": "2026-06-10T13:16:08.858605Z", + "start_time": "2026-06-10T13:16:05.786546700Z" } }, "source": [ @@ -31,7 +31,7 @@ "import shap" ], "outputs": [], - "execution_count": 13 + "execution_count": 1 }, { "cell_type": "markdown", @@ -42,8 +42,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2026-06-01T06:21:25.575064800Z", - "start_time": "2026-06-01T06:21:25.522020600Z" + "end_time": "2026-06-10T13:16:09.335624700Z", + "start_time": "2026-06-10T13:16:08.860583500Z" } }, "source": [ @@ -71,7 +71,7 @@ "}" ], "outputs": [], - "execution_count": 14 + "execution_count": 2 }, { "metadata": {}, @@ -84,8 +84,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-06-01T06:21:26.075224100Z", - "start_time": "2026-06-01T06:21:25.605213Z" + "end_time": "2026-06-10T13:16:09.762469700Z", + "start_time": "2026-06-10T13:16:09.336625200Z" } }, "cell_type": "code", @@ -100,7 +100,7 @@ "train = df.drop(test.index)" ], "outputs": [], - "execution_count": 15 + "execution_count": 3 }, { "cell_type": "markdown", @@ -118,16 +118,16 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2026-06-01T06:21:26.530589300Z", - "start_time": "2026-06-01T06:21:26.115011700Z" + "end_time": "2026-06-10T13:16:09.976732900Z", + "start_time": "2026-06-10T13:16:09.765477600Z" } }, "source": [ "# Initialize\n", "ht_ar = HyperTreeAR(\n", - " p=lag_p, # AR order (use last p months)\n", - " freq=freq, # Frequency\n", - " fcst_h=fcst_h # Forecast h months ahead\n", + " p=lag_p, # AR order (use last p months)\n", + " freq=freq, # Frequency\n", + " fcst_h=fcst_h, # Forecast h months ahead\n", ")\n", "\n", "# Train\n", @@ -145,7 +145,7 @@ ")" ], "outputs": [], - "execution_count": 16 + "execution_count": 4 }, { "cell_type": "markdown", @@ -156,8 +156,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2026-06-01T06:21:48.045962300Z", - "start_time": "2026-06-01T06:21:26.531588900Z" + "end_time": "2026-06-10T13:16:27.531759600Z", + "start_time": "2026-06-10T13:16:09.978735300Z" } }, "source": [ @@ -185,7 +185,7 @@ ")" ], "outputs": [], - "execution_count": 17 + "execution_count": 5 }, { "cell_type": "markdown", @@ -196,8 +196,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2026-06-01T06:21:48.621386Z", - "start_time": "2026-06-01T06:21:48.089838900Z" + "end_time": "2026-06-10T13:16:29.765756600Z", + "start_time": "2026-06-10T13:16:27.573777Z" } }, "source": [ @@ -225,7 +225,7 @@ ")" ], "outputs": [], - "execution_count": 18 + "execution_count": 6 }, { "metadata": {}, @@ -235,8 +235,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-06-01T06:21:49.641070300Z", - "start_time": "2026-06-01T06:21:48.666534700Z" + "end_time": "2026-06-10T13:16:31.151940500Z", + "start_time": "2026-06-10T13:16:29.787264100Z" } }, "cell_type": "code", @@ -270,7 +270,7 @@ ")" ], "outputs": [], - "execution_count": 19 + "execution_count": 7 }, { "cell_type": "markdown", @@ -284,8 +284,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-06-01T06:21:49.823748800Z", - "start_time": "2026-06-01T06:21:49.687528Z" + "end_time": "2026-06-10T13:16:31.401230200Z", + "start_time": "2026-06-10T13:16:31.184455200Z" } }, "cell_type": "code", @@ -320,13 +320,13 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 20 + "execution_count": 8 }, { "cell_type": "markdown", @@ -341,8 +341,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2026-06-01T06:21:49.857957100Z", - "start_time": "2026-06-01T06:21:49.825748300Z" + "end_time": "2026-06-10T13:16:31.451431Z", + "start_time": "2026-06-10T13:16:31.410787500Z" } }, "source": [ @@ -367,8 +367,8 @@ " MAE MAPE sMAPE WAPE RMSE\n", "model \n", "Hyper-Tree-AR(12) 12.626 2.862 2.797 2.652 17.382\n", - "Hyper-Tree-ETS(triple) 20.306 4.300 4.389 4.265 23.248\n", - "Hyper-Tree-STL(period=12) 17.514 3.520 3.578 3.678 20.892\n", + "Hyper-Tree-ETS(triple) 32.157 6.536 6.233 6.753 39.869\n", + "Hyper-Tree-STL(period=12) 18.945 3.785 3.862 3.979 22.477\n", "Hyper-TreeNet-AR(12) 15.839 3.428 3.457 3.326 19.424" ], "text/html": [ @@ -416,19 +416,19 @@ " \n", " \n", " Hyper-Tree-ETS(triple)\n", - " 20.306\n", - " 4.300\n", - " 4.389\n", - " 4.265\n", - " 23.248\n", + " 32.157\n", + " 6.536\n", + " 6.233\n", + " 6.753\n", + " 39.869\n", " \n", " \n", " Hyper-Tree-STL(period=12)\n", - " 17.514\n", - " 3.520\n", - " 3.578\n", - " 3.678\n", - " 20.892\n", + " 18.945\n", + " 3.785\n", + " 3.862\n", + " 3.979\n", + " 22.477\n", " \n", " \n", " Hyper-TreeNet-AR(12)\n", @@ -443,12 +443,12 @@ "" ] }, - "execution_count": 21, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 21 + "execution_count": 9 }, { "cell_type": "markdown", @@ -463,8 +463,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2026-06-01T06:21:50.101855800Z", - "start_time": "2026-06-01T06:21:49.904464600Z" + "end_time": "2026-06-10T13:16:31.693694600Z", + "start_time": "2026-06-10T13:16:31.497537200Z" } }, "source": [ @@ -493,13 +493,13 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 22 + "execution_count": 10 }, { "cell_type": "markdown", @@ -510,8 +510,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2026-06-01T06:21:51.088368600Z", - "start_time": "2026-06-01T06:21:50.300695200Z" + "end_time": "2026-06-10T13:16:32.752691Z", + "start_time": "2026-06-10T13:16:31.978994800Z" } }, "source": [ @@ -545,7 +545,7 @@ ], "text/html": [ "
" ] }, @@ -647,7 +647,7 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -673,7 +673,7 @@ "output_type": "display_data" } ], - "execution_count": 23 + "execution_count": 11 }, { "metadata": {}, @@ -687,8 +687,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-06-01T06:21:51.470035400Z", - "start_time": "2026-06-01T06:21:51.154363300Z" + "end_time": "2026-06-10T13:16:33.018370300Z", + "start_time": "2026-06-10T13:16:32.853807500Z" } }, "cell_type": "code", @@ -719,7 +719,7 @@ "output_type": "display_data" } ], - "execution_count": 24 + "execution_count": 12 } ], "metadata": { diff --git a/experiments/models.py b/experiments/models.py index 0ea852d..b5e09e8 100644 --- a/experiments/models.py +++ b/experiments/models.py @@ -12,6 +12,7 @@ HyperTreeNetAR, ) from hypertrees.models.mlp import MLP +from hypertrees.utils import NoDeepcopyObjective from sklearn.preprocessing import StandardScaler from chronos import ChronosPipeline @@ -921,13 +922,16 @@ def HyperTreeETSForecast( season_length=htets_params["season_length"], freq=freq, fcst_h=fcst_h, - loss_fn=loss_fn + loss_fn=loss_fn, + # Experiments reproduce the paper benchmarks, which were produced + # with the pre-0.2.0 state initialization. + seasonal_init=htets_params.get("seasonal_init", "legacy"), ) # Train model if manual_param is None: ht_ets.train( - lgb_params={k: v for k, v in htets_params.items() if k not in ["num_boost_round", "season_length", "ets_type", "manual_param", "scaling", "train"]}, + lgb_params={k: v for k, v in htets_params.items() if k not in ["num_boost_round", "season_length", "ets_type", "manual_param", "scaling", "train", "seasonal_init"]}, num_iterations=htets_params["num_boost_round"], train_data=train[["series_id", "date", "value"] + features], seed=123, @@ -1389,7 +1393,6 @@ class HyperTreeNetDirectForecasting: message="Using backward\\(\\) with create_graph=True will create a reference cycle.*" ) - _network_states = {} # Store network states for each instance def __init__( self, freq: str = "M", @@ -1483,9 +1486,6 @@ def get_embeds_loss( network_loss.backward() self.optimizer.step() - # Store network state - HyperTreeNetDirectForecasting._network_states = self.network.state_dict() - # Calculate loss for GBDT self.network.eval() fcst_gbdt = self.network(gbdt_embed) @@ -1580,10 +1580,11 @@ def train( ).to(self.device) self.optimizer = torch.optim.Adam(self.network.parameters(), lr=network_params["learning_rate"]) - # GBDT parameters + # GBDT parameters. The objective wrapper stops lgb.train's params + # deepcopy from cloning this instance (see NoDeepcopyObjective). self.lgb_params = { "num_class": self.embedding_dim, - "objective": self.objective_fn, + "objective": NoDeepcopyObjective(self.objective_fn), "metric": "None", "random_seed": seed, "verbose": verbose @@ -1639,9 +1640,8 @@ def forecast( device=self.device ).reshape(-1, self.embedding_dim) - # Load saved network state - self.network.load_state_dict(HyperTreeNetDirectForecasting._network_states) - + # self.network holds this instance's trained weights (boosting + # updated it in place; see NoDeepcopyObjective). self.network.eval() with torch.no_grad(): forecasts = (self.network(gbdt_embeds) diff --git a/hypertrees/conformal.py b/hypertrees/conformal.py index 277c314..e67a09f 100644 --- a/hypertrees/conformal.py +++ b/hypertrees/conformal.py @@ -177,7 +177,9 @@ def rolling_origin_residuals( Returns ------- scores : np.ndarray - Absolute residuals with shape ``(n_windows, n_series, fcst_h)``. + Absolute residuals with shape ``(n_windows, n_series, fcst_h)``. If the + data carries a ``mask`` column, residuals at padded rows (``mask == 0``) + are NaN and are excluded from the interval quantiles downstream. series_order : list Series ids in first-appearance order (axis 1 of ``scores``). """ @@ -226,6 +228,12 @@ def rolling_origin_residuals( fcst = model.forecast(test_data=test_df, type="forecast") resid = np.abs(fcst["fcst"].to_numpy() - test_df["value"].to_numpy()) + if "mask" in test_df.columns: + # Padded pseudo-observations (mask == 0, used by HyperTreeETS for + # uniform series lengths) carry no information about real forecast + # errors; mark them NaN so the NaN-aware interval quantiles ignore + # them. + resid = np.where(test_df["mask"].to_numpy().astype(bool), resid, np.nan) scores[w] = resid.reshape(len(series_order), fcst_h) return scores, series_order @@ -251,14 +259,18 @@ def _align_scores( def _distribution_bands( point: np.ndarray, scores: np.ndarray, levels: List[int] ) -> Dict[int, Tuple[np.ndarray, np.ndarray]]: - """``conformal_distribution`` intervals (synthetic-path symmetric quantiles).""" + """``conformal_distribution`` intervals (synthetic-path symmetric quantiles). + + NaN scores (residuals at padded pseudo-observations) are excluded via + NaN-aware quantiles; a cell whose scores are all NaN yields NaN bounds. + """ # Synthetic forecast paths: (2 * n_windows, n_series, h) paths = np.concatenate([point[None] - scores, point[None] + scores], axis=0) bands = {} for lv in levels: alpha = 100 - lv - lo = np.quantile(paths, (alpha / 2) / 100.0, axis=0) - hi = np.quantile(paths, 1.0 - (alpha / 2) / 100.0, axis=0) + lo = np.nanquantile(paths, (alpha / 2) / 100.0, axis=0) + hi = np.nanquantile(paths, 1.0 - (alpha / 2) / 100.0, axis=0) bands[lv] = (lo, hi) return bands @@ -266,10 +278,14 @@ def _distribution_bands( def _error_bands( point: np.ndarray, scores: np.ndarray, levels: List[int] ) -> Dict[int, Tuple[np.ndarray, np.ndarray]]: - """``conformal_error`` intervals (symmetric ``y_hat +/- quantile``).""" + """``conformal_error`` intervals (symmetric ``y_hat +/- quantile``). + + NaN scores (residuals at padded pseudo-observations) are excluded via + NaN-aware quantiles; a cell whose scores are all NaN yields NaN bounds. + """ bands = {} for lv in levels: - q = np.quantile(scores, lv / 100.0, axis=0) + q = np.nanquantile(scores, lv / 100.0, axis=0) bands[lv] = (point - q, point + q) return bands diff --git a/hypertrees/models/HyperTreeAR.py b/hypertrees/models/HyperTreeAR.py index e46fa2a..490c640 100644 --- a/hypertrees/models/HyperTreeAR.py +++ b/hypertrees/models/HyperTreeAR.py @@ -11,7 +11,7 @@ from ..utils import CustomLogger lgb.register_logger(CustomLogger()) -from ..utils import TimeSeriesPreprocessor, prepare_datasets, TrainingResult, validate_series_order, extract_forecast_lags, GaussNewtonHessian +from ..utils import TimeSeriesPreprocessor, prepare_datasets, TrainingResult, validate_series_order, extract_forecast_lags, GaussNewtonHessian, NoDeepcopyObjective from ..conformal import ( ForecastIntervals, validate_calibration_length, @@ -93,7 +93,7 @@ def __init__( freq: str = "M", fcst_h: int = 1, loss_fn: Callable = nn.MSELoss(), - hessian_method: str = "exact", + hessian_method: str = "analytic", n_hessian_probes: int = 5, ): """ @@ -110,10 +110,24 @@ def __init__( Forecast horizon (number of periods to forecast ahead). loss_fn : Callable Loss function for optimization. Must be a PyTorch loss function. - Default is MSE loss, but can be changed for different error metrics. + Default is MSE loss. Losses other than nn.MSELoss are not + recommended, as they have not been systematically tested yet. + nn.L1Loss is rejected (zero second derivative almost everywhere + breaks Newton boosting). hessian_method : str Method for computing the Hessian diagonal. Options: - - "exact": Exact diagonal Hessian via per-parameter second-order autograd. + - "exact": Exact diagonal Hessian via per-parameter second-order autograd + (one backward pass per lag and iteration). + - "analytic": Closed-form gradients and exact diagonal Hessians, + exploiting that the AR fit is linear in its parameters + (dL/dtheta_j = l'(y_hat) * lag_j and d2L/dtheta_j2 = l''(y_hat) * lag_j**2, + the second-order fit term vanishing exactly). Produces the same + values as "exact" for any loss that is a mean/sum of + per-observation terms -- which covers all standard PyTorch + regression losses -- at a fraction of the cost: at most one + small double-backward through loss(fit, target) instead of one + backward per lag. nn.MSELoss uses a fully closed-form fast path + with no autograd at all. - "gn": Gauss-Newton approximation estimated via Hutchinson probing. Guarantees positive semi-definite Hessians. Avoids second-order differentiation at the cost of Hutchinson estimation variance. @@ -131,8 +145,15 @@ def __init__( raise TypeError("freq must be a string.") if not isinstance(loss_fn, nn.Module): raise TypeError("loss_fn must be a PyTorch loss function.") - if hessian_method not in ("exact", "gn"): - raise ValueError("hessian_method must be either 'exact' or 'gn'.") + if isinstance(loss_fn, nn.L1Loss): + raise ValueError( + "nn.L1Loss is not supported: its second derivative is zero almost " + "everywhere, so LightGBM's Newton boosting receives all-zero Hessians " + "and cannot grow trees. Use nn.HuberLoss or nn.SmoothL1Loss for an " + "MAE-like loss with usable curvature." + ) + if hessian_method not in ("exact", "analytic", "gn"): + raise ValueError("hessian_method must be one of 'exact', 'analytic', or 'gn'.") if not isinstance(n_hessian_probes, int) or n_hessian_probes <= 0: raise ValueError("n_hessian_probes must be a positive integer.") @@ -160,6 +181,7 @@ def __init__( self._iter_count = 0 self._fit = None self._target = None + self._lags = None # Conformal prediction interval state (populated when train() is called # with forecast_intervals). @@ -171,6 +193,8 @@ def __init__( # Bind Hessian computation strategy if hessian_method == "exact": self.calculate_gradients_and_hessians = self._calculate_gradients_and_hessians_exact + elif hessian_method == "analytic": + self.calculate_gradients_and_hessians = self._calculate_gradients_and_hessians_analytic else: self._gn_hessian = GaussNewtonHessian(loss_fn, n_hessian_probes, self.dtype) self.calculate_gradients_and_hessians = self._calculate_gradients_and_hessians_gn @@ -289,14 +313,29 @@ def get_params_loss( # Calculate loss between forecasts and actual values loss = self.loss_fn(fcst, target) - if self.hessian_method == "gn": + if self.hessian_method in ("gn", "analytic"): self._fit = fcst self._target = target + self._lags = lags return params, loss def _calculate_gradients_and_hessians_exact(self, loss: torch.Tensor, params: torch.Tensor) -> Tuple[np.ndarray, np.ndarray]: - """Exact diagonal Hessian via per-parameter second-order autograd.""" + """Exact diagonal Hessian via per-parameter second-order autograd. + + Parameters + ---------- + loss : torch.Tensor + Loss value from the model. + params : torch.Tensor + Model parameters (AR coefficients as an ``nn.Parameter``, + shape ``(n_samples, p)``). + + Returns + ------- + Tuple[np.ndarray, np.ndarray] + Gradients and hessians as numpy arrays in the format expected by LightGBM. + """ loss.backward(create_graph=True) grad = params.grad hess = [ @@ -310,13 +349,82 @@ def _calculate_gradients_and_hessians_exact(self, loss: torch.Tensor, params: to return grad, hess + def _calculate_gradients_and_hessians_analytic(self, loss: torch.Tensor, params: torch.Tensor) -> Tuple[np.ndarray, np.ndarray]: + """Closed-form gradients and exact diagonal Hessians via model linearity. + + Since the AR fit is linear in its parameters, ``grad = l'(y_hat) * lags`` + and ``hess = l''(y_hat) * lags**2``, matching the "exact" method for any + per-observation loss. MSELoss uses closed-form derivatives; other losses + use one small double-backward through ``loss(fit, target)``. + + Parameters + ---------- + loss : torch.Tensor + Loss value from the model (unused; derivatives come from the + fit/target/lags stored by ``get_params_loss``). + params : torch.Tensor + Model parameters (unused, kept for a uniform dispatch signature). + + Returns + ------- + Tuple[np.ndarray, np.ndarray] + Gradients and hessians as numpy arrays in the format expected by LightGBM. + """ + fit = self._fit.detach() + target = self._target + lags = self._lags + + if isinstance(self.loss_fn, nn.MSELoss) and self.loss_fn.reduction in ("mean", "sum"): + # MSE fast path: l' = scale * (y_hat - y), l'' = scale + scale = 2.0 / fit.numel() if self.loss_fn.reduction == "mean" else 2.0 + g = scale * (fit - target) + h = torch.full_like(fit, scale) + else: + # Generic path: per-element first and second loss derivatives via + # a double-backward through the (tiny) loss(fit, target) graph. + # Requires the loss to have a well-defined double-backward (true + # for HuberLoss/SmoothL1Loss and other standard smooth losses). + # nn.L1Loss is rejected in __init__: its zero curvature breaks + # Newton boosting, and torch 2.8.0's l1_loss double-backward can + # return an uninitialized buffer instead of zeros. + fit_leaf = fit.requires_grad_(True) + loss_local = self.loss_fn(fit_leaf, target) + g = autograd(loss_local, fit_leaf, create_graph=True)[0] + h = autograd(g.sum(), fit_leaf)[0].detach() + g = g.detach() + + # Broadcast (N, 1) loss derivatives over the (N, p) lag matrix. + grad = (g * lags).cpu().numpy().ravel(order="F") + hess = (h * lags ** 2).cpu().numpy().ravel(order="F") + + self._fit = None + self._target = None + self._lags = None + + return grad, hess + def _calculate_gradients_and_hessians_gn(self, loss: torch.Tensor, params: torch.Tensor) -> Tuple[np.ndarray, np.ndarray]: - """Gauss-Newton Hessian diagonal estimated via Hutchinson probing.""" + """Gauss-Newton Hessian diagonal estimated via Hutchinson probing. + + Parameters + ---------- + loss : torch.Tensor + Loss value from the model. + params : torch.Tensor + Model parameters (AR coefficients as an ``nn.Parameter``, + shape ``(n_samples, p)``). + + Returns + ------- + Tuple[np.ndarray, np.ndarray] + Gradients and hessians as numpy arrays in the format expected by LightGBM. + """ grad = autograd(loss, params, retain_graph=True)[0] rng = torch.Generator().manual_seed(self._iter_count) hess = self._gn_hessian.estimate(self._fit, self._target, params, rng) self._fit = None self._target = None + self._lags = None grad = grad.cpu().detach().numpy().ravel(order="F") hess = hess.cpu().detach().numpy().ravel(order="F") @@ -430,10 +538,11 @@ def train( train_data, self.fcst_h, forecast_intervals, min_train=self.p + 1 ) - # General model parameters + # General model parameters. The objective wrapper stops lgb.train's + # params deepcopy from cloning this instance (see NoDeepcopyObjective). self.lgb_params = { "num_class": self.p, - "objective": self.objective_fn, + "objective": NoDeepcopyObjective(self.objective_fn), "metric": "None", "random_seed": seed, "verbose": verbose @@ -446,6 +555,7 @@ def train( self._iter_count = 0 self._fit = None self._target = None + self._lags = None self.model = None self.dataset_references = {} self.is_trained = False @@ -725,10 +835,9 @@ def forecast( elif type == "parameters": params_fcst = np.asarray(self.model.predict(test_data[self.features])) - # LightGBM may return 1D (column-major) or 2D depending on version/objective. - # Normalize to (n_test, p) before indexing. + # Booster.predict returns (n_test, p) for multi-class output if params_fcst.ndim == 1: - params_fcst = params_fcst.reshape(-1, self.p, order="F") + params_fcst = params_fcst.reshape(-1, self.p) out_df = pd.DataFrame({ "series_id": test_data["series_id"].to_numpy().flatten(), "date": test_data["date"].to_numpy().flatten(), diff --git a/hypertrees/models/HyperTreeETS.py b/hypertrees/models/HyperTreeETS.py index 5267ba1..692ed3b 100644 --- a/hypertrees/models/HyperTreeETS.py +++ b/hypertrees/models/HyperTreeETS.py @@ -10,7 +10,7 @@ from ..utils import CustomLogger lgb.register_logger(CustomLogger()) -from ..utils import TimeSeriesPreprocessor, prepare_datasets, TrainingResult, validate_series_order, GaussNewtonHessian +from ..utils import TimeSeriesPreprocessor, prepare_datasets, TrainingResult, validate_series_order, GaussNewtonHessian, NoDeepcopyObjective from ..conformal import ( ForecastIntervals, validate_calibration_length, @@ -98,6 +98,7 @@ def __init__( fcst_h: int = 12, loss_fn: Callable = nn.MSELoss(), n_hessian_probes: int = 5, + seasonal_init: str = "classical", ): """ Initialize the Hyper-Tree-ETS model. @@ -111,7 +112,8 @@ def __init__( seasonality_feature : str Feature name for seasonality. This is used to create seasonal indices. Must be present in the dataset. For example, "month" for monthly data, "quarter" for quarterly data, etc. This is required when - ets_type is "triple". + ets_type is "triple". Values must be 1-based season positions in [1, season_length]; + shift 0-based features (e.g. pandas dayofweek in 0..6) by +1. freq : str Frequency of the time series (e.g., 'D' for daily, 'M' for monthly, 'Q' for quarterly, 'Y' for yearly). @@ -119,16 +121,27 @@ def __init__( Forecast horizon (number of periods to forecast ahead). loss_fn : Callable Loss function for optimization. Must be a PyTorch loss function. - Default is MSE loss. Must be twice-differentiable for the - Gauss-Newton Hessian; non-smooth losses (e.g., L1Loss) have - zero or undefined second derivatives, causing degenerate Hessians. + Default is MSE loss. Losses other than nn.MSELoss are not + recommended, as they have not been systematically tested yet. + nn.L1Loss is rejected (zero second derivative almost everywhere + breaks Newton boosting). n_hessian_probes : int Number of Hutchinson probes for Gauss-Newton Hessian diagonal estimation. More probes reduce variance but increase computation. Default is 5. + seasonal_init : str + Initialization of the seasonal/level/trend states for the triple + ETS forward pass (ignored for ets_type="trend"). Options: + - "classical" (default): decomposition-based estimator following + R's forecast::ets and statsforecast (centered 2 x m moving-average + detrending, slot-aligned seasonal indices, OLS level/trend seed). + - "legacy": the exact pre-0.2.0 initialization, kept verbatim for + reproducing earlier results (including the paper benchmarks). """ # Validate inputs if ets_type not in ["triple", "trend"]: raise ValueError("ets_type must be either 'triple' or 'trend'.") + if seasonal_init not in ["classical", "legacy"]: + raise ValueError("seasonal_init must be either 'classical' or 'legacy'.") if season_length <= 0: raise ValueError("season_length must be a positive integer.") if not isinstance(season_length, int): @@ -137,6 +150,13 @@ def __init__( raise ValueError("Forecast horizon 'fcst_h' must be a positive integer.") if not isinstance(loss_fn, nn.Module): raise TypeError("loss_fn must be a PyTorch loss function.") + if isinstance(loss_fn, nn.L1Loss): + raise ValueError( + "nn.L1Loss is not supported: its second derivative is zero almost " + "everywhere, so LightGBM's Newton boosting receives all-zero Hessians " + "and cannot grow trees. Use nn.HuberLoss or nn.SmoothL1Loss for an " + "MAE-like loss with usable curvature." + ) if not isinstance(loss_fn, nn.MSELoss): import warnings warnings.warn( @@ -154,6 +174,7 @@ def __init__( self.ets_type = ets_type self.season_length = season_length self.seasonality_feature = seasonality_feature + self.seasonal_init = seasonal_init self.freq = freq self.n_params = 4 if ets_type == "triple" else 2 # alpha, beta, gamma, phi OR alpha, beta self.fcst_h = fcst_h @@ -168,6 +189,7 @@ def __init__( self.fcst_states = None # Store final ETS states for forecasting self.n_hessian_probes = n_hessian_probes self._iter_count = 0 # Iteration counter for seeding Hessian probes + self._init_cache = {} # Per-dataset cache of _init_triple_states results # Shared Gauss-Newton Hessian estimator self._gn_hessian = GaussNewtonHessian(loss_fn, n_hessian_probes, self.dtype) @@ -218,6 +240,224 @@ def _create_mask_from_data(self, data: pd.DataFrame) -> torch.Tensor: return mask + def _seasonal_positions(self, values) -> torch.Tensor: + """Convert 1-based seasonal feature values to 0-based tensor indices. + + Validates values lie in ``[1, season_length]``; a 0-based feature + (e.g. pandas ``dayofweek``) would silently wrap into the wrong slot. + + Parameters + ---------- + values : array-like + Raw values of the ``seasonality_feature`` column. + + Returns + ------- + torch.Tensor + 0-based seasonal positions as a flat ``torch.long`` tensor. + """ + idx = torch.tensor(np.asarray(values), dtype=torch.long) - 1 + if idx.numel() > 0: + lo = int(idx.min()) + hi = int(idx.max()) + if lo < 0 or hi >= self.season_length: + raise ValueError( + f"seasonality_feature '{self.seasonality_feature}' must contain " + f"1-based season positions in [1, {self.season_length}]; got values " + f"in [{lo + 1}, {hi + 1}]. Shift 0-based features (e.g. pandas " + f"dayofweek) by +1." + ) + return idx + + def _init_triple_states( + self, + target: torch.Tensor, + mask: torch.Tensor, + seasonality_idxs: torch.Tensor, + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """Initial seasonal indices and level/trend states for triple ETS. + + ``seasonal_init="legacy"`` reproduces the pre-0.2.0 initialization + verbatim (flat seasonal profile), required to reproduce earlier + results including the paper benchmarks. ``"classical"`` (default) + follows R's ``forecast::ets`` / statsforecast: centered 2 x m + moving-average detrending, per-slot ratio averages normalized to mean + one, and an OLS level/trend seed on the seasonally-adjusted head. + Indices are assigned via ``seasonality_idxs`` so they land in the + slots the recursion reads; short series and empty slots fall back to + a simple per-slot average. All statistics are mask-aware. + + Parameters + ---------- + target : torch.Tensor + Observations, shape ``(n_series, T)``. + mask : torch.Tensor + Validity mask (1 = real observation, 0 = padding), + shape ``(n_series, T)``. + seasonality_idxs : torch.Tensor + 0-based seasonal slot per observation, shape ``(n_series, T)``. + + Returns + ------- + Tuple[torch.Tensor, torch.Tensor, torch.Tensor] + Seasonal indices ``(n_series, season_length)``, initial level + ``(n_series,)``, and initial trend ``(n_series,)``. + """ + N, T = target.shape + m = self.season_length + + if self.seasonal_init == "legacy": + # Pre-0.2.0 initialization, kept verbatim (including its positional + # slot assignment and flat resulting profile) so that results from + # earlier releases and the paper remain reproducible. + init_len = min(m, T) + seasonal_avg = torch.zeros((N, init_len), dtype=self.dtype) + for i in range(init_len): + valid_obs = mask[:, i::init_len] + seasonal_avg[:, i] = (target[:, i::init_len] * valid_obs.float()).sum( + 1) / valid_obs.float().sum(1).clamp(min=1) + + seasonality = target[:, :init_len] / (seasonal_avg + self.eps) + if init_len < m: + # Pad with ones for missing season positions + pad = torch.ones((N, m - init_len), dtype=self.dtype) + seasonality = torch.cat([seasonality, pad], dim=1) + + season_adj = target[:, :init_len] / seasonality[:, :init_len] + level0 = season_adj[:, 0] + trend0 = season_adj[:, min(1, init_len - 1)] - season_adj[:, 0] + return seasonality, level0, trend0 + + slot_ids = torch.arange(N, dtype=torch.long).unsqueeze(1) * m + seasonality_idxs # (N, T) + ym = target * mask + + def slot_sum(ids: torch.Tensor, values: torch.Tensor) -> torch.Tensor: + """Sum ``values`` into their (series, slot) cells -> (N, m).""" + return torch.zeros(N * m, dtype=self.dtype).index_add_( + 0, ids.reshape(-1), values.reshape(-1) + ).reshape(N, m) + + # --- Fallback estimator: per-slot average of y over the series mean -- + cnts = slot_sum(slot_ids, mask) + slot_mean = slot_sum(slot_ids, ym) / cnts.clamp(min=1.0) + grand_mean = ym.sum(dim=1) / mask.sum(dim=1).clamp(min=1.0) + simple_idx = torch.where( + cnts > 0, + slot_mean / (grand_mean.unsqueeze(1) + self.eps), + torch.ones_like(slot_mean), + ) + seasonality = simple_idx + + # --- Detrended estimator: centered 2 x m MA, then per-slot ratios ---- + L = m + 1 if m % 2 == 0 else m # always odd + if T >= L: + kernel = torch.full((1, 1, L), 1.0 / m, dtype=self.dtype) + if m % 2 == 0: + kernel[0, 0, 0] = 0.5 / m + kernel[0, 0, -1] = 0.5 / m + trend_ma = torch.nn.functional.conv1d( + ym.unsqueeze(1), kernel + ).squeeze(1) # (N, T - L + 1), centered at offset L // 2 + window_valid = torch.nn.functional.conv1d( + mask.unsqueeze(1), torch.ones((1, 1, L), dtype=self.dtype) + ).squeeze(1) >= L - 0.5 # full window unmasked (implies a valid center) + + half = L // 2 + y_c = target[:, half:T - half] # window centers, length T - L + 1 + valid = window_valid & (trend_ma > self.eps) + ratios = torch.where( + valid, y_c / trend_ma.clamp(min=self.eps), torch.zeros_like(y_c) + ) + + r_cnts = slot_sum(slot_ids[:, half:T - half], valid.to(self.dtype)) + detr_idx = slot_sum(slot_ids[:, half:T - half], ratios) / r_cnts.clamp(min=1.0) + seasonality = torch.where(r_cnts > 0, detr_idx, simple_idx) + + # Normalize to mean one and guard against tiny indices + # (statsforecast clips initial seasonal states at 1e-2 as well). + seasonality = seasonality / seasonality.mean(dim=1, keepdim=True).clamp(min=self.eps) + seasonality = seasonality.clamp(min=1e-2) + + # --- Level/trend: OLS on the seasonally-adjusted head (as in ets) ---- + s_t = seasonality.gather(1, seasonality_idxs) + y_sa = target / s_t.clamp(min=self.eps) + maxn = min(max(10, 2 * m), T) + t_idx = torch.arange(1, maxn + 1, dtype=self.dtype).unsqueeze(0) + w = mask[:, :maxn] + sw = w.sum(dim=1).clamp(min=1.0) + mean_t = (w * t_idx).sum(dim=1) / sw + mean_y = (w * y_sa[:, :maxn]).sum(dim=1) / sw + dev_t = t_idx - mean_t.unsqueeze(1) + var_t = (w * dev_t ** 2).sum(dim=1) + cov_ty = (w * dev_t * (y_sa[:, :maxn] - mean_y.unsqueeze(1))).sum(dim=1) + trend0 = torch.where( + var_t > self.eps, + cov_ty / var_t.clamp(min=self.eps), + torch.zeros_like(cov_ty), + ) + # Evaluate the line at the first observation (t = 1 on the OLS axis) + # so level0 matches this recursion's timing, which seeds the state at + # the first observation rather than one step before it. + level0 = mean_y + trend0 * (1.0 - mean_t) + + return seasonality, level0, trend0 + + def _cached_init_triple_states( + self, + data: lgb.Dataset, + target: torch.Tensor, + mask: torch.Tensor, + seasonality_idxs: torch.Tensor, + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """Cache wrapper around :meth:`_init_triple_states`. + + The initialization depends only on the data, which is constant across + boosting iterations, so results are cached per lgb.Dataset. Entries + pin the dataset object, so a key hit proves it is that exact, + still-alive dataset. The seasonal indices are cloned on every return + because the recursion updates them in place; the cache is cleared by + ``train()``. + + Parameters + ---------- + data : lgb.Dataset + Dataset whose identity serves as the cache key. + target : torch.Tensor + Observations, shape ``(n_series, T)``. + mask : torch.Tensor + Validity mask (1 = real observation, 0 = padding), shape ``(n_series, T)``. + seasonality_idxs : torch.Tensor + 0-based seasonal slot per observation, shape ``(n_series, T)``. + + Returns + ------- + Tuple[torch.Tensor, torch.Tensor, torch.Tensor] + Seasonal indices ``(n_series, season_length)``, initial level + ``(n_series,)``, and initial trend ``(n_series,)``. + """ + key = id(data) + entry = self._init_cache.get(key) + if entry is not None: + return entry["seasonality"].clone(), entry["level0"], entry["trend0"] + + seasonality, level0, trend0 = self._init_triple_states( + target, mask, seasonality_idxs + ) + if len(self._init_cache) > 8: + # Bound growth from one-shot datasets (e.g. _store_final_states, + # conformal re-anchoring); the persistent train/eval entries are + # simply recomputed once after a clear. + self._init_cache.clear() + # Storing the dataset pins its id: a key hit therefore implies this + # exact dataset, and with it identical target/mask/positions. + self._init_cache[key] = { + "data": data, + "seasonality": seasonality, + "level0": level0, + "trend0": trend0, + } + return seasonality.clone(), level0, trend0 + def objective_fn(self, predt: np.ndarray, data: lgb.Dataset) -> Tuple[np.ndarray, np.ndarray]: """ Custom objective function for LightGBM training. @@ -367,6 +607,17 @@ def _forward_triple( - Seasonality: s_t = γ(y_t/(l_{t-1} + φb_{t-1})) + (1-γ)s_{t-m} - Fitted: ŷ_t = (l_{t-1} + φb_{t-1}) * s_{t-m} + Parameters + ---------- + params : torch.Tensor + Sigmoid-transformed ETS parameters, shape ``(n_series, T, n_params)``. + data : lgb.Dataset + LightGBM dataset whose raw DataFrame provides the seasonality feature. + target : torch.Tensor + Observations, shape ``(n_series, T)``. + mask : torch.Tensor + Validity mask (1 = real observation, 0 = padding), shape ``(n_series, T)``. + Returns ------- Tuple[torch.Tensor, torch.Tensor, torch.Tensor, List[torch.Tensor]] @@ -382,59 +633,57 @@ def _forward_triple( gamma_t = gamma.unbind(dim=1) phi_t = phi.unbind(dim=1) - # Initialize seasonality - init_len = min(self.season_length, series_len) - seasonal_avg = torch.zeros((self.n_series, init_len), dtype=self.dtype) - - # Compute initial seasonal averages - for i in range(init_len): - valid_obs = mask[:, i::init_len] - seasonal_avg[:, i] = (target[:, i::init_len] * valid_obs.float()).sum( - 1) / valid_obs.float().sum(1).clamp(min=1) - - # Initialize seasonality as ratios since we are using multiplicative seasonality - seasonality = target[:, :init_len] / (seasonal_avg + self.eps) - if init_len < self.season_length: - # Pad with ones for missing season positions - pad = torch.ones((self.n_series, self.season_length - init_len), dtype=self.dtype) - seasonality = torch.cat([seasonality, pad], dim=1) - - # ETS initialization using season-adjusted initialization - season_adj = target[:, :init_len] / seasonality[:, :init_len] - level_prev = season_adj[:, 0] - trend_prev = season_adj[:, min(1, init_len - 1)] - season_adj[:, 0] - fits = [target[:, 0]] - - # Get seasonal indices from features - seasonality_idxs = torch.tensor( - data.data[self.seasonality_feature].values - 1, - dtype=torch.long + # Get seasonal indices from features first: the state initialization + # assigns initial indices to the same slots the recursion reads, so a + # series that does not start at season position 1 is not rotated. + seasonality_idxs = self._seasonal_positions( + data.data[self.seasonality_feature].values ).reshape(self.n_series, -1) batch_idx = torch.arange(self.n_series, dtype=torch.long) - # Triple ETS updates with masking for padded values + # Initialize seasonal indices and level/trend states via the classical + # decomposition-based estimator. The result depends only on the data + # (never on the boosted parameters), so it is cached per lgb.Dataset + # and reused across boosting iterations. + seasonality, level_prev, trend_prev = self._cached_init_triple_states( + data, target, mask, seasonality_idxs + ) + fits = [target[:, 0]] + + # Pre-unbind the data tensors so the loop indexes Python tuples + # instead of slicing tensors at every step. + target_t = target.unbind(dim=1) + mask_t = mask.unbind(dim=1) + idxs_t = seasonality_idxs.unbind(dim=1) + + # Triple ETS updates with masking for padded values. Shared + # subexpressions are hoisted: every node created here is re-traversed + # by each backward pass (gradient plus the Hutchinson probes), so a + # smaller graph speeds up the forward and every backward. for t in range(1, series_len): - s_idx = seasonality_idxs[:, t] - valid_mask = mask[:, t] + valid_mask = mask_t[t] + invalid_mask = 1 - valid_mask + y_t = target_t[t] + s_prev = seasonality[batch_idx, idxs_t[t]] # s_{t-m} + phi_trend = phi_t[t] * trend_prev # phi_t * b_{t-1} + pred_base = level_prev + phi_trend # l_{t-1} + phi_t * b_{t-1} - fit_t = valid_mask * ( - (level_prev + phi_t[t] * trend_prev) * seasonality[batch_idx, s_idx] - ) + (1 - valid_mask) * fits[-1] + fit_t = valid_mask * (pred_base * s_prev) + invalid_mask * fits[-1] level_new = valid_mask * ( - alpha_t[t] * (target[:, t] / seasonality[batch_idx, s_idx]) + - (1 - alpha_t[t]) * (level_prev + phi_t[t] * trend_prev) - ) + (1 - valid_mask) * level_prev + alpha_t[t] * (y_t / s_prev) + + (1 - alpha_t[t]) * pred_base + ) + invalid_mask * level_prev trend_new = valid_mask * ( beta_t[t] * (level_new - level_prev) + - (1 - beta_t[t]) * phi_t[t] * trend_prev - ) + (1 - valid_mask) * trend_prev + (1 - beta_t[t]) * phi_trend + ) + invalid_mask * trend_prev - seasonality[batch_idx, s_idx] = valid_mask * ( - gamma_t[t] * (target[:, t] / (level_prev + phi_t[t] * trend_prev)) + - (1 - gamma_t[t]) * seasonality[batch_idx, s_idx] - ) + (1 - valid_mask) * seasonality[batch_idx, s_idx] + seasonality[batch_idx, idxs_t[t]] = valid_mask * ( + gamma_t[t] * (y_t / pred_base) + + (1 - gamma_t[t]) * s_prev + ) + invalid_mask * s_prev fits.append(fit_t) level_prev = level_new @@ -457,6 +706,17 @@ def _forward_trend( - Trend: b_t = β(l_t - l_{t-1}) + (1-β)b_{t-1} - Fitted: ŷ_t = l_{t-1} + b_{t-1} + Parameters + ---------- + params : torch.Tensor + Sigmoid-transformed ETS parameters, shape ``(n_series, T, n_params)``. + data : lgb.Dataset + Unused; kept for a uniform forward signature with ``_forward_triple``. + target : torch.Tensor + Observations, shape ``(n_series, T)``. + mask : torch.Tensor + Validity mask (1 = real observation, 0 = padding), shape ``(n_series, T)``. + Returns ------- Tuple[torch.Tensor, torch.Tensor, None, List[torch.Tensor]] @@ -476,21 +736,29 @@ def _forward_trend( trend_prev = (target[:, last_idx] - target[:, 0]) / max(last_idx, 1) fits = [target[:, 0]] - # Trend-only updates with masking for padded values + # Pre-unbind the data tensors so the loop indexes Python tuples + # instead of slicing tensors at every step. + target_t = target.unbind(dim=1) + mask_t = mask.unbind(dim=1) + + # Trend-only updates with masking for padded values (shared + # subexpressions hoisted; see _forward_triple). for t in range(1, series_len): - valid_mask = mask[:, t] + valid_mask = mask_t[t] + invalid_mask = 1 - valid_mask + pred_base = level_prev + trend_prev # l_{t-1} + b_{t-1} - fit_t = valid_mask * (level_prev + trend_prev) + (1 - valid_mask) * fits[-1] + fit_t = valid_mask * pred_base + invalid_mask * fits[-1] level_new = valid_mask * ( - alpha_t[t] * target[:, t] + - (1 - alpha_t[t]) * (level_prev + trend_prev) - ) + (1 - valid_mask) * level_prev + alpha_t[t] * target_t[t] + + (1 - alpha_t[t]) * pred_base + ) + invalid_mask * level_prev trend_new = valid_mask * ( beta_t[t] * (level_new - level_prev) + (1 - beta_t[t]) * trend_prev - ) + (1 - valid_mask) * trend_prev + ) + invalid_mask * trend_prev fits.append(fit_t) level_prev = level_new @@ -671,10 +939,11 @@ def train( if len(unique_lengths.unique()) > 1: raise ValueError("All series in train_data must have the same length. Found multiple lengths.") - # General model parameters + # General model parameters. The objective wrapper stops lgb.train's + # params deepcopy from cloning this instance (see NoDeepcopyObjective). self.lgb_params = { "num_class": self.n_params, - "objective": self.objective_fn, + "objective": NoDeepcopyObjective(self.objective_fn), "metric": "None", "random_seed": seed, "verbose": verbose @@ -682,6 +951,7 @@ def train( # Reset states self._iter_count = 0 + self._init_cache = {} self._fit = None self._mask = None self._target = None @@ -770,6 +1040,7 @@ def _model_factory(): fcst_h=self.fcst_h, loss_fn=self.loss_fn, n_hessian_probes=self.n_hessian_probes, + seasonal_init=self.seasonal_init, ) cal_train_kwargs = dict( @@ -1012,8 +1283,8 @@ def forecast( [self.fcst_states[series_id]['seasonality'] for series_id in test_series_ids] ) - seasonality_idxs = torch.tensor( - test_data[self.seasonality_feature].values - 1 + seasonality_idxs = self._seasonal_positions( + test_data[self.seasonality_feature].values ).reshape(self.n_series, self.fcst_h) batch_idx = torch.arange(self.n_series, dtype=torch.long) alpha_fcst = fcst_params[:, :, 0] diff --git a/hypertrees/models/HyperTreeNetAR.py b/hypertrees/models/HyperTreeNetAR.py index c65aea9..191e9cd 100644 --- a/hypertrees/models/HyperTreeNetAR.py +++ b/hypertrees/models/HyperTreeNetAR.py @@ -6,7 +6,7 @@ import lightgbm as lgb from typing import Tuple, Callable, Optional, List import time -from ..utils import TimeSeriesPreprocessor, prepare_datasets, TrainingResult, CustomLogger, validate_series_order, extract_forecast_lags, GaussNewtonHessian +from ..utils import TimeSeriesPreprocessor, prepare_datasets, TrainingResult, CustomLogger, validate_series_order, extract_forecast_lags, GaussNewtonHessian, NoDeepcopyObjective from ..conformal import ( ForecastIntervals, validate_calibration_length, @@ -108,7 +108,6 @@ class HyperTreeNetAR: plt.tight_layout() ``` """ - _network_states = {} # Store network states for each instance def __init__( self, p: int = 2, @@ -133,7 +132,10 @@ def __init__( Forecast horizon (number of periods to forecast ahead). loss_fn : Callable Loss function for optimization. Must be a PyTorch loss function. - Default is MSE loss, but can be changed for different error metrics. + Default is MSE loss. Losses other than nn.MSELoss are not + recommended, as they have not been systematically tested yet. + nn.L1Loss is rejected (zero second derivative almost everywhere + breaks Newton boosting). device : str Device to run the model on. Default is 'cpu'. This allows for GPU acceleration of network training if available. @@ -157,6 +159,13 @@ def __init__( raise TypeError("freq must be a string.") if not isinstance(loss_fn, nn.Module): raise TypeError("loss_fn must be a PyTorch loss function.") + if isinstance(loss_fn, nn.L1Loss): + raise ValueError( + "nn.L1Loss is not supported: its second derivative is zero almost " + "everywhere, so LightGBM's Newton boosting receives all-zero Hessians " + "and cannot grow trees. Use nn.HuberLoss or nn.SmoothL1Loss for an " + "MAE-like loss with usable curvature." + ) if hessian_method not in ("exact", "gn"): raise ValueError("hessian_method must be either 'exact' or 'gn'.") if not isinstance(n_hessian_probes, int) or n_hessian_probes <= 0: @@ -265,8 +274,8 @@ def eval_fn(self, predt: np.ndarray, eval_data: lgb.Dataset) -> Tuple[str, float dtype=self.dtype ).to(self.device) - # Load the most recent network state - self.network.load_state_dict(HyperTreeNetAR._network_states) + # self.network is the live module the objective updated in this same + # boosting iteration (guaranteed by NoDeepcopyObjective). # Compute loss without gradients self.network.eval() @@ -328,9 +337,6 @@ def get_embeds_loss_separate( network_loss.backward() self.optimizer.step() - # Store network state - HyperTreeNetAR._network_states = self.network.state_dict() - # Calculate loss for GBDT self.network.eval() ar_params_gbdt = self.network(gbdt_embed) @@ -457,7 +463,20 @@ def _calculate_gradients_and_hessians_separate(self, loss: torch.Tensor, embeds: def _calculate_gradients_and_hessians_separate_gn(self, loss: torch.Tensor, embeds: torch.Tensor) -> Tuple[np.ndarray, np.ndarray]: - """Gauss-Newton Hessian for separate gradient mode via Hutchinson probing.""" + """Gauss-Newton Hessian for separate gradient mode via Hutchinson probing. + + Parameters + ---------- + loss : torch.Tensor + Loss value from the model. + embeds : torch.Tensor + GBDT embeddings, shape ``(n_samples, embedding_dim)``. + + Returns + ------- + Tuple[np.ndarray, np.ndarray] + Gradients and hessians as numpy arrays in the format expected by LightGBM. + """ grad = autograd(loss, inputs=embeds, retain_graph=True)[0] rng = torch.Generator().manual_seed(self._iter_count) hess = self._gn_hessian.estimate(self._fit, self._target, embeds, rng) @@ -500,9 +519,6 @@ def _calculate_gradients_and_hessians_shared(self, loss: torch.Tensor, embeds: t # Update network parameters self.optimizer.step() - # Store network state - HyperTreeNetAR._network_states = self.network.state_dict() - # Clear existing gradients to prevent accumulation embeds.grad = None self.optimizer.zero_grad() @@ -510,7 +526,21 @@ def _calculate_gradients_and_hessians_shared(self, loss: torch.Tensor, embeds: t return grad, hess def _calculate_gradients_and_hessians_shared_gn(self, loss: torch.Tensor, embeds: torch.Tensor) -> Tuple[np.ndarray, np.ndarray]: - """Gauss-Newton Hessian for shared gradient mode via Hutchinson probing.""" + """Gauss-Newton Hessian for shared gradient mode via Hutchinson probing. + + Parameters + ---------- + loss : torch.Tensor + Loss value from the model (already backpropagated by + ``get_embeds_loss_shared``, which populates ``embeds.grad``). + embeds : torch.Tensor + GBDT embeddings, shape ``(n_samples, embedding_dim)``. + + Returns + ------- + Tuple[np.ndarray, np.ndarray] + Gradients and hessians as numpy arrays in the format expected by LightGBM. + """ grad = embeds.grad rng = torch.Generator().manual_seed(self._iter_count) hess = self._gn_hessian.estimate(self._fit, self._target, embeds, rng) @@ -519,7 +549,6 @@ def _calculate_gradients_and_hessians_shared_gn(self, loss: torch.Tensor, embeds grad = grad.cpu().detach().numpy().ravel(order="F") hess = hess.cpu().detach().numpy().ravel(order="F") self.optimizer.step() - HyperTreeNetAR._network_states = self.network.state_dict() embeds.grad = None self.optimizer.zero_grad() @@ -658,6 +687,11 @@ def train( gbdt_params = lgb_params.copy() self.embedding_dim = network_params["embedding_dimension"] + # Seed torch before constructing the MLP so initialization (and dropout + # draws during training) are reproducible even when the random + # projection layer -- whose constructor reseeds torch -- is disabled. + torch.manual_seed(seed) + self.network = MLP( tree_embed_dim=self.embedding_dim, output_dim=self.p, @@ -696,10 +730,11 @@ def train( else: self.calculate_gradients_and_hessians = self._calculate_gradients_and_hessians_shared_gn - # GBDT parameters + # GBDT parameters. The objective wrapper stops lgb.train's params + # deepcopy from cloning this instance (see NoDeepcopyObjective). self.lgb_params = { "num_class": self.embedding_dim, - "objective": self.objective_fn, + "objective": NoDeepcopyObjective(self.objective_fn), "metric": "None", "random_seed": seed, "verbose": verbose @@ -941,8 +976,8 @@ def forecast( device=self.device ).reshape(-1, self.embedding_dim) - # Load saved network state - self.network.load_state_dict(HyperTreeNetAR._network_states) + # self.network holds this instance's trained weights (boosting + # updated it in place; see NoDeepcopyObjective). self.network.eval() if type == "forecast": diff --git a/hypertrees/models/HyperTreeSTL.py b/hypertrees/models/HyperTreeSTL.py index 2581696..3ef1414 100644 --- a/hypertrees/models/HyperTreeSTL.py +++ b/hypertrees/models/HyperTreeSTL.py @@ -11,7 +11,7 @@ from ..utils import CustomLogger lgb.register_logger(CustomLogger()) -from ..utils import TimeSeriesPreprocessor, prepare_datasets, TrainingResult, validate_series_order +from ..utils import TimeSeriesPreprocessor, prepare_datasets, TrainingResult, validate_series_order, NoDeepcopyObjective class HyperTreeSTL: """ @@ -112,7 +112,10 @@ def __init__( Forecast horizon (number of periods to forecast ahead). loss_fn : Callable Loss function for optimization. Must be a PyTorch loss function. - Default is MSE loss, but can be changed for different error metrics. + Default is MSE loss. Losses other than nn.MSELoss are not + recommended, as they have not been systematically tested yet. + nn.L1Loss is rejected (zero second derivative almost everywhere + breaks Newton boosting). type : str Type of model variant to use. Currently, "default" and "paper" are supported: - "paper" uses the original method from the paper @@ -127,6 +130,13 @@ def __init__( raise ValueError("Forecast horizon 'fcst_h' must be a positive integer.") if not isinstance(loss_fn, nn.Module): raise TypeError("loss_fn must be a PyTorch loss function.") + if isinstance(loss_fn, nn.L1Loss): + raise ValueError( + "nn.L1Loss is not supported: its second derivative is zero almost " + "everywhere, so LightGBM's Newton boosting receives all-zero Hessians " + "and cannot grow trees. Use nn.HuberLoss or nn.SmoothL1Loss for an " + "MAE-like loss with usable curvature." + ) if not isinstance(freq, str): raise TypeError("freq must be a string representing the frequency of the time series.") if type not in ["default", "paper"]: @@ -408,6 +418,9 @@ def _forward_default( Forward pass to calculate the trend and seasonality from STL parameters. This implementation includes an updated trend smoothing method and more efficient seasonality calculation. + The trend smoothing window (params[:, :, 2]) is learnable: it enters + through a differentiable soft-boxcar kernel so gradients reach the GBDT. + Parameters ---------- params : torch.Tensor @@ -429,21 +442,37 @@ def _forward_default( slope = params[:, :, 1] trend_raw = intercept + slope * time_idx - # Map logit -> odd window size W in [3, max_w] - max_w = min(2 * m + 1, 101) + # Map logit -> effective window width in [3, max_w_model] per series. + # The width enters through a *soft* boxcar kernel so gradients flow back + # to the window parameter; a hard int(median(...).item()) cut would + # sever the autograd graph, giving zero gradient AND zero Hessian, and + # LightGBM would grow zero-valued trees for it (the window would stay + # frozen at its sigmoid(0) midpoint forever). + max_w_model = min(2 * m + 1, 101) w_logit = params[:, :, 2] - w_float = (max_w - 3) * torch.sigmoid(w_logit) + 3.0 - W = int(torch.median(torch.round(w_float)).clamp(3, max_w).item()) - if W % 2 == 0: - W += 1 - - # Grouped conv expects channels divisible by groups. - # Put series in the *channel* dimension: input (1, N, T), weight (N, 1, W), groups=N. - k = torch.ones((N, 1, W), dtype=dtype) / W # (N,1,W) - xin = trend_raw.T.contiguous().unsqueeze(0) # (1,N,T) - pad = W // 2 - xpad = torch.nn.functional.pad(xin, (pad, pad), mode="reflect") # (1,N,T+2p) - trend = torch.nn.functional.conv1d(xpad, k, groups=N).squeeze(0).T # (T,N) + w_eff = (max_w_model - 3.0) * torch.sigmoid(w_logit.mean(dim=0)) + 3.0 # (N,) + + # Kernel support: reflect padding requires pad <= T - 1, so cap the + # support at 2T - 1 (short forecast horizons used to crash here when + # W // 2 exceeded T - 1). Both arguments are odd, so K stays odd. + K = min(max_w_model, 2 * T - 1) + + if K >= 3: + w_eff = torch.clamp(w_eff, max=float(K)) + half = K // 2 + offsets = torch.arange(-half, half + 1, dtype=dtype).abs().view(1, -1) # (1,K) + # Soft boxcar: weight ~ 1 inside +-w_eff/2, smoothly decaying outside. + k = torch.sigmoid(w_eff.view(-1, 1) / 2.0 - offsets) # (N,K) + k = (k / k.sum(dim=1, keepdim=True)).unsqueeze(1) # (N,1,K) + + # Grouped conv expects channels divisible by groups. + # Put series in the *channel* dimension: input (1, N, T), weight (N, 1, K), groups=N. + xin = trend_raw.T.contiguous().unsqueeze(0) # (1,N,T) + xpad = torch.nn.functional.pad(xin, (half, half), mode="reflect") # (1,N,T+2*half) + trend = torch.nn.functional.conv1d(xpad, k, groups=N).squeeze(0).T # (T,N) + else: + # Series too short to smooth (T == 1); keep the raw linear trend. + trend = trend_raw # Seasonality: Fourier with per-cycle zero-mean centering H = (self.n_params - 3) // 2 @@ -463,7 +492,12 @@ def _forward_default( C = (T + m - 1) // m pad_T = C * m - T if pad_T > 0: - tail = torch.flip(seasonality[-min(T, pad_T):, :], dims=[0]) + # Extend by reflection. When the series is shorter than the padding + # (T < pad_T, i.e. less than half a seasonal cycle observed), keep + # ping-ponging the reflection until a full cycle can be assembled. + tail = torch.flip(seasonality, dims=[0]) + while tail.shape[0] < pad_T: + tail = torch.cat([tail, torch.flip(tail, dims=[0])], dim=0) S_ext = torch.cat([seasonality, tail[:pad_T]], dim=0) # (C*m,N) else: S_ext = seasonality @@ -576,10 +610,11 @@ def train( raise NotImplementedError(f"You have provided {self.n_series} series. Currently, HyperTreeSTL only supports univariate training (1 series at a time). Please train separate models for each series.") self.train_series_id = train_data['series_id'].unique()[0] - # General model parameters + # General model parameters. The objective wrapper stops lgb.train's + # params deepcopy from cloning this instance (see NoDeepcopyObjective). self.lgb_params = { "num_class": self.n_params, - "objective": self.objective_fn, + "objective": NoDeepcopyObjective(self.objective_fn), "metric": "None", "random_seed": seed, "verbose": verbose diff --git a/hypertrees/models/mlp.py b/hypertrees/models/mlp.py index 28c7ee5..7527e93 100644 --- a/hypertrees/models/mlp.py +++ b/hypertrees/models/mlp.py @@ -14,6 +14,15 @@ class RPLayer(nn.Module): In Proceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining (KDD '24). Association for Computing Machinery, New York, NY, USA, 3919–3930. https://doi.org/10.1145/3637528.3671881 + + Parameters + ---------- + in_dim : int + Dimension of the input (the tree embeddings). + out_dim : int + Output dimension of the random projection. + seed : int + Random seed used to draw the fixed (non-trainable) projection weights. """ def __init__(self, in_dim: int, out_dim: int, seed: int): diff --git a/hypertrees/utils.py b/hypertrees/utils.py index 0d32bc5..4f4ae6a 100644 --- a/hypertrees/utils.py +++ b/hypertrees/utils.py @@ -1,6 +1,6 @@ import pandas as pd import numpy as np -from typing import List, Dict, Optional, Any, Tuple +from typing import Callable, List, Dict, Optional, Any, Tuple import torch import torch.nn as nn from torch.autograd import grad as autograd @@ -86,15 +86,47 @@ def validate_series_order(data: pd.DataFrame, name: str = "data") -> None: f"`{name} = {name}.sort_values(['series_id', 'date']).reset_index(drop=True)`." ) - # Check 2: within each series, `date` must be strictly increasing. + # Check 2: within each series, `date` must be strictly increasing + # (monotonic AND free of duplicates -- is_monotonic_increasing alone is + # non-strict and would let duplicate dates through). for series_id, group in data.groupby("series_id", sort=False): - if not pd.to_datetime(group["date"]).is_monotonic_increasing: + dates = pd.to_datetime(group["date"]) + if not (dates.is_monotonic_increasing and dates.is_unique): raise ValueError( f"{name}: 'date' is not strictly increasing within series " - f"'{series_id}'. Fix with " - f"`{name} = {name}.sort_values(['series_id', 'date']).reset_index(drop=True)`." + f"'{series_id}' (out-of-order or duplicate dates). Sort with " + f"`{name} = {name}.sort_values(['series_id', 'date']).reset_index(drop=True)` " + f"and remove or aggregate duplicate dates." ) +class NoDeepcopyObjective: + """Keep a custom LightGBM objective bound to the live model instance. + + ``lgb.train`` deep-copies its ``params`` dict before extracting a callable + objective, so a bound method would be cloned together with its whole model + instance and boosting would train that hidden copy. This wrapper survives + ``deepcopy``/``copy`` by reference, keeping the objective pointed at the + original, live model. + + Parameters + ---------- + fn : Callable + The objective callable (typically ``self.objective_fn``). + """ + + def __init__(self, fn: Callable): + self._fn = fn + + def __call__(self, *args, **kwargs): + return self._fn(*args, **kwargs) + + def __deepcopy__(self, memo): + return self + + def __copy__(self): + return self + + class CustomLogger: def __init__(self): self.logger = logging.getLogger('lightgbm_custom') @@ -439,7 +471,20 @@ def __init__(self, loss_fn: nn.Module, n_probes: int = 5, dtype: torch.dtype = t self.estimate = self._general def _compute_loss_curvature(self, fit: torch.Tensor, target: torch.Tensor) -> torch.Tensor: - """Per-element d^2L/d(y_hat)^2 via autograd.""" + """Per-element d^2L/d(y_hat)^2 via autograd. + + Parameters + ---------- + fit : torch.Tensor + Fitted values. + target : torch.Tensor + Target values, same shape as ``fit``. + + Returns + ------- + torch.Tensor + Detached per-element loss curvature, same shape as ``fit``. + """ fit_leaf = fit.detach().requires_grad_(True) loss_local = self.loss_fn(fit_leaf, target.detach()) grad1 = autograd(loss_local, fit_leaf, create_graph=True)[0] @@ -453,7 +498,24 @@ def _mse( params: torch.Tensor, rng: torch.Generator, ) -> torch.Tensor: - """Hutchinson diagonal Hessian for MSELoss (constant curvature B = 2/N).""" + """Hutchinson diagonal Hessian for MSELoss (constant curvature B = 2/N). + + Parameters + ---------- + fit : torch.Tensor + Fitted values (graph-connected to ``params``). + target : torch.Tensor + Target values (unused for MSE; curvature is constant). + params : torch.Tensor + Parameters w.r.t. which the Hessian diagonal is estimated. + rng : torch.Generator + Seeded generator for the Gaussian probe vectors. + + Returns + ------- + torch.Tensor + Estimated Hessian diagonal, same shape as ``params``. + """ N = fit.numel() hess_sum = torch.zeros_like(params) for _ in range(self.n_probes): @@ -469,7 +531,24 @@ def _general( params: torch.Tensor, rng: torch.Generator, ) -> torch.Tensor: - """Hutchinson diagonal Hessian for arbitrary twice-differentiable losses.""" + """Hutchinson diagonal Hessian for arbitrary twice-differentiable losses. + + Parameters + ---------- + fit : torch.Tensor + Fitted values (graph-connected to ``params``). + target : torch.Tensor + Target values, same shape as ``fit``. + params : torch.Tensor + Parameters w.r.t. which the Hessian diagonal is estimated. + rng : torch.Generator + Seeded generator for the Gaussian probe vectors. + + Returns + ------- + torch.Tensor + Estimated Hessian diagonal, same shape as ``params``. + """ loss_curv = self._compute_loss_curvature(fit, target) sqrt_curv = loss_curv.clamp(min=0.0).sqrt() hess_sum = torch.zeros_like(params) diff --git a/tests/test_conformal.py b/tests/test_conformal.py index 366a97d..083fbad 100644 --- a/tests/test_conformal.py +++ b/tests/test_conformal.py @@ -41,6 +41,32 @@ def test_distribution_vs_error_bands_symmetry(): assert np.all(d90[1] >= d80[1] - 1e-9) # upper bound wider +def test_bands_ignore_nan_scores(): + """NaN scores (residuals at padded pseudo-observations) are excluded. + + Both band methods must compute quantiles only over the non-NaN windows; + series without NaN scores must be unaffected. + """ + rng = np.random.default_rng(0) + point = rng.standard_normal((2, 3)) + scores = np.abs(rng.standard_normal((5, 2, 3))) + + scores_nan = scores.copy() + scores_nan[0, 0, :] = np.nan # series 0: first calibration window is padding + + for fn in (_error_bands, _distribution_bands): + lo, hi = fn(point, scores_nan, [90])[90] + assert np.isfinite(lo).all() and np.isfinite(hi).all() + # series 1 (no NaNs) is unaffected + ref_lo, ref_hi = fn(point, scores, [90])[90] + np.testing.assert_allclose(lo[1], ref_lo[1]) + np.testing.assert_allclose(hi[1], ref_hi[1]) + # series 0 equals the bands computed from the remaining windows only + red_lo, red_hi = fn(point[[0]], scores[1:, [0], :], [90])[90] + np.testing.assert_allclose(lo[0], red_lo[0]) + np.testing.assert_allclose(hi[0], red_hi[0]) + + def test_align_scores_reorders_series_axis(): """_align_scores should permute the series axis to match target_order.""" # scores[:, i, :] == i so we can track where each series lands @@ -155,3 +181,44 @@ def fake_forecast(test_data, type="forecast"): assert scores.shape == (n_windows, n_series, fcst_h) # residuals should all be 0.5 (our fake_forecast adds 0.5) np.testing.assert_allclose(scores, 0.5) + + +def test_rolling_origin_residuals_masks_padded_rows(): + """Residuals at padded rows (mask == 0) must be NaN in the scores.""" + T, fcst_h = 12, 3 + dates = pd.date_range("2020-01-01", periods=T, freq="MS") + train_data = pd.DataFrame({ + "series_id": 0, + "date": dates, + "value": np.arange(T, dtype=float), + "mask": [1] * (T - 2) + [0, 0], # last two rows are padding + }) + + mock_model = MagicMock() + + def fake_forecast(test_data, type="forecast"): + return pd.DataFrame({ + "series_id": test_data["series_id"].values, + "date": test_data["date"].values, + "fcst": test_data["value"].values + 0.5, + "model": "mock", + }) + + mock_model.forecast = MagicMock(side_effect=fake_forecast) + mock_model.train = MagicMock() + + pi = ForecastIntervals(n_windows=2, step_size=1, refit=True) + scores, _ = rolling_origin_residuals( + model_factory=lambda: mock_model, + train_data=train_data, + fcst_h=fcst_h, + forecast_intervals=pi, + train_kwargs={}, + ) + + # Window 0 tests the last 3 rows: positions 1 and 2 are padding -> NaN + np.testing.assert_allclose(scores[0, 0, 0], 0.5) + assert np.isnan(scores[0, 0, 1]) and np.isnan(scores[0, 0, 2]) + # Window 1 tests rows T-4..T-2: only the last is padding -> NaN + np.testing.assert_allclose(scores[1, 0, :2], 0.5) + assert np.isnan(scores[1, 0, 2]) diff --git a/tests/test_hypertree_ar.py b/tests/test_hypertree_ar.py index bb35f1b..65d7174 100644 --- a/tests/test_hypertree_ar.py +++ b/tests/test_hypertree_ar.py @@ -29,14 +29,14 @@ def test_default_initialization(self): def test_custom_initialization(self): """Test model initialization with custom parameters.""" - loss_fn = nn.L1Loss() + loss_fn = nn.HuberLoss() model = HyperTreeAR(p=5, freq="D", fcst_h=3, loss_fn=loss_fn) assert model.p == 5 assert model.freq == "D" assert model.fcst_h == 3 assert model.loss_fn == loss_fn - assert model.loss_name == "L1Loss" + assert model.loss_name == "HuberLoss" def test_invalid_p_parameter(self): """Test that invalid p parameter raises ValueError.""" @@ -70,20 +70,34 @@ def test_gn_hessian_initialization(self): assert hasattr(model, '_gn_hessian') def test_default_hessian_method(self): - """Test that default hessian method is exact.""" + """Test that the default hessian method is the analytic fast path.""" model = HyperTreeAR() - assert model.hessian_method == "exact" + assert model.hessian_method == "analytic" assert not hasattr(model, '_gn_hessian') def test_invalid_hessian_method(self): """Test that invalid hessian_method raises ValueError.""" - with pytest.raises(ValueError, match="hessian_method must be either 'exact' or 'gn'"): + with pytest.raises(ValueError, match="hessian_method must be one of 'exact', 'analytic', or 'gn'"): HyperTreeAR(hessian_method="invalid") + def test_analytic_hessian_initialization(self): + """Test model initialization with the analytic hessian method.""" + model = HyperTreeAR(hessian_method="analytic") + assert model.hessian_method == "analytic" + assert not hasattr(model, '_gn_hessian') + assert model.calculate_gradients_and_hessians == model._calculate_gradients_and_hessians_analytic + def test_gn_hessian_warning_non_mse(self): """Test that warning is issued for non-MSE loss with GN.""" with pytest.warns(UserWarning, match="not nn.MSELoss"): - HyperTreeAR(hessian_method="gn", loss_fn=nn.L1Loss()) + HyperTreeAR(hessian_method="gn", loss_fn=nn.HuberLoss()) + + def test_l1_loss_rejected(self): + """nn.L1Loss must be rejected: its second derivative is zero almost + everywhere, so Newton boosting would receive all-zero Hessians and + could not grow trees.""" + with pytest.raises(ValueError, match="L1Loss is not supported"): + HyperTreeAR(loss_fn=nn.L1Loss()) def test_invalid_freq_type(self): """Test that non-string freq raises TypeError.""" @@ -498,8 +512,15 @@ def test_get_params_loss_with_gradients(self, model): # Check that parameters require gradients assert params.requires_grad - def test_calculate_gradients_and_hessians(self, model): - """Test gradient and hessian calculation.""" + def test_calculate_gradients_and_hessians(self): + """Test gradient and hessian calculation (exact autograd path). + + Uses an explicit hessian_method="exact" model: only the exact path can + differentiate a hand-built loss; "analytic" (the default) relies on + the fit/target/lags stored by get_params_loss. + """ + model = HyperTreeAR(p=2, hessian_method="exact") + # Create parameters that require gradients params = torch.randn(5, 2, requires_grad=True) @@ -1148,7 +1169,7 @@ def test_eval_fn_different_loss_functions(self): """Test eval_fn with different loss functions.""" loss_functions = [ (nn.MSELoss(), "MSELoss"), - (nn.L1Loss(), "L1Loss"), + (nn.HuberLoss(), "HuberLoss"), (nn.SmoothL1Loss(), "SmoothL1Loss") ] @@ -1306,3 +1327,79 @@ def test_invalid_level_value(self, calibrated): model, _, test = calibrated with pytest.raises(ValueError): model.forecast(test_data=test, level=[150]) + + +class TestHyperTreeARAnalyticHessian: + """Tests for hessian_method='analytic' (closed-form via model linearity).""" + + @staticmethod + def _grad_hess(method, loss_fn, predt, target, lags, p): + """Run one objective-style grad/hess computation with the given method.""" + model = HyperTreeAR(p=p, loss_fn=loss_fn, hessian_method=method) + params, loss = model.get_params_loss(predt, target, lags, requires_grad=True) + return model.calculate_gradients_and_hessians(loss, params) + + def test_analytic_matches_exact_across_losses(self): + """Analytic grad/hess must equal the autograd 'exact' path. + + Covers the MSE fast path (no autograd) and the generic + double-backward path (Huber, SmoothL1). + """ + torch.manual_seed(0) + n, p = 40, 3 + rng = np.random.default_rng(0) + predt = rng.standard_normal(n * p) + lags = torch.randn(n, p) + target = torch.randn(n, 1) * 5 + + for loss_fn in [nn.MSELoss(), nn.HuberLoss(), nn.SmoothL1Loss()]: + g_exact, h_exact = self._grad_hess("exact", loss_fn, predt.copy(), target, lags, p) + g_analytic, h_analytic = self._grad_hess("analytic", loss_fn, predt.copy(), target, lags, p) + np.testing.assert_allclose( + g_analytic, g_exact, rtol=1e-5, atol=1e-7, + err_msg=f"gradient mismatch for {type(loss_fn).__name__}", + ) + np.testing.assert_allclose( + h_analytic, h_exact, rtol=1e-5, atol=1e-7, + err_msg=f"hessian mismatch for {type(loss_fn).__name__}", + ) + + def test_analytic_matches_exact_sum_reduction(self): + """The MSE fast path must honor reduction='sum' as well.""" + n, p = 25, 2 + rng = np.random.default_rng(1) + predt = rng.standard_normal(n * p) + lags = torch.randn(n, p) + target = torch.randn(n, 1) + + loss_fn = nn.MSELoss(reduction="sum") + g_exact, h_exact = self._grad_hess("exact", loss_fn, predt.copy(), target, lags, p) + g_analytic, h_analytic = self._grad_hess("analytic", loss_fn, predt.copy(), target, lags, p) + np.testing.assert_allclose(g_analytic, g_exact, rtol=1e-5, atol=1e-6) + np.testing.assert_allclose(h_analytic, h_exact, rtol=1e-5, atol=1e-6) + + def test_train_and_forecast_with_analytic(self): + """End-to-end training with hessian_method='analytic' works.""" + n = 30 + dates = pd.date_range("2020-01-01", periods=n, freq="D") + train = pd.DataFrame({ + "series_id": "S1", + "date": dates, + "value": 100 + 10 * np.sin(np.arange(n) / 3), + "dow": dates.dayofweek.astype(float), + }) + test = pd.DataFrame({ + "series_id": "S1", + "date": pd.date_range(dates[-1] + pd.Timedelta(days=1), periods=2, freq="D"), + "dow": [0.0, 1.0], + }) + + model = HyperTreeAR(p=2, freq="D", fcst_h=2, hessian_method="analytic") + model.train( + lgb_params={"learning_rate": 0.1, "min_data_in_leaf": 2}, + num_iterations=5, + train_data=train, + ) + out = model.forecast(test_data=test) + assert len(out) == 2 + assert np.isfinite(out["fcst"]).all() diff --git a/tests/test_hypertree_ets.py b/tests/test_hypertree_ets.py index 82d3895..d6151a8 100644 --- a/tests/test_hypertree_ets.py +++ b/tests/test_hypertree_ets.py @@ -894,3 +894,187 @@ def test_level_without_calibration_raises(self, split): model.train(lgb_params=self.LGB_PARAMS, num_iterations=20, train_data=train) with pytest.raises(RuntimeError, match="not calibrated"): model.forecast(test_data=test, level=[90]) + + +class TestInitTripleStates: + """Tests for the decomposition-based state initialization (statsforecast-style).""" + + def test_l1_loss_rejected(self): + """nn.L1Loss is rejected: zero curvature yields all-zero Hessians.""" + with pytest.raises(ValueError, match="L1Loss is not supported"): + HyperTreeETS( + ets_type="triple", season_length=4, seasonality_feature="month", + loss_fn=nn.L1Loss(), + ) + + def test_seasonal_init_default_and_validation(self): + """Default is 'classical'; invalid values raise.""" + model = HyperTreeETS( + ets_type="triple", season_length=4, seasonality_feature="month" + ) + assert model.seasonal_init == "classical" + + legacy = HyperTreeETS( + ets_type="triple", season_length=4, seasonality_feature="month", + seasonal_init="legacy", + ) + assert legacy.seasonal_init == "legacy" + + with pytest.raises(ValueError, match="seasonal_init must be either"): + HyperTreeETS( + ets_type="triple", season_length=4, seasonality_feature="month", + seasonal_init="bogus", + ) + + def test_legacy_init_reproduces_pre_020_formula(self): + """seasonal_init='legacy' must match the pre-0.2.0 code verbatim, + so earlier results (incl. the paper benchmarks) stay reproducible.""" + m, cycles = 4, 5 + T = m * cycles + torch.manual_seed(3) + y = 100.0 + torch.rand(1, T) * 50.0 + mask = torch.ones_like(y) + slots = (torch.arange(T) % m).view(1, -1) + + model = HyperTreeETS( + ets_type="triple", season_length=m, seasonality_feature="month", + seasonal_init="legacy", + ) + model.n_series = 1 + seasonality, level0, trend0 = model._init_triple_states(y, mask, slots) + + # Reference: the original (pre-0.2.0) implementation, replicated verbatim + init_len = min(m, T) + seasonal_avg = torch.zeros((1, init_len)) + for i in range(init_len): + valid_obs = mask[:, i::init_len] + seasonal_avg[:, i] = (y[:, i::init_len] * valid_obs.float()).sum( + 1) / valid_obs.float().sum(1).clamp(min=1) + ref_seasonality = y[:, :init_len] / (seasonal_avg + model.eps) + ref_season_adj = y[:, :init_len] / ref_seasonality[:, :init_len] + + torch.testing.assert_close(seasonality, ref_seasonality) + torch.testing.assert_close(level0, ref_season_adj[:, 0]) + torch.testing.assert_close(trend0, ref_season_adj[:, 1] - ref_season_adj[:, 0]) + + def test_recovers_seasonality_and_trend_with_offset_start(self): + """The init must recover the seasonal shape under a linear trend, + with correct slot alignment for a series starting mid-season. + + The old positional init both cancelled the seasonal shape and, even + when shape-preserving, rotated the profile for series not starting + at season position 1. + """ + m, cycles = 4, 6 + T = m * cycles + S = torch.tensor([0.8, 1.2, 1.1, 0.9]) # mean exactly 1.0 + start_offset = 1 # series starts at season position 2 (slot index 1) + slots = (start_offset + torch.arange(T)) % m + trend = 10.0 + 0.5 * torch.arange(T, dtype=torch.float32) + y = (trend * S[slots]).view(1, -1) + mask = torch.ones_like(y) + + model = HyperTreeETS( + ets_type="triple", season_length=m, seasonality_feature="month" + ) + model.n_series = 1 + + seasonality, level0, trend0 = model._init_triple_states( + y, mask, slots.view(1, -1) + ) + + # Seasonal shape recovered in SLOT order despite trend and offset start + assert seasonality.shape == (1, m) + torch.testing.assert_close(seasonality[0], S, atol=0.05, rtol=0.0) + # OLS seeds: slope ~ 0.5, level ~ value of the trend line at t = 1 + assert abs(trend0.item() - 0.5) < 0.1 + assert abs(level0.item() - 10.5) < 0.5 + + def test_short_series_falls_back_without_crash(self): + """Series shorter than the MA kernel use the simple per-slot fallback.""" + m = 12 + model = HyperTreeETS( + ets_type="triple", season_length=m, seasonality_feature="month" + ) + model.n_series = 1 + for T in [1, 3, 6]: + y = 100.0 + torch.arange(T, dtype=torch.float32).view(1, -1) + mask = torch.ones_like(y) + slots = (torch.arange(T) % m).view(1, -1) + seasonality, level0, trend0 = model._init_triple_states(y, mask, slots) + assert seasonality.shape == (1, m) + assert torch.isfinite(seasonality).all() + assert (seasonality > 0).all() + assert torch.isfinite(level0).all() and torch.isfinite(trend0).all() + + def test_init_cached_per_dataset(self): + """The init must compute once per dataset, not once per boosting iteration. + + Cache hits must return the pristine initialization even though the + recursion mutates the returned seasonality tensor in place. + """ + m, cycles = 4, 6 + T = m * cycles + y = (100.0 + torch.arange(T, dtype=torch.float32)).view(1, -1) + mask = torch.ones_like(y) + slots = (torch.arange(T) % m).view(1, -1) + + model = HyperTreeETS( + ets_type="triple", season_length=m, seasonality_feature="month" + ) + model.n_series = 1 + + calls = {"n": 0} + orig = model._init_triple_states + + def counting(*args, **kwargs): + calls["n"] += 1 + return orig(*args, **kwargs) + + model._init_triple_states = counting + + data_a, data_b = object(), object() # only identity is used as cache key + + s1, l1, t1 = model._cached_init_triple_states(data_a, y, mask, slots) + s2, l2, t2 = model._cached_init_triple_states(data_a, y, mask, slots) + assert calls["n"] == 1 # second call is a cache hit + torch.testing.assert_close(s1, s2) + torch.testing.assert_close(l1, l2) + torch.testing.assert_close(t1, t2) + + # In-place mutation of a returned tensor must not poison the cache + s1[0, 0] = 123.0 + s3, _, _ = model._cached_init_triple_states(data_a, y, mask, slots) + assert calls["n"] == 1 + assert s3[0, 0].item() != 123.0 + + # A different dataset object recomputes + model._cached_init_triple_states(data_b, y, mask, slots) + assert calls["n"] == 2 + + # Entries pin their dataset object, so a key hit can only come from + # that exact, still-alive dataset (ids of live objects are unique). + assert model._init_cache[id(data_a)]["data"] is data_a + + def test_padded_rows_do_not_distort_indices(self): + """Masked (padded) observations must not contribute to the init.""" + m, cycles = 4, 5 + T_real = m * cycles + pad_len = 6 + S = torch.tensor([0.8, 1.2, 1.1, 0.9]) + slots_real = torch.arange(T_real) % m + y_real = 50.0 * S[slots_real] + + # Back-append garbage values that the mask flags as padding + y = torch.cat([y_real, torch.full((pad_len,), 9999.0)]).view(1, -1) + mask = torch.cat([torch.ones(T_real), torch.zeros(pad_len)]).view(1, -1) + slots = (torch.arange(T_real + pad_len) % m).view(1, -1) + + model = HyperTreeETS( + ets_type="triple", season_length=m, seasonality_feature="month" + ) + model.n_series = 1 + seasonality, level0, _ = model._init_triple_states(y, mask, slots) + + torch.testing.assert_close(seasonality[0], S, atol=0.05, rtol=0.0) + assert abs(level0.item() - 50.0) < 2.5 diff --git a/tests/test_hypertree_net_ar.py b/tests/test_hypertree_net_ar.py index c7e9d19..731329c 100644 --- a/tests/test_hypertree_net_ar.py +++ b/tests/test_hypertree_net_ar.py @@ -30,14 +30,14 @@ def test_default_initialization(self): def test_custom_initialization(self): """Test model initialization with custom parameters.""" - loss_fn = nn.L1Loss() + loss_fn = nn.HuberLoss() model = HyperTreeNetAR(p=5, freq="D", fcst_h=3, loss_fn=loss_fn, device="cuda") - + assert model.p == 5 assert model.freq == "D" assert model.fcst_h == 3 assert model.loss_fn == loss_fn - assert model.loss_name == "L1Loss" + assert model.loss_name == "HuberLoss" assert model.device == "cuda" def test_invalid_p_parameter(self): @@ -85,7 +85,12 @@ def test_invalid_hessian_method(self): def test_gn_hessian_warning_non_mse(self): """Test that warning is issued for non-MSE loss with GN.""" with pytest.warns(UserWarning, match="not nn.MSELoss"): - HyperTreeNetAR(hessian_method="gn", loss_fn=nn.L1Loss()) + HyperTreeNetAR(hessian_method="gn", loss_fn=nn.HuberLoss()) + + def test_l1_loss_rejected(self): + """nn.L1Loss is rejected: zero curvature yields all-zero Hessians.""" + with pytest.raises(ValueError, match="L1Loss is not supported"): + HyperTreeNetAR(loss_fn=nn.L1Loss()) def test_invalid_freq_type(self): """Test that non-string freq raises TypeError.""" @@ -395,9 +400,6 @@ def mock_network_call(x): mock_network.side_effect = mock_network_call model.network = mock_network - # Mock network state - HyperTreeNetAR._network_states = {} - # Mock the stored forecast lags (last 2 values for each series in reverse order) model.fcst_lags = { 0: np.array([11, 10]), # Series 0: [newest, oldest] @@ -728,36 +730,36 @@ def test_calculate_gradients_and_hessians_shared_gn(self): assert np.isfinite(grad).all() assert np.isfinite(hess).all() - def test_eval_function_with_network_state(self, model): - """Test evaluation function with proper network state handling.""" + def test_eval_function_uses_live_network(self, model): + """eval_fn must use the live self.network directly (no state reload).""" model.embedding_dim = 2 model.device = "cpu" model.dataset_references = {} model.lags_train = torch.randn(3, 2) - + # Mock network mock_network = Mock() mock_network.eval.return_value = None - mock_network.load_state_dict.return_value = None def mock_network_call(x): return torch.randn(3, 2) mock_network.side_effect = mock_network_call model.network = mock_network - - # Store network state - HyperTreeNetAR._network_states = {} - + # Setup test data predt = np.random.randn(6) # 3 samples * 2 embeddings mock_data = Mock() mock_data.get_label.return_value = np.array([1.0, 2.0, 3.0]) - + metric_name, metric_value, is_higher_better = model.eval_fn(predt, mock_data) # Check outputs assert metric_name == model.loss_name assert isinstance(metric_value, float) assert is_higher_better is False + # Regression guard: the network updated by the objective in the same + # boosting iteration is used as-is. Reloading from a stored state_dict + # is what previously allowed cross-instance weight leaks. + mock_network.load_state_dict.assert_not_called() class TestHyperTreeNetAREdgeCases: @@ -803,21 +805,81 @@ def test_different_frequencies(self): def test_different_loss_functions(self): """Test with different PyTorch loss functions.""" - loss_functions = [nn.MSELoss(), nn.L1Loss(), nn.HuberLoss()] + loss_functions = [nn.MSELoss(), nn.SmoothL1Loss(), nn.HuberLoss()] for loss_fn in loss_functions: model = HyperTreeNetAR(loss_fn=loss_fn) assert model.loss_fn == loss_fn assert model.loss_name == loss_fn.__class__.__name__ - def test_network_state_management(self): - """Test network state storage and retrieval.""" - model1 = HyperTreeNetAR(p=2) - model2 = HyperTreeNetAR(p=3) + def test_no_shared_network_state(self): + """Regression guard: no class-level network state shared across instances. + + A class-level ``_network_states`` allowed any later-trained instance + (e.g. the fresh models created during conformal calibration) to + overwrite the weights another instance loaded at forecast time. + """ + assert not hasattr(HyperTreeNetAR, "_network_states") + + def test_boosting_trains_this_instances_network(self): + """The boosting objective must train THIS instance's MLP decoder. + + ``lgb.train`` deep-copies its params dict before extracting the + objective; an unprotected bound-method objective gets re-bound to a + hidden deep copy of the model, leaving ``self.network`` at its random + initialization (``NoDeepcopyObjective`` guards against this). An + untrained network is detectable because the MLP init is + seed-deterministic: a fresh MLP built with the same seed has + identical weights. + """ + from hypertrees.models.mlp import MLP - # Test state storage - test_state = {'test': 'state'} - HyperTreeNetAR._network_states = test_state + n = 30 + dates = pd.date_range("2020-01-01", periods=n, freq="D") + rng = np.random.default_rng(0) + train_data = pd.DataFrame({ + "series_id": "S1", + "date": dates, + "value": 100 + np.sin(np.arange(n) / 3) * 10 + rng.normal(0, 1, n), + "dow": dates.dayofweek.astype(float), + }) + + seed = 123 + network_params = { + "learning_rate": 1e-2, + "embedding_dimension": 1, + "hidden_dim": 8, + "dropout": 0.1, + "use_random_projection": True, + "rp_embed_dim": 2, + } + model = HyperTreeNetAR(p=2, freq="D", fcst_h=2) + model.train( + lgb_params={"learning_rate": 0.1, "min_data_in_leaf": 2}, + network_params=network_params, + num_iterations=5, + train_data=train_data, + seed=seed, + ) + + fresh = MLP( + tree_embed_dim=1, + output_dim=model.p, + hidden_dim=network_params["hidden_dim"], + use_random_projection=True, + rp_embed_dim=network_params["rp_embed_dim"], + dropout_rate=network_params["dropout"], + seed=seed, + ) + fresh_params = dict(fresh.named_parameters()) + changed = any( + not torch.allclose(param.detach().cpu(), fresh_params[name].detach()) + for name, param in model.network.named_parameters() + ) + assert changed, ( + "self.network still has its seed-initial weights after training -- " + "the objective trained a deep copy of the model instead of this instance." + ) class TestHyperTreeNetARIntegration: @@ -924,9 +986,6 @@ def mock_network_call(x): return torch.randn(x.shape[0], 2) # Return appropriate size mock_network.side_effect = mock_network_call model.network = mock_network - - # Store network state - HyperTreeNetAR._network_states = {} # Mock the fcst_lags that would be created during real training # Get the last p values for each series (in reverse order: newest to oldest) diff --git a/tests/test_hypertree_stl.py b/tests/test_hypertree_stl.py index 5731909..7b5d118 100644 --- a/tests/test_hypertree_stl.py +++ b/tests/test_hypertree_stl.py @@ -29,7 +29,7 @@ def test_default_initialization(self): assert model.is_trained is False def test_custom_initialization(self): - loss_fn = nn.L1Loss() + loss_fn = nn.HuberLoss() model = HyperTreeSTL(period=24, num_seasonal_components=2, freq="D", fcst_h=6, loss_fn=loss_fn) assert model.period == 24 assert model.num_seasonal_components == 2 @@ -37,9 +37,14 @@ def test_custom_initialization(self): assert model.freq == "D" assert model.fcst_h == 6 assert model.loss_fn is loss_fn - assert model.loss_name == "L1Loss" + assert model.loss_name == "HuberLoss" assert model.forward_type == "default" + def test_l1_loss_rejected(self): + """nn.L1Loss is rejected: zero curvature yields all-zero Hessians.""" + with pytest.raises(ValueError, match="L1Loss is not supported"): + HyperTreeSTL(loss_fn=nn.L1Loss()) + def test_invalid_period(self): with pytest.raises(ValueError, match="Period must be a positive integer"): HyperTreeSTL(period=0) @@ -498,6 +503,38 @@ def test_forward_default_method(self): assert trend.shape == (n_samples, n_series) assert seasonality.shape == (n_samples, n_series) + def test_forward_default_window_param_receives_gradient(self): + """The learnable smoothing-window parameter must receive gradients. + + A hard ``int(median(...).item())`` window severed the autograd graph, + giving the parameter zero gradient and Hessian -- LightGBM then grew + zero-valued trees and the window never learned. + """ + torch.manual_seed(0) + model = HyperTreeSTL(period=12, num_seasonal_components=1, type="default") + T = 48 + params = torch.nn.Parameter(torch.randn(T, 1, model.n_params)) + time_idx = torch.arange(1, T + 1, dtype=torch.float32).reshape(T, 1) + + trend, seasonality = model._forward_default(params, time_idx) + loss = ((trend + seasonality) ** 2).mean() + loss.backward() + + assert params.grad is not None + assert params.grad[:, :, 2].abs().max() > 0 + + def test_forward_default_short_series_no_crash(self): + """Reflect padding must not exceed the input length for short horizons.""" + model = HyperTreeSTL(period=12, num_seasonal_components=1, type="default") + for T in [1, 2, 4, 6]: + params = torch.randn(T, 1, model.n_params) + time_idx = torch.arange(1, T + 1, dtype=torch.float32).reshape(T, 1) + trend, seasonality = model._forward_default(params, time_idx) + assert trend.shape == (T, 1) + assert seasonality.shape == (T, 1) + assert torch.isfinite(trend).all() + assert torch.isfinite(seasonality).all() + def test_forward_method_selection(self): """Test that the correct forward method is selected based on type.""" model_paper = HyperTreeSTL(type="paper") diff --git a/tests/test_utils.py b/tests/test_utils.py index 71207ea..9bd459d 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -385,6 +385,20 @@ def test_non_monotonic_dates(self): with pytest.raises(ValueError, match="not strictly increasing"): validate_series_order(data) + def test_duplicate_dates(self): + """Duplicate dates within a series must be rejected (strictness). + + ``is_monotonic_increasing`` alone is non-strict and would let + duplicates through, corrupting lag construction and reshapes. + """ + data = pd.DataFrame({ + 'series_id': [0, 0, 0], + 'date': pd.to_datetime(['2020-01-01', '2020-01-01', '2020-01-02']), + 'value': [1, 2, 3] + }) + with pytest.raises(ValueError, match="not strictly increasing"): + validate_series_order(data) + def test_valid_data_passes(self): """Test that properly ordered data passes validation.""" data = pd.DataFrame({ From a0ab40778448e02c6fbc93e6244f110642b541f7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20M=C3=A4rz?= Date: Thu, 11 Jun 2026 16:03:48 +0200 Subject: [PATCH 23/26] Add VAR and TSB models - HyperTreeVAR / HyperTreeNetVAR: VAR(p) over aligned panels with per-series scaling and a restricted GVAR-style factor design (type="factor") - HyperTreeTSB: intermittent demand with feature-driven smoothing rates - Additive-seasonality option for HyperTreeETS (ets_type="additive") - Example notebooks, README table rows, and release notes --- README.md | 3 + THIRD_PARTY_NOTICES | 28 +- examples/Basic Walkthrough.ipynb | 230 +++-- examples/Forecast Intervals.ipynb | 579 +++++++----- examples/HPO.ipynb | 677 ++++++++++++-- examples/TSB Intermittent Demand.ipynb | 501 +++++++++++ examples/VAR Models.ipynb | 598 +++++++++++++ examples/utils.py | 358 ++++++++ hypertrees/models/HyperTreeAR.py | 4 +- hypertrees/models/HyperTreeETS.py | 366 +++++++- hypertrees/models/HyperTreeNetAR.py | 37 +- hypertrees/models/HyperTreeNetVAR.py | 679 ++++++++++++++ hypertrees/models/HyperTreeSTL.py | 4 +- hypertrees/models/HyperTreeTSB.py | 964 ++++++++++++++++++++ hypertrees/models/HyperTreeVAR.py | 597 +++++++++++++ hypertrees/models/__init__.py | 3 + hypertrees/models/_var_base.py | 1136 ++++++++++++++++++++++++ hypertrees/utils.py | 10 +- tests/test_hypertree_ets.py | 229 ++++- tests/test_hypertree_tsb.py | 374 ++++++++ tests/test_hypertree_var.py | 1018 +++++++++++++++++++++ 21 files changed, 7927 insertions(+), 468 deletions(-) create mode 100644 examples/TSB Intermittent Demand.ipynb create mode 100644 examples/VAR Models.ipynb create mode 100644 hypertrees/models/HyperTreeNetVAR.py create mode 100644 hypertrees/models/HyperTreeTSB.py create mode 100644 hypertrees/models/HyperTreeVAR.py create mode 100644 hypertrees/models/_var_base.py create mode 100644 tests/test_hypertree_tsb.py create mode 100644 tests/test_hypertree_var.py diff --git a/README.md b/README.md index f089dd1..dcf405c 100644 --- a/README.md +++ b/README.md @@ -85,6 +85,9 @@ Hyper-Trees offer several advantages: | **`Hyper-TreeNet-AR`** | Hybrid model combining tree embeddings with a neural network to learn AR(p) parameters. | ![](https://img.shields.io/badge/Global-blue) ![](https://img.shields.io/badge/Local-green) | | **`Hyper-Tree-ETS`** | Exponential smoothing model where ETS parameters are estimated by trees. | ![](https://img.shields.io/badge/Global-blue) ![](https://img.shields.io/badge/Local-green) | | **`Hyper-Tree-STL`** | STL decomposition with tree-learned parameters for trend and seasonality. | ![](https://img.shields.io/badge/Local-green) | +| **`Hyper-Tree-VAR`** (experimental) | Vector autoregression with tree-learned, time-varying VAR(p) coefficient matrices, capturing cross-series lead/lag dependence. Intended for small aligned panels. | ![](https://img.shields.io/badge/Global-blue) | +| **`Hyper-TreeNet-VAR`** (experimental) | Hybrid model combining tree embeddings with a neural network to learn the VAR(p) coefficient matrices; recommended VAR variant, since its runtime is independent of the number of coefficients. | ![](https://img.shields.io/badge/Global-blue) | +| **`Hyper-Tree-TSB`** (experimental) | Intermittent demand model (Teunter-Syntetos-Babai) with tree-learned, time-varying smoothing rates for demand probability and demand size. | ![](https://img.shields.io/badge/Global-blue) ![](https://img.shields.io/badge/Local-green) | `Global` means a single model is trained across multiple time series; `Local` means a separate model is trained for each individual series. All models produce point forecasts and support conformal prediction intervals via `ForecastIntervals` (see [Getting Started](#getting-started)). Full distributional (probabilistic) forecasting is planned for future releases. Note on `Hyper-Tree-STL`: it is designed to decompose time series into trend and seasonal components and is not intended for forecasting. However, the STL-parameters can still be used to generate forecasts. diff --git a/THIRD_PARTY_NOTICES b/THIRD_PARTY_NOTICES index 9cef0ba..307b20f 100644 --- a/THIRD_PARTY_NOTICES +++ b/THIRD_PARTY_NOTICES @@ -15,12 +15,28 @@ libraries, each licensed under the Apache License, Version 2.0: - mlforecast https://github.com/Nixtla/mlforecast - neuralforecast https://github.com/Nixtla/neuralforecast -The conformal prediction interval implementation in hypertrees/conformal.py is -adapted from these libraries. Specifically, the rolling-origin calibration -procedure, the two interval-construction methods ("conformal_distribution" and -"conformal_error"), the per-horizon-step quantile logic, and the -"-lo-" / "-hi-" output column naming convention -follow Nixtla's design. The code has been modified from the originals. +The following components are adapted from these libraries and have been +modified from the originals: + + - Conformal prediction intervals (hypertrees/conformal.py): the + rolling-origin calibration, the two interval-construction methods + ("conformal_distribution" and "conformal_error"), the per-horizon-step + quantile logic, and the "-lo-" / "-hi-" + output column naming convention follow Nixtla's design. + + - Exponential smoothing state initialization + (hypertrees/models/HyperTreeETS.py): the classical and additive + seasonal/level/trend initialization (centered 2 x m moving-average + detrending, per-slot seasonal indices, the OLS level/trend seed, and the + initial-seasonal clipping) follows the statsforecast / R forecast::ets + heuristic. + + - TSB intermittent-demand method (hypertrees/models/HyperTreeTSB.py): the + probability/size smoothing recursion and the state initialization follow + the statsforecast TSB implementation. + + - Time series preprocessing (hypertrees/utils.py): the frequency-alias + conversion and the lag-column ordering follow the mlforecast conventions. A copy of the Apache License, Version 2.0, is available at: diff --git a/examples/Basic Walkthrough.ipynb b/examples/Basic Walkthrough.ipynb index c7cc27d..40a4755 100644 --- a/examples/Basic Walkthrough.ipynb +++ b/examples/Basic Walkthrough.ipynb @@ -12,9 +12,15 @@ { "cell_type": "code", "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T10:02:35.357511Z", + "iopub.status.busy": "2026-06-11T10:02:35.357511Z", + "iopub.status.idle": "2026-06-11T10:02:48.211980Z", + "shell.execute_reply": "2026-06-11T10:02:48.211980Z" + }, "ExecuteTime": { - "end_time": "2026-06-10T13:16:08.858605Z", - "start_time": "2026-06-10T13:16:05.786546700Z" + "end_time": "2026-06-11T12:51:05.485409300Z", + "start_time": "2026-06-11T12:51:05.476148100Z" } }, "source": [ @@ -26,24 +32,32 @@ " HyperTreeNetAR,\n", " HyperTreeSTL\n", ")\n", - "from utils import calculate_metrics\n", + "from utils import calculate_metrics, plot_forecasts\n", "import matplotlib.pyplot as plt\n", "import shap" ], "outputs": [], - "execution_count": 1 + "execution_count": 30 }, { "cell_type": "markdown", "metadata": {}, - "source": "## General Parameters" + "source": [ + "## General Parameters" + ] }, { "cell_type": "code", "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T10:02:48.214319Z", + "iopub.status.busy": "2026-06-11T10:02:48.214319Z", + "iopub.status.idle": "2026-06-11T10:02:48.256445Z", + "shell.execute_reply": "2026-06-11T10:02:48.256445Z" + }, "ExecuteTime": { - "end_time": "2026-06-10T13:16:09.335624700Z", - "start_time": "2026-06-10T13:16:08.860583500Z" + "end_time": "2026-06-11T12:51:05.524592400Z", + "start_time": "2026-06-11T12:51:05.503408800Z" } }, "source": [ @@ -53,6 +67,7 @@ "fcst_h=12\n", "num_iterations=100\n", "num_seasonal_components=1\n", + "seed=123\n", "device=torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "\n", "# Hyper-Tree Parameters\n", @@ -67,40 +82,50 @@ " 'hidden_dim': 128, # hidden dimension for the MLP network\n", " 'dropout': 0.1, # dropout rate for the MLP network\n", " 'use_random_projection': True, # whether to use random projections for the embeddings\n", - "\t'rp_embed_dim': lag_p, # dimension of the random projections (if used)\n", + " 'rp_embed_dim': lag_p, # dimension of the random projections (if used)\n", "}" ], "outputs": [], - "execution_count": 2 + "execution_count": 31 }, { - "metadata": {}, "cell_type": "markdown", + "metadata": {}, "source": [ "## Load and Prepare Data\n", "We'll use the Air Passengers dataset which contains monthly airline passenger numbers from 1949 to 1960." ] }, { + "cell_type": "code", "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T10:02:48.258449Z", + "iopub.status.busy": "2026-06-11T10:02:48.258449Z", + "iopub.status.idle": "2026-06-11T10:02:48.701896Z", + "shell.execute_reply": "2026-06-11T10:02:48.701896Z" + }, "ExecuteTime": { - "end_time": "2026-06-10T13:16:09.762469700Z", - "start_time": "2026-06-10T13:16:09.336625200Z" + "end_time": "2026-06-11T12:51:05.956563800Z", + "start_time": "2026-06-11T12:51:05.539105300Z" } }, - "cell_type": "code", "source": [ "# The data needs to have the following columns: 'date', 'series_id', 'value'. All other columns are automatically treated as features.\n", "# For the AR-models, you don't have to add lag-values yourself, this happens automatically during training.\n", "df = pd.read_csv('https://datasets-nixtla.s3.amazonaws.com/air-passengers.csv', parse_dates=['ds'])\n", "df.rename(columns={'unique_id': 'series_id', 'ds': 'date', 'y': 'value'}, inplace=True)\n", + "\n", + "# Add month and quarter as features\n", "df['month'] = df['date'].dt.month\n", "df[\"quarter\"] = df['date'].dt.quarter\n", + "\n", + "# Split into train and test\n", "test = df.tail(fcst_h)\n", "train = df.drop(test.index)" ], "outputs": [], - "execution_count": 3 + "execution_count": 32 }, { "cell_type": "markdown", @@ -112,14 +137,22 @@ { "cell_type": "markdown", "metadata": {}, - "source": "#### Hyper-Tree-AR" + "source": [ + "#### Hyper-Tree-AR" + ] }, { "cell_type": "code", "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T10:02:48.704034Z", + "iopub.status.busy": "2026-06-11T10:02:48.704034Z", + "iopub.status.idle": "2026-06-11T10:02:48.903693Z", + "shell.execute_reply": "2026-06-11T10:02:48.903189Z" + }, "ExecuteTime": { - "end_time": "2026-06-10T13:16:09.976732900Z", - "start_time": "2026-06-10T13:16:09.765477600Z" + "end_time": "2026-06-11T12:51:06.226078500Z", + "start_time": "2026-06-11T12:51:05.958554400Z" } }, "source": [ @@ -135,7 +168,7 @@ " lgb_params=ht_params,\n", " num_iterations=num_iterations,\n", " train_data=train,\n", - " seed=123,\n", + " seed=seed,\n", " verbose=-1\n", ")\n", "\n", @@ -145,19 +178,27 @@ ")" ], "outputs": [], - "execution_count": 4 + "execution_count": 33 }, { "cell_type": "markdown", "metadata": {}, - "source": "#### Hyper-Tree-ETS" + "source": [ + "#### Hyper-Tree-ETS" + ] }, { "cell_type": "code", "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T10:02:48.905697Z", + "iopub.status.busy": "2026-06-11T10:02:48.905697Z", + "iopub.status.idle": "2026-06-11T10:03:06.432526Z", + "shell.execute_reply": "2026-06-11T10:03:06.432024Z" + }, "ExecuteTime": { - "end_time": "2026-06-10T13:16:27.531759600Z", - "start_time": "2026-06-10T13:16:09.978735300Z" + "end_time": "2026-06-11T12:51:25.189406900Z", + "start_time": "2026-06-11T12:51:06.228078600Z" } }, "source": [ @@ -175,29 +216,37 @@ " lgb_params=ht_params,\n", " num_iterations=num_iterations,\n", " train_data=train,\n", - " seed=123,\n", + " seed=seed,\n", " verbose=-1\n", ")\n", "\n", "# Forecast\n", "ht_ets_fcst = ht_ets.forecast(\n", - "\ttest_data=test,\n", + " test_data=test,\n", ")" ], "outputs": [], - "execution_count": 5 + "execution_count": 34 }, { "cell_type": "markdown", "metadata": {}, - "source": "#### Hyper-TreeNet-AR" + "source": [ + "#### Hyper-TreeNet-AR" + ] }, { "cell_type": "code", "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T10:03:06.434531Z", + "iopub.status.busy": "2026-06-11T10:03:06.434531Z", + "iopub.status.idle": "2026-06-11T10:03:08.357706Z", + "shell.execute_reply": "2026-06-11T10:03:08.356702Z" + }, "ExecuteTime": { - "end_time": "2026-06-10T13:16:29.765756600Z", - "start_time": "2026-06-10T13:16:27.573777Z" + "end_time": "2026-06-11T12:51:25.961676900Z", + "start_time": "2026-06-11T12:51:25.249667100Z" } }, "source": [ @@ -215,7 +264,7 @@ " network_params=network_params,\n", " num_iterations=num_iterations,\n", " train_data=train,\n", - " seed=123,\n", + " seed=seed,\n", " verbose=-1\n", ")\n", "\n", @@ -225,21 +274,31 @@ ")" ], "outputs": [], - "execution_count": 6 + "execution_count": 35 }, { - "metadata": {}, "cell_type": "markdown", - "source": "#### Hyper-Tree-STL" + "metadata": {}, + "source": [ + "#### Hyper-Tree-STL\n", + "\n", + "For conformal prediction intervals with the other models, see the dedicated `Forecast Intervals.ipynb` example. `HyperTreeSTL` is designed for decomposition and currently does not support them." + ] }, { + "cell_type": "code", "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T10:03:08.359706Z", + "iopub.status.busy": "2026-06-11T10:03:08.359706Z", + "iopub.status.idle": "2026-06-11T10:03:09.644929Z", + "shell.execute_reply": "2026-06-11T10:03:09.644427Z" + }, "ExecuteTime": { - "end_time": "2026-06-10T13:16:31.151940500Z", - "start_time": "2026-06-10T13:16:29.787264100Z" + "end_time": "2026-06-11T12:51:27.751935600Z", + "start_time": "2026-06-11T12:51:26.017801800Z" } }, - "cell_type": "code", "source": [ "# Initialize\n", "ht_stl = HyperTreeSTL(\n", @@ -249,7 +308,7 @@ " fcst_h=fcst_h,\n", ")\n", "\n", - "# Add time variable\n", + "# Add time feature\n", "df_stl = df.copy()\n", "df_stl['time'] = df_stl.groupby(\"series_id\").cumcount() + 1\n", "test_stl = df_stl.tail(fcst_h)\n", @@ -260,7 +319,7 @@ " lgb_params=ht_params,\n", " num_iterations=num_iterations,\n", " train_data=train_stl,\n", - " seed=123,\n", + " seed=seed,\n", " verbose=-1\n", ")\n", "\n", @@ -270,7 +329,7 @@ ")" ], "outputs": [], - "execution_count": 7 + "execution_count": 36 }, { "cell_type": "markdown", @@ -282,16 +341,20 @@ ] }, { + "cell_type": "code", "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T10:03:09.646935Z", + "iopub.status.busy": "2026-06-11T10:03:09.646935Z", + "iopub.status.idle": "2026-06-11T10:03:09.877798Z", + "shell.execute_reply": "2026-06-11T10:03:09.877798Z" + }, "ExecuteTime": { - "end_time": "2026-06-10T13:16:31.401230200Z", - "start_time": "2026-06-10T13:16:31.184455200Z" + "end_time": "2026-06-11T12:51:27.952711600Z", + "start_time": "2026-06-11T12:51:27.818403200Z" } }, - "cell_type": "code", "source": [ - "plt.figure(figsize=(12, 5))\n", - "\n", "datasets = [\n", " (df, 'date', 'value', 'Actual', '#2E86AB', '-'),\n", " (ht_ar_fcst, 'date', 'fcst', 'Hyper-Tree-AR Forecast', 'green', '--'),\n", @@ -300,19 +363,12 @@ " (ht_stl_fcst, 'date', 'fcst', 'Hyper-Tree-STL Forecast', 'brown', '--'),\n", " ]\n", "\n", - "for data, x_col, y_col, label, color, style in datasets:\n", - " plt.plot(data[x_col], data[y_col], label=label, color=color,\n", - " linestyle=style, linewidth=2, alpha=0.8)\n", - "split_date = test['date'].min()\n", - "plt.axvline(x=split_date, color='black', linestyle=':', alpha=0.7, label='Train/Test Split')\n", - "\n", - "plt.title('Forecasting Results - Air Passengers Dataset', fontsize=16)\n", - "plt.xlabel('Date', fontsize=12)\n", - "plt.ylabel('Number of Passengers', fontsize=12)\n", - "plt.legend(fontsize=11)\n", - "plt.grid(True, alpha=0.3)\n", - "plt.tight_layout()\n", - "plt.show()" + "plot_forecasts(\n", + " datasets,\n", + " split_date=test['date'].min(),\n", + " title='Forecasting Results - Air Passengers Dataset',\n", + " ylabel='Number of Passengers',\n", + ")" ], "outputs": [ { @@ -326,7 +382,7 @@ "output_type": "display_data" } ], - "execution_count": 8 + "execution_count": 37 }, { "cell_type": "markdown", @@ -340,9 +396,15 @@ { "cell_type": "code", "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T10:03:09.905255Z", + "iopub.status.busy": "2026-06-11T10:03:09.905255Z", + "iopub.status.idle": "2026-06-11T10:03:09.917605Z", + "shell.execute_reply": "2026-06-11T10:03:09.917605Z" + }, "ExecuteTime": { - "end_time": "2026-06-10T13:16:31.451431Z", - "start_time": "2026-06-10T13:16:31.410787500Z" + "end_time": "2026-06-11T12:51:27.991789800Z", + "start_time": "2026-06-11T12:51:27.954758700Z" } }, "source": [ @@ -443,12 +505,12 @@ "" ] }, - "execution_count": 9, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 9 + "execution_count": 38 }, { "cell_type": "markdown", @@ -462,9 +524,15 @@ { "cell_type": "code", "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T10:03:09.919716Z", + "iopub.status.busy": "2026-06-11T10:03:09.919716Z", + "iopub.status.idle": "2026-06-11T10:03:10.068539Z", + "shell.execute_reply": "2026-06-11T10:03:10.068539Z" + }, "ExecuteTime": { - "end_time": "2026-06-10T13:16:31.693694600Z", - "start_time": "2026-06-10T13:16:31.497537200Z" + "end_time": "2026-06-11T12:51:28.244859200Z", + "start_time": "2026-06-11T12:51:28.035951100Z" } }, "source": [ @@ -499,19 +567,29 @@ "output_type": "display_data" } ], - "execution_count": 10 + "execution_count": 39 }, { "cell_type": "markdown", "metadata": {}, - "source": "## SHAP Analysis for Parameter Interpretability\n\nLet's use SHAP values to understand which features contribute to the forecasted AR coefficients. We use the Hyper-Tree-AR model for this analysis." + "source": [ + "## SHAP Analysis for Parameter Interpretability\n", + "\n", + "Let's use SHAP values to understand which features contribute to the forecasted AR coefficients. We use the Hyper-Tree-AR model for this analysis." + ] }, { "cell_type": "code", "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T10:03:10.071546Z", + "iopub.status.busy": "2026-06-11T10:03:10.070547Z", + "iopub.status.idle": "2026-06-11T10:03:11.137049Z", + "shell.execute_reply": "2026-06-11T10:03:11.137049Z" + }, "ExecuteTime": { - "end_time": "2026-06-10T13:16:32.752691Z", - "start_time": "2026-06-10T13:16:31.978994800Z" + "end_time": "2026-06-11T12:51:29.347420600Z", + "start_time": "2026-06-11T12:51:28.432771900Z" } }, "source": [ @@ -673,11 +751,11 @@ "output_type": "display_data" } ], - "execution_count": 11 + "execution_count": 40 }, { - "metadata": {}, "cell_type": "markdown", + "metadata": {}, "source": [ "# Inspect Tree Embeddings\n", "\n", @@ -685,13 +763,19 @@ ] }, { + "cell_type": "code", "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T10:03:11.139072Z", + "iopub.status.busy": "2026-06-11T10:03:11.138073Z", + "iopub.status.idle": "2026-06-11T10:03:11.258014Z", + "shell.execute_reply": "2026-06-11T10:03:11.258014Z" + }, "ExecuteTime": { - "end_time": "2026-06-10T13:16:33.018370300Z", - "start_time": "2026-06-10T13:16:32.853807500Z" + "end_time": "2026-06-11T12:51:29.554816900Z", + "start_time": "2026-06-11T12:51:29.417853200Z" } }, - "cell_type": "code", "source": [ "htnet_embeds = htnet_ar.forecast(\n", " test_data=df,\n", @@ -719,7 +803,7 @@ "output_type": "display_data" } ], - "execution_count": 12 + "execution_count": 41 } ], "metadata": { diff --git a/examples/Forecast Intervals.ipynb b/examples/Forecast Intervals.ipynb index 409d040..eaa984a 100644 --- a/examples/Forecast Intervals.ipynb +++ b/examples/Forecast Intervals.ipynb @@ -3,67 +3,125 @@ { "cell_type": "markdown", "id": "2e911782", - "source": "# Forecast Intervals with Conformal Prediction\n\nThis notebook demonstrates how to add prediction intervals to Hyper-Tree forecasts using conformal prediction. The approach is model-agnostic and works with all Hyper-Tree models (AR, ETS, TreeNet-AR).\n\n**How it works:** During training, a rolling-window cross-validation collects absolute residuals (conformity scores) per horizon step and per series. At forecast time, these scores are used to construct intervals at any requested confidence level.", - "metadata": {} + "metadata": {}, + "source": [ + "# Forecast Intervals with Conformal Prediction\n", + "\n", + "This notebook demonstrates how to add prediction intervals to Hyper-Tree forecasts using conformal prediction. The approach is model-agnostic and works with all Hyper-Tree models (AR, ETS, TreeNet-AR).\n", + "\n", + "**How it works:** During training, a rolling-window cross-validation collects absolute residuals (conformity scores) per horizon step and per series. At forecast time, these scores are used to construct intervals at any requested confidence level." + ] }, { "cell_type": "code", "id": "1bac7747", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T10:03:15.639144Z", + "iopub.status.busy": "2026-06-11T10:03:15.639144Z", + "iopub.status.idle": "2026-06-11T10:03:18.141639Z", + "shell.execute_reply": "2026-06-11T10:03:18.140628Z" + }, + "ExecuteTime": { + "end_time": "2026-06-11T11:56:09.774688800Z", + "start_time": "2026-06-11T11:56:07.130670800Z" + } + }, "source": [ "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", + "import torch\n", "\n", "from hypertrees.models import HyperTreeAR, HyperTreeETS, HyperTreeNetAR\n", "from hypertrees import ForecastIntervals\n", - "import torch\n", - "import re" + "from utils import plot_model_intervals" ], - "metadata": { - "ExecuteTime": { - "end_time": "2026-06-03T11:03:41.442314300Z", - "start_time": "2026-06-03T11:03:41.384622700Z" - } - }, "outputs": [], - "execution_count": 9 + "execution_count": 1 }, { "cell_type": "markdown", "id": "298aeca0", - "source": "## Load and Prepare Data\n\nWe use the Air Passengers dataset (monthly, 1949-1960) and reserve the last 12 months for testing.", - "metadata": {} + "metadata": {}, + "source": [ + "## Load and Prepare Data\n", + "\n", + "We use the Air Passengers dataset (monthly, 1949-1960) and reserve the last 12 months for testing." + ] }, { "cell_type": "code", "id": "fb4ce322", - "source": "df = pd.read_csv('https://datasets-nixtla.s3.amazonaws.com/air-passengers.csv', parse_dates=['ds'])\ndf.rename(columns={'unique_id': 'series_id', 'ds': 'date', 'y': 'value'}, inplace=True)\ndf['month'] = df['date'].dt.month\ndf['quarter'] = df['date'].dt.quarter\n\nfcst_h = 12\ntest = df.tail(fcst_h)\ntrain = df.drop(test.index)", "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T10:03:18.143781Z", + "iopub.status.busy": "2026-06-11T10:03:18.142644Z", + "iopub.status.idle": "2026-06-11T10:03:18.569427Z", + "shell.execute_reply": "2026-06-11T10:03:18.568412Z" + }, "ExecuteTime": { - "end_time": "2026-06-03T11:03:41.839362700Z", - "start_time": "2026-06-03T11:03:41.444279200Z" + "end_time": "2026-06-11T11:56:10.256071Z", + "start_time": "2026-06-11T11:56:09.776691900Z" } }, + "source": [ + "# The data needs to have the following columns: 'date', 'series_id', 'value'. All other columns are automatically treated as features.\n", + "# For the AR-models, you don't have to add lag-values yourself, this happens automatically during training.\n", + "df = pd.read_csv('https://datasets-nixtla.s3.amazonaws.com/air-passengers.csv', parse_dates=['ds'])\n", + "df.rename(columns={'unique_id': 'series_id', 'ds': 'date', 'y': 'value'}, inplace=True)\n", + "\n", + "# Add month and quarter as features\n", + "df['month'] = df['date'].dt.month\n", + "df['quarter'] = df['date'].dt.quarter\n", + "\n", + "# Split into train and test\n", + "fcst_h = 12\n", + "test = df.tail(fcst_h)\n", + "train = df.drop(test.index)" + ], "outputs": [], - "execution_count": 10 + "execution_count": 2 }, { "cell_type": "markdown", "id": "4ae3c43e", - "source": "## General Parameters", - "metadata": {} + "metadata": {}, + "source": [ + "## General Parameters" + ] }, { "cell_type": "code", "id": "2d426f65", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T10:03:18.571428Z", + "iopub.status.busy": "2026-06-11T10:03:18.571428Z", + "iopub.status.idle": "2026-06-11T10:03:18.588494Z", + "shell.execute_reply": "2026-06-11T10:03:18.588494Z" + }, + "ExecuteTime": { + "end_time": "2026-06-11T11:56:10.289486100Z", + "start_time": "2026-06-11T11:56:10.268082100Z" + } + }, "source": [ "lag_p = 12\n", "freq = 'MS'\n", "num_iterations = 100\n", - "ci_levels = [80, 90]\n", - "n_windows = 5\n", - "refit = True\n", + "seed = 123\n", + "level = [80, 90]\n", + "n_windows = 5 # number of rolling calibration windows\n", + "refit = False # train once on the oldest window for speed; True retrains per window\n", "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "\n", + "# Conformal prediction intervals, shared by all models\n", + "forecast_intervals = ForecastIntervals(\n", + " n_windows=n_windows,\n", + " method=\"conformal_distribution\", # or \"conformal_error\"\n", + " step_size=1,\n", + " refit=refit,\n", + ")\n", + "\n", "# LightGBM parameters for all models (can be tuned per model if desired)\n", "ht_params = {\n", " 'learning_rate': 1e-01,\n", @@ -79,68 +137,77 @@ " 'rp_embed_dim': lag_p,\n", "}" ], - "metadata": { - "ExecuteTime": { - "end_time": "2026-06-03T11:03:41.854418700Z", - "start_time": "2026-06-03T11:03:41.840363300Z" - } - }, "outputs": [], - "execution_count": 11 + "execution_count": 3 }, { "cell_type": "markdown", "id": "8a47fd4d", - "source": "## Hyper-Tree-AR with Forecast Intervals\n\nPass `forecast_intervals=ForecastIntervals(...)` to `train()` to calibrate conformal intervals, then request them via `level=[...]` in `forecast()`.\n\nKey parameters of `ForecastIntervals`:\n- **`n_windows`**: Number of rolling CV windows for calibration (more = better quantile resolution, but slower).\n- **`method`**: `\"conformal_distribution\"` (default, can produce asymmetric bands) or `\"conformal_error\"` (symmetric).\n- **`refit`**: If `True` (default), retrain the model for each CV window. If `False`, train once and reuse (faster).", - "metadata": {} + "metadata": {}, + "source": [ + "## Hyper-Tree-AR with Forecast Intervals\n", + "\n", + "Pass `forecast_intervals=ForecastIntervals(...)` to `train()` to calibrate conformal intervals, then request them via `level=[...]` in `forecast()`.\n", + "\n", + "Key parameters of `ForecastIntervals`:\n", + "- **`n_windows`**: Number of rolling CV windows for calibration (more = better quantile resolution, but slower).\n", + "- **`method`**: `\"conformal_distribution\"` (default, can produce asymmetric bands) or `\"conformal_error\"` (symmetric).\n", + "- **`refit`**: If `True` (default), retrain the model for each CV window. If `False`, train once and reuse (faster)." + ] }, { "cell_type": "code", "id": "dbb5135d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T10:03:18.590975Z", + "iopub.status.busy": "2026-06-11T10:03:18.590975Z", + "iopub.status.idle": "2026-06-11T10:03:19.005211Z", + "shell.execute_reply": "2026-06-11T10:03:19.005211Z" + }, + "ExecuteTime": { + "end_time": "2026-06-11T11:56:10.777565300Z", + "start_time": "2026-06-11T11:56:10.291484400Z" + } + }, "source": [ "ht_ar = HyperTreeAR(p=lag_p, freq=freq, fcst_h=fcst_h)\n", "ht_ar.train(\n", " lgb_params=ht_params,\n", " num_iterations=num_iterations,\n", " train_data=train,\n", - " seed=123,\n", + " seed=seed,\n", " verbose=-1,\n", - " forecast_intervals=ForecastIntervals(n_windows=n_windows, refit=refit)\n", + " forecast_intervals=forecast_intervals\n", ")\n", "\n", - "ht_ar_fcst = ht_ar.forecast(test_data=test, level=ci_levels)\n", + "ht_ar_fcst = ht_ar.forecast(test_data=test, level=level)\n", "ht_ar_fcst.head()" ], - "metadata": { - "ExecuteTime": { - "end_time": "2026-06-03T11:03:44.301176600Z", - "start_time": "2026-06-03T11:03:41.856437200Z" - } - }, "outputs": [ { "data": { "text/plain": [ " series_id date fcst model \\\n", - "0 AirPassengers 1960-01-01 403.564685 Hyper-Tree-AR(12) \n", - "1 AirPassengers 1960-02-01 402.666934 Hyper-Tree-AR(12) \n", - "2 AirPassengers 1960-03-01 464.129094 Hyper-Tree-AR(12) \n", - "3 AirPassengers 1960-04-01 453.348857 Hyper-Tree-AR(12) \n", - "4 AirPassengers 1960-05-01 466.937533 Hyper-Tree-AR(12) \n", + "0 AirPassengers 1960-01-01 403.564687 Hyper-Tree-AR(12) \n", + "1 AirPassengers 1960-02-01 402.666936 Hyper-Tree-AR(12) \n", + "2 AirPassengers 1960-03-01 464.129101 Hyper-Tree-AR(12) \n", + "3 AirPassengers 1960-04-01 453.348864 Hyper-Tree-AR(12) \n", + "4 AirPassengers 1960-05-01 466.937535 Hyper-Tree-AR(12) \n", "\n", " Hyper-Tree-AR(12)-lo-90 Hyper-Tree-AR(12)-lo-80 Hyper-Tree-AR(12)-hi-80 \\\n", - "0 377.535822 379.354170 427.775200 \n", - "1 379.954555 385.697925 419.635942 \n", - "2 440.362885 446.374410 481.883778 \n", - "3 436.129435 439.099078 467.598636 \n", - "4 449.567804 453.618077 480.256989 \n", + "0 377.658879 379.376548 427.752826 \n", + "1 380.005749 385.673160 419.660711 \n", + "2 440.170733 445.990101 482.268101 \n", + "3 436.069989 439.088275 467.609453 \n", + "4 449.502662 453.547709 480.327361 \n", "\n", " Hyper-Tree-AR(12)-hi-90 \n", - "0 429.593548 \n", - "1 425.379312 \n", - "2 487.895303 \n", - "3 470.568279 \n", - "4 484.307262 " + "0 429.470495 \n", + "1 425.328122 \n", + "2 488.087468 \n", + "3 470.627739 \n", + "4 484.372407 " ], "text/html": [ "
\n", @@ -176,78 +243,92 @@ " 0\n", " AirPassengers\n", " 1960-01-01\n", - " 403.564685\n", + " 403.564687\n", " Hyper-Tree-AR(12)\n", - " 377.535822\n", - " 379.354170\n", - " 427.775200\n", - " 429.593548\n", + " 377.658879\n", + " 379.376548\n", + " 427.752826\n", + " 429.470495\n", " \n", " \n", " 1\n", " AirPassengers\n", " 1960-02-01\n", - " 402.666934\n", + " 402.666936\n", " Hyper-Tree-AR(12)\n", - " 379.954555\n", - " 385.697925\n", - " 419.635942\n", - " 425.379312\n", + " 380.005749\n", + " 385.673160\n", + " 419.660711\n", + " 425.328122\n", " \n", " \n", " 2\n", " AirPassengers\n", " 1960-03-01\n", - " 464.129094\n", + " 464.129101\n", " Hyper-Tree-AR(12)\n", - " 440.362885\n", - " 446.374410\n", - " 481.883778\n", - " 487.895303\n", + " 440.170733\n", + " 445.990101\n", + " 482.268101\n", + " 488.087468\n", " \n", " \n", " 3\n", " AirPassengers\n", " 1960-04-01\n", - " 453.348857\n", + " 453.348864\n", " Hyper-Tree-AR(12)\n", - " 436.129435\n", - " 439.099078\n", - " 467.598636\n", - " 470.568279\n", + " 436.069989\n", + " 439.088275\n", + " 467.609453\n", + " 470.627739\n", " \n", " \n", " 4\n", " AirPassengers\n", " 1960-05-01\n", - " 466.937533\n", + " 466.937535\n", " Hyper-Tree-AR(12)\n", - " 449.567804\n", - " 453.618077\n", - " 480.256989\n", - " 484.307262\n", + " 449.502662\n", + " 453.547709\n", + " 480.327361\n", + " 484.372407\n", " \n", " \n", "\n", "
" ] }, - "execution_count": 12, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 12 + "execution_count": 4 }, { "cell_type": "markdown", "id": "34479a3a", - "source": "## Hyper-Tree-ETS with Forecast Intervals", - "metadata": {} + "metadata": {}, + "source": [ + "## Hyper-Tree-ETS with Forecast Intervals" + ] }, { "cell_type": "code", "id": "b3909a1a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T10:03:19.008214Z", + "iopub.status.busy": "2026-06-11T10:03:19.007214Z", + "iopub.status.idle": "2026-06-11T10:03:53.603809Z", + "shell.execute_reply": "2026-06-11T10:03:53.602805Z" + }, + "ExecuteTime": { + "end_time": "2026-06-11T11:56:46.716167600Z", + "start_time": "2026-06-11T11:56:10.848417500Z" + } + }, "source": [ "ht_ets = HyperTreeETS(\n", " ets_type=\"triple\",\n", @@ -260,44 +341,38 @@ " lgb_params=ht_params,\n", " num_iterations=num_iterations,\n", " train_data=train,\n", - " seed=123,\n", + " seed=seed,\n", " verbose=-1,\n", - " forecast_intervals=ForecastIntervals(n_windows=n_windows, refit=True),\n", + " forecast_intervals=forecast_intervals,\n", ")\n", "\n", - "ht_ets_fcst = ht_ets.forecast(test_data=test, level=ci_levels)\n", + "ht_ets_fcst = ht_ets.forecast(test_data=test, level=level)\n", "ht_ets_fcst.head()" ], - "metadata": { - "ExecuteTime": { - "end_time": "2026-06-03T11:05:52.872430100Z", - "start_time": "2026-06-03T11:03:44.519536700Z" - } - }, "outputs": [ { "data": { "text/plain": [ " series_id date fcst model \\\n", - "0 AirPassengers 1960-01-01 412.837921 Hyper-Tree-ETS(triple) \n", - "1 AirPassengers 1960-02-01 388.689178 Hyper-Tree-ETS(triple) \n", - "2 AirPassengers 1960-03-01 446.611877 Hyper-Tree-ETS(triple) \n", - "3 AirPassengers 1960-04-01 428.627716 Hyper-Tree-ETS(triple) \n", - "4 AirPassengers 1960-05-01 447.878479 Hyper-Tree-ETS(triple) \n", + "0 AirPassengers 1960-01-01 436.668884 Hyper-Tree-ETS(triple) \n", + "1 AirPassengers 1960-02-01 417.500061 Hyper-Tree-ETS(triple) \n", + "2 AirPassengers 1960-03-01 493.116577 Hyper-Tree-ETS(triple) \n", + "3 AirPassengers 1960-04-01 488.110718 Hyper-Tree-ETS(triple) \n", + "4 AirPassengers 1960-05-01 495.057190 Hyper-Tree-ETS(triple) \n", "\n", " Hyper-Tree-ETS(triple)-lo-90 Hyper-Tree-ETS(triple)-lo-80 \\\n", - "0 400.981943 401.406482 \n", - "1 377.327919 378.808121 \n", - "2 429.340707 433.964496 \n", - "3 405.167220 408.106351 \n", - "4 415.029961 421.563461 \n", + "0 416.208334 416.849469 \n", + "1 393.688594 398.844382 \n", + "2 457.727666 466.906839 \n", + "3 452.659897 454.806488 \n", + "4 455.050063 471.988248 \n", "\n", " Hyper-Tree-ETS(triple)-hi-80 Hyper-Tree-ETS(triple)-hi-90 \n", - "0 424.269360 424.693900 \n", - "1 398.570236 400.050438 \n", - "2 459.259259 463.883047 \n", - "3 449.149081 452.088213 \n", - "4 474.193497 480.726997 " + "0 456.488300 457.129434 \n", + "1 436.155740 441.311528 \n", + "2 519.326315 528.505489 \n", + "3 521.414948 523.561539 \n", + "4 518.126132 535.064317 " ], "text/html": [ "
\n", @@ -333,78 +408,92 @@ " 0\n", " AirPassengers\n", " 1960-01-01\n", - " 412.837921\n", + " 436.668884\n", " Hyper-Tree-ETS(triple)\n", - " 400.981943\n", - " 401.406482\n", - " 424.269360\n", - " 424.693900\n", + " 416.208334\n", + " 416.849469\n", + " 456.488300\n", + " 457.129434\n", " \n", " \n", " 1\n", " AirPassengers\n", " 1960-02-01\n", - " 388.689178\n", + " 417.500061\n", " Hyper-Tree-ETS(triple)\n", - " 377.327919\n", - " 378.808121\n", - " 398.570236\n", - " 400.050438\n", + " 393.688594\n", + " 398.844382\n", + " 436.155740\n", + " 441.311528\n", " \n", " \n", " 2\n", " AirPassengers\n", " 1960-03-01\n", - " 446.611877\n", + " 493.116577\n", " Hyper-Tree-ETS(triple)\n", - " 429.340707\n", - " 433.964496\n", - " 459.259259\n", - " 463.883047\n", + " 457.727666\n", + " 466.906839\n", + " 519.326315\n", + " 528.505489\n", " \n", " \n", " 3\n", " AirPassengers\n", " 1960-04-01\n", - " 428.627716\n", + " 488.110718\n", " Hyper-Tree-ETS(triple)\n", - " 405.167220\n", - " 408.106351\n", - " 449.149081\n", - " 452.088213\n", + " 452.659897\n", + " 454.806488\n", + " 521.414948\n", + " 523.561539\n", " \n", " \n", " 4\n", " AirPassengers\n", " 1960-05-01\n", - " 447.878479\n", + " 495.057190\n", " Hyper-Tree-ETS(triple)\n", - " 415.029961\n", - " 421.563461\n", - " 474.193497\n", - " 480.726997\n", + " 455.050063\n", + " 471.988248\n", + " 518.126132\n", + " 535.064317\n", " \n", " \n", "\n", "
" ] }, - "execution_count": 13, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 13 + "execution_count": 5 }, { "cell_type": "markdown", "id": "495f45ba", - "source": "## Hyper-TreeNet-AR with Forecast Intervals", - "metadata": {} + "metadata": {}, + "source": [ + "## Hyper-TreeNet-AR with Forecast Intervals" + ] }, { "cell_type": "code", "id": "ecfaad3c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T10:03:53.605809Z", + "iopub.status.busy": "2026-06-11T10:03:53.605809Z", + "iopub.status.idle": "2026-06-11T10:03:55.731746Z", + "shell.execute_reply": "2026-06-11T10:03:55.730742Z" + }, + "ExecuteTime": { + "end_time": "2026-06-11T11:56:49.802584900Z", + "start_time": "2026-06-11T11:56:47.334804600Z" + } + }, "source": [ "htnet_ar = HyperTreeNetAR(\n", " p=lag_p,\n", @@ -417,44 +506,38 @@ " network_params=network_params,\n", " num_iterations=num_iterations,\n", " train_data=train,\n", - " seed=123,\n", + " seed=seed,\n", " verbose=-1,\n", - " forecast_intervals=ForecastIntervals(n_windows=n_windows, refit=refit),\n", + " forecast_intervals=forecast_intervals,\n", ")\n", "\n", - "htnet_ar_fcst = htnet_ar.forecast(test_data=test, level=ci_levels)\n", + "htnet_ar_fcst = htnet_ar.forecast(test_data=test, level=level)\n", "htnet_ar_fcst.head()" ], - "metadata": { - "ExecuteTime": { - "end_time": "2026-06-03T11:05:57.077793500Z", - "start_time": "2026-06-03T11:05:53.483648300Z" - } - }, "outputs": [ { "data": { "text/plain": [ " series_id date fcst model \\\n", - "0 AirPassengers 1960-01-01 402.806098 Hyper-TreeNet-AR(12) \n", - "1 AirPassengers 1960-02-01 398.804139 Hyper-TreeNet-AR(12) \n", - "2 AirPassengers 1960-03-01 423.079688 Hyper-TreeNet-AR(12) \n", - "3 AirPassengers 1960-04-01 429.395641 Hyper-TreeNet-AR(12) \n", - "4 AirPassengers 1960-05-01 446.548640 Hyper-TreeNet-AR(12) \n", + "0 AirPassengers 1960-01-01 412.051285 Hyper-TreeNet-AR(12) \n", + "1 AirPassengers 1960-02-01 408.478998 Hyper-TreeNet-AR(12) \n", + "2 AirPassengers 1960-03-01 434.041320 Hyper-TreeNet-AR(12) \n", + "3 AirPassengers 1960-04-01 441.242457 Hyper-TreeNet-AR(12) \n", + "4 AirPassengers 1960-05-01 458.764859 Hyper-TreeNet-AR(12) \n", "\n", " Hyper-TreeNet-AR(12)-lo-90 Hyper-TreeNet-AR(12)-lo-80 \\\n", - "0 378.169183 386.027768 \n", - "1 368.787185 370.377720 \n", - "2 390.252195 391.159035 \n", - "3 397.351015 398.413260 \n", - "4 415.172470 415.726870 \n", + "0 388.546278 398.036382 \n", + "1 380.552001 384.359693 \n", + "2 404.207984 406.093781 \n", + "3 414.586314 414.618964 \n", + "4 432.928178 433.363722 \n", "\n", " Hyper-TreeNet-AR(12)-hi-80 Hyper-TreeNet-AR(12)-hi-90 \n", - "0 419.584429 427.443014 \n", - "1 427.230557 428.821093 \n", - "2 455.000342 455.907181 \n", - "3 460.378022 461.440267 \n", - "4 477.370410 477.924810 " + "0 426.066188 435.556292 \n", + "1 432.598303 436.405995 \n", + "2 461.988859 463.874656 \n", + "3 467.865950 467.898600 \n", + "4 484.165996 484.601539 " ], "text/html": [ "
\n", @@ -490,164 +573,172 @@ " 0\n", " AirPassengers\n", " 1960-01-01\n", - " 402.806098\n", + " 412.051285\n", " Hyper-TreeNet-AR(12)\n", - " 378.169183\n", - " 386.027768\n", - " 419.584429\n", - " 427.443014\n", + " 388.546278\n", + " 398.036382\n", + " 426.066188\n", + " 435.556292\n", " \n", " \n", " 1\n", " AirPassengers\n", " 1960-02-01\n", - " 398.804139\n", + " 408.478998\n", " Hyper-TreeNet-AR(12)\n", - " 368.787185\n", - " 370.377720\n", - " 427.230557\n", - " 428.821093\n", + " 380.552001\n", + " 384.359693\n", + " 432.598303\n", + " 436.405995\n", " \n", " \n", " 2\n", " AirPassengers\n", " 1960-03-01\n", - " 423.079688\n", + " 434.041320\n", " Hyper-TreeNet-AR(12)\n", - " 390.252195\n", - " 391.159035\n", - " 455.000342\n", - " 455.907181\n", + " 404.207984\n", + " 406.093781\n", + " 461.988859\n", + " 463.874656\n", " \n", " \n", " 3\n", " AirPassengers\n", " 1960-04-01\n", - " 429.395641\n", + " 441.242457\n", " Hyper-TreeNet-AR(12)\n", - " 397.351015\n", - " 398.413260\n", - " 460.378022\n", - " 461.440267\n", + " 414.586314\n", + " 414.618964\n", + " 467.865950\n", + " 467.898600\n", " \n", " \n", " 4\n", " AirPassengers\n", " 1960-05-01\n", - " 446.548640\n", + " 458.764859\n", " Hyper-TreeNet-AR(12)\n", - " 415.172470\n", - " 415.726870\n", - " 477.370410\n", - " 477.924810\n", + " 432.928178\n", + " 433.363722\n", + " 484.165996\n", + " 484.601539\n", " \n", " \n", "\n", "
" ] }, - "execution_count": 14, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 14 + "execution_count": 6 }, { "cell_type": "markdown", "id": "d5f38f47", - "source": "## Plot Forecasts with Intervals\n\nThe `plot_example_forecast` helper automatically detects and shades interval columns present in the forecast DataFrame.", - "metadata": {} + "metadata": {}, + "source": [ + "## Plot Forecasts with Intervals\n", + "\n", + "The `plot_model_intervals` helper detects and shades the interval columns present in each forecast DataFrame." + ] }, { "cell_type": "code", "id": "fdfdb175", - "source": [ - "fig, axes = plt.subplots(1, 3, figsize=(18, 5), sharey=True)\n", - "\n", - "for ax, (fcst_df, title) in zip(axes, [\n", - " (ht_ar_fcst, \"Hyper-Tree-AR\"),\n", - " (ht_ets_fcst, \"Hyper-Tree-ETS\"),\n", - " (htnet_ar_fcst, \"Hyper-TreeNet-AR\"),\n", - "]):\n", - " model_name = fcst_df[\"model\"].iloc[0]\n", - "\n", - " ax.plot(df[\"date\"], df[\"value\"], label=\"Actual\", color=\"#2E86AB\", linewidth=2, alpha=0.8)\n", - " ax.plot(fcst_df[\"date\"], fcst_df[\"fcst\"], label=\"Forecast\", color=\"green\", linestyle=\"--\", linewidth=2)\n", - "\n", - " detected = sorted(\n", - " int(m.group(1))\n", - " for c in fcst_df.columns\n", - " for m in [re.fullmatch(rf\"{re.escape(model_name)}-lo-(\\d+)\", c)]\n", - " if m\n", - " )\n", - " alphas = [0.15, 0.28, 0.40]\n", - " shade = {lv: a for lv, a in zip(sorted(detected, reverse=True), alphas)}\n", - " for lv in sorted(detected, reverse=True):\n", - " ax.fill_between(\n", - " fcst_df[\"date\"],\n", - " fcst_df[f\"{model_name}-lo-{lv}\"],\n", - " fcst_df[f\"{model_name}-hi-{lv}\"],\n", - " color=\"green\", alpha=shade.get(lv, 0.2), label=f\"{lv}% interval\",\n", - " )\n", - "\n", - " ax.axvline(x=fcst_df[\"date\"].min(), color=\"black\", linestyle=\":\", alpha=0.7)\n", - " ax.set_title(title, fontsize=14)\n", - " ax.legend(fontsize=9)\n", - " ax.grid(True, alpha=0.3)\n", - "\n", - "plt.tight_layout()\n", - "plt.show()" - ], "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T10:03:55.733746Z", + "iopub.status.busy": "2026-06-11T10:03:55.733746Z", + "iopub.status.idle": "2026-06-11T10:03:56.276567Z", + "shell.execute_reply": "2026-06-11T10:03:56.276567Z" + }, "ExecuteTime": { - "end_time": "2026-06-03T11:05:57.460488300Z", - "start_time": "2026-06-03T11:05:57.213149500Z" + "end_time": "2026-06-11T11:56:50.173090Z", + "start_time": "2026-06-11T11:56:49.895497Z" } }, + "source": [ + "plot_model_intervals(\n", + " actuals=df,\n", + " forecasts={\n", + " \"Hyper-Tree-AR\": ht_ar_fcst,\n", + " \"Hyper-Tree-ETS\": ht_ets_fcst,\n", + " \"Hyper-TreeNet-AR\": htnet_ar_fcst,\n", + " },\n", + ")" + ], "outputs": [ { "data": { "text/plain": [ "
" ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAABv0AAAHqCAYAAAAnJIIoAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3QeYo2XVN/B/epu6u7O9sLv0XlSaIiKiIkhREWmCHQE/C4qCoGLBigUVKzYQEMsKyIuANOlNetne2/SZ9Kd917kzT/JkatpMksn/913zbSaTSTKZkZz3nHOf47IsywIRERERERERERERERER1S13tZ8AEREREREREREREREREZWHRT8iIiIiIiIiIiIiIiKiOseiHxEREREREREREREREVGdY9GPiIiIiIiIiIiIiIiIqM6x6EdERERERERERERERERU51j0IyIiIiIiIiIiIiIiIqpzLPoRERERERERERERERER1TkW/YiIiIiIiIiIiIiIiIjqHIt+RERERERERERERERERHWORT8iIiIiIiIiIiIiIiKiOseiHxGNsH79erhcLrzjHe8Y89W5//771W0+8YlP1P0r+Pvf/179LIV+nHvuuah1f/zjH7PP98knnxzzdl/96ldH/HzhcBj77rsvLrvsMgwMDEzp8yYiIqoFjIXqMxYaLa4Z/iG3sX+/hX7ssssu2cfo7u7GF7/4Reyzzz4qZpKPJUuW4K1vfSu+9rWvYceOHVV9DYiIiIrBmKd2Yx55bPt5PProo6PeRvJ28nX5PZbKzu9JjFSOBx98MPt8b7nllqJycKFQCLvvvjsuuugibN++vaznQUSAly8CETW6Aw88EF/5ylfyrpOA6Q9/+AMOOOAAnHzyySNuX+t++9vfqsDJsixcd911eP3rXz/u7d/znveoQp+QZNUdd9yBb33rW7j99tvxxBNPIBAITNEzJyIioqk23WIhZ1wz3NFHH422trYRP6+Qol1rays+/elP510vtxebN2/GEUccgU2bNqnX4LzzzlNf27ZtGx555BGVLDvyyCMxZ86cSfrJiIiIqBFjnksuuUQV1Wo9DyUkFyV5qPe9733j3l4apt74xjdmm6r+85//4Kc//SlWrFiBZ555Bh0dHVPyvImmIxb9iKjhSRA3PJCTTicJ+uT6crudptqqVatUMPjud78br776Km688UZcffXVqnNqLO9973tx+umnZz9PJpM47LDD8Nxzz+HPf/6zSmoRERHR9DTdYqHhcc1oRvuZpOgnRbyxfl5JEkrB78orr8Tll18+4usvvPBCtkBIREREtaceY57ly5fjv//9L2677TaceOKJqEUyJeqvf/0r9t9/f9X8dNddd6mYadGiRWN+z7HHHqumJ9hM01Q/nzShS/FP4jIiKg3HexJRRUh3jtfrVZ3OoznnnHPyRhI4xwc89NBDquu6ublZJUqkO3v16tWj3s/OnTvxmc98Brvuuqs6fTZr1ix1+xdffHHEbWUUk3z09fXhwgsvVMGGPEcZJVDu2Ch5/nI/Bx98sBrrJM/fNjg4qJJCMvZJCm3yM7397W9XP+doir39RKSjyn7Nzz77bPT396vgqxjBYBBnnnmmuvz000+X9DyIiIgaCWOh2omFJosdx8roqdHst99+4ya3iIiIpgPGPFMb88jtJZd16aWXqsJYoaQZXIpokjeT/Nluu+2GL3/5y4jH43k5rre85S3qshTZnCM3ixkZKs3mcr+Sh5IPeZ7F5t7cbnd2nCrzUETlYdGPiCri4x//OAzDwO9+97sRX5OimxSdJKg5/PDD87722GOPqSP9MkpJEihvfvOb8Y9//EONTlq7dm3ebdesWYNDDjkEP/rRj1Snk9z++OOPx5133qlOpT3++OMjHjuVSuGYY45RXUZy8u2CCy6oyMil733ve/jkJz+JPfbYA5/61KfUKCfR09OjfkbpAG9vb1c7D6UoKQGLBFIypsCp2NtPRH4H0qEm93XCCSeoop8Ea/aYhVJIcElERETjYyxUG7HQZJo5c6b6d+XKldV+KkRERFXDmGdqYx4p1n30ox9Vze6S7ynEtddeq5rTH374YbzrXe9SeauFCxfim9/8Jt72trchnU6r28ltPvjBD6rLko+TAqP9Ucz0Ask5eTwe1Tx+6qmnoqmpSeUHZeVMKZiHIiqTRUQ0zLp16+Rd2Vq+fLn1la98ZdSPD37wg+o2H//4x9X3JBIJa8aMGdayZcss0zTz7u+nP/2puu2PfvSj7HX33Xefuk4+fvGLX+TdXj6X60844YS864844gjL4/FYd955Z971r732mtXc3Gztt99+edcvWbJE3c/b3/52Kx6PF/V7tp+f/JxO8rPL9ZFIxHr++edHfN8ZZ5yhvv7rX/867/odO3ZYixYtsjo6OtRrVertJ3Lrrbfm/V7EUUcdZblcLmvVqlUjbm//PDfeeGPe9fKYBxxwgPraLbfcUvDjExERTQeMheozFrKf23ve854xY9ht27aN+f3yvRI/juUnP/mJus3s2bOtK664Qr1G/f39BT03IiKiWsSYp3ZjHjvv9uijj1rbt2+3mpqarIULF+bdRvJdchv5Pdpeeukly+v1qpxOV1dX3mNdddVV6vbf//73R/z88vOWQl4bO/dmO+ecc9R199xzz4jb/+53v1Nfk+fiZBiG9c53vlN97Xvf+15Jz4WIMlj0I6Ixg75CPpzFpc985jOjvqkfdNBBViAQsLq7u0cEFbvvvrt6Y3eSz3fbbTdVqNq5c6e67plnnlG3/9CHPjTqb+yzn/2s+voLL7wwouj33HPPFf1bnijok591uM7OTlWUPOaYY8ZNFN12220l3b4QJ510kvqehx9+OHvdb37zG3Xdl770pYKSY+eff761ePFidf0pp5wy4vdDREQ03TEWqs9YyH5u433873//K7noJ41tn//85y2/35+9P4lX9957b+uSSy6xtm7dWtDzJCIiqhWMeWo35nEW/YQ0HMnn3/nOd8Yt+n3qU59S1z344IMjHkfyO1JcPOSQQypW9Pt//+//qe+/4YYbstdJXlCu+8AHPjBm0e+tb31rNg910UUXWXvttZe6Xhr+o9FoSc+FiDI4s42IxiRzxWV05mhkp50999v2sY99DD/84Q/x61//Wo3sFDKm4H//+x/OOOMMzJgxY8T9yFhMmdvtJJ/L9atWrcJzzz2nlvvKGFCxY8eOURcrv/rqq9l/991337zddLJfxUnmig+fTX7yySePWOY8nje84Q0jrnvyySfVeE0ZKTrac5Sfx36OMnqz2NvLay4fTvKc5bmL7du341//+pfadyjjUW3ve9/71ChUGQPx9a9/XY1cGO5vf/ub+nCS77v55pvVeFAiIqJGxFiovmIh516Z008/HZUmMdF3v/tdfOELX8Add9yh4tOnnnpKxbsvv/wyfvnLX6rY+dBDD634YxMREU0mxjy1FfOM5uKLL1ZjO7/97W+rcZ8yInQ0dv7s3//+N/7zn/+M+LrP58vm0Cby7LPPjhg7ussuu2R378nPc/3116O5uRmnnHJK9jaSL5Q9x7K+p7e3d9TnKs9t+POTXKBcJzsIiah0LPoRUcXsueeeaga4BATd3d1q78lvfvMb9TUJSEYz1n49+/r+/v7s7HMhRS35GEssFsv7fPbs2SOKVlL0e+CBB0YELcUU/UZ73vZzlJnp8jHRcyz29pLkksXKTjJ73U50SVFP13W1x8+ppaUFJ510Em666SaViJJ57sPZyTH5/tdee00Fk7fccovaWSiFQiIiIpoYY6HqxkJTZdasWTjnnHPUh914deGFF6oGKmmCk6Y1IiKi6Ywxz+TGPKORwtrll1+u9vNdddVVqhFpNPZjyf6+cknRb3jsJXk/u+hn5//OO+88hEKhvGZ+2e8nBco///nPuOCCC0bct/wMX/ziF2GapmrMl2Lon/70J5U//OMf/1j2cydqZPnHa4iIyiSLiKXTR96g4/G4KibJ0mFZDjwaObk33vWtra3ZwpW45ppr1CLgsT7sBcS20U6pScJo+PfZAUuhRrtf+zl+7nOfG/c5ykLkUm4vAdDwr0kB03bdddepf+X28vycH1Lws5crT7QseZ999lHdWHJiUILEZ555pqjXhoiIqJExFqpeLFQtc+fOVUkq6Up//vnnVfKLiIhoumPMM3kxz3iv+fLly1VubNOmTaPexn6sgYGBcR+rEJIrG/59zqkLdo7pd7/73Yg8lBT8nLcZixQIly1bphrZjzrqKBVTDT9dSETF4Uk/IqqoU089FR0dHeqEn4zzlJN6l1566Zi3lw4n6epxjviUzx955BEVJBxwwAHqOntM0qOPPqo6qWvR61//evWc5TlOxu3H89///hcrV65Uwd9YBdZbb70Vt99+O3bu3KlOQI5HxqJ+//vfV53z0nl11113lf0ciYiIGgFjoerEQtUmBT8ZlyXNb0RERI2AMc/UxzwSa3zjG9/ABz7wAVxxxRWj3kbyZ9K8LWM+3/a2t014n/YKGBk/WowNGzaoUZwyCWuskaT33nuvWvkjHwcddNC49yevz49//GMcfPDB+NKXvoR3v/vdI9YBEVFh+L8cIqoov9+vOoFkr4kU+yQgGe8UnRSqZAegk3wu18sYSikg2jPUJXCRk4OyZ244KRQOH9lZjS7v0047TRUsv/e9743aOfX444+rE5Cl3H48dufUZZddpgquo3185CMfgaZpBY9JkJGgEmzdfffdqqhIREREE2MsVJ1YaCr84Ac/GHMHzk9/+lNEo1E17kxG3BMREU13jHmqE/O8//3vxyGHHKJyO5I7G+6Tn/ykmuJ00UUXYePGjSO+3tfXp4pwNmnYF2OdHByLnO6TXNzHP/7xMfNQ0kReyGm/4buaJd664YYbino+RJTDk35EVHHyhi+nxLZu3Yr3vOc9454qk2XRMo/8jjvuUGMlX3rpJdx2221qV4p0+DhJwU+WAcvuuR/96EeqICUzwyWIkW6pzs5OJJPJqv5Gf/7zn6udeF/4whfUSILDDz8cbW1tKnh66qmn1HLmbdu2IRwOl3T70cjIBtm/F4lE8L73vW/M20nxVWamS7AlO/sKIWO0pLtKOsjuu+++El4RIiKixsNYaGpjoeH++te/jlmck6KcxJKlkOcnMdR+++2nmtEkxpXEmXTSS0e9xKXXXnttSfdNRERUjxjzTH3MY4/OlFN869atG/H1fffdVz3W+eefjz322APHH3+8mgo1ODiItWvXqoZ5yQ/94he/yMZG8+fPV2thZHLBwoUL1WNI0dBeuTOcFPvskZ7jNfpLgfLTn/60KuBJnlCmSk1ERpzKeM8rr7xSnWiUAiYRFYf/qyGiipNg4sgjj8RDDz2kFvCO57DDDsOXv/xl9fGTn/xEjRWQrh5ZSCwzvZ2WLl2qupGuvvpqFQBIgCG3nzdvnpr7/d73vrfqv03pkJLOLen2lhOJEthIMCRdXTKqVJYuS0Gz1NuPRgIz6QaTfYZNTU1j3m733XdXvxcZqSqPecQRR0z485x44ol43etep2a2y1iGY445pshXhIiIqPEwFpraWGi4v/3tb+pjrEkGpRb9JPaU5jSJif7973+rHdQSiy5ZskQl1j7zmc+oXdZERESNgjFPdWKeY489Fscdd9yYq1gkFyen5iR/9uCDD6r4RQp4ixcvVvGK5I9sEsv8/e9/xyWXXKKa7aU4KM4666wxi3733HOPasB/85vfrHJ1Y5HvlzGw8rPKY5xxxhkT/mzyWsj3SCwnpxk/9KEPFfCKEJGTyyp0cycRUYHktJ10BkkBSrqIRpvBLUUkObUnHTxymoyIiIhoumAsRERERI2AMQ8RUe3hTj8iqjjpgu7u7lZjHrh0l4iIiBoNYyEiIiJqBIx5iIhqD8d7ElHFyExx2av3y1/+Uu04keXBRERERI2CsRARERE1AsY8RES1i0U/IqqYL33pS/D5fGr+9jXXXDPm7G8iIiKi6YixEBERETUCxjxERLWLO/2IiIiIiIiIiIiIiIiI6hx3+hERERERERERERERERHVORb9iIiIiIiIiIiIiIiIiOpcXe70M00TW7duRXNzM1wuV7WfDhEREVFJLMvC4OAg5s+fD7e7/F4sxkhERERU7xgfEREREZUeI9Vl0U8KfosWLar20yAiIiKqiE2bNmHhwoVl3w9jJCIiIpouGB8RERERFR8j1WXRT0742T9cS0tLtZ9Ozejt7UV7e3u1n8a0w9eVr2s94d8rX9t6kU6n8dOf/hTJZBIXX3wx/H4/GtHAwIBqZLJjm3IxRhqJ/12cPHxt+brWE/698nWtB4yPMhgfTQ3+d5Gvaz3h3ytf13rDv9nKYoxUXIxUl0U/e6SnFPxY9MsxDIOvxyTg6zo5+Lryda03/JutLCn2Pf3009A0DU1NTQgGg2hklRpXzhhpJP5vd/LwteXrWk/498rXtR4wPsrH+Ghy8b+LfF3rCf9e+brWG/7NVhZjpOJipLos+hEREVF983q9+MQnPoFoNKouExERETU6xkdEREREjJHKxSwbERERVSWp9a53vUuNvGDRj4iIiIjxERERERFzSOVzV+A+iIiIiIiIiIiIiIiIiKiKpuVJP8uyoOu6mp3baAstZb5tI/H5fPB4PNV+GkREVMJ79bZt29DX14e2traK7Wyh8UlsJHsUG0kjxkcSG8kJWv7vioiovjA+qh7GSI2BOSQiovrEGKnBi36S2JEkYjweR6MxTRM9PT1oJJLMWrhwIZqamqr9VIiIqAipVAof//jHVQFqxYoVCAaDfP0mmexP3Lx5swqWG0kjxkciHA5j3rx58Pv91X4qRERUIMZH1cEYqXEwh0REVJ8YIzVw0U+SOuvWrVPdzfPnz1dJjkbqcJbTjY20F0mSlp2dnSqBudtuu/HEHxFRnYlEIqpZh6ame13eL6UQ1NHRwfhomsdH8r8riZEkLpYYye3mRH8ionrB+GhqMUZiDomIiOoDY6TCTat3d0lwSOFv0aJFKqnVaBqt6Cckcbl+/Xp1UoRjPomI6oec7LvpppvQ29vLU35TQN4npRgk75uhUAiNpBHjI/kdy/iqDRs2qPiYJ2mJiOoD46OpxxipsWIk5pCIiOoTY6TiTMu2X3YzN45GOslJRERULr5vNg7Gw0RERIVjjNQY+HsmIqJGMC2LfkRERERERERERERERESNhEW/BiZjMaXLqa+vr9pPhYiIGnCU0o9+9CNce+216jJRLWGMRERE1cD4iGodYyQiIqoGxkjFYdGvij70oQ+potsrr7xS0O3PPfdcfPrTn57050VERDTZDMPAf/7zHzz44IPqMpETYyQiImpEjI9oIoyRiIioETFGKg6LflUyODiIv/zlL5gxYwZ++9vfVutpEBERVYXX68V5552HM844Q10msjFGIiKiRsX4iMbDGImIiBoVY6TisOhXJTfffDMikQi+853v4E9/+lN2tJlpmvjJT36CPffcE83Nzdhtt91w5513qutuuOEG/PznP0dTUxP22WcfdftddtkFK1asyN6vXJbrbFdffbW6D7mv5cuX46c//WkVfloiIqKRAdupp56KE088kUU/ysMYiYiIGhXjIxoPYyQiImpUjJGKM+1b6y+99Qn0J9JT8litIT++9e43FHRbOd135pln4vTTT1cjO2+77TaV/JSinOw4uuWWW3DwwQdj06ZNiMVieMc73oFnnnkGbW1t6uuFWrJkCe69914sXLgQ999/P44//ngcdNBBOPLII8v4SYmIiKjeMUZijERERESMkYZjHomIiKi+TfuinxT8euIp1JKXX34Zjz32GH7xi1+oU3unnHKKKgJK0e/aa6/FV7/6VRxyyCHqtosXLy7rsd7znvdkL7/lLW/B29/+dlX8Y9GPiIiqybIs9PT0oK+vTzW0yI5bmlqMkRgjERFRbWF8VBsYIzFGIiKi2sIYqTjTvugnp+9q7bGkwHfAAQeoD/HBD35QneTbsmULNmzYoMZxVoqMBP3BD36A9evXq9Gh8XgcS5curdj9ExERlSKVSuHcc89V461lNHUwGOQLOcUYIzFGIiKi2sL4qDYwRmKMREREtYUxUnGmfdGv0HGbU0WSm7LDLxqNYu7cudlKtWEY+P3vf6/GKKxevRqHH374iO91u0euYJSTglLIs23bti17eePGjaqgKDsBjz76aDX79uSTT1aPR0REVG0ej0c1pFB1MEZijERERI0bH/Un+xHwBhD0svFqOMZIjJGIiKj2MIdUuJFVJJpUt956KwYGBtR+vmeffVZ9PPfcc7j88stx3XXX4WMf+xi+9rWvqeulOCeFu1deeUV975w5c7B27dq8op3s/bvxxhuRTCbV1372s59lvyaFRbnt7NmzVcHwjjvuwF133cXfMBERVZ2c7JMTftdffz1P+ZHCGImIiBrdVMVHhmngzlV34pXOTK6BahtjJCIianTMIRWHRb8pJqM9P/CBD2DPPfdUJ/3sj0996lPYunWrGvl5/vnn47TTTkNzczOOPfZYVfgTH/nIR9QI0BkzZmD//fdX133jG99Q+5A6Ojpw9tln45xzzsk+1t57743LLrsMxxxzDGbOnImbb74Z7373u6f6RyYiIiKqWow0b948nHHGGYyRiIiIhnTGOrGyZyUG04N8TeoAYyQiIiIqhsuqw1mPclKutbUV/f39aGlpyV4vp93WrVundtY14m4gXdfVCM9GMhW/897eXrS3t0/KfTcyvq58XesN/2b5uk5lTFPp+2vkGKkR4yPBGKl+8f2Gr2s94d9rfb6uD298GDe/dDNO3uNkHLPsGDRqfCQYIzVWjMT4qH7x/Yava73h3yxf12rGSDzpR0RERFXZcXvttdeq0dZymYiIiKjRTUV8pBkaVvesRjQdVZeJiIiIah1zSMVh0Y+IiIimnGEYatfs3XffrS4TERERNbqpiI96Ej1Y17cOXrcXCS0xKY9BREREVEnMIRWnsc7xExERUU2QcYuyvy0WizXk6EUiIiKiasRHa3rXqFN+Tf4mJI0kfwlERERU85hDKg6zbERERFSVgO2MM85Qc+5Z9CMiIiKa/PgopaewtmetOuXngotFPyIiIqoLzCEVh+M9iYiIiIiIiIimub5kHzb2b0RLoAUetwcpLVXtp0REREREFcaiHxEREU05y7LU6Cr5kMuT+TiaoU3a/RMRERHVS3y0tm8tBtODaA20wuvyImFwpx8RERHVvqnKIU0XHO9JREREUy6VSuH000+HpmlYsWIFgsHgpDxOd6IbPfEe7D5r90m5fyIiIqJ6iI/iWhwb+jaoy0FvEG63G2kjrRJnLperYo9DREREVK85pOmCRT8iIiKalgzTwLbBbdBNnQktIiIiamgJLYHN/ZsR8UXU5x6XR8VKEif5PL5qPz0iIiIiqhAW/YiIiGjKBQIB/OMf/0Bvb6+6PBl6k73qo8nfBNMyVXKLiIiIqBHjI9nn15PowZymOepzr9urTvrJGHQW/YiIiKjRc0jTCXf6VcnRRx+t/kCbmpqyHz//+c9RL8/9Rz/6UbWfBhER1TEZI+X1etXHZIyUkiLfjugO1cEul+WDah/jIyIiamSTGR/JyHPZ4Zc96ef2wLAMaCZ3H9cDxkhERNTIJjuHNN3wpF8Vfec738GnP/3pkr9fZtj6fBzDQURENFY3u1jbuxb7zd6PL1KdYHxERERUeUk9CViZpJmQCQjSFCWn/ag+MEYiIiKiQvCkX4256667cNBBB6G1tRUHH3ww7rnnnuzXzj33XHz4wx/GaaedhpaWFvziF79Qhb8rrrgCy5cvx5w5c/Dud78bW7duzX7P9u3bcdZZZ2HevHloa2vDUUcdhUQiob72hS98AUuWLEFzczP23ntv3HLLLdnv6+npwSmnnIL29nb1fYcccgg2bNiAz33uc/jvf/+LSy65RJ1OfOc73znFrxAREU0Huq7juuuuw/XXX68uV5IksLZHtyNlpPD8zuexuns1T/rVOcZHRETUCCYzPpLinrMzXk766YauxntS/WKMREREjWAyY6TpqCFO+l396NXqYyIHzzsYt37g1rzr3n3ju/HMtmcm/N7PHv5Z9VGO1atX46STTsINN9ygincrVqxQ/7700ktYunSpus2NN96o5tfedNNNSCaTuOyyy/D000/joYceUoVCKQCefvrpePDBB2GaJk488UTss88+ePnll1Vx77HHHoPbnan1HnDAAbj44osxc+ZMVfA7++yz8brXvU491ve//331P6AtW7aoMaQvvPCC+v4f/OAH6vFOPvnksk4pEhFRY5P3GHk/k+aVj370o2pEQ6X0J/vVaM/1feuxqX8TmnxNKqEV8oUq9hjTRT3ESIyPiIioUUxmfJTW03AhV/STnX7qpJ/Jk36jYYzEHBIRETVGjDQdNcSrM5AawJbBLRPeblHrohHXdcY7C/peeYxifelLX8JXv/rV7Oef//zn1Zz2U089VX3+3ve+F7/61a9Uoe/SSy9V1x133HF4+9vfri6HQiG1B/Dhhx9WJ/nkj/8b3/gGIpEINm3apE78vfLKK6oAKLcVb3zjG7OPd+aZZ2YvS6Hw29/+Nh555BFV9JOxod3d3Vi1apUqDh544IFF/3xERERjkQBNTpTHYrGKBWuWZeHOlzfh1c4N8Idfw7boZsyOzMZgepCjq+ooRmJ8REREjWoy4iPRHUvi3lcT6NNagY7MdW6XG7qlq/3HNBJjJOaQiIho+sdIj6/fiVe29+Lk/XdBWziA6aIhin4tgRYsaF4w4e06wh2jXlfI98pjFOuqq67KOy13/vnnY5dddsm7zbJly7B58+bs54sXL85e7urqUn/oMrLTOabD7/erop9834IFC7IFv+F++MMf4je/+Y26nXx/NBpV92kXIOUkoYwS7e/vx/vf/35VFBzrvoiIiIohQdqHPvQh9Pb2VixgW9c9iD88/hp6kr2Y3R7FocvmqEJgn9HHol8dxUiMj4iIqFFNRnwk/vq/tXh+k4GksRgHLTAR8ltqp5/ESdzpNzrGSCMxh0RERNMpRoqndfzswRehGRYGkml86uj9MF00RNGvnLFSw0dZTaaFCxeqMZ1O69evV0U9mz2aU8hYznA4jMcffxx77rmnOunn/KOX62U8pxTvgsFg3v3K48gpw3vvvVftEJT7ldN8EvQL2dcnS6LlY926dWpMqJwqlJ1+zudARERUK3YMJtSYqpSeQn90JsI+E0k9CRMcXVXPMRLjIyIiovJjJAsmYLmwpceDXefq6qSfxE26yb04o2GMxBwSERFNbz3xlCr4iac3dSGlGwh4PZgOWL2pIXKa7v7778c///lPVcD7+9//rkZzyujN0Ujx7ROf+IQqxMnJPiEjOW+++WZ1+fWvfz322GMPfPKTn0RfX5+6Tyn2pVIpDAwMwOPxoKOjQ+3+k0WYL774Yva+b7/9dqxcuVJ9raWlRY37tAuKc+bMwZo1a6bkNSEioulJmkzkfUk+7IaTciU0HaZlqfuLpQIYTLhUQssy2cVezxgfERFRo5iM+EgkNEPFSHC5sKknv/ebJ/3qF2MkIiJqFJOVQ7KldRPPbenGdMGiXw3ZddddVaHvK1/5CmbMmIErr7xSLaiUEZ/jjcA6/PDDccwxx6C9vR2HHHII7rrrrmxR8LbbbkM8HlfFv1mzZuHLX/6yKuS94x3vUDsD99tvP8yfPx8vvfQSjjzyyOz9rl69Wt2mubkZe++9t3oMGT8qZCTpPffcg7a2NpxwwglT8MoQEdF0Iw0oMo/97LPPVpcrNZpBTvVZsOCCC5t7vJkudjnpZ6Qr8hg09RgfERFRo5iM+EjE05pKkEl8tHPAg5TjcB9P+tUvxkhERNQoJiNGSqTzpx08uaET04XLqmT72BSRU2qtra1q15ycQrPJGEsZRbl06dIR4ywbwfDxno1gKn7nMitYCqrE17Ue8O+Vr209/ff7fe97HzRNw4oVKyry3/C/PLMGNz79KjrjnQh6gpjZbOLYfWN4pfMVnHPgOThw7oGol5im0vfXyDFSI8ZHgjFS/eJ7OV/XesK/19qPj8RH//wAVndvUoU/n8eHNyxPYdlsHS/ufBGn7nUq3rTkTWjE+EgwRmqsGInxUf3i+w1f13rDv9naj5EeW7cDP74/N/kw7PfgF6cfBZ+nds/JFRojNda7OxEREdWEQCCAm266SQXCcrlSo6ssS/bVWDK9Cj1RN5Jpjzr5pxlaRR6DiIiIqJ7iI+dJPxUgAWoaghT9BE/6ERERUaPmkJziaQMvbevBgQtnod7VbtmSiIiIpi2Xy4VIJKI+5HKlRjPIcE8gd3+yt0ZGWSX1ZEUeg4iIiKie4iPNMKGZdoSUuc/tfR5Inkseg41RRERE1IgxUnzYeE/x+PqdmA5Y9CMiIqJpIa7JQmdTXdbMKNbF/4FfPXcZ7ll3D3f6ERERUUOShJbER/bOY2FawNZeNkYRERFRY+eQhntqYycMCZTqHIt+REREVJU9a3/+85/x17/+VV2uVFIrrndjXfJmPNR7EdbE/4J+bTNe2PkC1vevr8hjEBEREdVbfGTKaE/LQjiQaY4Sm7u98Lg9nIZAREREDRsj2WZGMiNDoykdr+7oRb1j0Y+IiIimnARpN954I/72t79VLGDrjO/Af7s/ja2pO2FY+eM8u2PdFXkMIiIionqKj9QkBPX/gLltOgLezPVb+zyA5WXRj4iIiBoyRko4Tvodteu87OUnNnSi3g2Fe0RERERTx+Px4Pjjj0c8HleXK2Ft/3PQrKi67HV70erZB/ODb8HMcCvmNeUCOCIiIqJGiY8y4z2l5Gch6AUWzNCxdqcXhgn0x5pZ9CMiIqKGjJESjpN+Ryybi9tf3ADNsPDE+p344KG7w12h3YHVwKIfERERTTmfz4fzzz8fvb296nIlDKRyIxhO2/v9iPW+C7GUC6l0CgnNUAmvSi18JiIiIqqH+EgV/YZO+vm9LsxtzRT9RO9gC1J6qiKPQ0RERFRvMZJzvOd+82fimU1d6E2ksKZrALt1tKJhxntu2bIFZ511FmbOnIlQKIT99tsPTz31VPbrklC74oorMG/ePPX1Y489FqtWrcq7j56eHpx55ploaWlBW1sbPvzhDyMazXTmExEREZViMN2XvdwSaMbsFmPoMxf6ErLPJrfHhoiIiKgRyOgqddLPkqIfMLvVjo+AZNqPtJkeOglIRERE1DjiQ+M9pTU84PVgn3nt0E0dKT2Jbf0x1LOiin5SST3yyCNVNfX//u//8PLLL+MHP/gB2tvbs7f57ne/i5/85Cf4xS9+gccffxyRSARvf/vbkUzmdutIwe+ll17C3Xffjdtvvx0PPvggPvaxj2GyZH5ZqUn9kMeoF01NTXjhhRdQL44++mj86Ec/qvbTICKiGqYZJpLGQPbziD8CvzeTwHLBhXhaY9FvFIyR8jFGIiKi6UZGV6lzfi7A5wE8biBtdWNn6gnopgXNYIw0GsZI+RgjERHRdBMfOukX8nvUKE/DSqiCn2EaiKXqexJCUeM9v/Od72DRokX43e9+l71u6dKl2cvSHSbFmS9/+cs46aST1HV//OMfMWfOHKxYsQKnn346XnnlFdx555148skn8brXvU7d5pprrlEzWb///e9j/vz5FQ/UXu58GQktgckU8oWwd8feaofQRNasWYMLL7wQjz32GMLhMP7f//t/+MIXvpD9+sDAAD7xiU+ogqiclpTbXn755dmvf/7zn8dvf/tb9buQBZZ77723un7t2rU47bTT1P0Gg8ExH7+YU5XnnnuuOo3JohsREVWSNANJXKBpmlrEPN77VqEJrRbvYszyvR4uzwDaAm3YNNCPbclXkTIGsbK7nUW/Bo+RTj31VMZIRETUUPGR3cWeO+lnqff9x3uvQMrsRb/xVhxhHq0Kfx53ZfbjTAeMkUZiHomIiKZdjJQeKvr5vOiKd6EnsV2NQxcxTUPDFP1uvfVWdWrvfe97Hx544AEsWLAAn/zkJ/HRj35UfX3dunXYvn27Gulpa21txaGHHopHH31U/WLkXyki2QU/Ibd3u93qZOApp5wy4nFTqZT6cCZ8CiWVWQlqfR4f/B4/JkPaSKvHkMeaKKFlGAbe/e534+STT1avpySh3va2t2HhwoU444wz1G0uuugiNQJ148aN2Llzp3p9lixZgnPOOUcVS6WAun79evz+97/HJZdcgttuuy37fVdffXVF/ugrRdd1tVyTO5SIiGi090T5qARJaC0KH4OAtS8WzUhjXjPw8rZ1eCn6M/X1pu43T8uiH2OkwmIkiVcZIxERUaPFR86dfsLnsfB/q/9PFfzExvj9MKw3QTM1BFE7eYRqxkeNlkdijERERI0aIyWGxnsaVhIPbXgIMd2l8kbyIY3lDVP0k8Di2muvxWc/+1lceumlKnD41Kc+Bb/fjw9+8IOq4CfkZJ+TfG5/Tf6dPXt2/pPwejFjxozsbYa76qqr8LWvfW3UcaPOX3Q6nYZpmqrQJB9C/pXbBNwBuK2iVxgWRO5XHkMVuDB+d5yMRH3ttddw2WWXqULY8uXLcd555+GXv/ylOqUXj8dx0003qaKqjE+QjwsuuAC/+c1vVDAn+xEPOeQQ1f1+zDHHqDGq8rjSzS6v61FHHZX92cci41nld3fggQfiyiuvxDPPPIPFixfjz3/+s9qz+O1vf1s9FzmBecMNN6jnKY8vAeNzzz2nKurf/OY31WP29fXhiCOOwM9+9rPsKU25fzkZ+Otf/1o9X/lbuf/++9U4V9tf/vIX9dgvvvgi/ve//+HTn/60OgUqBcK3vvWt+PGPf6z2RgrpSrRf3+HkOvmd9/f3I5GYnJMKxf4fCMTXtZr498rXtl7Y0wEGBwfVe1+5/w3f3huDbuhwWS6E3V54U0CTK5L9elpLq0RI2B/GdPrfLGOkiWMkiWUYIzFGqid8L+frWk/491rb8ZHoGYjCNEx44EY60Yd71t6T/ZobPvi1ALp7uqEH9YaLjxo9j9SIMRJzSPWL7zd8XesN/2Yrq9Ixkm5IYS9zmq831oVn169CSmtFPNWhlsR09vWpuKFe/66KKvpJICQn9L71rW+pzw866CD1ZisBgxT9JsuXvvQlVWh0/nAytkl2CUpw4TzmKQk9KSLKhzBgqABAXecp6sctmOky4TE9eY87FjnRKOznZJMde/K5jLWSoFNeZ/vrBx98sAqg5PMDDjgAX/nKV9RoBQmA9ttvP/XHLqNX//Of/0z4+Db7ucrzueuuu3D99ddng7OPf/zjOPHEE/GZz3xGBWfDx3tK8PX000/joYceUgGVfH7WWWep3Yy2m2++Wd2vfF0COgnutm3bpn5vQgLDs88+Wz0HKRrL85cTofL7k5OkMiJWgj0hweLw18v5c8jPICdKJ/OEo3NvJfF1rXX8e+VrWy+k4UeCqEr8zW5NWnC5Xep93xswoQdMhMKB7NdjRgzB5iDaw7X133N5fysHY6SJY6Tvfe97KgnGGGly8D2Hr2s94d8rX9dGi4+E5dkMy2XBcJm4e9sKpM109mt+dyv6rUEEm4Job25vuPio0fNIjRgjMYdU3/g+zte13vBvtnZjpIFkWr3HyzQEw52AN+JFi7sV7o0edRpfc9fm76/QGKmolqV58+Zld6PY9tprLzU+QMydO1f9u2PHjrzbyOf21+RfGTUwvNNG3qTt2wwXCARUYOb8qFd77LEHdtllF1xxxRVq3MRLL72E6667LlullSAsEonkBSYSLElAJvbZZx+13+boo4/Gv//9b7UHUfbXyHgG6XCSri3pcJJAqlASDEpHlvzRSAAlweLKlSvHrKr//Oc/VyOy5O9BAq1vfOMbePjhh7Fp06bs7WT/jnRsye9OTnrKaAkJBIX8/qVbSx5LSAD6xje+UXV2yW0lOJdAlIiIqKjRVZapAja/16Wua/LnmkHSRlIFbtMNY6SJY6SLL75YdcgzRiIiokaNkdSIc8uCy2XBhUycZI+z0kzkFQKng+kUH01mHokxEhERNarE0PhOySO5XTp8bh98HjnjlxEbOgVYr4oq+h155JFqpICTFIfkuL5YunSpKtzJiTObBCGyq+/www9Xn8u/0rEjHT62e++9V50ilA6d6U4KW//85z/VKALZiXjmmWeqsQz2CAIZwyBHVJ0jCGR0ZXNzc/bzCy+8EM8++6yawS57FKXoKvcjRTQZn/CrX/1Kfa6WdRfAWWyVbqhQKJQNDofr6upCLBZT4x8kiJQP+X4p/jmLfjLmwUnmyP/pT39Sl2Wcg4xysG+zevVqnHTSSapIKMG4dHvJ4xAR0fQl73N///vf1XvZROOECk1o/d/2c/BU/8W4be2P0R3vhteTS2qlpmnRbzqZrBhJxlrJB2MkIiJqtPjI3lcjCS2Xy41z9j8LXzs6N/ZSt5KQnJeMSKfaxRiJeSQiokZX8RySlrkPU5qi3Lra4+v1SC3FpZrJJcfUMEU/Oab/2GOPqfGeUqiRo/VSYJJZ4XbBSGZqy8kvWS4sowak2CPFHFk4bJ8MfMc73oGPfvSjeOKJJ9QJMUnQnH766dlZ3tOddFnJyAIpbEliSjq13vzmN2c7uCSgk3EINrmNjF8YTk7kyestJ+86OzvVH/yyZcvUfHf5mlxXLnuMhE0SbzIHXgq5Ury1P2SOrhTyxvo+Kept3rxZFXul+Gef8hOf+MQnVHJPuvClSCwjIgotWBIRUX2S96zf/e53KpaoRMDWn4whZfYiZXUjrvergC1lDMKDzGk/zUyx6FcHGCMxRiIiamSVjo/sop8ktCSR5XIB85vnY+/2YzDTdyBm+Q9C2rCgmfXdzd4IGCMxRiIiamSVjpES6cyOX5mG4HKl4XMNnfST3nFL4ietcYp+r3/96/GPf/xDndTad9998fWvf13N6JZObOdYx4suuggf+9jH1O1lzMCdd96Zt29Nxjzuueeeagzl8ccfr0Y7SvGwUTz//PPqtJwU5qRCLWMZZPa4kILa+9//flx++eWqe10WGMuM9I985COjLqeWueW77rorZs2apYqHUiyU+5f7tjvjyyHjNteuXZstwkkxT4p0n/vc57In+7q7u9Xs9fHI6cH3vve9avG0FPfkeduk0Cdd+nLKT+5T5soTEdH0JiOlJQ6Qk+Pl7m0RO2Pd2ct+TwB7ztoTb1n6RnjdYXWdZvKkXz1gjMQYiYiokVU6PsqOQIcJn+pezzhm0bk4qPUS7N/y/2CYHmhGfSe2GgFjJMZIRESNrNIxUnzopF9mGoIOn9enCn5eqZa5pOiXKQrWq6I3Ep9wwgnqYyxy2u/KK69UH+MtXZSq7FSazJFexd73X/7yF1x77bVqYbTss1uxYgX233//7Nd/+tOfqiXICxcuVMUyOQkpJyadZMyqHGd99NFH1efyxy7f9853vlP9Dn75y19W5H8AUmyUfX/yO5PlyRJoSrHxu9/9rtqNs337dlVclP/RSbFyPPIzyAz5D3zgA3mjuGQ/oPy8P/vZz7D77rur8Z4yo56IiKYvOdUup9VlCbNcLldXPFf0a/I3oSXQgpQO+NwRpMweVfRjF3vjxkhyn4yRiIio0eIjEZOdfqaBoD9X9PO6c5dN080YaQyMkUrDPBIREdV6jBQfGt9pyrE+VxpeV6ZMpkZ8WkCyzot+LqsO5yjKybDW1lZ1Es65kFkSRLK/RXYL2icLdVPHy50vI6ElJvU5hXwh7N2xN7zuouuoFSNHW52LmxvBaL/zSpP/mLS3t0/KfTcyvq58XesN/2Zr+3W9+PY/4gdPf1Bdfv28o/CP0/+M9b2bcMINH0SftlJd/+iHHsVhiw5DPcQ0lb6/Ro6RGjE+EoyR6hffb/i61hP+vdb262qYFs78/T3419aPIW5sQWuwCd899rtYuc2P/23wq9vM71iJC454B96w8A1otPhIMEZqrBiJ8VH94vsNX9d6w7/Z2n5d73x5E/7w+ErEtRhaWp/F0bstUNf/639h7Iym0BFpxT8+cgpqTaEx0rR/d5cEkySaDHNyq7Met6eqBT8iIqJG1pvsyV5u9kcwt2ku/B4/gu4ZCLhmwOsOYiA9UNXnWGsYIxEREU1vss/PggXdisOEpk6uyWQgrzfX+62bLp70G4YxEhER0fSPkURm77EJmzrpByClm2rdmcRN9cjbKAEbC3JERES11WV77rnnqh20MvK73NPafYne7OW2UDPcLjc6Ih1467yvYEPfDvi8CXhcldmNM50wRiIiIpq+8ZGMrpJklhT97NP34n8778YjvffBsJI4Mvhe7vQbBWMkIiKi6R0j2Tv9PO7MZSE7kKXMZ5oW0oaJgLc+80gNUfQjIiKi2hOLxaBpWkXuqy+VO+k3M9iW7caKBPzqsmG6J3UvCxEREVGtxUeZop8Jw8qM8g57w+rftBFH3NiauaynGSMRERFRQ8VIiexJPxOevJN+8v+7YFqG2uvHoh8RERFRgQKBAH75y1+ir69PXS7XYLove7mjaVb2csTvgwtS9PMwoUVEREQNFR9JQks3k7Bg5J30C/ly9y1NUSkjVfZjEREREdVLjBQfOulnWCYCntwIT7+c9HNJ0c9CNJVGayizA7ne8KQfERERTTkJoubPn49QKFSRGenOot/syOzs5fBQ0c+0XIhrTGgRERFR48RHUvRLW9Hs5yFvpugX9uVGYmmmzsYoIiIiaqgYKZ7ONETJib6Az5V30k9ySBZMxCt0qrAaWPQjIiKiurc0/E5Y2nwYrh4sbl2cvX5L/Gm8HP0j0mYUj286Hqfv+766XcRMREREVGwXu2bkin5hX2a8Z9iX61rXDA0JLTP+k4iIiKgRxLXcSb+Qzztyp59lIZ6u36Kfu9pPgIiIiBqPruv417/+hbvuuktdLocEYyH3Usz2H4Fdmo7CzPDM7NeSRhc6tSfQb7yMLYPb1Lx2IiIioukeH9ld7Gkrlv08O97TnxuLpZkax3sSERFRQ8VIibQOCzLK04DPoxb5KV6PJccKYQ2N96xXPOlHREREU06CtF/84hdqCfNJJ50Er7f0kESWK0uwZg0FaEFPbmRVa6Ate3kgFcssaUYuoCMiIiKajvGRPd5TM0eO94w4xnvqZhpJPVnW4xARERHVW4xkWSbcbgMBT64Zyjc03tOEiWiqflfE8KRfA9pnn31w++23o16ce+65+PSnP13tp0FERBXkdrtx5JFH4tBDD1WXyx1dJcGalP28bhN+T25kVWugNXs5ms4U/YjGwhiJiIimS3xkx0hpIzZivGfI5zzpl1YjPhkj0XgYIxER0XSLkUzLgsdtwOvJFRClkTyz089CNM2iX02TrrWB1MCkfhTTGbdlyxacfPLJmDlzJmbNmoXTTjsNnZ2d2a9LxfrCCy9Ee3s7ZsyYgYsuuijv2OqPfvQjzJ49G7vuuisefPDB7PV9fX0qEHPe12heeuklnHDCCQU9169+9avquRIREVWS3+/HF7/4RdXUIZfLDdZ2Jp9DVN8IHX0IOrrX20O5k36xdJwJrWEYI+VjjERERNMlPrL31czw74O9w5/Dmft8AvvN3k9dH/Tmn/RLm2nGSMMwRsrHGImIiKZLjGRalpoYJQ1PbpcOn9unrpcmKLXTT5b6WRYGk/U7CcHbCIHaHavuQH+yf1IfpzXYiuN3Oz4veB7LBRdcoP7dsGGDmg975pln4lOf+hRuvPFGdf03vvENPPTQQ3j55ZfV5+985zvxrW99C1dccQW2b9+uvv7CCy/gySefVPcll8WXvvQlXHzxxejo6ECtkJ/PNE14HLNxiYiIKqknMYhHer6sLm/RlyHoOTf7tfZQ7qRfQk9CN8uf/T5dNFKMdMkllzBGIiKihiP7avzuVrT798Xr5ploDskwdOSNsdLMFDRdg2Ea8LqnfYqoIIyRqot5JCIimkxJtSJG3m9MuNxS6POpAuAX//NFRHztiJhvwmzfWxDXtLr9RUz78Z5pI62SWQFvQCWdJuND7lseQx6rEGvXrlWn+5qamtDc3Iz3v//92aSUuO666/DlL38Z8+bNUx+XXXYZfvvb32aTYLvttpu6/rjjjsOaNWvU9Q8//DBWr16N8847b8LH32WXXbBixQp1+fe//z0OPPBAfP3rX1enB+fMmaNOEgq5jSTSZBSoPFf5sAOwn/zkJ9hzzz3R1taGo48+Gq+88kre/V911VU47LDDEA6H1X0sX7487zk8/vjj6nuTySQ2btyIt73tbapYKacb3/Wud2H9+vUFvZZEREQ7o93ZFyHoCeeN95wZzp30S+qJgt+rG0EjxUirVq1ijERERA1H7atRaa3MjhpbxB/B/u1nYM/Ih7Eg+DbopgHNrN/EVqUxRhqJeSQiIppO8ZGQvX1y0s/r8mLL4Bb0p/qxNboeq+J/woCxCrF0/cZG077oZ5Pu8ogvMikfhXSuO332s5/FLbfcgv7+fjWSU7rXTzzxRPW13t5ebN68WRXibHJZCmNye0lmrVu3Tt3m7rvvxn777afGgUoX/M9+9rOSXhsZ0yDFORk7evPNN+Pzn/+8SpTJWM9LL71UjQKNRqPqQ1x77bUqwXbbbbehq6sLp556qnr+6XQuoSfFxD/84Q/qe6S7Xn5OSbrZ/vSnP+F973sfgsGgOgkor8mmTZtUwk6ey0c/+tGSfhYiIqoPqVQKH/zgB/HJT35SXS7H9mhurHXIF84b7znTMd4zbaTUuAZqrBjpM5/5jFr4XQrGSEREVK/xkYinDdXFLnzeTPFPSIPUPu3vwsLQsWj37gvDtNgYNQrGSGNjjERERPUaI8XTQ0U/tdPPhMvlQjwdx+zI7OxtEsZOxFn0o2LI0smdO3dmd/ZJEktGcwq7sCan4Gz25cHBQXX7a665RhXkfvjDH+I3v/kNvvOd76jPJbElY67k5N0//vGPgp+P7BX83Oc+B5/Pp75XOrieffbZMW8vxcUrr7xSJde8Xq8qOCYSCXV6z3b++edjjz32UGM9Zc6udOpLoU/I85Ti4jnnnKM+l8eT5y0FwJaWFtW1/9///lcVA4mIaHqSU+M9PT3qPVAul6Mz1pW9HJainydXaGoLNcGFTGt7ykgyodWAMdJJJ53EGImIiBouPrKTWr3plejXX8D6/jV5Y85lZ02GC0ndZGNUjWOMxDwSEVEjq2SMFB8q+vWn12HVwF24f/39aAm04OQ9Ts7exrDiPOlHhZNCloyylIDNPj0nl2UMlbBHaErHus2+LGOuhJyQe+qpp3DvvfeqQtnf//53dZruYx/7mEqMScFPCnHyP4JCyEhPp0gkopJnY5HRm2eddZZKtNkfdve9bfHixXnfIwW+v/zlL6oSf8cdd6if5Y1vfKP6WmdnJ8444wwsWrRIFf2OOuoodbvxngMREdU3aQj58Y9/rMZBl7uEuSuWG+/Z5G9W89htIb8PXldYXdaMJEdXNWCMJBMMPvzhDzNGIiKihoqPRFzTsSb+d7wYvRpXPXQVYulY9mveoaKfdLenDYsxUg1jjMQ8EhFRo6tkjBQfGu/Zk34NL/f9G9e/cD1W9axSTeQ23YojOXS7etQw4z1rhVSkZYSlFOVkjKV8XHTRReqUnIzKlM72hQsX5p20k8tSEGttbR1xf3KiTvbryR/7888/j0MPPTR7H7K/plxu98g/EXkuMnpLxm7ZH/F4HB/4wAfG/D7Z7ycnCmU/oJz4k6Kh/B8XQgqV8v3PPPMMBgYG8OCDD6rrK9HZSEREtUneJ5YtW6ZOe4/2XlOM7mSu6NcaaIbHnVtaE/J5sDj8VszzH4slTYfxpF+DxkjPPfccYyQiImqo+Egk0jp0M1focyazNKsfMX0rBvX1kJyWbtRvYmu6Y4zEPBIRUaOrZIyUGDrplzJzDcVN/iaEfKHs57oVy54IrEcs+k0xKXztuuuuakRmMplUH3JZkljyNXHeeefhm9/8JrZv364+vvWtb+EjH/nIiPuSnXnLly/PnpiTP3zZYbN161ZV8FuyZEnZz1dOAUoCTtdzf+QXXHABrrjiCrz22mvqcynU/fOf/5zwZN7ZZ5+txm7961//yo72tL9fEntyYrC7uxtf+9rXyn7eRETUOHoSPdnLbcEWuF258Cbk82K/1g9jefhMLG8+lkW/GsYYiTESERFVjjTRSie7dKoLr9ubNw3h/zZ8F4/2fQ5P938FuuniSb8axhiJMRIREVVOXDPUv2lzIK/oF/YOP+mXuV098qJBJPVkzdy3FMg+85nPYMGCBWpMw0EHHYRbb701+/XLL79cFb/22msv9bmcirv00kvz7kM63r/3ve/hoYceyl4n3ewf/ehH1Tisr3zlKyPGdpZCxmT9+c9/RkdHh/o/GuRU34UXXqh29Z166qnYtGlTdlTnMcccM2HRT56XnPqTwqdNinyyiNPu4P/sZz+LFStWlP3ciYiodkkzyQMPPKAaRk444QS1I7ZUvclc0W92ZGbe16To51I9Ti7ophtpM13W856OGiFGkgarD33oQ4yRiIioYeKjpG6o91LdSqjPQ95c97rwewLqXxMaUrrJxqhRX0PGSKVgHomIiGo5RkoMneAbUfRzTESQnX4SS9Url1WHMxTlZJiMcZI9LrIDzian5tatW4elS5eqPS7qOj2JO1bdgf5k7rjmZGgNtuL43Y5H0Jt53Gr98ZfzB1+PRvudV5rsK5SCJPF1rQf8e+VrW0///ZaEgKZpqtGjnP+Gv/7ak/HUzn+qy99+yw9xyVGfzn5NM0yc/rt/ozO2E+HgAC5/58E4cvGRqPWYptL318gxUiPGR4IxUv3iezlf13rCv9fajY964imcf9OD+PvmU9SIqjmROfjmMd/Mfv0bD/wY6wdeUJffv/sl+NJbPoAD5h6ARoqPBGOkxoqRGB/VL77f8HWtN/ybrd0Y6ean12DF8+tw97bPo1vLrA+5+rirVYPU+Xecrz5v8eyBo2Zfids+dhpqSaEx0rR/d5cEkySa0sbkdvb7Pf6qFvyIiIimSko34Pe4s7tZSyEz2F/3utchkUiUPY89ms4VreY255/083nc6rlKh1PaMBDXMiOuiDESERFRJUk/tTQb+b253cLVjI9kD41pyUm/+Kgn/QJDJ/1EUtd50s+BeSQiIqLKkfjI43bBXSM5pLimZ+I2M5q9LuKLwOP2qHjJMv3wusJIaaaamlCJPctTbdoX/eyAjQU5IiKi8t36/Hrc+PQavGX3+fjYkZkRi6Xw+/1q5LN0v8nlchw7/3LMsE5HyhzAopYFI77+Qv9v8XL/32HBwMldP8bblr+trMebThgjERERlU8KbF+54yl0DiZwydsOxF5z26seH8noKs2Ugl9muFPIl1/0c+ZI0oYO3cyMuqLc68M8EhERUXme2tiJq+99HstnteBr73pdyYW/SsZIcWmMgoW0Nag+l7GeUvAT17zzGtz7UhCbeg0YlqUao8JlPl411F+ZkoiIiKqiP5HGX59dqy4/sGqr6oyqBdKl5XYFEfG1IRKIjPh6wOtXBT8x2aMsiYiIqPHc/epmbO6Nqd14j63fiVogCa20o4PduadGBL25k35pOemnc+8xERERVY5hWvjj4yshqaPVnQPY2h+vmRjJUtMQotl9fk4+D+CCS+W8oun6jI9Y9CMiIqKC3PHSRmhGptBnWjLm06yJVy6zhNmC12Mi4Ehg2SK+XAA3kMotaiYiIiIqV1o3VIzkTCTVgoQmJ/1yRT/neE9JYnkco6rShsbxnkRERFRRj63bgc5oMheb1FCMpJu62nksmhw5I+HzWJmiH0zE0xrqUUOM9yQiIqLySAJLutidkpqOoLRAlSCVSuGiiy5S//7qV79CIDCyWFcISVolNEN1jnk9Vt5+GluTP7fcuDfBk35ERERUOQ+s3oaBpJYXH5WqUvGRPQlBN5NwwwcTmhrvKTv++pJ9avKBael54z3TZn12shMREVHtkVzNP19YP6LYVgsxUkKNQE+g1bsnIsEBzGmak/d1yS25XG4VN0VTKdSjaVn0kwWL1BhqZbQcEdF0JwU/Ka45yedtZfz3e9u2bdA0raz/lg+k4ni275cwDA86PHMQ8Bw34jbNjqJfX3JABW5uV2MOO+D7ZuNgPExENDVjq257YUPedcPjpWrER3bDVqt/Nxze9iu8afcUZrVGsXFgI1r8LVjavhRzmlZlb6sZ6YY/6ccYqTHw90xENDX+t7kbm3ozJ+lqLkbSdHhdIRzYcjHOOkIKfLk9gw9vehiPbHkNnbEYdgufi8Fk7qRiPZlWRT9Z4uh2u7F161Z0dHSoz52/tOlO13V4vdPqVzou+R94Z2en+h37fL5qPx0iooYZW+UMlEol79Hf/e530d/fX9YS5k3927E+/i91WXcfgKAvOOI2LYHW7OXBVLwhi37yPinvl/K+KTES46PpHR+l02n1u5a4uNwl50RENLbH1uePrSq3i71S8VF2zKgkxSwg7PcjqSexoHkBlrYuxaK2RXhs01PZ22qmrr7eiBgjMYdERESVd+uwU361FiOZMOFxG3C58qdXretdh9f6HlGXU2Y/BlP1GR9Nq3d3SWwsXbpUVX2l8NeIHd3yGjQSSVouXLgQHk9p4+WIiGhiDw4bW1WJeezyfrXXXnuht7e3rPeu7YNd2csBTxhBz8iiX1swdx5xMB2DYRrwuqdVCDQheZ+U98vNmzdj/fqRwfd01ojxkQiHw1i8eHFD/uxERFPVZHHr8/mn/Mrd6Vep+Mjupjel4ieJMi+QMDVouoYl7UuwrH0Zjl3+FjyzZhdEfK0IBzSk9PocX1UuxkiNFScwh0RENPle3dGH13b012QOycquiDHh8cjJw/yaQtgXzl7WzTgGOd6zNkilVxIccurNMEo/MlqPpNLd2po7zdAoXXks+BERTe7YqlsdY6vesEsHnljfWXaXVqVsj+7MXg77Igh4R851bwvm3hvjWuakXyNqamrCbrvtpsZhNJJGjI8kNpLpD410opOIaKo9u6UbG3uj6vKuHS3oiaXQE0+VNbqqkiSxZo+/8nksdMVj2HPmnljevhw+jw8zwzMQ8UYRcIfhsgaR0BPq9o343sEYqXEwh0RENPlufT7XaHzoLrPx+PpM3qYWYiTNMFWey7QsddJvONmBbNOtGGLp+tx5PC3b3O1xj4028jGRSCAYHHnCgYiIqFRPb+rMjq3ab/4M7D23PVv0S5YRsEljzqOPPorBwUEcd9xxJTdw7Ix2Zy+HvU0qiTV+0S+hTvo1KnmdG61ZhvERERFNhv97aVP28rv3W4K/PLNWFf2SZTRFVSo+ssewb0n8F9sSz+DOtSEsaZuP5kBzNlbyuX1wDyW7DNMD3UyqxijPsDFXjYIxEhERUfm29cfVPj8xMxLAW/dY4Cj6VT9Gig+dNlwfvxNbkv+HTY+14OQ9T8bStqUjT/pZcURZ9CMiIqLpZmNPpoNdvHWP+UjrZkV2+slps+985zvq37e85S2lF/1iufGeksgabVffrEh79rLsq0kb9dmpRURERLVjQ8+g+rcl6MMhiztw24uZ/ccp3VTd4+4STsxVKj6yT/p1p1/E9vR92L4O+MC+H8ibiCCjzj1uU+38M00PUkYK1tA4UCIiIqJS2FMQxJt3k4ajXGN2OUW/SsVIiaHm9Zi+Df3aJvR3AsfscozKE/k9/hFFv3i6PiclTcuTfkRERFQZMcfM9fZwIG+3XzmjGWQG+7777otkMlnWPPbOeK7o1xpoGbU7fUaoDYe0XaKe756zLRb9iIiIqCwyBtPuFJf4SAp8IZ8nr+AWcSS5pjo+spuzNDOW/VwKfkFvbjKQ7PDbmrwfuuGC3z0LaX1ew45AJyIiospw7jaWGCkki4VrKIcUHyo8ps2B7HVdiS6s7lmN9mA7Au5A3nhPFv2IiIho2omlckW+sM+bd9KvnCXMsoP3qquuUkuY5XKpehK58Z7tofZR99A0BQKYHzoCPVY3mnxdLPoRERFRWdKGCd3MnIoLDyWzgs6in2aUVPSrVHxkJ900K1f087v9CHhyiSzDMvDq4E3q8kzfwUgbp0AzNNXlTkRERFSKaF4OyYOQN78pqlSVipHisvMYFtJmZmKDaPI3Yd/Z+6I32YtYf2xanPQrr3WMiIiIGuaknySvnF1aSb36u/F6E73Zyx2RGaPeRjrvXXDJ0l9ohgu6WXqgSURERORMaEWGYqOQzxEjlTG+qlIkqaWb8ezncsrPWdBrCbRkLxtWEmmd0xCIiIio/PjD1lSDOaS4PD/LgmblTvo1+Zqw96y9ceCcA/GG+W/IXm9I0a8GYrpScLwnERERFRywJR3jGJxfq5a+ZO6k3+wxi35edQJQzgDKCCvu9CMiIqJyODvV7RN99ok/UQsJItmbo1mZop/P7YPP48vb6dfsbwZUdGTBQEol4hgjERERUTlijpNxEiP5PG543dJ8nRuNXu34yIQFzczsHgx5Q6oxal7LPETTUXQ7pknpVqKsPYTVxKIfERERjSk6FLD5PC4VrOXtqykj+Emn07j44ouRSqVwzTXXlDyeoSO0DG3enSpgm9vUMeptZNzWoLYOPdo6JAc6kTTeWvLzJiIiIoo6i36jnPRLpI2qxkeaYWZGkA4V/UK+ENxw5433lAKg1+WHbqVgWknoukvt+SMiIiKqyLQoO0byezGY1GoihxSX8Z6WCc3KjPcM+8KqMUpO+7UF27B9cDv27dgXPQOzEXIvzGt8rycs+hEREdGY4qlMUBbxZ7rYK7WE2TRNrFu3DpqmqculOmLuB5EcPAqmZaKjqW3U20gS7sWB67Az9SwQk5GgHyr58YiIiIicO4/tk36VaIyqVHykTiJaFnQzs5dGOti9bm9e0U8+97r90I0UdCupRqCnzTR/uURERFSy2FAOKS+PJI3YquhX/RxSPK3DMLVsY5Qq+rl9CPqC6vLy9uU4ec+T8dire6iCH4t+RERENG1P+sloT+H3uGU1nuSRyl7C/PWvfx0DAwNlLWGOptJqCbMM72wJBMcs+nndkeznPYmekh+PiIiIaLQu9qDzpF+JSa1KxUcyXtSwDBhIZp6bJwivx5s33lP2+/ncASSNwcxOP8NCUs/cnoiIiKj88Z750xBqIYcU13QV+8h4c7sxyuPxqFhJzG6anZmQ4DJUnimpmarJ3O1yo57wpB8RERGNPRpKN/P21MhuPAnYpDuqnNEMbrcbBx54IHp7e9XlUtk7c6QQ2RTIJbKGj/f0u1j0IyIiosqf9Gsa6mIPV+CkX6XiI+c+v+woT3d+0U9GWUnRT9hFP473JCIionJEh2IkOd3nlkSNo+gne/0kzySrY6oWI6V1pMz+7Oey0y/sDWfv0+P2qHjJ7TbgcvlUfGSYBtwlPOdqYtGPiIiIRuVcshxxjPWU4C1T9DNqoovMsix4PfIcw6PeRgLKgCdX9OtP5QI8IiIiouLjj1yMFLa72PNGoJfeGFUJ0ZQO0zLQ4TsUAX8UC1o61OgqOd1n87q82c8tGJCnzJN+REREVIk8kt04PtoIdJ8jHqnG8/O6mrA0+AHsNm8A4YAPEV8uXyQn+qQQ6HEbsCwX0rpPFf2kWaqesOhHREREBYxlyAU4KqkVS5WV0DIMA88884wazXD00UercQrF2jKwBX9d/yG4rBDmBg+E33PcmLcN+5qzl3sTvSU/byIiIqK8GGkoqWV3sYtE2qhafCQGk2n4XBHsETkfB++SxozWrZnxVa7c/UnBz+/Y8acZBuJa7nQgERERUTGkIdtujLJXxIxsjDLQMvpmlimJkQaSGnzuZswPHIdT9zawpuc1NAWasl+XWOmG52/A49uehmGlcHjrz1TuK1hfNT8W/YiIiKiQBczOLq3MZRn9aZgWPO7MyIZiyPLlK6+8Uv175JFHlhSwbY/uRMLoytwflqhkViFFv4HUgOrUkrENRERERKWcpLNFhsZ7BmXswJBSG6MqER/ZCS1TFjCrRJsbuqmrOMm5j0Y61tuDM9EVXwCvKwTDdCGhJUp6PCIiIqLUUI5o3JN+6WrHSGm1o8/jNuF1A7qlo9mfyxfJShuJl6Tgpx7XimIglUB7OFcYrAc86UdERETFnfQbNprB2cFVKJmXvttuuyGZTJY8j33LwM7cc/JGxi36Nflaspf7kn0wLAMesOhHRERE5Y1At+MgZ3KrnJ1+5cZHzoSWBQthvwtxU1P7aiSRZZPmp3csfw/a9FmqAOh3b+VJPyIiIqpIDinvpJ+vxmIk04DPK1MZ3Op0oozzdGoJ5PJHuhXDYKr+mqJY9CMiIqKSTvqJpGaUVPTz+/24+uqr1RJmuVyKzf07cs/PFxn35F6zI2jrS2ZO+rHmR0REROUmtexiX35Cq7TxnpWIj8SgOulnDj0vFwaTBsLDdh9LF3vY54WVHcnlRUyLqeSXszhIREREVGwOKf+kX23ESKaMH03piBvd8Hr7oBltcMGFgDc37nxE0c+MYyCZRL1h0Y+IiIhGFR1lX81oJ/2qZdtgZ/Zyc6A5b0/NcK2B1uzlgVRUnfQjIiIiKiep5fe64fNkus2DNRIf2V3s62P/xsrojVj9RAiHLzwUb17y5hG3C/t86jSgsEwfknpSxUheF1NFREREVMZJv6Hx57WUQxqUpihYWB27CdtSD+C+O4Cz9jtrxNSo9mB79rJmxRFLpVFvSj8LSURERNOavYB5/CXM1QvYdkRzRb+2YEvenprhWgKZGe1uBKAZBjQjF4wSERERlZLUcia0pPjn82ROyCXS1W0uGkxpSJl9SFt92BHbpk79hXz5o6tEWOK7oaN+puVV4z3VNAQiIiKiMnJIkYB3jBxS9eKMwWRaRhsgbQ5mr5OC3/CTfm2htuxlw4phIMWTfkRERDRNxFIjR1epy47RDM6dNsVIp9P48pe/rOaxf//73y9pPENXvDt7eUaoddzxnnvOPAjv6LgZA+kYXj93s+pkJyIiIirnpJ8zPrLHV0ljUalNUZWIj0R/Ig3NjGU/93v8o+4+Xtv3Gl6I/h8saNgTb0dSnwXd1BFAfvKLiIiIaCLRMXJIeeM9q5hDGlDjzy1ojqJfk79pRIw0IzQje1mzYnV50o8zG4iIiGjiLi1HJ3v++KrSurRM08Qrr7wCTdPU5VJ0xbuyl+c05YKy0YR9frjdmZ8hZZgs+hEREVFJNMNE2jBHdLHbSS1JKMVLLPpVIj4S/cm0SlI5i37yMVxSi6NPf1FdjmuHQjNbkTJSiCBS8mMTERFRY3I2hVd6vGclYqSBZBomTGhWVH0e8ATUKb+gZ1jRL5jLL+ky3jPNoh8RERFNw4AtbzSDo0srWWLRz+fz4bLLLsPAwIC6XIreZG/28tymmePeNuT3wO3KjNySp5zQEiU9JhERETU25yQEZ1OUM6kl8ZFlWXANxR5TGR9JB7t02jtP+kkySxJbw7UEWrKXNTMN3dCR1JLAyEmgRERERKWN93Se9KtiDmlAnfTLFf0i/khmGoIvv+g3M5TLLxlWAjGt/tbD8KQfERERTTiaIVLhLi2Px4PDDjsMvb296nIpBtJ92csLWmeNe1sJMl0uNyT1phsuJA2O9yQiIqJyJyEMO+k39LlhWtBNK7vjbyrjo8GkBksltHJFP9nnN9pJPxlpZdOMFAzLYIxEREREFW2MqpkcUjINw9ShDxX9wr4wvG7viPGeM8Mz8076xTnek4iIiKbbST+P24WA1z3qbPZSd/pVwsEz3w+vvi80M465ze0TFv1WRW9Bb2oTdmyJ4SPaMVP2PImIiGj6iKUdCa3A6Cf97BipNVTaTr5yDCbT6pShbsYdzyukxlcN1xxozl7WzBQM0+Q0BCIiIqrsST9/+Tv9KmEwpSGl9vlZmeflDcHn8Y0Y77modRHesfR92Nq5Czyu1pLHtlcTT/oRERHRuCf9In45JecaYzRD6fPYX3rpJTWa4fDDD4fbnSsqFmqW/2DMC8yD22WiKZAfpA0newg3J+5DVN+Cbj2AeDqXCCMiIiKqyEm/YTFSsUW/SsRHanQVLOhWZpS5jPWUhNZoJ/2cRT/DSiJl6Egb9be3hoiIiGr5pF/54z0rEyOlkTL6s5/LCT+Jk7ye/HiuLdiGfTsOQLJ/F+imhrij4atesOhHRERE4ya1hnexSwGt3IAtnU7j0ksvVUuYV6xYgWBw/KLdWF1asCz4fcao3evDO+/97lYAW6CbKQykBkp63kRERNTY8hJaI076ldcYVYn4SBJasq/GsOLZhJbXNXJ0lWjx53b6SZHQMr1IGamiH5OIiIgo6miMck6Iys8hldY4XpkYSUPKyOWCJDZyjjq3Zfb8eWCpE4Eutau53rDoR0RERCPILho7sImM08WeLDFgk5ODixYtQiqVyjtFWCjTshBLGSoE83mNEeMYhpPnHFBFv4wd0R0lPW8iIiJqbOOd9HMmtUpJEJUbH9kJLdnpJztohDRGSQe7dLKPf9IvBdP0IK5xGgIREREVzx7d6fe64fPkTuK5XS4VI0lsVGoBrTIxUhpJsy/7ucRGstdvOLfLjUjAr5rM5ZHimqFGp5f6uNXAoh8RERGN4NzV5xzLMHKnX2kBWyAQwM9//nO1hFkuF6tzcAC96VVImhbaXN4CTvpJsitX9OtMdMIwDXjcpS2AJiIiosYUS41d9Ct373G58VHupJ+FXcMfwu7z4ggG4vC5ffB7R473bA3kYiMDSVjwcgQ6ERERlbUipmlYDsmeviQFv1Lio4rFSIk0Znj3xREzvo1j9olie3R73tQDm+SJBtM96NF2qCaqOfob1BQFj6t+8kcs+hEREdEIMcfMcucC5kqNZijX/7a9iId7Pq8uL8ORCHjPHvf28pwD7lww1xXrygRtqJ+gjYiIiKovmhcjDR+BXv7e43LJ+HPTMtDhPxRvWmQhYW1EyBtSXevDRXwRNbYKQzsATcOLhJ7ZBUhERERUSh4pPCyHZDdi9yJdtfjItCwVI1nwoC0wA7u0zUI0HUXIFxpxW4mZ/vryLVgZXak+X9b6axiWUVf5Ixb9iIiIqKjRVV63G36PG2nDrFrAtmVwZ/Zy2BeZcLyndN47x3v2JHtU0ObDyA40IiIiorE4O9SbRoxAL3/vcbnsnX4i4LPUuE855Tdad7pMStiz7U1IpNoRcs+SoemIpWNVeNZERERUzzTDhGZY45z0y8RMySqNyoyndVX4kxhJ4qPc8xq96OccgS6xkR1b1YuRrV5ERETU8GJDYxlGG+/pPO1X6jx2WcJ8+eWX45vf/Ka6XKzt0c7s5SZ/RO2qGY8836BjvGd/sh9pvfjHJSIiosbmjJHCw0765e89NqY8PhJS5JPElKTSJKkl48zlRN9oyTWJn14353gsD78fC0PHApZf7fSrt8QWERER1cZoz+Hjzoc3Rkm5LalPfYw0kEyrnccS44SGwjcXXKPuPBYtgdykqIQeV/FUPeFJPyIiIho3YBs+3lOE/F6VVIqXeNLPNE08++yz0DRNXS7W9sFc0a8l0DzhbHU5nRjxtWc/lzEOSSOJFoyc305ERERUyDSEpgrv9Cs3PrL31SSNPkSN9ehJRJDQEkNjPEfK7PqT9Jt8uGBZPsSHEltuD3vEiYiIqPimqKYxckjOaQjORqmpiJEGhpqidqQfgRbtwxNbWtTEqKA3OGHRL2UkkNBTiPhHj6dqUVFR3Fe/+lXVHeb82HPPPbNfTyaTuOCCCzBz5kw0NTXhPe95D3bs2JF3Hxs3bsS73vUuhMNhzJ49G5///Oeh69UZDUZERFQL/rt6Gz7390fxn9e2oFbEHd3pTcO62IUdoCXSuhrNUCyfz4fPfe5zKm6Qy8XqjHVnL88ItY66p2a4jrCMrcqIalGVBCMiIqLaHRP1w/uex+W3P4nOaO28Z8dSmfyFz+OC3+up6N7jcuMj0Z9MoSv9HJ4d/CYuu+9SPLfjOTXGc9TH8/gQ9JmwQzndCCCpJeuum52IiKiRrNzZh8//4zHc8OQq1ApnQ/jwnccjRqCnpz5GGhgaf741eQ8e3XETfvXMr+Byu8aMkVoDuUlRmhVDVzQ2vU/67bPPPrjnnntyd+DN3cVnPvMZ/Otf/8Itt9yC1tZWXHjhhTj11FPx8MMPq68bhqEKfnPnzsUjjzyCbdu24ZxzzlG/qG9961uV+pmIiIjqRlo38PvHX0M8beBvz67FW/dYgFrr0hqtA8sO2Ewrk5QbnvSaiMfjwdFHH43e3l51uVg9iVzRb1akDR73xPexoGUBZvoOghshzA61I6kni35cIiIimhoPr92OJ9ZnTvY/tGY7TjlgaU289LG0Nk585OxiLz6hVW58JLtqBpMaUkZ/9rqgL4iQd+S+GvukX8hnwrBSMEwNqbQHuqmraQjyfURERFR7/vD4Smzui6mPE/dbgpagv9pPCdGhpigRrsEYaUCd9LOgWQOZ5+MNqVN+Y433bA/mJkXpZhw7BmPYczamb9FPinxStBuuv78fv/3tb/HnP/8ZxxxzjLrud7/7Hfbaay889thjOOyww3DXXXfh5ZdfVkXDOXPm4MADD8TXv/51XHLJJeoUod9f/T9QIiKiqfT0pi5V8BOSpKnF8Z6jjmbIC9iMoot+5epJ5op+c5tnFPQ9y9qX4JC2L6ldNUvbXmXRj4iIqIY9uHpb9vKgIy6plfGeo09CcJ70m/rTcjJSVLrYU2au6KeSWmMU8KTod9uaG7Cy91X1+bsjP0HaTKtpCG3Btil73kRERFSYzb1RrO0azJtAUAtFP2fj+Ogn/fJzSFNtcOikn2ZmXrsmfxO8Li9CvtEbo9pDjqKfFUNPrL6axose0r5q1SrMnz8fy5Ytw5lnnqnGdYqnn35azVQ99thjs7eV0Z+LFy/Go48+qj6Xf/fbbz9V8LO9/e1vx8DAAF566aXK/ERERER1mtDSTUudmqsFzj00Ef9ESa3SdtZITLFmzZrS5rGn+rKXF7TkxnaOpz0cgNvlggULqbSXRT8iIqIatXMwgVe295W1H28y6KaJ5FCiarSElnOnXymjq8qOj5JpNXY97Sj6hb3hccd7Bry+vFOMMtozZaSKfmwiIiKafA+u2T7mWM1a3XlcEzmkpAbNTMFAZmS87DtWcdBYJ/3yin5xdMfrq+hX1Em/Qw89FL///e+xxx57qNGcX/va1/CmN70JL774IrZv365O6rW15XeDSYFPvibkX2fBz/66/bWxpFIp9WGTIiEREVG964un8NyW3Ik1O/jxearfpRUdGl0lIhMuYS4+YEun0/jsZz+rGoZWrFiBYLC4EVKD6VwicF5TR0HfMyMShGto91/a8KkTf/WOMRIREU1HMs7TyS60VVvcMboqMkpCK+D1wAXAKrGLvdz4yB5dlR4aXaWepy8yZkLL6/bmjf5MaBp006j7vceMj4iIaDqS9/iHR8RItVL0KyKHlK5CDimZRtrI5ZHCvvCIOMhpZmhmXtGv3k76FVX0e+c735m9vP/++6si4JIlS/CXv/wFodDoL1AlXHXVVarAOJzMcJU9gZTBYujk4OvK17We8O+1vl7bu1duh6bnBzs7unpgREZPzEyl3oEYdCPz3LR4DL3asABHS2e/vqO7F21uo+hkjOz/lYCtr68PgUBxP3Ncy3SwexBA2AyrmGAifjMNl+mCx/LAk2pCtD9a0PfV8t8VY6TJf42Jr+1U498sX9dG/3uVk2r/eWVjNs4Q/dFY1d+zxY7BZPZ5eUx91OfkcVlI6gb64/Gin3O58dHWzh71/DQz93uZ7Z0NI2aM+lzktY64I9nP01oK/nQEg/2D6PVW7/VmfFQfrzPxdZ1K/Hvl61pvJuNv9uUd/dg5GMu7rrOnD71BaTmqrq6+wWyMZCQTI+IOI5XIfr2rbwC9vaEpjZE6+weR0HNFv2ZPM1rRisGBQbiHmsOdJM8kXPAAlomu/pE/Uy3/XRW9089JTvXtvvvuWL16Nd72trepiqu86M7Tfjt27MjuAJR/n3jiibz7kK/bXxvLl770JVXJdf5wixYtQnt7O1paWsr5EaYdeU2Ir2u94N8rX9dG/5t9ZvtKeD35b8X+cATt7c2oNs3lUc/N5QLmdcyESy44zGjtg9fTqS77guGSXpvrr79eBU3Ffq8kqN4864fYFt8An68Pza3NBd3HYs2NF6I/xfbkU/hvfxTH7v+Hqv93qJQF1E6MkQpT7d/zdMbXlq9rPeHfa328rit39qEnqefFSKbbWxO/v269P/u8Zo4Rf7SEgtDjMj7KPaXxkTB3xtUSF23opJ90sWt+DW3tbWPenzNpZrgS6DUtWEGrqq8346OpUwv/u5qO+Lryda0n/Hutn9f22Re2jsgheYOhmvgdmp7cc5s3awba25vyvt4xmIvt3P7AlMdIKcuNpJUr2nn9XrhDbsyckTvR5/QG9xvwucMuwdMr94NmaogaZk28zoXGSEXv9HOKRqNqjuq8efNwyCGHwOfz4T//+U/266+99pra+Xf44Yerz+XfF154ATt37sze5u6771aFu7333nvMx5EgVG7j/CAiIqpn67sHsaEnOuL6mhlfNTSaIeKXwp9r3J01U71nR82Kd/kRcM3AjOCcMUdWDTcjEoBhpVQizIKJbdHcPsV6xRiJiIim877jWouPYhOM9xQhfyYZU8p4z3LJ6CrLMpE2B9XnTf4m1b0+1k4/uzBo060k0roPKb2+d/oxPiIioulG1qo8sSFXU6m5GMmRF5po73E1djUPJjWkjNzO46A3iGb/2A33kUAETf4gfB4Z2g70J2pjjGqhiir6XXzxxXjggQewfv16PPLIIzjllFNUdfEDH/iAOl754Q9/WJ3Iu++++/D000/jvPPOU4W+ww47TH3/cccdp4p7Z599Np577jn8+9//xpe//GVccMEFRR/JJCIiqmcPrskltNrD/rL2401mwBbxjwzWRNCb6y6SEVZTHaxJQktCL7/XVMFaIVpDfgQ8rdnPO+OdMK3iF0ATERHR5NAME4+uy0wDCnjdCPk8NRYfOfbVjBEjhXzebBJOdu9MJdnplzYTMJEZy97ka4LX5R23Qao5kEt4GVYSuh5ATMsfHUZERETV9fj6nUjr5ig5pNoo+jkLeZFRGqOCQzFdNXJIlmVhIJlG0syN95SGKNl7PBa/xw+f2we/LxP7DSQMdT/Tsui3efNmVeDbY489cNppp2HmzJl47LHH0NHRob7+wx/+ECeccALe85734KijjlIjO//+979nv18KhLfffrv6V4qBZ511Fs455xxceeWVlf/JiIiIapRh5pYve90uvHnX+TXVpSUJqvhQJ/toC5grtYT5G9/4Br7//e+ry8WQYM1OoknRT4KxQnjdbjT7cyPIuxPdMMzqv95ERESU8dTGTsTTmffmNyyZjeagryrJocK62L0TN0YVGdeVEx/ZJ/2Sji52OcXndU9Q9HN0uetWHGnDh4SeKPqxiYiIaGomIbx1jwXZy7XSGBVNZYpjPo8LfkcsNLwpqho5pIRmIG0Y8CCEVt9CtAXbEPaEEfGPXfTzuDzwe/3wezXI7CvdNBF1THyodUXt9LvpppvG/XowGMTPfvYz9TGWJUuW4I477ijmYYmIiKaV57d2q05scfCiWZjZlDupVgtJLQnArAK72NXtSyhUmqaJxx9/XC1hlsvFWNm1Fq8N3gjD9KBNn1PwST8xIzQTGBrj3pfoV7PZfZ7Rf0YiIiKaWv91JLTetOs8bOzNjEJP1lhCS0TGGO/pHF8liTjn55MZHwmJLwPuGTiy9bd41yF96E/tVAmr8WKdmeHcLhvNjMLQA4imRo6gJyIiourojCbwyvbMKbW5LSHsN38G/vq/dTWTQ3KOQA/XYA5pUDWOm5gbeBNeN+8wHLM38OLOFxHyhcb8HhmP/ujmR/FCXzeiSTf2930SPfFktiFtWhX9iIiIqHwvb8stDz5y+VxoQyMaSu14qkYXe9489hIScV6vFxdeeCEGBwfV5WK80vUa1sRvUZfb48cWVfSbHc5MJxB9ySgSWiJvlw0RERFVzys7MgmttpAf+8xrz46C0gxLjf70eYoaVjSpo6uaRtlXM2on+9hN5BWNj0R/MqVGoLvdbnSEW5E2BlWc5HGP7Li3tQVyUxA0KwrdCCCW5nhPIiKiWvHqUMFPvHH5XAQdMUIt5JCcI9CbCsghlXI6sZwYaSCpqaKfjOcMOQZFBT1j55Ikdnp629PYOLARLnhgmB9HTyyFJTPG3gNYS1j0IyIimmL9idwogvktYewYzI1QStRAl1b+vpoxxns65rGXEmRKkPb2t78dvb29RQdsO6Kd2cvNgYgaW1Woec2zs5f7EwmOryIiIqoRKd3IjsOc1xqG2+XKS2rJ16pd9HM2Ro11gi/k95TcyV5OfJQbgS6jz024XHJyT1Nj0KVbfSzL2pfh5N1PxtYdr0PAMxOa7kXc6Fcj0McrFhIREdHU6HPkkOa1hKu6H280MvoyNdTMPtZJP1lt43G71Lqbqc4hDSTTqinKgoWwX2KizHMdb1WMxE72zj8LBgwrja5Y/Yw/r27ETERE1ID6k7mArTUUKHu2+WSNZRhvvGfQ8ZwnI8hM6Sn0JXPdbE6dsa7s5fZQS1EJqfnNc7KXo+k4klqyzGdKRERElW6Kagn6Rymg1UKMpBV30m8Kn7N0rw8kMkW/gC8zqF0Kd2GvFFDHTv20hdqwS/sumBNZhoC7DWndr+Ij3az+601ERESZopWtbUQOqfpFv7gjh9Q0RlOUS5q5hoqVU93sPpiyT/pJUdKt4iOZihD0jT81yrnzT7di6K6joh9P+hEREVUpqeV2ZcZn5nVplTDbfDK72MdOaJV30k8SU5s2bUJ/fz/a2tpUAOg0mB7E9uh2NPubRxT1uhM92cszQq3jJrKGW9w+L3s5riWQNFj0IyIiqrWiX+vQ7KWgt3ZjpDFP+pWxs2ai+Gg88liaaWJb8hEY6dX495oWzArPyktYjcbnzsR6Yb903rug6R6kdQMpI4WAN1DU8yciIqLJPenXEvLn5ZBqoikqb0XM2Dvvwj6vajKfjBzSeAakKQoWno9+C9tW+rC0ax4OnnfwuOM9heSjbGkzjp54CvWCRT8iIqIqdWlJQktGV1WrI7yQ8Z6hMRJakoSTEMsqcadfKpXCBRdcoJYwr1ixAsFgfrAlnVfRVBQxLYaWQEve13oT3dnLc5tnFFX0W9o+P3s5oSeQ1Fn0IyIiqrUudrvo54xDknrtnPSTPJOzIDlmY1SRMdJE8dF4BuX1syx0a89iZ/phrHwZOO/A8ybcfezzZJJzIX/mdKAk0WIpU+09Hh6DERERUbVP+vnVuHOfx6V2HtdCU1TUkUMaqylK2LmvUvJe5cRIA0kNmpnCoLEKg/2A5UrgDQveMGFzkzMO0qXoF6uf/BGLfkRERFPItKxsJ3t2dFVecsioqfGe441mkJFb8bRR8nNuaWlBOp0LXp0My1AFv1h6ZNGvL9WbvTy3aWZRj7mobQb2afoEDNODjmY/i35EREQ12MXemo2Ramt8ld3JLpMQxuowL3ds+3jx0UQJLRldpZkDuefiDamPiU76bR3cit7EI9iS1DEvcDTimovTEIiIiGpwWpRdVJOVK5qh1dz488h4Rb+hse1SrNQMs+hdzaXHSGkkjdz6GNnV53f7J4yR8op+VhzdLPoRERHRWAU10xo2umqS9+OVc9JvvNEMQa83U/QrIaElXVk33HCDWsI8WodWPB1Hf6of3fFuzG2am5dYG0znin6zI7OLetz2cACLI2/DQGoAEXeUO/2IiIhqcufxKOM9a+Gk31CMFCkgoSWKbYyaKD6aKKElo6vSVqbo53F5VEFvoi52GaP+4MYH1Vh1wIV5/jcjkXYzRiIiIqqxop89LcqOkQah1UgOaeIVMXYOySYnFIsp+pUXI2lI6bk1MWFfGF63d8IYqTXQmr2sWTLes35O+hVXTiUiIqKy9CdSI7rYA163GhMlkjXRpeWYxz5OUsvuMJuMIHND/was7F6JvmSfGsPpHPsZ0/qzn3eEO4q6X+m+D3oz4Y9m+NVJQiIiIqqxnX72ST9HHFLtaQgyrUGanUTEP3ZCq1pj2wdT+Sf9mgPNqmlqovGe0umeu40FA3Ek0x6kjeI76YmIiGgSpkXZK2KG4iNnvFFrOaTxxnuG8xqjpjJGSiNp5k76hXwhVfCzR5wXUvQzrASiKV3tPa4HLPoRERFVuYs9k5Dx1ERCq6iTfkNjSaVDSwLRSoprcQymBrEjtiOvMNcV60dqKJnldQXRFGgq+r7bQj61jFDT/OhP5UZgERERUY0U/eydfo6TftWOkeKOLvZIYOJ9NVOd0BpIpGEYOrShk37N/ma44ILfk0sQjkYSXs7xVpoVRVr35TVdERERUXVEU5qs7FVaQ4ER+RgZlambZs3kkMY76Ve1GCmp5Y33lGYnOe0nUxHG0xrKFf10KwELFnriuUb+WsaiHxERUZUTWjXXpeVMahWwhFkUuzxa5rB///vfxzXXXDPqTPaknsRgehDdiW70JnLjPLf0d6PJswhNniVo8c+fsHt9NF7fIAaM1ehKP4stA51Ffz8RERFVnoyntOVGoFenI7y8+Kj0QuVE8dGEo6vMQXVWTzT5m9ToqoliJRkBKh3vNs2MQtO9SOn1kdQiIiKazqSpx9YqDcwVyMdMamNUgTmkqYyR+hOpbPO4CHgCaq/fWPuZbbu07oJlbcuwtPl1CLpnwbIs9NZJ0W/s3wIRERFNyegqZ1Kr2l3sztEMrglGM+TvrNHHve1wpmnigQcegKZp6nLe1yxTnfSTf7viXdgZ24ld2ndR3eprerZgr8iFcLncmNm6Y8IZ7KN5ofeveCH6N3V5Vff/U4/jdrEPioiIqJr6hmIkiYkCQyf88pJDJewQrqRYqrBJCOU85/Hio4n0JZJIGLlGqYg/ovb1TVT083q8CHvDw076tasGLCIiIqqN+Ei0jJJDsvMx452wm4rTiLZxR6CXMd6z1BgppRtIaGloZm5NjN/rV81RE3nT4jfh9H1PR//AIjy7MQjLMtETY9GPiIiIRunCHu2knx2wpYZGZdrLmas5mkECsvGex4ikVqTwx/B6vfjIRz6CaDSqLjvJ3j4p+rUF2lTCacvgFjXiU0YprO3ZBhMWfC43Al5TdWgVa1Z4VvZyd2wAmqGVVDwkIiKiyp/0G60parJ2CE/KST/H14p9zuPFRxPpTSTzRlc1+ZoKKvrJST8pENp0MwZN93HvMRERUY1NQmgbZbxnzZ30K3QEepGNUaXGSAPJNFJGGqmh8efqeXhDebHPWNTeP7cPfp+uVsSYdTTekyf9iIiIplBfIjXueE9rqBPJGQxVK6k1XodWuaMZJEg76aST0NvbO7LoZxmq2CcBlpzC2x7djoHUAFJGClsGeuBGi3ql/L7Sin5zmzqyl/uSMbWzhkU/IiKi6tEMMztpoGWU+KgWElp5J/3GiZF8Hjc8bhcM08pLgpUbH02kP5lC2uzLS2hJokp21oxHdv45byMn/XTdj95k7r6cJCbrSfRgl7Zdinp+REREVO6KmNHHe1Z7BHrUEe+MOy1qknJIEzXep/UUNHMwe13QE8ybcjBejCQNVD5P5ncg4z174vUxCYFFPyIiomrtqxlzNEP1in4SxNhJrcgE4zrzd9ZULshUJ/3Scfg8PhWM9SX7sKF/g+o4743p8Li9aqxC0CevW/E7/Ra2zM1eHkzFEE1F0RZsq9jzJyIionK62MceXVUrCa3xutjtGCma0qfsOeumia5oAm6EMMt/AJrDA2gJtqhinuz1G4/EW3Iq0KZZkhRzozPap+LC4ftuZNcfR38SERFNjf7k6OM98/Ix6dpojHK7gODQiPapzCGNZ0NPD5JGCvMCb8RuM3dBONinGqMKySXZExNS3rTafyNN6RzvSURERGPOY5f0SXNwrE52CX6qM25SElSmHDcc1mk/mnI6yySJ1NnZib6+PrS1teUllNIyesFMocXXouasd8Y7sbl/M3oTA3h5xzasjF4NryuClsT+qihYrKXtC7OXo+k4olq06PsgIiKiyd95XEsn/QbGeI6jkeedKfoZFYuPxvP4up3oT6TQ4t0Tb521HG/b18LG/o2q6CcJq/F4XB40BRxFPzMGF9zoTaTVCHTZe+O0I7oDr3S9gj1n7VnUz0ZERETl7fQbbVqUSOp6TcRx8vzGi13KOelXaox064trYJg65gaPwFt2S2Fum46XO1+ecPy5kN2BVz96tVo/4zF3wWGBr3C8JxERUbWN1p1cbXYw1Bz0qdFPo3c8VS+p1euYT94eHr/w6NxZU+xzTqVS+PCHP6yWMK9YsQLBYC7gSmgJFVzJSCr5/UkX1saBjVi3M4CkPoiosVHdzrCWT5jIGs3SGfNyj6XHubOGiIgaTq3FSHld7I6EVsDrhjxNy6r+ST9njNQ2QYxkj7Yqdl/NePHReL/L217cAM3U1f7jvebLY3pUE5Xsq5nopJ/b5UZroFUV/4LeZrhdmYTdYMJETIuNKPrtjO9Ed7y7qJ+LiIioHsh7qqilGMnZdOTc6VcrOSTTsrJx3MQ5pNJP+pUSI63a2Y+VO/vV77UtDMxtM9Q6GbfbXdCKF7lNV6ILuqmjydOr7scZD9YyjvckIqJpRQKHR9ftwH0rt2Jt1wBOP2RXnLjfEtQCCRDs8VXDT9EFR5z0q/7OwXZHQDma/HESxT/nQCAwajAtu/t0S1fJJyGjN/uS/diwswU64tnbtQXaSiz6LcheTuoJFv2IiKghbO6N4r5VW/HQmu2q8eiKdx6CuS0T7zOp5kk/iRNkTJQks6p90q/XESM5R5CO18mum5baVyh7/sqNj8by0rZerOseUF3sTcEE5rdlYiNJaslJPynqjUe+Pq9pHi5702XQksvw5NrMTuVYSvY8x9Aeas+7vYxF18zcfkMiIqJ6Ju/Tz2zqUjmkF7f14I3L5uITb9obtcIuqEloIM3jY62IqWYMN1QrzStKTnjSr4I5pLH884V1SOlJuN0e7Dk/rV5D3ZCVMR7VXD4R+3aD6UEYSGTGe8ZTqtDprqHC8GhY9CMiomlBZoj/+anVeGjtdqR1M3v93a9urpminwRimpGJhtqGjYVyFtCqmdSSAMbWFi5mvGdxz1m6sv7617+qJczDO7RkT4zs9bM700O+EF7eFkUyHcCgvi57uxnhGdnCYDHmRGZnL6fNGAZSA0XfBxERUb14eVsvbnx6NVZ35r/fPbmhs2ZipLyi37CCmsQbNVH0G4qRXAUktYbvIvR5xo+pComPxnL7ixvVCT/dNLB0Th/c7lnqesu0EPZOXNSV5Jnf41exV8g/dMIBbsQ1IK7nmq1sfak+lfQiIiKqZ7IP9+/PrsN/XtuCgWSumeWB1dvwwcN2z8t31MS0qIAvr9A0ckVMLUyLqk4OaTQ7BuJ4bN02Nao85DfRFO5ESm9SkxB8Ll9BRT8hDVSq6GclYVmmauaX38lEpxqrrTb+eomIiMp0x8ubcO/KreMmkWo5oeU86VfN8VXOefETd2lNzhLme9fdi58++VPs27EvPnbIx1QHeu/AIrjdOnamH1e3keTUgXMPLGnshs/jg88dhmbG1d6azlhPxZ47ERFRLZHExI/vfyEvmTXa6f5aGu85MkbKxBvxKo/37IuPPqJ9NMNHbrUUv4K4IJt6o3huS7dKQvm9Kdy54We4ba2GWeFZOG75cQj7CzvJKYkvdTIwYI81A1Jpr9ph4ySFQTZLERHRdPD0xk7847n1Y47UrIWin11gGi8+qvZJP2c8Wa0c0mj+9dJGpIy0OpU3q30TLr3vK+r6IxYeoWKkoC9YcNFP6GZCNVlZQ83ytV70K3zGBBERUY2PrLK9Zff5WNgWUZfThln1zvCJ9tXU0km/0ru0Khew/eG5P6jTfk9tewpPbHkC3YNudA160Jl6SnVXid1n7q7GfpYq7G1R/1owsGNwkB3rREQ0LUmxzy74yUjKE/ZdnPe1WtxX4xzv6UxqpTQju2tnqknCyE5qFZLksXf6lTq+ajx9yT4VJ4nbX9yg/jVME3NmdKI70Y3tse3qQ4p4zb7mgu5TdtbI6T3phLeldd+Iop90y0u3OxERUb3b1BvLXj5w4UzsN39GzcVIUsyTUeGjx0e1cdKvZ6gpqpCdxyFnfDSJea+BZBr3r9qm4iWvx0Jbc2/2awFPQE2VCnoKK/o1+ZvUvyYMaGZKLZruiWXisFrGoh8REU0LXUNvutJ3/aHD98B82dI7xN6jV6v7amppCXNfXtFv/IAtEsgFbIOp4oJiWb58zTXX4Fe/+pW67PTk1iezl+9ccyde2ZKZW7819WD2+n1m7aPGfpbqY/v9GEe0/gaHtl2NrngSab02/kaIiIgmIz4ShyyelTfOc7BGElqFjPcUkvJK6tWJkeS1Gsq5FVT0czZGRYuIkcaLj2xbB7ZiR3QHumNJPLx2h7rO6zEwo7kzW6STBJXP7UPIX1isJN3uj21+DL9//lf438BV6uSgpvtG7D1OGkmktNo5IUpERFSJGOn9By/HHnNaazuHFKr9HNKMCRrHZTyp3cxVTHxUaIzkXPOT0NJqlOcuHSmk9FzDUsAXUKf3vJ7CTnI2+3MNVLoZy570q3Us+hER0bTQHct1X3vdbrQ4imrFFqSqMt7TWxvjPXuLGO/pLFwOJIp7jQ3DwF133YX77rtPXXaa1zQve3nzwGY8t/MlJI0e9GgvqOtkZNW85nkF7akZy4KWDrjggRsuRBMGYlp+UouIiGg6kMKQbWYkiKaAT41urKWElugbei4+jysviTV8fFW1piE4JyHIicmJOOM856SHcuIjIScdU0YKO2M78ei6rTDMzKCp3eYaSBi5hJYU/TxuT8Fd7FIg3NC/AU9ufQLd6eehWwlohg/9qf6820XTUfX4RERE9a5nKIckZjUFazKH5BydOXxaVK2c9CtmvKczj1TsKp6JYiSnx9btVPGKaRnYf6EbA+ncXuuQJ6SKfrJGphAtgcyUKKFZCdWGZo98r2XVH05LRERUJs0wswHDzKZMcsMZsNVKUmu8fTUhf211aTUFvPB5xg+C/F6PSsRJAq7YvUBerxdnn302otGouux04u4n4m+v/E2NqBLrYiswy3/QUI8/cPjCw9W/QW/pC3Ls19/lciOhWyqJNTM8s+T7IyIiqkXd0VzRb1YkqDqsmwO+obGftREfOcd7toYCI/b1Ok/NVavo54xzCjnp52yMKiapNV58JGQEp+zUk3FVG3rd2ULgjKYYdvblHqfJ1wSPy5PdQzMR2ZXsjKs0KwqP2Y7eeF/e7eTkn3TNExERTZeTfpLTiPi9aAlmJgwNHzteTc5Yra1Gp0X1OgpghcRIUrzcMZhAPK2rXN5EeadCYySbxEUbe/sQS0cRDqTRGvbkjSb3e/2I+DLrgArRHMid9NPMuMpKDaZq4+9jPCz6ERFR3XPO054ZyQQZtRiw9TsSRiPHe1b/pJ8ER3Yn+0Sz2J3Fs6SWKHrmvQRpp512Gnp7e/MCNsM0cMSiI9AebMcfnv8Dtke3o09/VXWcu+BS3eyHLjgU3fFulaAqVVswlD3pIE18UvQjIiKazqOr5KSf3Rgl79u1Mt5TTqvZz2V4fDQyqVWdGKnPEUsWVPRzNHcVU1wdKz6yyZ6+57Y/h4g/gk19HpV4klGccaNT7duzqbFVbm/Bo9D9br/acWPTzCi87hnoig+o+NAuxMpkBBb9iIio3sl7m90YJTkkeZ/LbxyvjRjJGX8MP+kX8HrUehur2tOihnJIEioMb24fTduwGMmOT8uNkWyrujajO96LtKFhbqvct4bBlGO8pzeAlmDu9F4xRT/diqu4q1ZOgo6HRT8iIppWCS3pYhfSxV5rAdu44z1rYHRVLK1nl0S3FzCWwU7O7RgovktrLJLMkoSSdF8dv+vxuO7Z69T1AXcrPrjvD5F0v6DGe/Yl+1SwVqqt8ZVYl7gFJuIwfPuM2FlDREQ07Yp+Q9MQmocao9KGqWIOZwxSDYPJ9NBZfomPcvHb6OOrqhMjOXe3FFv0cybsyqUbukpcSay0fWAmDFN+pxbSVg80U8vb0Scn9wptkPJ5fHkn/XQrqk6FSuNcSk+p+xOyM5B7kImIqN5J0UbiIDFz1BxSrTSOO9ev5L+ny/t0YGjyUrXiI+c0BMkNyXMqdhpCoUW/Qsj487+9dBeShkc1M7WEMq+L86SfjD4vdBKCOG7ZcdjYtxEzQ7Oxfss8VTCOpqpXZC0Ud/oREVHd64qO3sVecwGbo/jofH61MrrKua+mfYIFzGN1aRVKAqX+/n4MDGQ6yJ1jq5JaUnWcv2HBG9DinwW/qxXtvn0wp6lFjfaU04CypybkLax7fTS9yW3YkroD21L3oyu5Oa/zyyajs5zPjYiIqN50R4e6rwHMGCpW2UW/WomR8rrYa/WkX5E7/Zw7bYqZODFWfGST/TRS3OtJ9KAzmoRm6gj5LWhmpjjnTGjJKT+Jl0op+sl4T5mwENfMvL3HEi9pVm000xEREVVi57HdOF6LJ/2ccdpop+jsGKlaOSTTsrJxXDHTokrZezxRjCSN3HesvAMrO7eqgp8UICOBTGHXme+ReKeYVTEyaeqQeYfgkHkHIeBugQkLMZ70IyIimnzd8fwFzKIWlzDb4z0jo+zLC9ZAQiu/6FdYwOYcMdFXRJdWKpXCWWedBU3TsGLFCgSDme/rT/Zj6+BWNW5BxlIdu+Cz6B1YAI/Lj0gwrm4jyS5ZulzOSb99OvbIXo5qPehP9+d9XTd1rO9bj4UtC9Hkbyr5cYiIiGohqSUJFjv2GB4jzW4uvYmm4vtqRpk0UAsn/YqNkaSwKs3ukpMqJqE1VnxkS2gJpM00Qt4WNaEh7Esj4HOruCWuZ+IkITFSs79ZxVKFkNvlFf3MWGbvsWbm7T2WOI0NUUREVO+6Y6kRkxCa5L17aFxmrexsm6gxKhMjpauWQ5LGJrv+NqPAxvG8ol+icjHSxv6NeKnzJTT5ds+eOAwHrLyTfrLzWHJJxRT9pDFKvsftdsHjMVQcVCsj8sfD8Z5ERFT37FnsY+30k7FRtcDuFhstWPO63fB5XNAMqyYSWqMl3QoZzVCuO9fciR889gN1+b17vRd+nAKPK5OkjAwFbAk9UfRIhuH2n7t39nJc70FvojdvZ42c8pOOeSa2iIioXsnYbTtZZDdF1eI0hP5x9tXUzEm/oecoUUIh+2ok2SRjwiT2q0R85DzpZ5omQr4ONR1BRm16vJminXN0lRT91Ek/V+En/Zz7/9RJP5cLSc1SIz1tEi9J4ouIiGjaTIsaauaR924p/ElBp3ZO+o09LSrvpJ9u5OUzpkrvUGN7MTkk589RyRipN9mrmqB0PRfPNA076dcUaFKTDIqZGiWj0mVyggULXo+u/o2ma+PvYzws+hER0fTaVzN00kyCNVstBGwpPTdnfayxUNKlpRla1RNaxZz0cya+ikkcSlfWbbfdppYwOzu0dgzuyF6O+CPo7c8ErQFJaA3lrSSptaxtWcF7akazuHUhPAjAQAoxvUvdpwSIkvTKFv2MXABLRERUb5x76Jwn8Z2NUcWMnpwszpNwrY7nNnrRr7qNUXKCTxq1CiEFTLvoV2gibqz4yHnST7d0pDQfvC4PdFNDyuhXjVBHLT4Ky9uXq8RWs68ZYW+44OSfzz2s6GfKeE9A093ZvccSJ0W1aDZWIiIimhbjPfMao+yiX/Xjo4mmRTmnIchpu5RuTvme5t54eTmkYqYhTBQjdUY7VWNSLJWLfeyTfl9/y9dVfJQ20jAso6iTftJsJZMO+lP9SJkzEXLPQ1o3VXPdaL+TWsGiHxERTZuAze9xZ5cvS0JGAqNYSq+JgC2vi32UDi0R9HowCE11aVVzAXMxO/2cP4uzaFiqHXFH0c/bhK3pTMAWCWY6tKQoKp1Zc5rmFLynZjRejxdh72wM6puQMLpUECf3bSeypKtdPiciIppOkxCEHSvVSmOUM0YadbynN5e2qEZjlBTs7Bin0ISWaAv6sRkx6KaFeFpHxPG6l0oakmS3ccLwqjhINwy0hFyI+CJY0LwAy9qXqdu90vVKURMR5KSgFAltuhXN/Gt4s2NDpeAoH+U0XREREdVa47i908/Ob2xBXBV1pHE7YHceVzlGck5YGp5DsiU1fcqLfs4cUsE7/SbhpJ/EaluiW9QJPrvo53ZLUTRT9JsRmqE+JM8j62SKKfqt7lmNa568Rl1eEnkjWpoPVJclz1joeptqqN1yJBERUYFv7vZoBpnF7uxotpNatZbQGmssVGioS0uCtWqfCCh0NIPz1GIlArbOWGf2stfdrObpi7A/c2kgNaA60edG5ha8p2YsLf456l8LBrpiXap73aZ21mQfnYiIaHoltGx1Md7T70hoVaExSvYeGqZVVHxUTif7eGQSgYinM6kcr8uLhNk5osAnXekyMaFQ0vTUHGjGIfMOweEL3oIZvv3U9YbpzY73lN1+UnQMeErfqUxERFRr4z1nOGKk/Mao6sZIMilKTu+Nn0Oq7jSEvJ3HBYw/L2en33gkVumJ9yDsjyCeGloP45cpC/m3sxu9iyn6tYXaspcNJLJ5IjlgUMtY9CMioroWS+vZQMiZ0HIGExIsydH7mhldNeZ4z0zAJnv9dHPqn29fmaMZigmKZfnyr3/9a/zhD39Ql23d8e7sZdPIJbAiQ7PYJeHUEe7AgpYFZe+UmRGYl728PdqTHV8lu/wkaNw8sDmbXCMiIqrn0VXSGDVa0U8KWtXmjJFGG4Ged9IvrVd353GBkxCGFzALTWqNFR/ZJD6Rk36bBjarzz1uN/actSDv9J2M4XS5XUUV/fxuvyocnr3/2Xj/3mdhXvBN6nrT9Kk9fvZjy1gsnvQjIqJ61xNLZfMZzhGNzvfuajePF5JDshvHRVLXq5pDKvSknxQqfR5X0U1R48VI3YluxLQY/K5mDKUHYeeQnNJmesRI84m0BFqyl00roXYqi2gNxNDjYdGPiIimUYdWfpBRS53sztGXY41myAvYqtilNda8+Ep2aRmGgVtvvRV33nmnuuwM1rKXY2mYMpxePSdLJZosl6XGVzkDr1J1hBdkL3clelVBUUihry/Vh/V969GX7Cv7cYiIiKq+r2aMnX6DNXTSz+2SruyRp/ido6qqcdLPmdCaUeR4z2Lj0LHiI9u3H/o2fvH0L3DHhq/DtDLJvaagW42eemzzYypukaKgnACUEVeFkkKeJMHkewNDo7CEafrV9AMhyTQpKJYzXp2IiKjapMHazn04x5+PaIyqcoxk7/Mbd7ynM0aqQg7JOS2q0MZxmc7VOjQ5oZjd0uPFSBL/SB7HMHKxT2Ron9+/1/wbf3/l71jVs0o1ePu9/qKmFrQH27OXdSuppo3VSuPceLjTj4iIpmVCa2RSS6vqvG1nMDNaF/vw8VWy+6WpArtfittXkwnY2osYXSUz5GWXYtowiyr6eb1enHbaaYjFYuqyze4ml719bb5F2GxqKhElXVqyOFn2zezStktR3etjmRvJFf16431qsXO26Jfoy46zIiIiqkdd0dSoMVKTIz6qdhd73r6akD9vTLst7CgEJtJVaIpy7qspIkZynhYodO/xWPGRLaEnoJnyO9PQr6/E/MhekD6tBzc8iEc2P6Ju8+lDP60KfkUV/bx+NTZdinpetyTkJDbMnPQbSHerrnZ7IoLEaERERPV8ys8qIIdU7RipoBUxjhhJckhTzc4hucYpTI5GbisN/JKnkxHqHun8KiNGktGeIpHO5dTCAVPlue5ffz86452q+Pe5wz+HGcEZRTUwySQEmTIlsZBu5op+tX7Sj0U/IiKaPvtqHKOrRHOgdk76OccWjLavZuQSZmPKx6TKWNHxipJjd2n50RlNFjWaQYK0s88+G729vXkBm32yTsYtWFYzvG4LuqGrLq3edBTL2pZhdmQ2KmFJ6zK0efdBxDsXHaEODKQH1PWD6UH1kdASFXkcIiKiajZGyQilZkcSy+t2q1P9souk2vGRnOi3n0NBXex6/Yz3LGXv8VjxkW3vWXvj4U0Pq8td6Wex24w9VfLpla5XsmM65zXNU3uKixldJQU/u+gnBT+PJwVN86udftIMJY1QdtGPiIhoOo4/r7Wdfv2OouOYRb8q5pCc0xAkziykcDf857GGTlQWMhp0vBhpe3S7imNiQ/v8hOSQdsR2qIKf2HXGrqrY1xRoQjHcbrcq/MlkKM1KwoSM97RY9CMiIpqq8Z4zx+3SqvZohgLGezq6tKY6qdVXwlgGm130ixbRpTUWOc0nJKhKawGEvC4VXCXNLtVZLrv8WoOtqIQlbYuwT+RihHxBLGxag4HUgOrekjFWPYmeoWCOiIio/kghyG6Mkvho+Ak6SWplin7V7VKW52AOtdvbo56GkyKlFC6lOakqCS1HDFdMjFTq3uOxbOrflFfI604/i0jgNOyM7URvsjeb0LJgqVGdQW/hEy6kg11uf92z12Fl10q18+boGb+F2wggradVwU9iNI+Loz2JiGj65JBGnvSrnZ1+A0XmkBJTPAJdGrfsaQjFjD8fHiNJnFXoPsDRyGjy7bHtKofUOZiLdyMBE//b8Xz28/3n7A/N0NDkK67oJ+yin26mVIxt1cFJP+70IyKiuuacIV7TAVsBS5idJ/2menxVr3P8aJEBl/06W0UktSRQSiaT6iM3HiGKlJH5fUriqScuS5a9aA0GMah1qzFVksyScZ+VIPcrcyjk4S0zoMZ7SlJLRkNIVzsREVG9khFPdoFseHzkfO+W22iGWRv7akJjjzUPDu09rsroKmdjVDHjPYPFj/ccLT6y/eaZ3+AnT/wk+3nU2ATT1ZU95Sf26thL7UCWMejFjK6SYp7EXqZpqoKf0KwYTNONhJ5W0w9kGkPAW3pSjoiIqBZ0O97XRzaO1++0qMQUx0gymtMOVYrNITmLmOXkkNTzSA+q9SxN/qYRJ/1e2PlC9vP9Zu+nCoTFnvSzi34ibaRUo7j84NzpR0RENGUn/fIDDecoKwlIqslO9siIqoAjMHMKDSW06vGkn/NEYyHfn0ql8L73vQ+apmHFihUIBoPwerz4xtHfwIaBDUhqSXTv9MHlMjC3JYxdWjN7/GaGZ6JS2sIhdXpQ+rQsBNQJPwkYuxPdqqudiIhoOow/Hz66arRpCNXae5yX0BpnF4wktQahITnFXezDG8zGatwajfPnKXS852jxkU1O9A23LfEculKvZj/fc9aeqmjX4etQY66KOeknBT1nUU+zogi5OpDUrExCLdUHn8c3ohhJRERUT7qdJ/2GxUgtNZVDcsQfBY1An+LG8TJySM4iZrkxkkxpkjHkHZEOxFOZk34uF+ByJ7Cye6X6fFZolhp/Lre1C3jFiPgi6l/D0mGYaZ70IyIimqp57BKc+YcV02qqS2sokBlvuXHIEbAltCoGbEUktIb/TIUGbKORJFLQF8TilsVo9s+De6jrvDXkwfIZy7HP7H3Q7G9GpXREWtS4M8sykdZ0FQAOJAdUJ/vwMWhERET1uq9mvJN+1U5qOeOGtnFO0dmNUUmtCif9hp6jNJP5PIUPS5Lbyu7EcuMj27bothHXrR94Fq92ZYp+MhFhSesSaHpmdFUxozgl7ol4Iwh4HEU/M6r+1Q2vGh+aSCcQ9FSnOExERDQZjVHDY6SmGloRM5DQRt0TPFbjeGKKYyR7tOd4z28srY7XudBpCGORPI5maiqGsU/6hf0WXu56CYaVyavtN2e/bI6nmPHnNjlFaNOsuJpzJSPqa1nhrV9EREQ1RvbH2d3Xo3WoN9dIwCZjs+xxVGONZRjepTXlRb8S99WUurMmEAjglltuUUuY5bKQgEw6tKQzPa35VdFPdtLsNmsmZoZNzInMKWpU1URmN7WgM/0IVsevh94Tw8nek9W+GjnpF/aHEdclmCMiIqo/XdGxR1fVUmNU3s7jccd7Zt7/Za+fbppqz99UkIYkexpCMaM9nY1Rmd2JpcdHts54Z/ayG36YSOPVnmez1+0xcw91Yk/NL/AGio6ZQv5Q3kk/3coU/QzDg+54txrBLvFRQk8Udb9ERES1WPSTfcHOnJGQ+EIaduS9u1ZO+kkMNLzBfdSTflOcQ+qL52KbYnf6ORu9yo2RuuJdaoKTZshH5rqmoJk32nP/2fvn7sfR4FSoL77xi7hj5R1Y3LYY/3kurOLD0Xb6SRO5FBX93sqspCkHd/oREVHdkiDInjA0fCxDLe30c876bg6MndDKG+851V1ajpN+bWUuYS6EdFnJOAb5sDuuUnpKdWjJnj1dD8I9dP3i9hnYp2MfzG2ai0qaEY7A5w5Dt2Lqc0lobR3cir5EFJu6QuiPNaE3XtvLmYmIiCY66Td8/HktNUblx0j+AmOkqUtqRVM6dDMTbLaFi0/g2DFSSjcLet6jxUfOpJZwu3yY7X/DiO+VfX52E5WMRC+WJMGcJ/nsk36G6ct00Rsa4skIdvY1oSfqnfLkIhERUSX0DMVIMyK5nIOTnbOp9kk/O0aajjmkUsZ7jhUjbR/cropszn1+IZ+JF3Zkin5+tx97zNpD7eKT5iiZLlWsBc0LVGwlUxV8XgNpUxvx93Hva5vw00f+ifvX/g+1gCf9iIhoWu7zs8cqychMOTVXzYAt5kxoDeskq5WTfs558cWO93SOcijndX5408N4dNOjam9fOrk7XC53tqDr7DyvlLDfi1bf/OznPckeVfR7auvzeGDjv9Hm3Rd+azHesGjvij82ERHRlI33nHCnX/UaXJxd0s6RWuPHSDqaxkmATVp8VGRCa8Te42QaQV+o5OdiF/18rma0+/bH9vRDeV+XfX5Cus/D3uL31ciOm+E7/TJ3GEBCS6hdgZu6wnh1Wwivub04+4Aodu1oLfnnISIimmoygSmezuRaxtpnLM3j2wcSKicjU5uKGe1dKaZlIT40PrJWc0i9ZcRIzhySc79zsdJ6Wu08lrHmsaF9fiJurlNTnOz4yO/xq4kFMlWqlPGestNYThOqHcg+F3Rdin5yCMFSBUiZQvaz/76Arjiwfmc3jtsdVceTfkRENC1msY8XsA3vJK9mQmu8Lq1gDXRpSSFsrNERY3GeqCz0pJ+u6/jTn/6Em2++WV0Wd6+5G/esuwc3v3SzGmHlliN/sntvlGRlJUhwNjuyOPfck30YTA9iZc+rsGCgV39u3P1CRERE9Roj1cpOv8JjpOqMr8rfeVzaeE9bvyM5Vkx8JKQ7vT+ZSV75XC1o8+2P4xf8AKftfZoa6zkzNBPzm+ar20n4VMpJP0mC5RX9hk76WVZAJcpgAYl0LoXU0VR6AZOIiKj6O49Hf1/Pb4xKV604OTTUatxGp2pNQhhx0q/IxvGI3wuP21XUSb/RYqS+VCaHo9azOE76LWiZiwtedwGOWnwUDl1wqLpOdh7L+phSin5SLHS7JUPlgt9jqlHqST2d3aO4fWBANUjJtIXWUOVW0pSDJ/2IiKhudUfHXsBsk66oHYMJNZN9KnfAODkLjpFxArZw3hLmqQvYMvtq0iXNYh/RxV5EwCbBWlpL49xzz4XX6812sAu32Qa31z3pSaWZ4XZ4Xc3QrUEMpAYQTUexNbpOfS3onou9O/aYtMcmIiKa7GkIEgcFRmnmqZWdfjI+EwUktaQpyWYnWKZ+dFXp4z0LjZEkPvrLX/4CTdOy8ZF6HolelUiyi35eVwhzmiI4cvlxOG75carYJ81MMoLT4/KoU3vFki545wlBbWj8uWn6kDYHVYLL7qL3uKxxTx4QERHVe+O43Rg11u2mbBLCOPGRnEL0ul1qFPlUxkfCziG5hsU7hZCYRRqjeuKponJIw2OknngPknpSxS9Rx0m/9ogPe7QchIPmHZS9TrM0eD1eNaKzWBv6NuDprU/jBc8LMI1DEHQdCt3UsX2wF8tmzsaa7h1IG5rKrbWEauOMHYt+REQ0PQK2pokDtmhSK3rWeCVIwbGQgG346KqpIgXGtGGW1KElIkNdWjLSoNDEocfjwTHvOAY7+3aq7qy5wbnoTnRnv+62ZmRmtvs86v4nS3sohJB7NgaNQdUh9uTWJ6UMqr42y/d6zIhUfwEzERFRsSOhJIkixkpU1cpOPzupJatZZCT7WILeKp30cySiSjn9nz/eUysoPnr3u9+NWCymLttkdJXN62pSoUrAl3tuMm5KSALK6/KWXvRzfJ893lNO+iW1TpXWiw+d9Av5zVH3IBEREdVN43gBOaRqxUiFFv2E5EykiWrKi35DEwwkpiyluV72+qmiXzKtYteJ4gpnjCQjx2PxGLZGt6rYR8ZvOk/6hf32OcmctJEu+aTfq12v4v4N96vLr++YgaDnUNUMtbFvJ+a1NGNV97ZscxZP+hEREZWpO5brvi4sqVWdol/+6CpvzY2ushODopTXx9mlVeh4T5/Phzed8iY8seYJrOpdBcNloDueK/pZRrtKLkkg7lzSXGntoTDCnjkYNNaozx/amNuPM8v/erSF2R9FRET1RU6nWdbYO49HJrSqP95TRnuO937vHF81lUmtPkeMVNI0hCLHe0p89NGPfhS9vb3qsk3Gntv87hZVJPV55f7ym5Mk8eVxe0pKaMloz4gvgvMOOA9BTxueXbtAXW8aPkS1KNyuIPSh8DTkn9oRYkRERBXPIYUnziFVawR6MUU/iZGk6DeVOSQp0tnTEErZeeyMkSRmlZ/XGZuORuKis849C69sfAWv9LyiRo+v712fPbkn0wg2J+5Gh/8QhAMjn5Nu6Kq5SZqcin+urXlNUTJhwef2YutAN7YMBLGpp1ed8lO3rZHxnrVx3pCIiKiMeexyymysE2q10KWVN97TP85JP69naItd9RJapZz0s7u07NdYAsBCyAgqGenZlejC2t616En0qOtlLJXHFVGvRcckj9JoDQVU0c8W1+Lq37BnPsLuhWgLsehHRET1vK8mOOY4KLvZqBZO+o03/lw4TwFO5Qj0csd72vGRKHR81WjetPhN+O2Jv8Ux8/8fFgbfoWIllzszftNJM0sfXeV3++Hz+tQorAPm7YOIN1P0M0wvYqkYLCN3ClBO+hEREU3PaVHVn4aQV/SbYPKRHc9NZQ5JpmiZVumTEERryPE6FxgjyWm9/nS/Kt5Jg1NPsgdtwTb1tZV9D+PV2HV4ov8yrO9bO/J7zbRqbiqlqdx+DGFZSaSNlLof+T1JY9ZA0oT8P9n518KiHxERUWUCNum8HmsUQC0EbLECu7QkaAgMBWzJKiW0KtWlVaiklsS6vnVqHIOM+RRBb1h1qUsbe0fz5O3zs38fEe/8EdfP9h8Kv9dQSVEiIqJ63OcnxttDY8dIzuakqSS7lu0CXiGjq6pS9Ct3vKfzpF8RceiLO1/M23UsMaJu6Qi45iPkmQmv2weXOzN+c3hDVcgTUoW/YgV9QVVMVIVDtzTVDd2n7kZLsAV+14zsbUMBnvQjIqL6boyq5WkIhe48FsGhaQiaYamVK1M/LarExvESYyThdXvx0s6XMJgaxIzQDGzo24IX+n+tvpYy+7Chf8OI75FpCM3B5pKe68zQzOxlt1vW42jQZLqCK6JyVxIvSsFPtNbITr/aeBZERERFki4me1feWLPYRyxhrlJSK2+8p6MIOV4n+1QW/ZwjOUst+jlPCBbSpZVMJvGFD30Bf/v639DZ34nV3asRTWeSVwFPBG64VdA01gmFSpEAusWX6WR3mhM4DH5f9cadERERVWJ0VSExksRTUoCr5s7j8cafDx/vmazCNISmgLekRqD8+EgrKD468cQTceGHL8RLW1/KXi9jpGQaQVr3wy0TEdweeL3J7CgpZ9Ev7A+rZFixAp6A2nVjGJkY1O/N3Hdad2GPmXvAspqytw3zpB8REdVxY1Qk4M2LLcbOIdXASb8Cc0hTedrP3udX6vjz4c1UhUxDkBjp/e95Py795KV4bcdrqnl8TmSOaox6cMPDMJF5zfZsewuOXnL0iO+XGKnZX1rRrz0o62cyTGR+9rSeRlqHOnXYHU3B43LD5TYR9tdGua02ngUREVGR+uKFFaryT/pVp4jjLDYW2qU1laMZehOVG+8pCt3rp7iAjnAHXu58WXVeCZ+rCW5XJkTpGCdZWQnNQT9m+Jdjj/D5Kolmj/aMeBYh4KveuDMiIqJKvK8XGiPJmKZa3ldTjZN+UlCzk1ql7oT2ez3Z5+5MkE3ENE3siO7Ifm6YBpJ6EpqWmW4hJwj9HrfaZzN8dFVYJiYMxTRFPVePX01e2BnfqeKy7ckHoZtSaHSpSQ7xVG6qBnf6ERFRvXG+r48XHzkbtat30q+0GGmqmsedOZ9KjPcsZgS6xERyyq/J16T2EYsNfbmTfW9a8J5RR3jK7z/ij5T0XNtCufGempmA1+1RMVdXLIqeeA+iKah8UsCrlTQ+dDJwUQ0REdUlZ8eVM2k1WlGn+uM9h4pZHpdK0BR00k83VFAyFQGDcwxY6V1axY1mCAQCuOJHV+CeV+5BS6QFW+Jbsl/zOop+451QqASZjx/0tmJ24DC8Zfl+CAf68MCqhHrdedKPiIjq0aAjQVV4jKSVXNiqREIrUmBT1FSe9JPXREZlifYSE1qiNeRHUksUFIdKfHT99dfjl//9JbYmtmZjwd8+81vctfpubE4swLLIcZjb0qxGeEohUHba2KcBpYGqPdSeGZNeJPkeua/71t+Hp7c9ra57Q9tieN1LoZsSz+Zi0rCf4z2JiKi+SI7Ffl93nuYbf7xnDZz080900m/qY6RORw6pvcTxnq3Ok34FxkjX/uZa/PV/f8UgBjEnNCcb/2yNZop+AfcMzGqSyQQjXwcLFoKe0vJLzp1+aTMBt8etxntuH+jD9qgfuulCwAP4aqhxnCf9iIioLuWNzAyMF7BVf6ef/Vwjft+ERTw7qSUd1SnJsEyBtV0D6t+A113yDr28nTUFdGltH0jgwQ0WYtYM9ZpI59TcyFy0Bdrgc7Vni36zmyZ/p588ltflVcXZkHc+2n17w7JMhHyGGnNFRERUr0W/8WKk5kB1Y6RiutjzR1dNTcFpbXcmPhKL2kvrDHfGSPG0JBvHj+0kJvrfzhhW9s/Czugg+pKZfcfXv3A97ttwL9Ym/qRuM7elSSWgZOSnbTA9iIgvgnnN87JxVDHke6RjXsZU2VJmr/pXTvvFU7n7DHK8JxER1XUOaey4Q8Z526fn6mGnXzVipHVDOSSxuD03/rvUHFIh06JiaR1/eWkzVg54VKxj59Z2xnYibWaKkC3eZWgKjL7XUNbH2CcDiyXxlR1bpYyE+tfr8qAzNoA1XTvUehrhr6GiH0/6ERFRXXIGX+Ptycubx17l0QwTzWIfHrBJl5ZzVMNkkAKdvftn2awWNTKq3PGeExX9pGv9pw++iOe3JhFLzcX+ywzMb56PbxzzDdWhfvNjXrjdblWwdd7vZJAAWoJF6ZaPa2a2i103DcxraVZLoYmIiOpxGoK8pcvOmlrtZC80+VatLvY1nbmE1vJZLSXfT940hER63CkGa7oG8MuHXsHOwSD6jDA6453q5J78K9zww+cOY5cZLTB8c/Bi7MXs9w6kBjC3aW5eN3oxJJkV8oZUYsuWdhT97BjJ7zVQwnpDIiKi2mmKmiA3I7kIGZVZ7cZxeecdL5YbHiNNxZoYyedIvIKh5za71MbxvL3HE7/O1z+5Co+t60d3bBb2XKDDH8kU9zb050Z7NnuXojU0ssFKnrM66Tc0HaHUaQjSbJUyktnrpKFrRzQOtztT+JTxnrWCoRoREU2DLvaxA7aA1wO/1121ol9aN5Ae6uqeKKE1MmCb/C6tNV39FUlo5Z30myAwXtXZj9U7+rD1qYew7ekn0dOf68SKpqQL3gs3XFhUYsdYMSTYl44vr9ub7WI35ZilvB4zZ9fMPHYiIqJC2fFOxO8dt5nHOQ3BuX+4Gl3sEb+35vbV2AktsbyjteT7aSkiRvrX8+uw8Yn7seN/j6F7QDrIM8W+rniX+tfnalZJpqUzWlVjkuy1kUSWvRd5dmQ2Ap7SR5HKrpuQLzTipF8i7UJSy/wtBXxTt3eaiIhoqnNIzvdumQZkmKOfHJtM0XTmuYYD48dy1cghdcWS2SZ8ySGVmjNRuRhXYfGRFAUfWrUFW576Lzr/9zh25tJYefv8ZgZ2QdA/8velW7qKn5wxTrGNUbu07oJ5TfOwuGUR7LDUhSB6YqnsKUCe9CMiorqwrT+O3z32GnbtaMF7D1pW8imwyeBMTjUVELDJ3rpqdGk5n2dkgoTW8KTWVHRpra5QF3trESf97nx5EyzTwObH74du6Og+5UDMbs/8bfXFMt1sLpe7rFFahbL/dmS8p254IKPpDVNXYz2XtM+c9McnIqL69O9XNuHx9Ttx+iHLsfvs0k5WTXbs4dzZNxrnafpqjK8qZrxn0OtR8YGkceJT3MXeJF3sZewYzo+RMtMVRtMXT+HRNduw/tF7kNJTiOy1Jzb3b1O7auwxn153s0osLZrRhGBivpqMkDJSiKVj6oRfa6C15NFVQk765Y/3zDxuX9w52rN2utiJiKi2SA7j2v++jLDfi3MP3WPSJxeVMgmhsKKfLy9ecb6XT+m0qAn2+VUjh1SpSQiSX5Tfg8SgE+WQ/rNyC9Kajo2P3QdN19D99oOB+ZmvrXMU/RY27zLq98fTcRXjNPubS36+Xz36q3hiyxPYc9aeuO0ZC5rhgmn60eKbj21Dt6mloh9P+hER0Zj++cJ6vLC1B/94bj3uW7m1pl6pvJFQBYxmsJNg9imuqSKdYYUmtOyk1lR2sq/tGsxelvGepXJ2aY1XXO2OJfHY+p2qqNex94Fo22Nf9Cdyr0tfwq3mkUkAuLBt8k/6+T1u+Dxy0s8D0/RhMGmqsQ+RQGDCMRpERNSYJKHypydW4ZXtffjBf56v2vjw0cjOODt+KLSLvSbGe04Qy0kXeWAoqTUV8VFnNJn9vS6f1VrWyf+88VXj/K3c89oW6JaJ5j0Wwr3ci079Mby8Y5s65SeFP+F3tcDv8WBOczh7qi+pJxHVomo3cpO/CS2B0uO5oCc46k6/3pij6MeTfkRENAbJGz25oRMPrNqGm55eXVOv06AjNzNR3NFcxRhJclbxoedaizmkvEkIZeSQnDGSvMbScDUa3TRx96ubVQ5p9t4HZXJI8dzrskf7wZjtfwNavbthbsvoRb2eRA/mROagI9JR8nP1e/wqVyQCvsy/aV1yfrkYqZbGezKbRUREY9raH89evuHJVThw4UzMjJTe6VxJg47Aa6JO9uZA5usSQ0iCyZnkqqUudhFynAac7C6tTBd7fzbo7Siji73QLq17Xt2ifg9urxdL33IC+hP96Et6cdvKv+C17teQSEYw13M2XK65U3LST5J48ntJaBoMzYf+lAGvO4jZTSGO9iQiolHtGEhkRz3J+971T67E+W/apyZerWIKac6iYFWKfkOjq0TEX9jeY0lmTU1TVC6htWxW6V3hwhl39o0RI0mxVhJa8AAr9/4HLBiIGVuxtf8ArO7OJU1lvOe8lhA8bpcq8LUHM/v+ZFyVFOs6wh3q+lIFfUF1XzL6XBJb6aGTfr2xXEIx6Jf4tHZObhARUe3Y2h/LXr7rlc04YtmcmpmIkJdDGsoR1WKMJI3jVo3mkCpe9Av6sQkxaIalRpPKCdHhnli/E73xtMohLT/mRHTHejCQ9sM0NbjdwN7t70CyP/P7bA2PPlEhpsWwx6w9smM4Sy36ZS97cwVK5zQEn692in486UdERGPaOZjIXpY3YBn1OVb3TTXHZhYzmmGqx1cV8zxFaAq7tHZGk9l9OuXMYre1hTLjpKToN9rfiew3vOe1zeqy2yXJyEwY0p9wY0PfRrza9So2RJ+G2yUjvKbmpJ8dSEvR0jQDMC23GosVDlgqaVbOiCwiIpqeOqO5+Eg8uHo7ntvcjVrgPHVYyPjz0b5vqkSThRcoRXBoZ81UJ7RkzH052goYgf7Yuh0qRvW6A5gVXK6ui5tbsWMghdU9uaKf392CxTMyRcigN4g5TXMwmB5UYz2le10+L4fcpxvu7GlB+6RfNJmLEQM1lNAiIqLasnMwmb0sGYFfPfyKamypBYNFTYuq3gj0/MbxAlbETGEOSU4hruvOTIuaGQmgLVxevqSQNTF3vpLJIYn2cOb3Jr13kkfKfF+uvNUWHvm3ljJS8Lq9WNS6qKzn6vf6s3mugKPoZ8dIIb8Ft6s28qWCRT8iIhqVFGiGv+k+vbFL7a+pBXZySuaX+zzuIpJaU9yl5exiL7ZLS5/cgG1NZ3/FOrScAZtuWojLnINhHlm3I1tkPGzpHCyZmXk9JG7qS0aztwu4WzCrKThql9dkkKSoFBk9bq8KBmW/X0vQjSWtS/K6uYiIiOzRj8P95tFXp6QYVcl9NRJDyZhr9X1V3OknjUDOhNV4J/1EUjcmvQktv4u9taz7mminn/wsd76yKfv50bscaX8FWwd3YH3/+uzXfO4WLJ2ReT4+jw+zwrMQ8UXUib+5TXMR8Zc3JcGOe1qDrdmdftbQaFGxLv4PPLTl77h33b1IaPnFbyIiouGNUVv64vjHc+vqsDGqeif9nJMQij3pJzHSZNraF8sWFiuZQxJ9o8RIEo+t2pnJWy1sj+DQpbnHtEeP9ztO2rWGRhb9ehO9aA+1Y1FLeUW/21+7HTe9dBO++sBXEdVzhUhbJFA7BT/Boh8REU2Y0GoP596I5bRfLeyusbu0Cjk9V82Tfs4u9mLnsSf+P3vvAd7IeV1/X5Io7L2Ty+29SruSVr1LlmXHspTEjkvcYjuOXGQniq3ETXJc/45LErnE3Z8jO+6OZFndqitpVbb3wrJcdhLsJEAA/J77Au/gnSFAogxmgOX56dlnh2WJwQDaOXvvuedGaZwly67TPXTn714QERvRClqp7POLLth8cwtahyMFratX1NCfvvoFOvyj/6TAjI/GvKGmXx7lC5f7Eoum/OR7iPPh3Xku4XAPUpCWV9YIYQgAAADMV9CqDDucB8an6ZevnrL9YqkaLZ44c+l0tyfeM7KvJp60ATnpx/0+r9+cqQGOaf36E/vpUw+8pCVcsItdxnuyi13VN2brI+ZE/4i2Y7m52Emt3ztA9L+c+Uk0OHWWWofate9155Zpk35MU0kTlbhLqLGkUez4SxVu+rEBiicHnblOKsitIf9sJO6/z7ub9vfvpgdOPCC+DwAAAJDw/ZP1kKzBsKmH+cP+NmofCt3nsmbST7l3W13/SnRFTLpqSNxs+8QfXqSf7j6uma1OmlxDkmlRsSb91BrStStr6Kef/ZRWQxoaz6WesV4amghpQk5rCktFHcPTw7SifEXKxijesdw11kWdo50UoMh1kBS6MmOi1ZSm35e+9CUhzu+44w7tc9PT03T77bdTVVUVFRcX02233Ua9vb26P9fR0UE333wzFRYWUm1tLd15553k99vvigQAABC9oHXlqkba0VKtNc1+teeU7WJSCqF44qD0gs2X0fGe7LpPh0vrt/taqXN4gn7y4jHqHQ0Vb2SBySyXVoUS7TA0qXdpHe8bofahce2xVtWUUW5whgL+0D8KJmZCX3PkloicdbWglW6kkObiFsd8chFrZVVq8VgAAAAWR3TVB6/cqE3LPXy4kzrC97ps2OmnNgZZr7C+spJEtNzc+Cpz6gfH+4Zpd3s/newfFRpJuthlU9EMfcTnLfWdx6CPGNWQdf36ZirOKyYKS8CxQBuNeYNUm7+OCnIbqSCvmpZWRM6pvqSedjbtpBWVqRezQueaL9IP3rPtPfRfN32LLq38JjlzI0as2ZzQifFkIU8aAgAAABK+x3HqD8P/3n/DlmXimD/14xeO236hpCHbmZezYMKAPt7Tl9nG8TTVkB483CFqOH86dIb2nh2cs/PYnBqSK2YNaXTKR8+3hnpKRW4HXby8nvJm/TQb7iFx0+/zz/4bPdr3Lto78pWoU37B2SD5g36hk1KFTVbaz6W5qR/cdDwnmn4vvfQSffe736UtW7boPv/Rj36U7r//fvrVr35FTz31FHV1ddGtt96qfT0QCIiGn8/no127dtFPfvIT+vGPf0yf/vSnU3smAAAA0lbQqinJp3ddvE6II+Zgd2i/h11wdKSsSy20gDn0PTZO+inFNxYqC1GgWJPMjAnjxcdScP9mb6twtp8eDAk2jtJM1cUu3fCSwYnpOU0/yTVrG8ntdtMbP/56Gn7tQXpu9A6aDoQakM6c4lDTryL1wlW8yNhVflxu+PHEX21JoWWPDwAAILvoCxujWBetrSunW7aGilosTQ712KuRRhM0G8miFusqVbOkG97vI+OhilzxNY9kvKfcNW0GahPu1TODwtV+0uSCFhulq4vyNX1kjCaVGomLdletW0o//+nPyXlLPpGDaMx/isry1tP28k/Q1uJ7qLFwm9BtkgJHgWj8mTHlx3Ajj7VQbm4u5eXmkLEmekPDl+hfLvsX+tCFHzLl8QAAAJw7yIl5prYkn964dTnVhO9ZR3uHbd/tJyPQuYa0UMJAptSQihOtIZk46TccriExv3zllNAvZqdFVYX1ETNgqCFxvYrrVszlK+uptKiQvvDNf6NVb7mZcvLyqGusn6b8UzRLfhZbUff5jfnGqNhZnHK0JyP3HTNBiqQgnFNNv/HxcXrrW99K3/ve96iiIhJ9NTIyQj/4wQ/oa1/7Gl1zzTW0fft2+tGPfiSaey+88IL4nkceeYQOHz5MP/vZz2jbtm1000030ec+9zm69957RSMQAABA5k361RQXiPgqeUOO5lK2L4vdkdCk34jlO/38Cbm0VEdZrEXGiRIw7Nh79nQP7W7vI5+JLnZGFrSiNf1UAddcXiRE9rBjkKiYyDcbKZDKpl+zxfGeDO/0czvyKTcnT1dQAwAAACRc8OgPF7VYF/GE+OqayM63TNJI8U36KUUtk3RHPEwmqI+Mei7a3pdUExkYjmjV7fOrMUcjVYaNUTOBWd1rxNOVUjPVlRSQy5FH9XX11Fy3jCiHNdKwSGqY9Ia6b7UlDl2hssBZQKsqV1Gh0xyzUn5ePuXl5tFMMHSObsfsnH013BQszy835fEAAACcmytiuIbkzMul5VUlpt+7k9Vv8v4bj+5QTdHW7/RLTCOxKUoa9IdNPFe1+dg2NE67Wnu19KbGskIqVHYJmtH0m1tDirxfmsqLhf7xF/hpX/A/aN/YV2nAe0D7eqljOZVFafoNTQ5RXUmdKeaocndE+wRm9bsrpwJ99GDrt2hkOmJ2z8qmH8d38rTeddddp/v8K6+8QjMzM7rPr1u3jlpaWuj5558XH/Pvmzdvprq6SGzWjTfeSKOjo3To0KHknwkAAIA0urQKdPGN7Mw2cwotWYcWUxLHvpqyNDTSkorZikOwyaJQNNGTLBPKImiGDebf33VU+9ispp/OpaUIfuPH8vt4X0y1eyU5ciJTfRXOrZSXm0tN5dZN+smiKDcb83Ly2CSmiyoFAAAAJFwwktGPXNBi1HuG/U0/RSPFkYZQZpMxSn+e8TX9qgojOmNIKQSlwoRXr2c5zWLX6VCUFJfPlleZb4xSjVC84y9sYtfpqJXlS7XjjpF+mqVZUeyqL3VH3cNnFvnOfBF37g+ErovbOZvRLnYAAACZaRw31pDs1kgceymjR+MxRbmVaG47a0jxNP1YH1SGNdKQSTWkaMaoHz5/TJu8M2PKT74/pJVpcFz//lCfS3WRWzRu73zsTvIGx2hwZi8dnfih9vUSx4qoTb/xmXFaU7lGGJpSpSw/YvLzG5p+Jyd+TgcHXqSf7v8p7TqzizKBhFuyv/jFL+jVV18V8Z5Genp6yOVyUXm53vXFDT7+mvweteEnvy6/Fg2v1yt+SbhBCAAAIL30hZs03ACRsY087acKtoKy1J09VrjY7XRpSaHEzit2b8cjLjkGlItQZhW0osV1qQ77dDT9Bg3nLhuYvMybhR3v8nWfdNOWvitoduk1NJMzSgHyUu5sBdUUu4Qr0CqKDA41fp87cq17/FSARgIAAHuiPWV0VSYVtJhxpYmVyE4/q4taqos9nvhzozHKuPfFrIKWqpEaTHKxR3Oyy2LZoGKK4pQB1kd//OMfyXkil4hfvjyO+GylaueFYtdeU3moiJouuOHHEZ9D00P08KmH6WT/GLlmV9OywteLrxe57Y1mixfoIwAAsJ5+ZUWMNLtkikZKtIYk0xDY8G51WlSiTT+pkXrHpmjSFzLoq5GfycANNmMdKR01JK77cL2OTVBzJv1UjVSUL1bGXTR2Ee07vp9mVvqERpKUOZZTqWGn37R/WuiapYqRKhWqCqu04wP9u2m163WUl+Oi4Znj1Ot7QTNiba3bSplAQu+AM2fO0Ec+8hF69NFHKT/futirL37xi3T33XfP+bzH4xEvOAiBZmh6wHXFdV2s79duz5hw+VYWuGhsJDSi7qaA5vxt7xmggqA9sczdgx7tPHL9PnE/WAhHzqxwd/WPjsf1/WZd2+HxKXGuJU5X3I9b6sylkUk/9Y1O0ODQkIgOS4WuwdBryRS7HLpCG//kirxAUtckmjDMpSD5AkHqHh7V/cye4XFxDlWFbhoZHqbp6Wn6w//8gfpGR2jpW6+mAmeVcLH7gjNUW+Aw5XziPm/ftHZ9mBJnvmWPn+r/s9BI6b/GANfWavCezezr2to9qN0zinJnxf2C7395FCRvIEi9I2OW3sOMDI6F7re5lEPeiTGamZxfQzgCPu35dA8Ok6fCbcl17R5QtFxgJq5r5gx4tT9zpt9DHk/qBaeBkdGYGqmpOH7tthBu8muP09E3RKtKQ0W8tp7I+6mAAtTf30/f/va3qWe0hwquL6dS1zo6632IRvzHqCi3mWrdX0jr+ysQDFBpsJQmvBP0RNsT4nM1ziDlBP+CWqd+T71tHVRbVEA3LbsprecBfWQNuN/gumYTeL9m/nU9Mzis3dNcAS95PH5yBmeUe/cQrSkzbzo9Ec4OhfQR4wj647qHFeSS+DNcm+kfHEzYGJzstR0cjZyrf2qCPIGFm6VFebPan2nt6qOG0tRMQtzs9M7MRNVHTI071JcxgxJnLg2M+2lw3E/9A4PkCBvAu4ZGIlpxZpr6+8do/x/305KRFhpYNUujdEp8zZ1TQTX5FeSe0V+n6alpanQ0UkmwxJRz3Vy6mSrcFeTxeqhzrJ38ru/RpqJ/oOPjP9W+5+qmq8npc2aERkqo6cfxnX19fXT++edrn+Om29NPP03/9V//RQ8//LDYyzc8PKyb9uvt7aX6+npxzL/v3r1b93P56/Jr0bjrrrvoYx/7mO7JLVmyROwTLC01p7N8rqDuWAS4rpkO3q+Ze13ZweMNEjnyHNRUWar9zKbqMXKcHhDHAYfLttdwtnNUnBtTX1ke13lUFhdQ39g0TQWSv0bJ/DlvcFaca3lxQdx/vr68hLrHQw3VvPwiKk8xajJ33K9dr9dsXEbPnOrWJvF4v15DbTWZRV1ZMXWPTNKYLyi0AEdNCMEYfj81lJeI68B64fxLzqcj3ceI8nJoNndW7LWZzQnSstoyS99bjeTUrg/TVGnd4+flpRYzAY0UH7jfpA9cW1zXxfZ+nTozot0zltVVaT+zprSIekanaGJm1tb/L7zBHHF+7GKvqqxc8PsbJ4LkyOsQx/5cZ1LnnsyfyRmY0q5jXUV8993lrgJy5J0Qx1OzOaZcZ3+OQzuPt160jn6gxJ9vXFJr2mu5dGpWu87TlKf93GlF07bUVlJVVaVYl9La10prVt5KQ6OrqHfwRRoPtLICptVN1Wl9f3EDm7hO6GdjWI4wZHlnPUKnDczso+GpI0RDRNevuT6t5wF9ZB24j+O6ZhN4v2b2dR3xsaZwiAn+xnCNYYly//PlJKczzKB9IqDdb2vKIzWu+aguK6b2kdC0WV5BcVIrQJJ5vjOUK86Vvd98HeMxgTdWlpPjbMis73e4U77OHNUqr9eWJTU06fWLCHSZ3rRlWZNp6UwNlSV0ZjR0nWfdhVQRjoYd84dqaZy6wNeBa0gXXX4R7e3cS+vr30IHx35Lfd7dtLzwNiotDpDf7deZmM6OnqWdzTupsbbRlPPMLcilN218E/1w3w/JF/BRj+9ZKnOuojLnahoLtFFDSR2tqltFrmJXRmikhF6da6+9lg4cOEB79+7Vfu3YsYPe+ta3asdOp5Mef/xx7c8cO3aMOjo66OKLLxYf8+/8M7h5KOHJQW7ebdiwIerjut1u8XX1FwAAAIv2+YX31cyNZrBnys8Y0RlvNENZQejcOTbTH7QmmsjrD9BMYDahWIY5EVAmRGCoURblhS5649blpscySHiSj+F9RxNhN5ga0yCjYjkO/C3vfwtd+pcXU1lJXqTQlJNDLZWRZd9WYHxt1Ouf6UAjAQCAnfGeczXSlO17j2cS2pNnVwR6MtFV5QVuUQCLFiOe6nnwj716dSMtqyxOi0bi6E6JqovUY/4e1kf/9E//RB/80AepqoybuGOi2ce4c0uoujhyfumAzVpFziIKzAao1B16/t7gsPh9Khgyaxc6CynfkdlaCfoIAACshWssMno7dg0pU+I945s2LFc1kpUR6GFtUuRyxJ36pNYwzIhAV3Uaa8q/On+F9vHSyhJT17EYI9AZNoRLrSejYlkjvfv2d9PFt11MNeVOWl30Vrq08pvUmH8FlRXqkyDPjp2l6oJquqjpItPOk+PPm0qb6K83/LX4uM59ATXkX0lri99Bf9HyRXrXtndRbk7mrIlJaNKvpKSENm3apPtcUVERVVVVaZ9/z3veI6byKisrRXPuQx/6kGj07dy5U3z9hhtuEM29t7/97fSVr3xF7PH75Cc/SbfffrsQZgAAADJrAXNNeF+NUbCZtUsldQHiijuPXTI6PaPbT5gujEIpXtSdNSx6Ui066fb7uJ104bJaOtLjoXbPOL12YwuZSZVS1OIMdi7kGQtaRiqLAjQ25RBucnaVL6/U7wZON0WG16YmyjkCAAAADKcGRLtfqLpieNJny97jmUBQTNcntK9GKWjxPhWrUDWS8T4ci7zcHKoocAsNatz7kmqTtNDtED//fZetp3ufPiS0l5lNP7WgNaA0LAd0xijl/VRQSQ1lLno5EImHKnQWiYZbuil0FZI/6KcydxmNeEfIFxymwKyXvMHQuVTkI10IAACAHt5Ryx5eYw2pMkOafqruKI1Td9i29zhcv0nMOK6vIZnaJHW7aE1tOd2yZRk939ZLf3lepAFoBrKpp+7x4+sdCIbeUNXF7qg1pM6hiNYuK4wY+z3THvL6vXTDyhtoSdkS086TG3q8s29d9Tq68+I76UTHVhr3hgzsDSX1tLy8kg72HaRMwfR/iXz961+n3Nxcuu2228Ty5BtvvJG+9a1v6UYQH3jgAfrABz4gmoHcNHzHO95B99xzj9mnAgAAIEn6lYW5qksrUwSbLNAkUtQyurSsaPqpQinegtZcp5O5Li0WjpxF/8Er9SaedAi2oclpWlZVErOgJaksClL7APvYZ4kNY03l1k76sUst35mnFUrVxiUAAAAQzRjlduTqDD1GJ3tDWfqbM/Ppo3gLRXpTlD1Nv0SNUdz0YwMXNzlTdZrL8yh2hc5heVUpffWNoZQiM+Hz5GvN582FUaPOYyO/+h7iotKKimaazd2rfa7YVUQFjtR29MRDoaNQTPqV55dTx2gHzVKQRv28NydUfEPTDwAAgJG+GDWkAmee0EycBJRtNSQ1DWHEIo3EjS5et5NSWpTJNSSOa2XetH2l+GU20ZKu1MZlZZQaUkWxPr2rPNz049jN7rFuMeG3o3GHqZN3suk3FZiitdVr6UxPDo2HL3WRO9zxziBSbvo9+eSTuo/z8/Pp3nvvFb9isXTpUnrwwQdTfWgAAAAWxHvWRImuyqRohuIMdmlN+BI/T0ZtSA6Z4NJKJkIrWdRJvoGwApJuLVXQTU9P02c//FnqHummv7rrQ1zeEvGe7NByKvv1rIKvi2z61WRRvCcAAADr4KgheU9jfcRRiNHTEMyZQkuUMTX+PM77PRuBuJjD8edWutiTaVBqaQj9ES2qRqwm83ryjppEzyFZWANx088z5RVFPZ4slEUt1n4c4cX6iNOTeG/Ne//tvfTK8L9rf76ysFQUm9JNvjNf9PfK8su0zw3PHNOOKwow6QcAACB2WpR6b2atxBqJ9x5nSg0p7jSErK0hmdH089tSQ5LGKF1alFJDuvPv76T2oXb6u7v/gVvK4vO5uUTF+bOintQ+0k4tZS10zYpryO0w1+gvmn4OFwWmQ3UjlyPS6CvMwKZf5gSNAgAAyMx4T+UGzC5l6fLJBJcWT2fF6/DWCTaLXFrGWM1UMs3tKKwlgyo25bmrolOdBJwcnyTvpJcqC4PEbyue9GusIMrLiW8xsZmorw8m/QAAAESDtY8/HDWkutgzZe9xMvtq1DQEKyf9uMkokdrSao3E5yBLNNY0/ULvEY4/4/cS736Wr5la8BodHaWxsTGqK6rT/fnqIjfl5aZfI8l9fTzpJxmeOaodY9IPAACAkf4Y8eeZsvd41BvROPHe88sULWWVRlL1USLahBuZzrwc02pIySYyJENVlBqSNJAba0gT4xOihuRyEFWGp/3qSgMiMWHYO0y5lEvXrbiOqgurTT9Pbvq589wiAp1xK02/Ird+8jATsN5KDwAAIGuiGRy8O8UQg8lNHRYiXKxgJ43qcrcKKUASER+6aAaLXFpqsy2Rgpa608+M3YkTFjb9ohXj1HhPWdTiPb4f+9zH6KljT1F+gYOu2ThJB3t6aceyJeTItV6eXLKijloHx+iCpTVU4IQ8AgAAsED8ubKvZk4E+pQ9xqhkCzRsjDpLkyJ6i6fe2VRl1bnytFu+I/7HqyrMN83Jrk9CSP+9X+dkn5gmXyAQ+VpRRB9xatLIyAg1VzZTubtcFLGY+pLI5F064WnC2ZxZsdMv6qQfdvoBAAAw0KczjuuNUZmw91hvyHYlvPfYuhqS2pyM/zpxXa6yMJ96x6ZMSZwYT3LiMBn4OrMe5BQEWTvSrYhRakif/NIn6f/2/x85XA66bM009YzkUWN5SE8NTw1Tc1mz2LmXDnIoR2ikYDDU4FtS5ae2AQeV5M9SRVHmNf0w6QcAAEAHN/L6w/GeXJzgqCEV2QRkp7sqnKyCo5i0pl+csQz2ubSSE0puR54m8MyIZpDNx9ycUKZ+OomWJS8FGz92IVuywqK0vqmeymrLxHFZ4SxVlQ5Rab4+Ls0qXrdpKX3nzZfTR6/ebPljAwAAyA6kPopW0NLFe5pw77ZqX43RGGWVRtJ26bmdCd335bScGcao8SSvV7JwMU5t+kWLP+dr0dLSQs3NzVRWUEYf2PEB4SrnRhs7162AH0/EeypNvwBFrjXiPQEAAMy3IsYYvZ0Ja2JkBDpPw/GOwcRrSBHNkE5SidWU5vFJX+oTlcms1EkWrjlKfSdrSNHiPVkjNTY3ajUkjtRcUeunfFdo4m5yZpKWly9PWypCTg6/d9wUnA01+BorAnTL9gm6aeskpbhiOi3Ayg4AAGDOzZ2d3tEKWtF21lhRJJkTxTSbmEPLLpdWKpEIXPwZ946LghY3Oo3NVysKa8nA0wFyNxALNW4iy72EakMwGhzvKSOl7EAtegIAAADzudgzs6CV/KSfqpFS2ZOXztQGYxqC6gLP9PjzuZN+XvIFIq7waBqJY6QubbmUJmYmQt9TWEVWNf1yc3OpNr+WLmi8QDT/Hmt9THyN0xhKXCWWnAcAAIDsS0PgyHDjCpbM2HssdYcr7poI1zXYOM3J7iMWpTjoUwgSryGpOqO53JEV8Z7y3PvGpmnS5xcNS9n045fKmD4WDa0RV9KYdo00mxOJ9bTg0iQNmn4AAADmKWjNLUDo4qsmvbS00tp/+KtxB8lP+lnj0kqlmMTXuX1oXEQcjE75qDwOoROLZCYjU4GdWBPecSHUhqd8NBOYnSNC/X4/vfjUi3Sq7RQ139hMU8Epscuv1F1qyTkCAAAAqeyrUfeLMFzg4il9dmjb1vRLViNZPOk3EwhqBrNUClrSVGRHYS0ZqgwNS97pJ6kuDidp+P30+OOPi51+t9xyC9UX14vmHxezCp2FZAXsYufHrCmqofdvf3/o3AurqHusm/yzflsSGQAAAGQuPn9AM1bXRDEO2b33mI3IsjaTiD5i4zUbo7imYd2kX2o1JFUjNZcXmXIeRRY1/SSD45E0hIoC3meco6shtR1ro+qrq6koP/L8xn3jQifVFtWmPwI9GGn6ZTJo+gEAAIgdy7DApB+LH6tJNorJDpfWRApCSSd6Jr1JN/1SKawlC587Nyz5Wp8eGJ1T0JKC7Tc/+Q31jfXRRVdfRAO+AVpRvoKWlS2z5BwBAAAAMyf9pEbipt/wlD17j/WTfgmkISjGKCu0nb6QlFhJorzALVzfnPogI6Cyp+kX0XZczFKbfvJrrI/+67/+i2ZmZuh1r3udaPoVOAto0jdpWRoCN/2cOU7yB/2iuMVcv+J67esdIx2WnAcAAIDsoE/deaxMtUdt+tmw93jaHxBm6mSm1tgYxdpoZNpnibbTaRNXCsYokyLQC115WtMtnahmuu7RSa3JKvf5SY30ix/+gs54ztDKi1bqmn4j0yNUWVBJ1YXV6W/6EZp+AAAAsjiWIR6Xlh07a5KNrrLHpaUui04+voon5lZWl2ZFdJXRyX60d1j5fESwcWzUhm0byNHroO6Jblpbt5aWli0lpyOD8xEAAAAsaqQxihtVcketUSOd8UyICXfWAFZHoCe704+juKyc9Et25zHDhSd2fXMxS933kg3RVfz+kA1LduDzZISx2MX66KKLLqKpqSlxzMUr3ufnDXhF888KuKDlyHOQP+AngiwDAACwAP1xmKIypoaUoDaTxihuGk74/Gmvqeiafgmeq1qHSVUjSU1pRw3peN+IdlytfJ510Y4Ld1Bxd7HQRSrjM+O0qXYTOfOc6Y/3JDT9AAAAnOOCzY74Kn1By5UVLi2XI3dOrn2ieex2FNbMcGkd0wm2yOddLhe988PvpPv3309LKpfQ1rqtIpKBIz4BAACATMMfDGqu6WhJCNE0kuVNv3BRi+VNtKZkLEqV87Ri77FOyyWhTdgYxa8Fm7g40SBRjRXtPKyIrmIDGkdvsa7jFAeePJD7kOXrxfrok5/8JHk8HnHMtJS1kGfKQwUOa5p++Xn5YnffzGzo+rBmZo1W5CoSsZ8AAABAzLSoaDUkxVyUjTUkVSNZ2vRLcadfsgRnZ2kybGC3rOlXHL2GpD4n1kV3fuJOeurYU7R/ZD9N+6dFCgLrlEAwQEvKlliShjDL7q0sAIoNAACADl6eK6lZIJoh1ciA1Cf9HCm5tNKNFGyJxjJEy2NP9RyscrEbhVmrLt4zyo7I/EpaV71OFJNYQMkYKQAAACCT4OKJ/Dd+TZSdx9H2HluNtq/G7RQNpngpK3BbOumX6p4YNQ0hletsh0aSWoj1rEzXYFPUfEa0ppImKnGXWLrTTzT9AjP0wz0/pPc+8F766CMfpTHfmCWPDwAAIHt3HkerIbkceVqcty36SNE2iTaxypQmoTUaKVKnKk7AwDW3hpT8dZ70+bVZNsuafoXx15CKnEUiBWHUG/q+Kf+U0C51RXVpP09nrlNMHPKu5UwHTT8AAABRJ/3cjtyoBRAWPbIuYYdgU4VWIvtqorm00olwRSexLDq6Syv5pp8aZWqVYFOLcX5lybH6nJjGkkZaXbmail3FwsW+sWYjleWXWXKOAAAAgJk7jzNhZ41mNkrwfq+b9LMgAl1X0HLbp5HGbdBI6rnL/UJGfWSkuaxZ6CSetLOCvNw8UTzjnX58LPnHR/6RBiYHLDkHAAAA2ZkWVbOARpJ7j7NhRYzVNSRVyyWa2iDrTs68nJT1USrXy4x4T7WGpKZFMWyS4tQBNkRNzkyKz3Hzr8xdRrXFtWk/T2eek3IpV0wWZjpo+gEAANCN8Q+EXce8zy+a65h3qUi3k/3RDJnr0vL6g5pYSdXFnspE5YTP2uiqWG6sHEMx1Ov10mc+9hn6n6/8D60pW0NLy5daVswCAAAA0lnQsiMNgWMup2cCSemjAqdDRJEzoxYWtJJJbTC6wVNxssvzyM3ha2BNvHi0Bl91sV4fvec976EPfehD4phpKG6gy1ouE3tkrICLaQV5BaLpx0U0FePHAAAAQF+4hsTlo1hGFt7Hy8i9x9lSQ9Ibo6zTSGxGSnQdDX9/ZVgjDU2mYIqyoYbEDU6OOzeivp9YF93xgTvoG5/+BlEgtF/P6/fSmHeMGksbLYlBd+W5hCEKk34AAACyCm7iyUZVLBe72pBi0SNdylaRLS4tXRZ7gg4txu3Io+JwISyVPPZxG1xaXPQ0ytPyQpdu5w67+4YGhmhseEzksAMAAADZEl1VGyPe0869x/okhMTv99IYZWVBiylKIgJddYOn5GRPobCWLOq5Rz6Xr9NHfX19NDAwoE1C8NQdm6OsOkeGo0QDswEqzy+f43AHAAAAohmjeCqLTeLpjOY+l2tIqkYqSqKGpF7nSV+Apmb8WRN/zhrHONVnNJSzLurv76eJkQmhU4rdxTTiHSFvwEstpS2W6CQnx3tSdsR7JvcOAgAAcE6iuqWjTWtJyoVLa0zstuHikJodbqVLK1HXkZUuLZ1QSiLeUxaBxr3jYqcfT2Emsp8nqqvNIsHmyM0VhU91ysHo+OMlzF/72tdoZGREHAMAAACZjNpcilaUmDPpl4JhJ+WClpJskMjeY94xx2YhNnTFKtqZboxKMQ1hMKU0BH9KOi0Zor13VI2UKfqI9+XwpB83HAEAAIBYeP0BmghP7s1XQ5KTfrLp11JZbNlFHfP6kk+LKrAuLcofDNKUltqQnAbQR6B7qbnckRXx5/LcO4cntI85haJIaX5KjTQ8PEzFFcXUNdFFfeN9Yg9xQ0mDJefozHNSTm6OMEZlOoj3BAAAELURVq6IGyNqk89ql5YsFHEMkzo5lsmTfsm42FU3OA9TJnu+uvNIIkIrWdSCXLSmHy8/Xr16Na1cuVIcAwAAAFmjkWKYndS9x7yzxkpSbaRJjcSzZWMZbowyY6efGoearE4zLd5T+Vym6COOXOemnzrpV11Qbdv5AAAAyEzUOsV8NSQ79x7rjdCuhE1RVtWQJtWdx0lO+qmJAmweT11TWldDMqYhsD5Sp/ekRlq1ahU1lTVRTXGNiNpko1JdUZ0l5+jieM+cPBqcHKTh6WGaCaR/F3ayoMoGAABAY1gRMWqDzEiFrdEMvqSLRFa6tFItvjEyjz2V3UBmnIcZRa1YUxEAAABANiALPTwBVxSjEMNfkwUvy/VRipP9ahqCqgfTntqQRMONEydkDSjZicpM0Ufic/NMRtgFR69zjNa6qnW0vWG7aPh9YMcH7D4tAAAAGYZqcpqvhqSagq3ee6xPQ3Am3/RTfk6mpVqZWUMayxCNFGs/JFPqLqU1lWtE06+uuE58bJU+Wl+9nlZUrhAf9032UftIO3WMdIjfA8HMmQBEvCcAAACNEUWwZeKkH0dcyuiIRB1aVru0xsORUanERqnCeGB8mlZWJy5k1CXZVsV7RmvyGQtagUCAnnnmGRobG6PXvva1lJc3d2kzAAAAkClIvROa5suZ18numfSJxlm6YzLNKmhFotutMUZJLefMyyG3I3EfMl9TjgnjYlayk34TJsSwJwM75jmuyucP7YLJMejqTNFHBc7Qbm9+r6PZBwAAID7jeOxIaDv3Hssmlisvl9yOxO6rnC5V6HLQpM9Po2muIU34zFgRo68hpZ7I4LJv0m+BGhJP+22q3USV+ZWi+WcFuTm5tKx8GZXll4m9fiPTIzQxMyHSEbx+Lw1MDmRMMgKafgAAABIWbGpD0MqdNSw+OHYqWceRlS4tfbxnstEM5k36scB1JShwzY1m0H88MzND//7v/y5+v/7669H0AwAAkLGw6UgWjMoL5y9+2LX3WN1Xo07tJbX32KIIdJ7ym6+BupAxirXR6PSMiOpMNPJd52K3MN6Tny/ru+6RSW0qQj33TNFHhc5CyqEcMe2X7GsEAADg3EdthM1nHLerhqQao5KdWuN7NTf91Kj3dKBLIUh6RYzJaVFJ1rLSkRZl1EiF+YV0SfMl5HJY15jMzckVv7jhx1GfNUU1xP8xfRN9tLZ6rWgKZgKI9wQAABvoH58SBaRszWNXIwOszGNPdQeMdGkx6XZpmbH82Iw8dlnUsjKWIdpkX7Sdftu2baNNmzZhpx8AAACB1x9Ie8Mp2WKRlG086RfvlL6VTnazdvox3Eiz4lyLU5iwU3VFMtdZ1/SzcNLPWMTKVH3ETT92zQdmMyemCgAAFjM82c4ml2xdEaNGc1u595jNK1J3JDs9J7Uf7wL2+QOWpDYkvSJGV0NKtumn7Ba0Mi3KUENSn0ssjdRY2kjVhdZN1uXm5AozFL+vVKZmpsiR46Dm0mbLpg4XApN+AABgMf/7yin6/f42On9JFd153baMFWzqVFymRDOkGl1lqUtLjWYwIY89mfgqMwRuulxaLpeLPve5z5HH4xHHAAAAFjdcSPnH3z4vXMn/fP1WOq85M6JxEtlXkzEaKcUI9HQW47hY5gsXLVOJHVcLQayRaktCcZSZvtPPeO5Vxe6M1EcFjgJy5jrJF/CRIxdlIwAAsJPnTvfQvU8dooayQvriX1xoaYKPWcZxjubm5hnXnKzUR1MzARG3noruKC1Q0hCmfVRTnJjmiJcJZUUMx4EnAz9Hjk+fCcwmHYEujVHcpJWmeSvIhhpSrjLpp9bdRrwjtLRsqWW7BeMBk34AAGAxL7T1it9fPTNIvWNTGbnTr8jtmDcmiQWII7yjxsolzKorO1nBZqZL69UzA/SlR/bS/rODc742POlLeQmzbtIvies87Y8IXKsLWqpAY9FpddMRAABAdnGif0S71z10+AxlEvqC1vxxnXbtPR5NeaefK2oDMRk4zeKHzx+le58+RFMzkQKW0WBWlEIhSdUZyTjZ5V5Bq3ceG8/dWNDKFIpcRSK2ipt+AAAA7GV3W59Yc9I1MkkHuoYy6uVQjULzGcdVY5Tce2x5DSnFST8m1USKtsEx+sqje+nPx7vmfE3VjcnWb3gKrTKsLYYmU9t7zPrIyohvrkGqcfPGyb9MIDcnl/Jy8mjUOyqm+xhu+JW4Sqi+uJ4yCTT9AADAQtgBot7IX+3oz6jrLwsx8zm0GL7xS8Fm36SfyxSXVir8+IVjtO/soChq+YNBXTzZkV6P1iBdaCogFuzgkw6vwTgKWvy43IgcDT8v3V7BJJ1iycKC2uUIyQx2wmEfDAAAgPkYVvTEoW6PmMrPtugqo4ayVCOl6MrWT/qlpo/YDPXo0bP07Kkeuv9A+5yvSZrLi5N+DLW5Go+TnXfoHewa0uKYpFZKxU2fLDVKEStd0wJmxHs680KTfgAAAOxFNQC/nKE1pETSEOTeYysYUx4n2RqSPgI9tfP+1Z7TtKdzkL6368gc/cK1JUlTeVHKGmnSF5hjvjLCzVfWZryCyKgpkzWvp4LURaxnjZN/mUBebh6tqFhBTSVN5A14qWesh7x+r4j1dDus2eMdL2j6AQCAhXC0gNcfaQ69cmYgY64/iwFf+NzKFnCxq4KNndJWZcuPmzjpl6pLi59z//i05q5Xi1h7Owe0a3nh0lrKTcEdJYUO7/RbaA/k93cdpf/32D4xfahGe9rhYufn/JfbVgjBecuWuYuMvV4v/cM//AP90z/9kzgGAACwuFEbZFyAONA1d4o+06OrjNHcVqYhaHHebmdSuoP32sk/lmpBq3s0Ujh6+mS3Tr8839anHV+0rNaceM8FrjO/t+76vxfp8w/voSdPdNse73nhslpaXVtGyyqL6ZIVdRmpj3jKjxt/XNACAABgLzrj+JmBBesCdmgkNv06FthFa0cagvk1pNTSEHpGJ8Xv/BI+c6pH+/zZ4Qk645kQx6tqSlNqeKl/diHz+IOHOuiLj+ylT97/kpjw4zoXp2LZoY+Yv9iyVCRe3bp1+Zz0sUzRSGX5ZbSicgVtrt1Ma6rXUEtZC1UVVlGmgXB2AACwEKOwOdzjESLEjpvpfAWtsjhiD9SdNVzUqktwl0oyqEUodezfDpeWcd/N0yd76PwlNeL4+VZzCloMC572oXHi9At+jdTrrsLCX7r+WgfHhGhUFzAns98nVV6/ean4FQ1uSp45c4ZmZmbmLEEGAACw+PAY7qsvdwzQRcv0DRG7yI6dfpGiWzJwo5CLYWxkSjW6io1KarHpSI+HNjZUip/Lx0xdaQEtrSw2qaA1/6QfG7Ok6e6ZU9109ZpGw94ca3V4gdNB99y8I6P1ESc0lLpKaWAycwyKAACwGOF/56vTdHyfPtU/KswjdiN2mYXPTW2MZZJG0qdFJbvTT2n6pWiMUg1hz5zspjdsXiruuS8qpqidKepf3ZqYiWlqnmdqUD4uv6940pD1ml3GcWma51+ZrJEkBc4C8StTQdMPAAAsxChs+D7FN9ZLV9Rnlos9RmNpPsFmVtOv0zNOuzv66arVjTonmNk7/VJ1aRlfy1c6+kUDl91IezoHtLgoVTQlg7G5Gqvp1zE0rjmyGI6MUMWe1fGeC8GLl7/whS/Q6OiobUuYAQAAZA7GqTi+l/LEX154h3C27PTjez/vsp0J6CPdzSj6cXGISxxXrmrQxWbzjmLZ1ErF5MPPjYs+bIriYkqy0dzG5/3MyR6hh15q7xPal9m5rDal6G8+V/7j/PMWus68L1JytHdYRMfamYaQLfqIneyI9wQAAHsZn56Zs//ulTP9GdH04yQrXzj1aaEkhHQ2/fhnPXmii85fUk1LK0vSXEPypZSupdZseEfjqYFRWlVTRi+09ZpmHDfWkGLB+rFtaEz7eG/nILVUFNsWf55NGikbQLwnAABYSDRhw/EMGZfFHodLK13RDF99fD/96tXT9MWH98yJDTVjp5/651JxaQ0ZYhL8wVl6oa1vTrRnqsVKNSZsvuusFrQYbiark36ZME2qkpubS5s3b6YNGzaIYwAAAIsbz6T+nszx4cf7hikT0KUhxLH3WDYGzYz35H1033n2CH332SP04KEzsQtaSbrY1RQF1jRcyEsW4/N+sb1PFLmeN9HFzvpK6lWjJjNyvC+ikbhJeKBrSNOUrrxcsUM5U8gkfcRNP38wc3ZrAgDAYiSalsiUNTGJ6COmojA9e49/+PxR+uWrp+meP70y53qZUUNS9x6nkhYVTa9wxKcx2rNa2f2bDGqtbj4tenpwTNdQ5hqSqilRQ8puUGUDAACbGmsSbhL5g9bsxDMruipdgo2bfL1joT0wncMT9Pv9bdrX+samtEgo7qMlO7mmOtBScWlFE0+8t8bMaE/jzpr5ilpqQUs62dVlzJnkYgcAAACy0RjFE3wFzjxb9h6zLpL88tVT1BveCcOoO2HiMW7FoswkjWR8Lbnh99ixTtOiPY0aiU1cxikICU/1dYYLaeoUqZz0y7SCVibBO/0AAADYi3GtCMP3NVk3ya4aUnzNqEQ5E9ZIk74A/ej5o1r0I+sPNh6lqpHM0kfRnvNzp3vEL7NMUUylEoHumaeGdMJQQ+K0BzZGSaCRshs0/QAAwELUm3xN2L3DwuRoz3CGRVfZE81gdE39fl+riK3kQs69Tx/SXOeXraxfcEm0lS4tR3iaj0UTx3yaFe3JVCgxYvNO+hkEG18zNRc+0wRbIBCgF154gV566SVxDAAAYPHCxRl5j+Noapn6KHfVZkpRKxQpmWO7RuIore/tChW1OBbqV6+eEp/nU7t8VfKR8WbsrOFzkhpJ6iPZqJTRnhcvq0sp2tN4nfnnRiuKMif7R0Qkqsq+zsGMbfplkj7Kd6Q2aQAAAMDcJARZQ2JezQCNlEj8eTrjPeVeY7kTene40ff/7T5O3SMhk9TyqhJaUhF7t918sOGLjV+pp0VFdhBLjcQGsQcOtptqHI+3uRotUeNZxUiWacbxTNJI2QCafgAAYCFDk5Gb/HVrmzIqniFRwRZv7GSy58Cwafu7zx2m3+5r1SbZWOi+46K1ST+GeS6tyGt55eoG7ZgjscyK9pwz6ac8pgo/D+n0k2KU6R+PfH+mFbV4+fLnP/95+trXviaOAQAALF44SkhOajWXF9O6unJx3DM6RV0j+iktq+E0BhmXHY+Lfe69Oz0a6VC3hx46fIb+86mDQi8xb9i8jNbUhq5dMpSbsLNmwufX9vusrSun2pKQXuQdh2YWtOKNr1Ljz6VG4slNqdeKU4hDPdf1EU/6ccRocNb+RBIAAFisZHQNSWmAxaORuIkkm11mpkWxkV7lh88foz8f76InjneJj12OXPrglRuTNhzxn5Pm8VGTJv3UGpLUSGZEe0oTv3yqsfQRm7RkjQ01pHMTNP0AAMAml9aVqxtFTCXD02EygiAjdvrFIdjKlXhPswpa0SbvTg+M0W/3topjFi63X7GRCl3JLxQ2y6Wlvpav37RUE1VmF7R0Lq2JhQtaV69p0om2THVpcRFp/fr1tGbNGtt31gAAALAXtfDD+uL8JdXax690DGTVvppEpvQTgSOXjPx09wnqHZ3SCkW3nbc8pcdQJ/2STUNQny835S5fGSlqmRntGa9GUuPPb1y/ZM7XOZkhk8gkfcRNP0eOg3yB5PUyAACA1FDvqxsbKzUzzeEejza1bhfDk4mlRXHzTN6705UWFfrcDP33c0e0j99x0RpqLEtuys+oAXlHYDDJ2p36nK9Y1TDnmpkR7cnk8nWW+6WV6UKVvvFpTVtuqK+k5vK51yfTjOOZpJGyAVwhAACwkOHwTZ4LDCwaNtRXaBNZ6q4WO4taOYYIzFgUOB2UH95rk46C1iUr6sS5qNy6dblwjaeCeS6tkHji3YJ1pYW0pbFK+5pZ0Z7i57sc5MoL3a49UwsXtDY2VND68PtK93MyTLC5XC76yle+Qnfffbc4BgAAsHgxNoq2L6nRPn7ljL3xVWoxKZ6CVrr2HqvnwRpJhfXYB6/YmHT0uZlpCGrzraoony5fpW/6mRXtaZz0i3aduSjH8Z5Mab6Trl/XnPGmqEzSR0XOInLlucgbMC+CDQAAQPJmY6GRWkIaiftO+84OZtWkH1MevnePm7T3mJtwkvOaq+bsXr5waQ1dvbox5ceR+wBnDY+ZCKpZnjUSr61Jh3Gckc1VPtdo1/mEEu25uraUtjVH6lmZ2vTLJI2UDaDpBwAANuyrkTfg88OCLRP21shdKCX5zrhjKWWxhZ+XGZOKaoFpR0sNXb8+UpxZXVtGb9yamoPdLJdWtNfyCmWHjlnRnpobLhwTNhhr0k9p+q2pKaNtzZEJCabQlWfa+QAAAADpTBvg+2pDWSE1lhVqxpZUdvCaeW7xxJ+nKwJdXgM2Fr3zorWiiSV550VrhAEpVVTTV7JpCKpBiV/LupICLa7V7IJWZVH+vKkTXcMTWuRXKGq0QHtfZWpBK5ModBWKph8m/QAAwD6kjmC/DNcxtuvSEOytIY0o9/z4NZK5aQhqDWlZVQm95YLVusd676XrTTEblZpgjFJfS75eVyrGKLOiPY1R81ztirb3WDWOczR8tKYf1wZB9oKmHwAAWAQ7meT+ENko2tYUubGeGhi17bXgJpYsJsXr0FKfh9cfpKmZ1BfpqkU9dlK9eftKunh5LW1urKSPXLXJtMaVFKSzSQrNkCttVidaL1pWJxp/a+vK6NZt5jQnJfIxpmcCNDUT2iuk7ho6NRDZd8jOOXa4qaCgBQAAIJNRGzZSW2wN38vYm9M2OJZd8Z4mF7TUNAQ+By7C3HH1ZlpRXUK3bVsuIqLMQJ1kjBWXuRDqn5MFp7dduFqc6xu2LBUFObNY6DofUwpaq2vKdO8rCTRSbPId+eR2uNH0AwAAG5H3N75Hc2wjm1jcjlzba0iqMYqbWPE2iMzWSGoNic1L16xppJs2LhFNtI9du8W0+7wa3a7uWUxGI/FrybWt5opioeNYI739wkiz0gwWus7SOM4VtpXVpaLxJ5O8JNBI2U1mBdgDAMA5jHqjlTdg3mvC+9e4gSR3stjBpC/SxJKxBQnvUpn0prRrb65gc4oI0Q9ftZnMRnVQDU5Mi2iFROA/Y7wGLNo+cPlGSgeqG46FYlN55Dq3D41rr92a2lBBq760ULy35HsqE8Waz+ejT3ziEzQ9PU3f+MY3EM8AAACLGI/SKJL31SXlkb1v3aOTtEUxSmXyzuN07D32+gPC+KNO43GU9+dffyGZCV971jOB4KxO6ySCWgiTryUXk8w+1zn6KFpBS9l5LDXSec3V9KdDZ7TPZ5pGyiR9lJuTS6WuUhr16ovKgdkAuXIRqwUAAOmG78dy8l7eUznKu6GsSBiieE0MRzc6w+tA7DJGcVQ2NyTNuHcnfA6GGhKfx99euIbMpkqpIQ0kYYxis7a8Xmod7S/PWyF+pbuGpMJG8nbPuDheUlGs1fHYbP9Se2h6lOuUcs1MppBJGikbyKxXDwAAFtG+GoYFSV1JKGaoZ3Qy6YXApkZXKeIgEUe4OS6tSDZ6PHsFk6VaafL1j02nFF2liql0YWyuxopl4AhUiTrtl2kFLSYYDNKJEyfo9OnT4hgAAMDiJdqkX31pgfY51kiZEV0VnzYxe++xaopKZ9QS69Kq8HRe//hU6pN+adZIXKSS13koSpNSaiRuZK6oLhXH65QJiUzc6Zdp+qgsv2zOpJ/P76PKAnN2VwMAAJi/oSVLRGp8ZkNYI/HX+sambEuLknUktV5xrtaQanQ1pMSvOTf8Zi2sIc3XXD09MKq9r3ifn2SboYZk1g7mc1UjZTqY9AMAAIsw7jiR8N6azuEJEf05MD4t9o1YjVpMiregZdylMmxiUYu1RXEai1q1JYpgW8DJzo1YLja6lYasPrrKvNz1ZHLv1QXMa2sjO3O2NVXTQ4c7M7KgxTidTvr0pz9No6Oj4hgAAMDiRe4aEftqwgWbxrIi7evdI/alIegn/dwJ3bu7Ria1vcepFE7UglYiiQzJUFNcQH1j02IX3oR3horm0RCcFOGZ8lFFBc0pLHEieyKR8cnCmro7ynXmvc38eWZ5VYk2BcG/b2yopFfPDGTkvppM00fc9PMH9dHyQQpSaX6kSAgAAMAC43jYlMPwpJ+EaxVN5ZGPrWLC5xeTiEwi93v1eZhtjEqn7qhRakgDcaQh8OuSGwjaVkOaL97TuM9PslVJ1ShxZ94UXaZppEwHk34AAGCji52pU5p8sjhhNaoISMQdVWlyfFUy8RDJUF0cueYD8zjZ2eX+qQdeon/87Qv0g92n5p3aTCeqMI416ceudY5mkGxoqBA59hzLcOnKeso08vLy6IILLqDzzz9fHAMAAFi8yPsqN7Tk/l6OaJJTXN2jE5mx0y/fnr3Hxn016USNQOfYsFg8c7KbPvC/z9AnHtxLh7s9c15Lfv7p1HJGHWa8zmq0p5qEwLxuU4vQR0sqimh5VWY1rzJNHxU7i2lWm03geDK/aK7WFtXael4AALBYV8Qw9UoNiQ1GtpuiklwRY0rTTzkPy9Ki5tFHbIj6+hP76aO/eZ6++OfDWmN0KINqSHKfnxp/zvDamytW1Ys9f1euNmdf9LmskTIdTPoBAIDNgk3nZB+dpK1k/c6aEcVBnsikn5mCjQsIsqiV7oJWTRyCbV/nIP3n0wdpwhtyN7/S6RHZ5xzZZbVgi3Wded/OYNgxtrKmTCuUSif7PTfvEEUw40JmAAAAIFMIxoiH4omthtJCarV5Z408N76XJnI/Nd67U9l7rDYe066RDHuPl1WV6L7Or8NPXzxOjx07Kz7mUtbTp7qF2Yi/JqcSE4n6Mi0CfWKaCl3FcwtaNfqmH+9D/MFbrxK6yYrGZDaT78wPvchhvH4vufPcVFVoz45NAABYTMQyG3NalN0R6Gr8eSITdvOtLknqPGRaVJqn912OPGFIY50TyzjeMTROX//zfuoZDX29c2SS2obGxG7jTKkhcd3teNgYxddLHUJgPnD5RnrXznWoIZ0DYNIPAAAsQr3Rqo21TNhZo9tXk4AAMbPpN+0P0EwgVFUoTXMcFIsbuZTY2PRjEfTrPafpy4/u1Rp+TJBm6WT/qOX7akKPESnAqTtrTvbHLmjJgmmmNvw4g33v3r104MAB5LEDAMAiRuw4CTcVjI0iWdTir/fatLNGaqREI6PMLGpxVKWkrCC9cUaqk73PoJG4CfjZB1/WGn6SY73DtiQhGB9Hvc6yoBVt0o/hBnImNvwyTR8VOOXeqND/pJP+SSp0FlJVAZp+AABgXw2pUGcct3vSLxGjj9l7j6VG4vUw6b6vcwQ645n0CaOTyrOnukVKlGz4GTWSWsexwhjF17lA23vs1b1fZJ1rdU1Z1Ph51JDODdD0AwAAi5CChu+p6hJm46RfNkUzqM+Dd7qkgn5fTXoLWixsZCY7u7RkIYN5vrWXfrO3VTM1q84nTbBNhgSbIzfHkl0w5YUu4VwLPXZEsMkmpHEBczbg8/noU5/6FH3hC18QxwAAABYn+vhzvQbhST9Jrw0aiQs6vNsu0SQEY0En1b3HVsZ7qruljU72e58+RKcHxsQxx2PKa8IFLm7e6lzsSqyU1fFVPD16emBUawpyXFW2kGn6qMhZRI48B80EQzp93DdO1YXVlO/InmsKAADn2oqYYrdTTJ3ZaxxProakPhe1DpX0eYQ1Urp3Hhv3+rERStI+NEbfeuYw+cKNwGg1pFj7GdOJfByuX8ma1yldDWmuKSqTyTSNlOmg6QcAABYxPBkRI2oMI4s16cCxa6efKtgSKWqxS1o2vVTnUiZnsUuqi0JCjKcL1Ybj3s5B7fgvz1tO/3LjeVGafpF9NdGcUWbjyI1cZ1UsdnjGteOllfr4rUwnNzeXli9fTkuXLhXHAAAAFidqQ0ydbDc2/ezYWTOcZHSVce9xqk52VaeVpFkjqQ2yAWXSjyPOj/QMa9finpsvoMuUncFHe4d1WtD4WqaLaKkTnOIwHd7vZ4wnzXQyTR/xVJ87100+v0+L96wvqSdnXvpNbwAAsNiRNaRo02Fy2o+nzvgebfm5qU2/JI1RfK/mHXjJwn/e5w812qwwY8fa67f/7JCWWnHpijr68i0XUaErT9NH3HCL1cBNJxVhkz7XvCbC11mtIS2rDEWiZwuZppEyHez0AwAAC2DHsSdcODLe4MXOmrJC4ZwesGlnjRRs3L/iWIREYAc1Ryrwz+DnmWykgpUuduPOmv7xKU2onh2ZEL/zs3j9pqXiteDn2DfmpxP9I0JQyzgEqxxaocfKF81Jvs68DJobx22DY5rAtSpGyyxcLhf9x3/8B3k8HnEMAABgcRJr5zFTb/POGrWgpaYbWB3vqU9DSH/Tj6UcF6/UgpbadN3WXCWaaewc//2+0OeO9Q1TldLoszPeU+ojZmmWFbQyTR/xpB83+LxBLxXNFpE/6Keawhq7TwsAABaVRuJ/+5e49XUariEdD++v7R2dstzkolsRk7Axypy9x9bXkNQ0hIhGkjUk5qaNLeR25NHqmnJ6paNXaDhORJAahZuBHL1peRrChFdMiKoaaVmWGcczTSNlOmiLAgCABYzOs69GdWnN2hRfJafsuJCUaNNOFsG4ETWuFKUSPgflz6Z7px9TrWv6hQQbO7BkUYujG3hZMzdl19WXi895/UHac2ZA+3NWNtrkY/H7iCcP2PUvr9nSimJLJg4BAAAAu+I97YhAV1MIUtnpl/KkX7ioxbf6Ind6C0VcWJSag01Rkq7hSEGruTwUTb+mNqSPZBqCjD+30hila66Gd9ZkcxJCplHgKCCXwyUm/Dji05HrwD4/AACwCNU4bvz3vrrXr0tpOlnFyJS6bzixe77aJExFI6lNv0R1Wuo1pIhGOqtopMawYU3WkKQxyhPWKFYlIRgfS0Z8So3EiWPlWWYcB4mBph8AAFgo1qIVtIxFrZ4x/f6UdMPTeTK+KlGHlvH5pOJklwUtRubTWzXpJ11afP4yDqpJ2bW4Vilq8c4/q2MZornhODde0pJlLnYAAAAgWrHHOE3Hzm+pCeyIQFf3FSc6YWfm3uOxsEZiF3uyiQrJ7PUb9/q1yLBOpaDVFG76sWO8Mfy9rYNjutfIKo3E11leEvleUjVStkVXZRq8z6/YWSwafpMzk1TgLBA7/QAAAKQXToDiRKVY91RdDWnU2hoSI2tIbBZK1JBkrG0ky6jFNaTamMbxkEaqKnJrU3xrlX15r3T0a/v+rKwh6Q1oPpFgoRnHYYo650HTDwAALEA6j+MRbFYXtca9MxScTc6hJWMnozU3U3Jp5dvj0ur0zC1oMWvrIoJt39nIzj8rXVoVajSDaPqpWezZ52Lnxct33XUX3XPPPVjCDAAAixguQsw3Qc/xVQwXKqzeWaNO+iVqjOJ48FIT9h5zMUlqJCsKWsa9foPhopYaXaUao1ZVl2hJBAe7hyxPQ+Bio3xtpPlMaqR8Zx7VhJuS2UIm6qMydxn5Aj6a8E2I49L8UrtPCQAAFln8+fzGcTvSEEZSSItS0wBSa/pZF3/OVEUxjrOxa9IXMo43l0eMRqtqysiRmxOlhmTlihi1hjStM0VlW/x5pmqkTAZNPwAAsADV4R013rPMPsGWSkHLzPgq9TyszmPvj1bQUpp+SyqKqcCRpy1Bnk98p4tzbdIvGAzSwYMH6ciRI+IYAADA4kR1ikfbK6zGV/HOGjvOjUkmAklqJLn3OBmmZgKa9rCioGVMQ+iTGik86efKy9UZp1ZVRTSIPE92/HNEulXI68xakn/JQlxLRbElk5Hnuj4qzy+nmcAMjc+MU31RPbnysEcHAACs1CDRGkX1pQW27T1mTSOTmspSrSFNmVNDKrFAI/EUX3F4qlEax3XRnuWFOvPX0nBNSV9DsmvST28cz8amXyZqpEzGms2RAACwyFGbYZULRjNM2hddlYxgU/6MOtGY0k4/C5zs/FzZeeUPzmrFoa4YLnYuGK2sKqajAxMxpxzTjfq+4essBRs/h0blXLMFp9NJH//4x2lsbEwcAwAAWJzI6SwuTERr0DQadtYsqyqx3MWebMONoyfbaVzbe5zMzmJddJUF+2qMxijWSBwx1huOn+ddNerrtDo86adiZUFLaqTTNCZ2Y+/vGszqglYm6qNidzEFZ4M0G5il+pJ6u08HAAAW36RflEQmNtdwnOTghJe6RiZFMoBx71+64NhR6WVKxjiuRqCnUkOyekUMU11cQOPeMaFf/cFgzBqSTENoH9GnPVi18zhaDWnS58/qtKhM1EiZDCb9AADA5n01xp01LNisRHVHperSUt1oCZ9HWLCx05+vR7rhgpV0qrNLi0Xy2eHJqJN+anyViqXRDMpjceFNTiXyebKLLNvIy8ujyy67jHbu3CmOAQAALD4W2ldjTEOwemcNT+ilppFS33ts9b6aaBHobEiTxT2jPqosdM3RQ1UWxp8bTVh7OiNNv5YsLGhloj4qdBYKncxgnx8AAFjDkBJ/HksjSfM4N3PGvBETtZWmqNKUJ/185sR7WmSMqg1rJL4tciNNnfRrNtaQlDQEO2pIfE1kH1hdEePMy6GGLDSOZ6JGymSyr0oIAADn4KSfurNmxOKdNWpBKxmXltlLmNlJb5VDrTpcJPL6gzTu9VPn8LhWpDM2HqMJNruiGXhnjiy+ZaOLHQAAADCahdTkgEzZWSOLWhxXmYzBxoy9x/okBOvjPQcmpnUFLWPTjzWbuvvY6vhzo0ZS9+Ysg0YyhQJHAQUpSG6HmyoLKs35oQAAAOI3jsdljJq0Sb8lXhNhTVUSNjKZUUOyUiMZ9/p1zqORVkZJp7By0o+N7vL16Rub0nR0U3mxMNuDcxs0/QAAwAKkkIm1r8a4s8YuwZaMO6pUdQ8lGc3A7mFZWJPizwpqSiLxVacHRkXjL1osgywcqcKI3fZWTthxE9LlCD3eRPg8maVZ6GJnOIOds9iPHTuGPHYAAFik6KKrYhS06koKSN59uy1OQ5AaKdldembsPda56a0qaBXla9e8f0xf0IoWKb62rty2+HPxeMp1lhqJtSnvZM42MlEf8aSfM89Jxc5iTPoBAEAGaSTVGGVlYlSqk36MbEbx80x277FMreIyTZEFaVHGCPS+8SnNGMX1oWK3vpbF+/+M03+VlqchuLUd0dluHM9EjZTJoOkHAAAWCjaepIu2r8a4s8bKopZuX00SLi3VPZRsdNWEz0/BWWsLWsb4qr2KM9zo0GJcebm0orrUtn017KSPNiWarYLN5/PRP//zP9NnP/tZcQwAAGDx4YkjukrsrAnfr9mhLGMG0w2nLnASQCqRUWbsPVZd7FZFV7GpqTw8rcfxnrp9NVE00tpafdPPao0U7fG4EOp2ZF/0UybqI570c+e6qbqomvId1hYrAQBgsTKcQFqU9cbx1NKi1Hu33HucShpCqYVpUWoaAsdlynOIpo8YNQ2BTeRWmtyZ6DWk7DSOZ6JGymTQ9AMAgDTDy32lEJivCKJGM3RnqWDjvTz8fLOhoMXUKE70vZ0D2nFMwVZbZksW+3zO+WwVbCzKGxoaqK6uzjKBDgAAIPtc7HbtrBk1QR+pEU7DpsR7Wlcoqg472fnxWwfHNCd9fWnE4S5pqSymAmeebRqpqujcMUVloj4qchWR2+mmppKmjDknAAA415Gx4G5Hru4emwkR6COm1JBS23ss0qLkihgLa0hyRUz8NaSIMWq+IYB0ES1ONFvjzzNRI2Uy1sy+AgDAImZYcbHPVwRJ56TfL189Rc+c6qEb1jXT6za1aDfIIz0eOtY3rC3zLUoyEkEKttmwAORYqOwoaEXOs2d0SjuOFu/JrKsrpwcOdliexR7r/cNFLmOERLbgdrvpv//7v8nj8YhjAAAAi4+4m35lhXSga0hzspuVCsCa5UuP7CGnI4/evXMtLQvvXuGYqT8caF9wl85CqHtuko33tGNfjXSyn+gb0Wkkfh0cuXN9w1zAWlNbru3Ts7rpF+29k62mqEzUR0XOIip3l1Ntca3dpwIAAIsGmRDA97hYDQ6OmmRDDqcm9YxE6hlm8NSJLvrVntN0wdJaesuOVdpqk97RSXq+tVf7vvIk0qKM9+6QMSqx+zbHVfKUoB36KJEakhqBbnX8eaw40ZYsjD/PVI2UyWDSDwAAMqSgVVdaqO1PUcWDGfFUv9/fJpYM3/fySfraE/uFU54bfl96dC/5wtFVl66oT9otoz6veFxavET4/gPtNDgxbdu+GqZW2emnEsultaWpipZXlVC+M4+uWNVAVmN8/2Srix0AAAAwaoZ50xDStLPm2VM91DY0Lppbn/7jS6LAxQ2/7+86Sn8+3iW+h6XRxcvrkvr5yew9frGtV5yHjDFVJw7tKmotVNBibtqwREShr68vF5N/VlLgdMyZgoBGMg+Xw0WbazfTsvJlJv5UAAAA89VwuKm1kD7iuEiuI0lTVLK78aLxu/1tNDjhpYcOn6HP/PFlUcPhht89f3pV02+rakqjJgDEQ2WCNaQJ74yoIbWF0wf0NSTrjNBFbicVuvLiriGxnrpkRR05cnPo2jWNZDXqRKU0vvNzAOc+mPQDAIA0owqY+Zzi7JzinTXcnJM7a8wYWR8cn9YW9jIvdwzQJ/7woohCkA2/bc1V9O6L1yX9GKoQXcjJzgL2sw++LPb4vNDWS//2ugtozKZ4Tz5v6YyTFLkdMUUjv0aff/0F5A/Oak43KzE657PVxQ4AAAAY99Wo+++MNCgFJTN31vSORX7WTGCWvvPsEfrjoQ464wntsGMZ9sErNtLqmki8dzJ7j1kLxlPQevZUN9379GFxzNLkqtWNWnQVF4tixXulM95TpXGept/W5ir6/luvFOdpR+QSJzCcHY68ntBI5nLNimtM/okAAADiSYtaKD6TNRInRfkCQVGLSTR1KRrcPOwfixjROeb7X+7fLcw9ch9zc3kR/dO1W00xji9UQ+La2Fce20fH+0ao2O2g//irS/VJCBbWkOSEJe/zi6fpx9fnQ1duopnLgjbVkPTvB5iiFg+Y9AMAgDQzFJ5mY6oWiDvS7axJcpmxkX7l8bXPjU/rGn4fu2ZLSgIkEcH2+31tmlA8PTAmxJIsaFnt0uJinFEUs4t9PuHKX7NDrJ1rk368ePnuu++mL3/5y1jCDAAAi5SBsEbhfTWF80SM63bWmDjpx0YrI8aG3yUr6lN6jHj3HrMpihMZJI8fO6uLQOcpPyubaereYwkX+OaD9ZFdO1bUKFXWksnuGLIb6CMAAAAyEYlZqImXjjQErumoxmhmwuvXNfw++ZrzUzJsJ1JD2nW6VzT8mHGvn15q7zfUkKy95xtfEzZlzWdeYzKnhpS9xnFopMRA0w8AANIMRyJE2yEXDd6VYvYiZrWgdcuWZSKeUmJGw884gTafYOsdm6IHD4V24kmePtVt2OlnsUvLEPG5UEHLTox7BLNZsAWDQXr55Zdp79694hgAAMDigl3bMvKS9dF8zSKeOuMIKzP1kWqM4um091+2Xuw3NrPhF23vcSw4skoW05iT/aN0dnhCc7Jb7mIviRLvmSUaifWRXc3HVIE+AgAAkEjTr0GZwjcrDYFN4pIrVtXT9pZq7WMzGn6JNP2mZwI6UxTzzEl9DanM4hpSrUEjsT7KVN0xt4aUvcZxaKTEQLwnAABY5GKPZ3FvndKA4gaZuvTXDMHGe1Zu3bacHj3aKZYev2bDElMcR/E2/e576YSIxlR57lSP7nla3vQzTvplckFLuc68VzDWTsJswOFw0B133EFjY2PiGAAAwOJizDsjoqiiRQ8Z4YYf70Thncesj8yMQJcFNY7SXFVdSk+d7Kbzl1TT+voKMgNV+3HEZ7TiXf/4FD1wsH3O53mPjoxot7qgVW04zxyDOS3TUN9D2VzQgj4CAACgGserDE2beWtIo5FIzlQYGI/8nJaKEnrtxiViDzIbr7iGZEbNhpuGLOVY5wwppicjrI+MEemHuj1Up0S/W5kWxVQXFWRNDcntyBNpGpwmlu3GcWikxECVDQAALHJp5UTZyTafYONFyWYLNs4e5ybfaze2kJmouwpVl7rK4W4P7W7v10TZ8qpS2nd2UDi09nYO2Nb0M05fNmZwQau8wC2iI3ip94rqUhFPms2C7dprryWPx4OmHwAALELklF88SQhMXUmhaPpxPDlrh1Qd5hPeGXE/VR+/uaKY3nrBajITNWYyljGKHey8U5C5bGU9PXe6RxTBnjrZpX1PicUFLZcjT+g16aTna8SFo0xFbUiuqimlbAX6CAAAgDrpt5BGUmtIbCIyA9U4LtMYLl/VYOoLo+49jqWP+DpwEkLo+0kkMHDzkRXT0ye7M6aGxCtiMhmucXGCBOs6NtFlK9BIiYGmHwAAWCTYOJZpoam62nQ0/RIsqiVDkcshIrG4YBVNsPEi6J/uPq59/Dc7VgnBwU0/Rha6XI5cMcFmJcZr0lyeue5wnnR4/2Ub6IW2XnrD5mV2nw4AAABgUnTV/KYoY5QSa6RUm37Ggla6WCi+6kiPh15o7RPHrI3etXMtjXvZEDWo6SM7Jv2kWUw2/TLZxc5cvLyOTvaPkCsvjy5YWmv36QAAAACmpEVVLZCGwAkCcmKO0xCsbjqmQnmhSzT9Rqd8Yu+xIzd3jilKpkLcuGEJvWZ9aOKQUTWS5RHoxqZfhmukv71wDf3xUAddtbohq43jIDHQ9AMAgDTCwmU4PPkWT0FLFVR94+ZO+nEhKV3Lg9n5xUWtvrHpOdELMnO9fWhcHC+rKqErVjWIRqDqILeroFVbHGm0uoyncKsAAJzGSURBVB25cb1OdnLRslrxK9vhPPa2tjYaGRmhsrIyyjUIfAAAAIuooLVA/LlsQKlNv9W1ZeYVtOJ4/HRFoKt7av76/JUigunylfWi6aeSapMz2b1+pwZGs8LFzhr33Revo2wH+ggAAIBMQ2Bj9UKT/mwMZh3DZqY+kyLQVWOUcR2K+caoMW3vsaoHTw+M0q7TveK42O2gW7cup2K3U6ysOdIzrPs5Vsd7qpo0G5p+rJnvqN1M2Q40UmIkVGH79re/TVu2bKHS0lLx6+KLL6Y//elP2tenp6fp9ttvp6qqKiouLqbbbruNentD/4NKOjo66Oabb6bCwkKqra2lO++8k/z+UK4sAACca3BxZzaBglKB06EJFjMm/WYCkaajUZiYjRRonBUu88IlB7qGtOO37Fgl3EXs4rp0Zb3u+6yOrjI2WhvLMncB87mGz+ejj3zkI3TXXXeJYwAAAIuLgfHEmn66NAQTjFFWTfqpO/3Ux2RYL3HcEtNUXkhXr2kUxzypVujKs18jKeee6QWtcwXoIwAAWNxw004ao0JTfAvXJ2TEJ8eWTxhqMaloNFdeblr1R9U8GkmtIb0x3PBj2ECuwo3RfIvjx7kJyYZx+fjZHJmZTUAjpbHp19zcTF/60pfolVdeoZdffpmuueYaesMb3kCHDh0SX//oRz9K999/P/3qV7+ip556irq6uujWW2/V/nwgEBANP36Rdu3aRT/5yU/oxz/+MX36059O8LQBAECP1x+gPZ0Dc5pNGVXQilMIyKIW78bjpl0qDE1MR5qOaRYi9aWRXSq84FlFfsxydV1dufb5K1bqBZsdk358XZZUhApZFyytsfzxFyv8j5fKykqqqKhAoxUAANLI2eEJOt6nd0RnAolO2qk7a8yIr1I1WjqLNXzeslzXY9BH6sera8q0yCWeWuO4ShWr99Uw5y+p1op+W5oqLX/8xQj0EQAAWAMnD+0/O6jTI5kA17Sm5c7hOKfsak3USKLpGNZIcp+fFTUko0ZSa0pqDenCpbVCl6j6yGrjNj+e1Eg7WmoQmWnhdUcNKU3xnq9//et1H3/+858X038vvPCCaAj+4Ac/oPvuu080A5kf/ehHtH79evH1nTt30iOPPEKHDx+mxx57jOrq6mjbtm30uc99jj7+8Y/TZz/7WXK5rP+HDADg3OC/njpIL3cM0IrqEvrc6y7ImJuujGVIRLBxcUi6vnnaLxVntS6WIc1NvwZVsI1M0srq0jnCs7LIrYsYXVpZLBpuZzwTtmSxM/xe4fdM98ikOB9gDW63W5h/PB6POAYAAGA+/eNT9M+/f4GCs0Tvu3S9NkmWCQwqGim+nX7m7j3un4j8jOo0piGw7uGiGWsy1hpq7JZa4FJ1FHP5ygZ6/FiXrfGe6+sr6Ou3XSySKOx4/MUI9BEAAFjDr/ecpt/taxP3t/93y05bJuoX1keJN/1YI6m1mEQZm57R9uil2zjeUBo5b9ZIKqrWU5uDHIPOZu3nwtGfdumT26/YRK/bNEYtqCFZBjRSYiS9QIen9n7xi1/QxMSEiPnk6b+ZmRm67rrrtO9Zt24dtbS00PPPPy8+5t83b94sGn6SG2+8kUZHR7VpwWh4vV7xPeovAACQcPHkULdHHJ8eGKMnjkcKJJm1rya+xoZuZ02K8VXq46ddsJVFn/Rj0Tjh9c8RawwXvdR4Bjtc7IzbkSd2DSLaE2Qb0EgAgPk41jssGn7MfS+foHFvZI+u3UhnPRfZXHHEMnGRp8jtiBoBlQzSxZ5j2LuXTo3EsVvqLuMepaBVZ9BIa2rLdNONVu+rkbB2Q8MPZBvQRwCAhZA1JN4l9+u9pzPmgqk1HDZNx4Nq8O5P0RjVP2GhcVzZFzxn0i/cBGT9wxpQJRNqSLxLcUV1qVhbA0DWT/oxBw4cEE0+3t/He/t+97vf0YYNG2jv3r1iUq+8PDJyy3CDr6enRxzz72rDT35dfi0WX/ziF+nuu++e83meDuDmIwiBZmh6wHXN/OvKmeVj0xE31P+8eJTWl7vmCAM76BzwkD8Qang5Aj7x99ZCFOUGtD/T2j1Ay4rykr6uHX1D2s9yB2fievxkKZydiZx37xB5PBXi+PTQuPb5MmfOnHPYVlNIf8p30Jh3hjZU5qf1HFMBfxfgumbi+woaKf3XGODaZvN7tq03ogOGJ/30s+cP0Zu2LqVMiNTqH52kIM1SicMV972/wp1HI5PT1DcyQf0Dg+RQ0gMSva49wyF9UpHvovHREUon5c4c7XU41tlDq6tL5rw+rKOM1+E1q2vpRy+dprU1JZTnmyKPJ7MiyBj8HYvrmonvK+gja64zwHXN5vdrl2dMuwc/dLCdLmwooUZl8swuOvoGtfPKp0BcGqlAqcW093vI4ylL+rq29US0SUFOMK31GcfsLM0GAxSYnaX2gWHtsXh9z8B4qOlX4Z5bI2oqyKFVlYV0YmCMzqsrRg1pkbHY712jcT7/hCvia9euFQ2+kZER+vWvf03veMc7xP6+dHLXXXfRxz72Md2TW7JkidgDVFqa/MjyuQhfE4Drutjer0MDo+TIi/x1Nh0geqLdQ2+/cA3ZzWSwXTu3FQ21VBGHk3zFNJEj74w4npjNTfg6qd8/GezWHn95Qw1VVISKTOmguLSMnI4jNDtL5PEFtfOYHJyOnENdaIeb7nyJ6D/ffAX5A8G4nP52gr9jzYP3+37ta1+jqakp+td//ddFG/Gdl5faex4aKT7w/276wLXN7Os6rugA5pm2QXr9ttUpRYebNeWXm5cnYmcaKkvjfr7NVWXUORoyegVcBVRjmI5bCPk4Pn+AJv2z4trUV5Sk/X28vG6cHG2D4nhi1qE93vBM6ByY1c31lO/U3xNeU1FBV29cLnbXZHIaAf4eMA/ooxDQR9aB/39xXRfj+5V1wPhMUKeR/nC0l+66YZvt99tpGtTOa2ltVVzP2VFQTI684+J4dGY2pRrS9Nkx5fHn1m/MprmyhM4OT9LQtJ/KysvF+pW2QeUcasqjnsM9f7GTvP7gHO2UaeDvWPOARkpMIyXc9OOi3KpVq8Tx9u3b6aWXXqJvfvOb9KY3vUlc/OHhYd20X29vL9XX14tj/n337t26n8dfl1+bL7MV+34AALGIttflocNn6Lq1zbrISTvz2Hn0P95oJDN31ujiPePMg09pZ01ReGfNaGRnjbpI2hjvKWFhl+kNP2AuwWCQnnvuORENzscgOaCRAADzYdQRHPX5/+0+QZ+4YVtGRHsmsq+GqVUj0MemYuqKRPRRuqOrjPv61Aj03vBxRaErZtGKI8jB4gH6yBygjwAA89EXJSb8QNcQvXpmgLa31GTOTr84NUqx20EFzjwRI27miphENFqy1JUUiqbfTGBW6ENed9M7T/y5hGtNmd7wA+YCjZQYuWZccM5L5wag0+mkxx9/XPvasWPHqKOjQ8SBMvw7x4P29fVp3/Poo4+KaT2OCAUAgFQLWi0VxaG/m2aJfvZSyOlkJ1Iw8a4YbmzFA+e2c5OQ6RubNmVfDQvAInf6d8HIJuv0TEBk4xuz2euVhiZY3DgcDvr7v/97ete73iWOAQAApE8jceS53C287+wg7e0csPVyS32SqCmpRjVGpbDXL9nHTxbVhCZ10aTPr+33S7Z5Cc49oI8AAMCeGhLzs5dO0EwgmEHGqPh2+nEDTJrHWeME5ELnJBhQmobcgEs3jYpGknv8UEMC0YBGSmPTjyOknn76aWpraxPNO/74ySefpLe+9a1UVlZG73nPe0QM55///Gd65ZVXRCGPG307d+4Uf/6GG24Qzb23v/3ttG/fPnr44Yfpk5/8JN1+++2Y5AMAJE2/IkreuXONaLAxr54ZFG4tu+DG14Q3lIVenYCLnJuD8vvZpcUTc8nuy5GCMZHHN9vJ3jMaen1y5nFpgcUp2G6++WahDdD0AwAA8+Gi1VDYLV5fWkB/syOU1sLwtB/rhIxwscdZ0GLqlKafnJJLBk4lsHLSj3WYI2zoilbQUp8XWNxAHwEAgLU1pJs2LqF1deVa7eLRo522vgTSmFQkpvfiN8fKph/3+9TGYbKPz571eNbTpIpqfJK1I13TDzUkEAYaKY1NP57Q+9u//Vux1+/aa68V0Z7cuLv++uvF17/+9a/T6173OrrtttvoiiuuEJGdv/3tb3WZow888ID4nZuBb3vb28TPu+eeexI8bQAAiNAbFgZMc3kxvXn7Su3jF1pDEcJ2oAot2YhMNL6KG4dj3pALPFGGp3zkDzu8rChozXWyhwXb2KQ2wcgRoAAAAABIP1y0mVUKQZcsr6PVtWXi466RSeoYGs++eE/dpN+UOZN+FmgkNnTJolXv2KRouKoFLdU0BQAAAID0osZHcu3lHRet0T5+3sYaEuuDocmQMaqqMDF9YoxAT5b+sEZjfSYTqCyb9Atro3hWxAAA5iehPK0f/OAH8349Pz+f7r33XvErFkuXLqUHH3wwkYcFAIB5kUUfjrDkLHM1g13dm2JnQSvRglJtSb5OsJXmx7cPMFYsQ7UFsQzGolXXyASNTc9o044oaAEVnmDt7u7WdgHbvTAdAADONdSCDxeC+O/Z85dU04m+Ee0+vayqJKs0Ek8F8u2ChxT7U4hAt3LnsaSutIA6hye0nTU9ceyrAYsP6CMAALBYI5UUCC3CGoOTCLiGxH8X2/HvU16RIqM5E0lCYGqUGpKaaJAIUzN+rX5jlXFcberJNAT5e2m+U0TUA8BAIyUG/s8BAGQ1LIikW5vFGgszFgUsDnhPytnhiQyJrspPeJmxKkhX1YSc+Zm8r2ZuNMOkNuUni10ASHgf8Pvf/36amZmh3//+98I4BAAAID3RVXJCLloMtx0MhDUS19PKC+Ivajlyc4Wm4WKWeZN+1hujuJjVEy5oyfhVABjoIwAASD/SOMSTbJxIJO/TXMPhphebl0sLEjdem5qEkGDTTY0KT3bSb1DRR4nWsJKlvMBF+c48kXLFNST+nVOrGJiigAo0UmIgZw0AkNWwKJI7itXIp6byIvE7N/4mfSGnktWoLvJEBZNu0i9Jl5bV0VXycZx5OVq8p76gBRc70FNUVESFhXhfAABA2qOrwhqpSY1QUu7RVjMU1kgcf55odJR8LlyUG08yAl02RDkhggtNVkegc8NVN+mnmL0AgD4CAID0TgtJ4xDXLziCm2kM15CYLpuMUcnGnxvrYRwlnkq0p5WTfmzcl7Uifl3OjkSM+w0wRQED0Ejxg0k/AMA5FV0lYZfWkZ5hLb4qmUk5cwVbgjv9THBpqYLNqqYfC2YuXHF8Fbu01CkCxHsCFZ7s+8UvfkEejwdTfgAAYEF0lXRMy3hM3utnBz5/QJiymMokXOT8XA51e7TmXbHbmXBKhNyXY9WUn1EHsUbqDWukisKQwx0ABvoIAADSC0/x8TRZtBqSaoxaV1dua1pUdaLxnhzlzk1NoQGzxzgum3ttg2NCn+4/O6h9HsZxoAKNlBiY9AMAZDVqtJPaKNO5qW0qaqUSjcCCLdGm38sd/fSr/R00HC5kqYKtxqJoBjWiyh+cpYPhopwxbgIAAAAA6UXqB27ySfORMy9Xc27LnTXZVNAyOs/jKWrxfppf7zlNT5/uE8/XM+kVRSXjz0o3ajHx1MCY1vhEQQsAAACwjl6lhqTWKBqVGhIbx7MtLYo1XkWhe07E+3yc7B+hX+xtp07PePjPWb8ixqiF9nRGmn6oIQGQPJj0AwCcE1nsxkhMvWCbtFWwsXu7KMHlw+xa592EHE0aT9Nv1+ke+s+nDpE/4KfWES/dc/MOrenHcZtW5tGrgo1FJMOOM+SxAwAAANYh48G5aMO78CQNpUWiWcYud8+UT0RsZkt0VaI7a/zBIH39iQN0oGtIaKSCwiJaUlFki4u9TNlZI/URg4IWAAAAYB39UZIQjMZxu2pIqe7U4+fDaQZsLGLTU4Ezdh3q9MAofe6hV2nS66O9PaP05TdcRANKs1A1oltpjFI1kvqaAAASA5N+AICsRs0q1wm2UjWP3XqXFjvJh8JOdnbXc055osjnw81DLlrF4njfMH3n2cPaxxyLcN/LJ7SmI4tFmVNvBY1lkWsvnfS8hJqdZwBIZmZm6Bvf+AZ9+9vfFscAAADMg3fdyZ3Gqj4S9+lyNQ1hIqtc7IlEoLMW++Hzx0TDT/Kzl47Tq2cGbHGxqztr1AFLxJ8DFegjAACwcudxvk6TuMI1C3VNiR1pCFy9qUwiDUF9PvNpJDaIf+WxfeTzh+pM3CS89+lD+kk/K9MQlOaeqpGw8xioQCMlBiqwAICsRsY65RicSDUl3OiyL95zzDtDvkAw6YIWUxsWWSx61CgsFd4H89XH99NMQB/P9dDhTi2n3sqClhrvqfscoj2BgUAgQI8//jg9/fTT4hgAAEB69/lJGg07a6xGmqKSLSip+3fUmHcjDxzsoD8f79J9jvUSfz6Vx091Z40RJCEAFegjAACwRyPlKuYcrrPMZ7xOtzGK0wHUlIZ4UWtiagNPhU1hX35sL41M+XSf59UsJ/tHxXFpvtNS03a0qHM+B06/AkACjZQY+L8HAJDVyKxyzi5XRQkLJC6icDGrZ3SSgrOzlk67qQWtpJt+Bie7Mf6JXfxffmyfWETNbGqooDWVBfTbQ/oCl9UFLXXST4J9NcCIw+Ggd73rXTQ+Pi6OAQAAmIe6y8XY9NPFV9ngZNdP+iXuYi/Jd2oxmbFc7C+09tJ9L5/UPn7/Zevp/n2nqWtMb6Kycqcf0xBVI2HnMYgAfQQAAOlFbYapRiKpkTo84xScDa2SsTJeciYQ1BpxydZwFopA50bmN/58gDo9oaSHutICet2aOvrhy22k2sitjPaU6224ySf3HTOoIQEj0EiJgSobACBr4YxyKQpYrBhpCDf92NXN8QXGolcmF7SMgo0jKDYbvv6LV05qDv3m8iK64+rN5J0Yo87xGdrd3m+bYCtVinGSaK8PWNywYLv11lvJ4/Gg6QcAAGlKQmBqDYUjtfHUNWx900+3068wP6mYTC7ScVGOC3dGYxc72L/73BHt4786fwVdtbqR6t059OWnj+n0SXVRgf2TfiXYVwMiQB8BAEB6kc2wIreDitxO3dcadXv9Jixt+vEuPkky0Z6MWvNSY0wljx87q8We8/P/+HXbKD/opWF/Dv1mb6ttxnGGTfuj05F9fjBFASPQSImBeE8AQNaiOpeiObVVwWZ1fJWuoGXCpJ+6bFpyrDckiBy5OXTndVuFYOVC2PsuXa8TaVYLNj4H434a7KsBAAAA7N95zFQUuIQ5h+m2Ye+xTENw5uWIqb1kkDtrAsFZ8ihFMqZ9aExr7O1oqaY3blkmjutK8unvLl6nfR9fg2K3tR5Yo2u9ojDyWgAAAAAgvfCkmzRoRzNHq3WLLotrSENKDak6bTWkYe34w1du0pqat25bTuvry21LQjDGzzOY9AMgNdD0AwCck/tqjDGTVsdX8WRhqk2/mnl21szOzmrRXTUlBbrnz80/nvqrLHSLCbsdLTVkNUZHHPbVACP8Hh4cHKShoSFxDAAAIE2TfgaNpJpzeFKO46Ssgv++l8U21kd8LsnA2idWfJUa27WhvkL3GJeurKdbtiwThqmbNixJ+vGTxVjAQkELGIE+AgCA9DE4Pk3yn57SQKTSWB6pIXVnYQ2pvMAlTFWx9h6rGml9fYV2zIkJt1+xkVoqisUE4JWrG8lq6g01JGgkYAQaKTEQ7wkAiBtZFLJyoW+yWezGxlP3yIRtk37JurR4Qo/lGmvS3lG9YBv3+snrD8b8+SurS+mbf3UJ5eXkWF7QMjrk+NGN+wgB8Hq99M53vpNmZmbo97//PeXnW+8mBAAAMyPH8x15ttxzoyELPTxFVmKIrpJpCK2DY6Lw1Ts6Sc0VxZacF0dvyim8ZPVRtAh0tXClFs2ipR28aftKuu285WL/s9UYd9ZAHwEj0EcAgHMJjuDmOpLbkRlT7X0L1ZBK7UuL0q+ISU4jiQj0kgI6OzwpTFHGCHSpkULNQb0O4sf84hsuFMfqn7EKYzoU4j2BEWikxMiMyj0AIOPhJtY///4F+rv/eYraBscoE+hdaNLPVsHmTXmnH4uwqnCxyujSklN+80UvcDHLruKjKtj4OWRKoxhkFnl5eeIXAABkM08cP0vvve9p+sLDezJicpkLPDLSiQta0bSA6p62Mg3BjILWnKafwRilaqZYe43taPhFu/aIPwfRgD4CAJwLcLPv3x56ld71syfp+dZeyrQaUjTjTaHLIcw5cqefbcbxFOI15fOaCegj0Pn1GJ7yzfvzudlnR8MvetMPO4/BXKCR4geTfgCABeEC1g92HaWecFHlqZNdtKxqbcbHe/KeGI4mmPD6LYlm4Hz4Ts+EcM5Lgcjn4ErB1caCjd1Y/BzGvTPCIW6ccrRjyXIi0Qz1mPIDUeDJPp7w83g8mPIDAGQtbCr68QvHxG65g90esf+lSYmGsgMuGgXnia6yY+8xa5jTA6P0Unu/9rnKJE1RTF1JYdT9hTK6K5M1EidRHO8L7WVG/DkwAn0EADhX+M3e03SkJ7RD7rFjZ+ni5XUZX0NiWMeN9gyLqXxOKOBGYDqNWj2jk9Q6MEbHekPagKkqTF4j1QqNNKg9X2myUpMQ7NjZtxDqZB83XgucaFkAPdBIiYH/gwAAC7KrtZf2dIZEA9M9Mjcb3A7ktBtnlnM8gRG5s+Zk/ygNTnhFnBTHXJndED3RP0J/Pt5FL7T1aZFVklSiq6TwOdTtEccsBlfVlM1xgWWiYOMseJ5w5Ou+rbna7tMBAAAA0lKo+d6uI8JJLeF7td1Nv/559vlF23ucrqYfR56+2NZHTxzvohPhJpdKrCm8uCPQc1iH8TU3pCGENRJrvqI0FuqS5bzmanrqRLc4v3V15XafDgAAAGA6nA71fwfatY97LE5eioWamBRLI3ENSTYr2cwtazBmcnZ4gp480UVPn+zWIr8lXN8qjVLfSqZ5xhpJRqCraQvVKWiwdMFm+Y0NFaL+xVoJAJAamfevIABARjE67aOfvHhc9zkuaGVCoU26tNjtHSvGkp3s3PST572sqsS0c3jmZLcQsp3D0WMf8nJz6Mb1zSk9hs7JPjqlCU79pF/mCTaO8/zCX1yoa1QCAAAA5xJPHDurFYUkViQLLERfHAWtdMZ78lTf/75yip493TPHDCWpKy2g7UuqU9IZbKxiPcSTfmzCYi3I+lBO+oUag5mxY1HlwqU19PnXX0BlBS7xCwAAADiX4PSD7z57WBhzJEOT6TFhJ4qsIbE8iBUzzhP5qjHKzHrGoe4h+uWrp7WJ/2jctKElpYhNNbZUrd1l+qQf80/XbqXWwVHUkAAwATT9AADz8tMXj9OYwXnExSTOA7dzTxtnkUtn/XyCpUFxsrNLy6ymH2fBf+uZw7rPsYA9r7mKVlSX0oqqUvFYqUZBcFFMfcxEdvrZTWm+S/wCIBozMzP0/e9/nyYnJ+nDH/4wOZ2h6FoAAMgGeOL+f14+OefzmWCMUnfcxWr6sWapLHSLIpzZO2v+sL9NxHipNJcX0abGClpexRqphBrLi1LeGcONS276TfoCNO71i0h11of+cLZpTYppC+mCG5GsFQGIBvQRACDb+ePBdmobGp/zebNN2MkgayqsgWLVs9QIdI5tN3MdzNeeOCAiQ1Wj+JbGSlpVWyb0EeukVA1BqrErVg0pE+PPpT6Vk4kAGIFGSgw0/QAAMdnTOUDPnQ4tXObmFQu0w90e4dhiwaBGQ1lNfxxZ7MZlwGa679uHxnRRlq/duIQuWlZnunOtXpn0i+bSys0hqkgh7x0AuwgEAvTggw8K4Xb77bej6QcAyLpdx3KKjSe3dod31XUboiZtj66aJw2Ai1rc9OO9wZzsYJZRp10p9F21uoGuWdtEq6pLTZ+6Y2PUga7Qcc/YJJXkl9FAFhS0AJgP6CMAQDbDk3G/3ntaHPNt//wl1fRKx4D4mCfz7Wz6cbONNc/CNSTFOD5qnjGKaziy4cdNx5s3tdBlK+pTivJcKAK9V6khqWlRmWqMAmA+oJESA00/AEBM7nsp4mB/+4WrhUjgpp8Uc3Y2/VTH0nyCTXVpmbmzRnXRv35zC122soHSgfrcepTnLPPYOZIiVac8AHbgcDjob/7mb2hiYkIcAwBAtnC0d1jbdcxu7Pdeup6O9A6LZIRM2FkTr0bi+KqDiq4zq+nHRT2GjVDvu3R92iI21fgqLmqtrikzRFdlXvw5AAsBfQQAyGZ+teeUlsj0mg1LaG1tmdb0M3NqLpVoz4X0EX+NJ/A4pjRdNaRLV9bTaze2UDpw5OaKNKi+sWlRQ5IR6JxSIamCMQpkIdBIiYEqGwAgKiwI5K66FdUldOWqBnr2VE/G7KzhxcfR4guM8Ne41DRrsshUBWPdPI+fKlwwKy9wibgq6dJSHWpwsYNsFmxvectbyOPxoOkHAMgq9p8d0o7fvH0lFbudQm+MTY+IybmpGT8VOO35ZxYXdqRGqiqKHV1ljEBnXbe2rtyU6CrpJK8vKUjrTj1V//WEC2lq0w8aCWQj0EcAgGyF9+ru7wpppCK3g/76vJW6tKKeDKohqYlQRrjhx8Yirh/xOfPzMsNorZqy6pU1LumgrqRQNP04lWJ0ekaY1KQ+K3Y7bNOpAKQCNFJi2LeQCwCQ0RzrHdaOtzZViaKNutDYbsHWOTyui9eMBRe7ZNGHC1pcDDMDVbCpTvN0FrVYrHEhMRsWMAMAAADn8qSfZEtTlfi9Qd3Ba2PEZ6jpGFhQHzGNSsFLLYSlwuD4tIiTYmrTXNDipqJRl6nRVWj6AQAAANbRNTyhmZPX1ZULA7Nq0LE7Av2MUkNasoBGkrUvnlpU6y9mJCFYU0NSNdKkmFqUk37VSEIAYFGAph8AYMGCFgs2RhVsdkcznPGEilMsJNnJPh8yhpRdTp4pn6mCrcCZRyVuJ6UT3lmjPe7oFA1MqPtqEF0FshNuwHO0J/8yqxkPAADpZiYQpFMDI+K4tiRf7GRh9EUt+zTSGU+koNUcZ0HLzHOWE3fSZZ5Oahdo+mFfDchGoI8AAOdSDYnrNVIrdY+Ytx8vlRoSs6Ri/lU16iSgWRGfeuN4ejWSqku5hjQ0GTFlwTgOshVopMRA0w8AMK9g4xSD1bVl4pjjq0rznba72HnaTRZ12KG1UHSUWtRi95mZ0VV1aY6uko+hNht1BS1M+oEsxev10pvf/Gb6u7/7O3EMAADZwKmBUW1XjSxoGXcI25mGoCtolc9f0OJJOGdejqlmLiuTEFyOSCFRRqBLFzs/L46yAiDbgD4CAJxLTT+1HjPu9Yv9x3Ybo7gRWV00f2JSk6KhukxqVsoamiM3hyoXMK6niqrBeK8f4s/BuQA0UmKg6QcAmMO4d4Y6w0WjZZUlurxv6RiSO2vsQJ5bPAUto2CTewpTYcDC6Ko5go0n/dToqgXEKgAAAADSVdCq0I51k342piF0eOKPruL9NDINgRuVPMWYTdFV4jHCOowj0Hnncf94qKBWVZSfdlMWAAAAAOZqJJcjl5ZVlUSdmrPLGKUax5vLixbUCE1l5taQeEKpL2yMqikpMGVHYNzG8dFJ/YoY1JAAWBRgcycAYA7H+4ZJhu2tq484tKRgO943ojmVVDFnRxb7QtFVxsagGTtr1CnHdMcyGAuJLJLlrh4Gk34gW3G73fS73/2OPB6POAYAgGzgaE90F3umxHt2hpt+XEtSTU+x4MJX+9C4MDNxs7KlcmFdFfekn0XGqCPh1+Rk/wh5/aHGZQ3iz0GWAn0EAMhG2HQzOBFKb1lTU0aO3NyY9QyZJGUlauNuIVNUOozjvGbGFzZXWWOKKiRuK86GjeONZdh5DLIfaKTEwKQfAGAOsnjCrK3VN/3q07D/JZXoqpYFstjTIdjUgpa6INmaeM/IpB+LuEq4tECWwu5Kh8MhfmEaAwCQDQRnZ4UxiuG4c1UDuB2RHcN26SM+v7PhCCousDnzFv6nnmqe6lRMValqJI6u4mm7dKMWEg92e3TRpQBkI9BHAIBsN0WtVUxRTENZRC/ZpZESTYsqdDk0Xcc1pFR30MsYcqtqSKwBZYRoaEVMpIYFYxTIVqCREgNNPwDAHI6FJ/mMLvY5C41tE2xKdFX5wi4t3kVYHt7rwlOCKQs2i6OritxOKnY7tClDKdgqCt1xFfQAAAAAkDodQ+PatD3rI6NhQWqkCZt21rBGkPsG4yloyUk/s4xRIrpq1LroKqMOO9Q9pB0jCQEAAACwjmNhU1T0GlKR/cbxBNOiVPM4x4fzpJ5ZxvFaC9KiQo9ToO1SVOPfYYwCYHGAajEAQIfPH6DTA6PawuWycLMsah67TTtrpGBhl32p4fwWKmpxIY73vpgWXWWRYFN3Kcrzr4KLHWQxfr+ffvjDH9LPfvYzcQwAANm1z09f0IoWX5XJ+/yiNf1SjUC3OrrKeM1bB8a0Y+w8BtkK9BEAIJs1Um4OzYnvrCnhPbv27j0+MxTRSC02aCS5z89ujZTvzKMiFzZ9gewEGikx0PQDAOg42T9KgeDsPAUte6MZRqd8WtMr3oKW0c11RimKpRpdJSMT0k00YQgXO8h2wcY7/f74xz+i6QcAyL6mn2HnsTRL2amR1HjOeDUSu8CdeaFK3JkUC1pqdJVVBS3pYmfUHAe42EG2An0EAMg2Rqd9dHY4pAFWVJeKyHMV3u8ndQHro1STl5JBahw2jhuN7bFQtZSaNpW6cdyipl8UjcT6CKs1QLYCjZQYaO8DABJysbvCO2t4SbM9BS11AXN80VXR4qs2NVYmH101Zm10ldGlJYGLHWQzvMvvjW98I01MTIhjAADIZPj+LzUSu6SXVpbMe6+2w8mu7jyOVyOxjmksK6L2oXExnTgTCCYdHW5HQYt37nABz5jigH01IFuBPgIAZBvHFqghSY3UMzpFPn9QpBdZsfdXbUqOhOM54432ZJrKzItA5wh2JsdgWEondVFqSDUWXncAzAYaKTFQZQMAJNT0kxGf3PSTO2tK8p22RFc1x7HPz+xohmGOrvJbG10V67G46QhANgu2d7/73eTxeND0AwBkPNzQkgWjNbVlUU0/du89lkkGPLmXSPw4ayRu+rHxvmtkImpDM+HoKiUZwoqi1uh0ZB81R4vx3mMAshHoIwDAOVlDKiukvZ2D4phNRlY2/TpVU1ScO4/VnX6mNP3GQrqQk6KSNVclCmpI4FwDGikxEO8JANDgWM8T/aGiSWWhO2Z8ZL0uvio18ZNKdFW8WezRJv2SRd3Ro0adpptoxbNqi6JFAQAAgMVOPAUt3lnDDSc7dvrxhJ5sNPLkXp48kThQXe+pGKPs2Hkceiy9RuJCYiLPHwAAAADmaKQ1tbGN45Lu8NSbVZxRakiJTPpxmgCnXMkaUrKxpBPeGRr3+mNO31lbQ8KkHwCLBTT9AAAabUNjND0TEMdr68piZn032Bhf1aG4tFTn1UIUuZ1UUejSRF+ygk0taNVaWNCqj/JY1cWY9APZC/8/yJns/MuOvQ4AAGB204931tTatLOGm3Xy4RLZeZwOY5SV0VXRTFjY5weyGegjAEA2MTXjp9bBMU1PxEqBUiPQeyyuIckkBKYlgRUxas1p0ucnTzjxIRviz5kCZygCXQUaCWQz0EiJgaYfADYLpC89spc+9cBLNDzptf21ONg1pB2vq6uI+X0czSDhXHYr/4KXC5RZrLDzKhFkHCjHkhp3v0QjODtLP9h1lO76w4vUOjg6N7rKQsHG4rnAqV+IDZcWyGa8Xq/Y6ff2t79dHAMAgMr+s4P00d/sol/tOW37hWE9IDWSIzeHVtWUxfzexrBGkjtr7EhCSCS6KtmmH5u+/vX+3XTv04fElKFa1LIyuiqaMQr6CGQz0EcAgIU0yfd3HaE7f/8CnR4I1Sjs5EjPsGY6imWKUvWRHRHo6s7jRFbEJLsm5oGD7fRPv3ueXu7ot7XpZ2y2Mmj6gWwGGikx0PQDwEYeO3qW9p0dpJP9o/TUyW5bXwtuqD17qkf7eGtzVczvtWtnDRfPpsKTiIkWtIyTgarba76C42PHzlLb0Dj911OHyB8M2ibYeOpSjYJgx1a+oQkIAAAAnDsFraPCWPS7va007l3YqJNOjvUOi13GzIaGinkbWuq92sqIT11BK8FJP57K4z2A8eoj5mcvnaDTA2NCOz5ypFNEV7GpSv48KzHGV2HnMQAAgHMVrlE8fqxL7Kl78FCH3adDz56K1LG2zVND4l27rrB+srKGJIzjYWMUR3UmahxX0xOkAX0+Bsan6b6XTtLZ4UlhjOJ90PY2/fSPV4u0KAAWDYn9bQcAMLWg9cjRTtMWA6cKRzLIc+Boz/nESE1xgdhZE5y1uqCVXBZ7LCf7psbKeb//ieNd2nHXyCQ9evQs9YYnG62OrmL4NWkLR2fAoQWyHbfbTb/4xS/I4/GIYwAAkOztHKD+8WlxzObxrpGJmDtirEA1Zl2xsmHe72007KzZOP+3p2fSL8HoqtycHLEHsH1oXBSmeHJvvsbm4MQ07ekc0D7+7b7T1FReaFtBy7g/MNZOagCyAegjAMB8PHQ4c2pIbPiR02ycTLSlqWpercEmHTYp9Y5OUiA4a8n+XTaOT/oCSU35MU1liaUh/PlEl9CuDK/O+d9XT+ni3qPt2bNKI7HByxj3CUA2AY2UGJj0A8AmXj0zIFxAEi5o2cnTakFr1fwVKhZn6s4abmBa7WJPZtJPLYItFM3gmfRqAlby6z2ntdfJ6ugqo0sL0VUg2+Hp1aKiIvEr1v5QAMDiRC1oSeONXXj9AXqxrU8c84T9jqU1cccodVuo7aRG4nNMRiNIYxRLuoU06ZNc0FKkHxfTfvj8sajTjlZQ7HbonPtVSTx/ADIF6CMAQCzYcM1JUWrUtlW1mGi80NZHM4HQ41+6om7B+ohMjGLzeP/4lOXG8URNUca0qIWaftzIfFIxjjP88QFljY7RqJRu1CYj6yP8uxtkM9BIiYFJPwBs4uHDZ+YUtNgBZPZNmEXgH/a3Ced2S0UxLa8qoaWVJbriCDu6nzvdo7l/di6rW/DnciY7x27xzhpukFlRYNELtvS6tNSCFu/S41hRXt5sV0HLWEjEpB8AAIBzEW44qcWRRHaoJFM8+/3+NipyOWhZZYnQSI3lRcKNLnmpvU84tZmdy2rJ7Zg/Wlvde8zFOKt2RMvJSNZHyWjJUIJCr6aRWCvG0pV/Dhe0+GE4qsvrD2qPz9RbPOnHz5eNURw3ymDSDwAAwLmImhTF+AJBMX3PSUxmw/WQw90eoYuWV5bQsqoSKitwxTSOX75AEoJRI3H9y7hvLt3Gca6HJQrXzTgWlGPeWR/NV7PjpAq5z1nWkLikJCPieRoy0XjRVFGvcTreJwCAzAVNPwBsgMXCwW6P7nNcUPJM+aiy0NyYu0PdHvrlq6fnfJ6dWO+/bINwY7FbbDy8h2VHS01cQoRjoF49E3KZdXjGTWn6cfPxy4/uFcL1jqs3zyk4yaYfayzVcRUvRW4nVRS6yDPpozPD4zEFm66gRUSfuGEbfeHhPaKoZVd0FbO+vkKLVV0omhSATMfv99Mvf/lLmpiYoHe9613kcECSAABI7Iczkq5Jv5+/fJJ2t+un+ovcDnrvJevoorAB6umTPXEnIcidNTxtx7qO9ZFZHOoeom8/c5jW1ZXTP1yxUdeY5L0+qSQhGP/cfE1W3iUki1fbmqrE+fz8lVO677E6uorZ0lglmn61JfkoaoGsBvoIABDL4PPUCf0UGdM1PGn6fW940kv//ewRLaZSsr6+nD5y1WbR/OOIzuN9I1paABunEjFhc23n/CXVppzv93cdEUlaf3fJOjp/SY2pxnEZC8rah03g89Xsnjh+Vjv++8s30H0vn9TWw9hVQ2J9V17gouEpH21qqLD88QEwE2ikxEC8JwA28MiRM7pIIklXGpzssSKanjvdSz94/qhofCUS7Slhp5e6D9AMjvYOiyYlTxD+19OHRBNQzYs/G34uHAuRbLSmzHGf8PppdHom6vcc7BrSHOubmyrFHqE3bFmm+x47BBs/5pdv2Ul337xdFNoAyHbB9vOf/5x+85vfiGMAABAFrbAm4QkyTh9IZwR6tGYi64P/fOqQ0CRsQjrYPaRNj62tW3ivIDfjeGqQ4QLRWAytkUwzlH8e67eHDY3RE/2holuyO48Tia96/FikoHXt2ia6aWOLaLSpWB1dxdy6bTl94vptdM/NF1iyIwiAdAF9BACIxnOnerTddLoaUho0Eq9wiRYaeqRnmL72xH5Rp3n6lN4UFU/KgFpDahsyp4Y0MuWjx491CWP3t545LBqWqpn75MCoOObT47SqZFD3FscyRoX2HYdM8dwUZDP92y9YbXsNyeXIo397/QV01w3b6OZNSy1/fADMBBopMdD0A8Bi2B0km2xuRy79xeZIM0k2tcxE3Rt408YldN26Jq2I9tSJbjEFyK4ohh1bmxvjaybJghbTblLTj4WS6lr/vwNt4pgbk9yglHnxq2vLkn6MZiXHXXV9qTyuOLSuWdMkfr95Y4suLsoOwSZddNyERBY7yHby8vLota99LV1//fXiGAAAWB/JKM3LVtaLVAGGI8pVI5AZsLYYCOsOLs68eftK4WCXO1m4qMXx6DLq+/JVDbrpuvlYVlVselFLTtcxv3jlJPWNhZzj/Puv9kQSHdYkqZF4V7PUh7H0EUdWvRLWjJycsK25Wpiw3qoUtYz79ayCz2Nrc9Wc6DEAsg3oIwBANM2iGn7edP5Ky2pIFy+vpdduXEKl+U7xMU/3fe+5I/RMuKbF0ujSlfVx/VzWdVJrtKahhsTGrR+9GNkxzDpORq1z/YobYMmgTgh2xtBI6nqYq9c0Cs3Ik4yblYQm1lp2wKlcW5qqYIoCWQ80UmKg6QeAxbCDXcZEcgFpVU1pWuOrVBF0/dpmes/F6+jvL9ugfY532XBxi7lsRX3cQoDz2F2OXFMFG+8GVPndvjYhqrgI+Hxrnxa79VfnrUj6MRba68dOsZfDUV8sbLe3hCInWCC+6+K1Il6TC1obGxCvCUAqOJ1O+sAHPkDvfve7xTEAYHHDBS012vOG9c3a9BkXUThGymwTlmwwsvObJ/r/5cbztOgjntB79GjEBHRFnAUtRo0nb0uDRuJ9yt/fdZT8waBIRlAbpSurI7oyEbg41bRAk/UppaB11epGTTNe0FJDFywNxWntXL7wXmgAQGygjwAARg73eLTaxdq6Mt29Nh01JGmKYjju/O0XrqF/vn6bSGFgnjnVoyUjbWqojHtFDesG2UDj2EvWYmbXkHa39dPu9j6RgiBNUdyYfMdFa5J+jIXSEIz7jrnpFzrOob+9aI0wQ3Gzc3uLPnoUAJAY0EiJgQU6AFgIiwE12vPGdc1Umu9Ka7zngOIM5wXEzCUr6unsyCT9dm+r7nvjjfaUxSEuap3oGxGCb9w7Q8Xu1Ar3nDOuws1ILmZx8UnCe3ZS2R+4RJn0ixbNwAWtoFLQcuRGvBHnNVfTvX99mWgA2uFiBwAAAM5VeNexLFzxxB1rDDWGiXVLstGVCxW0qsKT/HzP/8jVm+lTD7wkosYlXGCrK40/Ekrda2PGpB/rx+EpfVHrQNcQff6hPUKHMRyx+a6da1N6HC5qtQ3xzuNQXJjavDTuO2aNJOGiFu/4GRifss3FDgAAAJyrqFN+N6xrFnUXNijzupL59vCaYRyvDmskNhXxnrr/ePKg7nuvTKCGJDUS7+Bl2ofGaH19anvmeMeekR8+f4zyHXmaUemNW5fHFdGerHF8n2HfsVqv4qSmb/7lJaK2hTQCAICVYNIPAAs5cHZIKyJtbKgQxauSfKeYXkvbpF/YgcWiUI0zuG3bcrpoWa328dLKYmqpTKyYpha1WLClipq/LuMj2ofGNQf7lasbhNMsFeROP6YjSjTD86292vE1YYeWSnmhGw0/AAAAwGQeOqyYotY3i99lvGc6dtboClpKcYYLaf983Tbdvf7ylQ0JN89kfJUZk348dSgNSVIfMbx3ULrKP3jFppT1idpUNUZ8nuof1Vz9HBFlbO6xe58bo4gfBwAAAMyN2ny5I5REVF7gogvDNRw5fcaNPzZgm8nAuDeqRrp4eR395XnLtY/znXm0IzzpHy/LqiKJBGw0SkcNidObpHGcV8PcujVyzsnA+koa6DuH2Ryl33j4/Ole3b5jI6wt0fADAFgNmn4AWMjDypQfx1YxXByRRS3elTI1k3rEgYRjnzxhZ7h0aKmTeh+4fAOd11xFha48+pvtqxL++epev7bB1AWb6tL64JWbdF+rKy1IKZJBFWzyWnCjkp3rEo6yko1AdmQl4uoHACTG9PQ03XLLLfS2t71NHAMAFi+8l25PeFccR0TtaAkVtNRJP7ONUbqClkEjcYT5P16zRRTXeEfepSvij/aUE4PSZMS7ZFLVdmp0Fe+HuXSF3gD1l9tWpLTvWDWASYzR7acHR3XnAABID9BHAACVR492ahNr161r0pKIVI0k99aZbYxiA5NqNmK4gcbmLLcjl/76/JXkTnBP3jJFa7Qp2iJZ1CSE9166XjQiJXx8+xUbTdllJzXSpC+g7VU2aiZ+HDZGAQDSAzRSYqDpB4BF8C6avZ2D4phdQtuXRBxR6RJsXCSSAjFaJCYLtDuv20rff8uVtLU5cXFidnyVdGnxzjxeeCwboyyePnTlJipwmhOpuSJ83rxbUS0isqtdOumXKc8NAJAeAoGA+AUAWNyIghZFClqyONPAk2NpmvTTxXtG0UgbGiroW2+6jO6+eYeugBQvUkfMRpmaS6WgVVHopr+9cI1WhFtXVy72EZrBCsV9b2z6qR+r+g8AYD7QRwAAaUp+4nhovzBro2vXRKbI1DSEsyZqJJ5ikxqpsih/zgQ/f/zOnWvpR2+7im7asCThn99SUSwSCkwzjk9GjOMcQfrWC1ZrH79751qqMyl2fLmikU4rmsjrD2jXn43jzvDeQwBAeoBGih8spQLAIh5RClrXr2vWuY3UjHAuaq2ojgiKVKMgJLH24KUSw8SREvw8OJ881fgqFpfSyc4FLYYn+9bWlglBa2YTjn/W7vZQREbrwKgQZ8bGJQpaAKQXt9tNP/7xj2l4eFgcAwAWJ1ws+fOJ0K44R24OXaMUtDiWnKfwOFaSTTqsFcyKj4wV76mSymOpaQjcMFtTW27KzmPWSKUFLvrc6y6gIz0eEXtuhoOd4egpnrTk5Ak+Z05D4GQIpj2s8/jDROPgAQDxA30EAJA8d7qHxr2htICdy2rFqhFJutIQJn1+bb1KLH2UikZibcd1pE7PhIjK5MZmKo0yWUPi02Edc93aJqoucoufubGhksxCrQ+dHhgVUacMJ0VJoz2M4wCkF2ikxIAFAQALYNH05IluLSLhasOuuHQJtqHwMuGFBFuysJCSDTN2N3HhLlkmfH7yh8fsygtCYpYLTZesqDddPOmc7EqjT21coukHQHrhfyhWVVVRZWUldkABsIjZdbqXJmRBa3ndnJ0n0snOWkqNATez6Sf3tJiJqiOMU3OpxHty5CjDO/WuXN2Y1BTifEjNxde7N7yHmgtyZ4YnNKNaolFeAID4gT4CADBsdHr4SKd2MW5cr5+qS9fe48E015BUYxSXf+R6lVTTEMryXZpRaVtztakNP2a5YsxX60bSFCW+B0kIAKQVaKTEQNMPAAt49nSPcEwxlyyvp9J8fUFLLmE2O5pBja6qLk7PJI0WX5WiYFMLWhWF+utjNsurlULcwFjUotxSxaEPAAAAgHQVtCL7jl8TJSaqsVwxRoUbT2amIXBMJrvOzYan4aQJXi0Ipdz0U1z+6WCFopHkHr+zwxMi1cG49w8AAAAA6eFE/4jWXOJm0qoafRoUJyG4whNyZhrHdfHnhp3HZqFbE5OCRuJEApmGkG59xEkI0pjGxnHWsOJYOX815QEAAOwGTT8ALC5o3bghtKdOpaa4QERaMV3DaRJsRZkt2PRNv/QKNm66Slc/R3qyWORfsmlZW5JPhS6kHwOQTvx+P/32t7+l+++/XxwDABYfx/pGqH0odO/lYhbvYjGSjp013MDiCMt06iOehpNJDjwlx9NyZsR7ctEpnag7a6QxSo0/R3QVAOkF+ggAwOin/JrnJKPwVFtDWGf0jE6mpDMSjT83tYakaIxEGZ3yadGalWk2jjMrwufNCRV9YfOYPH9+dRB/DkB6gUZKDDT9AEgzR3uHRV45s7q2TFdMkfAulvrSiGCTbupUGVR2+qU7miHVpp9a0JLxnulE7k3k+KrukUnhjvP5Q0IZDi0ArBFsP/rRj+i+++5D0w+ARcojiinqhnVzTVFMUxoi0DkKShaJ2CmfLqSeYF3H03JmGKOMaRHpKmipk35wsQNgHdBHAIDhSS+90NorLkRJvlOsPImGNBexpukdC0Vym5WEkK74c2OqUjbVkNSIz9aBUfIHg3QmbByvKy2gAieM4wCkE2ikxMDfSACkmVfPDGjHN6xrivl9LNg6hyfEXrv+8SmtCWjGpB9PEZYaduSYGl/FQjNFl5aVk37SXfZSe78mNGfFMwgBFzsA6ScvL4+uvfZampycFMcAgMWXhLCnc1AraPE+v2jodtaYFO+pL2ilselXVULPnQ4V7VgjJasvpEbiKFLep5xOOB6LY9Y9kz6hjzgJQS3IQSMBkF6gjwAA+7uGxL475qrVjTHv/ca9fs3K2hhTJv3SZIziVCVOV+obm6aOoXGhNeQ+vkSQqQ1W1ZBUYxQbonjSciYQeqGwzw+A9AONlBho+gGQZlRX+vr6ipjfFxJs/ZpgM6PpJwUbF7SSEVHxwG6m+rJCMS3Hgo3dTo7c3KQXMFux088oytjJniNal3O/BgBID06nk+644w7yeDziGACwuOBCDU/bM6trSmMWtLjRVeR2iCglsyb9dDuP09n0q9QXh65anVxzVNtXY4GLneFUCs/kAE3NBKh3dEqLP68pzqdiN/6+BiCdQB8BALi2IllfXx7zgshJPyYdGindxihu+vkCQWHqaq4oTqmGlO6dfkbjE+s69fpHS/QCAJgLNFJiIN4TgDTTPRoSX868nHndR6pgOGvCXr9Jn58mfaFiWmWaYhkkyypDAs2fQnyV6tKyJN5T3VkzOKbfV4MFzAAAAEBa4ThzSd08RifeYSOd7KwVpmb8psafpyu6ylgcSja+asw7o8W+W+FiN5qfnm/t1ZqzmPIDAAAA0k/XaKSmUl8SWyOlMw2h2O0Q+4nThW5NTJKJUbq0qDQlW6nwXmU2o0njuHreS8M1MQAAyBTQ9AMgjXCRpi+crc6Te/NN2zUqUQw86ZcNC5ijuZqSLWoNT0by2K0oanHcqSz0qU2/8gKXJS4xAAAAYDHTPRrZPdO4QLqBaoxS3e+muNjTuNOPp+JkNFb7UCgqM5WCVrkFSQjMiupIIe7PJ7q0YzT9AAAAgPTDU/ZMbg5RTUn+vPoox8RJP65fSTN2+mtIqjEqlCiQSg3JihoOG9FWhPf6cQLFyx2RVT7QSACATANNPwDSyMD4lObObkigoGWGYNNFV6WxoDXHyT6UnGCTRS2O8Er3vhrjebODnUWb+jkAQHqZnp6mN7/5zfSe97xHHAMAFhc9itZZKNK8ybCzJruMUSFd4fUHddONSZmiLIz3jLb/EEkIAKQf6CMAFjdsEJJpUbUlBfOuTnE58rRaD+sjjgRPBY7LlD8inaYoo9ZoTXLSz+qdfsZmpdRIbCYvzbfGmAXAYgYaKTHQ9AMgjUixxvCS34V243FcgHkFLa8lWezGKAN2sie3r8ZraUHLGPEpQUELAOuYmJigyUlz9k8AAM5djWS2MUpqpLzcHCpLcxyUqivakzBGeXT7aqwpKHHhjJMPjMAYBYA1QB8BsHhhM7TPH5yjfxaK+OQ9vHIHcDaYolh/Sa3BNaRkGpayhsTTjmUWNd3Upp9kKdbDAGAZ0Ejx40jgewEACdKdgItdijp2K417/ULspeJWUvfVpFuwsauJs81Hp2eS2unH+wdnAiGRF63IlC6WK/FVEhS0ALAGt9tN3/3ud2l4eFgcAwAWZ9PP5chdUO+oO2s6PMklCkRLQ2Bn9nzR62bQpMS3J6ORdPGeVhqjqkvo1TOD2ses86zYlwPAYgf6CIDFTcI1pPJC2nc2dL8+4xlPqYakTven2zjONJcXiUYlpy5xLSlRI5ZMQyjJdwojlxXIeM+FGoEAAPOBRkoMTPoBYJGLPR6XliogDnUPZcW+GsmSitC0H4u10QQdZroFzIX2TvpBsAFgDbwTobGxkRoaGsQxAGDxwNHnvWGNVF8y/85jpq60QMR/M0d6hrXo9GSYmvFrkd5WFLSWVESafmeGE29Yqq59mQhhBWrslvwYf1cDkH6gjwBY3KhR4A2K6SkWK5X79cFuj2lpUeleEcM0h2tIsmGZaAyqnPSzUh/xY7ERSgU1JACsARopMdD0AyCN9IQXMMui1kJsaarUjvefHTItmoGd7Fa4tCSdcTjZWaRJPFPWLmCWsJNMFYiFLgfVWCBuAQAAgMVM//gUyb5dfVnBgt/PTcFNDZVaOsDpgdGsSEJg6koKyRF2n59NUB8xw5PWx3tGK2Atq4oU5gAAAACQfuN4fcnCGmlTY6SGdCA88WeGcdwKjZRKDWlsekbTklbWkLjpYDRGIS0KAJD1Tb8vfvGLdMEFF1BJSQnV1tbSLbfcQseOHZuzVPH222+nqqoqKi4upttuu416e3t139PR0UE333wzFRYWip9z5513kt8fctwCcC4KNm4mceTAQqypLSe3I/S/5f6uoZQWMctoBnbG877ATBBs/Hxe6einf/rd8/Sx+1+l433DcwpaVk76GQUa7yaEix0Aa+D7/h//+Ed65JFHoAEAWMxJCKULu9iZrU1V2rGMsUq5oGWB0YfjpmQ8KUd2zQRCe3qMcDPzf146Qe/62ZP09aePatOMOmOUhfGeyw3xVdh5DIA1QB8BsLjRT/oVxmVkljWNtqFxGklhr58u3tOKSb84I9BP9o/QZx98mT70+1fo6ZPdtqZFGY1RxW6HpZOGACxmoJHS2PR76qmnREPvhRdeoEcffZRmZmbohhtuEEsUJR/96Efp/vvvp1/96lfi+7u6uujWW2/Vvh4IBETDz+fz0a5du+gnP/kJ/fjHP6ZPf/rTCZ46AJmNzx/Q3OQNpYVxNZOcebm0ob5CHLNYS3ZvDTug5KSfFQ4t486azijxVZ2ecfriI3vpq4/vp7PDkzQ5E6D7D7TPia6yel8M76yRIJYBAGsF23e+8x360Y9+hKYfAIuMHt2+moVd7HPSELqST0MYUKKrrIj3ZJrKQ0U77uPJWFNVsz15oos++ptd9MDBDvL5g3Skf1SLeZdFLS4qsU60Ci5gqbt1oJEAsAboIwAWN10j8e88lmxRp/26kjdGyRoSG5bKLajLLGQcZw30nWcO06ceeJmO9Y7QTDBIv9l7WpjJZbQnY8W5qizX1ZAQfw6AVUAjJUZC4z8PPfSQ7mNu1vGk3iuvvEJXXHEFjYyM0A9+8AO677776JprrhHfw8W89evXi0bhzp07haP/8OHD9Nhjj1FdXR1t27aNPve5z9HHP/5x+uxnP0suFxbEg3OD3rEpmk3AoSXZ0lRFezoHtYjPpZWJLwVmcSSjDqwqaDWXF8cUbM+e6qZvPXOYjIOL7NTn3TpDNrq0tjVX06/3tGrHAABryM3NpUsvvZSmpqbEMQBgcU76xauRWM9w84yNQ+z4nvDOUJF74RSF+eI9rYg/13bWtPaJ4zPDE9oOG57m+9Ije6Lu4Nnd3kebGyu1NASr9RFzXnMVPXmiW7xGNXFEjAEAUgf6CIDFiz8YpL6xKc04vtDOYzUN4f/Chup9Z4fospUNKaUhsPEn3sdOBdZxFYUu8kz6xN5jbuZJs/yJ/hH6wsN7aHomoPszfWPT1D40Lv6MxOpJu3V15ZTvzBPntq05kkQBAEgv0EiJkVLmHzf5mMrKkKuEm388/Xfddddp37Nu3TpqaWmh559/XjT9+PfNmzeLhp/kxhtvpA984AN06NAhOu+88+Y8jtfrFb8ko6PJ7/EA5yYcE7m3c1DXVFpTV0bn2djEkQ4tKdjiRb/Xb5Bev3lpSvv8rIiuYji+lBcaj07P6KIZ2MH+090ntNeGz4enDw92DdBMYJb2dQ7qXVoWC7aV1aV0983byesPiuIaAMAa2OTziU98gjweDww/KQCNBOaDoySfOtFFg8p0GzvHL1/ZYJk+iAbHXErqE9BImxurRNOPNQU3yi5aVpvx+2rmi696qb1P1/C7cGmN0LP+AH+tn/76vJXkD7u4rIz2lPztRWuEGW1NbZklxT8AAPSRWUAfgYXg+/ELbb3kD0SKSHWlBXTlqgbbVn70j01Hdh4noI9W15aJNTFc0+Aakto8ixc2Y094Q2uXrNSITWVFooHHj821JJky8POXT2oNP16Xs66ujHa39WrGKIeSfmB1Dak030Wfe90F1D0yQectgXEcAKtADcmipl8wGKQ77rhDuPQ3bdokPtfT0yNegPLyct33coOPvya/R234ya/Lr8XaJXj33XfP+TwXCjkuFCzuZigLg7v/tI98Qf2OFJY4d129gZZVFttyXU/3DJA/EBJNxbkB8X6Nh/zZWSp15dLQlI8OdQ1ST/8AuR15CT12W8+g9tgFFP9jp0ptoZOGJqZoaMJPHT19VOJ2UtfoFHkmQm61NdUl9OHL1tLJgTHaf6aX+AyfPtZBw1Mz2vmSd5I8/khBzgpqeFDAmWPZdUoni/XvASvAtcV1zcT3FTRS+q9xNvPQsW767cEzcz6/6+RZ+pdrNtp2bTsGR8R9v8jpIP/kOHmm4itMLS9xanph96mztKYs8Um/rqHQYzN5M9Pk8cxQuinJ8WuPebJnkDyeUJT7q63d2uffsX05Xbqshr49PU2vnGEtNUWPHzqtfT0/J2iLTllX7iLyTZHHF9Jy2cxi/rsgneC64rpm4vsK+sia65ytsDH53x7aTwNK4pBkYnycLllWY8t1PdE9rN33yxyhmme8rKgopAM9w6IWc7Cti5rD0eLxwnUb+dhFebOWaY6q/FztcQ93dNO62lJhWjvaPSQmHyvyXfTJa9eLdIQXTnWJGtJzJ87SmpoS7c/lCj1nrUZiO9eqUieNhYdhspnF+veAFeDa4rra+b5KuunHu/0OHjxIzz77LKWbu+66iz72sY/pntySJUuooqKCSkv1S+YXO3xNFhuHT/dQMCdX5/SR7O2fpPNWLrHluo74u8mRF/pfbHVTLVVUxP9e3bGsnp443iXiQXu8RNtqKhYUrUd7hqkrHJd1ZGhKe+yW2krL3hcr6yrp5FDoHMZnndRSUUGv9E1q57JzZRPVVVdRVWUFlbx4irxBoiMDE1TodIjvYQcXfx2kxmL8e8AqcG1xXc0mLy8xU4cRaKT4WKz/7x4bOqXdg1U6R700QU4tZtLKa8s7j0d9QXFeS6pKtcSQeLiwuJTyX2oV028nhiaF0XAhJ/u4d0akCkzx+BxP+k35xWMXuR3UUGuNO7u0jGOgjorzHpj2a9esffS4OBd+CtdsXCF00BVrl9CeLo/4/HNnQr8zjVVli/Z9bCa4hriu2cRifr9CH1nHYnyfnfGM07A3EFUjvdIzRjeft8aW6zreNaad04r6qoR+xoUrGulI/7g4bhv30+blC//ZtsExOjUwKupOXSMT2mM3V1VY9r5Y3TBJT7WG1tuMBHLF43KS12y4xre1pZZa6kPJDqtryqh9ZJr6JmfIOTKtne/S+hqqsCi94VxlMf49YBW4triudmmkpJp+H/zgB+mBBx6gp59+mpqbm7XP19fXk8/no+HhYd20X29vr/ia/J7du3frfh5/XX4tGm63W/wCIBpHe4e147dfuFpEKH318X0iOvKF1l762wvXiEXEVtOj7KtJJJpBRnxy04/Z3zUUc9ccx3g+eaKLnjrRTf3KjhoVK6MZ1PgqzmTf0FBBR3sijqt19aG/Fxy5ubS1sZx2dw6LyAYZ28B57gCAxRO79L73vU/oBt4RjPt8ckAjgViwS/pU/6imBd5/6XoRHfnHQx3ic7tae+mvTWj6JUrP6FTS+oj3p6ytK6dD3R6he/hnRdsJyGYo/p4/Hz9LL3f0C01oxKpoT4Z1aGNZEXV4xkW0Kb823PzkoiOztKJYNPyY85fUUF64kclRphI74j0BANYDfWQO0Ecg3hrSjeubaUdLDf3g+aNCV7CZmussvEs4G3YeJ7omhs1Qz57qEXUk3o0XjSqbakidw6Hz4ddA3Z8nOb+pktpHunQaiRWTjAQFAJzbQCMlxtzRqHngXGhu+P3ud7+jJ554gpYvX677+vbt28npdNLjjz+ufe7YsWPU0dFBF198sfiYfz9w4AD19YWW2TOPPvqomNjbsGFDgqcPQESwcX3k6jWNYveI3OXH0Z+HlaaTmbAQVHfnxdpXU17gogJnYv31jQ2V4vkwB84ORf2e3+5tpQ/98jn69Z7WmA2/YreDllhY0GuKsrNGvj68Q2h5VYn29fOb5jqJKlDQAmDRwJpiaGhIRLHwMQDAXE72j2j74DbWV9Cmxkq6eVOLKI7Ipl86/t/jhhs3s7zhyTozC1rMFmX/7v6ukDPcWMz6xB9epC88vIeeb+2L2vBj2JhkJc0VIY3EL0nv6CQd6xsRznrVFMVw829D7dx0iAqL99UAAOwB+ggAa5t+l62sFxrp0hWhIQS+N7/YFqlXmsnY9IzOHG6kR9l53FAaqa3EQ0NpIVUVhbTCsb7hqDps1+ke+of/fYZ+8uLxmA0/rkOtVxpt1u49npzz+qhNv/Oi1JBK8p3CVA4AOPeBRkoMR6KRnvfddx/94Q9/oJKSEm0HX1lZGRUUFIjf3/Oe94goTo7q4Ubehz70IdHo27lzp/jeG264QTT33v72t9NXvvIV8TM++clPip8Nlz9IFC7sdHpCzaVllSVac+3i5XW0u71fEzablQKRGbQPjdFn/vgyca3sUzedT6tqynRfn/SFlhAnW9AqdjtpZXUpnewfpc7hiTlOM3aI/35/q1Ys4gIeNzt3tFRrMaf8ORaviTYcU0FtMPJ5D4xzY9SrRTGoYmx9bZlw7MspPzsWMAMA7IN3AH/zm9+kkZERcQwAMBddwSTcVOLG0fqGCjrc7aHe0SlqHRyjFdXmRuX//OWT9MDBDlpfX06ffM35lGuI39QlIZQUJPzzWe/8/JVT4nj/2SG6cb0+xv2Ftj46E9aG0gB1+aoGalE0Cu8c5p9jJaox6szwhLj20QpazHlNlSL+XAVpCAAsDqCPAEh/0VhOkrExeVnYmMw1pN/sbRXHu0730ms3tpje8Lvr/14U9ZHbr9hAl61siGmM4ghybmYlAsedb22qEolRbHg60uOZkxj1fwfadWYorjldsqJOSxuQn1M1S7opcjuFxvFM+kRaFJvH2BjFlOY7qVGpp1UXucXrxbGkEpiiAFg8QCMlRkLdgG9/+9vi96uuukr3+R/96Ef0zne+Uxx//etfp9zcXLrtttvE2OWNN95I3/rWt3S5oxwN+oEPfEA0A4uKiugd73gH3XPPPQmeOgBEx6IUtJjzllRrDSVu/r374iA5o+z8S5Y/HT5DXn9QHP9uXxvded3W2C72BKOrJFyM4qYfc6BriK5a3ah9rW1oTBNr7FT/wGUbLI3xnK9ZydEKI1M+0fQ72uuJWdDi1+O85irhwpfwVCQAYHHAWmHFihVi0o+PAQDmcqw3VDBh1tZG7sFc1OKmH/N8a6+pTT82PT185Iw4PtIzLOKljAUnVSNx5GWitFQWiyKQTHNgI5Sq8Y4r2vCdO9fQNWuaTNWA5sRXTRhc7HrnOkeg/3z/GWEukyDeE4DFAfQRAOmFU5KGJkPG5DWKMZkbXUsri8UEHO+56x2borokzEmxeOZUt2aI/tWe03TJinqdMYpjv+XXk68hxV4TwxqNY8YZfl7/eO0WS1Oh5qO5vJg8k0M04fXTwa4hca4MR7obdzdfuLRG1/SDPgJg8QCNlOZ4z2i/ZMOPyc/Pp3vvvVdEdk1MTNBvf/vbObv6li5dSg8++CBNTk5Sf38/ffWrXyWHw7ppJHDuoBZM1IKW25FH25eEBA4LBi46mQXHJKhxD3vODIiYplixDInuq5FsNWSyqxxXCnkXL6vNiIafsajFTraXwtOWUrAZuWhZaCGzBC4tAAAAIHXYJX28L6SRuEFWXxopWl20tJbkqmN2svP3mgU3EVUH+UOHO2PGnzN1ynnFCxfI5JQem7s4xlTleNgd7szLyZiGH7OkPFJYax0YpdMDIWMXvzbGXTQ8ibihXt8IhEYCAAAAzDWOG2sUMuJTJkaZydMnu7XjvrFpUUeKtfM42abffGtiWC9JycfNwUxp+DHqZOHjx87GNI5HqyGVF8I4DgAA0ciMfwUDkCSxsr4ZjilQi1Bm8VJ7ny6SknXTw0c753GxJyfYVlaXUYEzT3NpqUU5Wchj1ijNzkxAdbK/1BFq+rHwXFUzd5Jga1M1uZRiHApaACwe/H6/2AH81FNPiWMAgHl0DI3TVFircBKC6pLmuCjZNGOnu2ySmV3QYvadHaSukYmo8Z4c5ZRsBLlur59S1OKkAXbmM8urSjOm4cfUlhSIRiSz9+wgBcL7FqOZopgLl0aKWhzzlUnPBQCQPqCPALCvhqQ2lMysIfF6GOMOvYcOh5IRzNp5rK6JYeSaGImq91TDfKbWkGJpJE6JUL+/EitiAFg0QCMlBv71CLIWnriTLmkWRUaX9ObGKlEkYV7u6I+6yDgZnj4ZcXzJEtqTx7toasYfVbDVJenSysvNETv5GI45kLtfZpWMc24KNldYl7ceD82KY0z2KZdXRfYtqnAE69bmyE4dCDYAFpdg+8Y3vkHf+c530PQDwGSOzBMdyVyy3HxjFE/wyYKSGsT08JFO3S5mufM42SQERt3VvL9rMIYpSr9v2W5Y1zWUhjSbOlwZzcXOXLC0RruO0EcALB6gjwCwpunHqQerDVqBDTryc7wfuDMch2mmKUre2w92e3Q/X60hpaKR1J3FvCYmWtPP+LztZolS05IaiWtFyypD+xaNXKg0Z6GRAFg8QCMlBpp+IGvheIKwSTpqwYQd0dIlzfv3jPEJycBOKc4YZ2pL8unK1aHly+ymV4WcjK5iY30qOfCqYJMRn5xBz052ZlVNmS4HPhNoiuJKi1XQYt64dZmIHltfXy6eDwBg8eSx79ixg7Zt24adfgCYjLpTd32Ue/D2lhpt6uyF1l5t6izVXTWSN2xZRi5H6J8ZT53o0nazyCm/VKKrmPJCt9i7w7QOjNHotG9OQSvTmn5MNKNWtNdHph/cvKlFGLxeu7HFgrMDAGQC0EcApI/RKR91hWs1vNOY18IY4d3Hkl0mGKP8wSA9eypkHHfk5tCt25ZrX3sovAfZuCImFY0UbU0Mp0bJOPTyAhfVZNB6GKYpyo7n1TVlwjAVjRvWNYtELY5Iv0BJRgAAnNtAIyUGmn7gnIxliCbYzHCyP3OqR8R5MpevbKCbNrTo4hlYTPEknixqsZhKJY4pWnxVJrvYmWjZ8PM1/Th+6ztvvpw+9ZrzY4o6AMC5h8vlos985jP08Y9/XBwDAMxBJAKEd/9yw6gl3BxTKXQ56Lzm0O5jnrw73BNpEiYD6x9pfmIv0g3rm+mKVQ2a8erJE11zmn6puNjVaT/WZdKQJZMQMjH+nFHjqGThjacKYvHWC1bTD956JV21utGCswMAZALQRwCkj6NKLSVWjWLnslptLx7XkFhXpQI33mTKwflLqoWRh6fYmGdO9ogUhLlpUckbx3lNTKFLvybmjCcS+841JDX2PRMocjtF7Hu8NSRO+fr3Wy+mr9168ZzELwDAuQs0UmKg6QeylqM9Cwu2jQ0VYoqM2ds5KFxWycJiT53m42IWF9I2NFRoi5f/eLCDvvXMYU1QyRinZOFCELuXZLOPnfK6LPZ5hJBdcI68UXgtdJ4sOjNNeAIAAADZCO+0k4kA3PiKlQigGqNeTTEN4XC3hwYnvOJ4a1OVmFK7cV2zzhj1+LGz9Pv9bSnvPI6ahtA1RDOBILWGY9+5WJaJRaAmQ9PPuG8xGtBHAAAAgHXGcdYw6+sjNR61GZcMTyk1JE6KYuPVVeHEKF8gSL/Ze5p+uvs4tQ6OanGVye481tbENOjXxJzI8BoS01xeHHfTTwKNBAAAsUHTD2QlHEN1IhxPwKIoVjwBF7qkE5wFlXF5ciKcHBjVYjs5ilI6s1+zPlLUuu/lk1p0g9xllyqyqMXJW+zE1/bl5JC2pDmTnexN5YVUmp95hTcAAADgXC9ora2LnQgg9wYbUwSSwWiKkjt+pQbjaPLv7zpKZ4fD8edEtDTGnpZ44WKQK5ymwC56Lpb5wzGlazI0LnxJEgUtAAAAAJjDMUUjzZcIoCYuqabrROEpvlc7QsYqNqPL2s4N65Zo3/PQ4U7606EzNBMIaZhlJtSQNivGqH1nB3VJCJm2zy+aMYobl6tqMrPWBQAA2QKafiAraRsaE3FRsqA1n8NHFTWpCDbeSWMsaMm9ONWGpiO7t27auIT+YstSShVVcL7Y1kcd4WXPLRXF4nEyvemHghYAIBper5fe97730R133CGOAQDWudjlZL68X7cNsq4KpRQkCqcQ7G7vE8esS3a01Ghfe82GSFFLNUR95OrNc7RTonB8unTieyZ99MTxiE5bk6HNNJ5AlLsUmbUZGEEKALAX6CMA0sPUTGjqjWH9UxJOhIrGGpNqSM+d7tEMSZeurCdHbqgE21BWSNuaI405hvXBZSvr6d0XryUza0gHzg5pk378GMtSNF1ZUUPifYuuKPsWAQCLG2ikxMjMjgFYlHDR6Hf7WoUAumZNUwLRnqGCTyzUgsqJvmG6KUoBaiF4wu/JEyEXu8uRSxctq9VNE773knX0vV1Hqboon65Z0yi+bpZI4fhQXnXHWpFFo4yUz1SHFqNOIMpoCQAAMEYmd3d308zMTMq7MgA41znS46Fdrb0iMpMn6OJp+jmES3p+rcBaonN4QmiM0wOjWhMtETiyUxqxLllep9tlzAWtK1c10MHuIXHM+o4LOWaxpalSONiN04ZrM1QjsWZcVlUqim/s+I+2bxEAsLiBPgIgfnhf3R/2t4nf37h1ecxIc4bvvfKfHAsZk1mryBqMGo2ZaJPx9/siseZXrIwYx+Xe3v7xKdEIZK10+aoGYcgyA7kmhuNJj/UNa8+bn5eq0zK3hpS4HgUAnPtAIyUGmn4gY3joyBl64GCH5vKJFbfAe2oePnJG+3ghwbakopjcjlxRkDrWm5xg+9lLJ0SkKHPzxpY5Gesc0/Cff3UppQN+LM5dP9ITEWuZXNBiLl5RR10jk+TIy6ELlQYpAACoS5i/8pWv0MjIiDgGAMT+x81/PHmQhqd8ovD0pTdcFPNSceOrd3RKHK+sWbiww072P4cn5Dj6KdGmX9/4NP3pUIfmHn/9Zn3CARff/v7yDWl7aVUnu9RIha68ObvzMol371xLjx7tpEtX1M9bnAQALE6gjwCIH95J/MtXT4vjsgI3Xbc2unmc9/6qe4UXqiG5HXkiZvP0wJgwR3FMZ6INuf/b3y60G7O9pXpObCfXvL76xospXXCNqme0U1dDmi/S1G74+rxr51rqHp2g121KPTELAHDuAY2UGJlp8QCLklPhHX3Mc6d7o36Pzx+grz6+T+yGkW6g5or5CzuhPPBQg2xo0kuDE6E/Gy+He0eEmGQqCl1zClpWIHfiqGSyYGO32pu2r6Tbtq1AQQsAEJXc3Fxav349rV27VhwDAKLD2kUWjXg3cWc45tvI4W4P/fdzR7SPr1rduOAlNaYhJMpvDpzRYqteu7FF23dsFdzc493OKqtryjNae3BR672XrhdJDgAAYAT6CID4OanUkHad7olpnmJ9xCZqhiftz1tSveDPVustJ5THiYeBCS/98VC7Vo962wWryWpUY1Q2GMeZG9Y30zsuWpuxa2wAAPYCjZQYqLKBjOGMZ0I7fqG1V5usk3Bkw71PH6KT/aPiYy7yfPSazXEVdtRMdnV580LwOfxyX8jBzvzN9lVzpvysQC58lpQVuKgmxV04AAAAAMh8zhiafBzzaYRd6P/+xH5NO12/rklERS0ERz8Vux3apB9rrXg52DVEe7o8mi55w5ZlZDW803lzU2VMzQcAAACAxVFD4hUw0Qzev97bSs+eCjUEXXm59M/Xb4urqaQ2yI4nmBjFpqiZQEhT8XqZ+tJCshq5JkZl9QKx7wAAAM4d0PQDGcH0TIAGwtN7zOj0DB3qHtJ9z89fPkm72/vFcb4zj+68bitVFcXX+FILQIm4tB471kldY+GYrOpSsXzZDpZXlWhFOSlAudAFAADZSiAQoGeffZZeeOEFcQwAiM7Z4ck5TT91DybHnn/l0b1iNzLDu/PYJR2PTuDvkU72Ca9f7DCO6//f4Cz9dPdx7eM3b19piykqmpM9k3ceAwDAQkAfARA/Z0ciTT9WRi+09s2JPf/t3lZxzKro9is36nbHzYeqJ44nUEPiPcyvnB3Spgp516AdyDUxqtGrtAArFQAA2Qs0UmKg6QfmhR3f6q900TUyIURaLCc7x2vKfX9cw/rIVZvmZKLPh+poOh7nIubRaR/9ak8oH555x0VrbIuL4sdVIz4zOdoTAADiYWZmhr785S/TN7/5TXEMQDbBTTerNNKZYf2kH+/sax0c0z7+7rOHtdjzpZXF9OGrNokoqXhJxhj1+LGzmrt+RXUJXRHHVGG62NxYJQp5DMu0VTXxFfMAACATgT4C2Y5RH6lGJTPh1S994T3Gkl2tkYhPNjJ9T4k9f+sFq+nCpbVx/3w2mFcVubUYUWMSVTT8wSD95MWIKYpXntgZVanWkNRIdwAAyEagkRIDQckgKixovvLYXtofdiipEQEfv24ruRx5pl45jqUy8lJ7P73n4qBoeP3PSyd0zbdtzQtnsKsUuZ1iUTI/DhfKeLKQpwVjMTrloy88ske43plLV9TZ7hzngtrzrX2ikHd+HBn0AACQ6XnsmzZtounpaez0A1nF0d5h+voT+0UqgcTlyKW3X7iGrlvbZPrjnY2ikXad7qUV1aW0/+wg7ekcFJ8rL3CJFIREJ+6MEegL7QJ8sa1PN+X3txfaZ4piSsRunip69cwgbW2qsm3iEAAAzAD6CGQzP37hGD1ytJPUPl9DWSH9643nxZ3SFC9dI5NzjOOnB8aod3SS6koL6RevnNT2Dl+7tpFeu3FJwo/BGolrMD5/kNqHxoT2isVMIEjffPKA2L8sjVjx7FdOJzuX1dHv9rWKqNELl8Xf8AQAgEwEGikx8K9iEJUDXYNzGn7M4W4PPX2qx/Silrqvhnf1DU16RUwVF7P4mAUdw423G9Y1J/UYLNi46ccC9PTAqGhgRmN40kuff3iP1ogsdTvpb3asIrvhRue/vf4CKnQ6hHAGAIBsxuVy0Re/+EXyeDziGIBs4f4D7bqGH8PFoJ+/fEKYhMxsOrE7XtMj+U4a984Q16+eb+0V2uR/Xjqpfe9bdqxKqqDGMVc8GMg/d6E0hOdO9dC9zxzSinlXLK/VRUfZxQev3CR2PmNXDQAg24E+AtkK79N7+EjnnM/zxN3/HWind+1ca+rjdQ7PrSHJxKh1deXaahjeO8xTfsmsR+GEJW76MayRYjX9eOrwa08coH1nQ0YsZ24uvefidbaaohiuG335DTtpwjdDq7DPDwCQ5UAjJQbiPUFMF7ukuaJIF5X08OEzpkc0cLyn5Jaty7TjJ46fpV8rEZtvT1KszXGy90Wen1Go3v2nV7QCW0Whi/7xinWmu9KShQtzaPgBAAAA9sAxVVJDuPJyhbaoKQ5phElfgJ45GYmVMgMuYHE6gdQAW5qqtM9/f9cR6gibpnj3b7J7hzm9YXlVSOexyWrM0NCUPHmii+59OtLwu3JVA73lvKWUCXCjlSOs5ktxAAAAAIA1NSTWRqyRnHk52m49uXs4HWlRb9gSqSFx0081Rf31+SuSNmStrVPXxESvIbFO+8pj+7SGH+vDD16y2vakKAnXj9DwAwCAxQeafmBBwfYvN5xHn3vdBZpoYXF1qNtj6pWTe2G4WMMRCEXukCjjqCbppt+5vDYl4aTuwTsRxcnOkaZfemQv9YRz4Tm//TM3baeG0oKkHxMAAAAA5w4ctSmjv7c0VdLdN++gf7x2i/b1h4+cMXW/n5qE0FReRJcsr9M+fvJEt3b8tgtWp+QmX1M3/16/A11D9N1nj2gxWpz48L7L1tvuYAcAAABA5tWQ/u6SdUIjyZ2/3Bh76kRXWmpIzLbmqki9yjNBpwZGNQN7KhGbLRUlIsKdiZWG8O1nD2n1Ma5nfeKGbbRe0VUAAACAHaDpB6JmkZ/qD4mkupICqigMLS++aUMkA/1Ph8+YduVYAPaPT4vjprIicubl0kWGBcuO3Bz6m+2pRWzWlxaIvS/M8f6ROUW5UwMjmlustiSfPvPa7SILHgAAgPn4fD768Ic/TJ/4xCfEMQDZVtBaVxeKCV9aWULr68u1SbkDUeLRk+XscCjenOHdxNtbajTXvIT3/MaKLI+XtYqpKpoxih36ktdsWELvvngtGn4AAJAGoI9AtiI1EvuBZAPuNesjNSSO/jTTGHU2nBbFTbnq4nydMUryth2pmaLycnO0KbnBCa9IhlKZ8M7QS22hGNECZ54wzK+vT02TAQAAiA40UmKg6QfmcLJ/RFt4zFnokguW1oisdGbPmQHqHQtNxJkl1qQTi7nYINhuXL+EaktSm7jjWFC564Vd+nJPoESdXuR4iJpiTPgBAEC6CAaD1NraSu3t7eIYgKxr+oUbfbIRJnnoiHnGqDPKvprmimIqdDnovOZq7XNcx+JdfqmyWklDMEagc6Q773SWhTV+vGSj1gEAAMwP9BHIRnjnME/YMcsqS7Q4TdYum8LGJK4f7e0cMOXxeIdeXzihiU1R3NjbuaxW6CIJx35vbQ7FoqfCGmUXnnHaj3WhbGNeubohYyI9AQDgXAQaKTHQ9ANxF7Qcubl03bomcczC5hGTiloclSXhST+GHeuywchRn+qeP7Oc7MeU58kc6Yl8vAHuLAAASPsS5s997nP0L//yL+IYgEyHm19Hw1rB7cgVRS3JjpYa4TJn9nYOUrfBWGSGRmosC6UPXKbs7rt+XbOI/UwV1lzy/DntgVMfJH1jU2KHILO2tlwkMgAAAEgP0EcgGzkWo4Y0xxh1uNOUx2MD96yhhlRe6KZNDZXimJt/HH1uBmoEurGGdLgnYhzHhB8AAKQXaKTEwL/awRyO9UbcS1zcUbl2bZMWK/XkiS6amvGbuq9mSXjSj51ad1y9Wbil7rrhPCp2h2I5U0UVYq+eibjMuLglne1c+OJYUwAAAOkjNzeXtm3bRps3bxbHAGQ6HEUum1+cHMCRTxLWLTesa9bt9jOjyShjx2uK8zXXPDcYedrudZtaTJnyk6wPpzv4AkE61B2JKD2smKJkjCkAAID0AH0Est04bqwhnbekWquv8I7gTqX+kyydShLCkopi7fh9l66nq9c00keu2kwtlZHPpzrpJyUf15BYn0XVSOHYdwAAAOkBGikxUGUDOjhj/Xi4+VWa7xR78FRK8110yYqQw3zSF6BnTvaY6mJvLo8IM45G+PvLNtDK6lLTXqWVNaVUURiaKDnQNag1LVsHR8nnD2oFLcRWAQAAACBeFzvDRSaOv2SeOtlNk77UjFHcYOS9xzK6SsIa5fWbl9JbL1hNbkeeaS/SjqU12vHu9tB+GqOLfWOKuwMBAAAAcK7vPNZrJGGMWq8ao1Kf9pOmKEZNPODUAm78XbSslsyiyO2kjeEJQjaAtQ2Nafv82gdDxy0VxVSSb45RHQAAADADNP2Ajo6hcZoKF5jWxWh+qcuYnzh+1jTBlu/Mo6qiUKRnumDBecHSkACcCcyK3YTGfX4cLQoAACC9BAIBeumll+jVV18VxwBkc0GL4VSCy8PRm9ys29Xaa1oSghkRnguxtalKa1q+3NFPgeDsnH1+y6vMM2IBAACYC/QRyDa8/gCdHhgVxw1lhVRWMDe2/6rVjSIanXn6VLcuRjwZzoT3BxqNUeniQqWJuLutf84+vw0NSEIAAIB0A42UGGj6AR1HdAWt6M2vZVUltDQclRBqEibvZOeiGLulZBa7FRN2F0Zxsqv7/DZinx8AAKSdmZkZuueee+j//b//J44ByJamH8d6rqqJ7HdRuWJVg3Z8IpycYIaL3YqCFk8NbmuuEsdj0zN0tNdDvdjnBwAAlgJ9BLKNk/0jFJyNbYpiCl0OzXzNCUvt4Wm5VNOi2JAkdxKnkwtaakhWqna3981JQtiAGhIAAKQdaKTEQNMP6OACj3G3SzRk5CZru/ah5DPZz44oBa3wPr90w83MYndoL87ezgERv6Xu86vFPj8AALAkj3316tW0YsUK7PQDGc/olI+6RibF8fKqkpixmssqS7S9L6fDkU+mNP2UfTXp5KJwQU4ao9SCFvb5AQBA+oE+AudaEoJEXdvSmoJG8vkD1Dc2pZmiOM0p3fD04trwc2M9yHsJ5T4/fvT1aPoBAEDagUZKjFDnAwBu4M3O0tGwcClw5s27+Hg5C7bjXeK4dWB0XnE3H+oSZ570swJ26O9oqaEnT3ST1x+k3+1r1fb5cbQn9vkBAED6cblc9LWvfY08Ho84BiCTOapM7c2neVyOPFpSUSwMUexC58irZPfuqTuPG8sKyQq2NVeTIzeH/MFZeqm9j8a9kSlc7PMDAID0A30Esg1ZQ1pII62oLtGOZRxoMnDTbdbiGpJMjJINzj+f6Irs86ssFhHvAAAA0gs0UmJg0g9o9IxO0eh0qLizprZ8XscUu9wlqTjZVRf7Eosm/Rh1sfOfDp/RjhHLAAAAAIBkXewyBp2ZneU0hLGkjVhSI9UU51OB0xqfHsdvbWmqFMeeSR+92BaKsMI+PwAAAAAY4f2/J/pHtNQk1iyxWFpZQrLElMqkn7rzmI1WVqHu9Xv4SKfWeMSUHwAAgEwETT+gISMumbV10XfVSFoqisXEHNM6OGrSAmbrBNvGhkoxzSiFqmRDPRYwAwAAAEDPMaXpJ+OdYrGiKvX4Kt53zHuPrdrnpyJ37qgaaW1tOTnz8M8GAAAAAERoGxoT6UlCK9SVzZuaxMkHcjKPG3czgdCfS5QONS3KQo1UVZSvTSuihgQAACDTQbynDUWj430hJxTDmmhTQ6XmCs+GWAaGCz/sqmobHKOu4UmamvEn7EJ/4GA77Ts7KI4LXXlUVeQmq+DzP39JNT13ulf7HPb5AQCAdfh8PvrkJz9J09PT9NWvfhURn4scjsF8vrWXxsKJA3Lq7OLldeJ3O2GNI5t3vH94oQinVOOrOFLzm08esMXFznAE+vdyjpDiicI+PwAAsAjoI2CEJ//3nx3UNZo4eWlTY2gyP3NqSBULfj9rJH4+wXAawqqa+c3mRl49008PKUlNVqZFyd3Hpwcihi7s8wMAAOuARkoMNP0shBtkd//pFRH3pMKRSV+79WLhHMqEST/e5RKP+FpRVSKeEz8d3l2TyF4/3qP3y1dPax/fsmW55bv0OJ5Bbfphnx8AAFhHMBikI0eO0MzMjDgGi5v7Xj5JjxzpnPP5g91D9JGrNpOdnOof1bTbutqFtQ7HV3EYAhe0Eo1AH53y0Rce2SN0FVPsdtC1a5vISripyYkIB7qGtM9hnx8AAFgD9BFQmfDO0GcffJkmvP45F+ZTrzlf1DDs5HgCaVHM8qpSevpkjzhmQ1UiTT+OHP+PJw9opqTLVtZTTXEBWZ2G8PNXTmkfY58fAABYBzRSYqDpZyGPHz87p+HH+PxBUej6mx2ryC7YVc47/WSxKp4Ip+XVpUTHu8Rx68BoXE0/3lHzqz2n6Xf72rTP/dX5K+j1m5eS1WxtqhINV77+DPb5AQCAdTidTvrXf/1XGh0dFcdg8cKTdE+dCOkJIy+29lHf9imqLbG2qKNyUpnWW1UTie5cKA2BG3dnhyfEFCNHWi3E8KSXPv/wHm2XX2m+kz75mvNtee4XLq3Rmn7Y5wcAANYBfQRUdrX2Rm34yeQku5t+J/tDGinfmRdXMkGyaQjPneqhe585pNXTLllRR39/2QaymoayQjFdKNfUYJ8fAABYBzRSYmA5h0X4/AHadTrkaHI7cukjV22iD165UUzVyYYgF4XsdLFLVtcuXNCSkRKSeJzs3PD7n5dO6hp+b9mxim7dupzsgAtwHPHJ8KsAFzsAAFhHXl4e7dy5ky644AJxDBYvL7T2aftgdrRU0x1Xb6Zr1jSKj7m28/CRSIyTHZzsj8Syx+tIl7Hts+H4qoUYnJgWaRCy4VdR6KLPvHa75dGeqpM9LFGFKQr7/AAAwBqgj4DKn8Mma+Y9l6wTGkmuRdnTOUjdI5O2XbChSa/4JWtDuXEkN7HBXH5bvHuPnzzRRfc+HWn4XbmqgW6/YiPlSaFiMTuX12nHmxvtbboCAMBiAhopMdD0swiOIpj0BTSRwL8uXVGvCQZ2bz0XbgrawckBpaBVHV9Bq6WiWBNarYPzu7SCs7P04xeP0x8PdWife8dFa2yZ8FN5647VdOmKOiGg7ZwiAAAAABYrf1am/G7ZupwuWlZLbzp/JTnzcrRiD08D2gEblqSLnXcLssM7HlZyGgLFV9TqG5uiux98RUtc4GLeZ27aTo1l1u6pUSkrcNE/XLFRaKS3XbDatvMAAAAAFiu8SkVqCJ6Qu25tk9BIN65fon3PI0fPZIQpanWcpig2XjeVh/TNGc84zQTmj/h/9GgnfffZI8IExvA1eN9l6+NqMKaL125ooWvXNtItW5bRec0hEzkAAACQaaDpZxFPnuzWjq9eHXKvM6/ZEBFsvJCYi0tmwiKK3WGqIIuGLGjFG12lxlcxXcOTMQty3PD7/q6j2q4elmd/d8k63XO3i+rifPrglZss35cDAACLHc5jP3DgAB0+fBg7/RYxPNl2oi+kUTguifcFM6UFLrpkRb04ZtPUs6fMN0Z1jUzQY0c7xb6cWAxOeGlkyqc18uItMunSEOaJr2KH/j1/eoX6x6fFx3UlBfTZ1+6gutL4movphM1prJFkcQ4AAED6gT4CkqdOdkWtIV29ppFc4XUsT57opkmfucYorkmxaf3VM/3z1qeSqSExUusFF0hDePBQB/3w+WPaxzdtXELvvnitrQ0/GWX6d5espzdtX0k5Np8LAAAsJqCREgNNPwvoHZ2kw90ecVxfWkBraiMuKC4grQ5/zLngh3tC32cWv9/fRv/93BH69B9fFqIttos9VHAryXcmNPEmBRtLQd5dEw1u+MlYCtZE/397dwIfZX0tfPxkI2ELJEBIAkkgbIKssgsiiApetWrttVptabX6tsX3U6sf+pYWoXWpn6qvdanWT6u3Vqtt1d7ifa1SURFRkE32zQBhDYQlYQlL1uf9nH/mefLMkEAmM5nkmfl97yc3M5lJMjk+JKfnf/7n/8PLBrHIBgAxrqKiQn7+85/Lww8/bG4jNrnP8pvcL9uveDJ9oH9jlDYRhbMp6tEFa+TlZdvMWM2GCmYFfqM9G1/Q0vFV9tSphkagHy47Yxb8dGFRZXdqJ3P/Y6RpSAIAxCbyI9h5yhJfw5NOPhjvGinZITlJLutb2xh1trJaFrsazMNhxe5D8vSiDfLEh+vl3Y11k5rCMf5c9e5y4WkI72/aI6+tKHDuf21Innx7dD8W2QAghpEjBYdFvwhwJ2HaoRXYDTR9YE+/ola46GLeEt/31jrZs59srHcMZ/HJM1LmOxxaFyGD6Vbq7RpfVV8n+/5jp5wFPy1+/e/LB8tlfbOa9PMAAKKH/q3JycmRHj168D/gY1RVTY186stTdFz4xD61BSz3uXgDMzub20XHT8vGopKwfW9txrLPodGmq2c+2WBeT7gKWu5pCJoL1Xdus3awH/PtItRdjnOvGSnp7WrP6QEAxCbyI6hVew6bI2DUmLwMaZ+c5BcYd2OUnn0czsaoT7fXTVd4Y9V2Wb6r+Jzn6Pez6z86ljwtiPxFR5XadtRTQ9IFz799ucO5/40RveVWdtUBQMwjRwoOi37NTJOhxQW1BS1dS6tvwWtMrwynyLN67xFztks4aBHLHhelyqtq5PGF6+ToqbqPnVvQanwXu3unX0NdWu4k7qZhvf061AAAsSs5OVleeOEFefLJJ81txJ41e4/IibO1ozVH5naV1JQ25zzHfW5NOBujVgVMP1i/v0Re+WLbOWOs/EZXuRqdghnxaTUwvsr9tX9+9Qhzjh4AILaRH0HZjdP2OM9APdM6yOCsNHO7+MQZWbf/aFgCp01KgU1Wz3+6yRnFbtPz+LS+pPoEWUPSaQh2n7meWxhIm6UqfF97TF43uXl4Pg2CAABypCCx6NfM1u8/6nSS6yG/9XVAJcbHy5UX9XAKQ/bZd+HoDnPPHVfaUf6bhWv9xli5i06NPYDZpl3s2p2v6ttF6F4IdI81BQAAsU3PoanvrBq3UbndTAe5WrPvqDkDLxwNWat9OVJifJx5Ux9tK/IbY6U7/+zcJqNjijlnMBj5rkXCwMYofQ17fGPR9Ry/zuzwAwAAInKk7Kyz8NatQ4oMzKxd3As0fVBdY9T7m/aGrX5VUV3jV0OqrLbkyY/WmQlR9TdFBVfnSU5McM4L1sVD3dnn5s6Z7KNwAABAcFj0i2RBq54OLdvU/j3MrHb1+c6D5z0wubFWuhb95l5ziSkq2TsAX1q6pd6ETcd7BsM9vqro2Gk5U+l/Jo67s13HdAEAAJSeLpc1+46YQOi0g6E9utQbFG0scu/2W1pYN3KqqXQcVenp2rGaQ3uky/+aONBvjJV9DnNtIcoKerRn4E4/+3u6FWkXu6/IldelNo8CAADQ0ed2NWhy/2yJb+D4lRE5XU1TktJFwuO+keHhahz/0WWD5GLfbkKdzPB/P1rnjBENZVqUe2JUTT3TEHa5a0jp1JAAAGgKFv2aSHfKXWhuell5pdNJnpqSJMN71l/QMo+3bSNDstOd3XjuRKcpdISnPSpBF9v0sOT/c9VwaZ+caD62rPCQeVy7quwkK6tTu3NmxQeTsFkB4xk0PvZ9LejVN7YLABC7hzA/+OCD8uijj5rbiA7atOSeJtCQz3Zog1Pt7Ul9sxosaCn3aPA1e4+GtaA1KjdDJvbJMufF2P7+5Q7zc4Qy2tMeX+XbRCg7A3b6ufM8zdEAAFDkR9FLG6TrOz/YTfMP+7xjTSEur+d4GJvmTnaOpCnVWl8zVVNV11jy5d4jzi6/4T27yk+mDJEends5zeNLd9Y2X233NTNp+uaebNBY7txn55GTDe70o3EcAGAjRwoOi35N8NmOA/L9NxbLfW8vNYcaN7Qrb1lhsVRp65KITOiTacZ4no+O/7TZyVZ4ClpdnUW9bwzPdz7+3+sKzaKc/RqbUtBSvV2f5y6QHT55Rs5UVpvbJGsAALeamhpZu3atbNy40dyG92mzz8MLvpS7Xl8sv120Xg6XnWm4oLWjbhKCLvqdT9cOKZKT1t7ZMRdqJ7udI2kx7ZKcrs65wz19o6a+OnRcNh4o9Tu/pm8Txku5pyHo+TTuxdBdR2tHe6pe6ez0AwDUIj+KTjuOnJAf/HWJ/OBvS+T9zXsbXPzbdui4M0ZTd9l1aV+7k69RNaQQF/2+OnRMysqrnEkImsdoU/id4y5ynvOPtYVyqrxS9peeMvfz0jqYcZ3Byu9at4OvwLVrsHb8+UlntGmHJjSlAwCiEzlScFj0a4J3Nuw23emHy87K04s2mgJX4EgCZXdoqUl9zl/QUtpJFa5O9lW73Yt+3ZzbUwf0kM6+M2lW7j4sH32133msKaOr1KDMzs7tDa5Dn90dWu4RVwAAJCUlyQMPPCAzZ840t+F924qPyZaDx8ztFbsOywP/vUze/HKHnPU1ANl2l5TJPl+xSM9q0aakC7GLWqF2suuZgPuPnXa+dydfTqTd8jcN6+U87+01O50udj3zr6njpexzeDRv3HTAlSOx0w8AUA/yo+j03qY9Zqz3qfIqeXX5VzL7nRXm/LxAS7Y3vinKzmXsaU4b9pdccCdhY4+HGe2qIQ3KSpOBvprPwRNn5LWVBc740abWkHSnX3JivFNDshvpNU8rr6r9GWgcBwC4kSMFh0W/IGmntl2osmmBa/b/rJAPt9UtoBUdP+XsestN69CohEU72fW5oXay61jRzQdLne4o+2sq7da6YWhdUWux68zBfhlN2+mXldpOurRPNre3FpdKRVX1ubPYWfQDALgkJCTI5MmTZeLEieY2vG/5rkN+9/U8vH+u2yU/nf+FGTtuWxxkQUtcO/JC7WT3n4RQV9BS43p399vtp4Une0yn5k9NYY9uV+t9jVGWa/y5NmLZC48AAJAfRR+tjwROctp37JQ89sFa+fPyr/yep9Oi7PGao/MyLvi1tWlpuO9cZJ2ypA1YTaG5id04rqPJ3Q3pyj0xyl1D6tOE8/yU5lV2Y5TWvXR0qOI8PwBAQ8iRgsOiXwgFrUvzu0v3jm3NbW1MenX5Njl4orZAtGR77azzYApaakRObcKmfU5rmljU0g5438ROGZXXTeICzslx7/azJSXEOSOogqVf3y5qaYFvqy/R9B9dxU4/AACilY5jsnMk3Rk3fVCOc56dTkb40xfbzG3tQLfPg9HcY1yvCxe0wtnJvvI8i36Bu/1sfZtY0FLaGZ/gC4S+bjse9qhPJiEAABDd1u0/6kw9GJyV5pdXLNi815lgoI1J9vEoY/MyzMJfY4zICf2YmD2lZSY/UYMy084Zq+ne7efW1J1+aqhfY1Ttrke7KUrROA4AQNOx6BekZbtqO6/Ut0b1lSduGieX98tyFrz+a9k2U/ha4jurRtfbJuTXHq7cGO6Z7E1d9GtoLENDu/3s8QoXOnPwfIb6usvc4xkKj9budOyQnOjsBAQAwJ7HXlBQIDt27OBMvyigneXHfBMKNCeYMba/yZHsXWyr9xyRlbsPybp9R+XE2UrzsUtyujX6rJZwdLJrJ/l23zl9uqOvvrGi7t1+4Vj0a5uUKP195wHqGT36xiQEAEBDyI+izxeuxvFrB+fKr64dZWpJNq0hlVdVy6euxvHL+mY2+usP69HF1J3Umn1HQ5+EkHduDSlwt59q1yZBshsxor0hQwJqSIpFPwBAQ8iRgsOiXxB0BIP7DBo9VFkX0LSwZS9qabLy0tKtcvRUuZOAdW7X+AWvwE72yurgOtmPnS6XNb7uLl1s659xbjdWfbv9QiloqcFZ6WLvJ1y/v0RKz1Q4RT3d5Re42xAAENsqKirk/vvvlzlz5pjbiJ5JCPbuvexO7eU7Y/o5H3/li69k4db9TZqEEI5O9kUFRc4ZNCNz/cdWnW+3Xyhd7IEjPjVPdBe0dHQoAAA28qPoHe2pdZ7B2ekm17hucK6zc86eiGDvdtNjX+zRl42hDVQDfHUfHU1uT59qrOoay29k58ic+hf9Anf75XdJNT9LU/Xo1E7SfbWyLQdLTe3LPvM4NSVJ0hh/DgBwIUcKDot+QVju2uXnHkelXdzfGzfAub/oq6ImF7RC7WR/b/Nes+NQTe6X7YyUCqSLlTe6iloXZ9UVpJqiY0qS9O7a0RkN4T6UmrEMAIBA2gySkZEhXbt2pTEkykZ7jnRNGRjfu7tpgFIlp8vNiCu7mDO0R3C5Ryid7Fp0e3/THnNbv4bmSA0xu/3Sanf7aVOXPco9LNMQ9h/1W/RjvCcAwI38KLqsdY321LHi9nQl/e/8/UsvMnmT0kU3PTJGXdYnM+jFtBE963INuwm8sZYVHnRGe2pupouODfnPEXW7/XQBMxTmmBhfLqg1rM93HpRT5fb481T+9wEA4Jy/G9SQGq92SxmCHsswNuAMGi1wjcnrJit8hx/b4w4Cz4tpbCf75zuLnRGfjU2mTldWyYdb95nbmjxec3HueZ9/1UU9JU7/L84/SWyqodldZOeR2kLW/9uw2/k4i34AgEDJycny8ssvS2lpqbmN6Bnt2a5Nol9ifuf4ATLrn19IhWt6wYQ+mUGPFddOdh2Vua34uNPJnpnauLFSi7cfcCYQaOPW+T5PC22zpg4zTVya74U6rUAX9nT6Qll5lWw8UCJJCQlOx3+38xTWAACxh/wo+ich2HQigh678o+1hX4fv6xPcI3jdg3pr6t3OI1RF6oF2fRYlndctZsbA46BCaQ7EO+bMliKT5yRaYNyJFR6rp+9y9C/htQh5K8NAIgu5EjBYadfCKM9A31nbH+/w5a1u1131AWrqZ3si3cccg5+1h2G9qiE8xW1rh7Ys3bxLwzjN90d+0XH60ZK6HhPAAAQewUtldGxrXzD1RmuJjWhoKUucZ993MhOdh1b5S4kfW3I+Qta9mv+5sg+YWlc0nzLbuA6XVFtzha0R3sy/hwAgOikUwZW+87Ks0d7BtJFv8zUuokCWmuq78zhC9HziO0dejoq80xl7Y65C9lw8LhT59IjXy7qXv/xMG5je3WXrw3tJcmJdbWvptKY2JUoakgAAIQPi34hjvZ004XA20fXnl2jYzX13LymaMxM9tMVVVJ88oxfQvnR9trXqOt31w3Ok0jTM2+SE/0vKb3flKQVAAB4a7RnUoL/aE+3ay7OcRbQtKDU1MU097l+DTVGad7kLnat2lfiN7aqJSYQ6DSEQL3S6WIHACCaR3uWV9WcM9rTTZvE75kwUOxTWaYN7Nmk76VNRPb0pqoaSzYWlZzzHD0zT5vZNXezLdhW5LcAGelmpNSUNvXmZUyLAgAgNIz3bAQtHC3ZfrDB0Z5uVw7oYQ4k1h1/Ooe8qS7J6Spbfef5rdx9WK4fUreId+JshRmTpWOqRuV2lTvG9Ddn6J0or5TEhETz+lpioU0T1kGZaX5FuNz0jiEd7gwAiN5DmB9//HE5c+aMzJs3T9q0adPSLwlNsGrPYWe055Bs/9GeblromnvNJbJ+f4nJFZrK7mQ/UnZWNh0okbLyStMsZftw2355eelWaZuUIDcPzzcTDdwFrQuNrWouQ+rp7uc8PwBAIPKj6KALax9u3X/BxnF7ZOaj14+RUxWVcnFWekg1pIW+76nHzozOy/B7PXP/tcqcK6w7+maM7W8WB7cfLTM1JM2v9PNbKkcqdJ13rDmcTlwAAMCNHCk4LPo1YiTUc59sdHbVDczsXO9oz8CkLVSj87rJG6u2m9tLC4v9Fv0+33HQOZdm1Z4jsnbfUUl2jRX9muu5kTakRxe/RT8KWgCA+tTU1Mjy5culsrLS3Ib37C45Kb9fstm5PyG/+3mf3zaptjEpFNqBrmcov7dpr9RYWtQ6JFf07+GcS/Pepj3mto47/8vKAvnXpt1y+OQZU9Bq7Niq5qALldqQpRMcbIw/BwAEIj+KDn9dtV02+HbbpaYk1TvaM9w723TBUJuvdCqUNmXpNKg2vhGcmw+UmgU/tf3wCXnw3VXSqW1dw53Wm1qqWVunMPyP33l+NI4DAM5FjhQcFv3OQ4tHr674ylnEatcmQe4cf5FEQmZqO8nv2lF2HjlpkjMtEtm79z7bWbfrUGmHVlV5ldMlFcoOw3AcxOxGQQsAUJ/ExES599575eTJk+Y2vKXkdLk8vnCdnPWdJawLceN6n3/RL1wuzc80i35q2c5iZ9Fvpy9fcis9XbsLsaXGVgXmSPbra5MQL9md27fYawEAtE7kR96nUwfe3VjbhKRpxw8vG1TvaM/mmLykzeOLCw6Y/EzrWHazVWANSdlnDHdpnyyXXqBxqzn1z+gsbRLjpcI3ClXPPAYAIBA5UnA40+883t+8Vz7Ysq82UHEiP5ky1Iw9iJRLe2c6t5cW1iZpRcdPmYVAlZvWwXRkJdoD4FtwbJUtu1M7kzTa2OkHAGgoYZs2bZpMnTqVRT8Pjj1/YuFas/Cn+nRNlR9NujhiHeL5XTpKd9/Yp00HS+WY73V8tuOg3xmC/TI6OfdbcmyVu5PdlpvegfHnAIBzkB9529p9R+S/lm117n9v3AAZ3jNy+celrgYsu4akO/5W+M5f1mNo7hjdz28c+3WDtabUcqVB+5gYGzUkAEB9yJGCQ2t9A1buPiR/WVHg3NfDlS80kiHcxvXOMKOp1NKdxfL1Yb39ClqT+mbJtYNz5Yr+2fLvLXslLUlkUFboo0VDoR30E/tkyjvrd0u3DinSgy52AACihp4Jo2PPd5WUmfv6t37WlcMk2Tc+KlK5xvje3WX++l1iWSLLdx+SKwf0lKW+LnZthrp5WG9T0FpWWCxfFh6QGy/p1+KLbIMy0yWtXRuz+7ClFyABAED4x54/88lGk5uoay/Olasu6hnRMOuITx0nqsfBrNl7xDRqrdt31Iw9V2PzMkwN6bK+mbJg8145e+aMOf+4pWkNSY+t0UkIF7dwTQsAgGjAol89yquq5aWlW8WXq8lNw3rJ5f2yI/tfxoxZSDFnz2wtPiZFx0/L7pIy+dxX0NKy1XjfCAYdBTpj7AApLS2V1uDm4fmmU0vHMmjXFgAA9Y3Q3rt3rxw/flw6d+7comMX0Xh6rrB77PlPrxzmdyZMpOgYKl30M69pZ7FkdmznnHesC2rtk5N8z8uUgWnJkpbWQVqadtc/fN1ok9O5O9oBALCRH3n3v9vLy7Y5Y891zOa3RveN+OtIiI8zIz0Xbt0vldWWrNp92DRH2Sb0qZ0mlZrSRm65pI+pIbV0U5S9QzG9XbJ0bpts6mAAAAQiRwoOKzL10G712VePMN3YE/K7y3+OyJeW4p6t/trKAjl08qy5rd1PmhS1RrrQN7RHlxYpAgIAvKG8vFxmzpwps2bNMrfhDdqJffPw3qaoZMaet9BiWk5aB+mZVjtyveDQcXlnQ+0CoLug1RppIUvPX9b4AQAQiPzIm7R57b4pQ6RXegfJ79pRZkZw7HkgbXiyLdy23+ygU53btmm1u+g0fgMz0ySrU7uWfikAgFaKHCk47PRrQK8uHeWR68dIx+SkFt19MCYvQ/70xTYzImLzgVJPFLQAAGiM1NRUqaioIFgeojnRN0bkmxHjGb5z9VqyK/zN0p3m9paDx8x7Hek5IoJn5wAAEG7kR96kTdlz/2OkVFTVRHTseaD+GZ3Ma9Gzl7Uxyt1Q3hp29QEA0FTkSI3Hot95tIaddLpbbnBWumwoKnE+lpQQZxYDAQDwqpSUFHn99dfNWCG9DW9p6QU/pef6vfll7aKfbVyvDEaLAwA8i/zI29omJUrb2gnjLUYX9jRH+temPX4fv6xPVou9JgAAQkWO1MzjPT/99FO5/vrrJTs723R7z58//5z5qnPnzpWsrCxp27atXHnllVJQUOD3nJKSErn99tvN6qye43PXXXdJWVlZsC8lZrhHfKqRud1MJzsAAECs0jONdYRW4PhRAACAWDY+oIbUo3M7yUtv+fONAQBAK130O3XqlAwbNkyef/75eh9//PHH5dlnn5UXX3xRli9fLu3bt5dp06bJ2bO1Z9EpXfDbtGmTLFy4UN59912zkHjPPfeE9pNEsdG53STRdfbLRNeMdgAAgFh1ae+6nKhL+2QZ0L1zi74eAACAlpbfpaN0T62byjAhP7NFj60BAACtfNHvmmuukUceeURuuummcx7TXX5PP/20zJkzR2644QYZOnSovPrqq1JUVOTsCNyyZYssWLBAXnrpJRk7dqxMnDhRnnvuOfnb3/5mnodztU9OkrG9MpyC1tAeXQgTAMDT9Cy/J5980uQAnOuHUDrZkxNr09krBvTgrBoAgKeRHyEcdIHvin7Z5nabhHhGewIAPI8cKThhnRFZWFgoBw8eNCM9bZ06dTKLe8uWLZNbb73VvNeRnqNGjXKeo8+Pj483OwPrW0yEyF2XXiTDe3aR/hmdOasGAOB5NTU1snjxYqmsrDS3gaaev/yra0dJ0fHTMjqvG0EEAHga+RHC5drBeeYMZh2H3rUD52cDALyNHKkFF/10wU917+4/P1zv24/p+4yMDP8XkZgo6enpznMClZeXmzfbiRMnJBYPhJ7IwcsAgCihf/u///3vmzN99TaahhxJJC+9o3kDAMDryI/Cg/xIJCE+Tsb19q/NAQDgVeRIwfFEle2xxx6TX/3qV+d8vLS0VKqrq1vkNbVGsbgYGgnElbh6CdcrsfWSSZMmmWv25MmTEqtC/TdLjtT8MQaxjTSuWeLqJVyv4Ud+RH4UKfz7Ja5ewvVKXL2Gazb8yJGk0ddVWBf9MjMzzfvi4mLJyspyPq73hw8f7jzn0KFDfp9XVVUlJSUlzucHmj17ttx///1+P1xOTo6kpaVJampqOH8Ez9OYgLh6BdcrcfUarlniGm4JCQkhfT45UuPwb7f5EFvi6iVcr8TVS2L5eiU/ipxYvs6aE3Elrl7C9UpsvSaWr9mERtaQ4sP5TXv37m0W7j766CO/BTo9q2/8+PHmvr4/duyYrF692nnOxx9/bOay6tl/9UlOTjaLe+43AADgXZZlmSagw4cPm9toGnIkAACiB/lReJAfAQAQXciRghP0Tj89e2f79u3O/cLCQlm7dq05ky83N1fuu+8+eeSRR6Rfv35mEfDBBx+U7OxsufHGG83zBw4cKNOnT5e7775bXnzxRamsrJR7771Xbr31VvM8AAAQG2et3HXXXSYPmD9/vqSkpLT0SwIAAGhR5EcAAADkSBFf9Fu1apVMmTLFuW+P3ZwxY4a88sor8tOf/lROnTol99xzj9nRN3HiRFmwYIFfMe/11183C31Tp06V+Ph4ufnmm+XZZ58N+YcBAADe6sKOi4tr6ZcBAADQapAfAQAAkCNFdNFv8uTJ5x3DpcW7hx56yLw1RHcFvvHGG8F+awAAECW0Gejtt9+W0tJSdvkBAACQHwEAAFBDCoOwnukHAAAAAAAAAAAAIPJY9AMAAAAAAAAAAAA8jkU/AAAQcZWVlfLcc8/JH/7wB3MbAAAg1pEfAQAAkCOFikU/AAAQcdXV1fLBBx/IokWLzG0AAIBYR34EAABAjhSqxJC/AgAAQLAJSGKifPvb35aysjJzGwAAINaRHwEAAJAjhYoqGwAAaJGi1i233CKlpaUs+gEAAJAfAQAAUEMKA8Z7AgAAAAAAAAAAAB7Hoh8AAIg4y7Lk+PHjcuLECXMbAAAg1pEfAQAAkCOFivGeAAAg4srLy+WOO+6QyspKmT9/vqSkpPBfAQAAxDTyIwAAAHKkmFz0s3cE6O4A1NF4JCQkEJIwI67Ng7gSV6/hmg2vs2fPmgW/qqoqE9uKigqJRXYuE67djuRI9ceY/Kh5EFvi6iVcr8TVC8iPapEfRQa/F4mrl3C9Elev4ZoNL3Kk4HIkTy76nTx50rzPyclp6ZcCAABC1L1795iPoeY2nTp1CjkO5EgAAEQH8qPavIb8CAAAkCMFlyPFWR48SKempkaKioqkY8eOEhcX19Ivp9Ws8uoi6N69eyU1NbWlX07UIK7E1Uu4Xomt13DN1nZnabKWnZ0t8fGhH7VMjsQ1Fin8+yWuXsL1Sly9hOuV/IjrzLv490tcvYTrldh6DdesNLqG5MmdfvoD9ezZs6VfRqukC34s+hFXr+B6Ja5ewzVLXJtDODrYbeRI9ePfbvMhtsTVS7heiauXxPr1Sn4UGbF+nTUX4kpcvYTrldh6Taxfs50aUUMKvaUcAAAAAAAAAAAAQIti0Q8AAAAAAAAAAADwOBb9okRycrLMmzfPvAdxbe24Xomr13DNEld4E/92ia3XcM0SVy/heiWu8C7+/RJXL+F6Ja5ewzVLXFtanKWn/wEAAAAAAAAAAADwLHb6AQAAAAAAAAAAAB7Hoh8AAAAAAAAAAADgcSz6AQAAAAAAAAAAAB7Hoh8AAAAAAAAAAADgcSz6tSKffvqpXH/99ZKdnS1xcXEyf/58v8eLi4vlu9/9rnm8Xbt2Mn36dCkoKPB7zuTJk83nut9+8IMf+D1nz549cu2115qvkZGRIbNmzZKqqiqJVpGI67p16+S2226TnJwcadu2rQwcOFCeeeYZiWaRul5tR48elZ49e5rnHDt2TKJVJOP6yiuvyNChQyUlJcX8Lpg5c6ZEq0jFdeXKlTJ16lTp3LmzpKWlybRp08zvh2gWjtiqZcuWyRVXXCHt27eX1NRUmTRpkpw5c8Z5vKSkRG6//XbzmMb3rrvukrKysoj8jGhZ5EfejWss5keKHMn7cSVHCn9cYy1HIj+CV64zakgtE9dYzJHIj7wf11jKjxR1pNYbV0UN6fxY9GtFTp06JcOGDZPnn3/+nMcsy5Ibb7xRdu7cKe+8846sWbNG8vLy5MorrzSf53b33XfLgQMHnLfHH3/ceay6utos+FVUVMjSpUvlz3/+s/mlPXfuXIlWkYjr6tWrzR+8v/zlL7Jp0yb5xS9+IbNnz5bf/e53Eq0iEVc3LfBrchHtIhXXp556ylynP/vZz8w1++GHH5riS7SKRFx1AUqTkdzcXFm+fLl89tln0rFjRxPXyspKiVbhiK0maxq7q6++WlasWGEKg/fee6/Ex9elKbrgp9fqwoUL5d133zWJ4j333BOxnxMth/zIu3GNxfxIkSN5O67kSOGPayzmSORH8Mp1pqghRT6usZgjkR95O66xlh8p6kitN67UkBrBQquk/2n++c9/Ove3bdtmPrZx40bnY9XV1Va3bt2sP/7xj87HLr/8cuvHP/5xg1/3vffes+Lj462DBw86H/v9739vpaamWuXl5Va0a6641udHP/qRNWXKFCsWNHdcX3jhBfPcjz76yHzd0tJSKxY0V1xLSkqstm3bWh9++KEVi5orritXrjRfZ8+ePc7H1q9fbz5WUFBgxYKmxnbs2LHWnDlzGvy6mzdvNl9HY2x7//33rbi4OGv//v3N8rOgdSI/8lZcYz0/UuRI3oorORI5Umu6XsmPEInrjBpSy8Q11nMk8iNvxTXW8yNFHal1xZUc6cLY6ecR5eXl5r1uobbpDojk5GTTKen2+uuvS9euXWXw4MGmU+j06dN+K+FDhgyR7t27Ox/TzowTJ06YTo1YE6641uf48eOSnp4usSiccd28ebM89NBD8uqrr/rt+olF4Yqr7pSqqamR/fv3mzEiOjb1lltukb1790osCldcBwwYIF26dJGXX37Z7KbW0ZR6W2Pcq1cviUWNie2hQ4dM1792ul566aXm79Pll1/uF3v926XjwEaNGuV8TDu99Gvp5yJ2kR+17rjWJ5bzI0WO1LrjSo7UPHElRwo+ruRHCBU5UvMgR2r9caWGFP64kh813zVLjhR8XMmRGie2K+gectFFF5lxKPrLobS01BSUf/Ob38i+ffvMtmvbt771LTMeYNGiRea5r732mtxxxx3O4wcPHvRb8FP2fX0s1oQrroF0dOrf//73mB09F6646i97nXP/xBNPmK8X68IVV90mr4t+v/71r+Xpp5+Wt99+25yXdtVVV5mvGWvCFVcdU/XJJ5+Y5+i5DB06dJAFCxbI+++/L4mJiRKLGhNbvR7VL3/5SzNSRGN2ySWXmHN/7Lnt+vdJFwXdNKa6cBCLf7tQh/yoeZAfNR9ypNYdV3Kk5okrOVLwcSU/Qmv5vUgNqXniGogaEjWk5kB+1HzIkVouruRIjdSI3YBoBdtb1apVq6xhw4aZxxISEqxp06ZZ11xzjTV9+vQGv449DnH79u3m/t13321dffXVfs85deqUeY6O/ox2zRVXtw0bNlhdu3a1Hn74YStWNFdcf/KTn1jf/OY3nccXLVoU0+M9wxXXRx991Nz/97//7Tzn0KFDZvTvggULrGjXXHE9ffq0NWbMGOs73/mOtWLFCmvZsmXWzTffbF188cXmsVjQlNh+/vnn5rHZs2f7fd6QIUOsn/3sZ841279//3O+n4540PG/iB3kR96Ka6znR4ocyVtxJUciR2ot1yv5ESJxndWHGlJk4hrrORL5kbfiGuv5kaKO1HriSo7UOOz085CRI0fK2rVr5dixY2Z1W3dDHD16VPLz8xv8nLFjx5r327dvN+8zMzOluLjY7zn2fX0sFoUjru4xAro7RXf4zZkzR2JZOOL68ccfy1tvvWV29Oibxlbptvh58+ZJLApHXLOyssz7QYMGOc/p1q2bieuePXskFoUjrm+88Ybs2rVL/vSnP8no0aNl3Lhx5mOFhYXmAOJYdaHY1nc9Kh2Lal+P+vdJRzi4VVVVmR2qsfq3C3XIj5oH+VHzIUdqvXElR2qeuJIjBR9X8iOEAzlS8yBHar1xpYbUPHElP2q+a5YcKfi4kiM1Dot+HtSpUydToNexZ6tWrZIbbrihwefqPxL3P4jx48fLhg0b/IqnOps5NTX1nIJrrAklrkrPRJwyZYrMmDFDHn300Yi85miP6z/+8Q9Zt26d+bi+vfTSS+bjS5YskZkzZ0osCyWuEyZMMO+3bdvmPEcXT44cOSJ5eXkSy0KJq85l11njcXFxznPs+zpONdY1FFs97zA7O9vvelRfffWVcz3q3y5N+FavXu08rv+DTuNqJ80A+VFk/+3Wh/wocrElR2qeuJIjNU9cyZGCjyv5EcKJHKl5kCO1vriSHzVPXMmPmu+aJUcKPq7kSI3UyB2BiICTJ09aa9asMW/6n+app54yt3fv3m0ef/PNN814wx07dljz58+38vLyrK9//evO5+u264ceeshsgy0sLLTeeecdKz8/35o0aZLznKqqKmvw4MFmxOfatWvNNmwdjxY4Vi2aRCKuOo5B43jHHXdYBw4ccN50u3u0ikRcA8XCeM9IxfWGG24wYyd1W7xev9ddd501aNAgq6KiwopGkYjrli1brOTkZOuHP/yhtXnzZmvjxo3md0KnTp2soqIiK1qFGlv129/+1kpNTbXeeustq6CgwJozZ46VkpLiN/5GRzmMGDHCWr58ufXZZ59Z/fr1s2677baI/7yIPPIj78Y1FvMjRY7k7biSI5EjtYbrVZEfoTX8XqSGRI4ULuRHzYP8qPlQR2qdcVXkSBfGol8rYi9oBL7NmDHDPP7MM89YPXv2tJKSkqzc3FxTFC0vL3c+f8+ePSY5S09PN4Xnvn37WrNmzbKOHz/u93127dplZuG2bdvWzA1/4IEHrMrKSitaRSKu8+bNq/d76C+maBWp6zXWFv0iFVe9f+edd1qdO3c2z73pppvM50arSMX1gw8+sCZMmGAW+tLS0qwrrrjCnO0XzUKNre2xxx4zz2vXrp01fvx4a8mSJX6PHz161CzydejQwSwQfu973zPJIqIf+ZF34xqL+ZEiR/J2XMmRyJFaw/VqIz9Ca/i9SA2JHKk1/F6khtSycY21/EhRR2qdcbWRI51fnP6/xu4KBAAAAAAAAAAAAND6cKYfAAAAAAAAAAAA4HEs+gEAAAAAAAAAAAAex6IfAAAAAAAAAAAA4HEs+gEAAAAAAAAAAAAex6IfAAAAAAAAAAAA4HEs+gEAAAAAAAAAAAAex6IfAAAAAAAAAAAA4HEs+gEAAAAAAAAAAAAex6IfAAAAAAAAAAAA4HEs+gEAAAAAAAAAAAAex6IfAAAAAAAAAAAA4HEs+gEAAAAAAAAAAADibf8f5OG+lNYD28AAAAAASUVORK5CYII=" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 15 + "execution_count": 7 }, { "cell_type": "markdown", "id": "1a21821c", - "source": "## Comparing Methods: `conformal_distribution` vs `conformal_error`\n\nThe default `conformal_distribution` builds synthetic forecast paths and can produce asymmetric intervals. The alternative `conformal_error` takes quantiles of absolute errors directly, always producing symmetric bands.", - "metadata": {} + "metadata": {}, + "source": [ + "## Comparing Methods: `conformal_distribution` vs `conformal_error`\n", + "\n", + "The default `conformal_distribution` builds synthetic forecast paths and can produce asymmetric intervals. The alternative `conformal_error` takes quantiles of absolute errors directly, always producing symmetric bands." + ] }, { "cell_type": "code", "id": "d486bac1", - "source": "fig, axes = plt.subplots(1, 2, figsize=(14, 5), sharey=True)\n\nfor ax, method in zip(axes, [\"conformal_distribution\", \"conformal_error\"]):\n model = HyperTreeAR(p=lag_p, freq=freq, fcst_h=fcst_h)\n model.train(\n lgb_params=ht_params,\n num_iterations=num_iterations,\n train_data=train,\n seed=123,\n verbose=-1,\n forecast_intervals=ForecastIntervals(n_windows=5, method=method),\n )\n fcst = model.forecast(test_data=test, level=[90])\n model_name = fcst[\"model\"].iloc[0]\n\n ax.plot(df[\"date\"], df[\"value\"], label=\"Actual\", color=\"#2E86AB\", linewidth=2, alpha=0.8)\n ax.plot(fcst[\"date\"], fcst[\"fcst\"], label=\"Forecast\", color=\"green\", linestyle=\"--\", linewidth=2)\n ax.fill_between(\n fcst[\"date\"],\n fcst[f\"{model_name}-lo-90\"],\n fcst[f\"{model_name}-hi-90\"],\n color=\"green\", alpha=0.2, label=\"90% interval\",\n )\n ax.axvline(x=fcst[\"date\"].min(), color=\"black\", linestyle=\":\", alpha=0.7)\n ax.set_title(method, fontsize=14)\n ax.legend(fontsize=10)\n ax.grid(True, alpha=0.3)\n\nplt.tight_layout()\nplt.show()", "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T10:03:56.278059Z", + "iopub.status.busy": "2026-06-11T10:03:56.278059Z", + "iopub.status.idle": "2026-06-11T10:03:57.382676Z", + "shell.execute_reply": "2026-06-11T10:03:57.382676Z" + }, "ExecuteTime": { - "end_time": "2026-06-03T11:06:03.607815900Z", - "start_time": "2026-06-03T11:05:57.608386800Z" + "end_time": "2026-06-11T11:56:51.930025100Z", + "start_time": "2026-06-11T11:56:50.400563900Z" } }, + "source": [ + "method_fcsts = {}\n", + "for method in [\"conformal_distribution\", \"conformal_error\"]:\n", + " model = HyperTreeAR(p=lag_p, freq=freq, fcst_h=fcst_h)\n", + " model.train(\n", + " lgb_params=ht_params,\n", + " num_iterations=num_iterations,\n", + " train_data=train,\n", + " seed=seed,\n", + " verbose=-1,\n", + " forecast_intervals=ForecastIntervals(n_windows=n_windows, method=method, step_size=1, refit=refit),\n", + " )\n", + " method_fcsts[method] = model.forecast(test_data=test, level=[90])\n", + "\n", + "plot_model_intervals(actuals=df, forecasts=method_fcsts, levels=[90])" + ], "outputs": [ { "data": { "text/plain": [ - "
" + "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 16 + "execution_count": 8 } ], "metadata": { @@ -657,7 +748,15 @@ "name": "python3" }, "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", "version": "3.11.0" } }, diff --git a/examples/HPO.ipynb b/examples/HPO.ipynb index dc3ca70..db966a8 100644 --- a/examples/HPO.ipynb +++ b/examples/HPO.ipynb @@ -11,12 +11,20 @@ }, { "cell_type": "code", + "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2026-05-07T08:49:44.882660100Z", "start_time": "2026-05-07T08:49:42.506310900Z" + }, + "execution": { + "iopub.execute_input": "2026-06-11T09:53:15.943104Z", + "iopub.status.busy": "2026-06-11T09:53:15.941981Z", + "iopub.status.idle": "2026-06-11T09:53:21.347316Z", + "shell.execute_reply": "2026-06-11T09:53:21.346309Z" } }, + "outputs": [], "source": [ "import pandas as pd\n", "import matplotlib.pyplot as plt\n", @@ -24,33 +32,40 @@ "from utils import calculate_metrics\n", "import optuna\n", "from optuna.samplers import TPESampler" - ], - "outputs": [], - "execution_count": 1 + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "# General Parameters" + "metadata": {}, + "source": [ + "# General Parameters" + ] }, { + "cell_type": "code", + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2026-05-07T08:49:44.898658900Z", "start_time": "2026-05-07T08:49:44.884659900Z" + }, + "execution": { + "iopub.execute_input": "2026-06-11T09:53:21.349317Z", + "iopub.status.busy": "2026-06-11T09:53:21.349317Z", + "iopub.status.idle": "2026-06-11T09:53:21.351773Z", + "shell.execute_reply": "2026-06-11T09:53:21.351773Z" } }, - "cell_type": "code", + "outputs": [], "source": [ "lag_p=12 # Lag order for AR(p) models\n", "freq='MS' # Monthly frequency\n", "fcst_h=12 # Forecast horizon (12 months ahead)\n", "num_iterations=200 # Maximum number of iterations for training\n", "early_stopping_round=10 # Early stopping rounds for HPO (stop if no improvement for 10 rounds)\n", - "n_trials=20 # Number of HPO trials" - ], - "outputs": [], - "execution_count": 2 + "n_trials=20 # Number of HPO trials\n", + "seed = 123" + ] }, { "cell_type": "markdown", @@ -63,12 +78,20 @@ }, { "cell_type": "code", + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2026-05-07T08:49:45.339758600Z", "start_time": "2026-05-07T08:49:44.901659800Z" + }, + "execution": { + "iopub.execute_input": "2026-06-11T09:53:21.353786Z", + "iopub.status.busy": "2026-06-11T09:53:21.353786Z", + "iopub.status.idle": "2026-06-11T09:53:21.778432Z", + "shell.execute_reply": "2026-06-11T09:53:21.777420Z" } }, + "outputs": [], "source": [ "# The data needs to have the following columns: 'date', 'series_id', 'value'. All other columns are automatically treated as features.\n", "# For the AR-models, you don't have to add lag-values yourself, this happens automatically during training.\n", @@ -78,23 +101,31 @@ "df[\"quarter\"] = df['date'].dt.quarter\n", "test = df.tail(fcst_h)\n", "train = df.drop(test.index)" - ], - "outputs": [], - "execution_count": 3 + ] }, { "cell_type": "markdown", "metadata": {}, - "source": "## Initialize Hyper-Tree-AR" + "source": [ + "## Initialize Hyper-Tree-AR" + ] }, { "cell_type": "code", + "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2026-05-07T08:49:45.357668600Z", "start_time": "2026-05-07T08:49:45.340754600Z" + }, + "execution": { + "iopub.execute_input": "2026-06-11T09:53:21.780547Z", + "iopub.status.busy": "2026-06-11T09:53:21.779564Z", + "iopub.status.idle": "2026-06-11T09:53:21.782795Z", + "shell.execute_reply": "2026-06-11T09:53:21.782795Z" } }, + "outputs": [], "source": [ "# Initialize the Hyper-Tree-AR model\n", "ht_ar = HyperTreeAR(\n", @@ -102,23 +133,127 @@ " freq=freq, # Frequency\n", " fcst_h=fcst_h # Forecast h months ahead\n", ")" - ], - "outputs": [], - "execution_count": 4 + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "## HPO using Optuna" + "metadata": {}, + "source": [ + "## HPO using Optuna" + ] }, { + "cell_type": "code", + "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2026-05-07T08:49:52.391857Z", "start_time": "2026-05-07T08:49:45.358626900Z" + }, + "execution": { + "iopub.execute_input": "2026-06-11T09:53:21.785799Z", + "iopub.status.busy": "2026-06-11T09:53:21.784807Z", + "iopub.status.idle": "2026-06-11T09:53:24.491439Z", + "shell.execute_reply": "2026-06-11T09:53:24.491439Z" } }, - "cell_type": "code", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m[I 2026-06-11 11:53:21,787]\u001b[0m A new study created in memory with name: HPO for Hyper-Tree-AR\u001b[0m\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "645550725b0a46de896b98045770d4b2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/20 [00:00 float:\n", "\n", @@ -135,7 +270,7 @@ " train_data=train,\n", " validation=True,\n", " early_stopping_round=early_stopping_round,\n", - " seed=123,\n", + " seed=seed,\n", " verbose=-1\n", " )\n", "\n", @@ -159,78 +294,38 @@ "opt_params = opt_param.params.copy()\n", "opt_rounds = opt_params[\"best_iteration\"]\n", "del opt_params[\"best_iteration\"]" - ], - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001B[32m[I 2026-05-07 10:49:45,363]\u001B[0m A new study created in memory with name: HPO for Hyper-Tree-AR\u001B[0m\n" - ] - }, - { - "data": { - "text/plain": [ - " 0%| | 0/20 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure(figsize=(12, 5))\n", "\n", @@ -280,20 +392,7 @@ "plt.grid(True, alpha=0.3)\n", "plt.tight_layout()\n", "plt.show()" - ], - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 7 + ] }, { "cell_type": "markdown", @@ -306,21 +405,22 @@ }, { "cell_type": "code", + "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2026-05-07T08:49:53.364584400Z", "start_time": "2026-05-07T08:49:53.336658800Z" + }, + "execution": { + "iopub.execute_input": "2026-06-11T09:53:24.881227Z", + "iopub.status.busy": "2026-06-11T09:53:24.880133Z", + "iopub.status.idle": "2026-06-11T09:53:24.893037Z", + "shell.execute_reply": "2026-06-11T09:53:24.893037Z" } }, - "source": "fcsts_df = ht_ar_fcst.merge(\n test[[\"date\", \"value\"]],\n on=[\"date\"],\n how=\"inner\"\n)\n\nfcsts_df.groupby(\"model\").apply(calculate_metrics).round(3)", "outputs": [ { "data": { - "text/plain": [ - " MAE MAPE sMAPE WAPE RMSE\n", - "model \n", - "Hyper-Tree-AR(12) 12.231 2.755 2.694 2.569 16.663" - ], "text/html": [ "
\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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
series_iddatemodelalpha_palpha_dpromo
0SKU 12018-01-01Hyper-Tree-TSB0.2168770.5870080
1SKU 12018-01-08Hyper-Tree-TSB0.2168770.5870080
2SKU 12018-01-15Hyper-Tree-TSB0.2168770.5870080
3SKU 12018-01-22Hyper-Tree-TSB0.2168770.5870080
4SKU 12018-01-29Hyper-Tree-TSB0.2168770.5870080
5SKU 12018-02-05Hyper-Tree-TSB0.0198150.4057590
6SKU 12018-02-12Hyper-Tree-TSB0.0262310.3221181
7SKU 12018-02-19Hyper-Tree-TSB0.0262310.3221181
8SKU 12018-02-26Hyper-Tree-TSB0.0198150.4057590
9SKU 12018-03-05Hyper-Tree-TSB0.0384300.0965680
10SKU 12018-03-12Hyper-Tree-TSB0.0384300.0965680
11SKU 12018-03-19Hyper-Tree-TSB0.0384300.0965680
12SKU 22018-01-01Hyper-Tree-TSB0.1326740.6336280
13SKU 22018-01-08Hyper-Tree-TSB0.1532520.1416521
14SKU 22018-01-15Hyper-Tree-TSB0.1326740.6336280
15SKU 22018-01-22Hyper-Tree-TSB0.1326740.6336280
16SKU 22018-01-29Hyper-Tree-TSB0.1326740.6336280
17SKU 22018-02-05Hyper-Tree-TSB0.0123840.1926780
18SKU 22018-02-12Hyper-Tree-TSB0.0123840.1926780
19SKU 22018-02-19Hyper-Tree-TSB0.0123840.1926780
\n", + "
" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 10 + }, + { + "cell_type": "markdown", + "id": "65a6dc11", + "source": "## Accuracy Comparison\n\nPoint-forecast metrics need care on intermittent data. The flat TSB forecast estimates the *expected* demand per period, and squared error (RMSE) is minimized by exactly that conditional mean, so RMSE is the fairest yardstick here. The absolute metrics (MAE, WAPE) are minimized by forecasting close to zero on mostly-zero series, so they reward degenerate forecasts and can exceed 100% WAPE even for a well-calibrated demand rate. MAPE is undefined on zero-demand weeks and is computed only on the nonzero subset. The TSB model estimates each SKU's expected demand rate, while the AR baseline, lacking an intercept, decays toward zero on the mostly-zero history and underforecasts.", + "metadata": {} + }, + { + "cell_type": "code", + "id": "854cb679", + "source": "fcsts_df = pd.concat(\n [\n tsb_fcst,\n ar_fcst,\n ], axis=0).merge(\n test[[\"series_id\", \"date\", \"value\"]],\n on=[\"series_id\", \"date\"],\n how=\"inner\"\n)\n\nfcsts_df.groupby(\"model\")[[\"value\", \"fcst\"]].apply(calculate_metrics).round(3)", + "metadata": { + "ExecuteTime": { + "end_time": "2026-06-11T13:29:06.724460100Z", + "start_time": "2026-06-11T13:29:06.680527700Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + " MAE MAPE sMAPE WAPE RMSE\n", + "model \n", + "Hyper-Tree-AR(8) 2.573 76.377 156.345 129.468 4.012\n", + "Hyper-Tree-TSB 2.331 71.810 170.232 117.276 3.219" + ], + "text/html": [ + "
\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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
MAEMAPEsMAPEWAPERMSE
model
Hyper-Tree-AR(8)2.57376.377156.345129.4684.012
Hyper-Tree-TSB2.33171.810170.232117.2763.219
\n", + "
" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 7 + }, + { + "cell_type": "markdown", + "id": "f9d73268", + "source": "## Practical Notes\n\n- **Equal-length panel**: TSB reshapes the panel to (n_series, T), so all series must have the same length. Pad shorter series and supply a `mask` column (1 = valid, 0 = padding); padded rows are excluded from the loss and from the conformity scores.\n- **Flat point forecast**: the TSB forecast is constant over the horizon at `p_T * z_T`. Horizon features therefore do not move the point forecast, though they do change `type=\"parameters\"`. This is the classical TSB behaviour: future occurrence is unobserved, so the expected one-step-ahead state propagates unchanged.\n- **Feature-driven smoothing**: the gain over classical TSB comes from letting `alpha_p` and `alpha_d` vary with features, so the probability and size estimates adapt their responsiveness by context (promotions, season, SKU).\n- **When to use it**: reach for TSB when the series is genuinely intermittent. On smooth, non-zero series an AR or ETS target model is usually the better fit.\n- TSB is **experimental**. The API and defaults may change in future releases.", + "metadata": {} + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/examples/VAR Models.ipynb b/examples/VAR Models.ipynb new file mode 100644 index 0000000..a4ef923 --- /dev/null +++ b/examples/VAR Models.ipynb @@ -0,0 +1,598 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e99b797525414fdb", + "metadata": {}, + "source": "# Vector Autoregression with Hyper-Trees\n\nThis walkthrough introduces the **experimental** multivariate Hyper-Tree models. They extend the autoregressive Hyper-Trees to a VAR(p) target model over an aligned panel of k series:\n\n$$y_{i,t} = \\sum_{j=1}^{p} A_j[i, :](x_{i,t}) \\cdot y_{t-j}$$\n\nEvery series' forecast is a feature-dependent linear combination of the lagged values of *all* series, so cross-series lead/lag dependence is captured by the off-diagonal coefficients of the time-varying lag matrices.\n\n- **`HyperTreeNetVAR`** (GBDT encoder + MLP decoder): the boosting cost is independent of the number of coefficients. This is the **strongly recommended** variant.\n- **`HyperTreeVAR`** (one boosted tree per coefficient): fully interpretable and intended for small panels, since each boosting round grows `k * p` trees.\n- **`type=\"factor\"`** (restricted \"Global VAR\", available on both models): each equation keeps only its own lags plus a shared cross-sectional factor, so the coefficient count per equation is `2 * p` regardless of k. This makes it a scalable middle ground when the unrestricted VAR is over-parameterized.\n\nAll models require an *aligned panel*: all series must have the same length and identical dates." + }, + { + "cell_type": "code", + "id": "4e68ded019b2d1f4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T09:50:54.355207Z", + "iopub.status.busy": "2026-06-11T09:50:54.355207Z", + "iopub.status.idle": "2026-06-11T09:51:05.430153Z", + "shell.execute_reply": "2026-06-11T09:51:05.430153Z" + }, + "ExecuteTime": { + "end_time": "2026-06-11T13:43:08.481273300Z", + "start_time": "2026-06-11T13:43:04.798619300Z" + } + }, + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import torch\n", + "\n", + "from hypertrees import ForecastIntervals\n", + "from hypertrees.models import HyperTreeAR\n", + "from hypertrees.models.HyperTreeVAR import HyperTreeVAR\n", + "from hypertrees.models.HyperTreeNetVAR import HyperTreeNetVAR\n", + "from utils import calculate_metrics, plot_panel_forecasts, simulate_var_panel\n", + "\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "\n", + "# Shared setup, used by all models\n", + "seed = 123\n", + "num_iterations = 300\n", + "level = [80]\n", + "forecast_intervals = ForecastIntervals(\n", + " n_windows=10, # number of rolling calibration windows\n", + " method=\"conformal_distribution\", # or \"conformal_error\"\n", + " step_size=1, # time steps between windows\n", + " refit=False, # train once on the oldest window for speed\n", + ")" + ], + "outputs": [], + "execution_count": 1 + }, + { + "cell_type": "markdown", + "id": "var-ex-sim-md", + "metadata": {}, + "source": [ + "## Simulate an Aligned Panel\n", + "\n", + "We simulate 10 monthly series over 20 years from a stable VAR(1) with a lead/lag *chain*: every series follows its own past and its neighbor's previous month (`A[i, i-1] = 0.3`). On top we add a common seasonal profile and strongly heterogeneous scales, which is exactly the situation the models' built-in per-series scaling (`scaling=\"mean\"`, the default) is for.\n", + "\n", + "Feature columns: `month`, `quarter`, and a series identifier `series_num`. The GBDT learns one global mapping from features to coefficients, so a feature must identify the series for the equations to differ. We cast it to pandas `category` dtype so LightGBM applies true categorical splits." + ] + }, + { + "cell_type": "code", + "id": "var-ex-sim", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T09:51:05.432183Z", + "iopub.status.busy": "2026-06-11T09:51:05.432183Z", + "iopub.status.idle": "2026-06-11T09:51:05.447712Z", + "shell.execute_reply": "2026-06-11T09:51:05.447181Z" + }, + "ExecuteTime": { + "end_time": "2026-06-11T13:43:08.516782100Z", + "start_time": "2026-06-11T13:43:08.483290200Z" + } + }, + "source": [ + "# Simulation parameters: k series, n_train months of training data, forecast horizon fcst_h, and VAR lag order var_p (number of coefficient matrices A1, A2, ...)\n", + "k, n_train, fcst_h, var_p = 10, 240, 12, 4\n", + "\n", + "df, train, test = simulate_var_panel(k=k, n_train=n_train, fcst_h=fcst_h, seed=seed)\n", + "print(f\"{k} series x {n_train} months, forecast horizon {fcst_h}\")" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10 series x 240 months, forecast horizon 12\n" + ] + } + ], + "execution_count": 2 + }, + { + "cell_type": "markdown", + "id": "eac95674e4754575", + "metadata": {}, + "source": [ + "## Hyper-TreeNet-VAR (recommended for runtime efficiency)\n", + "\n", + "The GBDT produces a low-dimensional embedding that an MLP decodes into all `k * p = 40` coefficients per row. Per-series scaling is on by default and forecasts come back on the original scale. We also calibrate conformal prediction intervals via rolling-origin cross-validation." + ] + }, + { + "cell_type": "code", + "id": "d91f4020e74aaa26", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T09:51:05.448747Z", + "iopub.status.busy": "2026-06-11T09:51:05.448747Z", + "iopub.status.idle": "2026-06-11T09:51:10.172680Z", + "shell.execute_reply": "2026-06-11T09:51:10.171671Z" + }, + "ExecuteTime": { + "end_time": "2026-06-11T13:43:14.994445600Z", + "start_time": "2026-06-11T13:43:08.520793Z" + } + }, + "source": [ + "torch.manual_seed(seed)\n", + "np.random.seed(seed)\n", + "\n", + "htnet_var = HyperTreeNetVAR(\n", + " p=var_p,\n", + " freq=\"M\",\n", + " fcst_h=fcst_h,\n", + " device=device\n", + ")\n", + "\n", + "htnet_var.train(\n", + " lgb_params={\"learning_rate\": 0.1},\n", + " network_params={\n", + " \"learning_rate\": 1e-3,\n", + " \"embedding_dimension\": 1,\n", + " \"hidden_dim\": 64,\n", + " \"dropout\": 0.1,\n", + " \"use_random_projection\": True,\n", + " \"rp_embed_dim\": k * var_p,\n", + " },\n", + " num_iterations=num_iterations,\n", + " train_data=train,\n", + " seed=seed,\n", + " forecast_intervals=forecast_intervals,\n", + ")\n", + "\n", + "# Request interval columns via level: adds -lo-80 / -hi-80\n", + "htnet_var_fcst = htnet_var.forecast(test_data=test, level=level)" + ], + "outputs": [], + "execution_count": 3 + }, + { + "cell_type": "markdown", + "id": "a1880c6ce45f404", + "metadata": {}, + "source": [ + "## Hyper-Tree-VAR\n", + "\n", + "One boosted tree per coefficient, so every coefficient is a separate, SHAP-able tree output." + ] + }, + { + "cell_type": "code", + "id": "ce70e089df123f2e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T09:51:10.175680Z", + "iopub.status.busy": "2026-06-11T09:51:10.174680Z", + "iopub.status.idle": "2026-06-11T09:51:26.093567Z", + "shell.execute_reply": "2026-06-11T09:51:26.092563Z" + }, + "ExecuteTime": { + "end_time": "2026-06-11T13:43:46.075989900Z", + "start_time": "2026-06-11T13:43:15.234756800Z" + } + }, + "source": [ + "torch.manual_seed(seed)\n", + "np.random.seed(seed)\n", + "\n", + "ht_var = HyperTreeVAR(\n", + " p=var_p,\n", + " freq=\"M\",\n", + " fcst_h=fcst_h\n", + ")\n", + "ht_var.train(\n", + " lgb_params={\"learning_rate\": 0.01},\n", + " num_iterations=num_iterations,\n", + " train_data=train,\n", + " seed=seed,\n", + " forecast_intervals=forecast_intervals,\n", + ")\n", + "ht_var_fcst = ht_var.forecast(test_data=test, level=level)" + ], + "outputs": [], + "execution_count": 4 + }, + { + "cell_type": "markdown", + "id": "3483d6fc", + "source": "## Hyper-Tree-FactorVAR (restricted, scales to large panels)\n\nA middle ground between the univariate AR and the unrestricted VAR. Each equation uses only its **own** lags plus the lags of a single cross-sectional **factor**. That factor is the equal-weighted mean of the (scaled) panel, the \"star variable\" of the Global VAR literature. This keeps a cross-series channel while cutting the coefficient count per equation from `k * p = 40` to just `2 * p = 8`, *independent of the number of series*. It is the principled choice when the panel is too large for the unrestricted `HyperTreeVAR`. Coefficients split into own-lag (`A{j}(own)`) and factor-lag (`A{j}(factor)`) blocks.", + "metadata": {} + }, + { + "cell_type": "code", + "id": "dff7ae00", + "source": [ + "torch.manual_seed(seed)\n", + "np.random.seed(seed)\n", + "\n", + "ht_factor_var = HyperTreeVAR(\n", + " type=\"factor\",\n", + " p=var_p,\n", + " freq=\"M\",\n", + " fcst_h=fcst_h,\n", + ")\n", + "ht_factor_var.train(\n", + " lgb_params={\"learning_rate\": 0.05},\n", + " num_iterations=num_iterations,\n", + " train_data=train,\n", + " seed=seed,\n", + " forecast_intervals=forecast_intervals,\n", + ")\n", + "ht_factor_var_fcst = ht_factor_var.forecast(test_data=test, level=level)" + ], + "metadata": { + "ExecuteTime": { + "end_time": "2026-06-11T13:43:49.384413200Z", + "start_time": "2026-06-11T13:43:46.103857700Z" + } + }, + "outputs": [], + "execution_count": 5 + }, + { + "cell_type": "markdown", + "id": "7f98e44d", + "source": "### How it works and how it differs from the other models\n\n**The mechanism.** Each equation forecasts a series from two blocks of lags: its **own** past, and the past of a single shared **factor** $f_t = \\frac{1}{k}\\sum_{i} y_{i,t}$. That factor is the equal-weighted mean of the *scaled* panel (the \"star variable\" of the Global VAR literature), computed internally:\n\n$$y_{i,t} = \\underbrace{\\sum_{j=1}^{p} a_{j}(x_{i,t})\\, y_{i,t-j}}_{\\text{own lags}} \\; + \\; \\underbrace{\\sum_{j=1}^{p} c_{j}(x_{i,t})\\, f_{t-j}}_{\\text{factor lags}}$$\n\nBoth blocks share the same lag order `p`: for every lag `j` there is one own-lag coefficient $a_j$ and one factor-lag coefficient $c_j$. As in every Hyper-Tree, the coefficients $a_j, c_j$ are **time-varying functions of features** generated by LightGBM. Here that means one boosted tree per coefficient, so `num_class = 2 * p`. When forecasting, the recursion advances all series jointly: at each step the fresh forecasts become the next own-lag, and **the factor is recomputed as the cross-sectional mean of those forecasts**, so the common signal keeps propagating over the horizon. `forecast(type=\"parameters\")` exposes the two blocks as the `A{j}(own)` and `A{j}(factor)` columns.\n\n**How it differs.** It sits between the univariate AR and the full VAR on the bias/variance spectrum:\n\n| Model | Coefficients per equation | Cross-series channel | Estimator |\n|---|---|---|---|\n| `HyperTreeAR` | `p` | none (own lags only) | one tree per coefficient |\n| **`HyperTreeVAR(type=\"factor\")`** | **`2p`** | **one shared common factor** | one tree per coefficient |\n| `HyperTreeVAR` | `k·p` | full pairwise lag matrices | one tree per coefficient |\n| `HyperTreeNetVAR` | `k·p` | full pairwise lag matrices | GBDT encoder → MLP decoder |\n\n- **vs `HyperTreeAR`**: AR sees only each series' own history. The factor design adds the factor block, so it can borrow the panel-wide signal at a coefficient count (`2p`) that barely grows beyond AR's `p`.\n- **vs the unrestricted `HyperTreeVAR`**: the full VAR regresses every series on *all* other series' lags (`k·p` coefficients, dense pairwise lead/lag links). The factor design replaces that dense block with a single factor, so its cost is **independent of k** and it resists the overparameterization that sinks unrestricted VARs on large panels. The tradeoff is that it can only capture cross-series dependence that flows through the common factor, not arbitrary pairwise links.\n- **vs `HyperTreeNetVAR`**: NetVAR still targets the *full* `k·p` matrices but keeps boosting cheap with a GBDT→MLP decoder. The factor design instead shrinks the *number of coefficients structurally*; on the direct model used here it stays fully interpretable (an explicit own/factor split, one SHAP-able tree per coefficient) with no neural network. `HyperTreeNetVAR` also accepts `type=\"factor\"` if you want the factor design with the MLP decoder.\n\nIn short: reach for it when the panel is large and cross-series dynamics plausibly run through a **common driver** (a market, category, or panel-wide factor) rather than dense pairwise relationships.", + "metadata": {} + }, + { + "cell_type": "markdown", + "id": "var-ex-ar-md", + "metadata": {}, + "source": [ + "## Univariate Baseline: Hyper-Tree-AR\n", + "\n", + "The univariate model sees only each series' own lags, so it cannot exploit the lead/lag chain." + ] + }, + { + "cell_type": "code", + "id": "dc0081e6b52f8d7c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T09:51:26.095568Z", + "iopub.status.busy": "2026-06-11T09:51:26.095568Z", + "iopub.status.idle": "2026-06-11T09:51:28.657279Z", + "shell.execute_reply": "2026-06-11T09:51:28.656777Z" + }, + "ExecuteTime": { + "end_time": "2026-06-11T13:43:53.208257100Z", + "start_time": "2026-06-11T13:43:49.416767800Z" + } + }, + "source": [ + "torch.manual_seed(seed)\n", + "np.random.seed(seed)\n", + "\n", + "ht_ar = HyperTreeAR(\n", + " p=var_p,\n", + " freq=\"M\",\n", + " fcst_h=fcst_h\n", + ")\n", + "ht_ar.train(\n", + " lgb_params={\"learning_rate\": 0.1},\n", + " num_iterations=num_iterations,\n", + " train_data=train,\n", + " seed=seed,\n", + " forecast_intervals=forecast_intervals,\n", + ")\n", + "ht_ar_fcst = ht_ar.forecast(test_data=test, level=level)" + ], + "outputs": [], + "execution_count": 6 + }, + { + "cell_type": "markdown", + "id": "var-ex-plot-md", + "metadata": {}, + "source": "## Forecasts\n\nAll four models on three of the ten series, with the 80% conformal interval of the recommended `Hyper-TreeNet-VAR`." + }, + { + "cell_type": "code", + "id": "var-ex-plot", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T09:51:28.659285Z", + "iopub.status.busy": "2026-06-11T09:51:28.659285Z", + "iopub.status.idle": "2026-06-11T09:51:29.945714Z", + "shell.execute_reply": "2026-06-11T09:51:29.945714Z" + }, + "ExecuteTime": { + "end_time": "2026-06-11T13:43:53.936535300Z", + "start_time": "2026-06-11T13:43:53.241140Z" + } + }, + "source": "datasets = [\n (df, \"date\", \"value\", \"Actual\", \"#2E86AB\", \"-\"),\n (htnet_var_fcst, \"date\", \"fcst\", \"Hyper-TreeNet-VAR Forecast\", \"green\", \"--\"),\n (ht_var_fcst, \"date\", \"fcst\", \"Hyper-Tree-VAR Forecast\", \"red\", \"--\"),\n (ht_factor_var_fcst, \"date\", \"fcst\", \"Hyper-Tree-FactorVAR Forecast\", \"purple\", \"--\"),\n (ht_ar_fcst, \"date\", \"fcst\", \"Hyper-Tree-AR Forecast\", \"orange\", \"--\"),\n]\n\nplot_panel_forecasts(\n datasets,\n series_ids=[\"Series 2\", \"Series 6\", \"Series 10\"],\n split_date=test[\"date\"].min(),\n interval_fcst=htnet_var_fcst,\n level=level[0],\n)", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 7 + }, + { + "cell_type": "markdown", + "id": "var-ex-params-md", + "metadata": {}, + "source": [ + "## Inspecting the Time-Varying Coefficients\n", + "\n", + "`forecast(type=\"parameters\")` returns every VAR coefficient as a column. A VAR(p) is conventionally written as\n", + "\n", + "$$y_t = A_1 y_{t-1} + A_2 y_{t-2} + \\dots + A_p y_{t-p}$$\n", + "\n", + "so with `var_p = 4` there are four coefficient matrices `A1, ..., A4` (one per lag), each of size k x k, where k is the number of series in the panel (here `k = 10`). Each DataFrame row holds the equation of its `series_id`, i.e. one row of every lag matrix, which is why a row carries `k * var_p = 40` coefficient columns. Reading a cell:\n", + "\n", + "- the row's `series_id` selects **which equation** (the matrix row: the series being forecast),\n", + "- `A{j}` selects **which lag** (the j-th matrix, j months back),\n", + "- `(Series m)` selects **which source series** the coefficient multiplies (the matrix column).\n", + "\n", + "Below we look at the equation of Series 6: `A1(Series 6)` and `A2(Series 6)` are its own-lag effects (the multivariate analog of the `AR(1), ..., AR(p)` columns of `HyperTreeAR`), while `A1(Series 5)` is the weight that Series 5's previous month receives in Series 6's forecast. In the simulation that is exactly the lead/lag link (Series 6 is driven by Series 5), and `A1(Series 1)` is an unrelated series for comparison. Stacking the k rows that share a date recovers the complete time-varying matrices for that time step. Note that the coefficients live in the scaled space (per-series scaling)." + ] + }, + { + "cell_type": "code", + "id": "var-ex-params", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T09:51:29.947717Z", + "iopub.status.busy": "2026-06-11T09:51:29.947717Z", + "iopub.status.idle": "2026-06-11T09:51:29.979925Z", + "shell.execute_reply": "2026-06-11T09:51:29.978920Z" + }, + "ExecuteTime": { + "end_time": "2026-06-11T13:43:54.020521800Z", + "start_time": "2026-06-11T13:43:53.958499900Z" + } + }, + "source": [ + "params = htnet_var.forecast(test_data=test, type=\"parameters\")\n", + "params[params[\"series_id\"] == \"Series 6\"][[\"date\", \"A1(Series 6)\", \"A1(Series 5)\", \"A2(Series 6)\", \"A1(Series 1)\"]].head()" + ], + "outputs": [ + { + "data": { + "text/plain": [ + " date A1(Series 6) A1(Series 5) A2(Series 6) A1(Series 1)\n", + "60 2020-01-01 0.045522 0.026507 0.056337 0.020276\n", + "61 2020-02-01 0.043268 0.027609 0.052135 0.022095\n", + "62 2020-03-01 0.037825 0.030270 0.041986 0.026486\n", + "63 2020-04-01 0.030708 0.033750 0.028717 0.032228\n", + "64 2020-05-01 0.023783 0.037752 0.015588 0.037502" + ], + "text/html": [ + "
\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", + " \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", + " \n", + " \n", + " \n", + "
dateA1(Series 6)A1(Series 5)A2(Series 6)A1(Series 1)
602020-01-010.0455220.0265070.0563370.020276
612020-02-010.0432680.0276090.0521350.022095
622020-03-010.0378250.0302700.0419860.026486
632020-04-010.0307080.0337500.0287170.032228
642020-05-010.0237830.0377520.0155880.037502
\n", + "
" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 8 + }, + { + "cell_type": "markdown", + "id": "var-ex-compare-md", + "metadata": {}, + "source": [ + "## Accuracy Comparison\n", + "\n", + "On data with genuine cross-series structure, the VAR models should come out ahead of the univariate baseline." + ] + }, + { + "cell_type": "code", + "id": "var-ex-compare", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-11T09:51:29.981925Z", + "iopub.status.busy": "2026-06-11T09:51:29.981925Z", + "iopub.status.idle": "2026-06-11T09:51:30.003193Z", + "shell.execute_reply": "2026-06-11T09:51:30.002187Z" + }, + "ExecuteTime": { + "end_time": "2026-06-11T13:43:54.167715500Z", + "start_time": "2026-06-11T13:43:54.101471800Z" + } + }, + "source": "fcsts_df = pd.concat(\n [\n htnet_var_fcst,\n ht_var_fcst,\n ht_factor_var_fcst,\n ht_ar_fcst,\n ], axis=0).merge(\n test[[\"series_id\", \"date\", \"value\"]],\n on=[\"series_id\", \"date\"],\n how=\"inner\"\n)\n\nfcsts_df.groupby(\"model\")[[\"value\", \"fcst\"]].apply(calculate_metrics).round(3)", + "outputs": [ + { + "data": { + "text/plain": [ + " MAE MAPE sMAPE WAPE RMSE\n", + "model \n", + "Hyper-Tree-AR(4) 65.788 6.350 6.403 5.797 85.259\n", + "Hyper-Tree-FactorVAR(4) 57.622 5.107 5.138 5.077 74.867\n", + "Hyper-Tree-VAR(4) 56.078 4.893 4.928 4.941 73.982\n", + "Hyper-TreeNet-VAR(4) 55.059 4.831 4.842 4.851 71.324" + ], + "text/html": [ + "
\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", + " \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", + " \n", + " \n", + " \n", + "
MAEMAPEsMAPEWAPERMSE
model
Hyper-Tree-AR(4)65.7886.3506.4035.79785.259
Hyper-Tree-FactorVAR(4)57.6225.1075.1385.07774.867
Hyper-Tree-VAR(4)56.0784.8934.9284.94173.982
Hyper-TreeNet-VAR(4)55.0594.8314.8424.85171.324
\n", + "
" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 9 + }, + { + "cell_type": "markdown", + "id": "var-ex-notes-md", + "metadata": {}, + "source": "## Practical Notes\n\n- **Aligned panel required**: all series must have the same length and identical dates, because the VAR design vector stacks the lags of every series at the same time points.\n- **Series identity feature**: include one (like `series_num` above) so the global GBDT can produce equation-specific coefficients, and cast it to pandas `category` dtype for true categorical splits.\n- **Scaling**: per-series mean scaling is on by default (`scaling=\"mean\"`). VAR coefficients multiply *other* series' values, so unscaled heterogeneous panels force the model to learn scale conversions while the loss is dominated by the largest series. `\"standard\"` and `None` are also available.\n- **Which model**: prefer `HyperTreeNetVAR`. Use the direct `HyperTreeVAR` for small panels where coefficient-level interpretability matters, or `type=\"factor\"` when the panel is large and cross-series dynamics plausibly run through a common factor rather than dense pairwise links.\n- **When to prefer the univariate AR instead**: if your series do not genuinely lead or lag each other, a VAR pays a large estimation-variance bill (`k * p` coefficients per equation) for little information gain.\n- All models are **experimental**. The API and defaults may change in future releases." + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/examples/utils.py b/examples/utils.py index fd08f1e..3d72196 100644 --- a/examples/utils.py +++ b/examples/utils.py @@ -204,6 +204,364 @@ def plot_example_forecast( plt.show() +def simulate_var_panel( + k: int = 10, + n_train: int = 240, + fcst_h: int = 12, + seed: int = 42, +) -> tuple: + """Simulate an aligned panel from a stable VAR(1) with a lead/lag chain. + + Each series follows its own past and its neighbor's previous month + (``A[i, i-1] = 0.3``), so the panel carries genuine cross-series + structure that a vector autoregression can exploit. A common monthly + seasonal profile and strongly heterogeneous per-series scales are + applied on top. Columns: ``series_id``, ``date``, ``value`` plus the + features ``month``, ``quarter``, and ``series_num`` (pandas ``category`` + dtype, so LightGBM applies true categorical splits). + + Parameters + ---------- + k : int, default 10 + Number of series. + n_train : int, default 240 + Training observations per series. + fcst_h : int, default 12 + Test observations per series (the forecast horizon). + seed : int, default 42 + Seed for the random number generator. + + Returns + ------- + tuple + ``(df, train, test)`` where ``df`` is the full panel and + ``train`` / ``test`` are the per-series head/tail splits. + """ + rng = np.random.RandomState(seed) + dates = pd.date_range("2000-01-01", periods=n_train + fcst_h, freq="MS") + + # Stable VAR(1) with a lead/lag chain + A = 0.5 * np.eye(k) + for i in range(1, k): + A[i, i - 1] = 0.3 + + const = 10.0 * (np.eye(k) - A).sum(axis=1) + Y = np.full((len(dates), k), 10.0) + for t in range(1, len(dates)): + Y[t] = const + A @ Y[t - 1] + 0.5 * rng.randn(k) + + # Common monthly seasonality and heterogeneous series scales + season = 1.0 + 0.25 * np.sin(2 * np.pi * np.arange(1, 13) / 12) + scales = rng.uniform(20, 2000, size=k) + Y *= season[dates.month - 1][:, None] * scales[None, :] / 10.0 + + df = pd.concat( + [ + pd.DataFrame({ + "series_id": f"Series {i + 1}", + "date": dates, + "value": Y[:, i], + "month": dates.month, + "quarter": dates.quarter, + "series_num": i, + }) + for i in range(k) + ], + ignore_index=True, + ) + df["series_num"] = df["series_num"].astype("category") + + train = df.groupby("series_id", sort=False).head(n_train).reset_index(drop=True) + test = df.groupby("series_id", sort=False).tail(fcst_h).reset_index(drop=True) + + return df, train, test + + +def simulate_intermittent_panel( + k: int = 20, + n_train: int = 156, + fcst_h: int = 12, + seed: int = 42, +) -> tuple: + """Simulate an aligned panel of intermittent (zero-inflated) demand series. + + Each SKU's weekly demand is the product of two feature-driven components, + which is exactly the structure the TSB method targets: + + * a demand *probability* (occurrence) that rises during promotions and + follows a mild monthly seasonal cycle, and + * a demand *size* (units when demand occurs) that is larger during + promotions. + + Both components depend on a binary ``promo`` feature and on ``month``, so a + Hyper-Tree-TSB whose smoothing rates are functions of features has real + structure to exploit. Columns: ``series_id``, ``date``, ``value`` plus the + features ``month``, ``promo``, and ``series_num`` (pandas ``category`` + dtype, so LightGBM applies true categorical splits). All series share the + same length, as TSB requires. + + Parameters + ---------- + k : int, default 20 + Number of SKUs (series). + n_train : int, default 156 + Training observations per series (weeks). + fcst_h : int, default 12 + Test observations per series (the forecast horizon). + seed : int, default 42 + Seed for the random number generator. + + Returns + ------- + tuple + ``(df, train, test)`` where ``df`` is the full panel and + ``train`` / ``test`` are the per-series head/tail splits. + """ + rng = np.random.RandomState(seed) + T = n_train + fcst_h + dates = pd.date_range("2015-01-05", periods=T, freq="W-MON") + month = dates.month.to_numpy() + + # Per-SKU baselines for occurrence probability (logit) and size (log), + # plus a shared monthly seasonal effect on the occurrence probability. + base_logit = rng.uniform(-2.2, -0.4, size=k) # mostly low occurrence + base_logsize = rng.uniform(0.5, 2.0, size=k) # heterogeneous sizes + season_logit = 0.5 * np.sin(2 * np.pi * month / 12) + + frames = [] + for i in range(k): + # Each SKU has its own promotion calendar: short recurring bursts. + promo = np.zeros(T, dtype=int) + start = rng.randint(2, 8) + while start < T: + promo[start:start + rng.randint(1, 3)] = 1 + start += rng.randint(6, 14) + + # Probability of demand and mean demand size, both functions of features. + p = 1.0 / (1.0 + np.exp(-(base_logit[i] + season_logit + 1.3 * promo))) + mu = np.exp(base_logsize[i] + 0.6 * promo) + + occurrence = (rng.uniform(size=T) < p).astype(float) + size = rng.poisson(mu) + 1.0 # at least one unit when demand occurs + value = occurrence * size + + frames.append(pd.DataFrame({ + "series_id": f"SKU {i + 1}", + "date": dates, + "value": value.astype(float), + "month": month, + "promo": promo, + "series_num": i, + })) + + df = pd.concat(frames, ignore_index=True) + df["series_num"] = df["series_num"].astype("category") + + train = df.groupby("series_id", sort=False).head(n_train).reset_index(drop=True) + test = df.groupby("series_id", sort=False).tail(fcst_h).reset_index(drop=True) + + return df, train, test + + +def plot_forecasts( + datasets: list, + split_date=None, + title: str = "Forecasting Results", + xlabel: str = "Date", + ylabel: str = "Value", + level: int = None, +) -> None: + """Plot actuals and model forecasts on a single axis. + + Parameters + ---------- + datasets : list of tuple + Entries ``(data, x_col, y_col, label, color, style)``, one per line. + split_date : optional + If given, a dotted vertical line marks the train/test split. + title, xlabel, ylabel : str + Axis annotations. + level : int, optional + If given, every forecast DataFrame carrying + ``-lo-`` / ``-hi-`` columns gets its + conformal interval shaded in the line's color. + """ + try: + import matplotlib.pyplot as plt + except ImportError as e: + raise ImportError( + "matplotlib is required for plotting. " + "Install it with: pip install hypertrees[plot]" + ) from e + + plt.figure(figsize=(12, 5)) + for data, x_col, y_col, label, color, style in datasets: + plt.plot(data[x_col], data[y_col], label=label, color=color, + linestyle=style, linewidth=2, alpha=0.8) + if level is not None and "model" in data.columns: + model = data["model"].iloc[0] + lo, hi = f"{model}-lo-{level}", f"{model}-hi-{level}" + if lo in data.columns and hi in data.columns: + plt.fill_between(data[x_col], data[lo], data[hi], color=color, + alpha=0.15, label=f"{level}% Interval ({model})") + if split_date is not None: + plt.axvline(x=split_date, color="black", linestyle=":", alpha=0.7, label="Train/Test Split") + + plt.title(title, fontsize=16) + plt.xlabel(xlabel, fontsize=12) + plt.ylabel(ylabel, fontsize=12) + plt.legend(fontsize=11) + plt.grid(True, alpha=0.3) + plt.tight_layout() + plt.show() + + +def plot_panel_forecasts( + datasets: list, + series_ids: list, + split_date=None, + interval_fcst: pd.DataFrame = None, + level: int = 80, + history: int = 100, + title: str = "Forecasting Results - Simulated VAR Panel", +) -> None: + """Plot actuals and model forecasts for several panel series side by side. + + One subplot per entry of ``series_ids`` with a single global legend + below the panels. Each DataFrame in ``datasets`` must carry a + ``series_id`` column. + + Parameters + ---------- + datasets : list of tuple + Entries ``(data, x_col, y_col, label, color, style)``, one per line. + Actual-value entries (``y_col == "value"``) are truncated to the + last ``history`` rows per series. + series_ids : list + Series to plot, one subplot each. + split_date : optional + If given, a dotted vertical line marks the train/test split. + interval_fcst : pd.DataFrame, optional + Forecast output with ``-lo-`` / ``-hi-`` + columns; the band is shaded in each subplot. + level : int, default 80 + Confidence level of the shaded interval. + history : int, default 72 + Number of trailing actual observations to show per series. + title : str + Figure title. + """ + try: + import matplotlib.pyplot as plt + except ImportError as e: + raise ImportError( + "matplotlib is required for plotting. " + "Install it with: pip install hypertrees[plot]" + ) from e + + fig, axes = plt.subplots(1, len(series_ids), figsize=(5 * len(series_ids), 5), sharex=True) + axes = np.atleast_1d(axes) + model = interval_fcst["model"].iloc[0] if interval_fcst is not None else None + + for ax, sid in zip(axes, series_ids): + for data, x_col, y_col, label, color, style in datasets: + series = data[data["series_id"] == sid] + if y_col == "value": + series = series.tail(history) + ax.plot(series[x_col], series[y_col], label=label, color=color, + linestyle=style, linewidth=2, alpha=0.8) + if interval_fcst is not None: + band = interval_fcst[interval_fcst["series_id"] == sid] + ax.fill_between(band["date"], band[f"{model}-lo-{level}"], band[f"{model}-hi-{level}"], + color="green", alpha=0.15, label=f"{level}% Interval ({model})") + if split_date is not None: + ax.axvline(x=split_date, color="black", linestyle=":", alpha=0.7, label="Train/Test Split") + ax.set_title(sid, fontsize=12) + ax.grid(True, alpha=0.3) + ax.tick_params(axis="x", rotation=30) + + fig.suptitle(title, fontsize=16) + handles, labels = axes[0].get_legend_handles_labels() + fig.legend(handles, labels, loc="lower center", ncol=3, fontsize=11) + plt.tight_layout(rect=(0, 0.12, 1, 0.96)) + plt.show() + + +def plot_model_intervals( + actuals: pd.DataFrame, + forecasts: dict, + levels: list = None, + title: str = None, +) -> None: + """Plot actuals, forecast, and conformal interval bands, one subplot per model. + + Interval columns named ``-lo-`` / ``-hi-`` + (produced by ``forecast(..., level=[...])``) are detected automatically + and shaded, widest level first. A single global legend sits below the + panels. + + Parameters + ---------- + actuals : pd.DataFrame + Realized values with ``date`` and ``value`` columns. + forecasts : dict + Mapping of subplot title to a forecast DataFrame containing + ``date``, ``fcst``, and a ``model`` column. + levels : list of int, optional + Restrict which detected levels are shaded; by default all are shown. + title : str, optional + Figure title. + """ + try: + import matplotlib.pyplot as plt + except ImportError as e: + raise ImportError( + "matplotlib is required for plotting. " + "Install it with: pip install hypertrees[plot]" + ) from e + + fig, axes = plt.subplots(1, len(forecasts), figsize=(6 * len(forecasts), 5), sharey=True) + axes = np.atleast_1d(axes) + + for ax, (name, fcst_df) in zip(axes, forecasts.items()): + model = fcst_df["model"].iloc[0] + ax.plot(actuals["date"], actuals["value"], label="Actual", + color="#2E86AB", linewidth=2, alpha=0.8) + ax.plot(fcst_df["date"], fcst_df["fcst"], label="Forecast", + color="green", linestyle="--", linewidth=2) + + detected = sorted( + int(m.group(1)) + for c in fcst_df.columns + for m in [re.fullmatch(rf"{re.escape(model)}-lo-(\d+)", c)] + if m + ) + if levels is not None: + detected = [lv for lv in detected if lv in set(levels)] + # Shade widest band first so narrower bands sit on top. + alphas = [0.15, 0.28, 0.40] + shade = {lv: a for lv, a in zip(sorted(detected, reverse=True), alphas)} + for lv in sorted(detected, reverse=True): + ax.fill_between( + fcst_df["date"], + fcst_df[f"{model}-lo-{lv}"], + fcst_df[f"{model}-hi-{lv}"], + color="green", alpha=shade.get(lv, 0.2), label=f"{lv}% Interval", + ) + + ax.axvline(x=fcst_df["date"].min(), color="black", linestyle=":", + alpha=0.7, label="Train/Test Split") + ax.set_title(name, fontsize=14) + ax.grid(True, alpha=0.3) + + if title is not None: + fig.suptitle(title, fontsize=16) + handles, labels = axes[0].get_legend_handles_labels() + fig.legend(handles, labels, loc="lower center", ncol=len(labels), fontsize=11) + plt.tight_layout(rect=(0, 0.08, 1, 0.96 if title is not None else 1.0)) + plt.show() + + def coverage( df: pd.DataFrame, level: int, diff --git a/hypertrees/models/HyperTreeAR.py b/hypertrees/models/HyperTreeAR.py index 490c640..55865c3 100644 --- a/hypertrees/models/HyperTreeAR.py +++ b/hypertrees/models/HyperTreeAR.py @@ -665,7 +665,7 @@ def _model_factory(): except Exception as e: self.is_trained = False - raise RuntimeError(f"Training failed: {str(e)}") + raise RuntimeError(f"Training failed: {str(e)}") from e def set_forecast_origin(self, history: pd.DataFrame) -> None: """Re-anchor the AR lag seed to the end of *history* without retraining. @@ -850,4 +850,4 @@ def forecast( return out_df except Exception as e: - raise RuntimeError(f"Forecasting not successful: {str(e)}") + raise RuntimeError(f"Forecasting not successful: {str(e)}") from e diff --git a/hypertrees/models/HyperTreeETS.py b/hypertrees/models/HyperTreeETS.py index 692ed3b..609479e 100644 --- a/hypertrees/models/HyperTreeETS.py +++ b/hypertrees/models/HyperTreeETS.py @@ -7,6 +7,7 @@ from typing import Tuple, List, Callable, Optional import time import random +import warnings from ..utils import CustomLogger lgb.register_logger(CustomLogger()) @@ -34,7 +35,8 @@ class HyperTreeETS: - Combines tree-based models (LightGBM) with exponential smoothing time series modeling - Allows ETS parameters to vary based on features - Provides ETS parameters that can vary over time - - Supports both triple exponential smoothing (with seasonality) and trend-only models + - Supports triple exponential smoothing with multiplicative ("triple") or + additive ("additive") seasonality, as well as trend-only models Use this model when: - You have relevant features that might influence the smoothing structure @@ -106,13 +108,20 @@ def __init__( Arguments ---------- ets_type : str - Type of ETS model to use. Either "triple" (with seasonality) or "trend" (linear trend-only). + Type of ETS model to use. Options: + - "triple": Holt-Winters with *multiplicative* seasonality and a + damped trend. Requires strictly positive series. + - "additive": Holt-Winters with *additive* seasonality and a + damped trend. Use when seasonal swings are roughly constant in + absolute size, or when series contain zeros or negative values + (where multiplicative seasonality breaks down). + - "trend": linear trend-only (no seasonality). season_length : int Seasonal length of the time series (e.g., 12 for monthly data, 4 for quarterly). seasonality_feature : str Feature name for seasonality. This is used to create seasonal indices. Must be present in the dataset. For example, "month" for monthly data, "quarter" for quarterly data, etc. This is required when - ets_type is "triple". Values must be 1-based season positions in [1, season_length]; + ets_type is "triple" or "additive". Values must be 1-based season positions in [1, season_length]; shift 0-based features (e.g. pandas dayofweek in 0..6) by +1. freq : str Frequency of the time series (e.g., 'D' for daily, 'M' for monthly, @@ -130,7 +139,8 @@ def __init__( More probes reduce variance but increase computation. Default is 5. seasonal_init : str Initialization of the seasonal/level/trend states for the triple - ETS forward pass (ignored for ets_type="trend"). Options: + ETS forward pass (ignored for ets_type="trend"; ets_type="additive" + always uses its classical additive estimator). Options: - "classical" (default): decomposition-based estimator following R's forecast::ets and statsforecast (centered 2 x m moving-average detrending, slot-aligned seasonal indices, OLS level/trend seed). @@ -138,8 +148,8 @@ def __init__( reproducing earlier results (including the paper benchmarks). """ # Validate inputs - if ets_type not in ["triple", "trend"]: - raise ValueError("ets_type must be either 'triple' or 'trend'.") + if ets_type not in ["triple", "additive", "trend"]: + raise ValueError("ets_type must be one of 'triple', 'additive', or 'trend'.") if seasonal_init not in ["classical", "legacy"]: raise ValueError("seasonal_init must be either 'classical' or 'legacy'.") if season_length <= 0: @@ -158,7 +168,6 @@ def __init__( "MAE-like loss with usable curvature." ) if not isinstance(loss_fn, nn.MSELoss): - import warnings warnings.warn( f"Loss {type(loss_fn).__name__} is not nn.MSELoss. The Gauss-Newton " "Hessian requires a twice-differentiable loss; non-smooth losses " @@ -168,15 +177,15 @@ def __init__( ) if not isinstance(freq, str): raise TypeError("freq must be a string representing the frequency of the time series.") - if seasonality_feature is None and ets_type == "triple": - raise ValueError("seasonality_feature must be provided for triple ETS type.") + if seasonality_feature is None and ets_type in ("triple", "additive"): + raise ValueError(f"seasonality_feature must be provided for {ets_type} ETS type.") self.ets_type = ets_type self.season_length = season_length self.seasonality_feature = seasonality_feature self.seasonal_init = seasonal_init self.freq = freq - self.n_params = 4 if ets_type == "triple" else 2 # alpha, beta, gamma, phi OR alpha, beta + self.n_params = 4 if ets_type in ("triple", "additive") else 2 # alpha, beta, gamma, phi OR alpha, beta self.fcst_h = fcst_h self.loss_fn = loss_fn self.loss_name = self.loss_fn.__class__.__name__ @@ -206,6 +215,8 @@ def __init__( # Set the appropriate forward function based on ETS type if self.ets_type == "triple": self.forward = self._forward_triple + elif self.ets_type == "additive": + self.forward = self._forward_additive elif self.ets_type == "trend": self.forward = self._forward_trend @@ -691,6 +702,279 @@ def _forward_triple( return level_prev, trend_prev, seasonality, fits + def _init_additive_states( + self, + target: torch.Tensor, + mask: torch.Tensor, + seasonality_idxs: torch.Tensor, + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """Initial seasonal indices and level/trend states for additive ETS. + + Additive counterpart of the classical ``_init_triple_states`` + estimator, following R's ``forecast::ets`` / statsmodels' heuristic + initialization [1, 2]: the trend is removed with a centered 2 x m + moving average, the detrended *differences* ``y - trend`` are averaged + per seasonal slot and normalized to mean zero, and level/trend are + seeded by an OLS fit on the seasonally adjusted head ``y - s``. + Indices are assigned via ``seasonality_idxs`` so they land in the + slots the recursion reads; short series and empty slots fall back to a + simple per-slot deviation from the series mean. All statistics are + mask-aware. + + References + ---------- + [1] Hyndman, R. J., Koehler, A. B., Ord, J. K., & Snyder, R. D. + (2008). Forecasting with Exponential Smoothing: The State Space + Approach. Springer. (Initialization heuristic, Section 2.6.1) + [2] Hyndman, R. J., & Athanasopoulos, G. (2021). Forecasting: + Principles and Practice (3rd ed.). OTexts. + https://otexts.com/fpp3/ + + Parameters + ---------- + target : torch.Tensor + Observations, shape ``(n_series, T)``. + mask : torch.Tensor + Validity mask (1 = real observation, 0 = padding), + shape ``(n_series, T)``. + seasonality_idxs : torch.Tensor + 0-based seasonal slot per observation, shape ``(n_series, T)``. + + Returns + ------- + Tuple[torch.Tensor, torch.Tensor, torch.Tensor] + Seasonal indices ``(n_series, season_length)``, initial level + ``(n_series,)``, and initial trend ``(n_series,)``. + """ + N, T = target.shape + m = self.season_length + + slot_ids = torch.arange(N, dtype=torch.long).unsqueeze(1) * m + seasonality_idxs # (N, T) + ym = target * mask + + def slot_sum(ids: torch.Tensor, values: torch.Tensor) -> torch.Tensor: + """Sum ``values`` into their (series, slot) cells -> (N, m).""" + return torch.zeros(N * m, dtype=self.dtype).index_add_( + 0, ids.reshape(-1), values.reshape(-1) + ).reshape(N, m) + + # --- Fallback estimator: per-slot deviation from the series mean ---- + cnts = slot_sum(slot_ids, mask) + slot_mean = slot_sum(slot_ids, ym) / cnts.clamp(min=1.0) + grand_mean = ym.sum(dim=1) / mask.sum(dim=1).clamp(min=1.0) + simple_idx = torch.where( + cnts > 0, + slot_mean - grand_mean.unsqueeze(1), + torch.zeros_like(slot_mean), + ) + seasonality = simple_idx + + # --- Detrended estimator: centered 2 x m MA, then per-slot diffs ---- + L = m + 1 if m % 2 == 0 else m # always odd + if T >= L: + kernel = torch.full((1, 1, L), 1.0 / m, dtype=self.dtype) + if m % 2 == 0: + kernel[0, 0, 0] = 0.5 / m + kernel[0, 0, -1] = 0.5 / m + trend_ma = torch.nn.functional.conv1d( + ym.unsqueeze(1), kernel + ).squeeze(1) # (N, T - L + 1), centered at offset L // 2 + window_valid = torch.nn.functional.conv1d( + mask.unsqueeze(1), torch.ones((1, 1, L), dtype=self.dtype) + ).squeeze(1) >= L - 0.5 # full window unmasked (implies a valid center) + + half = L // 2 + y_c = target[:, half:T - half] # window centers, length T - L + 1 + diffs = torch.where( + window_valid, y_c - trend_ma, torch.zeros_like(y_c) + ) + + d_cnts = slot_sum(slot_ids[:, half:T - half], window_valid.to(self.dtype)) + detr_idx = slot_sum(slot_ids[:, half:T - half], diffs) / d_cnts.clamp(min=1.0) + seasonality = torch.where(d_cnts > 0, detr_idx, simple_idx) + + # Normalize to mean zero (additive seasonal indices sum to ~0) + seasonality = seasonality - seasonality.mean(dim=1, keepdim=True) + + # --- Level/trend: OLS on the seasonally-adjusted head (as in ets) ---- + s_t = seasonality.gather(1, seasonality_idxs) + y_sa = target - s_t + maxn = min(max(10, 2 * m), T) + t_idx = torch.arange(1, maxn + 1, dtype=self.dtype).unsqueeze(0) + w = mask[:, :maxn] + sw = w.sum(dim=1).clamp(min=1.0) + mean_t = (w * t_idx).sum(dim=1) / sw + mean_y = (w * y_sa[:, :maxn]).sum(dim=1) / sw + dev_t = t_idx - mean_t.unsqueeze(1) + var_t = (w * dev_t ** 2).sum(dim=1) + cov_ty = (w * dev_t * (y_sa[:, :maxn] - mean_y.unsqueeze(1))).sum(dim=1) + trend0 = torch.where( + var_t > self.eps, + cov_ty / var_t.clamp(min=self.eps), + torch.zeros_like(cov_ty), + ) + # Evaluate the line at the first observation (t = 1 on the OLS axis) + # so level0 matches this recursion's timing, which seeds the state at + # the first observation rather than one step before it. + level0 = mean_y + trend0 * (1.0 - mean_t) + + return seasonality, level0, trend0 + + def _cached_init_additive_states( + self, + data: lgb.Dataset, + target: torch.Tensor, + mask: torch.Tensor, + seasonality_idxs: torch.Tensor, + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """Cache wrapper around :meth:`_init_additive_states`. + + Identical caching semantics to :meth:`_cached_init_triple_states`: + results are cached per lgb.Dataset (pinning the dataset object), the + seasonal indices are cloned on every return because the recursion + updates them in place, and the cache is cleared by ``train()``. + + Parameters + ---------- + data : lgb.Dataset + Dataset whose identity serves as the cache key. + target : torch.Tensor + Observations, shape ``(n_series, T)``. + mask : torch.Tensor + Validity mask (1 = real observation, 0 = padding), shape ``(n_series, T)``. + seasonality_idxs : torch.Tensor + 0-based seasonal slot per observation, shape ``(n_series, T)``. + + Returns + ------- + Tuple[torch.Tensor, torch.Tensor, torch.Tensor] + Seasonal indices ``(n_series, season_length)``, initial level + ``(n_series,)``, and initial trend ``(n_series,)``. + """ + key = id(data) + entry = self._init_cache.get(key) + if entry is not None: + return entry["seasonality"].clone(), entry["level0"], entry["trend0"] + + seasonality, level0, trend0 = self._init_additive_states( + target, mask, seasonality_idxs + ) + if len(self._init_cache) > 8: + # Bound growth from one-shot datasets (e.g. _store_final_states, + # conformal re-anchoring); the persistent train/eval entries are + # simply recomputed once after a clear. + self._init_cache.clear() + # Storing the dataset pins its id: a key hit therefore implies this + # exact dataset, and with it identical target/mask/positions. + self._init_cache[key] = { + "data": data, + "seasonality": seasonality, + "level0": level0, + "trend0": trend0, + } + return seasonality.clone(), level0, trend0 + + def _forward_additive( + self, + params: torch.Tensor, + data: lgb.Dataset, + target: torch.Tensor, + mask: torch.Tensor, + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, List[torch.Tensor]]: + """ + Forward pass for additive triple exponential smoothing. + + This implements the ETS state space equations for the additive + damped-trend Holt-Winters method (ETS(A,Ad,A)), in the component form + of Hyndman & Athanasopoulos, Forecasting: Principles and Practice + (https://otexts.com/fpp3/): + - Level: l_t = α(y_t - s_{t-m}) + (1-α)(l_{t-1} + φb_{t-1}) + - Trend: b_t = β(l_t - l_{t-1}) + (1-β)φb_{t-1} + - Seasonality: s_t = γ(y_t - l_{t-1} - φb_{t-1}) + (1-γ)s_{t-m} + - Fitted: ŷ_t = l_{t-1} + φb_{t-1} + s_{t-m} + + Parameters + ---------- + params : torch.Tensor + Sigmoid-transformed ETS parameters, shape ``(n_series, T, n_params)``. + data : lgb.Dataset + LightGBM dataset whose raw DataFrame provides the seasonality feature. + target : torch.Tensor + Observations, shape ``(n_series, T)``. + mask : torch.Tensor + Validity mask (1 = real observation, 0 = padding), shape ``(n_series, T)``. + + Returns + ------- + Tuple[torch.Tensor, torch.Tensor, torch.Tensor, List[torch.Tensor]] + Final level (n_series,), final trend (n_series,), + seasonality matrix (n_series, season_length), and list of fitted values. + """ + series_len = target.shape[1] + + # Unpack and pre-unbind parameters + alpha, beta, gamma, phi = params.unbind(dim=2) + alpha_t = alpha.unbind(dim=1) + beta_t = beta.unbind(dim=1) + gamma_t = gamma.unbind(dim=1) + phi_t = phi.unbind(dim=1) + + # Get seasonal indices from features first: the state initialization + # assigns initial indices to the same slots the recursion reads, so a + # series that does not start at season position 1 is not rotated. + seasonality_idxs = self._seasonal_positions( + data.data[self.seasonality_feature].values + ).reshape(self.n_series, -1) + batch_idx = torch.arange(self.n_series, dtype=torch.long) + + # Initialize seasonal indices and level/trend states via the classical + # decomposition-based estimator (additive form). The result depends + # only on the data, so it is cached per lgb.Dataset and reused across + # boosting iterations. + seasonality, level_prev, trend_prev = self._cached_init_additive_states( + data, target, mask, seasonality_idxs + ) + fits = [target[:, 0]] + + # Pre-unbind the data tensors so the loop indexes Python tuples + # instead of slicing tensors at every step. + target_t = target.unbind(dim=1) + mask_t = mask.unbind(dim=1) + idxs_t = seasonality_idxs.unbind(dim=1) + + # Additive ETS updates with masking for padded values (shared + # subexpressions hoisted; see _forward_triple). + for t in range(1, series_len): + valid_mask = mask_t[t] + invalid_mask = 1 - valid_mask + y_t = target_t[t] + s_prev = seasonality[batch_idx, idxs_t[t]] # s_{t-m} + phi_trend = phi_t[t] * trend_prev # phi_t * b_{t-1} + pred_base = level_prev + phi_trend # l_{t-1} + phi_t * b_{t-1} + + fit_t = valid_mask * (pred_base + s_prev) + invalid_mask * fits[-1] + + level_new = valid_mask * ( + alpha_t[t] * (y_t - s_prev) + + (1 - alpha_t[t]) * pred_base + ) + invalid_mask * level_prev + + trend_new = valid_mask * ( + beta_t[t] * (level_new - level_prev) + + (1 - beta_t[t]) * phi_trend + ) + invalid_mask * trend_prev + + seasonality[batch_idx, idxs_t[t]] = valid_mask * ( + gamma_t[t] * (y_t - pred_base) + + (1 - gamma_t[t]) * s_prev + ) + invalid_mask * s_prev + + fits.append(fit_t) + level_prev = level_new + trend_prev = trend_new + + return level_prev, trend_prev, seasonality, fits + def _forward_trend( self, params: torch.Tensor, @@ -1073,14 +1357,15 @@ def _model_factory(): except Exception as e: self.is_trained = False - raise RuntimeError(f"Training failed: {str(e)}") + raise RuntimeError(f"Training failed: {str(e)}") from e def _store_final_states(self, train_data: pd.DataFrame): """ Store final ETS states after training for use in forecasting. Runs a full forward pass on the training data to obtain the final - level, trend, and (for triple ETS) seasonality states per series. + level, trend, and (for the seasonal variants, triple/additive) + seasonality states per series. Also stores the series ordering to ensure consistent state access. Parameters @@ -1123,8 +1408,8 @@ def _store_final_states(self, train_data: pd.DataFrame): 'last_trend': last_trend[i] } - # Store seasonality for triple ETS - if self.ets_type == "triple" and seasonality is not None: + # Store seasonality for the seasonal ETS variants + if self.ets_type in ("triple", "additive") and seasonality is not None: for i, series_id in enumerate(self.series_order): self.fcst_states[series_id]['seasonality'] = seasonality[i] @@ -1325,6 +1610,55 @@ def forecast( level_h = level_new trend_h = trend_new + elif self.ets_type == "additive": + # Extract seasonality in test series order + seasonality = torch.stack( + [self.fcst_states[series_id]['seasonality'] for series_id in test_series_ids] + ) + + seasonality_idxs = self._seasonal_positions( + test_data[self.seasonality_feature].values + ).reshape(self.n_series, self.fcst_h) + batch_idx = torch.arange(self.n_series, dtype=torch.long) + alpha_fcst = fcst_params[:, :, 0] + beta_fcst = fcst_params[:, :, 1] + gamma_fcst = fcst_params[:, :, 2] + phi_fcst = fcst_params[:, :, 3] + + fcsts = [] + level_h = last_level + trend_h = last_trend + for h in range(self.fcst_h): + alpha = alpha_fcst[:, h] + beta = beta_fcst[:, h] + gamma = gamma_fcst[:, h] + phi = phi_fcst[:, h] + s_idx = seasonality_idxs[:, h].long() + s_h = seasonality[batch_idx, s_idx] + + # One-step-ahead fit (pseudo-observation), + # structurally identical to _forward_additive + pred_base = level_h + phi * trend_h + pseudo_y = pred_base + s_h + fcsts.append(pseudo_y.reshape(-1, 1)) + + # State updates exactly as in _forward_additive. + level_new = ( + alpha * (pseudo_y - s_h) + + (1 - alpha) * pred_base + ) + trend_new = ( + beta * (level_new - level_h) + + (1 - beta) * phi * trend_h + ) + seasonality[batch_idx, s_idx] = ( + gamma * (pseudo_y - pred_base) + + (1 - gamma) * s_h + ) + + level_h = level_new + trend_h = trend_new + elif self.ets_type == "trend": alpha_fcst = fcst_params[:, :, 0] beta_fcst = fcst_params[:, :, 1] @@ -1390,11 +1724,11 @@ def forecast( "date": test_data["date"].to_numpy().flatten(), "model": f"Hyper-Tree-ETS({self.ets_type})", }) - param_names = ["alpha", "beta", "gamma", "phi"] if self.ets_type == "triple" else ["alpha", "beta"] + param_names = ["alpha", "beta", "gamma", "phi"] if self.ets_type in ("triple", "additive") else ["alpha", "beta"] for i, param_name in enumerate(param_names): out_df[param_name] = fcst_params[:, :, i].flatten().numpy() return out_df except Exception as e: - raise RuntimeError(f"Forecasting not successful: {str(e)}") + raise RuntimeError(f"Forecasting not successful: {str(e)}") from e diff --git a/hypertrees/models/HyperTreeNetAR.py b/hypertrees/models/HyperTreeNetAR.py index 191e9cd..5c36882 100644 --- a/hypertrees/models/HyperTreeNetAR.py +++ b/hypertrees/models/HyperTreeNetAR.py @@ -27,7 +27,7 @@ class HyperTreeNetAR: Class that implements a Hyper-TreeNet-AR(p) model for time series forecasting. It combines LightGBM with a neural network, where the LightGBM first creates embeddings from the input data which - are then mapped as parameters to the target time series model. The HyperTree-AR(p) model extends traditional + are then mapped as parameters to the target time series model. The Hyper-TreeNet-AR(p) model extends traditional autoregressive models by allowing the AR coefficients to be time-varying and estimated by a combination of neural network and gradient boosted trees. This creates a non-linear, adaptive autoregressive model that can capture complex temporal dependencies. @@ -141,7 +141,9 @@ def __init__( This allows for GPU acceleration of network training if available. hessian_method : str Method for computing the Hessian diagonal. Options: - - "exact": Exact diagonal Hessian via per-parameter second-order autograd. + - "exact": Exact diagonal Hessian via per-embedding-dimension + second-order autograd (cheap, since the embedding is + low-dimensional). - "gn": Gauss-Newton approximation estimated via Hutchinson probing. Guarantees positive semi-definite Hessians. Avoids second-order differentiation at the cost of Hutchinson estimation variance. @@ -265,7 +267,7 @@ def eval_fn(self, predt: np.ndarray, eval_data: lgb.Dataset) -> Tuple[str, float warnings.warn("Unknown dataset in metric_fn. Using training lags.") # Calculate loss - is_higher_better = False + is_higher_better = False # Lower loss is better, so we don't maximize target = torch.tensor(eval_data.get_label().reshape(-1, 1), dtype=self.dtype, device=self.device) # For evaluation, we need to compute loss without any backward pass or gradient computation @@ -438,26 +440,9 @@ def _calculate_gradients_and_hessians_separate(self, loss: torch.Tensor, embeds: for i in range(self.embedding_dim) ] - # Batched Hessian-diagonal computation: replaces the per-dim Python loop with a single batched autograd call. - # n, k = grad.shape - # grad_outputs = ( - # torch.eye(k, device=grad.device, dtype=grad.dtype) - # .unsqueeze(1) - # .expand(k, n, k) - # ) - # hess_full = autograd( - # grad, - # embeds, - # grad_outputs=grad_outputs, - # is_grads_batched=True, - # retain_graph=True, - # )[0] # (k, n, k) - # hess = torch.diagonal(hess_full, dim1=0, dim2=2) # (n, k) - # Convert to numpy arrays and reshape as expected by LightGBM grad = grad.cpu().detach().numpy().ravel(order="F") hess = torch.cat(hess, dim=1).cpu().detach().numpy().ravel(order="F") - # hess = hess.cpu().detach().numpy().ravel(order="F") # only for the batched version return grad, hess @@ -574,7 +559,7 @@ def train( This method: 1. Preprocesses the time series data to create lag features 2. Sets up LightGBM datasets - 3. Train the models + 3. Trains the models The training data must contain columns: - 'series_id': Identifier for each time series @@ -625,7 +610,7 @@ def train( Returns ------- - TrainingResult + TrainingResult Object containing evaluation results and training information. """ # Validate inputs @@ -844,7 +829,7 @@ def _model_factory(): except Exception as e: self.is_trained = False - raise RuntimeError(f"Training failed: {str(e)}") + raise RuntimeError(f"Training failed: {str(e)}") from e def set_forecast_origin(self, history: pd.DataFrame) -> None: """Re-anchor the AR lag seed to the end of *history* without retraining. @@ -970,8 +955,10 @@ def forecast( try: # Get tree embeddings + # Predict on the DataFrame (not .values) so pandas ``category`` + # dtype features keep their categorical encoding at forecast time. gbdt_embeds = torch.tensor( - self.model.predict(test_data[self.features].values), + self.model.predict(test_data[self.features]), dtype=self.dtype, device=self.device ).reshape(-1, self.embedding_dim) @@ -1056,4 +1043,4 @@ def forecast( return out_df except Exception as e: - raise RuntimeError(f"Forecasting not successful: {str(e)}") + raise RuntimeError(f"Forecasting not successful: {str(e)}") from e diff --git a/hypertrees/models/HyperTreeNetVAR.py b/hypertrees/models/HyperTreeNetVAR.py new file mode 100644 index 0000000..5fc5f9e --- /dev/null +++ b/hypertrees/models/HyperTreeNetVAR.py @@ -0,0 +1,679 @@ +import warnings + +import numpy as np +import pandas as pd +import torch +import torch.nn as nn +from torch.autograd import grad as autograd +import lightgbm as lgb +from typing import Callable, Optional, Tuple + +from ..utils import TrainingResult, GaussNewtonHessian +from ..conformal import ForecastIntervals +from ._var_base import _HyperTreeVARBase +from .mlp import MLP + +warnings.filterwarnings( + "ignore", + message="Using backward\\(\\) with create_graph=True will create a reference cycle.*" +) + + +class HyperTreeNetVAR(_HyperTreeVARBase): + """ + Class that implements a Hyper-TreeNet-VAR(p) model for multivariate time series forecasting. + + It combines LightGBM with a neural network, where the LightGBM first creates + embeddings from the input data which are then mapped as parameters to the + target vector autoregression. The model learns the full time-varying + coefficient matrices A_1(x), ..., A_p(x) over an aligned panel of k series + so that y_{i,t} = sum_j A_j[i, :](x_{i,t}) . y_{t-j}, with cross-series + dependence captured by the off-diagonal coefficients (see ``_var_base.py`` + for the formulation, data requirements, coefficient ordering, and the + restricted ``type="factor"`` design). + + Training uses separated gradient flows (Option 2 in the paper, which the + ablations found indistinguishable from the shared-flow Option 1): per + boosting iteration the MLP takes one optimizer step on the current GBDT + embeddings, then gradients and Hessians for the GBDT are computed through + the updated network in inference mode. As in HyperTreeNetAR, the MLP + decoder lives on the instance (``self.network``) and is updated in place + during boosting; there is deliberately no shared/class-level network state. + Unlike ``HyperTreeNetAR``, this model exposes no ``gradient_mode`` option; + only the separated flow (Option 2) is implemented. + + Key features: + - Combines LightGBM and a neural network for multivariate forecasting + - Learns the time-varying lag matrices A_1, ..., A_p as functions of + features (full k x k, or own + factor lags with type="factor") + - Captures cross-series (Granger-causal) lead/lag dependencies via the + off-diagonal coefficients + - Boosting cost is independent of the number of VAR coefficients + + Use this model when: + - Your series influence each other and forecasts should exploit + cross-series lead/lag structure + - The panel implies many coefficients (k * p beyond a few dozen), since + GBDTs do not scale well with the number of parameters + - You want to leverage LightGBM for feature encoding and a neural network + for the mapping from embeddings to VAR coefficients + + Example usage: + ```python + # Imports + from hypertrees.models.HyperTreeNetVAR import HyperTreeNetVAR + import numpy as np + import pandas as pd + import torch + import matplotlib.pyplot as plt + + # Initialize model + lag_p = 4 + frequency = 'M' + fcst_h = 12 + model = HyperTreeNetVAR( + p=lag_p, + freq=frequency, + fcst_h=fcst_h, + device="cuda" if torch.cuda.is_available() else "cpu" + ) + + # Data + # The data needs to be an aligned panel (equal lengths and identical dates + # across series) with the columns: 'date', 'series_id', 'value'. All other + # columns are automatically treated as features. You don't have to add + # lag-values yourself, this happens automatically during training. + rng = np.random.RandomState(1) + dates = pd.date_range("2010-01-01", periods=120 + fcst_h, freq="MS") + df = pd.concat( + [ + pd.DataFrame({ + "series_id": f"s{i}", + "date": dates, + "value": base + np.cumsum(rng.randn(len(dates))), + "month": dates.month, + "quarter": dates.quarter, + "series_num": i, # identifies the series, so equations can differ + }) + for i, base in enumerate([100.0, 150.0]) + ], + ignore_index=True, + ) + test = df.groupby("series_id", sort=False).tail(fcst_h) + train = df.drop(test.index) + + # Train model + model.train( + lgb_params={'learning_rate': 1e-1}, + network_params={ + 'learning_rate': 1e-3, # learning rate for the neural network optimizer + 'embedding_dimension': 1, # embedding dimension for tree-embeddings + 'hidden_dim': 128, # hidden dimension for the MLP network + 'dropout': 0.1, # dropout rate for the MLP network + 'use_random_projection': True, # whether to use random projections for the embeddings + 'rp_embed_dim': 8, # dimension of the random projections (if used) + }, + num_iterations=100, + train_data=train, + seed=123, + verbose=-1 + ) + + # Generate forecasts + forecasts = model.forecast(test_data=test) + + # Plot results + for sid, group in df.groupby("series_id", sort=False): + plt.plot(group["date"], group["value"], label=f"Actual {sid}", + color='#2E86AB', linewidth=2, alpha=0.8) + for sid, group in forecasts.groupby("series_id", sort=False): + plt.plot(group["date"], group["fcst"], label=f"Forecast {sid}", + color='#F18F01', linestyle='--', linewidth=2, alpha=0.8) + + plt.title('Aligned Panel - VAR Forecasts', fontsize=14) + plt.legend(frameon=True, fancybox=True) + plt.grid(True, alpha=0.3) + plt.tight_layout() + ``` + """ + + _model_label = "Hyper-TreeNet-VAR" + _valid_forecast_types = ("forecast", "parameters", "tree_embeddings") + + def __init__( + self, + p: int = 2, + freq: str = "M", + fcst_h: int = 1, + loss_fn: Callable = nn.MSELoss(), + scaling: Optional[str] = "mean", + type: str = "full", + device: str = "cpu", + hessian_method: str = "exact", + n_hessian_probes: int = 5, + ): + """ + Initialize the Hyper-TreeNet-VAR(p) model. + + Arguments + ---------- + p : int + VAR lag order. Must be a positive integer. + freq : str + Frequency of the time series (e.g., 'D' for daily, 'M' for monthly, + 'Q' for quarterly, 'Y' for yearly). + fcst_h : int + Forecast horizon (number of periods to forecast ahead). + loss_fn : Callable + Loss function for optimization. Must be a PyTorch loss function. + Default is MSE loss. Losses other than nn.MSELoss are not + recommended, as they have not been systematically tested yet. + nn.L1Loss is rejected (zero second derivative almost everywhere + breaks Newton boosting). + scaling : str, optional + Per-series scaling applied internally before training; forecasts + (and prediction intervals) are transformed back to the original + scale automatically. Options: "mean" (default; divide by the + mean absolute training value), "standard" (z-score), or None. + Strongly recommended for heterogeneous panels: VAR coefficients + multiply *other* series' values, so unscaled panels force the + model to learn scale conversions while the loss is dominated by + the largest series. Coefficients returned by + ``forecast(type="parameters")`` live in the scaled space. + type : str + Structure of the VAR design vector. Options: + - "full" (default): unrestricted VAR; every equation regresses on + the lags of all k series (``k * p`` coefficients per equation, + decoded by the MLP). + - "factor": restricted GVAR-style design; every equation + regresses on its own lags plus the lags of the equal-weighted + cross-sectional average of the scaled panel (``2 * p`` + coefficients per equation, independent of k). Recommended for + larger panels, where the unrestricted design overparameterizes. + Parameter columns are named ``A{j}(own)`` / ``A{j}(factor)`` + and the model name becomes ``Hyper-TreeNet-FactorVAR(p)``. + device : str + Device to run the model on. Default is 'cpu'. + This allows for GPU acceleration of network training if available. + hessian_method : str + Method for computing the Hessian diagonal. Options: + - "exact": Exact diagonal Hessian via per-embedding-dimension + second-order autograd (cheap, since the embedding is + low-dimensional). + - "gn": Gauss-Newton approximation estimated via Hutchinson probing. + Guarantees positive semi-definite Hessians. Avoids second-order + differentiation at the cost of Hutchinson estimation variance. + n_hessian_probes : int + Number of Hutchinson probes for Gauss-Newton Hessian diagonal estimation. + Only used when hessian_method="gn". More probes reduce variance but + increase computation. Default is 5. + """ + super().__init__( + p=p, + freq=freq, + fcst_h=fcst_h, + loss_fn=loss_fn, + scaling=scaling, + type=type, + ) + if hessian_method not in ("exact", "gn"): + raise ValueError("hessian_method must be either 'exact' or 'gn'.") + if not isinstance(n_hessian_probes, int) or n_hessian_probes <= 0: + raise ValueError("n_hessian_probes must be a positive integer.") + if hessian_method == "gn" and not isinstance(loss_fn, nn.MSELoss): + warnings.warn( + f"Loss {loss_fn.__class__.__name__} is not nn.MSELoss. The Gauss-Newton " + "Hessian requires a twice-differentiable loss; non-smooth losses " + "(e.g., L1Loss, quantile loss, HuberLoss/SmoothL1Loss outside the quadratic " + "region) have zero or undefined second derivatives at kinks, " + "causing degenerate Hessians." + ) + + self.device = device + self.hessian_method = hessian_method + self.n_hessian_probes = n_hessian_probes + self.network = None + self.optimizer = None + self.embedding_dim = None + self._network_params = None + self._fit = None + self._target = None + if hessian_method == "gn": + self._gn_hessian = GaussNewtonHessian(loss_fn, n_hessian_probes, self.dtype) + + def objective_fn(self, predt: np.ndarray, data: lgb.Dataset) -> Tuple[np.ndarray, np.ndarray]: + """ + Custom objective function for LightGBM training. + + This function defines the gradients and hessians for the LightGBM model + based on the PyTorch loss function. It converts the raw LightGBM outputs + to embeddings, updates the MLP, computes the loss through the updated + network, and then backpropagates to get gradients. + + Parameters + ---------- + predt : np.ndarray + Raw outputs from LightGBM, representing the GBDT embeddings. + data : lgb.Dataset + LightGBM dataset containing the target values. + + Returns + ------- + Tuple[np.ndarray, np.ndarray] + Gradients and hessians for LightGBM optimization. + """ + self._iter_count += 1 + + target = torch.tensor( + data.get_label().reshape(self.k, -1), dtype=self.dtype, device=self.device + ) + embeds, loss = self.get_embeds_loss_separate(predt, target, self._Z_train) + grad, hess = self.calculate_gradients_and_hessians(loss, embeds) + + return grad, hess + + def get_embeds_loss_separate( + self, + predt: np.ndarray, + target: torch.Tensor, + Z: torch.Tensor, + ) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Transform LightGBM outputs into embeddings and calculate loss for separate gradients (Option 2). + + This function: + 1. Reshapes the raw outputs into tree embeddings + 2. Maps embeddings to VAR coefficients via the MLP and takes one optimizer step + 3. Recomputes the coefficients through the updated network in inference mode + 4. Calculates the GBDT loss between fitted and actual values + + Parameters + ---------- + predt : np.ndarray + Raw outputs from LightGBM. + target : torch.Tensor + Target values (actual time series values), shape ``(k, T_r)``. + Z : torch.Tensor + VAR design matrix, shape ``(T_r, k * p)`` for the full design or + ``(k * T_r, 2 * p)`` for the factor design. + + Returns + ------- + Tuple[torch.Tensor, torch.Tensor] + GBDT embeddings and loss value. + """ + # Reshape outputs into embedding matrix (samples × embedding_dim) + # The 'F' order means Fortran-style ordering (column-major) + gbdt_embed = torch.tensor( + predt.reshape(-1, self.embedding_dim, order="F"), + requires_grad=True, + dtype=self.dtype, + device=self.device + ) + + # Train network (forward pass) + self.network.train() + var_params_net = self.network(gbdt_embed) + fit_net = self._compute_fit(var_params_net, Z) + network_loss = self.loss_fn(fit_net, target) + self.optimizer.zero_grad() + network_loss.backward() + self.optimizer.step() + + # Calculate loss for GBDT + self.network.eval() + var_params_gbdt = self.network(gbdt_embed) + fit_gbdt = self._compute_fit(var_params_gbdt, Z) + gbm_loss = self.loss_fn(fit_gbdt, target) + + if self.hessian_method == "gn": + self._fit = fit_gbdt + self._target = target + + return gbdt_embed, gbm_loss + + def _calculate_gradients_and_hessians_separate( + self, loss: torch.Tensor, embeds: torch.Tensor, + ) -> Tuple[np.ndarray, np.ndarray]: + """ + Compute gradients and hessians for LightGBM optimization using separate gradients (Option 2). + + This function computes first and second-order derivatives needed for + gradient boosting optimization in LightGBM. + + Parameters + ---------- + loss : torch.Tensor + Loss value from the model. + embeds : torch.Tensor + GBDT embeddings. + + Returns + ------- + Tuple[np.ndarray, np.ndarray] + Gradients and hessians as numpy arrays in the format expected by LightGBM. + """ + # Compute gradients + grad = autograd(loss, inputs=embeds, create_graph=True)[0] + + # Compute hessians. We compute the diagonal of the Hessian matrix for each parameter separately + hess = [ + autograd(grad[:, i].sum(), embeds, retain_graph=True)[0][:, i:(i + 1)] + for i in range(self.embedding_dim) + ] + + # Convert to numpy arrays and reshape as expected by LightGBM + grad = grad.cpu().detach().numpy().ravel(order="F") + hess = torch.cat(hess, dim=1).cpu().detach().numpy().ravel(order="F") + + return grad, hess + + def _calculate_gradients_and_hessians_separate_gn( + self, loss: torch.Tensor, embeds: torch.Tensor, + ) -> Tuple[np.ndarray, np.ndarray]: + """Gauss-Newton Hessian for separate gradient mode via Hutchinson probing. + + Parameters + ---------- + loss : torch.Tensor + Loss value from the model. + embeds : torch.Tensor + GBDT embeddings, shape ``(n_samples, embedding_dim)``. + + Returns + ------- + Tuple[np.ndarray, np.ndarray] + Gradients and hessians as numpy arrays in the format expected by LightGBM. + """ + grad = autograd(loss, inputs=embeds, retain_graph=True)[0] + rng = torch.Generator().manual_seed(self._iter_count) + hess = self._gn_hessian.estimate(self._fit, self._target, embeds, rng) + self._fit = None + self._target = None + grad = grad.cpu().detach().numpy().ravel(order="F") + hess = hess.cpu().detach().numpy().ravel(order="F") + + return grad, hess + + def _fit_from_predt(self, predt: np.ndarray, Z: torch.Tensor) -> torch.Tensor: + """Compute the fitted values for raw LightGBM embedding outputs. + + Parameters + ---------- + predt : np.ndarray + Raw outputs from LightGBM (flattened Fortran-order). + Z : torch.Tensor + Design matrix for the dataset being evaluated, shape + ``(T_r, k * p)`` for the full design or ``(k * T_r, 2 * p)`` for + the factor design. + + Returns + ------- + torch.Tensor + Fitted values, shape ``(k, T_r)``. + """ + gbdt_embed = torch.tensor( + predt.reshape(-1, self.embedding_dim, order="F"), + dtype=self.dtype + ).to(self.device) + + # self.network is the live module the objective updated in this same + # boosting iteration (guaranteed by NoDeepcopyObjective). + self.network.eval() + with torch.no_grad(): + var_params = self.network(gbdt_embed) + fit = self._compute_fit(var_params, Z) + + return fit + + def _num_class(self) -> int: + """LightGBM output dimension: the tree-embedding dimension.""" + + return self.embedding_dim + + def _reset_training_state(self) -> None: + """Reset per-training state, including the network-specific parts.""" + super()._reset_training_state() + self._fit = None + self._target = None + self.network = None + self.optimizer = None + + def _post_datasets_setup(self, seed: int) -> None: + """Construct the MLP decoder and optimizer once the panel dimensions are known. + + Called after ``_build_panel_datasets`` has set ``self.n_params`` + (``k * p`` for type="full", ``2 * p`` for type="factor"), which is + the MLP output dimension. + + Parameters + ---------- + seed : int + Random seed forwarded from ``train()``. + """ + network_params = self._network_params + + # Seed torch before constructing the MLP so initialization (and dropout + # draws during training) are reproducible even when the random + # projection layer -- whose constructor reseeds torch -- is disabled. + torch.manual_seed(seed) + + self.network = MLP( + tree_embed_dim=self.embedding_dim, + output_dim=self.n_params, + hidden_dim=network_params["hidden_dim"], + use_random_projection=network_params["use_random_projection"], + rp_embed_dim=network_params["rp_embed_dim"] if network_params["use_random_projection"] else None, + dropout_rate=network_params["dropout"], + seed=seed + ).to(self.device) + self.optimizer = torch.optim.Adam(self.network.parameters(), lr=network_params["learning_rate"]) + + def train( + self, + lgb_params: dict = None, + network_params: dict = None, + num_iterations: int = 100, + train_data: pd.DataFrame = None, + validation: bool = False, + early_stopping_round: Optional[int] = None, + seed: int = 123, + verbose: int = -1, + deterministic: bool = True, + forecast_intervals: Optional[ForecastIntervals] = None, + ) -> TrainingResult: + """ + Train the Hyper-TreeNet-VAR model on an aligned panel of time series. + + This method: + 1. Pivots the panel and builds the VAR design matrix + 2. Sets up LightGBM datasets (one row per series and time step) + 3. Trains the models + + The training data must contain columns: + - 'series_id': Identifier for each time series + - 'date': Timestamp for each observation + - 'value': Target value to forecast + - Additional feature columns used for forecasting + + All series must have the same length and identical dates (aligned + panel); see ``_var_base.py``. + + Parameters + ---------- + lgb_params : dict + LightGBM parameters + network_params : dict + Network parameters. Available parameters are: + - "learning_rate": Learning rate for the neural network optimizer + - "hidden_dim": Dimension of the hidden layer in the MLP + - "embedding_dimension": Dimension of the tree embeddings from LightGBM + - "use_random_projection": Whether to use random projection for embeddings + - "rp_embed_dim": Dimension of the random projection embeddings (if used) + - "dropout": Dropout rate for regularization + num_iterations : int + Number of boosting rounds for training + train_data : pd.DataFrame + Training data containing series_id, date, value and feature columns + validation : bool + If True, a validation set will be created for evaluation. It splits + the last fcst_h time steps of each series for validation. + early_stopping_round : int, optional + If provided, training will stop if the validation loss does not + improve for this many rounds. + seed : int + Random seed for reproducibility + verbose : int + Verbosity level for LightGBM training + deterministic : bool + If True, sets LightGBM's ``deterministic`` and ``force_row_wise`` + parameters to ensure reproducible results. May slow down training. + See https://lightgbm.readthedocs.io/en/latest/Parameters.html#deterministic + forecast_intervals : ForecastIntervals, optional + If provided, calibrate conformal prediction intervals via + rolling-window cross-validation after the main model is trained. + The collected conformity scores are then used by + ``forecast(..., level=[...])`` to produce ``-lo-`` / + ``-hi-`` columns. See + :class:`hypertrees.conformal.ForecastIntervals`. + + Returns + ------- + TrainingResult + Object containing evaluation results and training information. + """ + if network_params is None: + raise ValueError("network_params must be provided.") + if not isinstance(network_params, dict): + raise TypeError("network_params must be a dictionary.") + required_net_keys = ( + "learning_rate", "embedding_dimension", "hidden_dim", + "dropout", "use_random_projection", + ) + missing_keys = [key for key in required_net_keys if key not in network_params] + if missing_keys: + raise ValueError(f"network_params is missing required keys: {missing_keys}") + + self.embedding_dim = network_params["embedding_dimension"] + self._network_params = network_params + + # Select gradient computation based on Hessian method + if self.hessian_method == "exact": + self.calculate_gradients_and_hessians = self._calculate_gradients_and_hessians_separate + else: + self.calculate_gradients_and_hessians = self._calculate_gradients_and_hessians_separate_gn + + def _model_factory(): + return HyperTreeNetVAR( + p=self.p, + freq=self.freq, + fcst_h=self.fcst_h, + loss_fn=self.loss_fn, + scaling=self.scaling, + type=self.type, + device=self.device, + hessian_method=self.hessian_method, + n_hessian_probes=self.n_hessian_probes, + ) + + cal_train_kwargs = dict( + lgb_params=lgb_params, + network_params=network_params, + num_iterations=num_iterations, + validation=False, + seed=seed, + verbose=verbose, + deterministic=deterministic, + ) + + return self._train_core( + lgb_params=lgb_params, + num_iterations=num_iterations, + train_data=train_data, + validation=validation, + early_stopping_round=early_stopping_round, + seed=seed, + verbose=verbose, + deterministic=deterministic, + forecast_intervals=forecast_intervals, + model_factory=_model_factory, + cal_train_kwargs=cal_train_kwargs, + ) + + def _tree_embeddings(self, features_df: pd.DataFrame) -> torch.Tensor: + """Compute the GBDT tree embeddings for a feature frame. + + Parameters + ---------- + features_df : pd.DataFrame + Feature frame (training feature columns only). + + Returns + ------- + torch.Tensor + Tree embeddings, shape ``(n_rows, embedding_dim)``. + """ + # Predict on the DataFrame (not .values) so pandas ``category`` + # dtype features keep their categorical encoding at forecast time. + gbdt_embeds = torch.tensor( + self.model.predict(features_df), + dtype=self.dtype, + device=self.device + ).reshape(-1, self.embedding_dim) + + return gbdt_embeds + + def _forecast_params(self, features_df: pd.DataFrame) -> np.ndarray: + """Forecast the ``(n_rows, n_params)`` coefficient matrix via GBDT + MLP. + + Parameters + ---------- + features_df : pd.DataFrame + Feature frame (training feature columns only). + + Returns + ------- + np.ndarray + VAR coefficients per row, shape ``(n_rows, n_params)``. + """ + gbdt_embeds = self._tree_embeddings(features_df) + + # self.network holds this instance's trained weights (boosting + # updated it in place; see NoDeepcopyObjective). + self.network.eval() + with torch.no_grad(): + params_fcst = (self.network(gbdt_embeds) + .cpu() + .detach() + .numpy()) + + return params_fcst + + def _forecast_tree_embeddings(self, test_data: pd.DataFrame, model_name: str) -> pd.DataFrame: + """Build the ``type="tree_embeddings"`` output DataFrame. + + Parameters + ---------- + test_data : pd.DataFrame + Validated forecast input (features already injected). + model_name : str + Model name identifier for the ``model`` column. + + Returns + ------- + pd.DataFrame + DataFrame with one ``tree_embedding_{i}`` column per embedding + dimension. + """ + gbdt_embeds = self._tree_embeddings(test_data[self.features]) + + out_df = pd.DataFrame({ + "series_id": test_data["series_id"].to_numpy().flatten(), + "date": test_data["date"].to_numpy().flatten(), + "model": model_name, + }) + # Add tree embeddings to the dataframe + for i in range(self.embedding_dim): + out_df[f"tree_embedding_{i + 1}"] = gbdt_embeds[:, i].cpu().numpy().flatten() + + return out_df diff --git a/hypertrees/models/HyperTreeSTL.py b/hypertrees/models/HyperTreeSTL.py index 3ef1414..c53754b 100644 --- a/hypertrees/models/HyperTreeSTL.py +++ b/hypertrees/models/HyperTreeSTL.py @@ -704,7 +704,7 @@ def train( except Exception as e: self.is_trained = False - raise RuntimeError(f"Training failed: {str(e)}") + raise RuntimeError(f"Training failed: {str(e)}") from e def forecast( self, @@ -838,4 +838,4 @@ def forecast( return out_df except Exception as e: - raise RuntimeError(f"Forecasting not successful: {str(e)}") + raise RuntimeError(f"Forecasting not successful: {str(e)}") from e diff --git a/hypertrees/models/HyperTreeTSB.py b/hypertrees/models/HyperTreeTSB.py new file mode 100644 index 0000000..1d5a4f7 --- /dev/null +++ b/hypertrees/models/HyperTreeTSB.py @@ -0,0 +1,964 @@ +import numpy as np +import pandas as pd +import torch +import torch.nn as nn +from torch.autograd import grad as autograd +import lightgbm as lgb +from typing import Tuple, List, Callable, Optional +import time +import random +import warnings +from ..utils import CustomLogger +lgb.register_logger(CustomLogger()) + +from ..utils import TimeSeriesPreprocessor, prepare_datasets, TrainingResult, validate_series_order, GaussNewtonHessian, NoDeepcopyObjective +from ..conformal import ( + ForecastIntervals, + validate_calibration_length, + rolling_origin_residuals, + interval_columns, +) + +class HyperTreeTSB: + """ + Class that implements a Hyper-Tree-TSB model for intermittent demand forecasting. + + The Teunter-Syntetos-Babai (TSB) method forecasts intermittent demand as the + product of two exponentially smoothed components: the demand *probability* + ``p_t`` (smoothed occurrence indicator, updated every period) and the demand + *size* ``z_t`` (smoothed over nonzero demands only). The Hyper-Tree variant + makes both smoothing parameters time-varying functions of features, so the + responsiveness of probability and size estimates can adapt to e.g. + promotions, listings, or seasonality. The recursion follows the reference + implementation in Nixtla's statsforecast: + + - Occurrence: d_t = 1 if y_t != 0 else 0 + - Probability: p_t = p_{t-1} + alpha_p,t * (d_t - p_{t-1}) + - Size: z_t = z_{t-1} + alpha_d,t * (y_t - z_{t-1}) if d_t = 1 else z_{t-1} + - Fitted: y_hat_t = p_{t-1} * z_{t-1} + - Forecast: y_hat_{T+h} = p_T * z_T (flat over the horizon, as in the + classical method: future demand occurrence is unobserved and the expected + states propagate unchanged) + + States are initialized as in statsforecast: ``p_0`` with the first + occurrence indicator and ``z_0`` with the first nonzero demand (0 for + all-zero series, which therefore forecast 0). For cross-series learning, + all series must have the same length; datasets with varying lengths should + be padded and carry a ``mask`` column (1 = valid observation, 0 = padding). + + Key features: + - Designed for intermittent (sporadic, zero-inflated) demand + - Combines tree-based models (LightGBM) with the TSB method + - Allows the smoothing parameters to vary based on features + - Handles obsolescence: the probability estimate decays during zero-demand periods + + Use this model when: + - Series contain frequent zeros (intermittent demand), where AR and ETS + target models are structurally misspecified + - You have features that signal when demand probability or size shifts + + References + ---------- + [1] Teunter, R. H., Syntetos, A. A., & Babai, M. Z. (2011). Intermittent + demand: Linking forecasting to inventory obsolescence. European + Journal of Operational Research, 214(3), 606-615. + [2] Recursion and state-initialization conventions follow the TSB + implementation in Nixtla's statsforecast (Apache-2.0): + https://github.com/Nixtla/statsforecast + + Example usage: + ```python + # Imports + from hypertrees.models.HyperTreeTSB import HyperTreeTSB + import numpy as np + import pandas as pd + + # Initialize model + frequency = 'W' + fcst_h = 8 + model = HyperTreeTSB(freq=frequency, fcst_h=fcst_h) + + # Data: intermittent demand with columns 'date', 'series_id', 'value'. + # All other columns are automatically treated as features. + rng = np.random.RandomState(1) + dates = pd.date_range("2022-01-03", periods=104 + fcst_h, freq="W-MON") + demand = rng.binomial(1, 0.3, len(dates)) * rng.poisson(5, len(dates)) + df = pd.DataFrame({ + "series_id": "sku_1", + "date": dates, + "value": demand.astype(float), + "month": dates.month, + }) + test = df.tail(fcst_h) + train = df.drop(test.index) + + # Train model + model.train( + lgb_params={'learning_rate': 0.1}, + num_iterations=100, + train_data=train + ) + + # Generate forecasts and inspect the time-varying smoothing parameters + forecasts = model.forecast(test_data=test) + parameters = model.forecast(test_data=test, type="parameters") + ``` + """ + + def __init__( + self, + freq: str = "M", + fcst_h: int = 12, + loss_fn: Callable = nn.MSELoss(), + n_hessian_probes: int = 5, + ): + """ + Initialize the Hyper-Tree-TSB model. + + Arguments + ---------- + freq : str + Frequency of the time series (e.g., 'D' for daily, 'W' for weekly, + 'M' for monthly). + fcst_h : int + Forecast horizon (number of periods to forecast ahead). + loss_fn : Callable + Loss function for optimization. Must be a PyTorch loss function. + Default is MSE loss. Losses other than nn.MSELoss are not + recommended, as they have not been systematically tested yet. + nn.L1Loss is rejected (zero second derivative almost everywhere + breaks Newton boosting). + n_hessian_probes : int + Number of Hutchinson probes for Gauss-Newton Hessian diagonal estimation. + More probes reduce variance but increase computation. Default is 5. + """ + # Validate inputs + if fcst_h <= 0: + raise ValueError("Forecast horizon 'fcst_h' must be a positive integer.") + if not isinstance(loss_fn, nn.Module): + raise TypeError("loss_fn must be a PyTorch loss function.") + if isinstance(loss_fn, nn.L1Loss): + raise ValueError( + "nn.L1Loss is not supported: its second derivative is zero almost " + "everywhere, so LightGBM's Newton boosting receives all-zero Hessians " + "and cannot grow trees. Use nn.HuberLoss or nn.SmoothL1Loss for an " + "MAE-like loss with usable curvature." + ) + if not isinstance(loss_fn, nn.MSELoss): + warnings.warn( + f"Loss {type(loss_fn).__name__} is not nn.MSELoss. The Gauss-Newton " + "Hessian requires a twice-differentiable loss; non-smooth losses " + "(e.g., L1Loss, quantile loss, HuberLoss/SmoothL1Loss outside the quadratic " + "region) have zero or undefined second derivatives at kinks, " + "causing degenerate Hessians." + ) + if not isinstance(freq, str): + raise TypeError("freq must be a string representing the frequency of the time series.") + + self.freq = freq + self.n_params = 2 # alpha_p (probability), alpha_d (demand size) + self.fcst_h = fcst_h + self.loss_fn = loss_fn + self.loss_name = self.loss_fn.__class__.__name__ + self.dtype = torch.float32 + self.model = None + self.features = None # Stores feature names after training + self.is_trained = False # Flag to track if model has been trained + self.dataset_references = {} # Store references to LightGBM datasets + self.eps = 1e-6 # Small constant to prevent numerical issues in sigmoid + self.fcst_states = None # Store final TSB states for forecasting + self.n_hessian_probes = n_hessian_probes + self._iter_count = 0 # Iteration counter for seeding Hessian probes + + # Shared Gauss-Newton Hessian estimator + self._gn_hessian = GaussNewtonHessian(loss_fn, n_hessian_probes, self.dtype) + + # Conformal prediction interval state + self._is_calibrated = False + self._cs_scores = None + self._cs_series_order = None + self._pi_config = None + + # Activation function for parameter bounds + self.sigmoid_fn = nn.Sigmoid() + + def _create_mask_from_data(self, data: pd.DataFrame) -> torch.Tensor: + """ + Create a mask for valid observations from the data. + + Parameters + ---------- + data : pd.DataFrame + DataFrame containing the time series data + + Returns + ------- + torch.Tensor + Mask indicating valid observations (1 = valid, 0 = padding). + """ + if 'mask' in data.columns: + mask = torch.tensor( + data['mask'].values.reshape(self.n_series, -1), + dtype=self.dtype + ) + else: + data_shape = data.shape[0] + mask = torch.ones((data_shape, 1), dtype=self.dtype).reshape(self.n_series, -1) + + return mask + + def _init_states( + self, + target: torch.Tensor, + mask: torch.Tensor, + ) -> Tuple[torch.Tensor, torch.Tensor]: + """Initial probability and demand-size states. + + Follows statsforecast's TSB: the probability state starts at the first + (valid) occurrence indicator and the size state at the first (valid) + nonzero demand. All-zero series get a size state of 0 and therefore + forecast 0. The initialization depends only on the data, never on the + boosted parameters. + + Parameters + ---------- + target : torch.Tensor + Observations, shape ``(n_series, T)``. + mask : torch.Tensor + Validity mask (1 = real observation, 0 = padding), + shape ``(n_series, T)``. + + Returns + ------- + Tuple[torch.Tensor, torch.Tensor] + Initial probability ``p_0`` and size ``z_0``, each ``(n_series,)``. + """ + occurrence = ((target != 0) & (mask > 0)).to(self.dtype) + + # p_0: occurrence indicator at the first valid observation + first_valid = torch.argmax((mask > 0).to(torch.long), dim=1) + p0 = occurrence.gather(1, first_valid.unsqueeze(1)).squeeze(1) + + # z_0: first valid nonzero demand (0 if the series is all zeros) + has_demand = occurrence.any(dim=1) + first_demand = torch.argmax(occurrence.to(torch.long), dim=1) + z0 = target.gather(1, first_demand.unsqueeze(1)).squeeze(1) + z0 = torch.where(has_demand, z0, torch.zeros_like(z0)) + + return p0, z0 + + def objective_fn(self, predt: np.ndarray, data: lgb.Dataset) -> Tuple[np.ndarray, np.ndarray]: + """ + Custom objective function for LightGBM training. + + This function defines the gradients and hessians for the LightGBM model + based on the PyTorch loss function. It converts LightGBM outputs to + PyTorch tensors, computes the TSB forward pass, and then backpropagates + to get gradients. + + Parameters + ---------- + predt : np.ndarray + Outputs from LightGBM, representing the TSB smoothing parameters. + data : lgb.Dataset + LightGBM dataset containing the target values. + + Returns + ------- + Tuple[np.ndarray, np.ndarray] + Gradients and hessians for LightGBM optimization. + """ + self._iter_count += 1 + + target = torch.tensor( + data.get_label().reshape(self.n_series, -1), + dtype=self.dtype + ) + + params, loss = self.get_params_loss(predt, target, data, requires_grad=True) + grad, hess = self.calculate_gradients_and_hessians(loss, params) + + return grad, hess + + def eval_fn(self, predt: np.ndarray, eval_data: lgb.Dataset) -> Tuple[str, float, bool]: + """ + Custom evaluation function for evaluating forecast accuracy on an evaluation dataset. + + This function computes the loss value to be monitored during evaluation. + + Parameters + ---------- + predt : np.ndarray + Outputs of LightGBM Model. + eval_data : lgb.Dataset + LightGBM dataset containing the evaluation data. + + Returns + ------- + Tuple[str, float, bool] + Name of the metric, value of the metric, and whether to maximize it. + """ + is_higher_better = False # Lower loss is better, so we don't maximize + target = torch.tensor( + eval_data.get_label().reshape(self.n_series, -1), + dtype=self.dtype + ) + _, loss = self.get_params_loss(predt, target, eval_data) + + return self.loss_name, loss.item(), is_higher_better + + def get_params_loss( + self, + predt: np.ndarray, + target: torch.Tensor, + data: lgb.Dataset = None, + requires_grad: bool = False + ) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Transform LightGBM outputs into TSB parameters and calculate loss. + + This function: + 1. Reshapes the raw outputs into TSB parameters + 2. Applies sigmoid transformation to ensure parameter bounds + 3. Runs the TSB forward pass to compute fitted values + 4. Calculates the loss between fitted values and actual values + + Parameters + ---------- + predt : np.ndarray + Outputs of LightGBM Model. + target : torch.Tensor + Target values (actual time series values). + data : lgb.Dataset + LightGBM dataset containing additional information. + requires_grad : bool + Whether to compute gradients (True during training). + + Returns + ------- + Tuple[torch.Tensor, torch.Tensor] + Parameters tensor and loss value. + """ + # Gradients must be w.r.t. raw (pre-sigmoid) outputs + # differentiating w.r.t. post-sigmoid params would miss the sigmoid(predt) factor + predt = nn.Parameter( + torch.tensor( + predt.reshape(-1, self.n_params, order="F"), + dtype=self.dtype + ), + requires_grad=requires_grad + ) + + # Apply sigmoid transformation and reshape for TSB computation; clamp to avoid numerical issues + params = torch.clamp( + self.sigmoid_fn(predt.reshape(self.n_series, -1, self.n_params)), + min=self.eps, + max=1-self.eps + ) + + # Get mask + if "mask" in data.data.columns: + mask = torch.tensor( + data.data["mask"].values.reshape(self.n_series, -1), + dtype=self.dtype + ) + else: + series_len = target.shape[1] + mask = torch.ones((self.n_series, series_len), dtype=self.dtype) + + # Forward pass to compute fitted values + _, _, fit = self.forward(params, target, mask) + + # Stack fitted values and compute loss with masking + fit = torch.stack(fit, dim=1) + loss = self.loss_fn(fit * mask, target * mask) + + # Store for Gauss-Newton Hessian estimation + self._fit = fit + self._mask = mask + self._target = target + + return predt, loss + + def forward( + self, + params: torch.Tensor, + target: torch.Tensor, + mask: torch.Tensor, + ) -> Tuple[torch.Tensor, torch.Tensor, List[torch.Tensor]]: + """ + Forward pass for the TSB recursion. + + This implements the TSB updates: + - Probability: p_t = p_{t-1} + α_p(d_t - p_{t-1}), updated every period + - Size: z_t = z_{t-1} + α_d(y_t - z_{t-1}) if demand occurs, else unchanged + - Fitted: ŷ_t = p_{t-1} * z_{t-1} + + The occurrence indicator ``d_t`` is data (constant w.r.t. the + parameters), so the size-update gating does not break differentiability. + + Parameters + ---------- + params : torch.Tensor + Sigmoid-transformed TSB parameters, shape ``(n_series, T, n_params)``. + target : torch.Tensor + Observations, shape ``(n_series, T)``. + mask : torch.Tensor + Validity mask (1 = real observation, 0 = padding), shape ``(n_series, T)``. + + Returns + ------- + Tuple[torch.Tensor, torch.Tensor, List[torch.Tensor]] + Final probability state (n_series,), final size state (n_series,), + and list of fitted values. + """ + series_len = target.shape[1] + + # Unpack and pre-unbind parameters + alpha_p, alpha_d = params.unbind(dim=2) + alpha_p_t = alpha_p.unbind(dim=1) + alpha_d_t = alpha_d.unbind(dim=1) + + # Occurrence indicators (data, constant w.r.t. the parameters) + occurrence = ((target != 0) & (mask > 0)).to(self.dtype) + + # Initialize states from the data + p_prev, z_prev = self._init_states(target, mask) + fits = [target[:, 0]] + + # Pre-unbind the data tensors so the loop indexes Python tuples + # instead of slicing tensors at every step. + target_t = target.unbind(dim=1) + mask_t = mask.unbind(dim=1) + occurrence_t = occurrence.unbind(dim=1) + + # TSB updates with masking for padded values. + for t in range(1, series_len): + valid_mask = mask_t[t] + invalid_mask = 1 - valid_mask + y_t = target_t[t] + d_t = occurrence_t[t] + + fit_t = valid_mask * (p_prev * z_prev) + invalid_mask * fits[-1] + + p_new = valid_mask * ( + p_prev + alpha_p_t[t] * (d_t - p_prev) + ) + invalid_mask * p_prev + + z_new = valid_mask * ( + d_t * (z_prev + alpha_d_t[t] * (y_t - z_prev)) + + (1 - d_t) * z_prev + ) + invalid_mask * z_prev + + fits.append(fit_t) + p_prev = p_new + z_prev = z_new + + return p_prev, z_prev, fits + + def calculate_gradients_and_hessians(self, loss: torch.Tensor, params: torch.Tensor) -> Tuple[ + np.ndarray, np.ndarray]: + """ + Compute gradients and Generalized Gauss-Newton Hessians for LightGBM. + + Uses exact first-order gradients and the Generalized Gauss-Newton (GGN) + approximation for the Hessian diagonal, estimated via Hutchinson probing. + As for ``HyperTreeETS``, the TSB recurrence makes exact second + derivatives propagate through the full recursion, so the + residual-curvature term is dropped, retaining only H_GN = J^T B J, + which guarantees positive semi-definite Hessians. + + Parameters + ---------- + loss : torch.Tensor + Loss value from the model. + params : torch.Tensor + Model parameters (pre-sigmoid LightGBM outputs, nn.Parameter). + + Returns + ------- + Tuple[np.ndarray, np.ndarray] + Gradients and hessians as numpy arrays in the format expected by LightGBM. + """ + grad = autograd(loss, params, retain_graph=True)[0] + + fit_masked = self._fit * self._mask + target_masked = self._target * self._mask + rng = torch.Generator().manual_seed(self._iter_count) + hess = self._gn_hessian.estimate(fit_masked, target_masked, params, rng) + + # Release graph references to prevent accumulation between iterations + self._fit = None + self._mask = None + self._target = None + + # Convert to numpy arrays and reshape as expected by LightGBM + grad = grad.cpu().detach().numpy().ravel(order="F") + hess = hess.cpu().detach().numpy().ravel(order="F") + + return grad, hess + + def train( + self, + lgb_params: dict = None, + num_iterations: int = 100, + train_data: pd.DataFrame = None, + validation: bool = False, + early_stopping_round: Optional[int] = None, + seed: int = 123, + verbose: int = -1, + deterministic: bool = True, + forecast_intervals: Optional[ForecastIntervals] = None, + ) -> TrainingResult: + """ + Train the Hyper-Tree-TSB model on time series data. + + This method: + 1. Preprocesses the time series data to create features and handle variable lengths + 2. Sets up LightGBM datasets with proper masking + 3. Trains the model using gradient boosting + 4. Stores final TSB states for future forecasting + + The training data must contain columns: + - 'series_id': Identifier for each time series + - 'date': Timestamp for each observation + - 'value': Target value to forecast + - Additional feature columns used for forecasting + + Parameters + ---------- + lgb_params : dict + LightGBM parameters like 'learning_rate', 'num_leaves', etc. + num_iterations : int + Number of boosting rounds for training + train_data : pd.DataFrame + Training data containing series_id, date, value and feature columns. All series must have the same length. + The data should be preprocessed to ensure that all series are of the same length and padded with 1 + in the 'mask' column for valid observations. Padded values should have a mask value of 0. + validation : bool + If True, a validation set will be created for evaluation. + early_stopping_round : int, optional + If provided, training will stop if the validation loss does not improve for this many rounds. + seed : int + Random seed for reproducibility + verbose : int + Verbosity level for LightGBM training + deterministic : bool + If True, sets LightGBM's ``deterministic`` and ``force_row_wise`` parameters to ensure + reproducible results. May slow down training. See + https://lightgbm.readthedocs.io/en/latest/Parameters.html#deterministic + forecast_intervals : ForecastIntervals, optional + If provided, calibrate conformal prediction intervals via rolling-window + cross-validation after the main model is trained. The collected conformity + scores are then used by ``forecast(..., level=[...])`` to produce + ``-lo-`` / ``-hi-`` columns. See + :class:`hypertrees.conformal.ForecastIntervals`. + + Returns + ------- + TrainingResult + Object containing evaluation results and training information. + """ + # Validate inputs + if train_data is None: + raise ValueError("train_data must be provided.") + if lgb_params is None: + raise ValueError("lgb_params must be provided.") + if not isinstance(train_data, pd.DataFrame): + raise TypeError("train_data must be a pandas DataFrame.") + if not isinstance(lgb_params, dict): + raise TypeError("lgb_params must be a dictionary.") + if not isinstance(num_iterations, int) or num_iterations <= 0: + raise ValueError("num_iterations must be a positive integer.") + if not isinstance(seed, int): + raise TypeError("seed must be an integer.") + if not isinstance(verbose, int): + raise TypeError("verbose must be an integer.") + if early_stopping_round is not None and ( + not isinstance(early_stopping_round, int) or early_stopping_round <= 0): + raise ValueError("early_stopping_round must be a positive integer.") + if not isinstance(validation, bool): + raise TypeError("validation must be a boolean.") + if not isinstance(deterministic, bool): + raise TypeError("deterministic must be a boolean.") + if forecast_intervals is not None and not isinstance(forecast_intervals, ForecastIntervals): + raise TypeError("forecast_intervals must be a ForecastIntervals instance.") + if early_stopping_round is not None and not validation: + raise ValueError("early_stopping_round can only be used when validation is True.") + if validation and early_stopping_round is None: + raise ValueError("early_stopping_round must be provided when validation is True.") + + if deterministic: + lgb_params = {**lgb_params, "deterministic": True, "force_row_wise": True} + + # Check required columns first + required_columns = ['series_id', 'date', 'value'] + for col in required_columns: + if col not in train_data.columns: + raise ValueError(f"Required column '{col}' not found in training data.") + + # Validate row ordering: each series must be a contiguous block with + # monotonic dates so the TSB reshape to (n_series, T, n_params) aligns. + validate_series_order(train_data, name="train_data") + + if forecast_intervals is not None: + validate_calibration_length( + train_data, self.fcst_h, forecast_intervals, min_train=2, + ) + + # Check if all series in train_data have the same length + unique_lengths = train_data.groupby('series_id')['date'].nunique() + if len(unique_lengths.unique()) > 1: + raise ValueError("All series in train_data must have the same length. Found multiple lengths.") + + # General model parameters. The objective wrapper stops lgb.train's + # params deepcopy from cloning this instance (see NoDeepcopyObjective). + self.lgb_params = { + "num_class": self.n_params, + "objective": NoDeepcopyObjective(self.objective_fn), + "metric": "None", + "random_seed": seed, + "verbose": verbose + } + + # Reset states + self._iter_count = 0 + self._fit = None + self._mask = None + self._target = None + self.model = None + self.dataset_references = {} + self.is_trained = False + self.fcst_states = None + self.features = None + self._is_calibrated = False + self._cs_scores = None + self._cs_series_order = None + self._pi_config = None + + # Set random seeds for reproducibility + torch.manual_seed(seed) + np.random.seed(seed) + random.seed(seed) + + # Copy to avoid modifying the caller's DataFrame across repeated train() calls + train_data = train_data.copy() + + # Update with user-provided LightGBM parameters + self.lgb_params.update(lgb_params) + + try: + # Initialize TimeSeriesPreprocessor for TSB-specific preprocessing + preprocessor = TimeSeriesPreprocessor( + freq=self.freq, + lags=[], # TSB doesn't need lag features like AR models + ) + + # Process dataset, including masking for variable-length series + full_ts = preprocessor.create_lags(train_data) + full_dict = preprocessor.extract(full_ts) + + # Store feature names and dataset dimensions + self.features = full_dict["features"].columns.tolist() + self.n_series = len(train_data['series_id'].unique()) + + # Prepare datasets (adapted for TSB) + (valid_sets, + valid_names, + callbacks, + evals_result, + _, # No lags for TSB + _, # No lags for TSB + self.dataset_references) = ( + prepare_datasets( + full_ts=full_ts, + preprocessor=preprocessor, + fcst_h=self.fcst_h, + dtype=self.dtype, + validation=validation, + early_stopping_round=early_stopping_round, + free_raw_data=False, + ) + ) + + # Train LightGBM model + start_time = time.time() + self.model = lgb.train( + self.lgb_params, + valid_sets[0], + num_boost_round=num_iterations, + feval=self.eval_fn if validation else None, + valid_sets=valid_sets, + valid_names=valid_names, + callbacks=callbacks + ) + training_time = time.time() - start_time + + # Store final TSB states for forecasting + self._store_final_states(train_data) + + # Set trained flag to True + self.is_trained = True + + if forecast_intervals is not None: + def _model_factory(): + return HyperTreeTSB( + freq=self.freq, + fcst_h=self.fcst_h, + loss_fn=self.loss_fn, + n_hessian_probes=self.n_hessian_probes, + ) + + cal_train_kwargs = dict( + lgb_params=lgb_params, + num_iterations=num_iterations, + validation=False, + seed=seed, + verbose=verbose, + deterministic=deterministic, + ) + self._cs_scores, self._cs_series_order = rolling_origin_residuals( + model_factory=_model_factory, + train_data=train_data, + fcst_h=self.fcst_h, + forecast_intervals=forecast_intervals, + train_kwargs=cal_train_kwargs, + ) + self._pi_config = forecast_intervals + self._is_calibrated = True + + # Return results + result = TrainingResult( + train_metrics=evals_result["train"] if validation else {"loss": []}, + validation_metrics=evals_result["validation"] if validation else None, + best_iteration=self.model.best_iteration-1 if hasattr(self.model, 'best_iteration') else num_iterations, + training_time=training_time + ) + + return result + + except Exception as e: + self.is_trained = False + raise RuntimeError(f"Training failed: {str(e)}") from e + + def _store_final_states(self, train_data: pd.DataFrame): + """ + Store final TSB states after training for use in forecasting. + + Runs a full forward pass on the training data to obtain the final + probability and size states per series. Also stores the series + ordering to ensure consistent state access. + + Parameters + ---------- + train_data : pd.DataFrame + Training data used to compute final TSB states. + """ + # Store series ordering from training data + self.series_order = train_data['series_id'].unique().tolist() + + # Get fitted parameters for the full training period + params = torch.clamp( + self.sigmoid_fn(torch.tensor(self.model.predict(train_data[self.features]), dtype=self.dtype)), + min=self.eps, + max=1-self.eps + ).reshape(self.n_series, -1, self.n_params) + + # Create mask and target tensors + train_mask = self._create_mask_from_data(train_data) + target = torch.tensor( + train_data["value"].values.reshape(self.n_series, -1), + dtype=self.dtype + ) + + # Forward pass to get final states + last_p, last_z, fit = self.forward(params, target, train_mask) + + # Store final states as dictionary with series_id as keys + self.fcst_states = {} + for i, series_id in enumerate(self.series_order): + self.fcst_states[series_id] = { + 'last_p': last_p[i], + 'last_z': last_z[i], + } + + def set_forecast_origin(self, history: pd.DataFrame) -> None: + """Re-anchor TSB states to the end of *history* without retraining. + + Recomputes the terminal ``{probability, size}`` states by running the + full TSB forward recurrence over *history* using the already-trained + GBDT parameters. Used by conformal calibration with ``refit=False``. + + Parameters + ---------- + history : pd.DataFrame + DataFrame with the same columns as the training data (including + any ``mask`` column), ordered by ``(series_id, date)`` with each + series in a contiguous block and all series of equal length. + """ + self._store_final_states(history) + + def forecast( + self, + test_data: pd.DataFrame, + type: str = "forecast", + level: Optional[List[int]] = None, + ) -> pd.DataFrame: + """ + Generate forecasts using the trained model. + + Following the classical TSB method, the point forecast is flat over + the horizon: ŷ_{T+h} = p_T * z_T, where p_T and z_T are the final + probability and size states after the training period. Future demand + occurrence is unobserved, and the expected one-step-ahead forecast + propagates unchanged, so horizon features do not alter the point + forecasts (they do affect ``type="parameters"``). + + Parameters + ---------- + test_data : pd.DataFrame + Test data for which to generate forecasts. Must contain the same + feature columns used during training. + type : str + Type of forecast to generate. Options: + - "forecast": Generate forecasted values + - "parameters": Return the TSB smoothing parameters + level : list of int, optional + Confidence levels (in ``(0, 100)``, e.g. ``[80, 90]``) for conformal + prediction intervals. Only valid with ``type="forecast"`` and requires + the model to have been trained with ``forecast_intervals=...``. Adds + ``-lo-`` / ``-hi-`` columns to the output. + + Returns + ------- + pd.DataFrame + Forecasted data with columns: + - series_id: Identifier for each time series + - date: Forecast date/time + - fcst: Forecasted value (if type="forecast") + - model: Model name identifier + - alpha_p, alpha_d: TSB parameter values (if type="parameters") + - -lo- / -hi-: prediction interval bounds + (if type="forecast" and level is provided) + """ + # Check if model is trained and states are stored + if not self.is_trained or self.model is None: + raise RuntimeError("Model has not been trained. Call train() before forecasting.") + if self.fcst_states is None or self.series_order is None: + raise RuntimeError("Final states not found. This should not happen after training.") + + # Validate input data + required_cols = ['series_id', 'date'] + for col in required_cols: + if col not in test_data.columns: + raise ValueError(f"Required column '{col}' not found in test_data") + + # Validate row ordering: each series must be a contiguous block with + # monotonic dates so the forecast reshape aligns with stored states. + validate_series_order(test_data, name="test_data") + + # Validate that test_data series_ids match training series_ids + test_series_ids = set(test_data['series_id'].unique()) + train_series_ids = set(self.series_order) + if test_series_ids != train_series_ids: + missing_in_test = train_series_ids - test_series_ids + extra_in_test = test_series_ids - train_series_ids + error_msg = [] + if missing_in_test: + error_msg.append(f"Missing series in test_data: {missing_in_test}") + if extra_in_test: + error_msg.append(f"Extra series in test_data: {extra_in_test}") + raise ValueError(". ".join(error_msg)) + + # Validate rows per series matches forecast horizon (forecast only; + # parameters can be requested for arbitrary-length input). + if type == "forecast": + rows_per_series = test_data.groupby("series_id", sort=False).size() + bad = rows_per_series[rows_per_series != self.fcst_h] + if not bad.empty: + raise ValueError( + f"Each series must have exactly fcst_h={self.fcst_h} rows in test_data. " + f"Series with wrong counts: {bad.to_dict()}" + ) + + # Validate type parameter + if type not in ["forecast", "parameters"]: + raise ValueError("Parameter 'type' must be either 'forecast' or 'parameters'") + + if level is not None: + if type != "forecast": + raise ValueError("level is only supported with type='forecast'.") + if not self._is_calibrated: + raise RuntimeError( + "Prediction intervals were requested via level, but the model " + "was not calibrated. Pass forecast_intervals=ForecastIntervals(...) " + "to train() before forecasting with level." + ) + if not isinstance(level, (list, tuple)) or len(level) == 0: + raise ValueError("level must be a non-empty list of integers.") + for lv in level: + if not isinstance(lv, (int, np.integer)) or not 0 < lv < 100: + raise ValueError(f"level values must be integers in (0, 100); got {lv}.") + + try: + # If mask was a training feature but is absent from test_data, add it (all test obs are valid) + if 'mask' in self.features and 'mask' not in test_data.columns: + test_data = test_data.copy() + test_data['mask'] = np.ones_like(test_data['series_id'], dtype=np.int32) + + # Check that all features used during training exist in test_data + missing_features = [f for f in self.features if f not in test_data.columns] + if missing_features: + raise ValueError(f"Missing features in test_data: {missing_features}") + + model_name = "Hyper-Tree-TSB" + + if type == "forecast": + # Extract stored final states in the correct order of the test data series + test_series_ids = test_data['series_id'].unique() + last_p = torch.stack([self.fcst_states[series_id]['last_p'] for series_id in test_series_ids]) + last_z = torch.stack([self.fcst_states[series_id]['last_z'] for series_id in test_series_ids]) + + # Classical TSB: flat forecast p_T * z_T over the horizon + point = (last_p * last_z).reshape(-1, 1).repeat(1, self.fcst_h) + + # Create output dataframe + out_df = pd.DataFrame({ + "series_id": test_data["series_id"].to_numpy().flatten(), + "date": test_data["date"].to_numpy().flatten(), + "fcst": point.flatten().numpy(), + "model": model_name, + }) + + if level is not None: + columns = interval_columns( + point=point.numpy(), + scores=self._cs_scores, + levels=level, + method=self._pi_config.method, + model_name=model_name, + cal_order=self._cs_series_order, + target_order=list(test_series_ids), + ) + for col_name, values in columns.items(): + out_df[col_name] = values + + elif type == "parameters": + fcst_params = torch.clamp( + self.sigmoid_fn(torch.tensor(self.model.predict(test_data[self.features]), dtype=self.dtype) + ), + min=self.eps, + max=1-self.eps + ).reshape(self.n_series, -1, self.n_params) + out_df = pd.DataFrame({ + "series_id": test_data["series_id"].to_numpy().flatten(), + "date": test_data["date"].to_numpy().flatten(), + "model": model_name, + }) + for i, param_name in enumerate(["alpha_p", "alpha_d"]): + out_df[param_name] = fcst_params[:, :, i].flatten().numpy() + + return out_df + + except Exception as e: + raise RuntimeError(f"Forecasting not successful: {str(e)}") from e diff --git a/hypertrees/models/HyperTreeVAR.py b/hypertrees/models/HyperTreeVAR.py new file mode 100644 index 0000000..c30bfa3 --- /dev/null +++ b/hypertrees/models/HyperTreeVAR.py @@ -0,0 +1,597 @@ +import warnings + +import numpy as np +import pandas as pd +import torch +import torch.nn as nn +from torch.autograd import grad as autograd +import lightgbm as lgb +from typing import Callable, Optional, Tuple + +from ..utils import TrainingResult, GaussNewtonHessian +from ..conformal import ForecastIntervals +from ._var_base import _HyperTreeVARBase + + +class HyperTreeVAR(_HyperTreeVARBase): + """ + Class that implements a Hyper-Tree-VAR(p) model for multivariate time series forecasting. + + The Hyper-Tree-VAR(p) model extends the Hyper-Tree-AR(p) model to a vector + autoregression over an aligned panel of k series, learning the full + time-varying coefficient matrices A_1(x), ..., A_p(x) with gradient boosted + trees so that y_{i,t} = sum_j A_j[i, :](x_{i,t}) . y_{t-j}. Cross-series + dependence is captured by the off-diagonal coefficients of the lag matrices + (see ``_var_base.py`` for the formulation, data requirements, coefficient + ordering, and the restricted ``type="factor"`` design). + + Key features: + - Combines tree-based models (LightGBM) with vector autoregressive modeling + - Learns the time-varying lag matrices A_1, ..., A_p as functions of + features (full k x k, or own + factor lags with type="factor") + - Captures cross-series (Granger-causal) lead/lag dependencies via the + off-diagonal coefficients + - Provides VAR coefficients that can vary over time + + Use this model when: + - Your series influence each other and forecasts should exploit + cross-series lead/lag structure + - The panel is small (k * p up to a few dozen coefficients) and + coefficient-level interpretability (including SHAP values per + coefficient) is desired + - For larger panels, use HyperTreeNetVAR, whose boosting cost is + independent of the number of coefficients + + Example usage: + ```python + # Imports + from hypertrees.models.HyperTreeVAR import HyperTreeVAR + import numpy as np + import pandas as pd + import matplotlib.pyplot as plt + + # Initialize model + lag_p = 4 + frequency = 'M' + fcst_h = 12 + model = HyperTreeVAR(p=lag_p, freq=frequency, fcst_h=fcst_h) + + # Data + # The data needs to be an aligned panel (equal lengths and identical dates + # across series) with the columns: 'date', 'series_id', 'value'. All other + # columns are automatically treated as features. You don't have to add + # lag-values yourself, this happens automatically during training. + rng = np.random.RandomState(1) + dates = pd.date_range("2010-01-01", periods=120 + fcst_h, freq="MS") + df = pd.concat( + [ + pd.DataFrame({ + "series_id": f"s{i}", + "date": dates, + "value": base + np.cumsum(rng.randn(len(dates))), + "month": dates.month, + "quarter": dates.quarter, + "series_num": i, # identifies the series, so equations can differ + }) + for i, base in enumerate([100.0, 150.0]) + ], + ignore_index=True, + ) + test = df.groupby("series_id", sort=False).tail(fcst_h) + train = df.drop(test.index) + + # Train model + model.train( + lgb_params={'learning_rate': 0.1}, + num_iterations=100, + train_data=train + ) + + # Generate forecasts and inspect the time-varying VAR coefficients + forecasts = model.forecast(test_data=test) + coefficients = model.forecast(test_data=test, type="parameters") + + # Plot results + for sid, group in df.groupby("series_id", sort=False): + plt.plot(group["date"], group["value"], label=f"Actual {sid}", + color='#2E86AB', linewidth=2, alpha=0.8) + for sid, group in forecasts.groupby("series_id", sort=False): + plt.plot(group["date"], group["fcst"], label=f"Forecast {sid}", + color='#F18F01', linestyle='--', linewidth=2, alpha=0.8) + + plt.title('Aligned Panel - VAR Forecasts', fontsize=14) + plt.legend(frameon=True, fancybox=True) + plt.grid(True, alpha=0.3) + plt.tight_layout() + ``` + """ + + _model_label = "Hyper-Tree-VAR" + _valid_forecast_types = ("forecast", "parameters") + + def __init__( + self, + p: int = 2, + freq: str = "M", + fcst_h: int = 1, + loss_fn: Callable = nn.MSELoss(), + scaling: Optional[str] = "mean", + type: str = "full", + hessian_method: str = "analytic", + n_hessian_probes: int = 5, + ): + """ + Initialize the Hyper-Tree-VAR(p) model. + + Arguments + ---------- + p : int + VAR lag order. Must be a positive integer. + freq : str + Frequency of the time series (e.g., 'D' for daily, 'M' for monthly, + 'Q' for quarterly, 'Y' for yearly). + fcst_h : int + Forecast horizon (number of periods to forecast ahead). + loss_fn : Callable + Loss function for optimization. Must be a PyTorch loss function. + Default is MSE loss. Losses other than nn.MSELoss are not + recommended, as they have not been systematically tested yet. + nn.L1Loss is rejected (zero second derivative almost everywhere + breaks Newton boosting). + scaling : str, optional + Per-series scaling applied internally before training; forecasts + (and prediction intervals) are transformed back to the original + scale automatically. Options: "mean" (default; divide by the + mean absolute training value), "standard" (z-score), or None. + Strongly recommended for heterogeneous panels: VAR coefficients + multiply *other* series' values, so unscaled panels force the + model to learn scale conversions while the loss is dominated by + the largest series. Coefficients returned by + ``forecast(type="parameters")`` live in the scaled space. + type : str + Structure of the VAR design vector. Options: + - "full" (default): unrestricted VAR; every equation regresses on + the lags of all k series (``k * p`` coefficients per equation, + one boosted tree each). + - "factor": restricted GVAR-style design; every equation + regresses on its own lags plus the lags of the equal-weighted + cross-sectional average of the scaled panel (``2 * p`` + coefficients per equation, independent of k). Recommended for + larger panels, where the unrestricted design overparameterizes. + Parameter columns are named ``A{j}(own)`` / ``A{j}(factor)`` + and the model name becomes ``Hyper-Tree-FactorVAR(p)``. + hessian_method : str + Method for computing the Hessian diagonal. Options: + - "exact": Exact diagonal Hessian via per-coefficient second-order + autograd (one backward pass per coefficient, i.e. k * p per + iteration -- costly for larger panels). + - "analytic" (default): Closed-form gradients and exact diagonal + Hessians, exploiting that the VAR fit is linear in its + parameters (dL/dA_q = l'(y_hat) * z_q and + d2L/dA_q2 = l''(y_hat) * z_q**2, the second-order fit term + vanishing exactly). Produces the same values as "exact" for any + loss that is a mean/sum of per-observation terms -- which covers + all standard PyTorch regression losses -- at a fraction of the + cost: at most one small double-backward through + loss(fit, target) instead of one backward per coefficient. + nn.MSELoss uses a fully closed-form fast path with no autograd + at all. + - "gn": Gauss-Newton approximation estimated via Hutchinson + probing. Guarantees positive semi-definite Hessians. Because + the VAR fit is linear in its parameters, this estimates the + same diagonal as "analytic", with Hutchinson sampling variance. + n_hessian_probes : int + Number of Hutchinson probes for Gauss-Newton Hessian diagonal estimation. + Only used when hessian_method="gn". More probes reduce variance but + increase computation. Default is 5. + """ + super().__init__( + p=p, + freq=freq, + fcst_h=fcst_h, + loss_fn=loss_fn, + scaling=scaling, + type=type, + ) + if hessian_method not in ("exact", "analytic", "gn"): + raise ValueError("hessian_method must be one of 'exact', 'analytic', or 'gn'.") + if not isinstance(n_hessian_probes, int) or n_hessian_probes <= 0: + raise ValueError("n_hessian_probes must be a positive integer.") + if hessian_method == "gn" and not isinstance(loss_fn, nn.MSELoss): + warnings.warn( + f"Loss {loss_fn.__class__.__name__} is not nn.MSELoss. The Gauss-Newton " + "Hessian requires a twice-differentiable loss; non-smooth losses " + "(e.g., L1Loss, quantile loss, HuberLoss/SmoothL1Loss outside the quadratic " + "region) have zero or undefined second derivatives at kinks, " + "causing degenerate Hessians." + ) + + self.hessian_method = hessian_method + self.n_hessian_probes = n_hessian_probes + self._fit = None + self._target = None + self._lags = None + + # Bind Hessian computation strategy + if hessian_method == "exact": + self.calculate_gradients_and_hessians = self._calculate_gradients_and_hessians_exact + elif hessian_method == "analytic": + self.calculate_gradients_and_hessians = self._calculate_gradients_and_hessians_analytic + else: + self._gn_hessian = GaussNewtonHessian(loss_fn, n_hessian_probes, self.dtype) + self.calculate_gradients_and_hessians = self._calculate_gradients_and_hessians_gn + + def objective_fn(self, predt: np.ndarray, data: lgb.Dataset) -> Tuple[np.ndarray, np.ndarray]: + """ + Custom objective function for LightGBM training. + + This function defines the gradients and hessians for the LightGBM model + based on the PyTorch loss function. It converts the raw LightGBM outputs + to VAR coefficients, computes the loss, and then derives gradients and + Hessians via the bound ``hessian_method`` strategy. + + Parameters + ---------- + predt : np.ndarray + Raw outputs from LightGBM, representing the VAR coefficients per + training row. + data : lgb.Dataset + LightGBM dataset containing the target values. + + Returns + ------- + Tuple[np.ndarray, np.ndarray] + Gradients and hessians for LightGBM optimization. + """ + self._iter_count += 1 + + target = torch.tensor( + data.get_label().reshape(self.k, -1), dtype=self.dtype + ) + params, loss = self.get_params_loss(predt, target, self._Z_train, requires_grad=True) + if not torch.isfinite(loss): + raise RuntimeError( + f"Training diverged at boosting iteration {self._iter_count}: the loss " + "is no longer finite. With one boosted tree per VAR coefficient, " + "strongly correlated series make the per-coefficient Newton steps " + "overshoot: reduce learning_rate (a rule of thumb is eta / k) and " + "keep per-series scaling enabled." + ) + grad, hess = self.calculate_gradients_and_hessians(loss, params) + + return grad, hess + + def get_params_loss( + self, + predt: np.ndarray, + target: torch.Tensor, + Z: torch.Tensor, + requires_grad: bool = False, + ) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Transform LightGBM outputs into VAR coefficients and calculate loss. + + This function: + 1. Reshapes the raw outputs into the coefficient matrix + 2. Computes the fitted values via the VAR forward pass + 3. Calculates the loss between fitted and actual values + + Parameters + ---------- + predt : np.ndarray + Raw outputs from LightGBM (flattened Fortran-order). + target : torch.Tensor + Target values (actual time series values), shape ``(k, T_r)``. + Z : torch.Tensor + VAR design matrix, shape ``(T_r, k * p)`` for the full design or + ``(k * T_r, 2 * p)`` for the factor design. + requires_grad : bool + Whether to compute gradients (True during training). + + Returns + ------- + Tuple[torch.Tensor, torch.Tensor] + Parameters tensor and loss value. + """ + params = nn.Parameter( + torch.tensor( + predt.reshape(-1, self.n_params, order="F"), + dtype=self.dtype + ), + requires_grad=requires_grad + ) + + fit = self._compute_fit(params, Z) + loss = self.loss_fn(fit, target) + + if self.hessian_method in ("gn", "analytic"): + self._fit = fit + self._target = target + self._lags = Z + + return params, loss + + def _calculate_gradients_and_hessians_exact(self, loss: torch.Tensor, params: torch.Tensor) -> Tuple[np.ndarray, np.ndarray]: + """Exact diagonal Hessian via per-coefficient second-order autograd. + + One backward pass per VAR coefficient (k * p per iteration); identical + values to "analytic" for any per-observation loss, at much higher cost. + + Parameters + ---------- + loss : torch.Tensor + Loss value from the model. + params : torch.Tensor + Model parameters (VAR coefficients as an ``nn.Parameter``, + shape ``(k * T_r, n_params)``). + + Returns + ------- + Tuple[np.ndarray, np.ndarray] + Gradients and hessians as numpy arrays in the format expected by LightGBM. + """ + loss.backward(create_graph=True) + grad = params.grad + hess = [ + autograd(grad[:, i].sum(), params, retain_graph=True)[0][:, i:(i + 1)] + for i in range(self.n_params) + ] + + grad = grad.cpu().detach().numpy().ravel(order="F") + hess = torch.cat(hess, dim=1).cpu().detach().numpy().ravel(order="F") + params.grad = None + + return grad, hess + + def _calculate_gradients_and_hessians_analytic(self, loss: torch.Tensor, params: torch.Tensor) -> Tuple[np.ndarray, np.ndarray]: + """Closed-form gradients and exact diagonal Hessians via model linearity. + + Since the VAR fit is linear in its parameters, ``grad = l'(y_hat) * z`` + and ``hess = l''(y_hat) * z**2``, matching the "exact" method for any + per-observation loss. MSELoss uses closed-form derivatives; other + losses use one small double-backward through ``loss(fit, target)``. + + Parameters + ---------- + loss : torch.Tensor + Loss value from the model (unused; derivatives come from the + fit/target/design stored by ``get_params_loss``). + params : torch.Tensor + Model parameters (unused, kept for a uniform dispatch signature). + + Returns + ------- + Tuple[np.ndarray, np.ndarray] + Gradients and hessians as numpy arrays in the format expected by LightGBM. + """ + fit = self._fit.detach() + target = self._target + Z = self._lags + + if isinstance(self.loss_fn, nn.MSELoss) and self.loss_fn.reduction in ("mean", "sum"): + # MSE fast path: l' = scale * (y_hat - y), l'' = scale + scale = 2.0 / fit.numel() if self.loss_fn.reduction == "mean" else 2.0 + g = scale * (fit - target) + h = torch.full_like(fit, scale) + else: + # Generic path: per-element first and second loss derivatives via + # a double-backward through the (tiny) loss(fit, target) graph. + # Requires the loss to have a well-defined double-backward (true + # for HuberLoss/SmoothL1Loss and other standard smooth losses). + fit_leaf = fit.requires_grad_(True) + loss_local = self.loss_fn(fit_leaf, target) + g = autograd(loss_local, fit_leaf, create_graph=True)[0] + h = autograd(g.sum(), fit_leaf)[0].detach() + g = g.detach() + + # Broadcast the per-observation loss derivatives over the design + # matrix (shared per time step for the full design, per row for the + # factor design), then Fortran-ravel as expected by LightGBM. + if self.type == "factor": + grad = g.reshape(-1, 1) * Z + hess = h.reshape(-1, 1) * Z ** 2 + else: + grad = (g.unsqueeze(2) * Z.unsqueeze(0)).reshape(-1, self.n_params) + hess = (h.unsqueeze(2) * Z.unsqueeze(0) ** 2).reshape(-1, self.n_params) + grad = grad.cpu().numpy().ravel(order="F") + hess = hess.cpu().numpy().ravel(order="F") + + self._fit = None + self._target = None + self._lags = None + + return grad, hess + + def _calculate_gradients_and_hessians_gn(self, loss: torch.Tensor, params: torch.Tensor) -> Tuple[np.ndarray, np.ndarray]: + """Gauss-Newton Hessian diagonal estimated via Hutchinson probing. + + Parameters + ---------- + loss : torch.Tensor + Loss value from the model. + params : torch.Tensor + Model parameters (VAR coefficients as an ``nn.Parameter``, + shape ``(k * T_r, n_params)``). + + Returns + ------- + Tuple[np.ndarray, np.ndarray] + Gradients and hessians as numpy arrays in the format expected by LightGBM. + """ + grad = autograd(loss, params, retain_graph=True)[0] + rng = torch.Generator().manual_seed(self._iter_count) + hess = self._gn_hessian.estimate(self._fit, self._target, params, rng) + self._fit = None + self._target = None + self._lags = None + grad = grad.cpu().detach().numpy().ravel(order="F") + hess = hess.cpu().detach().numpy().ravel(order="F") + + return grad, hess + + def _fit_from_predt(self, predt: np.ndarray, Z: torch.Tensor) -> torch.Tensor: + """Compute the fitted values for raw LightGBM coefficient outputs. + + Parameters + ---------- + predt : np.ndarray + Raw outputs from LightGBM (flattened Fortran-order). + Z : torch.Tensor + Design matrix for the dataset being evaluated, shape + ``(T_r, k * p)`` for the full design or ``(k * T_r, 2 * p)`` for + the factor design. + + Returns + ------- + torch.Tensor + Fitted values, shape ``(k, T_r)``. + """ + params = torch.tensor( + predt.reshape(-1, self.n_params, order="F"), dtype=self.dtype + ) + + return self._compute_fit(params, Z) + + def _num_class(self) -> int: + """LightGBM output dimension: one tree per VAR coefficient.""" + + return self.n_params + + def _reset_training_state(self) -> None: + """Reset per-training state, including the Hessian-strategy buffers.""" + super()._reset_training_state() + self._fit = None + self._target = None + self._lags = None + + def _post_datasets_setup(self, seed: int) -> None: + """Warn when the one-vs-all strategy becomes the runtime bottleneck.""" + if self.type == "full" and self.n_params > 50: + warnings.warn( + f"HyperTreeVAR grows num_class = k * p = {self.n_params} trees per " + f"boosting iteration, which scales linearly in runtime. For panels " + f"of this size consider HyperTreeNetVAR (GBDT cost independent of " + f"the number of coefficients) or type='factor' (2 * p " + f"coefficients per equation, independent of k)." + ) + + def train( + self, + lgb_params: dict = None, + num_iterations: int = 100, + train_data: pd.DataFrame = None, + validation: bool = False, + early_stopping_round: Optional[int] = None, + seed: int = 123, + verbose: int = -1, + deterministic: bool = True, + forecast_intervals: Optional[ForecastIntervals] = None, + ) -> TrainingResult: + """ + Train the Hyper-Tree-VAR model on an aligned panel of time series. + + This method: + 1. Pivots the panel and builds the VAR design matrix + 2. Sets up LightGBM datasets (one row per series and time step) + 3. Trains the model using gradient boosting + + The training data must contain columns: + - 'series_id': Identifier for each time series + - 'date': Timestamp for each observation + - 'value': Target value to forecast + - Additional feature columns used for forecasting + + All series must have the same length and identical dates (aligned + panel); see ``_var_base.py``. + + Parameters + ---------- + lgb_params : dict + LightGBM parameters like 'learning_rate', 'num_leaves', etc. + num_iterations : int + Number of boosting rounds for training. Note that each round grows + one tree per coefficient (``k * p`` for type="full", ``2 * p`` for + type="factor"). + train_data : pd.DataFrame + Training data containing series_id, date, value and feature columns + validation : bool + If True, a validation set will be created for evaluation. It splits + the last fcst_h time steps of each series for validation. + early_stopping_round : int, optional + If provided, training will stop if the validation loss does not + improve for this many rounds. + seed : int + Random seed for reproducibility + verbose : int + Verbosity level for LightGBM training + deterministic : bool + If True, sets LightGBM's ``deterministic`` and ``force_row_wise`` + parameters to ensure reproducible results. May slow down training. + See https://lightgbm.readthedocs.io/en/latest/Parameters.html#deterministic + forecast_intervals : ForecastIntervals, optional + If provided, calibrate conformal prediction intervals via + rolling-window cross-validation after the main model is trained. + The collected conformity scores are then used by + ``forecast(..., level=[...])`` to produce ``-lo-`` / + ``-hi-`` columns. See + :class:`hypertrees.conformal.ForecastIntervals`. + + Returns + ------- + TrainingResult + Object containing evaluation results and training information. + """ + def _model_factory(): + return HyperTreeVAR( + p=self.p, + freq=self.freq, + fcst_h=self.fcst_h, + loss_fn=self.loss_fn, + scaling=self.scaling, + type=self.type, + hessian_method=self.hessian_method, + n_hessian_probes=self.n_hessian_probes, + ) + + cal_train_kwargs = dict( + lgb_params=lgb_params, + num_iterations=num_iterations, + validation=False, + seed=seed, + verbose=verbose, + deterministic=deterministic, + ) + + return self._train_core( + lgb_params=lgb_params, + num_iterations=num_iterations, + train_data=train_data, + validation=validation, + early_stopping_round=early_stopping_round, + seed=seed, + verbose=verbose, + deterministic=deterministic, + forecast_intervals=forecast_intervals, + model_factory=_model_factory, + cal_train_kwargs=cal_train_kwargs, + ) + + def _forecast_params(self, features_df: pd.DataFrame) -> np.ndarray: + """Forecast the ``(n_rows, n_params)`` coefficient matrix from the GBDT. + + Parameters + ---------- + features_df : pd.DataFrame + Feature frame (training feature columns only). + + Returns + ------- + np.ndarray + VAR coefficients per row, shape ``(n_rows, n_params)``. + """ + params_fcst = np.asarray(self.model.predict(features_df)) + # Booster.predict returns (n_rows, n_params) for multi-class output + if params_fcst.ndim == 1: + params_fcst = params_fcst.reshape(-1, self.n_params) + + return params_fcst diff --git a/hypertrees/models/__init__.py b/hypertrees/models/__init__.py index e70251c..63434e2 100644 --- a/hypertrees/models/__init__.py +++ b/hypertrees/models/__init__.py @@ -4,3 +4,6 @@ from .HyperTreeETS import HyperTreeETS from .HyperTreeNetAR import HyperTreeNetAR from .HyperTreeSTL import HyperTreeSTL +from .HyperTreeVAR import HyperTreeVAR +from .HyperTreeNetVAR import HyperTreeNetVAR +from .HyperTreeTSB import HyperTreeTSB diff --git a/hypertrees/models/_var_base.py b/hypertrees/models/_var_base.py new file mode 100644 index 0000000..f7cf3d8 --- /dev/null +++ b/hypertrees/models/_var_base.py @@ -0,0 +1,1136 @@ +"""Shared base for the Hyper-Tree VAR models (``HyperTreeVAR`` / ``HyperTreeNetVAR``). + +The Hyper-Tree VAR models extend the univariate AR variants to a +multivariate VAR(p) target model. For a panel of ``k`` aligned series: + + y_{i,t} = sum_{j=1..p} sum_{m=1..k} A_j[i, m](x_{i,t}) * y_{m,t-j} + +i.e. every series' forecast is a feature-dependent linear combination of the +lagged values of *all* series. Cross-series dependence in the conditional +mean is carried entirely by the off-diagonal elements of the lag matrices +A_j (Granger-causal lead/lag effects). A multivariate innovation +distribution (e.g. the multivariate Gaussian used by GluonTS' DeepVAR) only +models the *contemporaneous covariance of the residuals*; it does not enter +the conditional mean and is therefore not needed for point forecasts. +Because all k equations share the same regressors, minimizing a +per-observation loss equation-by-equation is equivalent to the joint +(GLS/SUR) estimate in the classical linear case (Zellner, 1962), so nothing +is lost by training with the standard element-wise losses used across the +Hyper-Tree models. Conformal prediction intervals are supported exactly as +for the other models (per-series, per-horizon-step marginal intervals). + +The two concrete models live in their own modules, mirroring the repo's +one-class-per-file convention: + +- ``HyperTreeVAR`` (``HyperTreeVAR.py``): one boosted tree per VAR + coefficient, closed-form analytic gradients/Hessians. For small panels; + fully interpretable. +- ``HyperTreeNetVAR`` (``HyperTreeNetVAR.py``): GBDT encoder + MLP decoder + (Hyper-TreeNet architecture); boosting cost independent of the number of + coefficients, for larger panels. + +Both accept a ``type`` argument: ``"full"`` (default; unrestricted, +``k * p`` coefficients per equation) or ``"factor"``, a restricted VAR in +the spirit of the Global VAR (GVAR) literature [1, 2], where every equation +regresses on its **own lags** plus the lags of the equal-weighted +cross-sectional average of the scaled panel (the GVAR "star variable"), +i.e. ``2 * p`` coefficients per equation independent of k -- the principled +remedy for the overparameterization of unrestricted VARs on larger panels. + +Data requirements +----------------- +- Standard Hyper-Tree layout: columns ``series_id``, ``date``, ``value``, + sorted by ``(series_id, date)`` with each series in a contiguous block. +- The panel must be *aligned*: every series must have the same length and + identical dates, because each equation's design vector stacks the lags of + all series at the same time points. +- Because the GBDT learns a single global mapping from features to + coefficient vectors, the equations can only differ if some feature + identifies the series. As with the other global Hyper-Tree models, + include a series-identity feature (e.g. an integer-coded series id) + in the feature set -- ideally with pandas ``category`` dtype, so + LightGBM applies true categorical splits (an integer-coded identity + treated as numeric can only separate series by intervals of an + arbitrary coding). +- Series scales matter more than for the univariate AR models: VAR + coefficients multiply *other* series' values, so on an unscaled + heterogeneous panel the model must learn scale conversions between every + pair of series while the loss is dominated by the largest series. + Per-series scaling is therefore built in (``scaling="mean"`` by default) + and forecasts are transformed back to the original scale automatically. + +Coefficient ordering +-------------------- +For the full design, the flat coefficient vector of length ``k * p`` +produced per row is ordered lag-major: position ``(j - 1) * k + m`` is the +coefficient on lag ``j`` of the ``m``-th series (series in training +first-appearance order), matching the statsmodels VAR design-vector +convention ``z_t = [y'_{t-1}, y'_{t-2}, ..., y'_{t-p}]'``. For the factor +design, the own-lag block (j = 1..p) comes first, then the factor-lag block. + +References +---------- +[1] Pesaran, M. H., Schuermann, T., & Weiner, S. M. (2004). Modeling + Regional Interdependencies Using a Global Error-Correcting + Macroeconometric Model. Journal of Business & Economic Statistics, + 22(2), 129-162. (Global VAR; the "star variable" construction) +[2] Chudik, A., & Pesaran, M. H. (2016). Theory and Practice of GVAR + Modelling. Journal of Economic Surveys, 30(1), 165-197. +[3] Bernanke, B. S., Boivin, J., & Eliasz, P. (2005). Measuring the + Effects of Monetary Policy: A Factor-Augmented Vector Autoregressive + (FAVAR) Approach. The Quarterly Journal of Economics, 120(1), 387-422. +""" + +import time +import warnings +from typing import Callable, Dict, List, Optional, Tuple + +import numpy as np +import pandas as pd +import torch +import torch.nn as nn +import lightgbm as lgb + +from ..utils import CustomLogger +lgb.register_logger(CustomLogger()) + +from ..utils import TrainingResult, validate_series_order, NoDeepcopyObjective +from ..conformal import ( + ForecastIntervals, + validate_calibration_length, + rolling_origin_residuals, + interval_columns, +) + +# Columns that are never features. +_RESERVED_COLUMNS = ("series_id", "date", "value") + + +def _pivot_panel(data: pd.DataFrame, name: str) -> Tuple[np.ndarray, List, np.ndarray]: + """Pivot an aligned long panel into a ``(T, k)`` value matrix. + + Validates that all series have the same length and identical dates + (required so that the VAR design vector ``z_t`` exists for every row). + + Parameters + ---------- + data : pd.DataFrame + Long-format panel with ``series_id``, ``date``, ``value`` columns, + sorted by ``(series_id, date)`` with contiguous series blocks. + name : str + Label used in error messages. + + Returns + ------- + Tuple[np.ndarray, List, np.ndarray] + Value matrix ``Y`` of shape ``(T, k)`` with columns in + first-appearance series order, the series order, and the shared + date vector of length ``T``. + """ + lengths = data.groupby("series_id", sort=False).size() + if lengths.nunique() != 1: + raise ValueError( + f"{name}: a VAR model requires an aligned panel where all series have " + f"the same length. Found lengths: {lengths.to_dict()}." + ) + T = int(lengths.iloc[0]) + series_order = list(dict.fromkeys(data["series_id"].tolist())) + k = len(series_order) + + dates = pd.to_datetime(data["date"]).to_numpy().reshape(k, T) + if k > 1 and not (dates == dates[0]).all(): + raise ValueError( + f"{name}: all series must share identical dates (aligned panel). " + f"The VAR design vector stacks the lags of all series at the same " + f"time points, which requires aligned observations." + ) + + Y = data["value"].to_numpy(dtype=np.float64).reshape(k, T).T # (T, k) + + return Y, series_order, dates[0] + + +def _validate_aligned_dates(data: pd.DataFrame, name: str) -> None: + """Validate equal lengths and identical dates across series. + + Same alignment check as :func:`_pivot_panel` but without requiring a + ``value`` column, so it can be applied to forecast inputs. + + Parameters + ---------- + data : pd.DataFrame + Long-format panel with ``series_id`` and ``date`` columns, sorted by + ``(series_id, date)`` with contiguous series blocks. + name : str + Label used in error messages. + + Raises + ------ + ValueError + If series lengths differ or dates are not identical across series. + """ + lengths = data.groupby("series_id", sort=False).size() + if lengths.nunique() != 1: + raise ValueError( + f"{name}: all series must have the same number of rows. " + f"Found lengths: {lengths.to_dict()}." + ) + T = int(lengths.iloc[0]) + k = lengths.size + dates = pd.to_datetime(data["date"]).to_numpy().reshape(k, T) + if k > 1 and not (dates == dates[0]).all(): + raise ValueError(f"{name}: all series must share identical dates (aligned panel).") + + +def _build_var_lags(Y: np.ndarray, p: int) -> np.ndarray: + """Build the VAR design matrix ``Z`` from the value matrix ``Y``. + + Parameters + ---------- + Y : np.ndarray + Value matrix of shape ``(T, k)``. + p : int + VAR lag order. + + Returns + ------- + np.ndarray + Design matrix of shape ``(T - p, k * p)`` where row ``r`` + corresponds to time ``t = r + p`` and holds + ``[y'_{t-1}, y'_{t-2}, ..., y'_{t-p}]`` (lag-major ordering). + """ + T = Y.shape[0] + + return np.concatenate([Y[p - j: T - j] for j in range(1, p + 1)], axis=1) + + +class _HyperTreeVARBase: + """Shared plumbing for the Hyper-Tree VAR variants. + + Handles panel validation/pivoting, design-matrix construction, dataset + preparation, the training loop, the evaluation function, the multi-step + forecast recursion, conformal interval wiring, and forecast-origin + re-anchoring. Subclasses provide the LightGBM objective + (``objective_fn``), the fitted values for a raw prediction vector + (``_fit_from_predt``), the feature -> coefficient-matrix mapping + (``_forecast_params``), and the LightGBM output dimension + (``_num_class``). + """ + + _model_label = "Hyper-Tree-VAR" + _valid_forecast_types = ("forecast", "parameters") + + def __init__( + self, + p: int = 2, + freq: str = "M", + fcst_h: int = 1, + loss_fn: Callable = nn.MSELoss(), + scaling: Optional[str] = "mean", + type: str = "full", + ): + """ + Initialize the shared VAR state and validate the common arguments. + + Arguments + ---------- + p : int + VAR lag order. Must be a positive integer. + freq : str + Frequency of the time series (e.g., 'D' for daily, 'M' for monthly, + 'Q' for quarterly, 'Y' for yearly). + fcst_h : int + Forecast horizon (number of periods to forecast ahead). + loss_fn : Callable + Loss function for optimization. Must be a PyTorch loss function. + nn.L1Loss is rejected (zero second derivative almost everywhere + breaks Newton boosting). + scaling : str, optional + Per-series scaling applied internally before training; forecasts + (and prediction intervals) are transformed back to the original + scale automatically. Options: + - "mean" (default): divide each series by its mean absolute + training value. Location-free, so it introduces no implicit + intercept, and per-equation least squares is equivariant under + it (forecasts match manual pre-scaling exactly). + - "standard": z-score per series (subtract the training mean, + divide by the training standard deviation). + - None: use the series as provided. + Coefficients returned by ``forecast(type="parameters")`` live in + the scaled space. + type : str + Structure of the VAR design vector. Options: + - "full" (default): unrestricted VAR; every equation regresses on + the lags of *all* k series (``k * p`` coefficients per equation). + - "factor": restricted VAR in the spirit of the Global VAR (GVAR) + literature; every equation regresses on its **own lags** plus + the lags of the equal-weighted cross-sectional average of the + scaled panel (the GVAR "star variable"), i.e. ``2 * p`` + coefficients per equation, independent of k. The principled + remedy for the overparameterization of unrestricted VARs on + larger panels. + """ + if p <= 0: + raise ValueError("Parameter 'p' must be a positive integer.") + if fcst_h <= 0: + raise ValueError("Forecast horizon 'fcst_h' must be a positive integer.") + if not isinstance(freq, str): + raise TypeError("freq must be a string.") + if not isinstance(loss_fn, nn.Module): + raise TypeError("loss_fn must be a PyTorch loss function.") + if isinstance(loss_fn, nn.L1Loss): + raise ValueError( + "nn.L1Loss is not supported: its second derivative is zero almost " + "everywhere, so LightGBM's Newton boosting receives all-zero Hessians " + "and cannot grow trees. Use nn.HuberLoss or nn.SmoothL1Loss for an " + "MAE-like loss with usable curvature." + ) + if scaling not in (None, "mean", "standard"): + raise ValueError("scaling must be one of None, 'mean', or 'standard'.") + if type not in ("full", "factor"): + raise ValueError("type must be either 'full' or 'factor'.") + + self.p = p + self.freq = freq + self.fcst_h = fcst_h + self.loss_fn = loss_fn + self.loss_name = self.loss_fn.__class__.__name__ + self.scaling = scaling + self.type = type + self.dtype = torch.float32 + self.device = "cpu" + + self.model = None + self.features = None # Stores feature names after training + self.is_trained = False # Flag to track if model has been trained + self.dataset_references = {} # Store references to LightGBM datasets + self.k = None # Number of series (set during training) + self.n_params = None # k*p (full) or 2*p (factor), set during training + self.series_order_ = None # Training series order (axis/coefficient order) + self._Z_train = None # design tensor: (T_train, k*p) full, (N, 2*p) factor + self._Z_eval = None # design tensor for the validation split + self._fcst_state = None # lag state at the forecast origin + self._scale_loc = None # (k,) per-series location (training order) + self._scale_scale = None # (k,) per-series scale (training order) + self._iter_count = 0 + + # Conformal prediction interval state (populated when train() is + # called with forecast_intervals). + self._is_calibrated = False + self._cs_scores = None # conformity scores (n_windows, n_series, fcst_h) + self._cs_series_order = None # series order along axis 1 of _cs_scores + self._pi_config = None # ForecastIntervals configuration + + # ------------------------------------------------------------------ + # Subclass hooks + # ------------------------------------------------------------------ + def objective_fn(self, predt: np.ndarray, data: lgb.Dataset) -> Tuple[np.ndarray, np.ndarray]: + """Custom objective function for LightGBM training (subclass hook).""" + raise NotImplementedError + + def _fit_from_predt(self, predt: np.ndarray, Z: torch.Tensor) -> torch.Tensor: + """Compute the (gradient-free) fitted values for raw LightGBM outputs. + + Used by :meth:`eval_fn` to monitor the loss on the train/validation + datasets without building an autograd graph. + + Parameters + ---------- + predt : np.ndarray + Raw outputs from LightGBM (flattened Fortran-order). + Z : torch.Tensor + Design matrix for the dataset being evaluated, shape ``(T_r, k * p)``. + + Returns + ------- + torch.Tensor + Fitted values, shape ``(k, T_r)``. + """ + raise NotImplementedError + + def _forecast_params(self, features_df: pd.DataFrame) -> np.ndarray: + """Map a feature frame to the ``(n_rows, n_params)`` coefficient matrix.""" + raise NotImplementedError + + def _num_class(self) -> int: + """LightGBM output dimension; called after the datasets are built.""" + raise NotImplementedError + + def _post_datasets_setup(self, seed: int) -> None: + """Model-specific setup that requires the panel dimensions. + + Called by :meth:`_train_core` after ``_build_panel_datasets`` has set + ``self.k`` / ``self.n_params`` and before LightGBM training starts. + The default is a no-op. + + Parameters + ---------- + seed : int + Random seed forwarded from ``train()``. + """ + + def _forecast_tree_embeddings(self, test_data: pd.DataFrame, model_name: str) -> pd.DataFrame: + """Build the ``type="tree_embeddings"`` output (HyperTreeNetVAR only).""" + raise NotImplementedError + + # ------------------------------------------------------------------ + # Training plumbing + # ------------------------------------------------------------------ + def _validate_train_args( + self, lgb_params, num_iterations, train_data, validation, + early_stopping_round, seed, verbose, deterministic, forecast_intervals, + ) -> None: + """Common train() argument validation (mirrors the other models).""" + if train_data is None: + raise ValueError("train_data must be provided.") + if lgb_params is None: + raise ValueError("lgb_params must be provided.") + if not isinstance(train_data, pd.DataFrame): + raise TypeError("train_data must be a pandas DataFrame.") + if not isinstance(lgb_params, dict): + raise TypeError("lgb_params must be a dictionary.") + if not isinstance(num_iterations, int) or num_iterations <= 0: + raise ValueError("num_iterations must be a positive integer.") + if not isinstance(seed, int): + raise TypeError("seed must be an integer.") + if not isinstance(verbose, int): + raise TypeError("verbose must be an integer.") + if early_stopping_round is not None and ( + not isinstance(early_stopping_round, int) or early_stopping_round <= 0): + raise ValueError("early_stopping_round must be a positive integer.") + if not isinstance(validation, bool): + raise TypeError("validation must be a boolean.") + if not isinstance(deterministic, bool): + raise TypeError("deterministic must be a boolean.") + if forecast_intervals is not None and not isinstance(forecast_intervals, ForecastIntervals): + raise TypeError("forecast_intervals must be a ForecastIntervals instance.") + if early_stopping_round is not None and not validation: + raise ValueError("early_stopping_round can only be used when validation is True.") + if validation and early_stopping_round is None: + raise ValueError("early_stopping_round must be provided when validation is True.") + + required_columns = ["series_id", "date", "value"] + for col in required_columns: + if col not in train_data.columns: + raise ValueError(f"Required column '{col}' not found in training data.") + validate_series_order(train_data, name="train_data") + + def _reset_training_state(self) -> None: + """Reset per-training state so instances can be retrained safely.""" + self.model = None + self.dataset_references = {} + self.is_trained = False + self.features = None + self._iter_count = 0 + self._Z_train = None + self._Z_eval = None + self._fcst_state = None + self._scale_loc = None + self._scale_scale = None + self._is_calibrated = False + self._cs_scores = None + self._cs_series_order = None + self._pi_config = None + + def _fit_scaling(self, Y: np.ndarray) -> np.ndarray: + """Fit per-series scaling statistics on the training panel and transform it. + + Stores ``self._scale_loc`` / ``self._scale_scale`` (training series + order) and returns the scaled panel. With ``scaling=None`` the + statistics are identity, so downstream code can always apply + ``(Y - loc) / scale`` unconditionally. + + Parameters + ---------- + Y : np.ndarray + Raw value matrix, shape ``(T, k)``, columns in training series order. + + Returns + ------- + np.ndarray + Scaled value matrix, shape ``(T, k)``. + """ + k = Y.shape[1] + if self.scaling == "mean": + loc = np.zeros(k) + scale = np.abs(Y).mean(axis=0) + elif self.scaling == "standard": + loc = Y.mean(axis=0) + scale = Y.std(axis=0) + else: + loc = np.zeros(k) + scale = np.ones(k) + + self._scale_loc = loc + # Guard against constant / all-zero series. + self._scale_scale = np.where(scale > 1e-8, scale, 1.0) + + return (Y - self._scale_loc) / self._scale_scale + + def _build_panel_datasets( + self, + train_data: pd.DataFrame, + validation: bool, + early_stopping_round: Optional[int], + free_raw_data: bool = True, + ): + """Pivot the panel, build the VAR design matrix, and create lgb datasets. + + Sets ``self.k``, ``self.n_params``, ``self.series_order_``, + ``self.features``, ``self._Z_train`` / ``self._Z_eval`` and + ``self.dataset_references``. When ``validation`` is True, the last + ``fcst_h`` time steps of every series form the validation set. + + Parameters + ---------- + train_data : pd.DataFrame + Aligned panel of training data. + validation : bool + Whether to split off a validation set. + early_stopping_round : int, optional + Number of rounds for early stopping (validation only). + free_raw_data : bool + Whether to free raw data in the LightGBM datasets. + + Returns + ------- + Tuple[List[lgb.Dataset], List[str], Optional[List], Optional[dict]] + ``(valid_sets, valid_names, callbacks, evals_result)`` in the + layout expected by ``lgb.train``. + """ + Y, series_order, _ = _pivot_panel(train_data, name="train_data") + T, k = Y.shape + if k == 1: + warnings.warn( + "Only one series found. With k=1 the multivariate structure adds " + "nothing (and the factor equals the series itself); consider " + "HyperTreeAR instead." + ) + if T <= self.p: + raise ValueError( + f"Series length ({T}) must exceed the lag order p={self.p}; " + f"no training rows remain after lagging." + ) + + self.series_order_ = series_order + self.k = k + self.n_params = 2 * self.p if self.type == "factor" else k * self.p + + # Scale the panel; targets, design matrix, and the forecast recursion + # all live in the scaled space, forecasts are transformed back. + Y = self._fit_scaling(Y) + + if self.type == "factor": + # Per-series design blocks [own lags j=1..p, factor lags j=1..p], + # where the factor is the equal-weighted star variable of the + # scaled panel; row r of a block corresponds to time t = r + p. + factor = Y.mean(axis=1) + factor_lags = np.column_stack( + [factor[self.p - j: T - j] for j in range(1, self.p + 1)] + ) + designs = [ + np.concatenate( + [ + np.column_stack([Y[self.p - j: T - j, i] for j in range(1, self.p + 1)]), + factor_lags, + ], + axis=1, + ) + for i in range(k) + ] # k blocks of shape (T - p, 2p) + + def design_slice(lo, hi): + # Per-row design rows in dataset (series-major) order. + return np.concatenate([d[lo:hi] for d in designs], axis=0) + else: + Z = _build_var_lags(Y, self.p) # (T - p, k*p), row r <-> time t = r + p + + def design_slice(lo, hi): + # One shared design row per time step. + return Z[lo:hi] + + # Feature frame: drop the first p time steps of each series so feature + # rows align 1:1 with the design-matrix rows. + occ = train_data.groupby("series_id", sort=False).cumcount() + feats = train_data[occ >= self.p].reset_index(drop=True) + self.features = [c for c in feats.columns if c not in _RESERVED_COLUMNS] + + n_avail = T - self.p + if validation: + if n_avail <= self.fcst_h: + raise ValueError( + f"Validation requires more than fcst_h={self.fcst_h} usable time " + f"steps per series, but only {n_avail} remain after lagging." + ) + t_train = n_avail - self.fcst_h + else: + t_train = n_avail + + # Targets in dataset row order (series-major, time within series). + label_train = Y[self.p: self.p + t_train].T.ravel() + self._Z_train = torch.tensor( + design_slice(0, t_train), dtype=self.dtype, device=self.device + ) + + row_t = feats.groupby("series_id", sort=False).cumcount() + X_train = feats[row_t < t_train] + dtrain = lgb.Dataset( + data=X_train[self.features], + label=label_train, + free_raw_data=free_raw_data, + ) + + self.dataset_references = {id(dtrain): "train"} + + if validation: + label_eval = Y[self.p + t_train:].T.ravel() + self._Z_eval = torch.tensor( + design_slice(t_train, n_avail), dtype=self.dtype, device=self.device + ) + X_eval = feats[row_t >= t_train] + deval = lgb.Dataset( + data=X_eval[self.features], + label=label_eval, + free_raw_data=free_raw_data, + ) + self.dataset_references[id(deval)] = "validation" + + evals_result = {} + callbacks = [lgb.record_evaluation(evals_result)] + if early_stopping_round is not None: + callbacks.append( + lgb.early_stopping(stopping_rounds=early_stopping_round, verbose=False) + ) + + return [dtrain, deval], ["train", "validation"], callbacks, evals_result + + return [dtrain], ["train"], None, None + + def _compute_fit(self, params: torch.Tensor, Z: torch.Tensor) -> torch.Tensor: + """VAR forward pass: per-equation inner product with the design vector. + + Deliberately computed with element-wise ops (broadcast multiply + + sum) rather than ``torch.einsum``: einsum lowers to matmul kernels + that honor ``torch.set_float32_matmul_precision`` -- which the + experiments pipeline sets to ``"medium"`` -- and the reduced-precision + backward/double-backward through this op systematically destabilizes + HyperTreeNetVAR training (verified ~3x worse forecast errors across + seeds on the ausretail benchmark). Element-wise ops always run in + full float32, at the cost of materializing the ``(k, T_r, k * p)`` + product tensor. + + Parameters + ---------- + params : torch.Tensor + Coefficient matrix in dataset row order, shape ``(k * T_r, n_params)``. + Z : torch.Tensor + Design matrix: one shared row per time step ``(T_r, k * p)`` for + the full design, or one row per observation ``(k * T_r, 2 * p)`` + for the factor design. + + Returns + ------- + torch.Tensor + Fitted values, shape ``(k, T_r)``. + """ + if self.type == "factor": + return (params * Z).sum(dim=1).reshape(self.k, -1) + + P = params.reshape(self.k, -1, self.n_params) # (k, T_r, k*p) + + return (P * Z.unsqueeze(0)).sum(dim=2) + + def _train_core( + self, + lgb_params: dict, + num_iterations: int, + train_data: pd.DataFrame, + validation: bool, + early_stopping_round: Optional[int], + seed: int, + verbose: int, + deterministic: bool, + forecast_intervals: Optional[ForecastIntervals], + model_factory: Callable[[], object], + cal_train_kwargs: Dict, + ) -> TrainingResult: + """Shared training loop for both VAR variants. + + Validates the inputs, builds the panel datasets, runs the + model-specific post-dataset setup (:meth:`_post_datasets_setup`), + trains LightGBM with the subclass objective, and optionally + calibrates conformal prediction intervals. + + Parameters + ---------- + lgb_params, num_iterations, train_data, validation, + early_stopping_round, seed, verbose, deterministic, forecast_intervals + Forwarded verbatim from the public ``train()`` methods. + model_factory : Callable[[], object] + Zero-argument callable returning a fresh, untrained model with + this instance's constructor configuration. Used by the conformal + calibration to train per-window models. + cal_train_kwargs : dict + Keyword arguments forwarded to each calibration model's + ``train()`` call. + + Returns + ------- + TrainingResult + Object containing evaluation results and training information. + """ + self._validate_train_args( + lgb_params, num_iterations, train_data, validation, + early_stopping_round, seed, verbose, deterministic, forecast_intervals, + ) + + # Fail fast if any series is too short for the requested conformal + # calibration. A VAR(p) needs at least p + 1 rows to retain one + # training sample. + if forecast_intervals is not None: + validate_calibration_length( + train_data, self.fcst_h, forecast_intervals, min_train=self.p + 1 + ) + + if deterministic: + run_lgb_params = {**lgb_params, "deterministic": True, "force_row_wise": True} + else: + run_lgb_params = dict(lgb_params) + + self._reset_training_state() + + try: + valid_sets, valid_names, callbacks, evals_result = self._build_panel_datasets( + train_data, validation, early_stopping_round + ) + self._post_datasets_setup(seed) + + # General model parameters. The objective wrapper stops lgb.train's + # params deepcopy from cloning this instance (see NoDeepcopyObjective). + self.lgb_params = { + "num_class": self._num_class(), + "objective": NoDeepcopyObjective(self.objective_fn), + "metric": "None", + "random_seed": seed, + "verbose": verbose, + } + self.lgb_params.update(run_lgb_params) + + # Anchor the forecast lag state at the end of the training panel. + self.set_forecast_origin(train_data) + + start_time = time.time() + self.model = lgb.train( + self.lgb_params, + valid_sets[0], + num_boost_round=num_iterations, + feval=self.eval_fn if validation else None, + valid_sets=valid_sets, + valid_names=valid_names, + callbacks=callbacks, + ) + training_time = time.time() - start_time + self.is_trained = True + + # Calibrate conformal prediction intervals via rolling-window CV. + # Fresh model instances are trained per window (no forecast_intervals + # passed, so there is no recursion) using the same hyper-parameters. + if forecast_intervals is not None: + self._cs_scores, self._cs_series_order = rolling_origin_residuals( + model_factory=model_factory, + train_data=train_data, + fcst_h=self.fcst_h, + forecast_intervals=forecast_intervals, + train_kwargs=cal_train_kwargs, + ) + self._pi_config = forecast_intervals + self._is_calibrated = True + + return TrainingResult( + train_metrics=evals_result["train"] if validation else {"loss": []}, + validation_metrics=evals_result["validation"] if validation else None, + best_iteration=self.model.best_iteration - 1 + if hasattr(self.model, "best_iteration") else num_iterations, + training_time=training_time, + ) + + except Exception as e: + self.is_trained = False + raise RuntimeError(f"Training failed: {str(e)}") from e + + def eval_fn(self, predt: np.ndarray, eval_data: lgb.Dataset) -> Tuple[str, float, bool]: + """ + Custom evaluation function for evaluating forecast accuracy on an evaluation dataset. + + This function computes the loss value to be monitored during evaluation, + selecting the design matrix that matches the dataset being evaluated. + + Parameters + ---------- + predt : np.ndarray + Raw outputs from LightGBM. + eval_data : lgb.Dataset + LightGBM dataset containing the evaluation data. + + Returns + ------- + Tuple[str, float, bool] + Name of the metric, value of the metric, and whether to maximize it. + """ + # Use the appropriate design matrix based on dataset name + dataset_name = self.dataset_references.get(id(eval_data), "unknown") + if dataset_name == "validation": + Z = self._Z_eval + else: + # Default to the training design matrix if unknown + if dataset_name == "unknown": + warnings.warn("Unknown dataset in metric_fn. Using training design matrix.") + Z = self._Z_train + + is_higher_better = False # Lower loss is better, so we don't maximize + target = torch.tensor( + eval_data.get_label().reshape(self.k, -1), dtype=self.dtype, device=self.device + ) + fit = self._fit_from_predt(predt, Z) + loss = self.loss_fn(fit, target) + + return self.loss_name, loss.item(), is_higher_better + + # ------------------------------------------------------------------ + # Forecast plumbing + # ------------------------------------------------------------------ + def set_forecast_origin(self, history: pd.DataFrame) -> None: + """Re-anchor the VAR lag state to the end of *history* without retraining. + + Parameters + ---------- + history : pd.DataFrame + Aligned panel with ``series_id``, ``date``, ``value`` columns, + ordered by ``(series_id, date)`` with contiguous series blocks. + Must contain exactly the training series with at least ``p`` + observations each. + """ + if self.series_order_ is None: + raise RuntimeError("set_forecast_origin requires a trained model.") + validate_series_order(history, name="history") + Y, hist_order, _ = _pivot_panel(history, name="history") + if set(hist_order) != set(self.series_order_): + raise ValueError( + f"history must contain exactly the training series. " + f"Missing: {set(self.series_order_) - set(hist_order)}. " + f"Extra: {set(hist_order) - set(self.series_order_)}." + ) + if Y.shape[0] < self.p: + raise ValueError( + f"history must contain at least p={self.p} observations per series." + ) + # Reorder columns to the training series order. + idx = [hist_order.index(sid) for sid in self.series_order_] + Y = Y[:, idx] + # Scale with the training statistics so the lag state lives in the + # same (scaled) space as the learned coefficients. + Y = (Y - self._scale_loc) / self._scale_scale + if self.type == "factor": + # Own-lag state (k, p) and factor-lag state (p,), newest first. + factor = Y.mean(axis=1) + own_state = np.stack([Y[-j] for j in range(1, self.p + 1)], axis=1) + factor_state = np.array([factor[-j] for j in range(1, self.p + 1)]) + self._fcst_state = (own_state, factor_state) + else: + # Lag state z = [y'_{T-1}, y'_{T-2}, ..., y'_{T-p}] (lag-major). + self._fcst_state = np.concatenate([Y[-j] for j in range(1, self.p + 1)]) + + def _validate_forecast_args(self, test_data, type, level) -> None: + """Common forecast() validation. + + Parameters + ---------- + test_data : pd.DataFrame + Forecast input passed to ``forecast()``. + type : str + Requested output type. + level : list of int, optional + Requested conformal interval levels. + """ + if not self.is_trained or self.model is None: + raise RuntimeError("Model has not been trained. Call train() before forecasting.") + for col in ["series_id", "date"]: + if col not in test_data.columns: + raise ValueError(f"Required column '{col}' not found in test_data") + validate_series_order(test_data, name="test_data") + + # Validate series IDs match training data + test_series_ids = list(dict.fromkeys(test_data["series_id"].tolist())) + missing = set(test_series_ids) - set(self.series_order_) + extra = set(self.series_order_) - set(test_series_ids) + if missing or extra: + parts = [] + if missing: + parts.append(f"Missing series in training: {missing}") + if extra: + parts.append(f"Extra series not in test_data: {extra}") + raise ValueError( + ". ".join(parts) + ". A VAR forecast advances all series " + "jointly, so test_data must contain exactly the training series." + ) + + if type not in self._valid_forecast_types: + raise ValueError(f"Parameter 'type' must be one of {self._valid_forecast_types}.") + + if type == "forecast": + rows_per_series = test_data.groupby("series_id", sort=False).size() + bad = rows_per_series[rows_per_series != self.fcst_h] + if not bad.empty: + raise ValueError( + f"Each series must have exactly fcst_h={self.fcst_h} rows in test_data. " + f"Series with wrong counts: {bad.to_dict()}" + ) + _validate_aligned_dates(test_data, name="test_data") + + if level is not None: + if type != "forecast": + raise ValueError("level is only supported with type='forecast'.") + if not self._is_calibrated: + raise RuntimeError( + "Prediction intervals were requested via level, but the model " + "was not calibrated. Pass forecast_intervals=ForecastIntervals(...) " + "to train() before forecasting with level." + ) + if not isinstance(level, (list, tuple)) or len(level) == 0: + raise ValueError("level must be a non-empty list of integers.") + for lv in level: + if not isinstance(lv, (int, np.integer)) or not 0 < lv < 100: + raise ValueError(f"level values must be integers in (0, 100); got {lv}.") + + missing_features = [f for f in self.features if f not in test_data.columns] + if missing_features: + raise ValueError(f"Missing features in test_data: {missing_features}") + + def _model_name(self) -> str: + """Model name identifier, reflecting the design variant. + + Returns + ------- + str + ``"

U8X5~RPLDkFC;S|G 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