From 09300d98f783ac31434d256337c4050bf82fa138 Mon Sep 17 00:00:00 2001 From: madtoinou <32447896+madtoinou@users.noreply.github.com> Date: Sat, 11 Nov 2023 13:00:13 +0100 Subject: [PATCH] Feat/Example notebook for the regression models (#2039) * feat: example notebook for the regression models and new dataset (energy consumption and weather in Zurich, between 2015 and 2022) * fix: tests, some datasets width were missing * feat: udpated changelog * fix: to keep the API uniform, Zurich energy consumption and weather was split into two datasets. Energy consumption was added to the darts repo * fix: changed the way datasets are loaded, added an illustration for multi_models=True * fix: tweaked notebook * feat: grouped dataset and their width into a single variable to improve readibility * Apply suggestions from code review Co-authored-by: Dennis Bader * fix: simplified API to load the EnergyConsumptionZurich dataset, updated notebook accordingly * fix: remove the obsolete dataset from the tests * blabla * update dataset * update notebook p1 * update regression model notebook * notebook last fixes * fix: typo * add regression model example test to merge workflow --------- Co-authored-by: Dennis Bader --- .github/workflows/merge.yml | 2 +- CHANGELOG.md | 2 + darts/datasets/__init__.py | 111 +- darts/datasets/dataset_loaders.py | 18 +- darts/tests/datasets/test_dataset_loaders.py | 62 +- docs/source/examples.rst | 10 + examples/20-RegressionModel-examples.ipynb | 1100 +++++++++++++++++ examples/static/images/multi_model_ocl2.png | Bin 0 -> 56161 bytes .../static/images/regression_model_train.png | Bin 0 -> 39518 bytes examples/static/images/single_model_ocl2.png | Bin 0 -> 58563 bytes examples/static/images/single_model_ocl3.png | Bin 0 -> 49889 bytes 11 files changed, 1269 insertions(+), 36 deletions(-) create mode 100644 examples/20-RegressionModel-examples.ipynb create mode 100644 examples/static/images/multi_model_ocl2.png create mode 100644 examples/static/images/regression_model_train.png create mode 100644 examples/static/images/single_model_ocl2.png create mode 100644 examples/static/images/single_model_ocl3.png diff --git a/.github/workflows/merge.yml b/.github/workflows/merge.yml index 4f9571578a..d8b5ae732f 100644 --- a/.github/workflows/merge.yml +++ b/.github/workflows/merge.yml @@ -87,7 +87,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - example-name: [00-quickstart.ipynb, 01-multi-time-series-and-covariates.ipynb, 02-data-processing.ipynb, 03-FFT-examples.ipynb, 04-RNN-examples.ipynb, 05-TCN-examples.ipynb, 06-Transformer-examples.ipynb, 07-NBEATS-examples.ipynb, 08-DeepAR-examples.ipynb, 09-DeepTCN-examples.ipynb, 10-Kalman-filter-examples.ipynb, 11-GP-filter-examples.ipynb, 12-Dynamic-Time-Warping-example.ipynb, 13-TFT-examples.ipynb, 15-static-covariates.ipynb, 16-hierarchical-reconciliation.ipynb, 18-TiDE-examples.ipynb, 19-EnsembleModel-examples.ipynb] + example-name: [00-quickstart.ipynb, 01-multi-time-series-and-covariates.ipynb, 02-data-processing.ipynb, 03-FFT-examples.ipynb, 04-RNN-examples.ipynb, 05-TCN-examples.ipynb, 06-Transformer-examples.ipynb, 07-NBEATS-examples.ipynb, 08-DeepAR-examples.ipynb, 09-DeepTCN-examples.ipynb, 10-Kalman-filter-examples.ipynb, 11-GP-filter-examples.ipynb, 12-Dynamic-Time-Warping-example.ipynb, 13-TFT-examples.ipynb, 15-static-covariates.ipynb, 16-hierarchical-reconciliation.ipynb, 18-TiDE-examples.ipynb, 19-EnsembleModel-examples.ipynb, 20-RegressionModel-examples.ipynb] steps: - name: "1. Clone repository" uses: actions/checkout@v2 diff --git a/CHANGELOG.md b/CHANGELOG.md index 0fa67fd3de..0b823383f5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,11 +16,13 @@ but cannot always guarantee backwards compatibility. Changes that may **break co - Added callback `darts.utils.callbacks.TFMProgressBar` to customize at which model stages to display the progress bar. [#2020](https://github.com/unit8co/darts/pull/2020) by [Dennis Bader](https://github.com/dennisbader). - Improvements to documentation: - Adapted the example notebooks to properly apply data transformers and avoid look-ahead bias. [#2020](https://github.com/unit8co/darts/pull/2020) by [Samriddhi Singh](https://github.com/SimTheGreat). + - New example notebook for the `RegressionModels` explaining features such as (component-specific) lags, `output_chunk_length` in relation with `multi_models`, multivariate support, and more. [#2039](https://github.com/unit8co/darts/pull/2039) by [Antoine Madrona](https://github.com/madtoinou). - Improvements to Regression Models: - `XGBModel` now leverages XGBoost's native Quantile Regression support that was released in version 2.0.0 for improved probabilistic forecasts. [#2051](https://github.com/unit8co/darts/pull/2051) by [Dennis Bader](https://github.com/dennisbader). - Other improvements: - Added support for time index time zone conversion with parameter `tz` before generating/computing holidays and datetime attributes. Support was added to all Time Axis Encoders (standalone encoders and forecasting models' `add_encoders`, time series generation utils functions `holidays_timeseries()` and `datetime_attribute_timeseries()`, and `TimeSeries` methods `add_datetime_attribute()` and `add_holidays()`. [#2054](https://github.com/unit8co/darts/pull/2054) by [Dennis Bader](https://github.com/dennisbader). - Added optional keyword arguments dict `kwargs` to `ExponentialSmoothing` that will be passed to the constructor of the underlying `statsmodels.tsa.holtwinters.ExponentialSmoothing` model. [#2059](https://github.com/unit8co/darts/pull/2059) by [Antoine Madrona](https://github.com/madtoinou). + - Added new dataset `ElectricityConsumptionZurichDataset`: The dataset contains the electricity consumption of households in Zurich, Switzerland from 2015-2022 on different grid levels. We also added weather measurements for Zurich which can be used as covariates for modelling. [#2039](https://github.com/unit8co/darts/pull/2039) by [Antoine Madrona](https://github.com/madtoinou) and [Dennis Bader](https://github.com/dennisbader). **Fixed** - Fixed a bug when calling optimized `historical_forecasts()` for a `RegressionModel` trained with unequal component-specific lags. [#2040](https://github.com/unit8co/darts/pull/2040) by [Antoine Madrona](https://github.com/madtoinou). diff --git a/darts/datasets/__init__.py b/darts/datasets/__init__.py index c1c850c15a..ebb7f250cc 100644 --- a/darts/datasets/__init__.py +++ b/darts/datasets/__init__.py @@ -5,8 +5,9 @@ A few popular time series datasets """ +import os from pathlib import Path -from typing import List +from typing import List, Literal, Optional import numpy as np import pandas as pd @@ -813,3 +814,111 @@ def _to_multi_series(self, series: pd.DataFrame) -> List[TimeSeries]: Load the WeatherDataset dataset as a list of univariate timeseries, one for weather indicator. """ return [TimeSeries.from_series(series[label]) for label in series] + + +class ElectricityConsumptionZurichDataset(DatasetLoaderCSV): + """ + Electricity Consumption of households & SMEs (low voltage) and businesses & services (medium voltage) in the + city of Zurich [1]_, with values recorded every 15 minutes. + + The electricity consumption is combined with weather measurements recorded by three different + stations in the city of Zurich with a hourly frequency [2]_. The missing time stamps are filled with NaN. + The original weather data is recorded every hour. Before adding the features to the electricity consumption, + the data is resampled to 15 minutes frequency, and missing values are interpolated. + + To simplify the dataset, the measurements from the Zch_Schimmelstrasse and Zch_Rosengartenstrasse weather + stations are discarded to keep only the data recorded in the Zch_Stampfenbachstrasse station. + + Both dataset sources are updated continuously, but this dataset only retrains values between 2015 and 2022. + The time index was converted from CET time zone to UTC. + + Components Descriptions: + + * Value_NE5 : Households & SMEs electricity consumption (low voltage, grid level 7) in kWh + * Value_NE7 : Business and services electricity consumption (medium voltage, grid level 5) in kWh + * Hr [%Hr] : Relative humidity + * RainDur [min] : Duration of precipitation (divided by 4 for conversion from hourly to quarter-hourly records) + * T [°C] : Temperature + * WD [°] : Wind direction + * WVv [m/s] : Wind vector speed + * p [hPa] : Air pressure + * WVs [m/s] : Wind scalar speed + * StrGlo [W/m2] : Global solar irradiation + + Note: before 2018, the scalar speeds were calculated from the 30 minutes vector data. + + References + ---------- + .. [1] https://data.stadt-zuerich.ch/dataset/ewz_stromabgabe_netzebenen_stadt_zuerich + .. [2] https://data.stadt-zuerich.ch/dataset/ugz_meteodaten_stundenmittelwerte + """ + + def __init__(self): + def pre_process_dataset(dataset_path): + """Restrict the time axis and add the weather data""" + df = pd.read_csv(dataset_path, index_col=0) + # convert time index + df.index = ( + pd.DatetimeIndex(df.index, tz="CET").tz_convert("UTC").tz_localize(None) + ) + # extract pre-determined period + df = df.loc[ + (pd.Timestamp("2015-01-01") <= df.index) + & (df.index <= pd.Timestamp("2022-12-31")) + ] + # download and preprocess the weather information + df_weather = self._download_weather_data() + # add weather data as additional features + df = pd.concat([df, df_weather], axis=1) + # interpolate weather data + df = df.interpolate() + # raining duration is given in minutes -> we divide by 4 from hourly to quarter-hourly records + df["RainDur [min]"] = df["RainDur [min]"] / 4 + + # round Electricity cols to 4 decimals, other columns to 2 decimals + cols_precise = ["Value_NE5", "Value_NE7"] + df = df.round( + decimals={col: (4 if col in cols_precise else 2) for col in df.columns} + ) + + # export the dataset + df.index.name = "Timestamp" + df.to_csv(self._get_path_dataset()) + + # hash value for dataset with weather data + super().__init__( + metadata=DatasetLoaderMetadata( + "zurich_electricity_consumption.csv", + uri=( + "https://data.stadt-zuerich.ch/dataset/" + "ewz_stromabgabe_netzebenen_stadt_zuerich/" + "download/ewz_stromabgabe_netzebenen_stadt_zuerich.csv" + ), + hash="c2fea1a0974611ff1c276abcc1d34619", + header_time="Timestamp", + freq="15min", + pre_process_csv_fn=pre_process_dataset, + ) + ) + + @staticmethod + def _download_weather_data(): + """Concatenate the yearly csv files into a single dataframe and reshape it""" + # download the csv from the url + base_url = "https://data.stadt-zuerich.ch/dataset/ugz_meteodaten_stundenmittelwerte/download/" + filenames = [f"ugz_ogd_meteo_h1_{year}.csv" for year in range(2015, 2023)] + df = pd.concat([pd.read_csv(base_url + fname) for fname in filenames]) + # retain only one weather station + df = df.loc[df["Standort"] == "Zch_Stampfenbachstrasse"] + # pivot the df to get all measurements as columns + df["param_name"] = df["Parameter"] + " [" + df["Einheit"] + "]" + df = df.pivot(index="Datum", columns="param_name", values="Wert") + # convert time index to from CET to UTC and extract the required time range + df.index = ( + pd.DatetimeIndex(df.index, tz="CET").tz_convert("UTC").tz_localize(None) + ) + df = df.loc[ + (pd.Timestamp("2015-01-01") <= df.index) + & (df.index <= pd.Timestamp("2022-12-31")) + ] + return df diff --git a/darts/datasets/dataset_loaders.py b/darts/datasets/dataset_loaders.py index 19f2498d9d..01473bdfa6 100644 --- a/darts/datasets/dataset_loaders.py +++ b/darts/datasets/dataset_loaders.py @@ -31,8 +31,10 @@ class DatasetLoaderMetadata: format_time: Optional[str] = None # used to indicate the freq when we already know it freq: Optional[str] = None - # a custom function to handling non-csv based datasets + # a custom function handling non-csv based datasets pre_process_zipped_csv_fn: Optional[Callable] = None + # a custom function handling csv based datasets + pre_process_csv_fn: Optional[Callable] = None # multivariate multivariate: Optional[bool] = None @@ -49,7 +51,9 @@ class DatasetLoader(ABC): _DEFAULT_DIRECTORY = Path(os.path.join(Path.home(), Path(".darts/datasets/"))) - def __init__(self, metadata: DatasetLoaderMetadata, root_path: Path = None): + def __init__( + self, metadata: DatasetLoaderMetadata, root_path: Optional[Path] = None + ): self._metadata: DatasetLoaderMetadata = metadata if root_path is None: self._root_path: Path = DatasetLoader._DEFAULT_DIRECTORY @@ -131,7 +135,13 @@ def _download_dataset(self): "Could not download the dataset. Reason:" + e.__repr__() ) from None + if self._metadata.pre_process_csv_fn is not None: + self._metadata.pre_process_csv_fn(self._get_path_dataset()) + def _download_zip_dataset(self): + if self._metadata.pre_process_csv_fn: + logger.warning("Loading a ZIP file does not use the pre_process_csv_fn") + os.makedirs(self._root_path, exist_ok=True) try: request = requests.get(self._metadata.uri) @@ -186,7 +196,9 @@ def _format_time_column(self, df): class DatasetLoaderCSV(DatasetLoader): - def __init__(self, metadata: DatasetLoaderMetadata, root_path: Path = None): + def __init__( + self, metadata: DatasetLoaderMetadata, root_path: Optional[Path] = None + ): super().__init__(metadata, root_path) def _load_from_disk( diff --git a/darts/tests/datasets/test_dataset_loaders.py b/darts/tests/datasets/test_dataset_loaders.py index 8fd076b868..865331923b 100644 --- a/darts/tests/datasets/test_dataset_loaders.py +++ b/darts/tests/datasets/test_dataset_loaders.py @@ -10,6 +10,7 @@ AirPassengersDataset, AusBeerDataset, AustralianTourismDataset, + ElectricityConsumptionZurichDataset, ElectricityDataset, EnergyDataset, ETTh1Dataset, @@ -40,37 +41,36 @@ DatasetLoadingException, ) -datasets = [ - AirPassengersDataset, - AusBeerDataset, - AustralianTourismDataset, - EnergyDataset, - HeartRateDataset, - IceCreamHeaterDataset, - MonthlyMilkDataset, - SunspotsDataset, - TaylorDataset, - TemperatureDataset, - USGasolineDataset, - WineDataset, - WoolyDataset, - GasRateCO2Dataset, - MonthlyMilkIncompleteDataset, - ETTh1Dataset, - ETTh2Dataset, - ETTm1Dataset, - ETTm2Dataset, - ElectricityDataset, - UberTLCDataset, - ILINetDataset, - ExchangeRateDataset, - TrafficDataset, - WeatherDataset, -] - _DEFAULT_PATH_TEST = _DEFAULT_PATH + "/tests" -width_datasets = [1, 1, 96, 28, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 7, 7, 7, 7, 370, 262] +datasets_with_width = [ + (AirPassengersDataset, 1), + (AusBeerDataset, 1), + (AustralianTourismDataset, 96), + (EnergyDataset, 28), + (HeartRateDataset, 1), + (IceCreamHeaterDataset, 2), + (MonthlyMilkDataset, 1), + (SunspotsDataset, 1), + (TaylorDataset, 1), + (TemperatureDataset, 1), + (USGasolineDataset, 1), + (WineDataset, 1), + (WoolyDataset, 1), + (GasRateCO2Dataset, 2), + (MonthlyMilkIncompleteDataset, 1), + (ETTh1Dataset, 7), + (ETTh2Dataset, 7), + (ETTm1Dataset, 7), + (ETTm2Dataset, 7), + (ElectricityDataset, 370), + (UberTLCDataset, 262), + (ILINetDataset, 11), + (ExchangeRateDataset, 8), + (TrafficDataset, 862), + (WeatherDataset, 21), + (ElectricityConsumptionZurichDataset, 10), +] wrong_hash_dataset = DatasetLoaderCSV( metadata=DatasetLoaderMetadata( @@ -135,9 +135,9 @@ def tmp_dir_dataset(): class TestDatasetLoader: @pytest.mark.slow - @pytest.mark.parametrize("dataset_config", zip(width_datasets, datasets)) + @pytest.mark.parametrize("dataset_config", datasets_with_width) def test_ok_dataset(self, dataset_config, tmp_dir_dataset): - width, dataset_cls = dataset_config + dataset_cls, width = dataset_config dataset = dataset_cls() assert dataset._DEFAULT_DIRECTORY == tmp_dir_dataset ts: TimeSeries = dataset.load() diff --git a/docs/source/examples.rst b/docs/source/examples.rst index e7f9926a32..72b2557920 100644 --- a/docs/source/examples.rst +++ b/docs/source/examples.rst @@ -76,6 +76,16 @@ with Darts using the Optuna library for hyperparameter optimization. examples/17-hyperparameter-optimization.ipynb +Regression Models +================= + +Regression models example notebook: + +.. toctree:: + :maxdepth: 1 + + examples/20-RegressionModel-examples.ipynb + Fast Fourier Transform ====================== diff --git a/examples/20-RegressionModel-examples.ipynb b/examples/20-RegressionModel-examples.ipynb new file mode 100644 index 0000000000..a63b2514de --- /dev/null +++ b/examples/20-RegressionModel-examples.ipynb @@ -0,0 +1,1100 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "45bd6e88-1be9-4de1-9933-143eda71d501", + "metadata": {}, + "source": [ + "# Regression Models\n", + "\n", + "The following is a in depth demonstration of the regression models in Darts - from basic to advanced features, including:\n", + "\n", + "- Darts' regression models\n", + "- lags and lagged data extraction\n", + "- covariates usage\n", + "- parameters output_chunk_length in relation with multi_models\n", + "- one-shot and auto-regressive predictions\n", + "- multi output support\n", + "- probablistic forecasting\n", + "- explainability\n", + "- and more" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "3ef9bc25-7b86-4de5-80e9-6eff27025b44", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using `tqdm.autonotebook.tqdm` in notebook mode. Use `tqdm.tqdm` instead to force console mode (e.g. in jupyter console)\n" + ] + }, + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# fix python path if working locally\n", + "from utils import fix_pythonpath_if_working_locally\n", + "\n", + "fix_pythonpath_if_working_locally()\n", + "\n", + "# activate javascript\n", + "from shap import initjs\n", + "\n", + "initjs()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9d9d76e9-5753-4762-a1cb-c8c61d0313d2", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "%matplotlib inline\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from sklearn.linear_model import BayesianRidge\n", + "\n", + "from darts.models import (\n", + " LinearRegressionModel,\n", + " RegressionModel,\n", + " LightGBMModel,\n", + " XGBModel,\n", + " CatBoostModel,\n", + ")\n", + "from darts.metrics import mape\n", + "from darts.datasets import ElectricityConsumptionZurichDataset\n", + "from darts.explainability import ShapExplainer" + ] + }, + { + "cell_type": "markdown", + "id": "eacf6328-6b51-43e9-8b44-214f5df15684", + "metadata": {}, + "source": [ + "### Input Dataset\n", + "For this notebook, we use the Electricity Consumption Dataset from households in Zurich, Switzerland.\n", + "\n", + "The dataset has a quarter-hourly frequency (15 Min time intervals), but we resample it to hourly \n", + "frequency to keep things simple.\n", + "\n", + "**Target series** (the series we want to forecast):\n", + "- **Value_NE5**: Electricity consumption by households on grid level 5 (in kWh).\n", + "\n", + "**Covariates** (external data to help improve forecasts):\n", + "The dataset also comes with weather measurements that we can use as covariates. For simplicity, we use:\n", + "- **T [°C]**: Measured temperature\n", + "- **StrGlo [W/m2]**: Measured solar irradation\n", + "- **RainDur [min]**: Measured raining duration" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ea0d05f6-03cc-4422-afed-36acb2b94fa7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ts_energy = ElectricityConsumptionZurichDataset().load()\n", + "\n", + "# extract values recorded between 2017 and 2019\n", + "start_date = pd.Timestamp(\"2017-01-01\")\n", + "end_date = pd.Timestamp(\"2019-01-31\")\n", + "ts_energy = ts_energy[start_date:end_date]\n", + "\n", + "# resample to hourly frequency\n", + "ts_energy = ts_energy.resample(freq=\"H\")\n", + "\n", + "# extract temperature, solar irradiation and rain duration\n", + "ts_weather = ts_energy[[\"T [°C]\", \"StrGlo [W/m2]\", \"RainDur [min]\"]]\n", + "\n", + "# extract households energy consumption\n", + "ts_energy = ts_energy[\"Value_NE5\"]\n", + "\n", + "# create train and validation splits\n", + "validation_cutoff = pd.Timestamp(\"2018-10-31\")\n", + "ts_energy_train, ts_energy_val = ts_energy.split_after(validation_cutoff)\n", + "\n", + "ts_energy.plot()\n", + "plt.show()\n", + "\n", + "ts_weather.plot()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "9913460a-b4ee-4b66-8db4-b0e8ac189f77", + "metadata": {}, + "source": [ + "## Darts Regression Models\n", + "\n", + "Regression is a statistical method used in data science and machine learning to model the relationship between a dependent variable (target `y`) and one or more independent variables (features `X`).\n", + "\n", + "For convenience, the core Darts package ships with a couple of regression models:\n", + "- `LinearRegressionModel` and `RandomForest`: fully integrated sklearn models\n", + "- `RegressionModel`: wrap the Darts Model API around any sklearn-like model\n", + "- `XGBModel`: wrapper around [XGBoost's](https://xgboost.readthedocs.io/en/stable/python/python_api.html#xgboost.XGBRegressor) `XGBRegressor`\n", + "\n", + "In addition to these, we also offer a unified API for some state of the art regression models that can be installed following our [installation guide](https://github.com/unit8co/darts/blob/master/INSTALL.md):\n", + "\n", + "* `LightGBMModel`: wrapper around [LightGBM's](https://lightgbm.readthedocs.io/en/latest/pythonapi/lightgbm.LGBMRegressor.html#lightgbm-lgbmregressor) `LightGBMRegressor`\n", + "* `CatBoostModel`: wrapper around [CatBoost's](https://catboost.ai/en/docs/concepts/python-reference_catboostregressor) `CatBoostRegressor`.\n", + "\n", + "In Darts, the forecasting problem is translated into a regression problem by converting the time series into two tabular arrays:\n", + "- `X`: features or input array with the shape (number of samples/observations, number of features)\n", + " - The number of features is given by the total number of (feature specific) target, past, and future covariates lags.\n", + "- `y`: target or label array with the shape (number of samples/observations, number of targets)\n", + " - The number of targets is given by the model parameters `output_chunk_length` and `multi_models` (we'll explain this later on).\n", + "\n", + "### Target and covariates lags\n", + "\n", + "A lagged feature is the value of a feature at a previous or future time step compared to some reference point. \n", + "\n", + "In Darts, the value of the lag specifies the position of the feature value relative to the first predicted target time step `y_t0` for each observation/sample (a row in `X`).\n", + "\n", + "- `lag == 0`: position of the first predicted time step `t0`, e.g. position of `y_t0`\n", + "- `lag < 0`: all positions in the past of the first predicted time step `t-1`, `t-2`, ...\n", + "- `lag > 0`: all positions in the future of the first predicted time step `t+1`, `t+2`, ...\n", + "\n", + "The choice of lags is critical in achieving good predictive accuracy. We want the model to receive relevant information to capture the temporal properties/dependencies our target series (patterns, seasonalities, trends, ...). It also has a considerable impact on the model performance/complexity, as each additional lag adds a new feature to `X`.\n", + "\n", + "At model creation, we can set lags for the target and the covariates series separately.\n", + "\n", + "- `lags`: lags for the target series (the one we want to forecast)\n", + "- `lags_past_covariates`: optionally, lags for a past covariates series (external past-observed features to help improve forecasts)\n", + "- `lags_future_covariates`: optionally, lags for a future covariates series (external future-known features to help improve forecasts)\n", + "\n", + "There are multiple ways to define your lags `(int, List[int], Tuple[int, int], ...)`. You can find out more about this in the [RegressionModel docs](https://unit8co.github.io/darts/generated_api/darts.models.forecasting.regression_model.html#darts.models.forecasting.regression_model.RegressionModel).\n", + "\n", + "### Lagged data extraction\n", + "Now, let's have a look at how `X` and `y` is extracted for training using the scenario from below:\n", + "\n", + "- `lags=[-4,-3,-2,-1]`: use the last 4 target values (green) before the first predicted time step (orange) as `X` features.\n", + "- `output_chunk_length=1`: predict the target value `y` of next (`1`) time step (orange).\n", + "- we have a target series with 7 time steps `t_i, ..., t_i+6` (blue).\n", + "\n", + "*Note: This example only shows target `lags` extraction, but the same is applied to `lags_past/future_covariates`.*\n", + "\n", + "![forecast_single_model_ocl3](./static/images/regression_model_train.png)\n", + "\n", + "## Examples\n", + "Let's try to apply this to our electricity dataset. Assume, we want to predict the consumption of the next couple of hours after the end of our training set. \n", + "\n", + "As input features we give it the consumption at the same hour from one and two days ago -> `lags=[-24, -48]`." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6a3f3753-b7db-448c-942a-9db51390b1b9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = LinearRegressionModel(lags=[-24, -48])\n", + "model.fit(ts_energy_train)\n", + "pred = model.predict(12)\n", + "\n", + "ts_energy_train[-48:].plot(label=\"training\")\n", + "ts_energy_val[:12].plot(label=\"validation\")\n", + "pred.plot(label=\"forecast\")" + ] + }, + { + "cell_type": "markdown", + "id": "73f669b6-f14d-4a56-a9f2-069b4565d9d8", + "metadata": {}, + "source": [ + "### Covariates-based forecasting\n", + "\n", + "To use external data next to the history of our target series, we specify past and/or future covariates lags and then pass `past_covariates` and/or `future_covariates` to `fit()` and `predict()`.\n", + "\n", + "Let's assume that instead of having weather measurements, we actually have weather forecasts. Then we could use them as future_covariates. **We only do this here for demonstration purposes!**\n", + "\n", + "Below is an example that uses the last 24 hours (`24`) from hour target series (electricity consumption) and the values at the predicted time step (`[0]`) of our weather \"forecasts\"." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d46d7bff-4acb-4c98-8a79-42afe18b44d7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAHICAYAAABULQC7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAACXfklEQVR4nOzdd3xT9f7H8Ve6N6WFtlAKpewhQxBkC4hAEUFZKl4vKOJ1oHBFRK8oICIiqFwURaY/Lw5ARSpTRBmyBBGQvSmUWaClu03O74+YQwLdTXNyks/z8biPe5rRfHI8pO98p0FRFAUhhBBCCB3y0LoAIYQQQojSkiAjhBBCCN2SICOEEEII3ZIgI4QQQgjdkiAjhBBCCN2SICOEEEII3ZIgI4QQQgjdkiAjhBBCCN2SICOEEEII3ZIgUwiTycTJkycxmUxal1JseqwZpG5Hk7odS49167FmkLodzRnqliAjhBBCCN2SICOEEEII3ZIgI4QQQgjdkiAjhBBCCN2SICOEEEII3ZIgI4QQQgjdkiAjhBBCCN2SICOEEEII3ZIgI4QQQgjdkiAjhBBCCN2SICOEEEII3ZIgI4QQQgjdkiAjhBBCCN2SICOEEEII3ZIgI4QQZZCVlcVzzz3HkCFD2LZtm9blCOF2JMgIIUQZvPfee8yaNYvPP/+cNm3a0LVrV9avX4+iKFqXJoRbkCAjhBCllJ2dzccff2xz2/r16+natStt27blxx9/lEAjRDmTICOEEKX01VdfcfHiRQBatGhB7dq11fu2bdtG7969ad68OYsXL8ZoNGpVphAuTYKMEEKUgqIofPDBB+rPM2fO5ODBg3z55Zc0btxYvX3Pnj088sgjjBo1SlpnhCgHEmSEEKIUfvnlF/bu3QtA69atadOmDV5eXjzyyCPs2bOHZcuWcdddd6mP//HHH9m/f79W5QrhsiTICCFEKbz//vvq8ahRo2zu8/DwoE+fPmzfvp233npLvX3x4sUOq08IdyFBRgghSujw4cOsWLECgJiYGPr165fv4wwGA8OGDcNgMACwZMkS6V4Sws4kyAghRAnNmDFDPX7hhRfw8vIq8LFRUVF06tQJgCNHjrBnz55yr08IdyJBRgghSiA5OZmFCxcCEBgYyLBhw4p8zoABA9Rj6V4Swr5KHGTefvttunfvTqdOnRg0aBCbNm0CICEhgdatW9OhQwf1fxcuXFCft3//fh555BHatWvH8OHDOX/+vHpfVlYW48aNo2PHjvTq1YvVq1fbvGZCQgLx8fF06tSJCRMmkJubW9r3K4QQZfLZZ5+RmZkJwBNPPEFoaGiRz3nooYfw8DB/3H7zzTfSvSSEHZU4yAwePJiEhAQ2bNjAG2+8wbhx40hNTQWgVatWbNq0Sf1fVFQUADk5OYwZM4aHH36Y9evX07hxY9544w31d86ePZuUlBRWrlzJ5MmTmTJlCqdPnwbg2LFjfPDBB0ybNo0VK1aQlJTEvHnz7PHehRACAJPJxK5du0hJSSn0cTk5OXz00UeAefzLiy++WKzfHxERwd133w3AiRMn+OOPP8pWsBBCVeIgExsbi4+PD2D+h5yTk8OVK1cKfc6uXbvw9/enT58++Pr68tRTT3HgwAG1VWblypUMHz6coKAgmjZtSseOHVm7di0Aq1evplu3bjRs2JCgoCCGDRvGqlWrSlq2EEIUaPLkybRs2ZK4uDhWrlxZ4OMWL15MUlISAH369KFWrVrFfo37779fPf7mm29KX6wQwkbBI9QKMWXKFBISEsjOzqZTp07ExcWxf/9+9uzZQ9euXQkLC2PQoEH0798fMH8DsV7x0t/fn2rVqnHixAkCAwNJTk62ub9u3brqegsnTpygTZs26n116tTh3LlzZGVl4efnd1ttOTk55OTk2L5JLy81fJWEyWSy+X890GPNIHU7mtR9U3Z2trqw3dWrV+nVqxdjxozhrbfeshnEe+sCeC+++GKx6zCZTNx3332MGzcOo9HI4sWLeeedd9TZTM5IrhHHkrrzZ+mSLUypgszYsWN5+eWX2blzJ8eOHQPgzjvv5OuvvyYqKooDBw4wevRowsPD6dy5M5mZmQQGBtr8jsDAQDIzM8nIyMDT09MmlAQGBpKRkQFw23ODgoLU2/MLMgsWLGDOnDk2tw0YMICBAweW5q0CkJiYWOrnakWPNYPU7WhSt3kM3tWrV21umzp1KuvXr+e///2v2kW+Y8cOtUuocePGVK9eXe0CL46wsDDatWvHxo0bOX36NMuXL6dZs2Z2ex/lRa4Rx5K6bdWsWbPIx5QqyAB4enrSunVrvvrqK+Li4mxaTRo3bszDDz/ML7/8QufOnfH39yc9Pd3m+enp6fj7+xMQEIDRaLRpYUlPTycgIADgtuempaWpt+dn6NChDB482PZNlqFFJjExkZiYmGKlQmegx5pB6nY0qfum5cuXq8dDhw7liy++IC8vj507d/LAAw/wf//3f3Tv3p2RI0eqjxszZgyxsbElrvuxxx5j48aNAGzatIk+ffrY5T2UB7lGHEvqLr1SBxkLk8nE2bNnb7vdusk0Li6O77//Xv05MzOTs2fPEhcXR0hICOHh4Rw7dkzdn+TIkSPExcWpz7W0+gAcPXqU6OjofFtjAHx8fEoVWgrj4eGhqwsL9FkzSN2O5u51Hz9+nJ9//hmA2rVrM2/ePIYPH86gQYM4c+YMV65coVevXvzrX/8iISEBgKpVqzJo0KBSvf5DDz3Ec889R25uLkuWLGHatGlOf/7d/RpxNKm7FK9dkgdnZGSwatUqMjIyyMvL4+eff2bXrl00b96cLVu2cO3aNQAOHTrEN998Q4cOHQDzrrCZmZkkJCSQk5PDvHnzaNiwIVWqVAEgPj6euXPnkp6ezr59+9i4cSPdunUDoEePHqxbt45Dhw6RlpbG/Pnz6dmzpz3PgRDCTVnPgLSswHv33Xeze/dudXCuoih88skn6pTpESNGlPrLUsWKFdXPtrNnz7Jt27YyvgMhRImCjMFg4IcffiA+Pp6uXbuyYMECJk2aRO3atdm+fTsDBw6kQ4cOvPbaazz++OPqP1gfHx+mTp3KokWL6Ny5M3v27GHixInq73366acJCgqiR48ejB07lrFjx6rNtrVr12bkyJGMGjWK+Ph4IiMjeeKJJ+x3BoQQbikvL48FCxYA5u7nf/7zn+p9YWFh/PDDD7z77rt4enqqtwcEBDB8+PAyva71eD2ZvSSEHSiiQEajUTlx4oRiNBq1LqXY9FizokjdjiZ1K8qyZcsUQAGUBx98sMDHbdq0SYmOjlYA5bXXXivVa1nXfe3aNcXHx0cBlCpVqjjtfwO5RhxL6i49/XXECSGEHcydO1c9fuqppwp8XPv27Tl69Ch79+612cm6tEJDQ+nevTsA58+f57fffivz7xTCnUmQEUK4nbNnz6oL38XExHDfffcV+nh/f3/uuOMOuw1mHDRokHos3UtClI0EGSGE21m4cKG6gNcTTzxhMw7GEXr37o2vry8AS5cuxWg0OvT1hXAlEmSEEG7FZDKps5UMBoMmkwdCQkKIj48H4OLFi+raMkKIkpMgI4RwK+vWrePUqVMAdO/enerVq2tSh/XspcWLF2tSgxCuQIKMKDeKonDmzBmWLl3KmDFj6Nu3L99++63WZQk3V9xBvuXt/vvvV1co//bbb8nLy9OsFiH0rMwr+wphcePGDbZt28aOHTvU/124cMHmMcuXL2fevHkMHTpUoyqFO7t8+TLLli0DICIiwmZHakcLCgqiV69eLF26lMuXL/Prr79y7733alaPEHolQUbYRUJCAo899hipqamFPk5RFJ588kk8PDxsFiATwhH+7//+j9zcXACGDBli9+1MSmrgwIEsXboUgM8//1yCjBClIF1LosyWLFnCQw89dFuICQ0N5b777uP1119n+fLljBgxAjCHmaFDh/K///1Pi3KFm1IUhTlz5qg/Dxs2TMNqzHr16kXFihUB+Oqrr9SxO0KI4pMWGVEm//vf//jnP/+pTmW9//77GTRoEK1ataJOnTo2m4damvFnzpyJoij885//xGAw3LZbuRDl4bfffuPw4cMAdOrUiTp16mhckXnLgxdffJHx48djNBp59913+eSTT7QuSwhdkRYZUWpz5szh8ccfV0PMk08+ybJly3jssceoW7euTYgB81TXGTNm8OyzzwLmabCPP/44X331lcNrF+7HujVGy0G+txoxYgRBQUEAzJ8/n3PnzmlckRD6IkFGlMpHH33E8OHD1R2Bn332WT777LMiFxYzGAx89NFHPPPMM4A5zDz22GOyuqkoV9evX2fJkiWAeQfqfv36aVzRTWFhYTz33HMA5OTkMG3aNI0rEu7krxMK7Z8zMeJDEzm5itbllIoEGVFi7733njreBeCll17io48+Kvby7ZYw8/TTTwPmMPOPf/xDXTJeCHtLSEggMzMTgMceeww/Pz+NK7L173//W52KPXv2bC5fvqxxRcId5OUpPDpR4bd98NF30H+cQnaO/sKMBBlRbIqi8NZbbzFmzBj1ttdff5333nvvtm6konh4eDBr1ix1wKXRaOTFF1/kP//5D9evX7dn2ULw888/q8fO1BpjERERwfDhwwHIzMzkgw8+KPZzZf0ZUVqfJcC+Ezd/TtgCD/5HIStbX2FGgowotvHjx/PGG2+oP0+aNIm33nqrxCHGwsPDg9mzZ6tLxBuNRqZMmUKtWrWYNm2a+g1aiLJQFIX169cD5s0f7777bo0ryt/o0aPx9vYGzF23165dK/TxiqLwyiuv4O/vzwsvvOCIEoULSU5RGDfvZmDxN2/9xart8MCrChlZ+gkzEmREsezbt4+JEyeqP0+fPp3//Oc/Zf69Hh4ezJkzh1deeUX9EL969Sovv/wydevWZd68efKNU5TJsWPHSExMBKB9+/bqZo3Oplq1aupCkTdu3GDmzJmFPn7ChAlMnTqVvLw8Zs6cyfHjxx1RpnARb8xTuPr3ihmP3QdrphkIMvdu8tNO6D1WIT1TH2FGgowolg8//FA9njBhAv/+97/t9rs9PDyYPHkyP//8M4899pjawnP27FmGDRtGkyZN+P7779WBxUKUhHW3UteuXTWspGivvPKKOmB+xowZ3LhxI9/HffLJJ0yYMMHmNstGmEIUZe9xhU+Xm48D/eHdfxno0NTAmmkGggPMt6//A+LHKKRlOP/nrgQZUaSLFy+qi9dVqFDBriHGWrVq1fj888/Zs2ePzdLxBw8e5KGHHuKuu+7i888/Jysrq1xeX7gmS7cSOH+QiYuL49FHHwXMLZOffvrpbY9ZunSpOssJUIP//Pnz1VWLhSiIoii8+F+Fv1fN4D//MFC1kvkaanuHgXXvG6hgXg2AjXugx8sKqenOHWYkyIgizZo1i5ycHACGDx+urnlRXu644w4SEhLYtGkT7dq1U2/ftWsXQ4YMoVq1aowdO1ZWQRVFMplMapAJDQ2lefPmGldUtFdffVUNJ7eOFVu/fj2DBw9WWydfeeUVHnzwQcD8hePHH390fMFCV5b+Cr/uNh/XioZRA2zvb9XQwM8fGKgYbP75t33QfbRCSprzhhkJMqJQmZmZ6kqjnp6eNtOuy1v79u3ZtGkTCQkJNn+AkpOTeffdd4mLi6NPnz6sXbtWXZRPCGt79+4lOTkZgHvuuafIdY6cQYMGDejfvz8Aly5dUnfr3r17N3379lW/VAwdOpR33nnHZnE/60X/hLhVRpbC6Fk3A8n7zxnw8719skaLegbWf2ggvIL552374f6xzjubSYKMKNSiRYvUNS0GDBhATEyMQ1/fYDBw//33s2vXLn777TceffRRdVCwoigsX76c7t27U79+fRISEhxam3B+1t1KXbp00bCSkrEeSD916lQOHjxIjx491DEz999/P5999hkGg4Fu3bpRvXp1AFavXs3p06c1qVk4v/e+gjMXzcf33QW92xX82GZ1DPzyoYHKoeafN++FoVMUTCbnCzMSZESBFEWxWc9i1KhRmtViMBho27YtixYtIjExkbfeeovo6Gj1/qNHj9KnTx9mzZqlWY3C+ehpoK+1pk2bquPEzp49S8uWLbl06RIA7dq145tvvsHLy7xVnqenp7oek6IozJ8/X5uihVM7fUFhyiJzCPHyhA9HGIpcOuOOWgZWTYE4QwYGReHrn+H1uRJkhI6sXbuWAwcOAOZunlatWmlckVlkZCSvv/46p06dYunSpXTo0AEwf4g/99xzvP766zLDSZCbm8vGjRsBiIqKokGDBhpXVDLWrTIZGRkANGrUiISEBAICAmweO3ToUHVl7fnz52M0Gh1XqNCFlz9RyDL3SjKiHzSILXr9r5xrOWSN2M7Mv37jo+PbaJdykSlfKHy23Lk+XyXIiAK9//776rGWrTEF8fLyol+/fmzYsIFXX31Vvf3tt99m2LBhsv6Mm/v9999JS0sDzN1KpV24USt333039957r/pz9erVWbNmDRUrVrztsdWqVSM+Ph4wt+CsXr3aYXUK5/frboUlv5iPK4fCG/8s+t9CbkouO/rtIuVP82IzsdlpvHZ2L/89vo0vxl9g1VbnGZcoQUbk66+//mLt2rUA1KxZkz59+mhcUcEMBgOTJ0/mv//9r81U1L59+5Kenq5xdUIreu1Wsvbee+8RGhpKzZo1WbNmjU136q2sB/1+9tlnjihP6EBWtsILM262oLwz3EBocOFBJjc1lx39d5G6xxxiDN43Hx+Xncarp/dyYsA2ts276BSt3xJkRL6sF8AbOXKkLmZ7jBgxgm+++QYfHx8AVqxYQdeuXbly5YrGlQktuEKQadasGVeuXOHIkSPUr1+/0MfGx8dTtWpVwHztJyUlOaJE4cTSMhTuH6uo+ym1qAdD4wt/Tt6NPH4f+Acpf6QA4FPJh/a/tuWuxXdS4c4Q9XE1M29wdcyfbLhnOzc2pmkaaCTIiNtcunRJXQAvJCREXTZdDwYMGMCaNWsICTH/g9u+fTvt2rWTNWfcTEZGBlu3bgXMi8zVqFFD44pKz9PTUx3YWxgvLy+bfcsWLFhQ3qUJJ3Y1VaHbSwo/7zL/HOgPn75kwMOj4NaYvPQ8fn/kD67/fh0A7zBvWi9rSXD9ICp3rUzbtXfT5IvmJFW8GWiyDtzg7L+T2PPUvvJ8O4WSICNu88knn5CdnQ2YF8ALDg7WuKKSueeee9i0aRNVqlQB4MiRI7Ru3ZrRo0ezdu1a2YzSDfz222/qeit6bY0pjSeffFLtXp07d66sr+SmLiQr3POCwrb95p9Dg+Cn6QZa1i84xBgzjOx89A+ubTVvVuod6kXr71oS3ODm57/BYKBafAS9d7RmdrNmHPO7eV9Yl0rl82aKQYKMsJGVlcXHH38MOH4BPHtq0qQJW7dupV69eoC5lWn69Ol0796dsLAwunfvzvTp0/nrr7+coo9X2Jde148pq9jYWLp16wbAqVOnWLduncYVCUc7fUGhw/M3u5Miw2DDTANtGhcSYjKN7HxsN1c3m0OMV4gXrb5tScgdIfk+PjLMg6kLIhjftDVvxTRlc0gEk89GafZZKkFG2Pjyyy/VBfD69++vLrSlRzVq1GDz5s3cf//9NjNWsrKyWLt2LaNHj+aOO+4gOjqat99+W8NKhb1Zj49xpyAD5lZUC1np170cOq3Q/jmFY+fMP1ePhE0zDTSpVUiIyTLyxz//JHmDeQVsr2AvWi1tQYVmFQp9rXrVDSyb7MEf4RG8W70JTet6aDYzUIKMUCmKYjPlurw2h3SkSpUqkZCQwOXLl/nmm2948sknqVatms1jzp8/z+uvv66umSP07fr16+zaZR4YcMcddxAREaFxRY7Vu3dv9T0vW7aMixcvalyRcIQ/DptbYs6av4dSrzps/shAnZjCw8XhiUe4/LN5QoRnoCd3LWlBaIvQYr1mx2YGFr4Ks0de5pm+ZSi+jCTICNW6devYv9/cqdq2bVunWQDPHsLDwxk4cCBz587lzJkzHDhwgA8//NDmPW7atEnDCoW9bNiwQR0b4m6tMQA+Pj4MGTIEgLy8PD7//HNtCxLlbss+hc4jFa6YJxrRrA5snGkgJrLwEJN2OI3TcxMB8PD34K5vWlDxrtASvfagLtC1mbbjDiXICNXMmTPVY1dojSmIwWCgQYMGvPjiizbTzLds2aJdUcJuXGHadVlZtiwA86BfGQfmunLzFB6eoJD695JZ7e6AXz40EFGx6G6eg28cRjGar41aI+MIa3P7Yot6IEFGAHD16lVWrVoFQHR0NH379tW2IAe588471XVnJMi4BkuQ8fT0pFOnThpXo406derQuXNnwLwP2YYNGzSuSJSXbzdAonkbLtrdAWunF73gHcCldZe5vM7cpeQX7Ufcs7HlWGX5kiAjAPj+++/VJf0HDRqkiwXw7MHX15eWLVsCcOzYMXVjPqFPFy5cUMc6tWzZUl1PyB1Zr/QrG0m6rg+X3GxtmzTMQIBf0SHGlGvi0LjD6s/136yLZ4B+P/MlyAgAvvnmG/V40KBBGlbieG3btlWPt23bpmEloqysp127a7eSxYMPPkiFCuaZJ99//7268aRwHVv/Utj+9xyFprWhU7PiPe/MwkTSjpj7okJbVqDKQ1HlU6CDSJARXL58Wf0DULNmTe666y6NK3KsNm3aqMfSvaRvMj7mJj8/P/r16wdAWloaCQkJGlck7M26NWbkAEOxpj/nXMvh6LvH1Z8bvl1fdxuq3kqCjODbb7/FaDQCMHDgQN1f1CUlQcZ1WAK5r6+vzX9Xd/Xoo4+qx19++aWGlQh7O3NR4duN5uOIivBwMSfoHXvvOLnXcgGoOqAKoS1Dy6dAB5IgI9y6WwmgSpUq1KxZE4Dff/9dXdpe6MuJEyfUPbXatWuHv7+/tgU5gXvuuUfdqmPVqlVcvXpV44qEvXz8ncLf3z95pg/4+Rb9BTTtSBqn592cbl1vXN3yLNFhShxk3n77bbp3706nTp0YNGiQuvZGQkICjz76KB07dqRPnz4sXbrU5nktW7akffv2dOjQgQ4dOtgMPsvKymLcuHF07NiRXr16sXr1apvnJiQkEB8fT6dOnZgwYQK5ubmlea8iH0lJSeqMhjp16tCsWTNtC9KIZZxMVlYWe/bs0bgaURruvJpvQTw9PXn44YcByM3Nve1zWehTeqbCZ3/3FPp4wzN9i9eKfvDNIyh5f0+3fqEm/tF+5VWiQ5U4yAwePJiEhAQ2bNjAG2+8wbhx40hNTSUnJ4dXX32V9evX8/777/PZZ5/xxx9/2Dx32bJlbNq0iU2bNqm7tALMnj2blJQUVq5cyeTJk5kyZQqnT58GzDNJPvjgA6ZNm6ZuTT9v3rwyvm1hsXTpUnWNiYcfftjtupUsrAf8SveSPslA3/wNHjxYPZbuJdfwf2vgepr5+NF7ITKs6M/ty+uvcHmtedlfv6p+xD1fszxLdKgSB5nY2Fh13Q2DwUBOTg5XrlyhX79+3HHHHXh5eVGrVi1atWpV7CXfV65cyfDhwwkKCqJp06Z07NiRtWvXArB69Wq6detGw4YNCQoKYtiwYep6J6Ls3L1byULGyejfL7/8AkBwcLA6pV6Y10qqW9fchbBhwwYSExM1rkiUhcmkMGPpzUG+L/YvxnTrPBMHXz+k/lzvzTq6nm59K6/SPGnKlCkkJCSQnZ1Np06diIuLs7nfaDSyf/9+4uPjbW5/7LHHMBgMtG7dmpEjRxIaGkpqairJycnUrl1bfVzdunXVpfJPnDhh80emTp06nDt3jqysLPz8bm8Wy8nJuW2Mg5eXlxq+SsKyzLnl//WgJDUnJiaqf7QbNWpEgwYNNHuvWp/rRo0aERgYSHp6Olu2bCl2HVrXXVquVndKSoq6p9Cdd96Jh4eHU703rc/3o48+yvjx4wH46quvGD16dJHP0brm0nL1uldth8NnzMf3NIMmtRRMpsJXbj6zMJG0w+bp1hVaViDqwUi7nZ/yPt8eHkW3t5QqyIwdO5aXX36ZnTt3cuzYsdvu/+STT6hcubJNAJkzZw533HEHN27c4N1332XixIm8//77ZGRk4OnpaRNKAgMD1TUPMjMzCQwMVO8LCgpSb88vyCxYsOC2HV8HDBjAwIEDS/NWAXT5DaY4Nc+dO1c9vu+++9TuPC1pea6bNGnC1q1bOXv2LFu3bqVq1arFfq4erxFwnboPHjyoHleqVMkpruX8aHW+O3bsqB4vXLiQAQMGFPu5rnKN6EVRdb/7RQRgHsj+SKdLnD5d+D5HxjQjxyefVH+u+FwIZ86cKXOdtyqv822ZiFGYUgUZMA8ia926NV999RVxcXFqaFm6dCnr169n/vz5NuMtmjdvDkDFihUZPXo0vXr1Ijc3l4CAAIxGo00LS3p6OgEBAQD4+/uTnp6u/p60tDT19vwMHTrUpk8YytYik5iYSExMTLFSoTMoSc0//fSTejx8+HBq1KhR3uUVyBnOdZcuXdi6dStg/kdZnOm7zlB3abha3Xv37lWPGzZsqOm1nB+tz3eNGjVo1aoVO3bs4ODBg6SlpdGoUaNCn6N1zaXlynXvPwmb/jIfx1WFoQ9EUNQi7KfnnsGYYm4tqdIvivr317dn2U5xvksdZCxMJhNnz54FYO3atWqLSGhoaIHPsbxZRVEICQkhPDycY8eO0bhxYwCOHDmidlfFxcXZtPocPXqU6OjofFtjwLzza2lCS2E8PDx09Q8Ciq75xIkT/P7774A5ZNavb9+Lu7S0PNe3rvBrme1RHHq8RsB16rb+NhgbG+u070nL8/3oo4+yY8cOAL7++mvefvvtYj3PVa4RvSis7o++u9l980I/A97eRY+POfdVknpce1RcuZ0TLc93iV41IyODVatWkZGRQV5eHj///DO7du2iefPmbNu2jffee48PP/zwtib548ePc+TIEYxGI6mpqUyfPp3WrVurgSM+Pp65c+eSnp7Ovn372LhxI926dQOgR48erFu3jkOHDpGWlsb8+fPp2bOnnd6++5JBvre7++671WMZ8Ksv1l1JztYa4ywGDRqk/qH58ssvZUdsnUlOUfi/Nebj4AAYGl/44wFS9qaSuvcGABWahxDcILgcK9ROiVpkDAYDP/zwA++++y6KohATE8OkSZOoXbs27733HqmpqTbTqnv27Mlrr73G1atXeeedd7h06RKBgYG0atVKHXgG8PTTTzNp0iR69OhBSEgIY8eOJTY2FoDatWszcuRIRo0aRXp6Ol26dLF5DVE61kGmLOOHXElYWBgNGjTg4MGD7N69m8zMTFlUTSckyBQtKiqKrl278tNPP3Hq1Cm2bt1q0wopnNtnCZD19zyWJ3tBSGDRrTFnvzynHlcbXK28StNciYKMv78/n376ab73zZ49u8Dn3XXXXXz33XcF3u/n58ekSZMKvL9379707t27+IWKQh0+fFhd9K1Vq1bFGkzlLtq2bcvBgwfJy8tj586ddOjQQeuSRDFYB5mYmBgNK3FugwcPVsfGffnllxJkdCInV+Gj78wtaAYDjOhXdIgxZhlJWmLuVvLw86CqzjeGLIz+OhBFmUm3UsFkPRl9sgSZKlWq4Ovrq3E1zuvBBx9Uxxd+8803skq6Tny3EZKumI/7tIe4qkUHmYurLpF7PQ+AqN6ReFfwLs8SNSVBxg1Jt1LBZIVf/cnKylLXkJFupcKFhISordtXrlxh3bp1GlckimP9HzfHMz1bzO0Izi662a0UMzja7jU5Ewkybuavv/5SV1xu37491aq5br9padSrV4+KFSsC5iAjAyKdn/WaGBJkima9I/aiRYs0rEQU19GzN4/vKsYE08zETK78mgyAfw1/wtqFlVNlzkGCjJv5+uuv1WPpVrqdh4eH2r105coVjh8/rnFFoigy0LdkevbsqS6PsWzZMpt1uoRzsgSZShUgNLgYg3y/Pgd/fweLeTQag4dr76EnQcaNKIqidit5eHjQv39/jStyTtK9pC8SZErG19dX/befnp7O8uXLNa5IFCYjS+Gcea9H6hSjAV0xKZz98u+1YwwQ/UjxVyjXKwkybmT37t3q4oKdOnUiKsp1R7GXhQz41RcJMiUnO2Lrx7GbQ12oXYwgk7zpKplnzNsWVOocjn+06y8hIUHGjWzcuFE9ltaYgrVq1UpdOEyCjPOTIFNyHTt2JDraPAB09erVJCcna1yRKMhRqy2M6lQr2doxMS68dow1CTJu5PDhw+qxZe8rcbugoCCaNm0KmAdHp6amalyRKIwEmZLz8PBQx8jl5eWxYcMGjSsSBbEe6FtU11Lu9VwuJJhn8HlX9CaiZ0Q5VuY8JMi4kSNHjqjH9erV07AS52cZJ6MoCtu3b9e4GlEYS5AJCwsjONg1l2AvD506dVKPt23bpmElojDHzt2cOVlUkEn67jymbPN+TNEDquDp6x5/4t3jXQrgZotMpUqVCAtz7el4ZSXjZPQhLy9P3bRWWmNKpnXr1uqxBBnnVZIWmcT/WW9J4Nprx1iTIOMm0tLSOHfOfJHXrVtX42qcn8xc0oekpCSMRiMgQaakIiMj1e1Jdu7cKav8OilLkImoWPj+Sql/pZK6x9wNHtI0hJDGIY4ozylIkHETR48eVY+lW6losbGx6qyubdu2YTKZNK5I5EfGx5SNZcf3zMxM9u7dq3E14lZpGQrn/x6HXVRrjO0gX/dpjQEJMm7DeqCvBJmiGQwGtVUmNTVVXQ1ZOBcJMmVj3YUq3UvOx2bqdSHZxJht4tzi8wB4+HpQtV+Vcq7MuUiQcRPWQUa6lopHxsk4PwkyZWNpkQHYunWrhpWI/NiOjym4W+nS6kvkXjN3DUbeH4F3qOtuEJkfCTJuQlpkSk7GyTg/CTJl07RpU3W3cGmRcT7FHehrs0Hko+6xdow1CTJuwjL12sPDg1q1amlcjT7ceeed+Pj4ALB582aNqxH5kSBTNj4+PrRo0QKA48ePc/nyZY0rEtaKM/XalGMiefNVAPyq+hHe0f1mpEqQcQOKoqgtMrGxseo3MFE4Pz8/dYrq8ePHSUxMLOIZwtEsQSYgIIDw8HCNq9En6y5UWTPJuVi3yBS0PcGNAzfUtWPC2lZ0+Q0i8yNBxg2cP3+etLQ0QLqVSqpz587q8a+//qpdIeI2iqJw5swZwNwaYzC43we4Pcg4GedlCTJRYRAckP/1fX33zZXHKzR3nynX1iTIuAFZ0bf07rnnHvVYgoxzuXz5MpmZ5s3xpFup9KyDjIyTcR6p6QoXzT1GhY6PSdmdoh6H3lmhnKtyThJk3IDMWCq9Nm3aqF1xEmSci4yPsY9q1apRrZr5L+WOHTvUBQaFto4Vo1sJ4Pof5iBj8DS41SJ41iTIuAGZsVR6fn5+6jfWEydOqF0ZQnsSZOzHco2npaWxf/9+jasRULyp13lpeaQdNg8bCG4YhGeApyNKczoSZNyABJmyke4l5yRBxn6ke8n5FGfqdereVPh70fEKzd2zWwkkyLgFyxiZwMBAqlatqnE1+mM94PeXX37RsBJhTYKM/UiQcT7FmXotA33NJMi4uJycHE6ePAmYx8fIzI6Sa926tYyTcUISZOznzjvvxNvbvBqsBBnnYDP1uoDtCWSgr5kEGRd3/PhxdfCedCuVjp+fn7rK76lTpzh16pS2BQngZpDx8vKiShX32lvG3vz9/WnWrBkABw8e5Nq1a9oWJNQgU7USBPoXMPX674G+Hv4eBNUPclRpTkeCjIuTqdf2IeNknI8lyMTExODp6Z6DHO3Juntpx44dGlYiUtIULl83HxfUrZSTnEPmafPyAxWahODh5b5/zt33nbsJmXptH7IwnnNJTU3l+vXrgHQr2YuMk3EexepW+vNmt5I7D/QFCTIuT2Ys2UerVq3w8/MDzAN+FUUp4hmiPMn4GPuz3qpAVvjVVnGmXlu6lcC9B/qCBBmXZ921JC0ypefr66uOkzlz5oyMk9GYBBn7i42NJSIiAjDvuWQymTSuyH0VZ+p1itWMJXce6AsSZFyepUWmSpUqBAcHa1yNvkn3kvOwXphQgox9GAwGtXvp+vXrNl+ChGMVNfVaURSu/z1jyTvUi4CaAY4qzSlJkHFh165d4/Lly4B0K9mD9YBfWU9GW9IiUz5knIxzsG6RqZXPGJmsc1nkXMoBoEKzCm6/rIYEGRcm42Psq1WrVvj7+wPmFhkZJ6MdCTLlw3qcjAQZ7ViCTLXKEOB3e0ixGR/j5t1KIEHGpcn4GPvy8fGhXbt2ACQmJnLixAmNK3Jf1l1LMTExGlbiWlq2bImHh/nPwvbt2zWuxj1duwHJf+eUAsfHWAWZUDefsQQSZFyatMjYn6wn4xwsLTJVqlRRV10WZRcUFMQdd9wBwF9//UVaWprGFbmfo8XY9dp6oK+0yEiQcWkSZOxPBvxqLzs7mwsXLgDSrVQeLONkTCYT+/bt07ga91PU1GvFpKhryPhV8cUvSoK8BBkXZula8vb2JjY2VttiXETLli0JCDDPEJD1ZLSRlJSkHkuQsT/rcTJ//PGHhpW4p2NFTL1OP5pOXpp52xl3XwjPQoKMizKZTBw9ehSAWrVq4eXlpXFFrsHHx4f27dsDcO7cOY4fP65xRe7n3Llz6rEEGfuznrn0559/aleImzp68/LON8hc3y0DfW8lQcZFnTlzhqysLEC6lexNpmFrS4JM+apTpw4VK1YEzEFGWh0d6/jfl7fBALWq3n6/zUJ40iIDSJBxWTJjqfxYj5PZsGGDhpW4J+laKl8eHh5qq0xycrLMznMwyxiZmAjw8y1i6rWbb01gIUHGRcmu1+WnRYsWBAYGArKejBakRab8ycJ42riW5sG1G+bj/LqVTDkmbvxlbpEJrBWAdwVvB1bnvEocZN5++226d+9Op06dGDRoEJs2bVLvW7hwIffeey9dunRhxowZNh/w+/fv55FHHqFdu3YMHz6c8+fPq/dlZWUxbtw4OnbsSK9evVi9erXNayYkJBAfH0+nTp2YMGECubm5pXmvbkVmLJUfb29vdZzM+fPnOXnypMYVuRcJMuXPOsjIejKOc+rCzbGM+e16fePADUw55r+rMtD3phIHmcGDB5OQkMCGDRt44403GDduHKmpqWzevJmlS5eycOFCFi9ezObNm1m+fDkAOTk5jBkzhocffpj169fTuHFj3njjDfV3zp49m5SUFFauXMnkyZOZMmWKuk7EsWPH+OCDD5g2bRorVqwgKSmJefPm2entuy7rICNdS/Zn3b0kH/SOZQkyFStWlP3DykmrVq3UY2mRcZxTF2+2sOQ39dq6W8ndN4q0VuKpLNbTeA0GAzk5OVy5coWVK1fSv39/qlUzt4c99thjrFq1ij59+rBr1y78/f3p06cPAE899RT33nsv58+fp0qVKqxcuZLp06cTFBRE06ZN6dixI2vXruWpp55i9erVdOvWjYYNGwIwbNgwJk2axL/+9a9868vJySEnJ8f2TXp54ePjU9K3qu7+qqddYC21WmYshYaGEh4e7vTvQW/numPHjurx1q1bdVO3hd7Ot0Vubq7NGjJ6qV9v5zskJIT69etz6NAh9u7dS1ZWVqk+Q7Wgt3NtYTKZOHXx5p/kWtEKJpNtt7V1kAluFuwU77G8z7dlpenClGpO7pQpU0hISCA7O5tOnToRFxfHyZMniY+PVx9Tt25dPv74YwBOnDhB7dq11fv8/f2pVq0aJ06cIDAwkOTkZJv769aty/79+9XnWq9rUKdOHc6dO0dWVhZ+fn631bZgwQLmzJljc9uAAQMYOHBgad4qYF6OXk8yMzPVJdxjY2NtlnN3dno515UqVSIwMJD09HS2b9/OmTNndLlxm17Ot0VSUhJ5eXkAVK5c2WbPJT3Q0/muV68ehw4dIjc3l59++onGjRtrXVKJ6OlcW5y8UEk9DvQ4x+nTeTb3X9l+xXzgCddDrpF6OgVnUV7nu2bNmkU+plRBZuzYsbz88svs3LmTY8eOAZCRkUFQUJD6mMDAQDIyMgDzH1bL4Ejr+zMzM8nIyMDT09MmlBT2XMtrZGZm5htkhg4dyuDBg23fZBlaZBITE4mJiSlWKnQGJpOJtWvXqj83btxYF+MI9HiuO3TowOrVq7l8+TIZGRlqq6Ee6PF8g+1mkfXr19fFtQ36PN/t2rXjhx9+AMwBslevXhpXVDx6PNdgrvv0JfP4Tw8PaN8iGl+rP1t5aXkcPGWexBHSMJia9Yr+A+8IznC+S71KmqenJ61bt+arr74iLi6OgIAAm3050tPT1RVQ/f39SU9Pt3l+eno6/v7+BAQEYDQabVpYCnuu5TUsuxDfysfHx+5NoB4eHrr6B2E9+LR+/fq6ql1P57pLly7qwPSNGzfq7hsr6Ot8g+1mkbGxsbqqHfR1vlu2bKke//nnn7qp20JP5xpAUW6OkakeAf5+trWn/ZUGf/feVLizgtO9Ny3Pd5lf1WQycfbsWWrWrKm2zoB5+m9cXBwAcXFxNvdlZmZy9uxZ4uLiCAkJITw8vNjPPXr0KNHR0fm2xggz63UfZMZS+enQoYN6LAMiHcM6yOilNUavmjdvrh7v2rVLw0rcw5UUuJFh/pOc74q+MtC3QCUKMhkZGaxatYqMjAzy8vL4+eef2bVrF82bNyc+Pp5vv/2Wc+fOceXKFRYtWkTPnj0B87obmZmZJCQkkJOTw7x582jYsCFVqlQBID4+nrlz55Kens6+ffvYuHEj3bp1A6BHjx6sW7eOQ4cOkZaWxvz589XfK/JnHWRkxlL5ad68udr6J0HGMay7liTIlK+QkBB1csfevXtl2YtyVtSu1zY7XsvUaxslCjIGg4EffviB+Ph4unbtyoIFC5g0aRK1a9emffv2PPTQQzz++OMMGDCAdu3a8cADDwDm7p6pU6eyaNEiOnfuzJ49e5g4caL6e59++mmCgoLo0aMHY8eOZezYseo/oNq1azNy5EhGjRpFfHw8kZGRPPHEE/Y7Ay7I0rVkMBioU6eOxtW4Ll9fX1q0aAGYWwqTk5M1rsj1SZBxLEt3aXZ2NgcOHNC4GtdW1K7Xlj2WPPw9CKoXeNv97qxEY2T8/f359NNPC7x/6NChDB06NN/7GjVqxNdff53vfX5+fkyaNKnA39u7d2969+5dklLdlqIoaotM9erVCxxLJOyjdevWbN26FTC3yuhlQKReWbqW/P39qVSpUhGPFmXVuHFjfvzxR8C8E3bTpk01rsh1FbbrdfaVHDJPZwJQoWkIHl7ONT5Ga3I2XMylS5e4ccO8xrWMjyl/1iugWgKNKB+KoqhBpkaNGrqc7q431gPYZZxM+Sps1+uUP633V5JupVtJkHExsqKvY1mvcSRBpnxdvnyZzEzzt9Lq1atrXI17aNSokXr8xx9/aFiJ67Pseu3hATWr2N6X8qfVjtcy0Pc2EmRcjGwW6VjVqlUjKioKgB07dmA0GjWuyHXJ+BjHq1ChgjqD9M8//1QXIxT2pSiKOkYmNgp8vG1bG9MO3VzaJKSxbMtxKwkyLkaCjONZpqmmpaWpK1IL+5Mgo40777wTMC+bYd3iK+zn0jW4YV4DNt/NItOPm9dSM3gaCIgNcGBl+iBBxsVI15LjWa+3Id1L5cc6yEjXkuNYggzIOJnycurCzeO4qrb3KYpC+nFzyvGv4Y+Hj/zZvpWcERdj2SzS39+fmJgYjatxD9ZBRtaTKT+yGJ42rIOMjJMpH5eu3TyuEm57X1ZSNsZ0c5d1YG2Zdp0fCTIuJC8vj+PHjwPmzTWdbQlrV9W4cWO8vc1Li0uLTPmx7HoNULVq1UIeKexJWmTKn3WQqRxqe5+lWwkgqLZ0K+VH/tK5kGvXrqmD8aKj8+loFeXC19dX/bA/fPgwV69e1bgi12S94GDlypU1rMS9hIeHqy1gu3fvxmQyaVyR67l0/ebxbUHm2M0gE1hLWmTyI0HGhVj/AQ0PDy/kkcLerNeT2b59u4aVuK4rV64A4O3tTVBQkMbVuBfLCtbp6ek2EwqEfVy+rqjHEaG291nGx4B0LRVEgowLsQ4yFStW1LAS99O6dWv1WLqXyoclyFSsWFEWw3Mw6V4qX9ZdSxG3fHTbtshI11J+JMi4EOsgExYWpmEl7kcWxitfiqLYBBnhWJYWGZABv+XBJsiE2t5nCTKegZ74Rvk6rigdkSDjQiTIaCcmJkYdgLp9+3ZZGM/OMjIyyM7OBuTa1oK0yJQvyxgZb0+FCla9psZsExlnzKtZB9YOlJbIAkiQcSHXrt2M9fKt1bEMBoM6TubGjRscPHhQ44pci6U1BiA0NFS7QtxUREQE1aqZNwCSAb/2Z2mRCQ8xYp1VMk5mwN+nOlBmLBVIgowLkTEy2pLupfJjHWTk2taGpVUmNTVVXeZBlJ3JpHD5uvk4PMS2Jdd6fEyQDPQtkAQZFyJdS9qyDjKyMJ59WU+9lmtbGzJOpnxcT4O8v/NLeIhtS5f1GjIyY6lgEmRciAQZbd155514eXkB0iJjb9K1pD3rICPjZOzHeqBvePCtLTJWU69lDZkCSZBxIdZjZCTIOJ6/v7+6XcHBgwdt/nuIsrEOMnJta0O2KigfNkGmkK4lmXpdMAkyLsS6RUa+tWrDuntJFsazH+uuJRkjo40qVapQpUoVwBxkFEUp4hmiOKxX9S2oa8mvii9eQV4OrEpfJMi4EEuQCQoKUrs4hGNZr/Ar42TsR7qWnIOlVebatWucOnVK22JcREEtMjnXcshJzgWkW6koEmRciCXIyAe9dmTmUvmQriXnIONk7O/StZstW9ZBxmZ8jAz0LZQEGRehKIo6JkOCjHZq1KhBVFQUYO5akvU27EO6lpyDzFyyv4K6lmzGx8gaMoWSIOMibty4oa4mW6FCBY2rcV/WC+OlpKRw6NAhjStyDdYbRgYGyrdTrcgKv/ZXUNeSbZCRa74wEmRchAz0dR7SvWR/liBTqVIlWaZdQ9HR0URERAAy4NdebKdfW7XIyK7XxSZBxkVYB5mQkJBiPy82NpYPP/yw2I//9ddfMRgMXL9+vQTVuRcJMvalKIratVSpUiWNq3FvBoNBbZW5cuUKiYmJGlekf5aupeAA8PO5GQzT/m6RMXgb8I/x06Ay/ZAgo0P33HMPI0eOtLmttC0yv//+O8OHDy/249u2bcv58+el+6oQLVq0UGeNycylssvIyCArKwuA8PBwjasRMuDXviwtMta7XitGhYwT5haZwJoBeHjJn+rCyNlxEdaLr1WoUIG8vLxiPa9y5coEBBR/IJmPjw9RUVHSvF+IgIAAmjZtCsCBAwdISUnRuCJ9s56xJEFGe7Iwnv3k5ilcu2E+jrAaw555LgtTtrmbSbqViiZBRmeGDBnChg0bmDFjBgaDAYPBwMKFCxk4cKD6mPfee49NmzZx/Phx+vTpQ2RkJEFBQdx1112sW7fO5vfd2rVkMBiYO3cuDz74IAEBAdSpU4fly5er99/atbRw4UJCQ0NZs2YNDRo0ICgoiB49enD+/Hn1OXl5ebzwwguEhoYSHh7OK6+8wj//+U/69u1bLufIGVi6lxRFkYXxysh6xpJ0LWlPWmTs58r1m8eVQm8ey4q+JSNBRmdmzJhBmzZteOqppzh//jznz58nJibG5jFvvvkmTZo0IS0tjfj4eNatW8fu3bvp3r07vXv35syZM4W+xoQJExg4cCB79+4lPj6ewYMH23Rd3SojI4Np06bxxRdfsHHjRs6cOcPo0aPV+999910WLVrEggUL+O2330hNTWXZsmVlOg/OTjaQtB/rFhkJMtqrXr262jK2a9cuGfBbBtZTr627ltKPWgWZOtIiUxRZ/vUWLVu25MKFC+rPRqMRT0/Pcn/dqKgodu7cWeTjKlSogI+PDwEBAep6JbdO8a1Tpw7h4eFUrlxZ7eIAmDRpEt9//z3Lly/n+eefL/A1hgwZwiOPPALA5MmTmTlzJjt27KBHjx75Pj43N5dPP/2UWrVqAfD8888zceJE9f6ZM2fy6quv8uCDDwLw0UcfsXLlyiLfq55Zr/ArA37LRrqWnItlwO9PP/3EpUuXSEpKIjo6WuuydMl6xpJ115Lsel0yEmRuceHCBc6dO6d1GWViGYibnp7OhAkT+PHHH0lKSiIvL4/MzMwiW2SaNGmiHgcGBhIcHMylS5cKfHxAQIAaYsC8J4vl8SkpKVy8eJFWrVqp93t6etKiRQuXXiyuZs2aREREcOnSJbZt24bJZMLDQxpAS8O6a0mCjHNo0aIFP/30E2AeJyNBpnRsgkzozeM02fW6RCTI3MLSymHhyBYZe7HMWnr55ZdZs2YN06ZNo3bt2vj7+9O/f39ycnIKfb63t7fNzwaDodDQkd/jb21uvnVwsKs3RxsMBlq3bk1CQgLXr18nMTGRGjVqaF2WLknXkvOxHvC7e/duevfurWE1+mXdtVQ5nxYZ71AvfMJtP1/F7STI3MK6e8dkMnH69Glq1KjhVN+mfXx81FV882MJMps2bWLIkCFql05aWprDN3qrUKECkZGR7Nixgw4dOgDmcLh7926aNWvm0FoczbqV6syZMxJkSkm6lpxP48aN1ePDhw9rWIm+We+zZGmRMWYYyTprXm4gsFagzBAtBgkyOhQbG8v27ds5deoUQUFBNq0lvr6++PmZF0+qXbs23333Hb1798ZgMDBu3DhNunNGjBjBO++8Q+3atalfvz4zZ87k2rVrLv8PtHr16upxUd15omAya8n5xMXF4eHhgclk4siRI1qXo1v5jZFJPyEr+paU8zQziGIbPXo0np6eNGzYkMqVK9v8kbTeGfiDDz6gYsWKtG3blt69e9O9e3ebJmFHeeWVV3jkkUd4/PHHadOmDUFBQXTv3l0NXK5Kgox9SNeS8/H19SU2NhaAI0eOuHxXcXnJb9ZShmxNUGLSIqNDdevWvW0mzLPPPktmZqZNkImNjWX9+vU2j3vuuedsfr61qym/DyTr7Qjuuecem8cMGTKEIUOG2Dy+b9++No/x8vJi5syZzJw5EzB32TVo0MBm7RtXJEHGPqw3jAwKCip0KQDhOHXr1uXEiROkpqZy6dIlIiMjtS5JdywtMgYDhIfAuRuy63VpSIuMC8jKyiIzMxOwbZFxFqdPn2bOnDkcOXKEffv28cwzz3Dy5EkeffRRrUsrVxJk7EM2jHROdevWVY+le6l0LEEmPAT+3tVENossBQkyLsB6e4KKFSsW8khteHh4sHDhQu666y7atWvHvn37WLduHQ0aNNC6tHJVuXJlfH19AQkypSUbRjovCTJlZ+layncNGYN5nyVRNOlacgHWTe3OGGRiYmL47bfftC7D4Tw8PKhevTpHjx7l9OnTKIoiLQolJBtGOq86deqoxxJkSi49UyHDfGmrQUZRFNL/XkPGv5ofnv7lv/SHK5AWGRdgHWScsWvJnVm6l27cuCGbR5aCDPR1XtIiUzb5LYZnvGYkL9W84a90KxVfiVpkcnJyeOedd9i+fTvp6enUq1ePMWPGULt2bSZPnsyqVatsHtu2bVs++OADwLz0v5+fn/qNdOjQoTzxxBOAeYzH22+/zYYNGwgODmbEiBE2y+EnJCTwySefkJ6eTpcuXXjttdduW4TNnVl3LUmQcS63jpOxrPEjikemXjuvmJgYfH19yc7O5ujRo1qXozs2M5b+bpHJOX1zsVIJMsVXohYZo9FIdHQ0CxYsYP369XTs2JGXXnoJgNdee41Nmzap/6tduzadOnWyef6yZcvU+y0hBmD27NmkpKSwcuVKJk+ezJQpUzh9+jQAx44d44MPPmDatGmsWLGCpKQk5s2bV9b37VKcvWvJncmA37KRxfCcl6enJ7Vr1wbMn9OFLdIpbme7hoz5C3726Vz1Ntn1uvhKFGT8/f0ZNmwYkZGReHp6MmjQIJKSkmym5wKcPHmSkydPcu+99xbr965cuZLhw4cTFBRE06ZN6dixI2vXrgVg9erVdOvWjYYNGxIUFMSwYcNsWn6EdC05MwkyZSNdS87N0r2UnZ1NYmKixtXoS35dS9IiUzplGuy7d+9ewsLCbmsuX7VqFe3btycoKMjm9scee0zdg2bkyJGEhoaSmppKcnKymuzB/I9j//79AJw4cYI2bdqo99WpU4dz586RlZWV74JqOTk5t+0l5OXlhY+PT4nfn2UVXGff3NC6+d3y38LZa76VXs71rYqqu1q1aurx6dOnneb96eV8WweZsLAw3dR9Kz3WXZyarQf8Hjp0yCa4a0Uv5/qiVZCpFKpgMplsgkxAnL/Tvwco//NdnO2BSh1k0tLSmDx5Ms8+++xt961Zs4aRI0fa3DZnzhzuuOMObty4wbvvvsvEiRN5//33ycjIwNPT0yaUBAYGkpFhHrmdmZlJYODNZGoJR5mZmfkGmQULFjBnzhyb2wYMGFCmxdec/ZuGpRsOUEOcs9dcEFer23rD0YMHD9r8t3IGzn6+jx07ph4bjUa1XmevuyB6rLuwmq1bgLdv3069evUcUVKxOPu5Pn6mIhACgCnrAomJ2WqQMfgauJh3EcNp/cxyLK/zXbNmzSIfU6ogk52dzUsvvUT79u3p06ePzX179uwhNTWVdu3a2dzevHlzwDyGY/To0fTq1Yvc3FwCAgIwGo02LSzp6ekEBJj7B/39/UlPv7nSYVpamnp7foYOHcrgwYNt32QZWmQSExOJiYlxqk0jb5WXl6ceW9ZmKazmuLg4XnzxRV588UXA/Mf222+/pW/fvvk+/tSpU9SqVYtdu3aVaaPHwn6PXs71rYqqOyIiQj1OTk52mo0j9XK+ra/thg0bEhMTo4u6b6WX822tODVbt5ZfuXLFKa5vvZzrLKshRU0aRBEdkcfBs+bZX0G1A4mtGatNYSXkDOe7xEEmLy+P1157jcqVK9/W6gLmMS1du3YtNDhY3qyiKISEhBAeHs6xY8fUHVWPHDlCXFwcYP6ja/2t7OjRo0RHRxe4T4+Pj0+pQkthPDw8nPofhPWspUqVKpGSklJkzQaDQb3//PnzVKxYscDHW24vyXkYMmQI169fZ9myZeptNWrU4Pz581SqVKnQ13Lmc12QguoODAwkIiKCS5cucebMGad7b85+vq3Hf0VERJTqWnQmeqy7sJqtW2COHj3qVO/N2c/15es3u2IiKxrITsyGv8NNYK1Ap649P1qe7xK/6ttvv012djbjx4+/bXGvvLw8fvrpJ5up0wDHjx/nyJEjGI1GUlNTmT59Oq1bt1YDR3x8PHPnziU9PZ19+/axceNGunXrBkCPHj1Yt24dhw4dIi0tjfnz59OzZ8/Svl+XZPmwNxgMhISElPj5UVFR6gq05cnT05OoqCi8vNxrHUbLuIGkpCRyc3OLeLSwJoN9nVtERIT6mSNryZSMZfq1txdUCJKtCcqiREHm/PnzJCQksHv3bjp37kyHDh3o0KEDu3fvBmDbtm34+vretsPy1atXGTt2LJ06dWLAgAF4eHgwfvx49f6nn36aoKAgevTowdixYxk7dqy6s2rt2rUZOXIko0aNIj4+nsjISJup2+5m9uzZREdH2wyssgQZb29vTp48yfDhw6lSpQpBQUHcddddrFu3rtDfaTAYbFpOduzYQfPmzfHz86Nly5bqf18Lo9HIk08+Sc2aNfH396devXrMmDFDvX/8+PF8/vnn/PDDDxgMBgwGA7/++iunTp3CYDDw559/qo/dsGEDrVq1wt/fn9atW/Pqq6/adCfcc889vPDCC4wZM4awsDCioqJsrh09sAQZk8lEUlKSxtXoy60bRgrnYjAY1JlLp06dIjs7W+OK9MMyaymiovk8WgeZIAkyJVKir8ZVqlRh586dBd7fvn17VqxYcdvtd911F999912Bz/Pz82PSpEkF3t+7d2969+5dklJd1oABA3jhhRf45Zdf6Nq1K2C7qV5aWhr33HMP06ZNIyAggM8//5zevXtz+PDhYs0oSE9P5/7776dLly7873//4+TJk+pYGguTyUS1atVYvHgxlSpVYsuWLWp4GjhwIKNHj+bgwYOkpqayYMECwDwo8NY/4ufOnSM+Pp4hQ4awcOFCNm3axOuvv46/v79NWPn888/597//zfbt29m6dStDhgyhXbt2aquds7t1CrYzjCPQC+t9lgwGQ767swtt1a1bl507d6IoCsePH6dhw4Zal+T0TCaFy9fNx5ap1za7XssaMiXiXm38xdDyKRMXLN3yChiN0Xh6AobynQYXFQY75xTdQBYWFkaPHj348ssv6dq1q9pdBxAdHU3Tpk0JDQ2lRo0aeHh4MGnSJL7//nuWL1/O888/X+TvX7RoEUajkfnz5xMQEECjRo04e/YszzzzjPoYb29vJkyYoP5cs2ZNtmzZwuLFixk4cCBBQUH4+/uTnZ1NVFRUga81a9YsYmJi+Oijj1AUBX9/f/Ly8hg7dixvvPGG2t/apEkT3nzzTcA83fOjjz7i559/1m2QEcWjKIpNSBfO6datCiTIFO16GuT9PR7GsqpvhnQtlZoEmVtcuArnLlvf4nynaPDgwQwfPpxZs2bZzOgKDw8nPT2dKVOmsGnTJpKSksjLyyMzM7PYf0APHjxI06ZN1VljYDszweLTTz9l7ty5nD59mszMTHJycko8o+ngwYO0adPG5pt227ZtSUtL4+zZs2oAaNKkic3zqlSpwqVLl0r0WlqSIFM6smGkPsieSyVnu6qv+f8tLTI+lbzxDpUteErC+f5KayzKemFcBYzGPDw9vaCcp/PbvG4RevfujclkYsWKFVSuXFm9vWLFiowZM4bVq1fz/vvvU7duXfz9/enfv/9tiwQWpDhN94sXL2bUqFFMnz6dNm3aEBwczHvvvcf27duL/yb+fq1bB4xbXt/69lv31TIYDLpYKMrCuivJ2daRcWayz5I+WAcZ2XOpeG5d1Tc3NY/si+bP6MBa0hpTUhJkbmHdvWMymTh9+pzaTeMs/P39eeihh1i0aBFVq1ZVbw8LC2PDhg3069ePBx98EA8PD9LS0jh16lSxf3fDhg354osvyMzMVNfq2bZtm81jNm3aRNu2bW0WQzx+/LjNY3x8fIrce6Vhw4Z8++23NuFp69atBAcHEx0dXeyanZ20yJSOzFjSB+vVfaVFpnhsN4w0kHHyZrdSgIyPKTHn+essSmTw4MGsWLHCZrZRWFgYtWrVYs2aNfz555/s2bOHRx99tEStF48++igeHh48+eSTHDhwgJUrVzJt2jSbx9SuXZudO3eyZs0ajhw5wrhx4/j9999tHhMbG8vevXs5fPgwV65cyXfa8bPPPktiYiIjRozg0KFD/PTTT4wfP55///vfThUcy6py5crq9HYJMsUnG0bqQ0hIiDoWToJM8dzatZRx2irI1JQgU1Ku89fCzXTp0oWwsDDOnj2r3hYWFsb7779PhQoVaN++Pb1796Z79+63TYcvTFBQEAkJCRw4cIDmzZvzn//8h3fffdfmMf/617946KGHGDRoEK1btyY5Ofm2rSqeeuop6tWrR8uWLalcuTK//fbbba8VHR3NypUr1ener7/+Ok888QSvv/56Cc+GczMYDGqrzOnTp2XmTTFJ15J+WFplLly4oE4+EAW7dO3mZ0BEKGScylR/DqiR/6r1omDStaRTnp6eJCUl8fHHH6uzkcLCwoiNjWXRokU23WHPPfeczXNv7Wq69Q/r3XffbbPWy62P8fX1ZcGCBerUaot33nlHPa5cubK6g3lhr9WpUyd27Njxdzfe6du68X799dfbfod1K5ReVK9enaNHj5KWlkZKSsptG62K20nXkn7UrVuXTZs2AeZxMi1atNC4Iudm27UEmadvBhl/CTIlJi0yOme9hHvFihU1rEQURsbJlJx0LemHzFwqmUK7lqpLkCkpCTI6Zx1krHeiFc7FOsjIzKXika4l/ZAgUzLWQaZyKGScMbfIeAQY8A6XqdclJUFG56w3jJQg47ysp2BLi0zxSNeSfkiQKRlL11JwAPh5QebfQca7qvdtS1KIokmQ0TlpkdEH6VoqOela0o9atWqpf4AlyBTNep+lrAtZKLnmsYPe0dIaUxoSZHROxsjogwSZkrN0LXl7exMcHKxxNaIwvr6+6ka/R44ckZl5hcjNU7h2w3x864wln6oSZEpDgozOWYJMYGAgPj4+GlcjClKtWjX1WIJM8VjvsyTN7c7P0r2Umpqqqy1EHO3K9ZvHt85YkhaZ0pEgo3OWICPdSs7N39+fiIgIQIJMcciGkfpjvcKvbFVQsFunXlvPWJIgUzoSZHRMURR1sK8EGedn6V5KSkrKd6VjcZNsGKk/MuC3eG7dZynDqkXGR4JMqUiQ0bGMjAx1M0gJMs7PEmRMJhPnzp3TuBrnJlOv9UeCTPHYriFjsO1akjEypSJBRocURWH48OE2GyvKQF/nJ1Owi0+mXuuPBJnise5aqhx6s0XGN8IHDz/5k1wactZ0aPXq1SxcuJAZM2aot+mxRSY2NpYPP/xQ6zIcRmYuFZ9Mvdaf6tWrqxMOJMgUzHqfpcoBRrIvZgOyNUFZSJDRoePHj1OlShWbb/glCTKKopCXl1cepYlCSJApPula0h9PT09q164NwLFjxzAajRpX5Jysu5bCMmSPJXuQIKMzQ4YMYcSIEZw5c4bOnTurt2/evJmIiAgCAgIYMGAAv//+u3rfr7/+isFgYM2aNbRs2RJfX182bdqEoihMnTqVuLg4/P39adq0KUuXLrV5vf3799OrVy9CQkIIDg6mQ4cOHD9+HIDff/+dbt26UalSJSpUqECnTp34448/bJ4/fvx4qlevjq+vL1WrVuWFF14A4J577uH06dOMGjUKg8GAp6dneZ0ypyFBpvika0mfLN1L2dnZJCYmalyNc7LuWgpKsdr1WvZYKjUJMjozY8YMJk6cSLVq1Zg2bZp6+4EDB/j888/ZuXMnsbGx9OzZ02axPIAxY8bwzjvvcPDgQZo0acLrr7/OggUL+OSTT9i/fz+jRo3iscceY8OGDQCcO3eOjh074ufnx/r169m1axdPPPGE2ppz48YN/vnPf7Jp0ya2bdtGnTp1iI+P58YN82pPS5cu5YMPPmD27NkcPXqUZcuWcccddwDw3XffUa1aNSZOnMj58+fdYvCrBJnik64lfZJxMkWztMgYDOB1RVpk7MFL6wKczeYuW8m5ZO6zVACj0cgJz9OU93JcPhG+tF/fpsjHVahQgeDgYDw9PW2abh9//HF69uyJyWRi8uTJdO7cmXnz5vHyyy+rj5k4cSLdunUDID09nffff5/169fTpo35dePi4ti8eTOzZ8+mU6dOfPzxx1SoUIGvv/4ab2/zaHrrD6ouXbrY1DZ79mwqVqzIhg0buP/++zlz5gxRUVHce++9eHt7U716dVq1agWYu8I8PT0JDg4mKioKk8nk8pspVq5cGV9fX7KzsyXIFEG6lvTJei2ZI0eOcN9992lYjXOyBJnwEMhKtA0yadzQqCp9kyBzi5xL2WSdz7a5LQ/nHE9i3eJy9913q8fe3t7cddddHDx40ObxLVu2VI8PHDhAVlaWGmwscnJyaN68OQB//vknHTp0UEPMrS5dusQbb7zB+vXruXjxIkajkYyMDPWP9IABA/jwww+Ji4ujR48exMfH07t3b7y83POyMxgMVK9enaNHj3L69GkURZEVawsgXUv6JC0yRbN0Ld26qm9ADX/SjBJkSsM9/6IUwifCVz22tMh4eno6pEWmpKx3vg4NDbW5L78/koGBgeqxyWQCYMWKFTbTuMG8bwqYV6MtzJAhQ7h8+TIffvghNWrUwNfXlzZt2qhr28TExHD48GF++ukn1q1bx7PPPst7773Hhg0bCgxHrq5GjRocPXqUtLQ0rl+/LtPmCyBdS/okQaZw6ZkKGeZ1Hs2r+u42r+pr8DbgV8UPzmpYnI5JkLmFdfeOpbujRo0aeHg433Ai6xaZo0eP0rNnTwByc3PZtWsXI0eOLPC5DRs2xNfXlzNnztCpU6d8H9OkSRM+//xzcnNz8w0emzZtYtasWcTHxwOQmJho8wcIzGHogQce4IEHHuC5556jfv367Nu3jzvvvBMfHx+3m9lw6zgZCTL5kw0j9SkyMpLg4GBu3Lgh2xTkw2YxvAqK2iLjH+OPwVNaZ0vL+f46i2KzDjJTpkxh9erVHDhwgNdee42MjAyefPLJAp8bHBzM6NGjGTVqFJ9//jnHjx9n9+7dfPzxx3z++ecAPP/886SmpvLwww+zc+dOjh49yhdffMHhw4cBqF27Nl988QUHDx5k+/btDB482KYVZ+HChcybN4+//vqLEydO8MUXX+Dv769OG4+NjWXjxo2cO3futgDkqmTAb/HIhpH6ZDAY1FaZU6dOkZ2dXcQz3Iv1jKVov1zy0sxf5GTGUtlIkNExS5Dx9PSkX79+/OMf/6Bly5acOnWKVatWFflt/6233uKNN97gnXfeoUGDBnTv3p2EhARq1qwJmJv0169fT1paGp06daJFixbMmTNHbZ2ZP38+165do3nz5vzjH//ghRdeUDdGBHN315w5c2jXrh1NmjTh559/JiEhQe0qmDhxIqdOnaJWrVpERkaWxylyOhJkiscSZKRbSX8sQcZkMnHixAmNq3Eu1i0y0cYs9dg/VoJMWUjXkg6NHDmSkSNHEhsbC5g/7GfOnMnMmTNtusMs7rnnHhRFue33GAwGXnjhBXVtl/w0adKENWvW5Htf8+bNbdarAejfv7963LdvX/r27Vvg77777rvZs2cPgFvMWgIJMsVhvWGkDPTVn1vHyTRo0EDDapyLdZCpnCVryNiLtMjomKVFRo/bE7grCTJFkxlL+iYDfgtm3bUUmmYVZGIDHF+MC5Ego1O5ubnqwnMSZPQjJiZGPXaHFqjSkCCjbxJkCnb5+s2Wcf/rGTePpUWmTCTI6JT11GuZ+aIffn5+6nggaZHJn/VieDJGRn9uXRRP3GTdteR12bpFRoJMWUiQ0SnrGUvSIqMvlu6lpKQkcnNzNa7G+UiLjL5VqFBBHfQvQcaWdZBRzpuDjFewF96h7rmulr1IkNEp6xYZCTL6YgkyiqK4xR5TJSVBRv8s3UsXLlwgNTVV42qch2WMjJ+Xiewk84D2gFh/WWKgjCTI6JS0yOiXDPgtnHQt6V+9evXU4/3792tYiXOxtMjU88tGyTOPl5HxMWUnQUanJMjolwSZwkmLjP7deeed6vGtSzS4K5NJ4fJ183Ftb5mxZE8SZHTKOsjIYF99kSBTOAky+nfXXXepxxJkzK6nQd7fO7JUV6x2vZYWmTKTIKNT0iKjX9aLFcoU7NtJ15L+NWnSBB8fH0CCjIX1QN8qeTJjyZ4kyOiUDPbVL2mRKZylRUY2jNQvX19fmjZtCsDhw4dJSUnRuCLtWQeZ8AxZ1deeJMjolLTI6FelSpXw8/MDJMjkRzaMdA3W3Uu7du3SsBLnYL2qb8gN6VqypxIFmZycHCZMmEB8fDydOnVi+PDhHDt2DICEhARat25Nhw4d1P9duHBBfe7+/ft55JFHaNeuHcOHD+f8+fPqfVlZWYwbN46OHTvSq1cvVq9ebfO6CQkJ6mtOmDBB1t5AgoyeGQwGtVXmzJkz+e6D5c4sXUvSraRvMk7GlnWLjN9Vc5DxjfLF089To4pcR4mCjNFoJDo6mgULFrB+/Xo6duzISy+9pN7fqlUrNm3apP4vKioKMAegMWPG8PDDD7N+/XoaN27MG2+8oT5v9uzZpKSksHLlSiZPnsyUKVPUsQPHjh3jgw8+YNq0aaxYsYKkpCTmzZtnj/eua9ZBJjQ0VLtCRKlYgkxaWhrXr1/XthgnkpGRQWam+UNeBvrqmwQZW5eumb+w+JqMeKTmADI+xl5KFGT8/f0ZNmwYkZGReHp6MmjQIJKSkor8IN61axf+/v706dMHX19fnnrqKQ4cOKC2yqxcuZLhw4cTFBRE06ZN6dixI2vXrgVg9erVdOvWjYYNGxIUFMSwYcNYtWpV6d6tC7GMkalQoQKenpLo9UbGyeRPZiy5jvr16xMYGAjAjh07NK5Ge5aupagc6/ExMvXaHrzK8uS9e/cSFhamtgjs2bOHrl27EhYWxqBBg+jfvz8AJ06coHbt2urz/P39qVatGidOnCAwMJDk5GSb++vWrasuonTixAnatGmj3lenTh3OnTtHVlaWOs7AWk5ODjk5ObZv0stLHUFfEiaTyeb/nYn1ztfW9TlzzYVxt7qtN488efIkd9xxh13rKoqznu9Lly6px7de2+C8dRdFj3WXtWaDwUCLFi3YuHEjiYmJnD9/Xt1nrDw567m++HcjemTuzSDjV8Pvtnqdre6ilHfdHh5Ft7eUOsikpaUxefJknn32WcC8ANLXX39NVFQUBw4cYPTo0YSHh9O5c2cyMzPVZG4RGBhIZmYmGRkZeHp62oSSwMBAMjLMO4Pe+tygoCD19vyCzIIFC5gzZ47NbQMGDGDgwIGlfaskJiaW+rnlwWQyqUEmMDAw3ym8zlZzcblL3dbX9J49e9QZHo7mbOf7wIED6rG3t3eB09Odre7i0mPdZam5bt26bNy4EYAVK1bQtWtXe5VVJGc714kXIgE/mxaZjMD0265xZ6u7uMqr7po1axb5mFIFmezsbF566SXat29Pnz59AIiOjlbvb9y4MQ8//DC//PILnTt3xt/fn/T0dJvfkZ6ejr+/PwEBARiNRpsWlvT0dAICzE1utz43LS1NvT0/Q4cOZfDgwbZvsgwtMomJicTExBQrFTpKSkqKmn6joqJs1iVx1pqL4m51N2/eXD1OS0uz+W/oCM56vrds2aIe16pV67bz4qx1F0WPdduj5i5dujB37lzA3IXqiOvcWc91yt/5JcZ0M8jE3BlDWA3zgqbOWndRnKHuEgeZvLw8XnvtNSpXrszIkSMLfJz1tMm4uDi+//579efMzEzOnj1LXFwcISEhhIeHc+zYMRo3bgyYd0yNi4tTn2uZGQVw9OhRoqOj822NAfDx8SlVaCmMh4eHU11Y1mOSwsLC8q3N2WouLnepOzY2Vj0+c+aMZu/Z2c639SD2SpUqFVibs9VdXHqsuyw1t27dWj3euXOnQ9+7s53r88nmL5/VlQz1tsDYwNtqdLa6i0vLukv8qm+//TbZ2dmMHz/eJqxs2bJFHYB66NAhvvnmGzp06ABAixYtyMzMJCEhgZycHObNm0fDhg2pUqUKAPHx8cydO5f09HT27dvHxo0b6datGwA9evRg3bp1HDp0iLS0NObPn0/Pnj3L/Mb1TBbD07+YmBi8vb0B2Lp1q0zB/pv1qr4y2Ff/atasqU6j//333932Ok/PVLjxd36JzDHveu3hY8Cviq+GVbmOEgWZ8+fPk5CQwO7du+ncubO6Xszu3bvZvn07AwcOpEOHDrz22ms8/vjjahjx8fFh6tSpLFq0iM6dO7Nnzx4mTpyo/t6nn36aoKAgevTowdixYxk7dqz6jbV27dqMHDmSUaNGER8fT2RkJE888YT9zoAOyRoy+ufr66uOF0hMTJRZHX+TWUuuxWAw0LJlS8D839Zdt+Q4b8nnikLFdHOi8Y/xx+AhCz7aQ4m6lqpUqcLOnTvzva958+aMGjWqwOc2atSIr7/+Ot/7/Pz8mDRpUoHP7d27N7179y5JqS5Ngoxr6N+/v7r449KlS22a4d2VBBnXc9ddd7FmzRrA3Cpj3a3qLixBpoIxF688cxeT7HptP/rriBOy87WL6Nu3r7oG0JIlS9y22d2abBjpelq1aqUeu+vCeJYgE5Vzc3yMbE1gPxJkdEhaZFxDeHg4Xbp0Acy7YMt+NLJhpCuSFX6tgkyu7HpdHiTI6JAM9nUdAwYMUI+XLFmiYSXOQTaMdD1RUVFUq1YNMK/yrrcF3+wh6Yq5tdV6DRlpkbEfCTI6JC0yrsO6e2np0qVu370kG0a6JkurzI0bNzh8+LDG1TjeecuqvtbbE8gYGbuRIKNDEmRcR+XKlbnnnnsA83Ycu3fv1rYgDcmGka7L3buX8u1aqiEtMvYiQUaHZLCva7HuXlq6dKmGlWhLZiy5Lgky5v+3BBnvUC+8K3hrWJFrkSCjQ5YxMn5+fgVu1SD048EHH1RXxHTn2UsyY8l1WdaSAfcNMp6Kicp/L4bnX0O6lexJgowOWe98LfQvIiKCTp06AXDs2DH27t2rcUXauHz5snosLTKuJTQ0lDp16gDw559/kpOTo3FFjpOdo3A1FSrnZql/cKVbyb4kyOiQBBnX079/f/XYXWcvnT9/Xj2OiorSsBJRHizdS9nZ2fz1118aV+M4F/4eCWA9Y0mCjH1JkNGZzMxMdUCkBBnX8dBDD6nTjd21e+nChQvqsWUfNuE63HWcTNLfQ7+sZyxJ15J9SZDRGes1ZGSgr+uIiopSN1k9cuSIW31jtbAOMtIi43rcNcjIjKXyJ0FGZ2QxPNfl7rOXpGvJtTVv3lxdM8kdg0ykdC2VGwkyOiNryLiuW7uX3I20yLi2gIAAGjduDMBff/1Fenq6xhU5xvnkv1f1tbTIGMCvmgQZe5IgozMSZFxX1apVadeuHQAHDx7kwIEDGlfkWJYgExwcTGBgoMbViPJg6V4ymUxus/jjzQ0jzUHGr4ofnr7yp9ee5GzqjCyG59rcefaSpWtJBvq6LnccJ3M+GfyNeVQw5gKyWWR5kCCjM9Ii49r69eunHrvTOJmMjAxSU1MB6VZyZe4YZJKSITJXNossTxJkdEYG+7q2atWq0aZNG8A8juDQoUMaV+QYMj7GPTRu3Bg/Pz/AfYLM+eRb1pCRFhm7kyCjM9Ii4/rccfaSrCHjHry9vWnWrBlgXsXa+ouZK8rLU7h8/ZYgU13WkLE3CTI6I2NkXJ9195K7jJORFhn3Yd29tHPnTg0rKX8Xr4Gi3NK1JFOv7U6CjM5cunRJPY6IiNCwElFeqlevTuvWrQHYu3cvR44c0bii8idryLgPdxonI2vIOIYEGZ2xfHMNDAwkKChI42pEebGevfTDDz9oWIljSNeS+7AOMqtWrSIvL0/DasrXrav6evh64Bvpq2FFrkmCjM5YPvDlW6tr6927t3q8evVqDStxDGmRcR9169ZVw+rmzZt59NFHyc3N1biq8nE+GVAUtUXGP8Yfg4dB26JckAQZHcnOzlYHx8mHvWurW7cuNWvWBGDTpk3cuHFD44rKl7TIuA8PDw/mzZuHj48PYB4H9vDDD5OTk6NxZfaXdEUh1JiDn2ICZMZSeZEgoyMXL15UjyXIuDaDwUCPHj0AyM3N5ZdfftG4ovJlCTKenp6Eh4drXI0obz179mTZsmX4+pq7Wb777jsGDhzocmHm1qnXsoZM+ZAgoyMys8O99OzZUz1etWqVhpWUP0vXUkREhLqxoHBtPXv2ZPny5eq6Mj/88AP9+vUjOztb48rs53zyLQN9Y2XqdXmQIKMjEmTcS5cuXdTm91WrVqEoisYVlQ+TyaS2Nkq3knu57777+PHHH/H3N7dU/Pjjjzz44INkZWVpXJl9nL9qtVkkECAtMuVCgoyOSJBxL4GBgXTs2BGA06dPu+wqv1euXMFoNAJyXbujrl27snLlSgICzK0Vq1atom/fvmRmZhbxTOd3W9eSTL0uFxJkdESCjPuxjJMB1529JAN9xT333MOqVavUXc/XrFnDAw88QEZGhsaVlZ7JpHDhqu1ieDLYt3xIkNERCTLuxx3Gych1LQA6duzImjVr1PWx1q1bx4MPPqjbMTOXr4PReLNFxjvUC+8Qb22LclESZHREPvDdT4MGDahevToAGzZsID09XeOK7E/WkBEW7dq1Y+3atQQHBwOwdu1aBg4cqMt1Zs4ng6diolKuebyPfw0Z6FteJMjoiHWQke0J3IP1NOycnBx+/fVXbQsqB9K1JKy1adPGZszM8uXLGTx4sO5WAD6fDJVzs7DMwZOtCcqPBBkdsXzgh4eHq7NZhOtz9e4laZERt2rfvj0JCQnq1OwlS5YwdOhQdVC4Htw60FeCTPmRIKMTiqLI9gRuqmvXrnh7m/vWXXEatnSZivx06dKF77//Xr32//e///Gvf/0Lk8mkcWXFc+saMtK1VH4kyOjEjRs31OmI8mHvXoKDg2nfvj0AJ06c4OjRoxpXZF8SZERBevToweLFi9VFEufOncuLL76oizB/PlmxXUNGWmTKjQQZnZDmd/fmytOwLdd2cHCwOv1WCIu+ffuyaNEiPDzMf64++ugjxowZ4/Rh5rYWGVkMr9xIkNEJ+dbq3lx5nIzl2paBvqIggwYNYsGCBRgM5p2jp02bxqRJkzSuqnBJyVar+hrMO1+L8iFBRickyLi3xo0bEx0dDcCvv/7qEqueAmRkZJCamgrIdS0K9/jjj/Ppp5+qP0+YMIHLly9rWFHhrAf7+lXxw9NX/tyWFzmzOiFBxr0ZDAa1VSYrK4sNGzZoXJF9yHUtSmL48OE8++yzABiNRn777TeNK8qfoihcu5RHBaN5/RvZmqB8SZDRCfnAF9bjZFyle0nWkBEldd9996nHzhpkrt2Aihky0NdRShRkcnJymDBhAvHx8XTq1Inhw4dz7NgxABISEnj00Ufp2LEjffr0YenSpTbPbdmyJe3bt6dDhw506NCB+fPnq/dlZWUxbtw4OnbsSK9evW4bzJiQkKC+5oQJE3S5ymNZSZAR9957L15eXoDrBBkZxC5Kqk2bNuqxswaZ88lQRdaQcZgSBRmj0Uh0dDQLFixg/fr1dOzYkZdeegkwh5xXX32V9evX8/777/PZZ5/xxx9/2Dx/2bJlbNq0iU2bNvHEE0+ot8+ePZuUlBRWrlzJ5MmTmTJlCqdPnwbg2LFjfPDBB0ybNo0VK1aQlJTEvHnzyvq+dUeCjKhQoQJt27YF4OjRoxw/flzjispOrmtRUhEREdSpUweAXbt2kZWVpXFFtzuffMtmkbKGTLkqUZDx9/dn2LBhREZG4unpyaBBg0hKSuL69ev069ePO+64Ay8vL2rVqkWrVq04cOBAsX7vypUrGT58OEFBQTRt2pSOHTuydu1awDzVtFu3bjRs2JCgoCCGDRvmMt9GS8Lyge/l5UVYWJjG1QitWM9ecoVp2NYtMtK1JIqrXbt2gPkL9K5duzSu5nZJV2xX9ZUxMuXLqyxP3rt3L2FhYYSGhtrcbjQa2b9/P/Hx8Ta3P/bYYxgMBlq3bs3IkSMJDQ0lNTWV5ORkateurT6ubt267N+/HzAvAGbdlFinTh3OnTtHVlaWuny1tZycHHJycmzfpJdXqZb0t6wg6QwrSVqCTGRkJFBwTc5Uc0lI3cVz33338eqrrwLmLwDPPPNMqX6Ps5xv6yATERFRZD3OUndJ6bFuZ665TZs2LFy4EIDNmzfb/I1whrqTrtiuIeMX4yvXdilZ1g8qTKmDTFpaGpMnT1ZHkFv75JNPqFy5ss3FNWfOHO644w5u3LjBu+++y8SJE3n//ffJyMjA09PTJpQEBgaSkZEBQGZmps0iWZYt3jMzM/MNMgsWLGDOnDk2tw0YMICBAweW9q2SmJhY6ufag9Fo5NKlSwBUrFhR7XYrjNY1l5bUXbjQ0FAiIiK4dOkS69ev58iRI/j6+pb692l9vk+ePKke5+XlFevaBu3rLi091u2MNcfGxqrH69aty/fzXcu6D5+qyF1/dy0p3gYuZF3AcNpQrOc64/kujvKqu2bNmkU+plRBJjs7m5deeon27dvTp08fm/uWLl3K+vXrmT9/vrp4EUDz5s0B8x/i0aNH06tXL3JzcwkICMBoNNq0sKSnp6s7n/r7+5Oenq7+nrS0NPX2/AwdOpTBgwfbvskytMgkJiYSExNTrFRYXi5evKim3erVq1OjRo0CH+ssNZeU1F188fHxLFy4kKysLE6dOmUzi6O4nOV8p6SkAODp6UmzZs3UpegL4ix1l5Qe63bmmmNiYqhYsSLXrl3jzz//pHr16urfG2eoOz1HUbuWfKL9ia0ZW+RznKHu0nCGukscZPLy8njttdeoXLkyI0eOtLlv7dq1aovIrd1N1ixvVlEUQkJCCA8P59ixYzRu3BiAI0eOEBcXB0BcXJw6MwrMgxyjo6PzbY0B8PHxsfvO0B4eHppeWJbWGDCPIyhOLVrXXFpSd9F69uypNquvXbvWZlp2SWl9vi1dphEREermgMWhdd2lpce6nbFmDw8P2rZty4oVK7hy5QrHjh2jXr16tz1Gq7pTz2Xip5i/fAbX9C9RHc54votDy7pL/Kpvv/022dnZjB8/3qbFZdu2bbz33nt8+OGHVK1a1eY5x48f58iRIxiNRlJTU5k+fTqtW7dWA0d8fDxz584lPT2dffv2sXHjRrp16waY185Yt24dhw4dIi0tjfnz59sMeHQHstaGsNatWzf1A2PlypVOv+dMQYxGIxcvXgTkuhYlZxnwC7BlyxYNK7ldXtLN8TFBNWXGUnkrUZA5f/48CQkJ7N69m86dO6trwuzevZsFCxaQmprKE088od4+efJkAK5evcrYsWPp1KkTAwYMwMPDg/Hjx6u/9+mnnyYoKIgePXowduxYxo4dq/aB1q5dm5EjRzJq1Cji4+OJjIy0mbrtDmSKqrBWsWJFdRr24cOH+e677zSuqHSSk5MxGo2AXNei5KyDjDOtJ6MoCp6XZQ0ZRypR11KVKlXYuXNnvvfNnj27wOfdddddhX7Y+vn5FboBWO/evendu3fxC3UxEmTErV5++WU2b96sHvfq1avA7lZnJde1KIuWLVvi5eVFXl6eUwWZGxlQMV3WkHEk/XXEuSH5wBe36t27N127dgXMM39mzJihcUUlJ2vIiLIICAjgzjvvBODQoUMkJydrXJGZ9WaRIGvIOIIEGR2QICNuZTAY+OCDD9SxMm+//bbNdaIHcl2LsnLGcTK3r+orQaa8SZDRAesPfMuCeELccccdDB8+HIAbN27w+uuva1xRycggdlFWThtk/m6RMQZ44V2h+LPxROlIkNEBywd+UFCQuiCgEAATJ04kJCQEgPnz57N7926NKyo+2TBSlJVl0Ds4z4Df85dMVM79e/+nSGmNcQQJMjpgCTLyYS9uVblyZd544w3APFti1KhRupmOLV1LoqyqVKmirvz6+++/37Y9jRauncjEsqyjT4wM9HUECTJOLisri+vXrwPyYS/yN2LECHWvsg0bNvD9999rXFHxSIuMsAdL91JWVhZ//PGHxtVAxqmb42OCa0qLjCNIkHFylgXDQD7sRf58fHyYPn26+vPo0aPJysrSsKLisbTIBAcH2+ynJkRJONt6MtaL4YXXlSDjCBJknJw0v4vi0ON0bOkyFfZgPU7GGQb8Wi+GV7GOBBlHkCDj5CTIiOIwGAy8//77upmOnZGRQWpqKiAzlkTZNGrUSB3w/ttvv2k+RizwuiyG52gSZJycBBlRXE2aNOGpp54CzNOxx40bp3FFBZPrWtiLp6cnbdq0Acxd8SdOnNCslsxshbBMc5BRAP8YaZFxBAkyTk4+8EVJWE/HnjdvHn/++ae2BRVAVvUV9uQs42Ss15DJCPLF01f+xDqCnGUnJ0FGlERERITNdOwpU6ZoXFH+5LoW9uQsC+OdS8wj1JgLQE6YtMY4igQZJycf+KKkRowYQVhYGAArV650irU1biXXtbCnVq1a4elpXr1l69atmtVx8eDN8TFEyfgYR5Eg4+SsP/AjIiI0rETohY+PD/Hx8YB5rMzGjRs1ruh20rUk7CkoKIimTZsCsH//fnUguaOlHLsZZHyqSYuMo0iQcXKWIFOpUiW8vWXPDlE8vXv3Vo8TEhI0rCR/0iIj7M3SvaQoimYL42WcyVCPQ+IkyDiKBBknpiiKrLUhSqV79+54eXkBsHz5cs2npN5KWmSEvVmPk9m1a5cmNRitFsOrVF+CjKNIkHFiqamp6gqtEmRESVSoUIF77rkHgFOnTrF//35tC7qFJaB7enoSHh6ucTXCFVgvjKdVkPGyWgwvupEEGUeRIOPEpPldlIUzdy9Zru2IiAh1kKYQZRETE0NMTAwAf/75J7m5uQ6vISDFHGRyDB5E1PJ1+Ou7KwkyTkyCjCgL6yCzfPlyDSuxZTQa1T3EpFtJ2JP1BpJ79uxx6GsrikLFdHOQuervh4en/Hl1FDnTTkyCjCiLmjVr0qhRIwC2b9/OpUuXNK7ILDk5GaPRCMh1LexLy/Vk0s5n42symY9DpFvJkSTIODEJMqKsHnjgAcD8bXHFihUaV2NmPdBXrmthT9bjZBy9wu+5v26Oj8kJlyDjSBJknJgEGVFWzti9ZH1dS9eSsKcmTZoQGBgImFtkHDlb75LVYniGKAkyjuSldQGiYBJkRFm1atWKypUrc/nyZdauXUtWVhZ+fn6a1iTXtSgvXl5eTJ48GYA+ffpgMBgc9topB9OxDFv3jZFVfR1JWmScmHzgi7Ly9PTk/vvvByAjI4NffvlF44pkDRlRvp5//nl69+6tzmBylNw/rqrHQc0qOPS13Z0EGSdmCTLe3t5UrFhR42qEXjlb95IEdOFqrl/MxftECgCJPoHE3aFtq6e7kSDjxCwf+JGRkXh4yH8qUTrdunXDx8cHgB9//FHzVX5lsK9wNR++eRXPv/9dXaoRRvsmGhfkZuSvo5MyGo3qdFn5sBdlERQURJcuXQA4e/Ysf/75p6b1SIuMcCU//a5w/udk9efez4fj4eG4sTlCgozTunz5Mqa/1ySQD3tRVpZp2KD9Kr+WIBMcHKzOMBFCj1LSFJ58V6FZunl8jGKARg+EaVyV+5Eg46TkW6uwJ8uAX9B+nIyla0mua6F3//5IIf1cFjWy0wEIbVEB7xBvjatyPxJknJQEGWFPMTExNGvWDDBvqJeUlKRJHenp6dy4cQOQGUtC31ZsVZi/Epqm35ytVLmTbICqBQkyTkoWDRP2Zt299OOPP2pSgwR04Qqupio8NdU8uLdZ2s0gEy5BRhMSZJyUfOALe3OG3bAloAtX8MIMhfPJgKJwd645yHgGeBLaMlTTutyVBBknJUFG2Nudd96phof169eTmZlZxDPsT65roXffb1RY9JP5uIFXBkEZ2QCEtamIp6/8SdWCnHUnJR/4wt48PDzUQb9ZWVkO31QPZA0Zob1FaxWuppZuLaXL1xWennbzueObS7eSM5Ag46Ssg0xkZKSGlQhXYj1OZt26dQ5/felaElrac0zhsUkKNQcpTFigkJJW/EBz+oLCY28pXL5u/vmBdhB36eb6MZU6yrRrrUiQcVKy1oYoD127dsXf37wz7/r169W1ihxFWmSEliYuVPA1GalyOYXxCxTiHlZ4d5FCembBgebgKYV/vm2i9iMKa3833xYWAp+OVLi6+RoAPuHeBDcKdsRbEPmQIOOkLEFGPuyFPfn7+3PvvfcCcOXKFbZs2eLQ15cuU6GlSS2v8sX5rUw88wcVc7O5mgpjZ5sDzYwlClnZNwPN7wcVHvqPiUb/VPi/NZBnNN8e6A//e92A35kb5N3IAyC8YzgGWc1XMxJknFBmZiYpKeYNyOTDXthbv3791OP33nvPoa9tCTKenp5UqlTJoa8tRM6a8wRezyTImMc7yiEsW9hdugYjZyrUftTcQtPt3yZaPa3w/SawbE1WMRjeHAKnFxvoebeB5A1W3UoyPkZTEmSc0MWLF9VjCTLC3h5++GGqVasGmNeTcdTeS4mJiRw8eBAwX9eenp4OeV0hLBq8XQ+fSuYNVGOOXmL745cY2Pnm/ecum1to1u28eVuVcJj2rIHTSwyMf8KD8ArmlpcrG28GGRnoq60SBZmcnBwmTJhAfHw8nTp1Yvjw4Rw7dky9f+HChdx777106dKFGTNm2Oyyu3//fh555BHatWvH8OHDbfrKs7KyGDduHB07dqRXr16sXr3a5nUTEhLU15wwYQK5ubmlfb+6IM3vojz5+voyZswY9edJkyY55HVHjRqlTvnu37+/Q15TCGs+YT40nFxf/Tll2iH+928jf8438EA728fGVYXZow2c/MbASw8bCA642XWUl57HtR3XAQio6U9AdX9HlC8KUKIgYzQaiY6OZsGCBaxfv56OHTvy0ksvAbB582aWLl3KwoULWbx4MZs3b1b3dMnJyWHMmDE8/PDDrF+/nsaNG/PGG2+ov3f27NmkpKSwcuVKJk+ezJQpUzh9+jQAx44d44MPPmDatGmsWLGCpKQk5s2bZ6/375QkyIjy9sQTT1C5cmUAvv32W/bv31+ur7dq1Sq+/fZbACIiIhg/fny5vp4QBanyUBSV7zNf+9kXszk0/ghNaxv44R0Ptn9q4N8D4as3DRz+n4HhDxjw9bl97Mu1bddQcs1f1KU1RnslCjL+/v4MGzaMyMhIPD09GTRoEElJSVy/fp2VK1fSv39/qlWrRqVKlXjsscdYtWoVYN7bxd/fnz59+uDr68tTTz3FgQMH1FaZlStXMnz4cIKCgmjatCkdO3Zk7dq1AKxevZpu3brRsGFDgoKCGDZsmPp7XZUEGVHe/P39eeqpp9Sf33777XJ7raysLEaMGKH+PH36dEJDQ8vt9YQojMFgoPF7DfAMNHdtJv7fWZI3m9eDadXQwPTnPXi4qwEvr4IH717ZcHP9GBkfoz2vsjx57969hIWFERoaysmTJ4mPj1fvq1u3Lh9//DEAJ06coHbt2up9/v7+VKtWjRMnThAYGEhycrLN/XXr1lW/IZ44cYI2bdqo99WpU4dz586RlZWFn5/fbTXl5OSQk5Nj+ya9vPDx8Snx+7NMTdVyimpERESJXl+rmstK6nYsk8nEo48+ymeffcaVK1f45ptveOONN6hbt67dX2vKlCkcP34cgE6dOvHII4+U+nzp+Xxb/78e6LFmKF7dvlV9qTuuDgfHHgJg38i/aLehDZ7+xRu3deXXK+YDA1RsG2qXc+TK57ssPDyKbm8pdZBJS0tj8uTJPPvsswBkZGQQFBSk3h8YGEhGRgZgnoVz61oogYGBZGZmkpGRgaenp00oKey5ltfIzMzMN8gsWLCAOXPm2Nw2YMAABg4cWNq3SmJiYqmfWxpHjx5VjxVFUbvZSsLRNduL1O04AQEBDBkyhGnTpmEymXj99dftPovp1KlTvPPOO4D5C8Wrr77KmTNnyvx79Xi+QZ9167FmKLpupYuCfxM/MvdmkXEykz/e2E3E85WL/L15V/O4sT8NAL/6vpy/cR5u2KVkwHXPd2nVrFmzyMeUKshkZ2fz0ksv0b59e/r06QOYPxTT0tLUx6SnpxMQEACYW2DS09Ntfkd6ejr+/v4EBARgNBptWlgKe67lNSyLet1q6NChDB482PZNlqFFJjExkZiYmGKlQnuxfr/NmzenatWqxX6uVjWXldTtWJa6X331VebNm8e1a9dYtmwZ7777brE+OIpDURSeeeYZtYV01KhRdOvWrUy/U+/nW09167FmKFndlWZV4rcu21ByFK5+cZ16/6hLSJOQQp9z/g+r1anvrUKNGjUcXrczcYa6Sxxk8vLyeO2116hcuTIjR45Ub69ZsybHjh2jffv2ABw5coS4uDgA4uLi+P7779XHZmZmcvbsWeLi4ggJCSE8PJxjx47RuHHjfJ9rPTPq6NGjREdH59saA+Dj41Oq0FIYDw8Ph/4Hsky/NhgMREZGluq1HV2zvUjdjhUaGsqLL77I+PHjMRqNTJ06ldmzZ9vld3/33XesWbMGgGrVqvHGG2/Y7Rzp9XzrsW491gzFqzukQQi1/x3H0SnHUYwKf/37IG3XtsbDq+DnJW+8OT6m8j2V7H5uXPl8l9trl/QJb7/9NtnZ2YwfPx6D4eZgqPj4eL799lvOnTvHlStXWLRoET179gSgRYsWZGZmkpCQQE5ODvPmzaNhw4bqXivx8fHMnTuX9PR09u3bx8aNG9Vvbj169GDdunUcOnSItLQ05s+fr/5eV2UZ7FupUiW8vb01rka4uhdeeIHgYPPy6gsWLLBLE3FaWhovvvii+vOMGTNsup6FcBa1XowjqL752kzdk8qpTwruylcURV0Iz8PXg4qtQx1RoihCiYLM+fPnSUhIYPfu3XTu3JkOHTrQoUMHdu/eTfv27XnooYd4/PHHGTBgAO3atVM3qPPx8WHq1KksWrSIzp07s2fPHiZOnKj+3qeffpqgoCB69OjB2LFjGTt2LLGxsQDUrl2bkSNHMmrUKOLj44mMjOSJJ56w3xlwMoqiyPYEwqEqVqyozirKzc21yziZiRMncvbsWcD8ZeTBBx8s8+8Uojx4+Hhwx4eN4O/v5UemHCP9RHq+j804lUlmYhYAFVuFFntwsChfBsV61Tphw2Qycfr0aWrUqOGwJrPr169TsWJFALp166ZOQy8uLWq2B6nbsW6t+8qVK9SoUYOMjAz8/Pw4efJkqYP0/v37adasGXl5efj6+vLXX3/ZzEq0Z916oce69VgzlL7uA68d5NRs80B030hfIu6rRHincCp1DMcn3Dxc4czCRP566QAAdV+vQ+1RcZrXrTVnqLtM06+F/ckaMkILlSpV4plnnmH69OlkZWUxbdo0pk2bZvMYk8nE/v372bhxI2fOnCEwMJDAwECCgoJs/v+tt94iL8+8md6rr75qtxAjRHmq+1odLq68RGZiFtkXs0n84hyJX5wDA4Q0CaFSxzCu7UxRHy/rxzgPCTJORoKM0Mro0aP5+OOPycrK4pNPPmH06NGcPXuWjRs3snHjRjZt2sTVq1eL/kV/q1WrFq+88ko5ViyE/XgFeXHX4hYc+M8hrv52DVP23+uiKOaxM6l7Um8+toIXFZoWPrtJOI4EGSdj2dYBsNu0PiGKIyoqiqeeeoqZM2eSkZFBtWrVMBqNpf59M2fOLHB2oRDOKKhuEK2WtMSYYeTq9mtc+TWZK78mc+Mv24ViKneuhMGz4JV/hWNJkHEiV69e5bPPPgPAz8+PAQMGaFyRcDdjxoxh9uzZ5OTk3BZiwsPD6dChAx07dqRJkyZkZ2eTlpZGenq6zf9nZGTQrl07l59dKFyXZ4AnlTtXonLnSgBkX84meeNVrvyajDHbSP037b8Ctig9CTJO5JNPPlEXw3viiSeIiIjQuCLhbqpVq8aECRN47bXXiIqKolOnTnTs2JGOHTvSoEEDXQ1CFMJefCv7UrVfFar2q6J1KSIfEmScRGZmJjNmzADMCwtZdhUXwtHGjh3L6NGj8fT0tFkrSgghnJEEGSexcOFCLl++DJj3hrKsbCyEFry85KNBCKEP0k7sBIxGo81UV5npIYQQQhSPBBkn8O2333LixAnAvAhe8+bNNa5ICCGE0AcJMhpTFIV3331X/XnMmDEaViOEEELoiwQZjf3888/88ccfANx555107dpV44qEEEII/ZAgo7GpU6eqx6+88orMEhFCCCFKQIKMhv744w9++uknAOLi4njooYc0rkgIIYTQFwkyGrJujRk9erRMeRVCCCFKSIKMRk6cOMGSJUsAiIiIYMiQIdoWJIQQQuiQBBmNTJ8+HZPJvLvqCy+8gL+/v8YVCSGEEPojQUYDly5dYv78+QAEBgbyzDPPaFyREEIIoU8yKKMcHDp0iLlz55KcnAygzkQyGAwYDAaOHj1KVlYWAMOHDycsLEyzWoUQQgg9kyBjR4cOHeKtt97iq6++QlGUIh/v5eXFqFGjHFCZEEII4ZokyNjB4cOH1QBjGfdSHC+++CIxMTHlWJkQQgjh2iTIlMGRI0d46623+PLLL20CTKVKlXj55Zfp3bu3epuiKOr/wDw2JjY21tElCyGEEC5FgkwpHD16lLfeeotFixbZBJjw8HBefvllnnvuOYKCgjSsUAghhHAPEmRK4bvvvuOLL75Qfw4PD2f06NE8//zzEmCEEEIIB5Lp16Xw3HPPUalSJcLCwpg8eTInT55k7NixEmKEEEIIB5MWmVIICgoiISGBRo0aERwcrHU5QgghhNuSIFNKd999t9YlCCGEEG5PupaEEEIIoVsSZIQQQgihWxJkhBBCCKFbEmSEEEIIoVsSZIQQQgihWxJkhBBCCKFbEmSEEEIIoVsSZIQQQgihWxJkhBBCCKFbEmSEEEIIoVsSZIQQQgihWxJkhBBCCKFbEmSEEEIIoVsGRVEUrYsQQgghhCgNaZERQgghhG5JkBFCCCGEbkmQEUIIIYRuSZARQgghhG5JkBFCCCGEbkmQEUIIIYRuSZARQgghhG5JkBFCCCGEbkmQEUIIIYRuSZARQgghhG5JkBFCCCGEbrltkDl06BB79uzh+vXrAJhMJm0LKqZdu3YxatQofv31V61LKZGTJ09y6tQpsrKyAH2c7/3797NhwwZOnz4N6KNmkGvb0fR4bYNc346mx+tbL9e2l9YFOFpOTg5vvvkm27dvp379+ly9epVx48bRqFEjrUsrkKIoKIrC7NmzWbJkCUOGDKF27dooioLBYNC6vEJdv36diRMncvToUapWrUpISAgvvfQSUVFRTlt/ZmYmb775Jn/88QfNmzdn586dzJo1iwYNGjhtzSDXtqPp8doGub4dSa/Xt96ubbdrkTl58iQpKSn8+OOPfPjhh7Rp04bJkydz7NgxrUsrkMFgICcnh2PHjjFr1iwef/xxqlWr5nQX062uXr3KW2+9RXBwMAkJCYwaNYrAwEDmzZsH4LT1b9myhZycHNatW8d7773H/fffz/Tp0wHnrRnk2nYkvV7bINe3I+nx+tbjte12QWb37t1cv36dgIAAfHx8ePHFF6lcuTKrVq3i2rVrWpdXoD///JOUlBTq16/P8uXLeeaZZ5g+fTqbN2/WurQCeXh40LFjR5555hkA6tatS7NmzfDy8kJRFI2ru52lpv3793P16lX19rZt21KnTh31fmesHeTadiS9Xdsg17dW9HZ96/Hadukgs3//fqZOncp3333HuXPnAGjWrBkAp06dUh/32GOPsXPnTvUxWsuv7lq1apGamsqsWbNYtmwZffr0wdfXlxkzZrBlyxanuMBOnTrFX3/9pf4cEhLCvffeqzZHenh4cOXKFS5fvuw0qd66ZqPRCMB9991HRkYG69atY/fu3UyaNInz58/z3nvvkZWV5RS1y7XtWHq8tkGub0fT4/Wt12vbmssGmTVr1vDss8/i6+tLQkIC06ZNY8eOHdSoUYM6deqwdu1a9bEtW7YkODiYNWvWANp+I7m17unTp7N161YqV65Mq1atWLt2LU899RQ9evTg+eefp127dvzyyy8YDAbN6s7Ly2PGjBk8+uijzJgxg/T0dPW+wMBA4OY5TUxMpG3btur9Wg0ey69mLy/zkLH69eszevRotm/fzvPPP0+fPn0YMWIEBw4cUJvgnekakWu7/Ojx2ga5vrWgt+tbr9d2flw2yGzdupWnnnqKF198kXfeeYdmzZoxdepU/P39ufPOOzl69Cg7duxQH3/vvfdy6NAhzQcy3Vp306ZN1Q+Xxo0bc/nyZa5cuaI+vkOHDvzyyy9kZGRoVvfRo0dJSUnh2WefJSoqiiVLlgC2famWfxAXL16kevXq6u1a/YMoqGZLPXfffTeRkZEMHDiQ4cOHU6tWLUaNGsWaNWtIT093qmtEru3yo8drG+T6doa6nf361uu1nR+XDDJ5eXl4eXmRl5cHQFRUFAMGDCAgIIDZs2dz//33Ex0dzZw5c0hOTgbgyJEj3H333Zr+Qyis7k8++YQePXrwwAMP8PXXX6v/IE6cOMG9995LQECAZnVXqVKFxx9/nL59+9KiRQt27NjBqVOnMBgM6gXv6elJSkoKmZmZNG/enM2bN9O2bVu+/PJLp6rZw8MDo9GI0WgkKyvLpu/9wIEDdOrUSf1mqwW5th1Lj9d2YXXL9e34up31+tbrtZ0flwgytzbLeXl5YTAYSElJIS0tDYCAgAD+9a9/sXz5cm7cuMHw4cMJDAzk5Zdf5tFHH2XDhg20atXKaev+8ccfuX79Oi+++CKRkZG89tprPP744yxYsIB7771X07pDQ0OJjY0lKCiIZs2aER0dzeLFiwHzwDGL33//nWvXrjF06FAmT57MG2+8weOPP+50NXt6euLp6ckdd9xBUlISL730EsOHD+d///sfvXv3xtfX1yE151e3XNuOrVsP13ZJ63am6/tWerm+S1K3M13f1vRybReLolO5ubnKhQsXbrvdaDQqiqIoO3fuVPr166f89ddfislkUhRFUa5cuaKMHj1aWbVqlaIoipKTk6McP35cWbNmja7qzs3NVc6cOaP89NNPmtedn/Xr1yvPPPOMsnXrVpvbV61apbRr106ZO3dueZR4G3vUfPr0aWXp0qXKN998Ux4l5is3N1c5efLkbbfr4doua91aXdv51Z0fZ7m2FcU+dWtxfVv+21v+38LZr2971O3o67ugmvPjTNd2SelyQbzFixczd+5catasSYMGDejVqxd16tTBZDKpSbJFixbUq1ePxYsX89RTT1GtWjVCQ0M5f/48ISEhgPmbSVxcHHFxcbqq22AwEBMTQ0xMjNPUDah91A0bNqRBgwasWbOGu+++m3Xr1tGsWTNat27N2rVrHdKUao+aGzRoQPXq1W36hsvbkiVL+PTTT4mOjqZWrVr06tWLli1bOv21ba+6HX1tF6ducK5r2151a3F9f/vtt6xfv56XXnqJuLg4m3qd+fq2V92OvL4Lq9mas13bpaG7rqXff/+d5cuXM2vWLF566SXS0tKYOXMmly5dwsPDA5PJpPbvjRgxgmvXrjFnzhz279/P7t27MZlMVKpUCSDf/6h6qNvT09Op6raw9FFHRkbSo0cPDhw4QKtWrfi///s/TCYTFStWdMg/BnvV7OixAqdOnWLFihX897//5a233qJChQp88MEHnDt3Th3b4IzXtj3rduS1XZy6LZzl2rZn3Y68vnNycpg/fz7z5s3DZDKpA0tvvU6d7fq2d92OuL6LW7OFM13bpaZpe1AJWJrvlixZoowePVq9/dChQ8o//vEPZerUqfk+/siRI8r06dOVYcOGKffdd5/yww8/OK5oxX3qtpaamqr0799f6datm7JixYpyr9VCjzVb27Vrl9K3b18lMzNTURRFuXHjhjJu3Djl2WeftXmcs1wjFq5etzU9XSfWtK47MzNT2bBhg7J161Zl48aNyrPPPqts3rxZUZSb14WFM10neqy7JDVb0/oaKQunDzLr1q1TTp48qeTm5iqKoijz5s1TXn/9dSUtLU1RFEXJyspSBgwYoPTp00fZt2+foij59wcWd6yEvbhz3YcOHVI++eQTqbkIS5YsUbZu3arcuHFDURRF2bJli/LKK6/YjHtISkpS7r33XmXLli2KouT/QeToa8Sd69brdeIMdaempiqKoijXr19XZs2apbz88stqnYWN4dD6OtFD3faoWYtrxF4MiuIEy2bmY9WqVXz44YdER0djNBqJiIjgvffe4+LFi4waNYp27drRq1cv/vrrL3777TeioqIIDAxk2LBhNr9HcfDaAu5etyPpsWaAH3/8kZkzZ1K3bl0MBgM3btxgwYIFXL16lRdeeIF//OMfdOvWTW0K/vTTTzlx4gRTp061+T2OvkbcvW5Hc5W609LS+Oyzz2y6snbv3s0XX3xBu3bt6NevH0aj8bZuF62vEz3Uba+adU+7DFWw7du3K4899pg6ejopKUlp06aN8vvvvyuKYh5dPWHCBGXIkCHKww8/rOzbt0/58MMPlUWLFimKUrwR2lK3vuvWY82Koijbtm1TnnnmGfWb88WLF5WuXbsqBw8eVBRFUT799FNl+PDhSmJiovqcpUuXKmPHjlVbmLQgdTuWq9V95MgRRVEUtdU0PT1dWbRokfLcc88p6enpiqIoSkpKiqIo2vzb1GPdeqy5vDjlrKW6devSq1cv7r77bnJzc6lSpQrdunXj0KFDtGzZks6dO9O5c2fOnj1LtWrVAHMytdBqYSSpW2ouSosWLYiNjSUyMpLr168zfvx4PD09OXPmDPXr1+fpp5/m6aefZvny5XTv3p1atWphNBrx8vJSlw2XuqVuvdV9+vRp6tSpo7YUBAQE0KZNG06fPs1///tfkpOTiYqK4t///rcm/zb1WLceay4vTtu1dKt//OMfDBs2jE6dOqlNY5bVKT/77DM2bNjABx98QM2aNbUu1YbU7Th6qjklJYVJkybh7+/P/fffz549ezCZTAwePJjExES++eYb9u/fT/PmzVm5ciWvvvoqvXr10nwZdqlb6i5t3QaDge7du6tTj/Py8nj22WfZvXs38fHxjBs3TtNVhfVatx5rtjstm4OKYjKZlNzcXCUtLU0ZOnSocuDAAZumsAsXLiivv/66MmTIkGIvDOUIUrfj6LFmC8uAPEVRlJMnTyrPP/+8unDWjRs3lJ9++kn59NNPlRMnTmhVYr6kbsdylbpHjBih1p2Wlqb8+9//VgYMGGDTPeYM9Fi3Hmu2J01aZA4dOkRCQgJxcXG0bduWKlWqAKhrqdyaFE+cOMHrr7+u7u9w4cIFQkJC8Pf3Jzk5WZ2jL3W7Tt16rLk0dRuNRnJzc/Hz82Po0KE0adKEUaNGOaRWqVvqdnTdTZs2ZeTIkRiNRq5evUrlypWlbheqWSsOXxBv3bp1PP3003h7e7NixQqmTp3Kpk2bAPO4BS8vLzIyMvj999/JyckBzKOuW7ZsCcArr7zCI488woULFzAYDA77AyV1O65uPdZc0rpzc3MB8wJZfn5+XLlyhaCgINq0aeOQWqVuqVuLuu+++271dkf9YdVj3XqsWUsODzJbtmxh6NChjBw5ksmTJ9OiRQvef/99TCYTBoOBL774gk6dOrFnzx51WuHRo0dJSEigS5cueHl5qSlV6nbNuvVYc0nr9vT0JCsri19//ZWPP/6YgQMHEh0drYYxqVvqlrrdt2491qwlhwUZk8mE0WjE29tbXUI7KiqKfv36ERYWxocffkh2djZnzpzh888/Z9iwYWrTWWZmJlWrVuWzzz7j7bffJigoyFFlS90OrFuPNZe2bg8PD/z8/Lhw4QJHjhzh448/ZuzYsQ4dgCd1S91St3PVrceanUJ5Db5JTExUZs2apRw+fNjm9ilTpijvv/++zeCkbdu2KT179lQuX76s3mY0GpW8vDxFURSHrosgdTuubj3WrChlrzsvL0+t2/L/jiB1S93FIXU7rm491uyMyqVFZt26dTz33HN8/vnn7Nixg7S0NPW+7t2789tvv3Hq1CmUv8cZ161bl6ZNm7J9+3YAdZdOy+qDjloXQep2XN16rNledXt6eqp1O2qFTalb6pa6natuPdbsrMql7Sk9PZ3nn3+e9PR01q1bR6NGjWjevDkAzZo1o2HDhixevJjQ0FBiYmIIDQ3l3LlzNluda0Hqlpqlbqlb6pa6pWZ9KZcWma5du9K+fXv69u1LcHAwGzdu5MqVK+r9I0aMICUlhTlz5rBv3z727NlDXl6eOrtEq/9AUrfULHVL3VK31C0160x5913t2rVLGTZsmPLLL78oRqNRXazs6NGjyocffqhudf7999+XdyklInU7jh5rVhSp29GkbseSuh1HjzU7E4csiDdt2jTS0tJ48skn1SWTLS5dukRERER5l1AqUrfj6LFmkLodTep2LKnbcfRYs7Mo1yBjGZB59uxZ3nnnHXr37s358+cxGo089thj+Pn5lddLl4nU7Th6rBmkbkeTuh1L6nYcPdbsbMp1HRnLYmXVqlUjIiKCcePG8dVXX9G4cWOn/o8jdTuOHmsGqdvRpG7HkrodR481O53y7rvKzc1VPv74Y6V169bKkiVLyvvl7Ebqdhw91qwoUrejSd2OJXU7jh5rdiYOGSOzY8cOmjZtiq+vb3m/lF1J3Y6jx5pB6nY0qduxpG7H0WPNzkKT3a+FEEIIIezB4ZtGCiGEEELYiwQZIYQQQuiWBBkhhBBC6JYEGSGEEELolgQZIYQQQuiWBBkhhBBC6JYEGSGEEELolgQZIUSJ7dy5k5YtW9KyZUuSkpK0LkcI4ca8tC5ACOFcLJvWFaZDhw40btwYAB8fH0eUVaSdO3fyr3/9C4Dly5dTtWpVjSsSQjiCBBkhhI169eoRHh4OwKVLl7h06RIAdevWVUNLp06d6Nu3r1YlCiGESrYoEEIUaPbs2cyZMwewbeXIr/Vj/Pjx/Pjjj1SpUoWnn36aTz75hLS0NB544AGee+45Pv74Y5YvX05wcDBDhgyhf//+6utcvnyZWbNmsXXrVq5fv05kZCS9e/dmyJAheHmZv2/t27ePWbNmceTIETIyMqhYsSL16tXjpZdeYsWKFWqd1u6//37Gjx/PF198wapVq7hw4QLp6emEhITQrFkznn/+eWrUqAFAQkICEyZMAGDKlCnMnz+f06dP06JFCyZMmMCvv/7K3LlzycrKolu3bowePVqtrWXLlgCMHDmSAwcOsGnTJvz8/OjXrx9PP/00BoOhPP7zCCGQMTJCCDu7cuUKU6ZMwdvbm/T0dL766iv+8Y9/sHz5coKCgrhw4QJTp07l5MmTAFy/fp0hQ4aQkJBAZmYmNWvW5MKFC3z66ae8/fbbAJhMJkaOHMnvv/+Ol5cXNWvWJDc3l02bNnHhwgUiIyOpWbOmWkPdunVp3Lgx1apVA2DXrl0kJiYSHh5ObGwsqamp/PLLLzz77LNkZ2ff9h7efPNNcnJyyMnJYcuWLQwfPpx3330XX19fUlJSWLp0KT/88MNtz5s1axa7d+8mODiYa9euMXfuXL755pvyOM1CiL9JkBFC2FVubi4fffQR3333HZGRkQAkJiby1VdfsXTpUnx9fTGZTOzatQuAxYsXc/HiRcLDw1m2bBlfffUV7777LgA//vgjiYmJpKamkpKSAsCCBQv48ssv+emnn/jmm2+Ii4ujb9++vPLKK2oN06ZNY+HChQwbNgyAESNG8Msvv7BkyRK++eYb/vvf/wJw8eJF9uzZc9t7eOKJJ1i6dCk9evQA4OTJk7z55pt89913NGvWDDC3St2qUaNGJCQksHz5cpo3b67WK4QoPzJGRghhV5ZuG4CoqCguXrxIrVq11G6pihUrcuHCBa5evQrA/v37AUhOTqZbt242v0tRFP766y969uxJkyZN2Lt3L/379ycmJoZatWrRvn17NWwU5sKFC0yePJljx46RkZGBdY/65cuXb3t8x44dAahSpYp6W4cOHQCIjo7mzz//VOu31rVrV7W7qWvXruzevZvk5GSuXbtGxYoVi6xTCFFyEmSEEHYVGBioHnt6et52m2W8iCVMWP4/MDDQpnvIws/PDzB326xevZo9e/Zw8uRJfv75Z9auXcuVK1d4/PHHC6zn7NmzjB49mtzcXAIDA2nQoAF5eXkcOXIEMHdbFfQeLPUDBAUF5Vu/EEJbEmSEEJpq1KgRW7ZswdPTk8mTJ6stN+np6fzyyy907twZRVHYu3cvvXv3VmdLTZw4keXLl7N7924ef/xxNfAAZGZmqseHDx8mNzcXgJkzZ9KkSRPWrFnDf/7zH7u/l59//lkdxLx+/XoAwsPDpTVGiHIkQUYIoamBAwfyww8/cOnSJfr160fNmjVJT0/n4sX/b+fuURcHAgCKv6CdRWIVoxYWuYDgMUxlY6EIgk3ARmzFo3gpCxs7mxViZSMksIWsF9iVP8O+3wVmpnvM1y/qumY6ndI0DWVZ0ul0SNOUKIo+l4XzPAdgOBzSbrep65qyLMmyjMViQZ7ntFotmqZhu93S6/Woquora7lcLhRFQRRFn2frq9XqK2NJevOyr6Qf1e12OZ1OFEVBHMdcr1derxfj8Zjdbge8j3hmsxn9fp/7/c7tdiPLMpbLJZvNBoAkSdjv96RpyuPx4Hw+U1UVo9GIw+HAYDCgrmuSJPm8hvrXyrJkMpnwfD6J45j1es18Pv/KWJLe/EdGkv7Sn39kjscjRVH88Gyk/4s7MpIkKViGjCRJCpZHS5IkKVjuyEiSpGAZMpIkKViGjCRJCpYhI0mSgmXISJKkYBkykiQpWIaMJEkKliEjSZKCZchIkqRg/QZELqnq7UuGRQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = LinearRegressionModel(lags=24, lags_future_covariates=[0])\n", + "model.fit(ts_energy_train, future_covariates=ts_weather)\n", + "pred = model.predict(12)\n", + "\n", + "ts_energy_train[-48:].plot(label=\"training\")\n", + "ts_energy_val[:12].plot(label=\"validation\")\n", + "pred.plot(label=\"forecast\")" + ] + }, + { + "cell_type": "markdown", + "id": "7c7a6c5e-04c3-4a95-9d4a-03ec3517cd63", + "metadata": {}, + "source": [ + "### Using only covariates\n", + "\n", + "Sometimes, we might also be interested in a forecasting model that purely relies on the covariates values.\n", + "\n", + "To do this, specify at least one of `lags_past_covariates` or `lags_future_covariates` and set `lags=None`. \n", + "Darts regression models are trained in a supervised manner, so we still have to provide the target series for training.\n", + "\n", + "How well can we predict the electricity consumption using only the weather \"forecasts\" as input?\n", + "\n", + "The lags tuple `(24, 1)` means (number of lags in the past, number of lags in the future)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8aaa2095-0a32-4146-9b1b-82cd9e1624f4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = LinearRegressionModel(lags=None, lags_future_covariates=(24, 1))\n", + "model.fit(series=ts_energy_train, future_covariates=ts_weather)\n", + "pred = model.predict(12)\n", + "\n", + "ts_energy_train[-48:].plot(label=\"training\")\n", + "ts_energy_val[:12].plot(label=\"validation\")\n", + "pred.plot(label=\"forecast\")" + ] + }, + { + "cell_type": "markdown", + "id": "0ba7df08-2b2a-4e10-849c-728e269e4044", + "metadata": {}, + "source": [ + "And what if we added some calendar information? We can let the model generate calendar attribute encodings for free with `add_encoders`." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d03e283c-21a6-4330-8f50-34f77351818f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = LinearRegressionModel(\n", + " lags=None,\n", + " lags_future_covariates=(24, 1),\n", + " add_encoders={\n", + " \"cyclic\": {\"future\": [\"minute\", \"hour\", \"dayofweek\", \"month\"]},\n", + " \"tz\": \"CET\",\n", + " },\n", + ")\n", + "model.fit(series=ts_energy_train, future_covariates=ts_weather)\n", + "pred = model.predict(12)\n", + "\n", + "ts_energy_train[-48:].plot(label=\"training\")\n", + "ts_energy_val[:12].plot(label=\"validation\")\n", + "pred.plot(label=\"forecast\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "08c62699-baf4-404f-bd60-33d4e072192d", + "metadata": {}, + "source": [ + "### Component-specific lags\n", + "\n", + "If the target or any of the covariates is multivariate (has multiple components/columns), we can use dedicated lags for each component.\n", + "Just pass a dictionary to the `lags*` parameters with the component name as key and the lags as value.\n", + "\n", + "In the example below, we set the default lags to `(24,1)` (used for the covariates components `'T [°C]'` and `'StrGlo [W/ms]'`) and give feature `'RainDur [min]'` a dedicated lag `[0]`." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "76f60b93-6433-4e20-9ae6-32f511fedd65", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = LinearRegressionModel(\n", + " lags=None, lags_future_covariates={\"default_lags\": (24, 1), \"RainDur [min]\": [0]}\n", + ")\n", + "model.fit(series=ts_energy_train, future_covariates=ts_weather)\n", + "pred = model.predict(12)\n", + "\n", + "ts_energy_train[-48:].plot(label=\"training data\")\n", + "ts_energy_val[:12].plot(label=\"validation data\")\n", + "pred.plot(label=\"forecast\")" + ] + }, + { + "cell_type": "markdown", + "id": "af170e70-0c06-45f9-a093-df36dd9373c1", + "metadata": {}, + "source": [ + "### Model's output chunk length\n", + "\n", + "This key parameter sets the *number of time steps that can be predicted at once by the internal regression model*.\n", + "\n", + "It is not the same as forecast horizon `n` from `predict()` which is the **desired** the number of generated prediction points, that is achieved either with:\n", + "- a single shot forecast (if `output_chunk_length <= n`), or\n", + "- an auto-regressive forecast, consuming its own forecast (and future values of covariates) as input for additional predictions (otherwise)\n", + "\n", + "For example, if we want our model to forecast the next 24 hours of electricity consumption based on the last day of consumption, setting `output_chunk_length=24` ensures that the model will not consume its forecasts or future values of our covariates to predict the entire day." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b376f792-d374-4c6c-b47a-644621248efd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model_auto_regression = LinearRegressionModel(lags=24, output_chunk_length=1)\n", + "model_single_shot = LinearRegressionModel(lags=24, output_chunk_length=24)\n", + "\n", + "model_auto_regression.fit(ts_energy_train)\n", + "model_single_shot.fit(ts_energy_train)\n", + "\n", + "pred_auto_regression = model_auto_regression.predict(24)\n", + "pred_single_shot = model_single_shot.predict(24)\n", + "\n", + "ts_energy_train[-48:].plot(label=\"training data\")\n", + "ts_energy_val[:24].plot(label=\"validation data\")\n", + "pred_auto_regression.plot(label=\"forecast (auto-regression)\")\n", + "pred_single_shot.plot(label=\"forecast (single-shot)\")" + ] + }, + { + "cell_type": "markdown", + "id": "948afd96-fbd7-459d-a9ea-af1025968213", + "metadata": {}, + "source": [ + "### Multi-model forecasting\n", + "When `output_chunk_length>1`, the model behavior can be further parametrized by modifying the `multi_models` argument.\n", + "\n", + "`multi_models=True` is the default behavior in Darts and was shown above. We create `output_chunk_length` copies of the model, and train each of them to predict one of the `output_chunk_length` time steps (using the same inputs). \n", + "This approach is more computationally and memory intensive but tends to yield better results.\n", + "\n", + "### Single-model forecasting\n", + "When `multi_model=False`, we use a single model and train it to predict only the last point in `output_chunk_length`. This reduces model complexity as only a single set of coefficients will be trained and stored.\n", + "\n", + "We are still able to predict all points from 1 until `output_chunk_length` by shifting the lags during tabularization.\n", + "This means that a new set of input values is used for each forecasted value. Due to the shifting, the minimum length requirement for the training series will also be increased." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "0d40df60-0978-48d1-b156-6a60655c5cfc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "multi_models = LinearRegressionModel(lags=24, output_chunk_length=24, multi_models=True)\n", + "single_model = LinearRegressionModel(\n", + " lags=24, output_chunk_length=24, multi_models=False\n", + ")\n", + "\n", + "multi_models.fit(ts_energy_train)\n", + "single_model.fit(ts_energy_train)\n", + "\n", + "pred_multi_models = multi_models.predict(24)\n", + "pred_single_model = single_model.predict(24)\n", + "\n", + "ts_energy_train[-48:].plot(label=\"training\")\n", + "ts_energy_val[:24].plot(label=\"validation\")\n", + "pred_multi_models.plot(label=\"forecast (multi models)\")\n", + "pred_single_model.plot(label=\"forecast (single model)\")" + ] + }, + { + "cell_type": "markdown", + "id": "0b05cba7-0a4a-441b-9ab1-57992b9a52b6", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "### Visualization\n", + "To vizualize what is happening under the hood, let's simplify the model a bit and show the process for different parameters.\n", + "\n", + "#### Multi models with auto-regression\n", + "Model setup: `LinearRegressionModel(lags=[-4, -3, -2, -1], output_chunk_length=2, multi_models=True)`.\n", + "\n", + "When calling `predict(n=4)`, the input series is processed as follows:\n", + "\n", + "![forecast_multi_model_ocl2](./static/images/multi_model_ocl2.png)\n", + "\n", + "Since `n>output_chunk_length`, the model had to use auto-regression and the forecasted period is composed of two chunks of size `output_chunk_length`.\n", + "There was no lags shift per output chunk because `multi_models=True`.\n", + "\n", + "#### Single model with auto-regression\n", + "\n", + "Model setup: `LinearRegressionModel(lags=[-4, -3, -2, -1], output_chunk_length=2, multi_models=False)`.\n", + "\n", + "![forecast_single_model_ocl2](./static/images/single_model_ocl2.png)\n", + "\n", + "Apart from the auto-regressive prediction, we can see the lags shift per predicted time step because `multi_models=False`.\n", + "\n", + "The same process also occurs during tabularizion for training the model: each green chunk is paired with an orange value, constituting the training dataset." + ] + }, + { + "cell_type": "markdown", + "id": "fdc2cfab-3b39-41c4-8701-ac6ee67b4b63", + "metadata": {}, + "source": [ + "### Probabilistic forecasting\n", + "\n", + "To make a model probablistic, set parameter `likelihood` to `quantile` or `poisson` when creating a `RegressionModel`. At prediction time, probabilistic models can either :\n", + "- use Monte Carlo sampling to generate samples based on the fitted distribution parameters when `num_samples > 1`\n", + "- return the fitted distribution parameters when `predict_likelihood_parameters=True`\n", + "\n", + "Note that when using the `quantile` regressor, each quantile will be fitted by a different model.\n", + "\n", + "Probabilistic models will generate different forecasts each time `predict()` is called with `num_samples > 1`. To get reproducible results, set the random seed when creating the model and call the methods in the exact same order." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "38de016d-4029-4c80-bbf8-2fd73716f8cd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Value_NE5_q0.05 : 19580.123046875\n", + "Value_NE5_q0.50 : 19623.302734375\n", + "Value_NE5_q0.95 : 20418.7421875\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = XGBModel(\n", + " lags=24, output_chunk_length=1, likelihood=\"quantile\", quantiles=[0.05, 0.5, 0.95]\n", + ")\n", + "\n", + "model.fit(ts_energy_train)\n", + "\n", + "pred_samples = model.predict(n=24, num_samples=200)\n", + "pred_params = model.predict(n=1, num_samples=1, predict_likelihood_parameters=True)\n", + "\n", + "for val, comp in zip(pred_params.values()[0], pred_params.components):\n", + " print(f\"{comp} : {round(val, 3)}\")\n", + "\n", + "ts_energy_train[-48:].plot(label=\"training\")\n", + "ts_energy_val[:24].plot(label=\"validation\")\n", + "pred_samples.plot(label=\"forecasts\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "f578a80a-9ba1-4067-97ab-477bd447a7c3", + "metadata": {}, + "source": [ + "### MultiOutputRegressor wrapper\n", + "\n", + "Some regression models support native multi-output support. This is required to fit and predict:\n", + "- multiple outputs/multiple target steps (with `output_chunk_length>1` and `multi_models=True`)\n", + "- probabilistic models using quantile regression\n", + "- multivariates series\n", + "\n", + "For models that don't support it, Darts wraps sklearn's `MultiOutputRegressor` around them to handle the logic under the hood." + ] + }, + { + "cell_type": "markdown", + "id": "af6db120-f776-459b-9751-af02fd579188", + "metadata": {}, + "source": [ + "## Explainability\n", + "\n", + "We offer explainability for the regression models with Darts' `ShapExplainer`. The explainer uses [shap](https://github.com/shap/shap), a library based on game theory, to give insights into feature importances over time for our forecast horizon." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "e6a1dbfe-34db-43d9-aec5-3c711d9f80be", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No data for colormapping provided via 'c'. Parameters 'vmin', 'vmax' will be ignored\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = LinearRegressionModel(lags=24, lags_future_covariates=(24, 24))\n", + "model.fit(ts_energy_train, future_covariates=ts_weather)\n", + "shap_explainer = ShapExplainer(model=model)\n", + "shap_values = shap_explainer.summary_plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "f96a3875-fb99-4210-b79d-47e7b553a0f1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + " Visualization omitted, Javascript library not loaded!
\n", + " Have you run `initjs()` in this notebook? If this notebook was from another\n", + " user you must also trust this notebook (File -> Trust notebook). If you are viewing\n", + " this notebook on github the Javascript has been stripped for security. If you are using\n", + " JupyterLab this error is because a JupyterLab extension has not yet been written.\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# extracting the end of each series to reduce computation time\n", + "foreground_target = ts_energy_train[-24 * 2 :]\n", + "foreground_future_cov = ts_weather[foreground_target.start_time() :]\n", + "\n", + "shap_explainer.force_plot_from_ts(\n", + " foreground_series=foreground_target,\n", + " foreground_future_covariates=foreground_future_cov,\n", + ")\n", + "\n", + "# the plot cannot be rendered on GitHub or the Documentation page. Run it locally to see it." + ] + }, + { + "cell_type": "markdown", + "id": "9b0a0b82-5d79-4633-af38-58eb9b56fcfd", + "metadata": {}, + "source": [ + "## Conclusion\n", + "\n", + "By tabularizing the data and unifying the API across libraries, Darts closes the gap between traditional regression problems and timeseries forecasting.\n", + "\n", + "`RegressionModel` and its sub-classes offer a wide range of functionalities which can be used to build strong models in just a few lines of codes." + ] + }, + { + "cell_type": "markdown", + "id": "b153cc69-2485-4bbd-85ff-c5cd9e107582", + "metadata": {}, + "source": [ + "# Appendix" + ] + }, + { + "cell_type": "markdown", + "id": "4b995311-0bdc-4d05-9573-f82466aba6e0", + "metadata": {}, + "source": [ + "### RegressionModel\n", + "`RegressionModel` wraps the Darts API around any sklearn regression model. With this we can use the model in the same way as any other Darts forecasting models.\n", + "\n", + "As an examnple, fitting a Bayesian ridge regression on the example dataset takes only a few lines:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "b2af4e28-2b29-4563-8d8f-1a57c4a5c157", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = RegressionModel(\n", + " lags=24,\n", + " lags_future_covariates=(48, 24),\n", + " model=BayesianRidge(),\n", + " output_chunk_length=24,\n", + ")\n", + "\n", + "model.fit(ts_energy_train, future_covariates=ts_weather)\n", + "\n", + "pred = model.predict(n=24)\n", + "\n", + "ts_energy_train[-48:].plot(label=\"training\")\n", + "ts_energy_val[:24].plot(label=\"validation\")\n", + "pred.plot(label=\"forecast\")" + ] + }, + { + "cell_type": "markdown", + "id": "9ea22e77-ad17-4fe4-a757-18447fa2ef50", + "metadata": {}, + "source": [ + "The underlying model methods remain accessible and by combining the `BasesianRidge.coef_` attribute with the `RegressionModel.lagged_feature_names` attribute, the coefficients of the regression model can easily be interpreted:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "a5ff0e6d-3b37-4c17-82c3-96faa8f3ca8d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Value_NE5_target_lag-24': -0.3195560563281926,\n", + " 'Value_NE5_target_lag-23': 0.37621876784175745,\n", + " 'Value_NE5_target_lag-22': 0.005325414282057739,\n", + " 'Value_NE5_target_lag-21': -0.11885377506043901,\n", + " 'Value_NE5_target_lag-20': 0.12892167797527437}" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# extract the coefficients of the first timestemp estimator\n", + "coef_values = model.model.estimators_[0].coef_\n", + "# get the lagged features name\n", + "coef_names = model.lagged_feature_names\n", + "# combine them in a dict\n", + "coefficients = {name: val for name, val in zip(coef_names, coef_values)}\n", + "# see the coefficient of the target value at last timestep before the forecasted period\n", + "{c_name: c_val for idx, (c_name, c_val) in enumerate(coefficients.items()) if idx < 5}" + ] + }, + { + "cell_type": "markdown", + "id": "4989e3b1-e875-4b11-8de7-554e5ebbad90", + "metadata": {}, + "source": [ + "One of the limitation of the `RegressionModel` class is that it does not provide probabilistic forecasting out of the box but it is possible to implement it by creating a new class inheriting from both `RegressionModel` and `_LikelihoodMixin` and implementing the missing methods (the `LinearRegressionModel` class can be use as a template)." + ] + }, + { + "cell_type": "markdown", + "id": "c0e9aee2-7692-4407-a56c-e8ee2d37cb8d", + "metadata": {}, + "source": [ + "## Custom model\n", + "\n", + "You can even implement your own model as long as it works with tabular data and provides the `fit()` and `predict()` methods:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "d860f4cf-d9f4-4b17-99ef-848dc5325a13", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAHICAYAAABULQC7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAACmTElEQVR4nOydd3xTdffHPzfpShfdg9JBaQuUvXfLFCgiDpaAiMhwPCo8iPKooCAiKu6JTEV/KioqlTKEiuwps6yW0tJd2kLbdKVJ7u+P29wmdNC0Se69yXm/Xr68Se44+fZL7ueec77nMCzLsiAIgiAIgpAgMqENIAiCIAiCaC4kZAiCIAiCkCwkZAiCIAiCkCwkZAiCIAiCkCwkZAiCIAiCkCwkZAiCIAiCkCwkZAiCIAiCkCwkZAiCIAiCkCwkZAiCIAiCkCwkZO6BVqvFjRs3oNVqhTZFEtB4GQeNl3HQeBkPjZlx0HgZhxjGi4QMQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShYQMQRCiQq1W49lnn8WUKVNw5swZoc0hCELkkJAhCEJUfPfdd/jiiy+wdetW9OrVC/PmzUN+fr7QZhEEIVJIyBAEISq+/fZbfptlWaxbtw6RkZH44IMPoFKpBLSMIAgxQkKGIAjRkJ6ejr///hsA4OvrCzc3NwBASUkJFi1ahG7duvGfEwRBACRkCIIQEd999x2//fzzzyM5ORlz5swBwzAAgGvXruHJJ5/EBx98IJSJBEGIDBIyBEGIApZlDcJKjz32GPz9/bFu3TqcOnUKgwcP5j9bvXo1NBqNEGYSBCEySMgQBCEKTpw4gWvXrgEAhg4ditDQUP6znj174sCBAxg3bhwAoLCwEP/++68gdhIEIS5IyBAEIQr0vTEzZ86s8znDMBg/fjz/eteuXRaxiyAIcUNChiAIwamqqsKPP/4IAFAoFHjkkUfq3W/06NH8NgkZgiAAEjIEQYiAhIQEFBUVAQAeeughuLu717tfSEgIIiIiAADHjh3D7du3LWYjQRDixGgh89Zbb2H06NGIjY3FlClTcPDgQQBAfHw8+vXrhyFDhvD/5ebm8sclJSXh0UcfxaBBgzBv3jzk5OTwn1VWVmLp0qWIiYnBuHHj6jxpxcfHIy4uDrGxsVi+fDmqq6ub+30JghAh9wor6RMTEwMA0Gq12Ldvn1ntIghC/BgtZKZPn474+Hj8888/WLZsGZYuXYqSkhIAQN++fXHw4EH+v4CAAACASqXCSy+9hKlTpyIxMRGdO3fGsmXL+HOuXbsWxcXFSEhIwKpVq7B69Wqkp6cDAFJSUvDhhx9izZo12LFjB7Kzs7FhwwZTfHeCICyAUqnE6dOnodVq6/28oKAAO3bsAAAEBgZi5MiRjZ4vNjaW36bwEkEQRguZsLAwODg4AOCS71QqFQoKCho95vTp01AoFJgwYQIcHR0xd+5cXLp0iffKJCQkYN68eXB1dUW3bt0QExODPXv2AOB+qEaNGoXo6Gi4urpizpw52Llzp7FmEwQhAFqtFkOHDkXv3r0xZswYlJaW1tnnxx9/5L2sM2bMgFwub/Scffv2hUKhAMD9PrAsa3rDCYKQDHbNOWj16tWIj49HVVUVYmNjER4ejqSkJJw7dw4jRoyAl5cXpkyZgokTJwIAUlNT+bg2wCXztWnTBqmpqXBxcUFhYaHB51FRUUhKSuKPHTBgAP9ZZGQksrKyUFlZCScnpzq2qVSqOmXM7ezsePFlLLqnyIaeJglDaLyMw9rH6+jRozh9+jQA4K+//sLw4cMRHx8PPz8/fh/9sNKMGTMaHQutVgtHR0fExsZi165dyMrKwoULF9C5c2fzfQmJY+1zzNTQeBmHucdLJru3v6VZQmbJkiVYvHgxTp06hZSUFABcnYcff/wRAQEBuHTpEl588UV4e3tj2LBhqKiogIuLi8E5XFxcUFFRgfLycsjlcgNR4uLigvLycgCoc6yrqyv/fn1CZtOmTVi3bp3Be5MmTcLkyZOb81V5MjIyWnS8rUHjZRzWOl6bNm0yeH3q1CkMGDAA33zzDYKDg5GSkoKTJ08CADp16gQ3Nzc+rNwYffr04cNKP/74I+bOnWt6460Ma51j5oLGyzjMNV5t27a95z7NEjIAIJfL0a9fP/zwww8IDw838Jp07twZU6dOxd9//41hw4ZBoVCgrKzM4PiysjIoFAo4OztDo9EYeFjKysrg7OwMAHWOVSqV/Pv18cQTT2D69OmGX7KFHpmMjAwEBwc3SRnaOjRexmHN48WyLPbu3QuA+zfo7++PrKwspKWlYcqUKUhISEBiYiK//5NPPmlQBK8+dOM1ZcoUvPnmmwC4QnorV6403xeRONY8x8wBjZdxiGG8mi1kdGi1WmRmZtZ5X9cbBQDCw8Px22+/8a8rKiqQmZmJ8PBwuLu7w9vbGykpKbx7+Nq1awgPD+eP1Xl9ACA5ORlBQUH1emMAwMHBodmipTFkMhlNaiOg8TIOaxyvU6dO8d6VESNG4Ouvv8bo0aNx5coV5ObmYujQoXB0dATAPRhNmzatyWPQoUMHhIWFIS0tDQcPHkR5eTnvrSXqxxrnmDmh8TIOIcfLqKuWl5dj586dKC8vh1qtxr59+3D69Gn06NEDR44c4Ws6XLlyBT/99BOGDBkCAOjVqxcqKioQHx8PlUqFDRs2IDo6GoGBgQCAuLg4rF+/HmVlZbhw4QIOHDiAUaNGAQDGjBmDvXv34sqVK1Aqldi4cSPGjh1ryjEgCMIM/PLLL/z2xIkTERISgoMHD6Jfv34AuI7Wt27dAsD9O/f392/yuRmGwZgxYwBweXH79+83neEEQUgKo4QMwzD4448/EBcXhxEjRmDTpk1YuXIlIiIicPz4cUyePBlDhgzBK6+8gpkzZ/JixMHBAe+++y6+//57DBs2DOfOncOKFSv4886fPx+urq4YM2YMlixZgiVLliAsLAwAEBERgQULFmDhwoWIi4uDv78/Zs+ebboRIAjC5LAsi19//RUA96Q2YcIEAICPjw/27dvHixAdjz/+uNHX0D/H7t27W2AtQRBShmFp7WKjaLVapKenIzQ0lNyMTYDGyzisdbzOnTuH7t27AwCGDx9ep3BddXU15syZg2+//Rbt27fH2bNnGwwX66M/XkqlEt7e3lCr1YiIiEBycrI5vorksdY5Zi5ovIxDDONFfyWCIEyOzhsDgC/DoI+9vT2++eYbXL58GadOnWqSiLkbd3d3DBo0CABXOFM/l44gCNuBhAxBECZHlx/DMAweeuihBvfr0KFDi5J0KbxEEAQJGYIgTMqlS5dw+fJlAMDgwYP5ViXmQF/IULsCgrBNSMgQBGFS9MNKjzzyiFmv1a1bN14oJSYmoqqqyqzXIwhCfJCQIQjCpOgvu3744YfNei2GYXDfffcB4MpDHDp0yKzXIwhCfJCQIZqMSqXC4cOHsXLlSkycOBFbtmwR2iRCZCQnJ+P8+fMAgP79+yM4ONjs16Q8GYKwbVpc2ZewXrRaLU6dOoXExET8/fffOHToEN8DC+BCCM7OzmYPHxDSwZJhJR2jRo0CwzBgWRa7du3Cu+++a5HrEgQhDkjIEPVSUlKCuLg4HD58uNH9Zs6ciXbt2vE1QwjbRj+sZCkh4+Pjgz59+uDEiRO4cOEC0tLS+IKaBEFYPxRaIuqgVqsxZcqUOiKmdevWmDFjBjZs2IBp06YB4PISHnjgAeTl5QlhKiEi0tLScPr0aQBcW5KmdK01FbrKwQCwYcMGi12XIAjhISFDGMCyLJ577jl+Kaunpye+/PJLXL16FZmZmdiyZQtmz56NDRs2oH///gC49u0PP/wwrRixcYQIK+mYNWsW5HI5AE7IVFdXW/T6BEEIBwkZwoAPPvgAX331FQCu+upvv/2Gp556ClFRUQYdzZ2cnLBt2zYEBQUBAI4cOYKnn34a1PHCdhFSyLRu3RoPPPAAACAnJwc7duyw6PUJghAOEjIEz7Zt27B48WL+9caNGxEbG9vg/oGBgfjjjz/48vKbNm3Cxx9/bHY7CfGRmZmJo0ePAgC6dOmCqKgoi9swb948fnvt2rUWvz4hLqrVLOa9p8V9/9UiOYMesKwZEjIEAODEiROYMWMG71F54403MGPGjHse16tXL2zevJl/vXjxYhw4cMBcZhIiZefOnfy2UKvY7rvvPj7Jd/fu3UhLSxPEDkIcbN4JrIsH/joFjFnMouAOiRlrhYQMgbS0NIwfPx4VFRUAgMceewzLli1r8vFTpkzBq6++CoBbsv2f//zHIMxAWD/Hjh3jt0eOHCmIDTKZDHPnzgXA5XqtW7funsdoNBpzm0UIgFrN4u3vaoVLajbw0GssqlQkZqwREjI2TmlpKcaNG4f8/HwAQGxsLNatW2eQD9MUVqxYgQcffBAAoFQqMXnyZDz88MPIzs42tcmECDl+/DgAwM7ODj179hTMjtmzZ8POjqsqsXHjxgaTflmWxfPPPw8nJyesWrXKkiYSFuCHfcCNHMP3Dp0H5r7HUh6fFUJCxsb57LPPcOnSJQBA+/btsW3bNjg6Ohp9HplMhi1btmD8+PH8e7/99huio6Oxbt06aLVak9lMiIuSkhJ+DnXr1g0KhUIwWwICAvil2Lm5uYiPj693vy+//BKffvop1Go13nrrLZSVlVnSTMKMaDQsVm2pFSsf/IeBouYnbctu4O3vBDKMMBskZGwYlmUN8lt+//13eHl5Nft8rq6u+O233/DJJ5/A19cXAFBcXIx58+ZhxIgRSE5ObqnJhAg5efIk/5Tbr18/ga0B5s+fz2/Xl/R7+vRpLFy4kH9dXl5OnbOtiG0HgCs3ue0hXYGFkxl891qth/nVdSx+/pu8MtYECRkb5sSJE7h27RoAYOjQoejQoUOLz8kwDO6//34kJSXh8ccf59/fv38/unbtiiVLlqCgoKDF1yHEgy6sBIhDyIwYMQLh4eEAgD179iA1NZX/7M6dO5g0aRJUKpXBMT///LNFbSTMA8uyWPltrUhZ+jgnYB6OZfD2vFoxM/MtFicukZixFkjI2DDffvstvz1z5kyTntvb2xubN2/Gnj17+JUklZWVeOedd9C2bVu8+uqrKCoqMuk1CWHQT/TVFUkUEv2kXwB80i/Lspg9ezZu3LgBAOjbty+8vb0BAH/++Sef7E5Il/jDwPnr3HbfjsDI3rWfvTwdeLymv2ilCnjgFRY380jMWAMkZGyUqqoq/PDDDwAAhUKBiRMnmuU6o0aNwsWLF7Fo0SI4ODgA4JKBV61ahbCwMCxduhS3b982y7UJ88OyLO+R8fT0RGRkpMAWcTzxxBMGSb8qlQoff/wxfvvtNwCcrVu3buUT1MvKyqhztsS52xvz2kzGYNECwzD4ejGDmG7c67wi4KFXaSWTNUBCxkbZsWMHLyAefvhhuLm5me1aLi4uWLNmDa5fv45nnnkG9vb2ALgVUytXrkRYWBgV0pMo6enp/Iq3vn37Gr3azVz4+/vjoYceAgDk5+fj1VdfNSj2+O233yI0NNRAwOs3vCSkx18ngZNXuO1uEcD9A+vu42DP4Nc3GbTjCpLj32tczgwhbUjI2CjffPMNv23qsFJDtGnTBp9//jlSUlIwf/58XtCUlJRgwYIFWLNmjUXsIEyH2MJK+ugn/a5ZswZqtRoA8NJLL+H+++8HAAwfPhweHh4AgO3bt1O/MAmj74159TGmQVHt48Hg5+UMHLifH7z/E7DnBIkZKUNCxga5desWEhISAHA9akaMGGHR64eEhOCrr75CcnIynnzySf79xYsXY+PGjRa1hWgZYkv01WfYsGGIiIgweG/w4MFYuXIl/9rBwYFfrl1aWoo9e/ZY1EbCNBw4y+LgeW67QwjwcEzj+/eIYrB6vl7y7yoW+bdJzEgVEjI2yI8//sg/nc6YMYPvGmxpQkNDsX79erz55pv8e3PnzuXzGAjxo++R6du3r4CW1OXupF8fHx/8+OOPvCdQB4WXpI++N+aVxxjI5fcOcb4wERhdM2XzioAn3qZieVKFhIwNIkRYqTFeffVVLFiwAADX4mDq1KlITEwU1ijinqhUKpw5cwYAEBkZya8AEhNz585FdHQ0PD098dNPP/Hd2vUZNWoU3N3dAQB//PFHnaXZhLg5lsTir1Pcdnhr4NEmOphlMgbfvMLAz5N7nXAM+JQ6q0gSEjI2RlJSEk6fPg2Aa/jYqVMngS3iVhO8//77vKhSqVSYMGECTp48KbBlRGOcO3eOzykRW1hJh6enJy5evIi8vDwMHz683n0cHR3xwAMPAOAKOO7bt8+SJhItILeQxaPLa70o/5vBwM6u6Qnn/l6cmNGx+EuWX75NSAcSMjaGOWvHtASZTIb169fzLQ6USiXGjh2Ly5cvC2wZ0RD6YSWxChmAE8p3h5PuhsJL0qO0nMW4l1mk5XKvu0UAM0cbf54x/RgsmMRtq6qBaSuAiipxrL4jmgYJGRtCo9Hgu++4RiN2dnZ49NFHBbbIEHt7e/z000+IieEy9QoLCzFixAi88847uH6dHpPEhn6ir9hWLBnLfffdB1dXVwBcq46Gmk0S4qBazWLy6yz+5QqTI9gPSHiXgYN98wTI6vkMuteUQLqcDiz/zhPUHk46kJCxIRITE/lu1HFxcXw/JDGhUCiwfft29OjRAwCQk5ODJUuWICIiAj179sTbb79NPZtEgs4j4+joiK5duwpsTctQKBT8kuyioiL8/fffAltENATLspi/hsWuGh3t4QrsWsOgtU/zvSiODgx+WFbbXHLrATcMehY4daX5yb+VVSyWb2KxLp4SiM0NCRkbQmxJvg3RqlUr7Nq1C8OGDTN4/8yZM3jllVcQFRWFHj164OjRowJZSBQUFPBesp49e/JVm6UMhZekwRubWGziqkfAwR74YxWD6LCWh4I6hDL44r+15zlxGeg7n8VTa7QoLDZejHz5B2frvPdYJJ4mMWNOSMjYCKWlpdi2bRsALgFS9/QpVvz8/JCYmIjr16/jnXfeQe/evQ0+P3v2LP773/8KZB1x4sQJflvqYSUdY8eOhbOzMwDgt99+40sUEOJhXTyLFZu5bYYBvnuNQUx30+WzzBrLYN+HQGRrbuUaywJrtwPtZ7BY/ycLrbbpguSvk7X7btlDQsackJCxEX799Ve+Kd7UqVPh6OgosEVNIzw8HC+99BJOnjyJGzduYM2aNfDy8gLAeWjoZiMMUkn0NQZnZ2eMGzcOAOdxOnDggMAWEfokHGXx9Ae1guCDZxlMGmb6pNyhPYA/38zBmmcAVwX3XmExMPddFgOfYVFUcm9RotGwOJJU+3rbAVBPJzNCQsZG0CX5AuIOKzVGWFgYFi1ahFGjRgHgGl9evXpVYKtsEzFX9G0J+uGln3/+WUBLCH2q1Sxmv8NCo+Fe/3cysGCy+VYW2dsBCycDV79n8OjI2vePX+LCRfciKQ0oVta+LikDdh5vcHeihZCQsQFKS0v5p8uwsDDJ33i6d+/Ob589e1YwO2wVrVbLh5b8/f0RGhoqsEWmIy4uDk5OTgCAbdu2QaO7cxKCsus4V30XAO7rA7z3jGWWR7f2YfB/y2RI/IiBvV2tLffi0Pm67/24jzwy5oKEjA2QmJjILyeNi4sTTYfi5kJCRliuXbuGO3fuAOC8MVKfT/q4urpi7NixALiu2UeOHBHYIgIwzDF5fiIDmcyyc25YTwb9ornt5EzgZl7jouTQhdrPdR1gth8GlOUkZswBCRkbYNeuXfz2mDFjBLTENJCQERZrDSvpePDBB/ntHTt2CGcIAQC4U8pi+2Fu29eD88gIwcheteJp3+nG99V5ZFwUwKyan9yKKiCedLFZICFj5bAsi507dwLgOv3evaRZigQEBMDf3x8AJ2So0Ztl0U/0tZYVS/qMHTuW9zKRkBGen/cDVTXtrx4dAdgb0YLAlIzoVbu9r5Hl1DfzWGTkc9v9o4HHRtfa+8Ne+q0yByRkrJyrV68iPT0dADBkyBC+eqnU0XllCgoK+CJ/hGXQeWQYhqmzLN4a8PX15Tt5X7x4ETdv3hTYIttmy+7am7++KLA0fTtyHhaA88g09AClnx8zuAv3X2sf7vWuE8DtUhIzpoaEjJWj88YA4GP/1gCFl4ShvLwc589zv9SdOnXiu0ZbG7pl2AB5ZYQkLYfFwRph0CEE6NVeOFsc7BnE1BSwzi0CLqXVv59+fszgrgzkcgZTavqVVquBbf+Y105bxGgh89Zbb2H06NGIjY3FlClTcPDgQQBAfHw8pk2bhpiYGEyYMKFOZczevXtj8ODBGDJkCIYMGYKNGzfyn1VWVmLp0qWIiYnBuHHjDHI6dOeOi4tDbGwsli9fTn1QjMDa8mN0kJARhtOnT/MreawxP0aHfsHIP//8U0BLbJvv9tRuPzaaETyxfGTve+fJ6Dwycjn4BOGpw2uP+zGRPDKmxs7YA6ZPn47FixfDwcEBSUlJePbZZ7F9+3aoVCr873//Q8eOHZGeno6nn34a4eHh6NmzJ3/s77//Dh8fnzrnXLt2LYqLi5GQkIDr16/jhRdeQMeOHREaGoqUlBR8+OGH+OyzzxASEoJFixZhw4YNeOqpp1r2zW2A8vJy/PMPJ/+Dg4MRHR0tsEWmg4SMMFh7oq+O7t27o3Xr1sjOzkZiYiLKy8v5qr+EZWBZ1mC10vRRAhpTw915Ms9PNBRWt0tZXLzBbXePANycuc/7dATCWwOp2UDiv0BuIYsAb+tZ7Sc0RntkwsLC+L4qDMNApVKhoKAAjzzyCLp06QI7Ozu0a9cOffv2xaVLl5p0zoSEBMybNw+urq7o1q0bYmJisGcPJ8V37dqFUaNGITo6Gq6urpgzZ45BuIRomP3796OqqgoA540R+mnGlERGRkKh4ALWJGQshzW2JqgPhmEQFxcHgPMYUxNJy3PyMnAtg9uO7Q6EBgj/+9UlHPBpxW3vPwuo1YbelaMXubYGAJcbo4NhGEwdwW1rtcAv+81uqk1htEcGAFavXo34+HhUVVUhNjYW4eHhBp9rNBokJSXxPwQ6ZsyYAYZh0K9fPyxYsAAeHh4oKSlBYWEhIiIi+P2ioqKQlMTVd05NTcWAAQP4zyIjI5GVlYXKykq+cJU+KpUKKpXK8Eva2TW7qZ22ppe7VoI93fUF3+jRoy3yHSw1XgzDoGvXrjh+/DhSUlJQXFwMNzc3s17THEhtft24wT1uMgyDqKgoi9ttyfEaO3Ys1q9fD4ALL0k1x0xqc0zHt7trt6ePspz99xqvYT2Bn//mqvWeuMyif6daMXNQL9F3YGfDc0weBqzawm3/sI/FMw9ZR4jJ3PNLJru3v6VZQmbJkiVYvHgxTp06hZSUlDqff/nll/D19TUQIOvWrUOXLl1QWlqKd955BytWrMAHH3yA8vJyyOVyA1Hi4uKC8vJyAEBFRQVcXFz4z3SrbioqKuoVMps2bcK6desM3ps0aRImT57cnK/Kk5GR0aLjhSA+Ph4AJ+QiIiL41UuWwBLjFR4ezoc69uzZI+kVNFKZX5mZmQAAHx8fQVeLWWK8oqKi4ODgAJVKhe3bt2Px4sWS9mpKZY4BgEoN/LC3DQA5HO216BueifR0y974GxqvHmGu+BneAIBtibcR6FrCf7bvpD8A7r4U5pmB9PTam7u7HIgKCsS1LAccuQgcOZ2JIB/rqRxtrvnVtm3be+7TLCEDAHK5HP369cMPP/yA8PBwXrT88ssvSExMxMaNGw3+0ffo0QMA13n5xRdfxLhx41BdXQ1nZ2doNBoDD0tZWRkfj1YoFCgrK+PPo1Qq+ffr44knnsD06dMNv2QLPTIZGRkIDg5ukjIUCykpKbxwGThwILp06XKPI0yDJcdr8ODB+OGHHwAAeXl5kiyVL6X5pdFocOvWLQBczpUQ423p8YqNjcVff/2F7OxsKJVKdO7c2ezXNDVSmmM6th8Gikq57QmDZejSMcRi177XeE0aBbyyidv+N9UToaGeALhaN+dr8mMigoDe3YLrHDtjNLCsZp3L4WttsLhXnV0khxjmV7OFjA6tVss/pe3Zs4f3iHh4eDR4jO7LsiwLd3d3eHt7IyUlhf+RuHbtGh+uCg8PN/D6JCcnIygoqF5vDMAVfWuuaGkMmUwmmR8BAHyOEcC5yC1tuyXGSz+R/Ny5c5L6+9yNFOZXfn4+v2IpMDBQUHstNV73338//vrrLwBcLl/Xrl3Nfk1zIYU5puP7v2o9GTPHWL4lAdDweEW0AcICtEjLBQ5fBCpVDJydGJxJZlFVzXmNBnetPyTy6EgWyzZy+/yUCLw8XRp/j6Yg5Pwy6qrl5eXYuXMnysvLoVarsW/fPpw+fRo9evTAsWPH8N577+Gjjz5C69atDY67fv06rl27Bo1Gg5KSErz//vvo168fLzji4uKwfv16lJWV4cKFCzhw4ADf4XjMmDHYu3cvrly5AqVSiY0bN0o2Vm1JrHXZtT5dunThvX6U8Gt+9ENJd/8bt1aonozluVPK8qX8hWxJ0Bi61UuqauDwBW5bPz9mcJf6hVdEGwa9O3DbZ5KBqzetI09GaIwSMgzD4I8//kBcXBxGjBiBTZs2YeXKlYiIiMCmTZtQUlKC2bNn87ViVq1aBQAoKirCkiVLEBsbi0mTJkEmk+GNN97gzzt//ny4urpizJgxWLJkCZYsWYKwsDAAQEREBBYsWICFCxciLi4O/v7+mD17tskGwBqprKxEYmIiAK6cf7du3QS2yDy4uLggKioKAHDhwgWo1WqBLbJucnJy+G1bETLt2rVD+/ZcFbYjR46gqKhIYIusH7G0JGgMw3oynBgxLITX8LGPjtCrKbPP9LbZIkaFlhQKBb766qt6P1u7dm2Dx/Xp0wfbtm1r8HMnJyesXLmywc/Hjx+P8ePHN91QG+fgwYOoqKgAYH3Lru+me/fuuHr1KqqqqnD16lV06tRJaJOsFlv0yABceOnq1avQarXYvXs3Hn30UaFNsmrE0pKgMYbXRrWx719Aq2V5z4xPKyCqbnoMz6ShwKLPue2/TrF4/QlxfkcpYT0BOoLHWtsS1AcVxrMctipkKLxkOdJzxdOSoDH8PBl0qak6cvoqF166XZOcPLgrGn14DPZnENmG2z5xGSivpPBSSyEhY4Xo8mNkMhlGjhwpsDXmhYSM5dAXMoGBgQJaYlkGDx7M95TauXMnn/BMmJ6jSbXbU4Y3LgiERpcnw7LAym/1wkoN5MfoE9ud+3+12vA7E82DhIyVkZ6ejsuXLwPgKq96eXkJbJF5ISFjOWwxRwYA7O3tcd999wHg8v2OHTsmsEXWS3pu7XZ0mHhFDGCYJ7PnZO37jeXH6IjtXnvsP2drRZAypQypn6ch47tMFJ8vgVYlrSKGQtHi5deEuLCF1Ur6BAQEwN/fH3l5eTh79ixYlhX1U5yU0XlkZDIZ/Pz8BLbGstx///18I9wdO3Zg0KBBAltknaTn1d7UQ/wFNKQJxHQD7OSAWs9Bp3AEekTe+9hYvfUX/5wFVIUqJL93HTc3ZYDVa3vA2DNwi3ZDq65ucO/qDt/hPnAOo55fd0MeGSvDlvJjdOi8MgUFBYJWm7V2dGMbEBAAuVwusDWWZezYsbxApjwZ83Ezr3Y7VORCxs2ZQd+Ohu/1iwYc7O/9IBXszyC8NWCn1SJgfxr29z6I9HU3DUQMALDVLErOlSBjSxaSFl/GP/0OIesX+o27GxIyVoRKpcK+fdx6Ph8fH4OCcdYMhZfMj1qtRl4ed5expfwYHX5+fujThytocv78eUmV+5cSutCSgz3gL4Go+Ii7KvMObmIBdZZlMd0pF2tTjuDx7GSoS7jSEXJnOSIWhaPDm+3RemIgXKNcDO7SrJrFuacuIOP7LBN9A+uAhIwVcfXqVb6Fw8iRIyVTxbOlkJAxP/n5+XxTOFvKj9GHVi+ZF5ZlkV7jkQn2gyDVfI1lZC9DGwd3vbfN6jI1Tk48jf7xFxBQzZXJYBmgzbQgxJ4YjKhXIhH+TBi6r+2KmKODcV/aCAzY1Q9Bj9b8u2OBC89fRPomEtM6bONOZyOkpaXx2x06dBDOEAtDQsb82Gqirz76odrDhw8LaIl1UqwESrlewaIPK+no3wlwrumWI5MBA+5RxkpbrcWZJ8+hYH8h/95ZFy98O7Y/un7aGU6BdVvv2LnYwbOPB7p+2hlh82t7TiW9eAk3vkozxdeQPCRkrAh9IaOrjGwLREZG8k1ESciYB1utIaNP165dYWfHrY84f/78PfYmjCVdLz9G7Im+OhzsGTxZ46ibNBRwd2nYI8OyLC68kIRbfxUAAOzc7PB51+54NbQntue4oUrVeD0ZhmHQ8a0OCH+hthv05Vev4vpHqS3+HlKHhIwVcePGDX7bloSMXC7nm/mlpKSgtLRUYIusDxIygKOjI+/pvHz5MlQqlcAWWRdSSvTV5+PnGaRtZfDD642Hla4uv4asn2pW/jnK0Ov7HvAZ6QswDCpVwMkr974WwzBovzQSkUva1Z73zWRceycFLGu7hfVIyFgRtuqRAQzDS/S0bHpstRje3egEc3V1NV+viTAN+jVkQgPEnx+jg2EYhAYwjZZ9SP0iDamfptUcAHRf2xXeg7zuqifT9OtFLo5A+2W167xT3r2OtK9vNsN664CEjBWhEzJyuRxBQUHCGmNhKE/GvFCODId+A9Zz584JaIn1IaUaMsaQ9XM2riy9yr/u9F40AsZzX1BX4RcwLIzXFNq9EI6Oq2pzIZNXp6D6TnWLbJUqJGSsCJ2QCQ4O5mP5tgIJGfNCoSUOfSFDnj/TItXQUmPcSizA+f9c5F9HvtwOoU/UdpQMbw0E+XLbhy8C1WrjxEzb+aFoM517aFWXqJH66Y17HGGdkJCxEoqLi3H79m0AQNu2be+xt/XRpUsX3rVLQsb06ISMXC6Hr6+vwNYIB3lkzId+sm8bK5hiJUml+HfWWb7IXcisYEQsbmewD8MwfJXf8krgVBPyZO4mcnE7yBy43760r2+iKr+qRXZLERIyVkJ6ejq/bWv5MQDg4uKCqKgoAMCFCxegVqsFtsi60K/qayv1ierD39+fF3Lnzp2z6QRLU6PzyAR4AU6O0smRqQ9Ww+LCCxehKeP6F/jf74dO73asN49maA/j82T0UQQrEPw45+XRlGtw/UPbW8Vku79IVoatrljSRxdeqqqqwqVLl4Q1xopQq9XIz88HYNthJYB7gtZ5ZW7duoXc3Nx7HEE0hSoVi5ya0iqhAcLaYgpufpuJ4jMlAADX9i7ovrYrGHn94swgT+Zc84RxxMJwyBTc7fzm5gxUZFY06zxShYSMlWDLK5Z09O7dm98+efJkI3sSxpCXl8d7HmxdyACUJ2MOMvJrt6We6FuVX4Wrb17jX3d6Lxpyp4Z7k0W24bxQAHDoPKA2Mk8GABz9HRE2LxQAoFWxSFlz3ehzSBkSMlYCCRmgb9++/DYJGdNBib6GUJ6M6bGmRN8rb1yDupgLbQdNaQ3vQY03jWIYhvfKKCuAM8nNu274c2Gwc+MWeWT+XzbKrpc170QShISMlUBCBujZsyefv3HixAmBrbEeSMgYQkLG9KQbCBnp5scUHi7ii97ZtbJDh+VRTTpOv57M/rPNu7aDpwPa/icMAJejc+2dlOadSIKQkLESdELGzs7O5mrI6HB1dUV0dDQALuG3osK24sTmgorhGdKhQwfY29sDoNCSqUjPlX4NGa1Ki6QXa3Pz2i+NgqOvY5OObUk9GX3azg+Fgzc3N3O25aIkyTaqnJOQsRJ0QiYkJARyecPxWGunT58+ALgEVVqGbRqoGJ4hDg4O6NixIwDgypUrqKqyveWupuamXo6MVJN9b3yZBuU1LpzTqmcrhMxs0+RjO4YCvh7c9sHzgEbTPDFj52aH8AXh3AsWuLaqmXEqiUFCxgq4c+cO7ty5A8B2w0o6KE/G9FBoqS668JJaraYVciZAvz2BFD0yFRkVSFlTs+xZBnReE93gKqX60M+TKSkDzrUgKhT6RDAcAzhPUP6uW7hz6k7zTyYRSMhYAZQfU4vOIwNQnoypICFTF8qTMS26ZF83Z8DDVVhbmkPSksvQlHM1Y0KfDEGrbu5GnyO2m149mRZMKblCjki9wntXV1l/rgwJGSuAhEwtXbp0gaMj9zRCHhnToBMydnZ28Pb2FtgacaBrHglQnkxL0WpZPrQU6o9Gmy+Kkbyd+cjfdQsA4OjvgKhXIpp1HlPlyQBAm+lBcA5TAAAK/ylE6WXrzpUhIWMFkJCpxcHBgS+Md+3aNT7kRjQfXY5MYGCgTVf11Yc8MqYjrwhQ1fQ6lFpYSV2mxqX/1XZB7/hmB9i72zfrXJ3aAl41jpx/zhrfd0kfmb0MYU+F8q8zvs1s9rmkAP0qWQEkZAzRz5M5deqUgJZIn+rqaqrqWw9+fn4ICOCyUqlVQcuQcqLv9Q9SUZFRCQDwjvFC4MPN/wIyGYNRNTU97yiBxH9bZlvQpNaQOXG3+MyfsqGp0LTshCKGhIwVoN+ewBYbRt4N5cmYDv0S/CRkDNF5ZQoLCw3yiAjj0E/0lVINGeVVJVI/TwMAyBwYdHo3usVhscnDao/fmtgycWzvYY/ACZywUherkbs97x5HSBcSMlaAziNjb29PdT5AK5dMCSX6NgzlyZgG/aq+UgktsSyLpJcug63mxEb4c23hGunS4vOO7Q+4cqkt2HYAUFW3TMwEP167BPzmFusNL5GQkTgsy1INmbuIjIyEuzsXbCaPTMugYngNQ3kypiE9r/ZmLZX2BNm/5qDwUBEAQBGqQLuF4SY5r8KRwQODuO07SmBvCyPjnn094NqeE1i3j96G8qqyhRaKExIyEufOnTsoKeG6rFJ+DIdMJuPDS9nZ2cjKyhLYIulCxfAahoSMaTAILUkgR6a6uBqXl17lX0e/3QFyhekeIKcMrw0v/dTC8BLDMAieaf1eGRIyEocSfetHP0+GwkvNh0JLDdO+fXs4ODgAICHTEnTJvnby2i7QYubaqhSo8lUAAP84P/iP9jPp+Uf3BdxrolS/HwIqq1omZoImt4bMkbvVZ/2UDU2l9SX9kpCROCRk6ofyZEwDCZmGsbe353t7Xb16FZWVlQJbJE10HplgP0BuRDVcISg+W4z0jTcBAHJnOaLf7mDyazg6MHhwMLddUgbsaeHPl4OXAwLGczG76qJq5O3Iv8cR0oOEjMTRX7FEQqYWWrlkGihHpnF04SWtVoukpCSBrZEeJWUs7tSkbYg90ZfVsLj44iVAy72OWNwOijYKs1zLlOElAIbhpW8zWnw+sUFCRuLoe2Ro6XUtQUFB/I335MmT0Gq1AlskTXQ5Mvb29lTVtx4oT6Zl6K9YEnuib8aWTBSf4fIRXdu7oK1ewTlTM7I34OnGbW8/DFS0MLzkNdATLu2cAQBFh25DmVLWUhNFBQkZiUOhpfphGIb3yhQXFyMlxfr7jZgDnUemdevWkisdbwlIyLSMdH0hI+JEX9VtFa6+eY1/3em9aMgczHf7dLBn8NAQbltZAew81rLzMQyD4MeD+deZ31lX0i8JGYlDNWQaRj9PhsJLxlNVVYWCggIAlB/TEFRLpmUY1pARr1BOX38T1XfUAIDWkwLhPcj8WcmTTRxeCprSGow9d87MH7KhVVmPl5qEjITRryETGhpKfXDuglYutQyq6ntvfHx8+LGhVgXGk54r/hoy6jI10r7mEnwZOYOo/zWvKaSxDO8JeLfitv88CpRVtGxuOfo4IOB+bpBVBSrk7bSepF+680mY27dvo7SU62pKYaW69O7dm98mj4zxUKJv09CFl27fvo3MTOty2ZsbKYSWMr7LQnUR19Uy8KEAOIc6W+S69nYMHonhtssrgR1HW35Og6Tfb6xnrpKQkTC0YqlxvLy8EBHBPT2dOXMG1dXVAlskLagYXtOgPJnmox9aCjZtORaToFVpceOzNP51uwWWXVChH17a+nfLvX3eg73g3JZbaVX4TyHKbpS3+JxigISMhKEVS/dGlydTVVWFCxcuCGyNtKAaMk2D8mSaj84j4+fJlecXG1k/56Aym6sP5DfGF24d3Sx6/dhu3NgAnEemtLyFlX5lDIIfq/XKWEvSr9FC5q233sLo0aMRGxuLKVOm4ODBg/xnmzdvxsiRIzF8+HB8/PHHBvHipKQkPProoxg0aBDmzZtn8LRXWVmJpUuXIiYmBuPGjcOuXbsMrhkfH4+4uDjExsZi+fLl9GRdA61YujeUJ9N8SMg0DfLINI9qNYtsLpdclDVkWA2L1E9qvd7tFpimn5Ix2NkxeCSW265UAX8eafk52zwaBMaOE40Z/5cFbbX0k36NFjLTp09HfHw8/vnnHyxbtgxLly5FSUkJDh06hF9++QWbN2/G1q1bcejQIWzfvh0AoFKp8NJLL2Hq1KlITExE586dsWzZMv6ca9euRXFxMRISErBq1SqsXr0a6enpAICUlBR8+OGHWLNmDXbs2IHs7Gxs2LDBRF9f2pCQuTe0cqn5UI5M04iKioKjoyMAEjLGkJkP6J51xZjom5eQj7Kaeitegzzh2cdDEDtMXRzP0c8R/mO5OJ4qX4X8XbdafE6hsTP2AP0bJsMwUKlUKCgoQEJCAiZOnIg2bTi31YwZM7Bz505MmDABp0+fhkKhwIQJEwAAc+fOxciRI5GTk4PAwEAkJCTg/fffh6urK7p164aYmBjs2bMHc+fOxa5duzBq1Ci+FPicOXOwcuVKPPXUU/Xap1KpoFKpDL+knR3fE8VYdIXUxFhQTT9HJiQkRBQ2im28unbtCrlcDo1GI8rCeGIbL330hUxAQIAobBTjeMlkMnTq1An//vsvkpOTUVFRwQsbMSDGMQOAG7VOeYT4i8c+rVYLlmWR+nHt72vb58MEs29gJyDQG8gpBHYeB26XaNHKtWXnbPNYEHLjubjezW8y4DfOt9nnMvf8aspqXKOFDACsXr0a8fHxqKqqQmxsLMLDw3Hjxg3ExcXx+0RFReHzzz8HAKSmpvJJlwCgUCjQpk0bpKamwsXFBYWFhQafR0VF8eW+U1NTMWDAAP6zyMhIZGVlobKyEk5OTnVs27RpE9atW2fw3qRJkzB58uTmfFWejAzxlXVOTk4GADg4OKCqqor3YokBMY1X+/btcenSJSQlJeHy5ctwdrbMqgNjENN46dDNJwcHB5SUlPAr5MSA2MYrJCQE//77L7RaLfbv348OHUzfg6eliG3MzlxyAeADAHC1L0J6unjmV9nxcpSc4+xxbO+IsnAlytOFq4Z7X09PfPOXO1TVwA+7bmFsn5Yl6bJhLOxb26E6W42C/YVIPpoCh9b2LTqnueZXU/I/myVklixZgsWLF+PUqVN8xdTy8nK4utbKRBcXF5SXc4NdUVEBFxcXg3O4uLigoqIC5eXlkMvlBqKksWN116ioqKhXyDzxxBOYPn264ZdsoUcmIyMDwcHBoqrTwrIssrKyAHA1ZMSS7CvG8Ro4cCAuXboErVaLgoICDBkyRGiTeMQ4Xjp0xfCCgoJEE7oU63j16dMHv//+OwDgzp07CA01X/l6YxHrmJX9U7vdvYMXQkPF0fpaq9Xi0FO1ySgdF7dHQJiwsa9xg4Fv/uK2C8p9YYrppZnFInlVCsAC2A+E/q95JxXD/GqWkAEAuVyOfv364YcffkB4eDicnZ2hVCr5z8vKyvgnX4VCgbIyQzVbVlYGhUIBZ2dnaDQaAw9LY8fqrqFQ1N+sy8HBodmipTFkMpmofgQKCgr4cQkLCxOVbYC4xqtfv35Yv349AODUqVOIjY0V2KK6iGm8AC4Bv6ioCACX6Csm2wDxjVenTp347StXrojKNh1iG7OM/NpQRNtABjKZOFYt3TldjPJTFQAAl3bOCHwgAIzAtkWHseAUB3D1ZtPCLfcieHobpLxzHayGReb32Yh8OQIyu+afV8j51eKrarVaZGZmom3btgb9bK5du4bwcC7LOzw83OCziooKZGZmIjw8HO7u7vD29m7yscnJyQgKCqrXG2NL0NLrptOrVy9+++zZs8IZIiH0q/pSou+90eXwAcClS5cEtEQ6pNdOMVGtWtJfqRT+fFswcuEFVkQQoNMIl02UQeAU4Ai/0VxuTFVeFW7tKTDNiQXAKCFTXl6OnTt3ory8HGq1Gvv27cPp06fRo0cPxMXF4ddff0VWVhYKCgrw/fffY+zYsQC4G0lFRQXi4+OhUqmwYcMGREdH8z+QcXFxWL9+PcrKynDhwgUcOHAAo0aNAgCMGTMGe/fuxZUrV6BUKrFx40b+vLYMrVhqOtHR0bCz45yPtKqkadDSa+No27Ytn+BLQqZp6GrIuCgAL3dhbdFRekWJ/ARuFY9jgCNaTxLH3Hd0YBBe8zxxNQPQak3TCiP4cb1Kv1ukW1PGKCHDMAz++OMPxMXFYcSIEdi0aRNWrlyJiIgIDB48GA8//DBmzpyJSZMmYdCgQXjggQcAcOGed999F99//z2GDRuGc+fOYcWKFfx558+fD1dXV4wZMwZLlizBkiVL+JtzREQEFixYgIULFyIuLg7+/v6YPXu26UZAopCQaTqOjo588uXly5dRVVUlsEXih4SMcdjZ2aF9+/YAOI8y1bpqHJZl+aq+IX4QTWf19PU3+e2wZ0IhdxRPKK5jTQpLeSWQaaIV077DfODUhotu3Np7CxWZFaY5sYUxKkdGoVDgq6++avDzJ554Ak888US9n3Xq1Ak//vhjvZ85OTlh5cqVDZ53/PjxGD9+vDGmWj0kZIyjW7duuHjxItRqNS5fvozu3bsLbZKoISFjPNHR0Th//jzUajVSUlLQsWNHoU0SLbfucAXeAPH0WNKqtMj5jVsTzjgyCH4sSGCLDOkQCsTX5CBfSTdNOI6RMwieEYTk1dcBLZDxfRaiXrZMU0xTIh65SRgF9VkyDqq+ahxUDM94KE+m6ejnx4ilGF7+X7dQfUcNAHAb5go712avhTELHUJqvVamypMBgDbT2vBKIPO7LLAa6XVwJyEjUXQeGUdHR/j7i+SXQMSQkDEOahhpPCRkmo5+s8gQf3GElbK21or3VnEiSdrRo0NI7faVm6YTG4ogJ/jdxyX9VmZX4tY+6SX9kpCRICzL8kJGjEuvxQgJGeOg0JLxkJBpOul6QkYMHpnqO9W4tYdLPHHwdYBLX/EVzeygV+blys2G92sO+o0kb34jrsKJTYHugBKkoKCALxhIYaWm4e/vj4AALhh/9uxZg4amRF10QkahUKBVq1YCWyMNIiIi+NVxJGQa52Ze7b8/MeTI5PyeC62Ksynw4QC+qaKY8HJn+E7YV0xcxN13pA+cArlVd/l7bvEdv6UCCRkJQom+zUPnlSkqKuKrIhP1oxMyrVu3Fs2KErFjb2+PqKgoAMDVq1ehVqsFtki8ZOlFL9o0v82Pycj6Wc8DOUm8OWG68FJuEXCn1HQPYzI7GdrMqPHKaLmu2FKChIwEISHTPCi81DQqKipw584dAJToayy68FJVVZVBQj5hSFFJ7baPwA6/8vRy3D52BwDg2t4F7l3dhDWoEQzzZEx77uAZQUDNM0vmd5mSSvolISNBSMg0DxIyTaOwsJDf9vPzE9AS6UF5Mk2jsEbIONhzBfGEJOvn2sT2oMni9kB2DK21zdRCRtFGAd+RXBPPioxKFOyXTtIvCRkJomvmB4BWLBkBCZmmcfv2bX7b09NTQEukBwmZpqHzyHi5CVsMj2VZg9VKrSeK2wNpkPCbbnqPScjMYH775jfSqfRLQkaCFBcX89uUiNl02rdvz5eRJyHTMLqwEgB4eHgIZocUISHTNIpKuf8L3Zqg+N9ilF/nFk54DfaEoo3A7qF7oB9aMmUtGR2+9/nA0b8m6XfXLVTmSCPpl4SMBCEh0zzs7Oz4LsXXrl2r05Gd4CAh03yioqL4cggkZOqnSsWirKYSvtBCJmurYVhJ7IT4AwpOZ5g8tARwSb/BM7iKxqyGRaZEkn5JyEiQkpLaTDkSMsaha03AsiwuXrworDEihUJLzcfR0REREVyJ98uXL0Or1QpskfjQT/T1EjCvVltd25JA5iRDwHgRrAO/BzIZg/Y1Xpnr2YCq2vThpTYz2vBJvxlbMsGaqEGlOSEhI0H0PTLu7uKrQClmKE/m3pBHpmXowksVFRVITzeD/1/i6MJKAOAt4HPYrX0FUBVyzT39x/rB3l1cLQkaQhde0miA62ZwmDiHKOA7XD/pt/AeRwgPCRkJohMyTk5OcHBwENgaaUFC5t6QkGkZlCfTOGLxyGTrrVYSc+2YuzFXzyV9gmdKq9IvCRkJohMyFFYynq5du/LbJGTqh0JLLYOETOMYCBl3YVYsVZdUI29nPgDAwceB90BIAXPWktHhN9oXjv7cQ3L+rluozK0yz4VMBAkZCaLLkSEhYzyenp4ICeF+Cc6fP085DPVAHpmWQUKmcQoNhIwwNuRuz4O2ivu3H/hQAGT20rkVdgyr3TZl80h9ZPYyris2AFbNIvMHcSf9SuevRwAAtFotCZkWogsvlZaWGhQXJDhIyLSM9u3b87VRSMjURd8j4y2QkNFvSSCF1Ur6RLYBdKV3TN1zSZ/gx4L4bbEn/ZKQkRhKpZJveEiJvs2D8mQah0JLLcPZ2Rlt27YFwAkZalBqSJFejyAhPDJVeVUoOszNcZd2zmjVQ1q/owpHBmE1C6yu3ITZ5pdzqDN8hnkDACrSK1Dwj3iTfknISAyqIdNy9IXM2bNnhTNEpOg8Mg4ODnBychLWGImiCy8plUpkZkqnQqolEDrZN3dHHlBz7w98MEDULQkaQpcnU1oOZJuxk4B+0m/Gt+KdxyRkJAYJmZajqyUDkEemPnRCxsPDQ5I/8mKA8mQaRugcmdztefx2wHhptnjpqN+qwEwJvwC3LN3Bj0v6zUvIR1W+OJN+SchIDCqG13LCw8Ph6uoKgIRMfehCSxRWaj4kZBpGyByZqgIVio5w89u5rQJuncXb6boxOug3jzRjnozMXoY2j9ZU+hVx0i8JGYlBHpmWI5PJ0KVLFwBcJ3H9MbV1NBoNL5Yp0bf5kJBpGF1BPHs7y3e+zt+ZD1bDxZUCxkszrATcvQTbvDlYIfrhJZEm/ZKQkRhU1dc06OfJnD9/XkBLxIW+x4+ETPPp0KEDv01CxhC+87W75Ttf52zP5bcDHpBmWAkw7IJtrqJ4OpzDnOEdyyX9lt+owJ3T4nvwIyEjMcgjYxpo5VL90Iol0+Dm5sbXK6KVS4bwQsbCUZ3qO9UoPFAEAFAEO6FVd+k+CPp6MHx7B3PmyOgI0qt8nPN7biN7CgMJGYlh6hyZsLAwfPTRR03ef//+/WAYxqDWiBQhIVM/VEPGdOjCS3fu3EFOTs499rYNVNUslDWdry3dZylvZz5YtS6s5C/ZsJIOXXgp6xZQWm5eoewf5weZAzdeuX/kii68REJGYpjaI3Py5EnMmzevyfsPHDgQOTk5kvcGdenShf8hoyXYtZBHxnRQnkxdhFx6nRuvt1rpAfF3ur4X+nkyV83slbFvZQ+fmjYOlTlVuH3ijnkvaCQkZCRGU3JkWJaFWq1u0vl8fX3h7Ozc5Os7ODggIEC6SXI6XF1dERERAQC4ePFik8fL2iGPjOkgIVMX/c7Xllx6XV1SjYK/uYIrToGO8Ogl7QcxwDLNI/UJnFAr/nJ+E1d4iYSMxEhISOC3+/fvD4ZhsHnzZjAMg927d6N3795wdHTEwYMHcf36dUyYMAH+/v5wdXVFnz59sHfvXoPz3R1aYhgG69evx0MPPQRnZ2dERkZi+/bt/Od3h5Y2b94MDw8P7N69Gx07doS7uztmzZpl4EpXq9V4/vnn4eHhAW9vb7z88st4/PHH8eCDD5pljJqKLrxUWVmJ5ORkQW0RCyRkTAcJmboI5ZHJ330LWpVeWEkm7QcxwDI9l/TxG+MHmSMnGXLjc/nVX2KAhIzEaN++Pb999uxZ5OTkIDg4GADw0ksv4e2338bly5fRtWtXKJVKxMXFYe/evThz5gxGjx6N8ePH4+bNxv2Qy5cvx+TJk3H+/HnExcVh+vTpKCoqanD/8vJyrFmzBlu2bMH+/fuRnZ2NxYsX85+/8847+P7777Fp0yYcPnwYJSUl+P3331s2ECaA8mTqQqEl09GxY0d+m4QMR6HeghfvVpYTEwZF8KwgrATctQTbAh4Ze3c7+I7gwktVeSoUHb19jyMsh53QBoiN3r17IzfX0G2m0Wggl8vNet2AgACcOnXqnvtVVFTw25GRkXB2dsaVK1cAACtWrMCoUaP4z729vQ1u1itXrsRvv/2G7du34z//+U+D15g1axYeffRRAMCqVavw6aef4sSJExgzZky9+1dXV+Orr75Cu3btoNVq8dhjj+GLL77gP//000/xv//9Dw899BAA4LPPPjPwLAnF3UJm6tSpAlojDsgjYzo8PDzQunVrZGdnIykpCSzLSj4k21KECC2plWrcSuTCSg5+DvDs62GZC5uZsADAwR5QVVtm5RLAdQrPS8gHwIWXvAd7WebC94CEzF3k5uYiK0uc1QuB2hwZhmGgUBhWk+rdu7fB67KyMixfvhx//vknsrOzoVarUVFRcU+PTNeuXfltFxcXuLm5IT8/v8H9nZ2d0a5dO/61n58fv39xcTHy8vLQt29f/nO5XI5evXpBq9Xe49uaF/LI1IWEjGmJjo5GdnY2ioqKcOvWLfj5+QltkqAIEVq6tbcA2krutyZgnD8YuXWISbmcQVQbFhdvAMmZgFrNws7OvN/N7z5fyBQyaCu0yP0zD9HvdBBFXIeEzF0EBNR1O1rKI9MUdELGwcGhztOdi4uLwevFixdj9+7dWLNmDSIiIqBQKDBx4kSoVKpGr2Fvb2/wmmGYRkVHffvfXTfjblvFUFcjODgYrVq1QnFxMe/VsnUotGRaoqOj+by0y5cvk5ARoPO1tRTBq4+OYcDFG0C1GkjNAaKCzXs9O1c7+I3yRe72PKgKVCg6dBteMcL/TpCQuYu7wztarRbp6ekIDQ2FTCa89NQJGUdHx3vue/DgQcyaNYsP6SiVSqSlpZnTvDq0atUK/v7+OHHiBIYMGQKAE4ZnzpwxaN4oBAzDoE2bNiguLkZOTg65/kEeGVOjWxkHADdu3EBsbKyA1giPQY6MBYSMplyDW3/VhJW87eE1UPibrim5O0/G3EIG4DqG63KOcv7IFYWQEf7OTDQZlmX5gnhqtRppaWkoKCho0FsSERGBbdu24ezZszh37hymTZsmSDjnueeew9tvv40//vgDV69exQsvvIDbt2+LQjQEBnIVKysrK6nnEgyFjNRrBYmB0NDaWvLp6RbIyBQ5ls6RuZVYAE25BkBNUTc767rl6S/BtlSejN8oX8iduQhFbnwetNXCpggAJGQkRWVlJaqrqwFweSbR0dHw9fVtMOflww8/hKenJwYOHIjx48dj9OjR6NmzpyVNBgC8/PLLePTRRzFz5kwMGDAArq6uGD16NJycnCxuy93ohAwAqr6K2tCSq6trnZAhYTxhYWH8tqW9oWLEIEfGAkLG2org3Y2+R+ZyumXC9XJnOfxG+wIAqm9Xo/BgwytaLQWFliSEvsdg6NChBvVdZs2aVWf/sLAwJCYmGrz37LPPGry++8e1vtwV/af0oUOHGuwza9asOte+7777oNFo+Nd2dnb49NNP8emnnwLgwnUdO3bE5MmT61zL0twtZPSXzNoiur81hZVMA3lkDNEJGTs54GrmzteaSg3yd3GLDuw97OA9RBwrbEyJfigpxYJrVAInBPBF8XJ/z4P7IlfLXbweyCMjIaTaMDI9PR3r1q3DtWvXcOHCBTz99NO4ceMGpk2bJrRp5JG5CxIypqVVq1b8WJJHBiisETLerczf+brg70KoldwDld9YP8jsre925+rMwK8mRSU123LX9R3pA7kLF17KS8gHWy3s4g3r+8taMVIVMjKZDJs3b0afPn0waNAgXLhwAXv37hWF94OETC1VVVV8nSJasWQ6dF6ZjIwMA0+lLWLJztf6XZr1y+tbG+Gtuf9nFwAVVRYKLynk8B/LrcBTF6uhPF5mkes2BAkZCWHqzteWIjg4GIcPH0ZxcTFKSkpw5MgRxMTECG0WABIy+tCKJfOgy5NRq9U2Pcf0O1+bOz9GU65B3s7asJJPrLd5Lygg4bU/YUiz4PQKfLBWHJb+pbTcheuBhIyEkKpHRsyQkKlFX8iQR8Z06OfJ2HJ46bb+iiUze2Ty996CpqxmtdL9/pA5WO+tTueRAbhaMpbCZ7gP7Ny4NNvS/UpoKoXzNhr111WpVFi+fDni4uIQGxuLefPmISUlBQBXyn7IkCH8f/369cPChQv5Y3v37o3Bgwfzn2/cuJH/rLKyEkuXLkVMTAzGjRuHXbt2GVw3Pj6ev+by5cv5lTu2RlM6XxPGoS9ksrMtGGQWIfrF8MgjYzr0Vy7ZcsJvod6KJW8zP4fpd2fW9xxYI+Gta3ONbljwJ0zuKIN/HBde0pZpUbi/0HIXvwujhIxGo0FQUBA2bdqExMRExMTEYNGiRQCAV155BQcPHuT/i4iIqFP86ffff+c/nz17Nv/+2rVrUVxcjISEBKxatQqrV6/m/8GnpKTgww8/xJo1a7Bjxw5kZ2djw4YNLf3ekoQ8MqbH1dUVrq5cxj15ZO7w2yRkTAd5ZDgs1Z5ArVQj/69bAAAHHwerXK2kj6FHxrJJt/oiMef3vEb2NC9GCRmFQoE5c+bA398fcrkcU6ZMQXZ2tsEPIMBVsLxx4wZGjhzZpPMmJCRg3rx5cHV1Rbdu3RATE4M9e/YAAHbt2oVRo0YhOjoarq6umDNnDnbu3GmM2VaDVHNkxI7OK2PrQobaE5gH8shwGNaQMd+Kpfzdt6CtqOmtdL+/1RXBuxv9HBlLrlwCAJ+h3vAe6gX///qi/bJIy15cjxbVkTl//jy8vLzqPL3t3LkTgwcP5p90dcyYMQMMw6Bfv35YsGABPDw8UFJSgsLCQoNS3lFRUUhKSgIApKamYsCAAfxnkZGRyMrKQmVlZb0F1VQqVZ1eQnZ2dnBwcGjWd9RVwhW6wSFg+MTs5uYmCpvuRkzj1VQCAwORnJyM0tJSlJaW1ulZZU7ENF5FRbWFrdzd3UVh092IabyaSnBwbbGPGzduWNx2sYxZgV7hbA83FlqtebwH2b/VPpAEPOhn9PcWy3g1lQCv2i7YqdkWttsO6PVTD2RkZMAhwMEs125Ka6BmCxmlUolVq1bhmWeeqfPZ7t27sWDBAoP31q1bhy5duqC0tBTvvPMOVqxYgQ8++ADl5eWQy+UGosTFxQXl5eUAgIqKCoMbi04cVVRU1CtkNm3ahHXr1hm8N2nSpBYXX8vIyGjR8aZAvyu3UqkU9dOdGMarqejnG506dcrgCdpSiGG89MMe1dXVNL9MBMuycHFxQVlZGa5fvy7YuAo9ZtfT3QBwYR626hbS08tNfg2NUoNbe7neSnY+cpQElqA0vfQeR9WP0ONlDEHerXEj1x7Xs7RIS8uAEN1fzDVebdu2vec+zRIyVVVVWLRoEQYPHowJEyYYfHbu3DmUlJRg0KBBBu/36NEDAOeyfvHFFzFu3DhUV1fD2dkZGo3GwMNSVlYGZ2dnAFw4q6ysdo26Uqnk36+PJ554AtOnTzf8ki30yGRkZCA4OFjwppH6NSg6duyIkJCQRvZumPDwcLzwwgt44YUXAHDtDn799Vc8+OCD9e6flpaGdu3a4fTp0/ds9NjYeBlzHkvSrl07flsmkxnkNJgbMc0vfaKioiw6Dk1FrON1L8LCwpCUlITs7GyL2y6WMWP17jZR4b4wx/TK+imbL84W9FBrhIWHGX0OsYyXMUSFADdygfIqGZxbhfJF8iyBGMbLaCGjVqvxyiuvwNfXt47XBeByWkaMGNGocNB9WZZl4e7uDm9vb6SkpKBz584AgGvXriE8PBwAd9PVrYwCgOTkZAQFBTXYp8fBwaHZoqUxZDKZ4JNaP0fG09OzRfYwDMMfn5OT0+j5dO8bMwZPPvkkiouL8fvvv/PvhYaGIicnBz4+PoKPpT6tW9dmy+Xl5Qlimxjml34yuZeXl+D2NIYYxssYdEKmqqoKBQUFCAiw/Eoaocfsdmlt2MGnFQOZzPRug9w/ahNOWz8c2KLvK/R4GUO71rVjm5bLIMDb8i4ZIcfL6Ku+9dZbqKqqwhtvvFGnxLRarcZff/2FMWPGGLx//fp1XLt2DRqNBiUlJXj//ffRr18/XnDExcVh/fr1KCsrw4ULF3DgwAGMGjUKADBmzBjs3bsXV65cgVKpxMaNGzF27Njmfl9JoxMyDMPAzc10af8BAQFwdHQ02fkaQi6XIyAgAHZ24mrxRbVkOGjVkvmglUvmbxipuq1Cwd/cEmCnICd49PYw/UVEiv4SbEsn/IoBo4RMTk4O4uPjcebMGQwbNoyvCXPmzBkAwLFjx+Do6Finw3JRURGWLFmC2NhYTJo0CTKZDG+88Qb/+fz58+Hq6ooxY8ZgyZIlWLJkCZ+nEBERgQULFmDhwoWIi4uDv7+/wdJtW0L/ifluHnjgATz++OO4fv06JkyYAH9/f7i6uqJPnz7Yu3dvo+dlGMbAc3LixAn06NEDTk5O6N27N//31aHRaPDkk0+ibdu2UCgUaN++PT7++GP+848++gjffvst/vjjDzAMA4ZhsH//fqSlpYFhGJw9e5bf959//kHfvn3h6OiIwMBALFmyBGq1mv986NCheP755/HSSy/By8sLAQEBBnPHFJCQ4aBVS+aDVi4Z1pExh5DJ25EPVs2FlQIfDABjBo+PWDFYgm2DQsaoR+PAwECcOnWqwc8HDx6MHTt21Hm/T58+2LZtW4PHOTk5YeXKlQ1+Pn78eIwfP94YU60SnZBhWRZ///03RowYAYC7Ae3evRvx8fFQKpWIi4vDypUr4eTkhG+++Qbjx4/H1atXm5RTU1ZWhvvvvx/Dhw/Hd999hxs3bvC5NDq0Wi3atGmDrVu3wsfHB0eOHMG8efMQGBiIiRMnYu7cucjJyUFpaSk2bdoEgAtV3F1wLisrC3FxcZg1axa+/fZbXLlyBXPnzoWTk5OBWPnmm2/w3//+F8ePH8fRo0cxa9YsDBo0iPfatRQSMhw6j4xMJquz4pBoGeSRMex87eZs+vPbUhG8u6lbS8Z2RBzQwuXX1kjvuVrkFum9wQIaTRDkcgCM+Za1BXgBp9Y17iDTCRk3Nzf83//9Hy9kfv75Z3h5eWHEiBGQy+Xo1q0bf8zKlSvx22+/Yfv27fjPf/5zTzu+//57aDQabNy4Ec7OzujUqRMyMzPx9NNP8/vY29tj+fLl/Ou2bdviyJEj2Lp1KyZOnAgXFxcoFAqoVKpGcwG++OILBAcH47PPPgPDMOjQoQOys7Px8ssvY9myZXy8tWvXrnj99dcBcMvvP/vsM+zbt4+EjInRCZlWrVpJJjdAKpBHBiiqWTzk5W76ztdVt6pQeJD74XYOU6BVD9uqfN5WwFoyYoCEzF3kFgFZt+5+V/hhqq6u5jsTBwYG4tdff8UXX3wBR0dHfP/995g6dSrkcjnKysqwfPly/Pnnn8jOzoZarUZFRQVu3rzZpOtcvnwZ3bp141eNATCo46Pjq6++wvr165Geno6KigqoVCqjVyJdvnwZAwYMMPhRGzRoEJRKJTIzM3kPUteuXQ2OCwwMRH5+vlHXagxPT084OjqiqqrKpoWMLrREYSXTQx4Z83a+zo3PA6vhwkoBEwJMLpTEjrsLA59WLAqKScgQ4DwjBrCARqOGXG5nVm9dnevehf6KpbCwMOTk5GDHjh3o06cPDh48iA8++AAAsHjxYuzevRtr1qxBREQEFAoFJk6cWKdIYEOw7L2LVG3duhULFy7E+++/jwEDBsDNzQ3vvfcejh8/3qRr6F/r7h8c3fX137e3tzfYh2EYkxZeYhgGAQEBSE9Pt1khw7Is75GhRF/T4+fnBycnJ1RWVtqkR0ZVzaK0pmyMOfJjcn6vDSu1fsi2wko6wltzRQczbwFVKhaODrYj5kjI3MXd4R2tVov09CyEhoYK6m7XT/T19PTEww8/jO+//x4pKSmIiopCr169AAAHDx7ErFmz8NBDDwHg6u4Y8wQYHR2NLVu2oKKigq/Vc+zYMYN9Dh48iIEDBxoUQ7x+/brBPg4ODgZ1bxq61q+//mogaI4cOQI3NzcEBQU12WZTEBgYiPT0dBQWFkKlUpllCb+YKSsr4/9e5JExPQzDIDQ0FFevXkVaWlq9It6a0e987W1iIVOZU4miI5w30SXCBW6dzdxaW6SEtwZOXAZYFkjPA6KC732MtUCBcIlwd8PI6dOnY8eOHdi4cSNmzJjBfxYREYFt27bh7NmzOHfuHKZNm2aU92LatGmQyWR48skncenSJSQkJGDNmjUG+0RERODUqVPYvXs3rl27hqVLl+LkyZMG+4SFheH8+fO4evUqCgoK6u1Y/swzzyAjIwPPPfccrly5gj/++AOvv/46/vvf/1pcNOrnyeTm5jayp3VCna/Njy5Ppry8HIWFwnUKFgJzLr3Ojc8DahzJgQ/ZXlhJhy3nyZCQkQh3N4wcPnw4vLy8cPXqVUybNo3/7MMPP4SnpycGDhyI8ePHY/To0XWWwzeGq6sr4uPjcenSJfTo0QOvvvoq3nnnHYN9nnrqKTz88MOYMmUK+vXrh8LCwjqtKubMmYP27dujd+/e8PX1xeHDh+tcKygoCAkJCThx4gS6deuGp556Ck8++SRee+21JttrKmw94ZdqyJgfW86TKdLzyJhcyOyoLYJna6uV9LHlWjIUWpIId3tk5HJ5neXMAPfUl5iYaPDes88+a/D67h/Ru/Ni+vfvb1Dr5e59HB0dsWnTJn5ptY63336b9/74+vryHcwbu1ZsbCxOnDhRZz8d+/fvr/Oefs0bU0FC5g6/TaEl86AvZNLT09G7d28BrbEshXolsLzcTOcxUd1W4fbROwAA53bOcG1vuYavYsOwC7ZtLcEmj4xEuFvIEKZFv02BLQoZCi2ZH/0l2LbskfE24c/Xrb8K+NVK/mP8bDasBNh2UTwSMhJBX8jod2smTAN5ZO7w2yRkzMPdHhlbwiBHxoS5uHm7assw+I/1M92JJUgbX67YIACk2thPGAkZiUAeGfNCQuYOv02hJfNg0x6ZktqQsqlyZDRVWtzaWwAAsPeyh0cf2/5dtLNjEFqTIpSa3bRSGtYCCRmJcHeyL2FabF3IUGjJ/AQGBvI1kWzOI2OGZN+iw0XQlHElA/zu84XMjm5nujyZ0nLDvCRrh/7yEoE8MubF19cXcjnnl7VFIUOhJfMjk8n4atW2JmT0b6qmqiOTl6AXVhpj22ElHbaaJ0NCRiJQjox5kclk8Pf3B2CbQoY6X1sGXZ5McXGxgXi0dkztkWFZFvk1+TEyRxl8hnm3/KRWgMESbBv6GSMhIxHII2N+dOGlvLy8e1YltjbII2MZbLV5pC7ZV26iztcl50pQmVMFAPCO8YKdK1USAcgjQ4gcypExPzoho9VqcetWnc6hVg0JGctgq0Xx9BtGmmKJdN5OWq1UH3VrydgGJGQkgs4jo1Ao6jRRJEyDLSf86kJLjo6OfI8twvTYqkemsEbImCw/Zlftg4bffb6mOakVQB4ZQtTohEyrVq3AsizmzZsHLy8vMAxTpwov0Tz0hUx9VZOtGep8bRls0SNTrTZt5+vymxUovcgl3bTq2QpOgU4tP6mV4OHGwLOmTg/lyBCiQydk3N3dsWvXLmzevBl//vkncnJy0LlzZ4Gtax5hYWH46KOPhDaDx5Y9MjohQ4m+5sUWPTK3TZzom69fBG8MeWPuRueVycgHVNW2EV4iISMBtFotSktrnkBatcL169cRGBiIgQMHIiAgAHZ2xiW6sSwLtVptDlMlja0KGY1Gw+dgkUfGvAQFBfHL/G3FI2Pqqr4G+TFxlB9zNzoho9UCN/Ma39daICEjAZRKJV+lMTMzE8899xxu3rwJhmEQFhaGqqoqPP/88/Dz84OTkxMGDx6MkydP8sfv378fDMNg9+7d6N27NxwdHXHw4EGwLIt3330X4eHhUCgU6NatG3755ReDayclJWHcuHFwd3eHm5sbhgwZguvXrwMATp48iVGjRsHHxwetWrVCbGws/v33X4Pj33jjDYSEhMDR0RGtW7fG888/DwAYOnQo0tPTsXDhQjAMI4oeKbYqZPRXxJGQMS92dnZo06YNANvxyBTqCZmW9lmqLq5G0REun0sRqoBrB9eWndAKMUz4Fc4OS0JCRgLo32j69OmDFStWoE2bNsjJycHJkyfx0ksv4ddff8U333yDf//9FxERERg9ejSKiooMzvPSSy/h7bffxuXLl9G1a1e89tpr2LRpE7788kskJSVh4cKFmDFjBv755x8AQFZWFmJiYuDk5ITExEScPn0as2fP5r05paWlePzxx3Hw4EEcO3YMkZGRuP/++6FUKgEAv/zyCz788EOsXbsWycnJ+P3339GlSxcAwLZt29CmTRusWLECOTk5ohAOtipkqD2BZdHlyRQWFvL/VoSgMrsSNzdnmL2UvaFHpmUPLLf2FoBV1zSJHGvbTSIbwhZrydDi+7s4NPwoVPlV/GsWnOs9VZ5u1qboDn6OGJw4oN7P9IWMt7c33NzcIJfLERAQgLKyMnz55ZfYvHkzxo4dCwBYt24d/vrrL2zYsAGLFy/mj12xYgVGjRoFACgrK8MHH3yAxMREDBjAXTc8PByHDh3C2rVrERsbi88//xytWrXCjz/+yK+UioqK4s83fPhwAzvXrl0LT09PHD9+HJ06dcLNmzcREBCAkSNHwt7eHiEhIejbty8AwMvLC3K5HG5ubggICGjp8JkEXUE8wLaEDLUnsCxhYWE4cOAAAM4r06lTJ4vbcPn1q7jxeRrAAu7d3OHRw3wlHQyETAtzZPIoP+aeGK5cYgGz3rnEAQmZu1DlV/GFlvRRQ7icksaK4V2/fh3V1dUYNGgQ/569vT369u2Ly5cvG+zbu3dvfvvSpUuorKzkhY0OlUqFHj16AADOnj2LIUOGNLjcOz8/H8uWLUNiYiJfRK68vJxf8TNp0iR89NFHCA8Px5gxYxAXF4fx48cbndNjKRwcHODj44OCggKbEjJUQ8ay3L1ySQgh4xrhwj2lAcj+Nce8QsZEyb5alRa3/qppEulhB8/+5D2sD1tcgi3OO4qAOPg5GrzWeWTkcrnZPTIN0VgxPJ1b+G4XK8uydd5zcXHht7VaLQBgx44dCAoKMtjP0ZGz5V71RGbNmoVbt27ho48+QmhoKBwdHTFgwABUV1cDAIKDg3H16lX89ddf2Lt3L5555hm89957+Oeff0RbCycwMBAFBQXIzc2tdwytEQotWRYxrFwKGO+PpJcuQatikbMtFx2XtwcjN89cLyyuDV21pI5M4eEiqEu5B0rfkb6Q2VNmRH0E+3EVlDUaEjI2y93hHa1Wi/T0dISGhkImE+YfTmMemYiICDg4OODQoUOYNm0aAKC6uhqnTp3CggULGjxndHQ0HB0dcfPmTcTGxta7T9euXfHNN9+gurq6XuFx8OBBfPHFF4iLiwMAZGRkoKCgwGAfhUKBBx54AA888ACeffZZdOjQARcuXEDPnj3h4OAgulYAgYGBuHDhAlQqFYqKiuDtbf09XCi0ZFnEUEvG3sMeviN9kZeQj6q8KhQeKoJPrHnmuqk8Mvl6RfBotVLD2NsxCPFjcSMHuJ5d/0OttUGSVgI01jDSxcUFTz/9NBYvXoxdu3bh0qVLmDt3LsrLy/Hkk082eE43Nze8+OKLWLhwIb755htcv34dZ86cweeff45vvvkGAPCf//wHJSUlmDp1Kk6dOoXk5GRs2bIFV69eBcCJqC1btuDy5cs4fvw4pk+fbuDF2bx5MzZs2ICLFy8iNTUVW7ZsgUKh4H/IdbkCWVlZdQSQUNhiwi+FliyLGDwyANB6ol4ByF/MN9dNsfyaZVk+P4axZ+AzzMcEllkvuvBSSZlhHR9rhYSMBLhXw8jVq1fjkUcewWOPPYaePXsiJSUFu3fvvmeY4M0338SyZcvw9ttvo2PHjhg9ejTi4+PRtm1bAFxicWJiIpRKJWJjY9GrVy+sW7eO985s3LgRt2/fRo8ePfDYY4/xS8B1eHh4YN26dRg0aBC6du2Kffv2IT4+nvdyrFixAmlpaWjXrh18fcWRuGfrQoZCS+YnODiYf0IWspaM332+sHPlatrkxudBU2ke76gpkn2Lz5SgMrMSAOA9xAv27hRMaAxby5Oh2SAB7hYyEydONAgbOTk54ZNPPsEnn3xS7/FDhw6td4klwzB4/vnn+dou9dG1a1fs3r273s969OhhUK8GAB5++GH+KfPBBx/Egw8+2OC5+/fvj3PnzjX4uRDYopCh0JJlcXBwQOvWrZGVlSWoR0aukMP/fn9k/ZgNdakat/4qQMB4/3sfaCSFep2v3V0a37chcuNrK7uZw0ZrIzyQgS6bOzUb6N1BWHvMDXlkJAB1vrYctihkKLRkeXTh1by8PFRUVAhmh354KesX8zy6t7TzNcuyyP2zRsjIAP84EjL3wtY8MiRkJMC9QkuE6bBFIaPvkaHQkmXQz5O5efOmYHZ4D/GCg58DAODWXwWoLq42+TV0yb7NDSuVXlaiPJXrOuk10BOOPg4mssx6MRAyOdbfb4mEjARoLNmXMC22KGT0PTIklC2DGFYuAYDMTobWD3IFKbVV2lrPh4moVrMoKeO2m5voaxBWup+8MU2BPDKE6CCPjOWwZSHj6uoq2mKF1oZYVi4B5l29pL9iprl9lgyEzDgSMk3B0w1oVdOGioQMIQp0OTJ2dnb3LFJHtAxnZ2fe62UrQkYXWqKwkuXQ98gILWRa9WwF57bc70rhwSJU5lSa7NwtXXqtTCmD8jLXj8qjjwecWjuZyDLrhmEYvnnkzXxAVW3d4SUSMhJA55Fp1aqV1Rc2EgM6r4ytCBmdR4YSfS2HrsQBACQnJwtoCXfTaz2xJhbBAjm/55rs3C1dek2rlZpPxxqtrNEAF1KFtcXckJCRADohQ/kxlqF1a+5HvaysDKWl1l1NqrKyEpWV3BM4eWQsR3h4ON8KJCkpSWBrgNYP1zZuNWV4ybCqr/EPYYb5MVTN1xj6dqwd75NXBDTEApCQETksyxp4ZAjzY0t5MrT0Whjs7OzQsWNHAMC1a9dQVVW3Ua0lcY1yhXs37kGp+GwJlCllJjlvYW16n9GhpfKbFSg5x7l03Lu5wznU2SQ22Qp9O9Zun7hMoSVCQCoqKqBWc43SSMhYBhIyhCXo3LkzAECtVvNtP4TEIOn3V9PM+6IWJPvqr6Ci1UrG0z0SsOMKN+PEZWFtMTckZEQOFcOzPLYqZCi0ZFl0QgYALl68KKAlHK0fDABqohHZv+TUWw3cWIpKas9hrEcmj/JjWoTCkUGXcG77UhpQWm69XhkSMiKHll5bHlsSMtSeQDjEJmScWjvBe7AXAKA8tRzFZ0ruccS9aW6yb2VOJW6fuAMAcO3gCtfIZvY2sHF04SWWBf69Jqwt5sQoIaNSqbB8+XLExcUhNjYW8+bNQ0pKCgAgPj4e/fr1w5AhQ/j/cnNrs9+TkpLw6KOPYtCgQZg3b57BDaKyshJLly5FTEwMxo0bh127dhlcNz4+nr/m8uXLUV1t+uqTYoWK4VkeWxIyFFoSDrEJGeDumjItL0BS2Ewhk7sjn98mb0zz0U/4tebwklFCRqPRICgoCJs2bUJiYiJiYmKwaNEi/vO+ffvi4MGD/H8BAVwmvEqlwksvvYSpU6ciMTERnTt3xrJly/jj1q5di+LiYiQkJGDVqlVYvXo1X1shJSUFH374IdasWYMdO3YgOzsbGzZsMMV3lwTkkbE8tipkKLRkWUJCQuDqylUtE4uQCRjvD5kjd1vI/iUHWpW2RefT98h4GyFkKKxkGvroNYu05oRfo4SMQqHAnDlz4O/vD7lcjilTpiA7O9vgx7A+Tp8+DYVCgQkTJsDR0RFz587FpUuX+JtEQkIC5s2bB1dXV3Tr1g0xMTHYs2cPAGDXrl0YNWoUoqOj4erqijlz5mDnzp3N+7YShHJkLI8tCRkKLQkHwzC8V+bGjRtQKpUCWwTYt7KH/zhumbOqsBp5u/LvcUTj6JJ9jel8XVWgQuGRIgCAc7gz3KJdW2SDLRMdBrjU1FC15iXYLapHfv78eXh5efE/gOfOncOIESPg5eWFKVOmYOLEiQCA1NRURERE8McpFAq0adMGqampcHFxQWFhocHnUVFRfG2F1NRUDBgwgP8sMjISWVlZqKyshJNT3SqPKpUKKpXK8Eva2cHBoXmNxrRarcH/LY3+jcbNzU0wO5qK0ONlClxdXaFQKFBRUYGcnByzfhehx0t/frm7u4v+7yb0eJmaTp064dixYwA4r0zfvn1Nfg1jxyzo0dbI2calBWRsyYR/C+q36Dwynq5cKYmmJBDn7sgFakz1H+fX5ONMhTXNMYYBekUBB84B6blAToEW/l6mvYa5x0smu7e/pdlCRqlUYtWqVXjmmWcAAD179sSPP/6IgIAAXLp0CS+++CK8vb0xbNgwVFRUwMXFUI67uLigoqIC5eXlkMvlBqLExcUF5eVct9O7j9W5YisqKuoVMps2bcK6desM3ps0aRImT57c3K8KAMjIyGjR8c1Fv6GcSqUSvJx5UxFqvEyFr68vbt68iczMTIuMuVDjlZmZyW9XVFTQ/LIwuuKLAPDPP//A3998YZSmjhkbysI+0A7VOWoU/F2IlOMpsA+wb9Y1b90JBiCDm6Ia6elNy7m5+UvtnGR7awWbk9Yyx9q39sCBc5w3f8fBfIzoXmGW65hrvPSrYDdEs4RMVVUVFi1ahMGDB2PChAkAgKCgIP7zzp07Y+rUqfj7778xbNgwKBQKlJUZFlgqKyuDQqGAs7MzNBqNgYelrKwMzs5c8aO7j9W5XxvqOfTEE09g+vTphl+yhR6ZjIwMBAcHN0kZmhq5XM5vt2vXzqBHixgRerxMRXBwMG7evImSkhL4+fmZrceV0OOlnzgfHR2NkJAQi9tgDEKPl6kZMmQIv52bm2uWf9/NGTP1YxqkvJsKsABzSIbQRcbbVa0GlDX3TH8v+yZ9t+rialw5ybVscGrjhPZjoyzelsXa5tjwvsC6mmyM9EI/mHqKiWG8jBYyarUar7zyCnx9fbFgwYIG99OffOHh4fjtt9/41xUVFcjMzER4eDjc3d3h7e2NlJQUPl587do1hIeH88fqVkYBXF+SoKCger0xAODg4NBs0dIYMplMkD+Sfo6Mp6enZP5hCTVepkI/TyY/P79JTwUtQajx0k8m9/LykszfTOrzS0fXrl357aSkJLN+J2PGLHh6G6S8xwmZzB+yEbGoHRiZcYLidikLgAsJ+Xo0LUSQn3ALbE2Dw4D7/Q0e5CyNtcyx/tG1f4dTV5v2d2gOQo6X0Vd96623UFVVhTfeeMNArBw5coSPt1+5cgU//fQT/7TRq1cvVFRUID4+HiqVChs2bEB0dDR/s4iLi8P69etRVlaGCxcu4MCBAxg1ahQAYMyYMdi7dy+uXLkCpVKJjRs3YuzYsS3+4lKBkn2FQd8zcf78eQEtMS+6RH2ZTAY3t2a0JyZahL+/P3x9fQEAFy5cENiaWhRtFPAZ6g0AqEivQOGhIqPPcetO7bavR9OOyfqxNvyk3/+JaD6hAbXjf+IyLJpvZCmMEjI5OTmIj4/HmTNnMGzYML5ezJkzZ3D8+HFMnjwZQ4YMwSuvvIKZM2fyYsTBwQHvvvsuvv/+ewwbNgznzp3DihUr+PPOnz8frq6uGDNmDJYsWYIlS5YgLCwMABAREYEFCxZg4cKFiIuLg7+/P2bPnm26ERA5tPxaGIYOHcpv//XXX8IZYmZ0Dx8eHh7UWV0gdJ7o3NxcFBQUCGxNLcEz2vDbmd9nGX28sUKmPK0cRUe4+ega5YJWPen3zhQwDMMXxisqAVJbXh5IdBgVWgoMDMSpU6fq/axHjx5YuHBhg8d26tQJP/74Y72fOTk5YeXKlQ0eO378eIwfP94YU60GKognDEOHDoWdnR3UajV2794ttDlmQ+eRoRoywtG5c2f8/fffALjwUmxsrMAWcfiN9YO9pz2qb1cjNz4P1e9Uw96j6Um/hkLm3iI586faO2zQ1NYkrE1Inw4MdhzlPDEnLgPtgu5xgMSQfgDQytEJGYZhyPVvQdzc3DBw4EAAXFHG1NRUgS0yPSzL8kKGasgIhxgr/AKA3FGGoElc+F9bpUXWL8bVVDLGI8NqWWTphIwMCJrUuvEDCKPQ74R98oqNh5YIy6PLkXFzc7OKxDMpMXr0aH7bGsNLSqUSGo0GAAkZIRGrkAGANgbhpcxG9qzLreLaG6bPPaJERUdvoyKdW+LkM9QbTq3rX8xBNA/DCr/C2WEu6M4ocnQeGcqPsTz33Xcfv62rNG1NUHsCcdCpUyd+W2xCxr2TG1p150LaJedLUXy+6Y0kjfHI6Cf5tplqZXEPEeDjwaBtzULMf68BarV1eWVIyIgcnZCh/BjL06NHD3h7cys39u3bB7VaLbBFpoXaE4iDVq1aITg4GAAnZMS2qqRNM5N+mypk1GVq5PzBVRK2c7ODf1zzKwkTDaMLL1VUAUlpgppickjIiJjq6mpUVHDuVvLIWB65XI6RI0cC4ATliRMnBLbItFDna/GgCy/duXMH2dniWlbS+pEAyBS6RpLZ0FRqmnRcQe06hUaFTN6f+dCUcecMfCgAcoVwtWOsGWvuhE1CRsTQ0mvh0c+TsbbwEoWWxIOY82Ts3e0ROJ6r6VJ9R428HU1rJKnzyCgcARdFwyuQMn+o9fIETaUkX3Ohn/BrbZ2wSciIGCqGJzy6WkiA9QkZCi2JBzELGQBoM6M2byXju6Yl/eqETGPemIrM2mJ7zuHO8OzbyM5Ei+gRCejWi5BHhrAY5JERnjZt2iA6OhoAcPz4cQMvhtQhISMe9IWMmCr86vAa6Anntly/scIDRSi9omx0f62WRWHNc1hjQibrp2xd9Xy0mUK1Y8yJi4JB55pOK0lpQFmF9XhlSMiIGCqGJw50q5e0Wi327dsnsDWmQ7+KrK5MPiEMHTt25MsriNEjwzAMQmbXtu1I/fhGo/vfLgVqVvY3KGRYlq0tgsdQWMkS6MJLGg1wJllYW0wJCRkRQx4ZcWCty7D1hYyPj4+AlhAKhQIREREAgEuXLvH1fcREyMw2sPfkKvtm/5qD8psVDe7blBVLd07eQfn1cgCA92AvKNqYp8M8UYu1JvySkBExlCMjDmJjY/mO6rt37xbd8tjmcuvWLX6bhIzw6MJLFRUVuHGjcY+HENi52iFsHueVYTUsUj9t2EYDIdPAT1fmD4YtCQjzY1gYzzp+xwASMqKGPDLiwNnZme/knp6ejpSUFIEtMg3kkREXYk/4BYDQuSGQu3DLozO/z0JVXlW9++kLGZ96+ixpKjTI+Y2rHSN3kSNgvL/JbSXq0qktt4oMAE5eEdYWU0JCRsRQjox40A8vWUsTSZ2QcXFxgUJBbn2hkYKQcfB0QMgsrniftkqLG1+l17vfvUJLeQn5UJdyBSYDHvCHnYtR/YuJZmJvx6BnFLedmg0U3LEOrwwJGRFDHhnxYI15MjohQ94YcSAFIQMAbZ8OhcyB87Lc3HgT1cXVdfYxKIZ310+XpkqL5Peu86/bPEotCSyJYT0Z4ewwJSRkRAwJGfHQtWtX+Ptz7u+///4bKpVKYItahlarRWFhIQASMmIhIiKCz8USs5BxCnRCUI34UCs1SF9/s84+t/Se9O/2yFz/MBVlyWUAgFY9W8FrABVjtCQDOtWG+v48Sh4ZwsxQsq94kMlkfHE8pVKJY8eOCWxRy7hz5w6/MoaWXosDe3t7dOjAZWNevXpV1GI5/Lm2/N0jbW06NOWGq6waCi2VXi7F9Y9SAQCMHYMuH3cCI6PaMZZkTD/AidPL+PUfQKORvpghISNiyCMjLqwpT4YSfcWJLrykVqtx7do1ga1pGJe2zmj9MNdOWVVYjYwthtV+6xMyrIbFhReSwFZzN852L7SFe7SbBawl9HFzZhDXn9vOvw0cOCesPaaAhIyIoWRfcaFrIAlIP0+GhIw4EXuFX33CX2jLb6d+lgatSsu/vlXz02VvB7Ry5bbT19/EndPcBy4RLmj333CL2UoYMmlYrRds69/kkSHMiE7IKBQK2NvbC2wNERgYiK5duwIATp8+bSAGpAbVkBEnUkn4BQD3aDf4jeHCkpXZlcj6OYf/TOeR8WnFVQWuyKjA1bdqS8l2+agT5E7U5Voo7h9gGF5Sq6UtZkjIiJiiIq6ZmpeXl8CWEDp03bBZlpV0uwJqTyBOunTpwm+LXcgAQLsFtV6V1I9Toa3WgmVZg4aRLMvi4ouXoCnj8mhCZgVTgq/AuDozGDeA2751R/rhJRIyIoVlWVoeK0L082SsRcjQ/BIPISEhcHXlYjGnT59GZWWlwBY1jmcfD3gN5kRJ2fVy/N3tAC68kQyvMq71gK8H187g1l5uvjkGOKL965FCmUvoMdmKwkskZERKaWkpqqu5+gx0oxEPAwYMgJ0dV7zr0KFDAlvTfEjIiBOZTIa+ffsCALKysjB37lzRt8SIejkCjJy7KVblVSHzsxvYkHwYq9JOoX9WFi6/UltCtvOaaNi7U5hcDIwbUFvlV+rhJRIyIoVuNOLExcUFPXv2BABcvnxZsnkylCMjXt577z2+0vJ3332Ht99+W2CLGsdroBf6/dEH/uP8wNjVPuV3K7uNgfsuQVXIPZAFTPCH/1g/ocwk7sJFURteKigG/pFweImEjEghISNedH2XAODw4cMCWtJ8KEdGvPTs2RPfffcd//rVV1/FL7/8IqBF98ZrgCd6fdsDw8/HQjsrElkOzgaf27WyQ6e3OzZwNCEUBuGlRPLIECaGhIx4GTx4ML8t1fCSbn4xDANPT0q8FBsPP/wwVq1axb+eOXMmTp48KaBFTcPR3xG3RrTFvIiBeCmsN5QDA9GqZyv03Ngdjv6OQptH3EVcf8DZidv+9YB0w0skZEQKCRnxMmjQIH774MGDAlrSfHShJU9PTz7nhxAXS5YswcyZMwEAFRUVeOCBB5CRkSGwVffm1h0ADIMkF0/IFnXBoL/6w2eot9BmEfWgH14qLAb+PiOsPc2FhIxIISEjXnx9fflS8qdPn0Z5ebnAFhkPrYgTPwzD4Ouvv+Y9gLm5uXjggQegVCoFtqxxGuuzRIgP/fDSz/vJI0OYEF1DP4BuNmJElyejVqtx4sQJga0xDpVKxffxovwYcePo6IjffvsNbdtyVXTPnj2LGTNmQKvV3uNI4WiozxIhTvTDS9sOANUSDC+RkBEp5JERN/p5MlILL5FIlhY+Pj74888/+TYlf/zxB15//XWBrWoYEjLSwtmJwf364aV/hbWnOZCQESkkZMSNlBN+aem19IiOjsbWrVshk3E/2StXrsS2bdsEtqp+dEKGYQAv6gkpCaReHI+EjEjRFzLe3pQoJzbatm2L1q1bAwCOHDkCtVotsEVNh5ZeS5PRo0fjnXfe4V8//vjjSEpKEtCi+tEJGW93QC5nGt2XEAdj+wMuXOki/HZQeuElEjIiRXezcXFx4YtjEeKBYRjeK6NUKnH+/HmBLWo65O2TLosWLcKjjz4KgJt3Dz74IG7fvi2wVYboOl/7tBLWDqLpODsxGD+Q2y4qARIlFl4iISNSaFWJ+NEvjCelPBkSMtKFYRisX78e3bt3BwCkpKRg+vTp0Gg0whpWQ0UVi7IKbpvyY6TFpKG13rPpb7J48XMtrt6UhmeGhIwI0Wq1fEIm3WjEi1TzZChHRto4Ozvjt99+40POO3fuxLJlywS2iqPgTu02CRlpMbY/4F3jRSssBt7/Cegwg0Xsc1p8t4dFRZV4RQ0JGRFSXFzMP2HRjUa8dOnShV9JcujQIdE399NBOTLSJywsDFu3boVcLgcArFq1ShRtDGjFknRRODJI/IjB1BGAg15fzwPngMdWsgh6mMVHW8X5G0dCRoSQ618ayOVyDBzIBZZzc3Nx/fp1gS1qGjS/rIPhw4djzZo1/OtZs2YJnvyry48BSMhIka7tGPzwugxZvzL44D8MOoTUfna7FPjv5yzyisQnZkjIiBC60UgH/TwZqYSXaH5ZDy+88AJmzJgBACgrKzPozyQEhh4ZWrEkVXw8GCyczODSFgYHP2MwuCv3PssCZ5KFta0+SMiIELrRSAcpFsbT5cjY29vDzY0KfUgZXRsDJyeuNKvQVaYptGRdMAyDwV0ZzH+gVpSeJSFDNAUSMtKhT58+sLfnAspS88j4+vqCYeipWeooFAp06dIFALeKqbS0VDBbqM+SddI9onb7TLLEQ0sqlQrLly9HXFwcYmNjMW/ePKSkpAAA4uPjMW3aNMTExGDChAl1Es969+6NwYMHY8iQIRgyZAg2btzIf1ZZWYmlS5ciJiYG48aNw65duwyOjY+P56+5fPlyVFdXN/f7SgISMtJBoVCgT58+AIBr164hLy9PYIsah2VZWtpvhfTo0YPfPnfunGB2kEfGOukQAjg6cNtnU4S1pT6MEjIajQZBQUHYtGkTEhMTERMTg0WLFgHgRM7//vc/JCYm4oMPPsDXX3+Nf/81rKrz+++/4+DBgzh48CBmz57Nv7927VoUFxcjISEBq1atwurVq5Geng6Ae8L48MMPsWbNGuzYsQPZ2dnYsGFDS7+3qCEhIy30w0uHDx8W0JJ7U1ZWhqqqKgA0t6wJfSFz5swZwewgIWOd2Nkx6BLObSdnAspycXlljBIyCoUCc+bMgb+/P+RyOaZMmYLs7GzcuXMHjzzyCLp06QI7Ozu0a9cOffv2xaVLl5p03oSEBMybNw+urq7o1q0bYmJisGfPHgDArl27MGrUKERHR8PV1RVz5szBzp07jf+mEoKEjLSQUsIv1ZCxTsQiZAr0Vi15uwtmBmEGdOEllgXOi2yBpl1LDj5//jy8vLzg4eFh8L5Go0FSUhLi4uIM3p8xYwYYhkG/fv2wYMECeHh4oKSkBIWFhYiIqA3CRUVF8csIU1NTMWDAAP6zyMhIZGVlobKykk9w00elUkGlUhl+STs7ODg4NOs7arVag/9bAv2bjZeXl0Wv3VKEGC+h6d+/P7998OBBo767pccrPz+f3/bx8ZHc38kW51dT6NSpE2QyGbRaLc6cOWMwPpYcM51Hxt0FsLdjodWK68m9KdAcq5+782T6d+L+tuYeL12j1MZotpBRKpVYtWoVnnnmmTqfffnll/D19TUQIOvWrUOXLl1QWlqKd955BytWrMAHH3yA8vJyyOVyA1Hi4uKC8vJyAEBFRQVcXFz4z1xdXfn36xMymzZtwrp16wzemzRpEiZPntzcrwoAyMjIaNHxxpCdnc1vK5VKPswmJSw5XmIgKioK165dw5kzZ3Dp0iWDOdsULDVe+l5SOzs7Sc4twPbmV1No164dkpOTkZSUhOTk5DoPb5YYs7yiNgDk8HSpRnp69j33FzM0xwzxd3UEEAAAOHSmFHE9igw+N9d4tW3b9p77NEvIVFVVYdGiRRg8eDAmTJhg8Nkvv/yCxMREbNy40WBFhM716enpiRdffBHjxo1DdXU1nJ2dodFoDDwsZWVlcHZ2BsCFs8rKyvjzKJVK/v36eOKJJzB9+nTDL9lCj0xGRgaCg4ObpAxNgW7Vgbu7u4GnSgoIMV5iYNiwYbh27Ro0Gg2ys7MxcuTIJh1n6fHS/zcZERGB0NBQs1/TlNjq/GoKvXv3RnJyMqqrq6FUKvnfXEuNWbUaKK75qQ70sZfc3NJBc6x+vH0BhuFCSym5bggN5Uo3iGG8jBYyarUar7zyCnx9fbFgwQKDz/bs2cN7RO4ON+mj+7Isy8Ld3R3e3t5ISUlB586dAXCrP8LDucyi8PBwfmUUACQnJyMoKKhebwwAODg4NFu0NIZMJrPYH0l/VYlU/yFZcrzEwJAhQ7B27VoAwJEjR3DfffcZdbylxquoqPYpys/PT7J/I1ubX02hZ8+e+OGHHwBwYf9evXoZfG7uMbtdygLgwg2+Hk0LCYgZmmOGuLsCkW20uJYBXLgBaLUM7OxqH4yEHC+jr/rWW2+hqqoKb7zxhsHT3bFjx/Dee+/ho48+QuvWrQ2OuX79Ov+0WlJSgvfffx/9+vXjBUdcXBzWr1+PsrIyXLhwAQcOHMCoUaMAAGPGjMHevXtx5coVKJVKbNy4EWPHjm3JdxY1arUat2/fBkDJmFJCKp2wKZHcehE64ZdWLFk/ujyZKhVwVUSRN6M8Mjk5OYiPj4ejoyOGDRvGv//JJ59g06ZNKCkpMVhWPXbsWLzyyisoKirC22+/jfz8fLi4uKBv37544403+P3mz5+PlStXYsyYMXB3d8eSJUsQFhYGgHN/L1iwAAsXLkRZWRmGDx9ucA1r4/bt23zzQbrRSIeQkBCEhoYiPT0d+/fvx/Xr19GuXTuhzaoDCRnrhYQMYW66RzLY+jd3fzqTDHS6d/qKRTBKyAQGBuLUqVP1fqZzq9dHnz59sG3btgY/d3JywsqVKxv8fPz48Rg/fnzTDZUwdKORLnPnzsVrr70GrVaL9957D1999ZXQJtWBll9bL15eXggJCcHNmzdx9uxZaLVai7r6qc+S9dMjsnb7bDKLGfeJ4+9MAUCRQUJGujz77LN876JNmzYZrD4TCzS/rBudV0apVFq8Gzt5ZKwf/SXYYqrwS0JGZNCNRrp4eHjw5QhUKhU+/PBDgS2qi25+ubm5wdHRUWBrCFMjZHjpVjH1WbJ2ArwZ+Htx22eSwadBCA0JGZFBQkbaLFiwgBcIX375pcEqITFAfZasm+7du/PbZ8+etei1C+7Ubvu0suilCQuiCy8VlQCZ+Y3vaylIyIgMEjLSJiAgAE8++SQArh7SZ599JrBFtWg0GhQWFgKguWWtCOuRqd0mj4z1IsbwEgkZkaG70QB0s5EqixcvhlwuBwB8/PHHfBFHodFfEefr6yuwNYQ5CA4OhpcX5/u3uJC5U7tNQsZ66R5Rm+B7JllAQ/QgISMyyCMjfcLCwjBt2jQAXAG6r7/+WmCLOGhuWT8Mw/Bemby8POTk5Fjs2joho3AEXBTiWM1CmJ4eUbXbZ5MpR4aoB7rZWAcvv/wyv/3++++jqqpKQGs4aG7ZBkKFl3RChrwx1k271oBLTYcg8sgQ9aK72TAMA09PT4GtIZpLp06d8OCDDwLgmoB+++23whoEqiFjKwghZLRaFoUl3DYJGetGLmfQlesghLRc4E6psPYAJGREh07IeHp6ws6u2c3JCRHwv//9j99+5513oFarBbTG0CNDOTLWi/7KJUsJmdulgEbDbZOQsX70C+Ods2y5onohISMyaHms9dC3b1+MGDECANdv7JdffhHUHgot2Qbt27eHQsH5/i21BJsSfW2L7pG1OVBnRRBeIiEjIqqrq1FczK1hpBuNdaDvlXn77bcFLSBFoSXbQC6Xo2vXrgA4Aa37TTEnBkKGashYPQatCkSwBJuEjIigpdfWx/Dhw9G3b18AwPnz53H06FHBbKHQku2gnydz7tw5s1+vQE8r+VCfJaunU1ugpsIEzpGQIfQh17/1wTAM5s+fz79OTEwUzBaaX7aDvpCxRHiJQku2hcKRQYcQbjspDaiqFtQcEjJigm401smwYcP47f379wtmh25+yWQyeHh4CGYHYX4svXKJQku2hy68pNYAKdn2gtpCQkZEkJCxTsLCwhASwj2+HD58WLCaMrocGS8vL77yMGGddO7cmf8bW8YjQw0jbQ39Cr+X0h0EtISEjKggIWOdMAzDe2UqKytx4sQJQezQzS/Kj7F+FAoFOnToAAC4dOmS2cUzhZZsj+56Cb+XbpKQIWogIWO9DB06lN8WIrxUWVnJ93yiuWUb6MJLarUaycnmXSNLQsb20G8eSR4ZgoeEjPUitJChFXG2h36eTFJSklmvpet8bW8HtHI166UIkeDdikGwH7d9+aYDtFrhbCEhIyJIyFgvYWFhCA0NBQAcOXLE4nkyVEPG9tAXMpcuXTLrtXQeGZ9WXCiVsA10XhllpQw3LNeftA4kZEQECRnrRj9P5vjx4xa9NtWQsT30WxWYU8iwLEsNI20Ug07YAtaTISEjInQ3G7lcjlataA2jtSFkeIlEsu3h6emJsLAwAMDly5eh0TVDMjGl5YCqpo4ICRnbQn/lkpCF8UjIiAjdzcbb2xsyGf1prI3Y2Fh+m4QMYQl0Xpny8nKkpJjnTmNQ1Zeev2yKnlHAoM7AYyNKMLircHZQe2URQQ0jrZuwsDCEhYUhLS0NR44cQWVlJRwcLJPtTzkytsm8efMwduxY+Pv7o23btma5Bq1Ysl1CAxgc+IxFevpthIa6C2YHPfaLhIqKCpSVlQGgG401o8uTqaqqsmieDOXI2CZjx47FnDlz0LVrV7OJ5vzbtdu+1GeJEAASMiKBlsfaBkLlyVBoiTAXmxJqq/qG+gtoCGGzkJARCXSjsQ3082T+/vtvi12X5hdhDv45y+K3g9x2gBfwSGzj+xOEOSAhIxLoRmMbhIaG8rkKx44dQ2VlpUWuq8uRcXJygouLi0WuSVg3Wi2LRZ/XemPemsvA1ZlCS4TlISEjEkjI2A76eTLHjh2zyDX1E8mpYBlhCr7/Czh9ldvuFgE8PkZYewjbhYSMSCAhYzvo58n8888/Zr8ey7K0Io4wKeWVLP73da035v1nGcjlJJAJYSAhIxJIyNgOlq4nU1JSgupqrmIZzS3CFLz/E5BVs6L//oHAiF4kYgjhICEjEmjVku0QEhKC8PBwAJbJk6Gl14QpySlg8c7/cd4YuRx472kSMYSwkJARCeSRsS104SWVSoUzZ86Y9Vo0twhTsnQDi7IKbvupB4AOoSRkCGEhISMS6GZjW+gSfgGYPeGX5hZhKs6lsNiYwG23cgVef4JEDCE8JGREgu5m4+DgAFdXV4GtIcyNfp6MuYUMtScg6uP//mKRU8Dee8caWJZbbs3WHPLaYwxV8iVEAQkZkUDLY22L4OBgtGvXDgBw7tw5lJeXm+1alCND3M25FBYzV7HoOJPFl7+z0GobFzQsy2L9n8C+09zrtoHAc49YwFCCaAIkZEQALY+1TfTzZMzplaHQEnE3r3zNQqMBipXAMx+wGPgMi7PJ9YuZf6+yGPo8i3nv1X7+zlMMHB3ogYsQByRkREB5eTm/coVuNLaDfp7Mvn37zHYdEjLE3XzzCoNZY2tfH78E9J7HYtFnWijLOcGSW8jiydVa9J7H4sC52n2njQQmDrWsvQTRGCRkRADdaGyTESNGQCbj/gl+9913UKvVZrkO5cgQd+PjwWDT/2TY/wmDDiHcexoN8MFWIHomJ2gip3GJvbqcmIgg4I9VDL5bylD4mxAVJGREAAkZ2yQgIADjxo0DAGRmZiIhIcHk16iursa5c9zjNMMw8Pb2Nvk1COkS253B2Y0M3nySgaMD915GPidolDVLrFu5cpV7k75l8MBgEjGE+DBKyKhUKixfvhxxcXGIjY3FvHnzkJKSwn++efNmjBw5EsOHD8fHH38Mlq2NqSYlJeHRRx/FoEGDMG/ePOTk5PCfVVZWYunSpYiJicG4ceOwa9cug+vGx8fz11y+fDlfpdRaICFju8yfP5/f/uqrr0x+/m+//Rbp6ekAgFGjRsHBwcHk1yCkjaMDg9ceZ3BxM4P7+tS+L5MBzzwIJP8fg/9OYeBgTwKGECdGCRmNRoOgoCBs2rQJiYmJiImJwaJFiwAAhw4dwi+//ILNmzdj69atOHToELZv3w6AE0AvvfQSpk6disTERHTu3BnLli3jz7t27VoUFxcjISEBq1atwurVq/kf35SUFHz44YdYs2YNduzYgezsbGzYsMFU318UkJCxXe677z4EBQUBAHbt2oW0tDSTnVulUuHNN9/kX7/xxhsmOzdhfUS0YbBrDYNtKxksfhQ4t5HB5/+V0RJrQvQYJWQUCgXmzJkDf39/yOVyTJkyBdnZ2bhz5w4SEhIwceJEtGnTBj4+PpgxYwZ27twJADh9+jQUCgUmTJgAR0dHzJ07F5cuXeK9MgkJCZg3bx5cXV3RrVs3xMTEYM+ePQC4H/dRo0YhOjoarq6umDNnDn9ea0FfyJDr37aQy+WYOnUqAG712rp160x27s2bN/MPBGPGjMGAAQNMdm7COmEYBg/FMHj3aRk6h5OAIaSBXUsOPn/+PLy8vODh4YEbN24gLi6O/ywqKgqff/45ACA1NRURERH8ZwqFAm3atEFqaipcXFxQWFho8HlUVBSSkpL4Y/V/gCMjI5GVlYXKyko4OTnVsUmlUkGlUhl+STu7ZrvUtVqtwf/NgX4yppeXl1mvZW4sMV7WhFarxeTJk/Hxxx9DrVZjw4YNWLp0aYtDQFVVVXjrrbf416+//rpV/E1ofhkPjZlx0HgZh7nHS7cgojGaLWSUSiVWrVqFZ555BgC3hFi/Iq2Liwtf5KuiogIuLi4Gx7u4uKCiogLl5eWQy+UGoqSxY3XXqKioqFfIbNq0qc5T7aRJkzB58uTmflUAQEZGRouOb4wbN27w29XV1fxTtJQx53hZG76+vrjvvvuQkJCAvLw8bNiwweChoDl89913uHnzJgBumbe/v79VzCsdNL+Mh8bMOGi8jMNc49W2bdt77tMsIVNVVYVFixZh8ODBmDBhAgDA2dkZSqWS36esrAzOzs4AOA9MWVmZwTnKysqgUCjg7OwMjUZj4GFp7FjdNRQKRb22PfHEE5g+fbrhl2yhRyYjIwPBwcFNUobNoaqqit/u0qULQkJCzHIdS2CJ8bImdOO1YMECftXStm3b8PTTTzf7nJWVlfj666/516tXr0ZoaGiLbRUDNL+Mh8bMOGi8jEMM42W0kFGr1XjllVfg6+uLBQsW8O+3bdsWKSkpGDx4MADg2rVrCA8PBwCEh4fjt99+4/etqKhAZmYmwsPD4e7uDm9vb6SkpKBz5871Hqu/Mio5ORlBQUH1emMArleROVZmyGQys/2RCgsL+W0/Pz+r+MdjzvGyRoYPH47IyEgkJycjMTERKSkpiIqKata5Nm7ciMzMTADA+PHj0bdvX1OaKgpofhkPjZlx0HgZh5DjZfRV33rrLVRVVeGNN94wqCcQFxeHX3/9FVlZWSgoKMD333+PsWO50pG9evVCRUUF4uPjoVKpsGHDBkRHRyMwMJA/dv369SgrK8OFCxdw4MABjBo1CgCXpLh3715cuXIFSqUSGzdu5M9rLeiSfXUeKsL2YBjGYCm2vkfFGCoqKvD222/zr5cvX95i2wiCIMSMUUImJycH8fHxOHPmDIYNG4YhQ4ZgyJAhOHPmDAYPHoyHH34YM2fOxKRJkzBo0CA88MADADgvybvvvovvv/8ew4YNw7lz57BixQr+vPPnz4erqyvGjBmDJUuWYMmSJQgLCwMAREREYMGCBVi4cCHi4uLg7++P2bNnm24ERAD1WSIA4PHHH4ejoyMALtdL17bCGL7++mtkZ2cDAB588EH06NHDpDYSBEGIDYbVr1pH1EGr1SI9PR2hoaFmcZuxLAsHBweo1Wr06NED//77r8mvYUnMPV7Wxt3j9dhjj+G7774DAGzZsgUzZsxo8rkqKioQHh6O3NxcAMDZs2fRrVs3s9gtFDS/jIfGzDhovIxDDOPVouXXRMspKSnhe+yQR4aYP38+L2S++uorAyGj1Wpx9uxZ7NmzB6WlpXB3d4e7uzvc3Nzg7u6OQ4cO8SLmkUcesToRQxAEUR8kZASGqvoS+gwaNAidOnVCUlISDh8+jKNHjyInJwc7duxAQkICL1Tuxeuvv25mSwmCIMQBCRmBOXToEL+tK1VP2C4Mw+Cpp57Cc889BwAYOHCg0eeYMmUKunTpYmrTCIIgRAkJGYHR7xv18MMPC2gJIRYee+wxvPzyy3xRSB0KhQIjRozAuHHjEBERgdLSUpSUlBj85+zsbFAWgSAIwtohISMg165dw8GDBwEAHTt2RP/+/QW2iBADrVq1wooVK/DSSy8hJCQE48aNw7hx4zB06NAGC0ESBEHYKiRkBGTTpk389uzZsw3q8hC2zaJFi7Bw4UIwDEPzgiAIohFIyAiEWq3GN998A4BroTBz5kyBLSLEBi39JAiCuDf0SykQu3btQk5ODgCujLyfn5/AFhEEQRCE9CAhIxD6Sb7WVqmYIAiCICwFCRkByMvLw59//gkACAwMxJgxYwS2iCAIgiCkCQkZAdiyZQtfzXfWrFmws6NUJYIgCIJoDiRkLAzLsgZhpSeeeEJAawiCIAhC2pCQsTBHjx7FlStXAAAxMTGIjIwU2CKCIAiCkC4kZCyMvjfmySefFNASgiAIgpA+JGQsiFKpxE8//QQAcHNzwyOPPCKwRQRBEAQhbUjIWJCtW7eirKwMAPDoo4/CxcVFYIsIgiAIQtqQkLEgVDuGIAiCIEwLrfs1Mfv378dPP/2EyspKvkcOwzDQaDQ4cuQIAKBTp07o27evkGYSBEEQhFVAQsZEZGVlYdGiRXwOTGM8+eST1AiQIAiCIEwAhZZaSHV1Nd5//3106NChSSImODgYjz/+uAUsIwiCIAjrhzwyLeCff/7Bs88+i6SkJP49Hx8fvP322xg8eDBYljX4DwAiIyPh6OgolMkEQRAEYVWQkGkGubm5WLx4Mb777jv+PYZhMH/+fLz11lvw8vIS0DqCIAiCsB1IyDSDjz/+2EDE9O7dG1988QX69OkjoFUEQRAEYXtQjkwzeOWVV9C6dWt4enriq6++wrFjx0jEEARBEIQAkEemGbi5uWHbtm0IDw+Hr6+v0OYQBEEQhM1CQqaZ9OvXT2gTCIIgCMLmodASQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShYQMQRAEQRCShWFZlhXaCIIgCIIgiOZAHhmCIAiCICQLCRmCIAiCICQLCRmCIAiCICQLCRmCIAiCICQLCRmCIAiCICQLCRmCIAiCICQLCRmCIAiCICQLCRmCIAiCICQLCRmCIAiCICQLCRmCIAiCICQLCRmCIAiCICSLndAGCMmVK1dQVVWF0NBQeHh4QKvVQiYjbdcQN27cAMMwCAgIgJOTE41XE6A5Zhw0x4yD5pdx0PwyDqnML5sUMiqVCq+//jqOHz+ODh06oKioCEuXLkWnTp2ENk2U3LlzBytWrEBycjJat24Nd3d3LFq0CAEBAWBZFgzDCG2i6KA5Zhw0x4yD5pdx0PwyDqnNL/FJKwtw48YNFBcX488//8RHH32EAQMGYNWqVUhJSRHaNNFRVFSEN998E25uboiPj8fChQvh4uKCDRs2AAD9ADQAzbGmQ3PMeGh+NR2aX8Yjtfllk0LmzJkzuHPnDpydneHg4IAXXngBvr6+2LlzJ27fvi20eaJCJpMhJiYGTz/9NAAgKioK3bt3h52dHViWFdg68UJzrOnQHDMeml9Nh+aX8Uhtflm9kElKSsK7776Lbdu2ISsrCwDQvXt3AEBaWhq/34wZM3Dq1Cl+H1slLS0NFy9e5F+7u7tj5MiRvAtWJpOhoKAAt27doieZGmiOGQfNMeOg+WUcNL+Mwxrml1ULmd27d+OZZ56Bo6Mj4uPjsWbNGpw4cQKhoaGIjIzEnj17+H179+4NNzc37N69GwBsTqmr1Wp8/PHHmDZtGj7++GOUlZXxn7m4uACoHZOMjAwMHDiQ/1yr1VrWWBFBc6zp0BwzHppfTYfml/FYy/yyaiFz9OhRzJ07Fy+88ALefvttdO/eHe+++y4UCgV69uyJ5ORknDhxgt9/5MiRuHLlik0mfyUnJ6O4uBjPPPMMAgIC8PPPPwMwjB/rJm5eXh5CQkL49231RwCgOWYMNMeMh+ZX06H5ZTzWMr+sVsio1WrY2dlBrVYDAAICAjBp0iQ4Oztj7dq1uP/++xEUFIR169ahsLAQAHDt2jX0799fVH8gSxEYGIiZM2fiwQcfRK9evXDixAmkpaWBYRj+H7lcLkdxcTEqKirQo0cPHDp0CAMHDsT//d//CWy9MNAcMw6aY8ZB88s4aH4ZhzXNL6sRMne7uezs7MAwDIqLi6FUKgEAzs7OeOqpp7B9+3aUlpZi3rx5cHFxweLFizFt2jT8888/6Nu3rxDmW5y7x8vDwwNhYWFwdXVF9+7dERQUhK1btwKAQd2AkydP4vbt23jiiSewatUqLFu2DDNnzrSo7UJBc8w4aI61DJpfxkHzyzisan6xEqa6uprNzc2t875Go2FZlmVPnTrFPvLII+zFixdZrVbLsizLFhQUsC+++CK7c+dOlmVZVqVSsdevX2d3795tOcMFoqHxqo/ExET26aefZo8ePWrw/s6dO9lBgwax69evN4eJoqO6upq9ceNGnfdpjtVPQ+NVHzTHWH7O6P6vg+ZX/TQ0XvVB88t25pdkPTJbt25FXFwcli1bho8++gjJyckAYFB5sFevXmjfvj22bt3KZ1p7eHggJycH7u7uADhXY3h4OO677z5hvoiFaGy89GFrnqKjo6PRsWNHPrFr7969KCgoQL9+/bBnzx48+eSTlv0CAvDzzz9j9OjRWLZsGZYvX45Tp04BoDnWEI2Nlz40xzh+/fVX/Oc//0FqaqpB+AMAza96aGy89KH5xWFL80uSQubkyZPYvn07vvjiCyxatAhKpRKffvop8vPzIZPJoNVq+T/ac889h9u3b2PdunVISkrCmTNnoNVq4ePjAwCiLLdsapoyXjp0sU9/f3+MGTMGly5dQt++ffHtt99Cq9XC09MTzs7OQn0Vi5GWloYdO3bgk08+wZtvvolWrVrhww8/RFZWFmQyGTQaDc0xPZoyXjpsfY6pVCps3LgRGzZsgFar5ZNS754nNL84mjpeOmh+2d78YlhWRGuo7oHuSfiXX37B8ePH8d577wEArl69irfeegtdunTB4sWL6+yfnJyM+Ph4XL58GTdv3sSzzz6LBx54QKivYTGMHS99SktLMXv2bBQXF2PBggWIi4uzpOmC8++//+LNN9/EDz/8ACcnJyiVSrz77rsoLCzE559/zu9n63NMR1PHSx9bnWOVlZU4ceIEHBwcUF1djR9//BHTpk3DoEGD6vSyofll3HjpQ/PLhuaXoIGtJrJ37172xo0bbHV1NcuyLLthwwb2tddeY5VKJcuyLFtZWclOmjSJnTBhAnvhwgWWZeuPoTY1P0TqmGK8rly5wn755ZeWNVxAfv75Z/bo0aNsaWkpy7Ise+TIEfbll182yPfIzs5mR44cyR45coRl2do4sz62MsdMMV62NMfuHq+SkhKWZVn2zp077BdffMEuXryYH5/G8j9sdX41Z7xsaX79+uuv7JkzZ9jy8nKWZVl+3GxlfonaI7Nz50589NFHCAoKgkajgZ+fH9577z3k5eVh4cKFGDRoEMaNG4eLFy/i8OHDCAgIgIuLC+bMmWNwHlZka97NhanGy5b4888/8emnnyIqKgoMw6C0tBSbNm1CUVERnn/+eTz22GMYNWoU/xTz1VdfITU1Fe+++67BeWxljplqvGyFu8dLqVTi66+/hp1dbb/eM2fOYMuWLRg0aBAeeeQRaDQayOVyg/PY6vxq7njZCufPn8fLL7+MwMBAsCwLhUKBhQsXIjIykt/HFuaXaINfJ06cwP/93/9h+fLl2LhxI1avXo3Dhw/j1KlT8Pf3x9y5c1FYWIjly5fj+++/x/Tp0wGAj33q6zMp/4GaiinHy1Y4fvw4EhIS8MYbb+DTTz/Fa6+9hoyMDFy5cgVeXl4YMmQItm3bhuzsbP4YX19fyOVyg6qhgG3MMVOOly1Q33jdvHkTN27cAAC+fkf79u3Ru3dv/P333ygvL4dcLkdJSQmA2n+Xtjq/mjtetsK5c+cwePBgbNy4EZ988gk8PDzw888/GzR3tIX5ZXfvXYQhKioK48aNQ//+/VFdXY3AwECMGjUKV65cQe/evTFs2DAMGzYMmZmZaNOmDQBOzeuQ+h/GWGi8jKdXr14ICwuDv78/7ty5gzfeeANyuRw3b95Ehw4dMH/+fMyfPx/bt2/H6NGj0a5dO2g0GtjZ2fElz20JGi/jaGi80tPTERkZyXsZnJ2dMWDAAKSnp+OTTz5BYWEhAgIC8N///tem/l3SeBmHRqPBuXPn0LNnTwCAm5sbpk2bhl9//RV79+5FREQEANsYL9F6ZDw8PDB16lQAgL29PQAgNTUVwcHBAMCvgggMDERZWRk+/PBDHDt2DAMGDBDGYIGh8TIeOzs7+Pv7o7i4GG+99RZ8fHzw5ptvIj09HWvXroVSqcSCBQuQn5+PJUuWYNWqVfjkk0/Qv39/ALb39EfjZRwNjdeNGzfw/+3df0xV9R/H8ecNVApUGAUimKJOE/DXZLU5f5TOmRs4NsxqKaH9MFEWmZt/pFPbVHTOuQy06TTnjPkjl6CzAsNFWfmLUDN1FMkluyDgL66o93LP9w++93wl9ZsnhevF1+Mf2Llczvu8gHvfnM/nfM6GDRuw2+3m1/bo0YOKigo+//xznnjiCd5999128yZzr5TXvfN4PAQEBBAbG0thYaG5PSEhgfj4eKqqqvj111/N7e0+L19MzLHC4/EYLpfLaGhoMKZNm2acOnWqxWQlh8NhzJ8/30hPT7/nhbjaM+X173gnExqGYVRUVBizZ882F4S6evWqUVhYaKxbt874/ffffVXiQ0V5WfP3vDIzM828GhoajDlz5hgvvfSSYbfbfVXiQ0V53ZuqqiojJSXFKCkpabFt5syZxuHDhw3DaP57bO95+Wyy7+nTpykoKKB3794MHz6cqKgoAHMNmFsnd0Hz2YX58+eb98RwOBx06dKFxx9/nLq6OvOa9/ZKeVlnNbOmpiZcLhdBQUFMmzaNQYMG8d577/midJ9QXtbcb16DBw8mKyuLpqYm6uvreeqpp3xxGG1GeVljt9u5dOkSAwcOvO2yae99kjweDxs3bqS4uJitW7eaj6elpTFmzBjS09Mfibx8MrRUVFTEjBkz6NChA3v37mXFihWUlJQAzXM1AgMDuXbtGocPH+bmzZtA88zrxMREAObNm8err76Kw+HAZrO1+zdl5WWdlcxcLhfQvIJlUFAQtbW1hISEPFLDbsrLmgeRl3fILSAgoF2/yYDyssLtdrNmzRpefvllVq9ezdWrV3nsscdaDM0GBgbS2NjIsWPHmDhxIoZhsGzZMmpqanA6nYSEhDBs2DCg/ecFPmpkDh48yLRp08jKymLp0qUMGzaMVatW4fF4sNlsbNmyhdGjR1NWVmZ2od4Fe8aMGUNgYKDZ2T8KlJd1VjILCAjg+vXrHDhwgJycHCZPnkx0dLTZCD4KlJc1yssa5XXvysvLuXjxIhkZGcTExJgr895q69atjBo1itLSUiIiIliyZAnnz59n/vz5JCUlER4ezoABA3xQvW+06VVLHo8HwzDo0KGDOfm0W7dupKamUlxczOrVq5k1axaVlZVs3ryZuLg487mNjY10796dxYsXm7Ox2zvlZd2/zSwoKAiHw8HZs2fJycl5ZF4ElJc1yssa5WVdVFQUaWlpPPnkkxQXF7Nv3z6ef/558x/RyspK7HZ7i7xiY2NZuXIllZWVdOzYkZ49e/ryENpea07AsdvtRm5urnHmzJkW27Ozs41Vq1a1mND1448/GhMmTDAuXLhgbmtqajLcbrdhGIa5Km17prysu9/M3G63mZn3Y3umvKxRXtYoL2vulpfXuXPnjCVLlhjZ2dl3fLypqemOK4w/alptaKmoqIhZs2axefNmDh06RENDg/nY+PHj+f777/njjz/Mcb9+/foxePBgfvrpJ+B/94DwrkDY3tehUF7WPYjMAgICzMza++qgyssa5WWN8rLmbnkZt8yFefrppxk+fDiVlZV89913LZ7vfc33h5s6trZWG1pyOp3Mnj0bp9NJUVER8fHxDB06FIAhQ4YQFxfH9u3bCQ0NpUePHoSGhvLnn3+atw5vV9e43wPlZZ0ys0Z5WaO8rFFe1twtL28Oxn9vGxAXF0dcXBxFRUWMGDGC/fv388wzzxAdHe3jI3h4tForN3bsWEaMGEFKSgqdO3fm22+/pba21nw8MzOTy5cvs379ek6cOEFZWRlut9u8ouZR+6VWXtYpM2uUlzXKyxrlZc0/5eXNIyIigvHjx3PmzBmeffZZNm7c2O7PVlnVJuvIHDt2jLVr1/Laa68xatQobDYbNpuN8vJy9u7dy8mTJ6msrGTmzJmkpKS0djkPPeVlnTKzRnlZo7ysUV7W/D2vW4eLGhoamD59OvX19WRlZZGUlOTDSh9ObbYg3sqVK2loaOCNN94wl833qqmpISIioi3K8BvKyzplZo3yskZ5WaO8rPl7Xt6hpfLycgoLC5k5c6avS3xotXoj452QVFVVxbJly0hOTuavv/6iqamJKVOmEBQU1Jq79zvKyzplZo3yskZ5WaO8rLlbXm63m/T0dPPeeXJ3rT7d2XuKLCYmhoiICBYsWEBeXh4JCQn6hb4D5WWdMrNGeVmjvKxRXtbcLa+BAweqiblXbXGNt8vlMnJycoznnnvO2LFjR1vs0q8pL+uUmTXKyxrlZY3yskZ53Z82myNz6NAhBg8eTKdOndpid35PeVmnzKxRXtYoL2uUlzXK69/z2d2vRURERO6XlgQUERERv6VGRkRERPyWGhkRERHxW2pkRERExG+pkRERERG/pUZGRERE/JYaGREREfFbamRExLIjR46QmJhIYmIi58+f93U5IvIIC/R1ASLycPHetO7/GTlyJAkJCQB07NixLcr6R0eOHOGdd94BID8/n+7du/u4IhFpC2pkRKSF/v37Ex4eDkBNTQ01NTUA9OvXz2xaRo8eTUpKiq9KFBEx6RYFInJXn3zyCevXrwdanuW409mPRYsWsWfPHqKiopgxYwZr166loaGBiRMnMmvWLHJycsjPz6dz586kp6czadIkcz8XLlwgNzeXH374gUuXLhEZGUlycjLp6ekEBjb/v3XixAlyc3M5e/Ys165dIywsjP79+/P++++zd+9es85bJSUlsWjRIrZs2cK+fftwOBw4nU66dOnCkCFDmD17Nj179gSgoKCAxYsXA5Cdnc3GjRs5d+4cw4YNY/HixRw4cIANGzZw/fp1xo0bx9y5c83aEhMTAcjKyuLUqVOUlJQQFBREamoqM2bMwGaztcaPR0TQHBkRecBqa2vJzs6mQ4cOOJ1O8vLymDp1Kvn5+YSEhOBwOFixYgUVFRUAXLp0ifT0dAoKCmhsbCQ2NhaHw8G6detYsmQJAB6Ph6ysLA4fPkxgYCCxsbG4XC5KSkpwOBxERkYSGxtr1tCvXz8SEhKIiYkB4OjRo9jtdsLDw+nVqxdXrlyhuLiYjIwMbty4cdsxLFy4kJs3b3Lz5k0OHjzI22+/zfLly+nUqROXL19m586d7N69+7bn5ebmUlpaSufOnbl48SIbNmxg27ZtrRGziPyXGhkReaBcLhcff/wxu3btIjIyEgC73U5eXh47d+6kU6dOeDwejh49CsD27duprq4mPDycL774gry8PJYvXw7Anj17sNvtXLlyhcuXLwOwadMmPvvsMwoLC9m2bRu9e/cmJSWFefPmmTWsXLmSTz/9lDfffBOAzMxMiouL2bFjB9u2beOjjz4CoLq6mrKystuOYfr06ezcuZMXX3wRgIqKChYuXMiuXbsYMmQI0HxW6u/i4+MpKCggPz+foUOHmvWKSOvRHBkReaC8wzYA3bp1o7q6mj59+pjDUmFhYTgcDurr6wH45ZdfAKirq2PcuHEtvpdhGJw8eZIJEyYwaNAgjh8/zqRJk+jRowd9+vRhxIgRZrPx/zgcDpYuXUp5eTnXrl3j1hH1Cxcu3Pb1o0aNAiAqKsrcNnLkSACio6P5+eefzfpvNXbsWHO4aezYsZSWllJXV8fFixcJCwv7xzpFxDo1MiLyQAUHB5ufBwQE3LbNO1/E20x4PwYHB7cYHvIKCgoCmodtvvzyS8rKyqioqGD//v18/fXX1NbWkpaWdtd6qqqqmDt3Li6Xi+DgYAYMGIDb7ebs2bNA87DV3Y7BWz9ASEjIHesXEd9SIyMiPhUfH8/BgwcJCAhg6dKl5pkbp9NJcXExL7zwAoZhcPz4cZKTk82rpT788EPy8/MpLS0lLS3NbHgAGhsbzc/PnDmDy+UCYM2aNQwaNIivvvqKDz744IEfy/79+81JzN988w0A4eHhOhsj0orUyIiIT02ePJndu3dTU1NDamoqsbGxOJ1OqqurcbvdJCUl0dTUREZGBsHBwURGRmKz2czJwn379gUgJiaGwMBA3G43GRkZREVFMWXKFPr27UtAQABNTU1kZmbSrVs36urqWuVYTp8+TXJyMjabzbxs/fXXX2+VfYlIM032FRGfCgsLY9OmTSQnJ9O1a1d+++03bty4wdChQ5kzZw7QPMSTmppK9+7dqampoaqqiqioKKZOncpbb70FQGhoKHPnziUyMpL6+npOnjxJXV0dvXr1YsGCBURHR+N2uwkNDTWvhnrQMjIySExMpKGhga5duzJ9+nReeeWVVtmXiDTTOjIiIvfJu47MwoULSU5O9nE1Io8WnZERERERv6VGRkRERPyWhpZERETEb+mMjIiIiPgtNTIiIiLit9TIiIiIiN9SIyMiIiJ+S42MiIiI+C01MiIiIuK31MiIiIiI31IjIyIiIn5LjYyIiIj4rf8A4zp+T99tjUwAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "class CustomRegressionModel:\n", + " def __init__(self, weights: np.ndarray):\n", + " \"\"\"Barebone weighted average\"\"\"\n", + " self.weights = weights\n", + " self.norm_coef = sum(weights)\n", + "\n", + " def fit(self, X: np.ndarray, y: np.ndarray):\n", + " return self\n", + "\n", + " def predict(self, X: np.ndarray):\n", + " \"\"\"Apply weights on each sample\"\"\"\n", + " return (\n", + " np.stack([np.correlate(x, self.weights, mode=\"valid\") for x in X])\n", + " / self.norm_coef\n", + " )\n", + "\n", + " def get_params(self, deep: bool):\n", + " return {\"weights\": self.weights}\n", + "\n", + "\n", + "window_weights = np.arange(1, 25, 1) ** 2\n", + "model = RegressionModel(\n", + " lags=24,\n", + " output_chunk_length=24,\n", + " model=CustomRegressionModel(window_weights),\n", + " multi_models=False,\n", + ")\n", + "model.fit(ts_energy_train)\n", + "pred = model.predict(n=24)\n", + "\n", + "ts_energy_train[-48:].plot(label=\"training\")\n", + "ts_energy_val[:24].plot(label=\"validation\")\n", + "pred.plot(label=\"forecast\")" + ] + }, + { + "cell_type": "markdown", + "id": "e8a2e524-a5c6-48bf-b804-cd5506e1bf15", + "metadata": {}, + "source": [ + "## Example of the boosted tree models\n", + "\n", + "Make sure to have the dependencies for lightgbm and catboost installed. You can check out our installation guide [here](https://github.com/unit8co/darts/blob/master/INSTALL.md)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "8d3f6fe5-d7ba-44e0-a0e1-6f4cfb2e75ea", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LightGBMModel MAPE: 2.2682070257112743\n", + "XGBoostModel MAPE: 3.5364068635935895\n", + "CatboostModel MAPE: 2.373275454432286\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "lgbm_model = LightGBMModel(lags=24, output_chunk_length=24, verbose=0)\n", + "xgboost_model = XGBModel(lags=24, output_chunk_length=24)\n", + "catboost_model = CatBoostModel(lags=24, output_chunk_length=24)\n", + "\n", + "lgbm_model.fit(ts_energy_train)\n", + "xgboost_model.fit(ts_energy_train)\n", + "catboost_model.fit(ts_energy_train)\n", + "\n", + "pred_lgbm = lgbm_model.predict(n=24)\n", + "pred_xgboost = xgboost_model.predict(n=24)\n", + "pred_catboost = catboost_model.predict(n=24)\n", + "\n", + "print(f\"LightGBMModel MAPE: {mape(ts_energy_val, pred_lgbm)}\")\n", + "print(f\"XGBoostModel MAPE: {mape(ts_energy_val, pred_xgboost)}\")\n", + "print(f\"CatboostModel MAPE: {mape(ts_energy_val, pred_catboost)}\")\n", + "\n", + "ts_energy_train[-48:].plot(label=\"training\")\n", + "ts_energy_val[:24].plot(label=\"validation\")\n", + "pred_lgbm.plot(label=\"lgbm\")\n", + "pred_xgboost.plot(label=\"xgboost\")\n", + "pred_catboost.plot(label=\"catboost\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/static/images/multi_model_ocl2.png b/examples/static/images/multi_model_ocl2.png new file mode 100644 index 0000000000000000000000000000000000000000..b4bd2301f334bed6e9302d83a74f505ae3bc91ad GIT binary patch literal 56161 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 W@L7z*z5fI7PeSCYaHXK$_x}Z$Zkjd# literal 0 HcmV?d00001 diff --git a/examples/static/images/regression_model_train.png b/examples/static/images/regression_model_train.png new file mode 100644 index 0000000000000000000000000000000000000000..ee0c39ea7f99a8da5d61a593501f93f9b1424c0c GIT binary patch literal 39518 zcmeFYbx>YO_b!TS@Bo1Xx8T7gXprC#+#$HT`x`5CsYf3QbZ%R1pdajtL41`V$fY z@TOY5{R0#fO0l_!h=Qbu2&saDt%4~2sKfg)*oU)^EvFDr-!9h!AZl&D^%gSqzrz;;z^gsp!+UG zXlMQPCeD|Wgbg=(2T9iNxR7r$z5z`AVT#3r!WbJ9b9S9vGTZQ<(9;3%)-8MF{KIrk&^zi35f+s zNz(=2Blbe!S>l)*5mf3|M88XWDYk0i2pqygr)PRhgJ~mOr8w;{*a`?vnaEBcvRAOG zX4Z1;Xl_}!h#y{IqG7l5wIiC7qDpkUDSuiF1D}ax1*Ihf{}raGUBC|W1%m7fB{w1y z$TAbw33Qi<|HN-w|5-Ea7fiTSGCEOzb~65+XO$lhNbxqHZ{Bn$P{u-02^T~@ix!d2 z;!wa+Mo|%(RA4-(cY48#r~~57YEmF!himyH(19ca+AT-7f*Jm(@#;DHhcBxQc66y| z+Z{J29`!FuK^W~}Cp_1L3-DLphF7uRNR2*%b|_SlP*+LcOOQu@kcirpAXEG_L3$y9 zI`(PdjYkxI&)X;HBHv%Js6OM8fuctE-fd(UZy3yio9LY=J^(+!C_`fM>o9i6^-c@e+AKDRrO>W;(?R>) zVJkn~WSgm$h)6zduR5Nr(r_8)*7Jfk*9<3~yN9n4_PMcO8tSnbZqeID0+Cmo7i(rKB z0H-0UE6GGdLas-B6(y)R@e=PTx-q(#oQC|YG>>$Hw7W>IqU=}Q2~i7lXa1UakM!Hm zx57brMkPN~uwRxa6e?RNHx`^LCVjOk9#BosPtDiP^Af%Jbc%|b9UO%6HXy%JJ6CbD zUaGF|Go9?DDu)b*bd9=m+aB&@zJ(hH4u>8GNV9d0spiZA%>L0tVtwSgnxlHLI;0w! zH{3>Qdu)7H?A-s{<+i*rxzXRF_?G-a>OyI+<;lnQ-&R;z38+H9hrSM#A9u>D$VbjE zNl_I%+^W7J9Or0e|40}>h(@SGn8BWu+?q^~{G20&oy6jOHA6LdHJ-)cMB~>B177dO zc_+yEx81<}*cw=1n^sQc^llUse4?FZAFduc2N6sTj5Ev^ zcOBI745b>Uzi<8C{2iv&u3Dn%Yjyp5WG!BeUZF@g(ZTxc@yBb>*c`)eu$IK7@Ac`t)Q`;o|SKan< z9jUJ!Ww)7fU-q4@j`JOyvl?oLIX^yl^SzAv=B$9{;)|OT2 z)mbl2zY$)YBu~k%%pUH%Un>%vg(ySD>n>>b=cQAnTx{B{F>ULsMjh8%6(`4<#~`v~ zDTG{XT=+IVO~#OTdSi5B6)j1vO)bxU|NfLZ0_*wmLq{=9F|}M*tkZ|9Sm z*(gk@O!ZQw`KOn8+b$qC*JpLiqS|I{&zydqQng8M&(Bz!GBxQ5xOZOk{VXajlATU1 z<wU1!i!wpHL zpa8~(V3q*w^NHuh-WFHq8?lhb_w~ zYi(ij`Ep}&tQA;SLa|B_v1Hux+*|Kj`0RUYL~(?5#+m?HIMaRTgEpk|Ub=revkarv z*!zxpRnmRE1nL7iHx<0!v?p{Xb!H3foJgdJ{Q1N>g6uuUGn$hOx9nqLE*dBcH5kl8 zcp;?Q`ZEToE<;Af!T`^({qmL;1DVUV^_JVjf)`Mkh7(;>l-F5bk?zN-Z?BK{Alpy6 zvU&Y{haO-OH4v8Gk9^1n!dC-hbx9LhStvT-83_so8XF20c!CE0LIs*b!ToxMf}#d~ zLqWkte}X~;eq#gw6f$A{DurXpg#GIo`qSfw!b&2NlE7~zLkDAH8%Hx+r(WMPpae$1 zTv^>oT~>zI(AJviy^*bfF_W9M-D4FfJ~v+A(c0MQJ*k_um5n2>8$bE4FL;6H$Jfl{ zq`y9Kvg9XMmsKDYv2`#eng_M+(&%wxqS5Z{_&+5Sc_{q(joa}g+nO$97 znOxbJY#mIQS$KGOm|w9nv$8S*Uobkl+c>>e zXpZku7_Wl4o3WLKsJS(uRiJAEY&@^{el_!3$$vZgM@^D#ea_-`8jV>*Am z1?E!#g^&3^wjqF0L&xn71tkO}DJrb&27R!I=%u9cynVIKN#SzI^SIy%4c+I@Q`2DdSi$~VNALhWy1 z0xIznKFo&P?i?*lCBQ`GU-rZiwcW6yE>8iHeTL;IJeNd5elQ84RI<_pOT|E)z*p_LEQ zzX?J5Uo;>S*!PDPNeAKM2OpG5bzA5r_mtyP8yvMA9}b_p_OALyNHowH=je~#Pal}V z{-^hTj&Nr7tEr87IY2M`mXQu-sL&SBc-Pt%dT`o zt2jR0>Er#^K3B*C77#tlcr7eXd?tA*#D(|-5l|<-_#Le2_ zx>&-C!fUm>UbO%AT^mPmFJJjrw|>d?e2)6~2?$je_SdHZxQVQnudfEk*{BDjlxT*o*##F~ zJo+f9HQd~SMlT#~9;9}5;pDtQ`t+<&$6**Pmr^f$z&r-|=mQkY?i;^$vBs~|tU-X* zW|USU^y2#$3eIw@HWkORMU;5FPeVDDI^P}%ed3pvE%-HA%9%o?3=Xb`(UoRkA0Ds0 zX0N+$&W0C0Dsvi)EE12FlMnPx9xeWH9^uAhR!$%krycw2REB2aY!|yR{Bx4Mr=7+Z zB$k_ZWj=CMUUn3}R)S?@Co^R+@-Nv&ThZ34D+WayLwIzud$FfFpX%9QkgjtdU8)$5 zHQ=$QTBPKBZO6o&$JBDXyRsXL|cqgEpI-6shXl`;g0E^`lNYloMRV$mN}A#_xt zrFm*JOc}Fn8@ri;-a~;#Cncdk$_n&W=n1e+v2g!k$P%caAd1##>*p?ggJFApEfMSv z%Zggse4{NTN#xEa^dvoT{i{db48I(BMxIn1ajp6T?!$oqwHn2j9PjURm-LiWZ=gW? zc%*jriyyUrIY;|*5Qj7*J}F~3t{MKcN7~l4accsPC`GCyrLcF2=+1bohxRW&^lO3B z?g*x%I+Yq^y*X6jmhy*!p(V$RC0AP||25r6lQy!AAImjF@krzp7?ulO& zltagj|CW>p6|-KVJMQh&uc`aPH6_Ymz|@TKyCHSS2N*tuprm({E%5*eZhK*w&_%~U9NWGQ;*8kz12A1DSD5)_qjdOpX|Ed%@2V=^V7Tu49uXM+$ zO#ZH;VoTG@n?lA8Xh9owUeACqIq(Y%!Y(P(DQ6z-6nvb0EFi)NW>wiH9>uRD1ScPO95TgQ$bAn@2dFMfaL)zODANY_~#x8IEx-I zNhd{nq-_7y;h#?{w7`O>wB zad-H8D^SpF*uWI1O$wX*^Yvp7lmLC^BlQ1E60jVr0mA+doSYAQYU<+cYA~y6UyP1_ zO1C!hUy1!wA16^l`ucvcea{Jx7m>ApNPiEne#-61@}>(6vDI9P_I&i~zp3LIBvd;h z6Lcea~CEnGLkk(cRS?A^y8y7t!M3ijqYnl|%B_>b$ht2s9r&uWiO zBlp(9yo*`_&rdDb=-q_eHyJxuviclNyqj%tiL%n*eH(r-M~aObSG;eh*oQ=!4=LLQ z>m28or435^My}u0YD|(OvBIy?_2Qje+WIZ+cr3v#5Y#{pZS^jSQmT_%h$(gL3nd%=th?UdiqSi5TaATg5;>+z+HjGvaCH^(KEHT+9+vfRu=aF) zhj{7~eCj@I5`Mjsd|8unO%!v-B~+HWa0NB24Zb)ty76%{)e!Ve-ZqIJS7^sShK|uS zr;E{TI8N?{4EpB1?`?=f$#Di-W_s*$Q5Y|r)%6u;rET0{>1>SSKkpMn&7W_41L$JG zZ9Qx(R~nyI`D>)SKBw&x!+Li_LXX5UxN^l3Hly8fd>@b7UO)dL%b;+&Ef|+UNyTDu zT(@$g&vns#1*U)^lF-@nbj60p^IpH1U`p>&b?61XuNObxlHp903yh^tDrJ7e!P)I6 zj^}kTmCi@4Th0C3!+jOrTALQ4*Bo~)#p%rbc@fbI0n+{6%&p9aOE;>8i<465Hh0on zVaJ|>KdmIZK^s%PZ;p?VTM&yAe@5K|T;#>;Y*u7B<_O;{nScYabd=i47gh;D8xXV+ zRH|+Mb~e~s={pjoPwqAbvxqR}U}8I`VH2f36fO>q2gn6~`$dn=*H{d=RPX-k(g(CQ zZ<<@zOwq}dTyQ3VgKu3_G>5D3KHI9os8FGfQe+)`)7?>%7>RvudHE|Iuj}$yS|xE- zqtCCYvvv4fj+fF_SnPFP^UTX-2rves6Gg9ehDgUVXsk8=P}%?f0GJn*FXTR&&2)%6 zVl)g9gE;mDk3-`A57Wq4ODZb)pC%uO!k@l;cZdhh=#s{bC{6B60A1QG7Yi)K5ZbER`ZhnDuu{)EjqHQlIUjVh@C6x@Ld=l!WL`vE^_SV~Gt z(cAM~3bEj)QO)jWeW3(wl(oW&rE#%*?(r$cp2!E4OQLz_mc}R--4j@>dliI|Oe-17 zz6=y|%CX;HPtn}GK$m$9tv7L4@ZEDGcGCGPL?mr^^TOBpl2Ctdj|_#X+9+8 z43f^F=Hq_(UF=loYV^pJ#`cSQw2^^F+gJHYHMJeIeplDe zKaAmGz4nI#WQy^bfbFu5?{1`3SxeZQn?p82D^_5c<`-E@_8)#gh^9>2`4vl6DX7h| zE=q-Eti8{^b<%Nlk@CATUy*T|fk4&ii<*?roCL#q+0h@3f|~-e z_SMssR99~I1l^C1lN>i{lHu_qfhAowV=GA&wFK2PT)Kps$jmyXax!ISvUJMD0gP8k6n!#~vpwjEcfmXddvmv!sXk-e- za;lhx5m)gnully@j*j-{1coUDe}PhYBN&@HZkNqsIS zC6}qB3mW+yo!Y$EGQT`uUnux)GVl>u=g7&{(`!ci%+eyy>ZhxvBgw#v{-eK>PUg`_6ixQ?Mqu@7%8vj*<2IjWL*Jc$d&R)nXS(#Iu8b0G+3E-|;ncDwfk zH@n|;6*G;D8yY4-dM$Qv%fliD zgRfGkY>&wJRIy3dY>YsNPpLcn!TTi!64EQ^0InrB5l)+hmy?AmXME?4@f%PmL(iQj%)kb8)<)6loT-Fx!bKEEW!RG=MdwIRC(jmqQTrj zKXb)$nLh74DH^ZZ9uvi7*e&1FPwu{M^~a(RrkU)mFQ`!yS5Vfu)7Aa2kcXbp8QYkd z$(4F^e?Q$m_-WF9H0dZ9ljlSs>sl6?Gu5^q7$yYl#^Yb`KG(L7pWkh`8V^Qf^lDnh zlcAZ-vE=sTuXx=U47sdW@Mr4K@hKf7NjME4$$DO@gPqopwd=duPnzWn`sad05D_O! zDfPU52Drl^BBt0-&!HF|FYTC9B`|7H)2o$++Vc>ZexK~@tPw%H3T39c&v(KJd|J#F-@w=UHq6aHazcZE`y_^QsV;74o#!C()d!N7K}_;1948Jkj=GR-bL5k@z|W#N^I{0f-I-W_}+aMrZq*0y@aC}8u>169aGX# zjq9Dt2{HqXr<}Pk(7fiCQAvaa_>r7~rme$(l5#vMF>_s(pg;kWy9jFXm;=pZ@ z?rQZG59d(&{fjke$re=u_u%7Ot6!NlA=29R^tOk{<0bDg3%VDy7@E+`AMh#y4w`)S zMu;_754~sW-n)ms!DG@JFD6+8FAHt3pzC+y!2qF6SgEO{oj5qU5QAt#B_`bY%l>vn7!3^c zAfNDxacX*6?0Sj9POfFIbpd6>i&ReQrUavS*u1J;r8-Ru{=OC=Vaq-tN5}iT zqa1^KarA21DF%G|&h+X!Do&hO{B3e+yxEKIoV?Ivd8q@?PYWcq4BcvX5_uf+2%dj= z8$oR1s|ZQ>6}d?^;CJWPLaW)yy@gQCO8Yg|sCiT8v(LqK4{ZH>NUDr>49iJ(JZ+at z;;4>+(;!hK_TIOo)c{ZBr1#kuP)5dIlns7V1H$DtS>mr0iA~bg#=9@7irap~jH!|` zJ|HMJZ~E-A+n9&GZE|hpfS!bl z;ZCa^zWZ+cmI{!au}nxWucdsb+a$r1A-K;}SX(=;T>r-UinEC^M?x(sC%gG-$#Y6s zN7zJvu)?sruhx2g<4c5qLtSnC%~r}_C0y!IUD^-`JUZ&lEq{nX)D7-ZEnGxFY9> zFS@+A^@me`h#CtN>XOkI6f$q~x&5SEokvNpnhS9@)-HQjI<#n#8Z(1G=03*(Rj32! zr0qYm8-CeRqG#aHy)@uKhmzw2wp3mB#28633|1+nx#KE{J$~Ez(ztl*+Z|_dWC^_w zyVCk(<5k_EsZZvh7@a*V-<@TTmG0J6{5W8r=it89Dz z^~GY#JIKwUR&RRQXAX5!oZ;eG3!YgJ>af1B71ng?j1B{_+X^&W&DYxa5hgs|*F9&$ zg2w{h1BonSjn0-ytj59av2-eZaGbhstME9HBe4Ckv=oe*)sY%iCP_@Bgc~EX!hA94 zKN_6(RdKFIRG%iFH|zO=C*c^Kbh_Jm(q7lOPwfYO{3zj%fR^KVb#zopS#egj?M|)6 z6XQ^lv(bAt$1pEXY6@CYtd*mft*~fixO1uA4T-1lt)RqLej7!7lP_d3Q382?N^M@9 zvGE$Tho;ppXZb1c;w)e4N1U`SJkwfX6A;BtCB#@Z(dweLk>3@YV{+`ar`~=}b4u2} z<9r&XqxqoTmVP^p{o?{ceC+8rSyMYJP4XF`x3=uQlkc1`pl|AxlC`Cvx#Ap(_SLc< z_fi`$eV>br2#T*zqix{<;}?1`;X65fmSo$4xMM1nCM#NJ?pl$j6FBc8j=Vf&_svzl z|8_ccVdUKY?EAx*t#}{v`fcLvw4dtu&{V|9R0N@mEVQax(8C--o+2%W&}f;Sphk^F zoN|e#%H`oa&1PR5+lu|-=}4AHwxKK~`^&AL>)o>ZXhcoqtvQBjR&&*oDELear63_g zlA`W|g@$pN`DBj$iwk7w#|Sik#@*@LZII*Y>Cpne+{;1&WNkqsqXFzij~=W57YQ;^%m6erks7V>C4XaD-B;y4_8g{ID% zd`24;{b&rdRHxrK?$t<@Y7_l;uWjXelj>k5O6m+Qc?Cw2$Ks>z4^{G)V!QA!GFTiR zGr59r*Uwi-E>?=Puh;m6{BhkwXzpA3)QIJp%9!_-E#OHTP~x1PI42`Ay`Yd5#*z@y zzsoo?>iAKI%}ws1W?z)i%y~zVO9H*e37$}~*gW5#CW&Kvdqv}MgQy2qM~N+r-m!lX z*$U@|A)$8>N7%5*Ps*V@KFr~cAtC4-N63>4Q4-;}O*Y4_AE{sr#-*p`HGv0`*FQq9 zy*=mCgA|SWMf5gBqwWvf&Ukl#SSrEWQ=7$=rGH6)n6aGFpy!^`NeeAf7bFV`A6=~j}89b zCKT0F6*gB+W~Gor)GCbpCq{Mh%+0|c8|Hsa@Tp8sdc*oP{TmU4AO^qVKR z@a6xIf=;CdGR@{3a_)Zv5q{;TCEfx_+p%}XQ7ZpR0K@%1s?zTCRj$asZ$AO%z3FgI z;bxm8=#5zJn@vLC(0Y(?L#b3i|H}5riB_+mF_uAx%-QzGBv@)?W>loo`fS;O>7Y3F zrG^}xase&$)YDN)QzTIUC*7Yejid;K#IfQQO6*p~QHdDD%)a*Tvd;|-4vrQ(^Nn1i z>X+Jeh$B+-$;WfM3LngNCV7p^_)h%I8`iF+fyP0&uMatDFF_$WTK1GMv`m@4Uza>C z%#*lG8%0GwrtIU>s!DaqB-7u@IE1(3X5xLxDA z78FgFG9QO0li!@;JJ=d_q{HOPr$x#gKJPC*Oj&@RU@rb50M-_Tw7;R{z?la|+%QXAVhX&V|< zv6kD{sczco12fU)>MXVL?KN|_IB6$bbwKA=GVfgdRfE%0OA*=elk86E{vqq8hGr!x9zwKd>R{%?cA98Oq$iV|Hh)xR(oq;Tc5A^swGmlmd#=viE&sTX;`SZ+Ive&c$~Q< zf62s<+a#VTdB%CFm~oY}#E7Pq0 zZO3VAsUI%33|5!FGz3SEJ}mwmEAREsE(=-GnGY^{4mvYReP^(@eCI)Jx7tErN*YNH zBiu2nl-`wo8A<(t_FKOgri2;{@2h1t>m$|(C~l@}Px!(Cwzc=6J-}7>MVL@9a(y0eC_m{JOMdC816mhmCV=n& zp)a=?WW}lGcG-x$={$@=XTG*I>D4GiGNTWP&ZU<~>26Yob#67u>()Iv3sr8w$G^Y; zZH8?3mQ6vmP)R2wbfRwcZLbIR)+u$R3|KFfcNLEtPYCYO)i`ANGjp|;#VstIK%Ujr z=WAG29r4IIgu<#<1VCLJdvmaM1zee=f`o#RHfj(|#;bjghn`J4mf$mMaCW(<0w|vk z3_avp#lzWM83xwhXyap&;_;ODBa$Ahq`#bg$m+VK=J18XQ#mc=$caR$#N>PcW*#Cq z@8^k#T8llRVa#q$;;JU-ss`;`{M>t@;YO}Er7Y8uZI}~hWY{wVe;`Uq#ZvmPv93Yd z_2(NWH3Oe^hnN`$(Ct;Lrn&uJbH{s80Qq(~->l)V*=Kyk;S2F8)F}0xUp%q~(0)HK z+~vUnIX`brtV|MX|Hrazoa%BtTpIQ45PYT{V9oBigY}eDR*t=!ad&KG>F4c-0$lQH z;oK%##tM&W4j+G_WjX@jWY_%oF#Vr$IaXgI# zXbe2I_RW)RNQhJn&dDmIR=)M6|E+VpjXYOEymfkwc&x5580IQ>CosNm(nccc&JGI> z^F$t$1*;o>azYblRb{HvoYKqS2)2 z;cUYwo6K*4uzzpx4e4xY8B%a`N%tx@2-sP=S0u(zKp~VY_Lu;01Dy2_rvc__R<=_1 z?h^`GVmIZ+3m-0Ln;sRgE~y9t;kO%as$3z2nz%S0$;ljW;`&~HF>H0z0exo2zA%Xw zl}Ir(AwGn)pRc-F#d0F5_1NoWX+gyyy-=?KDjWhr*V2#1F!=Lhu%}^O5c*i783bc1 zYreW^#&0zy(RrZDxlHT}q@`>Hs>prK_YkK=FoO+K0t?i?`mWMv*msdiaU*+oha3xQ zwbFMOomMkD6b>;k=SynLukZx4kIRkkA|6gGK+1a=Ra*-XD*US8m{Kuf{1GpuR>`R- z9pkNr==gGR_XKanFs(XmEaTC`u5g7{$aM)_a&rB~Ve!q)2V4G$Y5QVJFxUyF82J`5 zo&xNfe*|?lFj)!*g#VZiUu zt%-Qqg#9)MPv#r8Kljr3>kwI}S2YA%+K?6W6``h=AC6wesE96+DF26H%jvwhT zL+P)7D-j|Gobdm}W~>P6XIj0R?(ffr9gY@wmV3MGw~N%ux+*v>INg_Qr%QFZHULnv zz*VI5-$WlF6x113yPxY3f>L!hiyJ_8fp#FSxnHN=PI$>}9qs0zYB<^zWRzOtw5#a8 z0zzCch1~9!br~Hmwfx%X{;9u}W0=|}+Sku-0gTyrZ=wL3fFQ|4;|}PT@p7y8(VYsA z%$TdQWxhGxbhI^u{`b1&i!b4_vIb=Lvh{kHb(^2r64VrZfP8E7yt4UuP>Xp7*D?jb zZ-!Q_PP@@B_}pG~)y~kD?t9{3j+A02)7TD;-cesQ&$x$Mf_Fy0OmjE(#V4k@1oAj+ zNN6X7RUF1^*+fCWchXsJ0t~FC;{aL#jRiI?t}zUmrW%k^{|_hX*VC9(`+j?XkG=Q( z&+c3x1v^%4u2i5>6klyIDdlo7vpQ6TfROI7M_ZuV(#USJpq|WbP7VMgU%YNM6OIfE zRf?#+?=Cr}3)RZf+091UU*vZLL&G8@?k@ufR^__1FU7+qT+MAOXI!~^>&~YAdg54CUXp)29o%^1i+jqKy&@pb&J#%uWXn2 zaD*fVenPz zy9Hk@Zyq%r#me;7titbi8I8=A$T5Es5?X_8jo)oiqgC za`Ln7VXk$ijh?9QaKw+m6OeU`2Bt*v@?dro7(%RV>rGenh}n2v*v*@=brrLak6VK& zDVF=r9FbYw0^sxUM?T4@ejfnU(t|)C>XizIO)19*Aipe?&gX9Q00C1&WpBElkG|dP zrO9C5-oXcFW|BI}9XRZHC=QLU1R+2H^a=7gB9Z>Wn=z#kwtXa3)TA z0B$b>Q7cv_15nKbKK9 z2k;%yh7b_KT1zm!O_xj-uC102Gb`jxLkbg57bhf$yvu7T6c)s(IycZWcph z-J8XT!*1UC9AH0?_}*9W{rrJL?YG9ebdfr72B^uTw1|bYB@e-fT_{Tr!eOp&a4=Ir z{du%lgKc_quqym@mJT<&xhnyO%z&I$>DRLy$rw?s6tl4@#~BQWTw&8 z+D!pCV2gYDLAyk@`rf0I+S)lQ9srj(g=wcN=DuaiX9$?6fUDyI5eokY+w=qI1Ym=r zMYQS=kjwGNTYxengDJvRB>Z`{$~1*}C56)(`;aqhQNk%6RrWTdh29)WBw{+2Oay^e ztu*!K&B2XyYc2XnDe9a@JDVK|%~s~&2JCAh^IKv{YMJfulx7AHmochV3;15IBF;8C7u{h4KvR{chE{}`z;K4( zpA7PUxMBg-iu1}^Zh|hWFv8(j7Bq^tnQI7O6GPSCMo7O+>-jPsw>`8XbDDM4JeOE% zb}ys#r#D-j%hF5b;Lhr9iq?Hy`qb0q37EWWw;cpK{o-gY&pkNpJbiAAth7CVYkT*a zV2)7)md$n1Ie{g}yR3c+6`$#ap`+pf`?DM!{pb`YeMRe8#R`K?OQtMCb+eVVA3-=r z-h?YZW#-np*q}BWB7WnqDk_p5eHDUn9bvwmlg-hpv&obGhz@fzsiqf%&RO6uYSE8; z$eLxyZ-$R#?X6I4_AZIrKKls~FMF32u}8@dMK4$z3)CmW1gzmiuT7X#@?;2Nn1}bb zhBKB2nzKp-__VBdYB)x)^-j0=7^{4ehNG!Mb}O@W#H+visWYXD9yP6VgW6;{v9i@IKX6 zb0sFaHwk3KoVs6MHoF{mIE6e=fS%jdbZ7KWSOxsX2%6GpR zslY%$BcxQym%}|A%F^LC8Ax1BA5%vBDHD_f4bzf8G?xYY&f*H$x&%{gAIh36n=N@K z^d;}t96A0%wl6ygE<~c^Rhyqom!cigYo&m6xl`U#qI)GRksZGj-u6vI5-)v#E>v@x z$YvUjOxb+$4K=;ao_YToTe4zYL!DhA+c{Imm7O~a*2SXy%~`SJaRCUGV^m1#AZObg z^(oPSGA!{Nj0ll4A2!G65$XRhwiT5S)WKr(A2-0}oU+U3dA>s?^63dy8j+}J{Rs0R zl~n92y}X(Le;=MHJc79}!-aZ#>aUqfNz}30B{&gh2v-R41j_mn#eQu1$ zRkp_E1v&inE$Rpkd9#(G_hhJeT|UvGWa9A{1l)B|Tcqrw zhaw^o?u8S^wEXKq)9mUkr2rPm(bUHfXHls4J6 z#DC^ayL+cfcOBSJsAtw17V-OYrQ)JjR`m52l0E-*YP`3laEj zFCo?U1v%l@m;1(XSAC3fP#F?SkB2pd!G0kzk;EHI_(yY|sBpTx^kn&0(nAC82RaH; z_+{obAh{BqeS4fzK7SM-kNxi$x*&pQ_QwvLGA$(Q9;IMVej6N3l`6i zZ3b^dOLd;jG*>?zrYiUBHVGQ*i--%3e@Q_`Mqp@dJQ)tt9YF-#lq-(<{28f05iH)T z7dZ^FpLDE*!3U0A@#*}YeE{uXar$7crpRe`tg~eZxXDHN2=08kx=}bswG{oK;`pY+ z0Dfap{x(P;CY9n9czl-C{#tFU;Xw&V8YvyJZho=d-2cf&NzV68XRoh@PGb2=FP`tl zv7xR)UmjGI|1D=4xK{_<23mxlXzzTDb1St3<7Mysh1=-;L2AvI<+tNguPRN}^Q6}= z6fI2g&&~^Q#v08Jxv|9M?}hgk=UxtZTU7@N85!kx@$FgPSRG)xp3re~i+Z&1C??l= zd?OB!=}>eds;>vmTIajtZy#?30ufdGLW5&}rm(-!`Oc_fsWwjo5IZQo^3+Cw_C&ou zJ$$2a0yZ#Tg6NtrWffSdw`hpBaR@IR+^2`$`P8?d%I}8ywI;|t7}d%U^P^z}A~WdK zOSL{b3yUpOc%vye{tb@aH@#KJ2jT(>JrI;zB3|x(Pd-F{G`-%+CLH3Drqx>#w%?yj zwZ9RQrPuR%QM{+805%PAZ3WwQ$@PuygIAD0e5%H|b;<)Ld|Q*bbb%Fk>?kQXfo>bP zmx%`NbA9BPbUmtH;3_TRp4AP-Q*K-5#ogQ%N-!sX1Z1R*hEgX#<;wX)0W|c-b6h2` zH9xXSCyLaD7u)l`n? zEw$bqAl`UxiWj^q3;wR0sWu5z=7?!D;{4{G~ruFm~9E5(UXgp0#^ z3CEyALtpM@nel!}_p-z07%nn0ntgq=cSxDe$1RyO8eGfRm`l}_H%h$@oklkwR4UC6 zRe2mwi#K}G7F(fW2N>--Z~0C(PBIqu8Mxo-@8|8bcYcX*jXw%S!ZKSS(98}YcyuOeT}xvI|zJd`)H zCYHMFHnPS<-83aHG7Y!hCQh^#G~OLN0TECFS2TkF)+^)l#n%8W*3Sh#x!JDx{Q2y6 z9Zob=qUt654^AC8M$E&MqIq${;HxqF0kTrkD^43<$T3qLRkz zjc3#f?Z;(MAMxtpbwAD77);^n5&)2e6-|&~V0cQ{4NBKRck0!{K21bg<0WP7j8tY0 z2j+6l4T;oc>g+(-K`q^j07>P{p~D(cl5|O5^J!HzUJ2Vgh9o}M3M&ziw!1^3Vj4dY zb^q3bd6;Xpj9eNw1!IPn-xMcj@o{}{^>qfA)nba!J=a*LK&`^=4-jjfvy3Zuf1~ekr?XOU7$FjRv6IQINSyiomSp73Vn;%B8zr(iUjE4ukaHYg_e zc&0L4z*REc{lT>09dFyYwP%bWQL3gLIJ(jGigWy1woE|b*q`W^YTfAg6#i`O+Mf8D zGD%ay-AvSuB-4`np}R)wwOT`!y(6twMdAI$Hp!_~$|r}dbIB$gHywd8SbSk&VV2~Y zrlYU01Lnb&yd={sd=!4|zA#6$@`i&R`AX|aPKN{P4`~C~!0k>cAuWyOvC=kVU8l;f z<^sj0?2^8>@3HZ|j%UVu@ojs%mtGlSKYQ^~hj@=_p7TKFn({Kw6J%qE-xpMsuo07x zB2hjm8@j;=&7QJ*OZH^vWPs#dqvW?E|n zh4KOIa!K9)tG&03s%m}Tg=M)A5RnE!>29UF1nHD+rMo+qh)PN$9fC-Ary|`UozmT1 z=UMxgTmSEQKfLd!Gmc|y$7ZwFT5~>Y&ilFU`-(|&RU(^GB0DKKsOnT1ZyqJ&6#il; zXydpJt~p;mTDSB?5p-M$sWIGQrj+WwCqXvP4+CX95hUD%@c_!rudQc-l@C1ti(+0F z7V2vqLA5|VS2RLD#6L_MZeSD?WVZ&o^9uFfH8E7w%DX|?%*W2 zh4Lw_|AR+k+7@%lEn%&hvi8VN#vLVB`t^)VKIUpRC0u?8;^^aS6 zf2>VcB5Xhr$7nwc65RQ!q;r2IXd-#!kUMs`s`;jY&v^e0j|p|)q_eFf{>ra_HInjD zqlQY$#!FJXp$6fbH{!Ac4og8ioJM9}*7gfT+4k?6Y)PNgwzd+vPQNOAX4?1UwBqLa zR9~~oCVARvSS~|X3SheMYCn1J+@@lt>th9!CafL7g(@E3Ps@*Qgak4Gg@{aQzyQ0h zd)Sef{9e**C4_Y=7y-&;rCJw=zcSP+!|HtXfI#T%@X?GFey{Fpd1l=bqhI(7ADkEl zHcsxB9v+$+^81jCwneY*x2YPBEv@F4upDGf9YpN^KqC z%4u;%AE5Zy3!PpM$BO*G?ZHJGP%@5pI(xbylgN0_ybNLLfPGBT*X`o*bLq<##asT zm%HKS#zooK3NW~%{z#&qdLf=o3zpjC1BaF?e|yOUF@zw$>2xY>GlI>7k=-*oR{00jz{)=JXeK`S;){pjRhRrUTDOD)9+u-`gXZ>9&k!N` zYS{LDx^`RR&v=|SRC+!e7OZpQs~74-d=H3s<;6qG)4MO$fji;qToz|KvAXx+L!N`( zE*YIpeHs+elSrW)9ZCf!1E0{^3HA{3ZFQh@0_BRi^@1>@({raW967Ngj6{UC z$NFPjl>Og$78~yJfn`=gNG7asi_ZuoZvRJ5ae_TC>H_u|KcGcp*HEhTQZ>a(QPwVC zhGe>RI!FQ*C2>j2Z~RYwun`+jdVHQczcUwiAc4q$IfQ8X(+=icd+&D#i*mDi?RBed`LzcATcge;zC;hEbO5Mq`@#+4;rVy<=< z@k!E%JYuHr?&lwWocX*E;GC|qnLAK^9|0i$0Dfvr)VF`A>@fC7z&hT%#9xB`(a61q zM+G2$2k|DqwQ^@4o1GQj*8<9BqWG0RyX9z)ue7*4hNS8Lpt?)ylNNS)DQYnIQ6|f& zHBvd>DI&W1$(SS!geEK{Qdj$=(S*=P{sPBJit&`AK%K1s#M+bELCLS2py`PNhGiWY*# z^+d=;gY&lR1vxo+ru6Y+Dqj&nq&C&wG2CiyfCc%_m!cfjho~U<_Uol+Ffr)S^DgZo zL8ikM*{a$6@4bWKK{1ifqE>?bzqf5H`Ma`fplU4H1HB#rq^#*ms;!AnDxs=L9VC5x zCkSwHqf8)2%nqF3rinmQmF^@eLcF!E$F?YCAj3{WGPy z-@&^Nf(hTGIQ7N7Big;=>Rs7^4Bb^VR+key_gYh=vK#p-%=HrPrE^|TFpnob6csMs zPf8$09NiT(DZSpa#x)vo@)-;h(kB>)N@>7Tc8;p`S2{ zXZY?U3KhT4-H}e>Nn$=8eyZ$psjL`2U&TDP$zN=sC%tJR_0fcwt1BAn0Jl4HRZ#6!FW=y@{)c22O zEMj!-3P_EHzOJ_%bOSvg(=Rs^O7K2)yNwLu!FZvI4j}RamU;h)AkIv7jd1#>yLL7A zmIh%Sk|%hy=4d~-%x~UD3Yc;pGSoH5$gICc9jR%EU29=mXW5=Kss|IHNIDtneqF{X zMN;*YCtp-d72bE2p8IxXki>Q7V4G$xN1+c)w!J$hQjfUNt5GtMO`s@9H7AS7-?x_R z!_sJCsLktW@XqeuupUgkJXr2v{9MN#dAS*5kN2)c+7mQhFJD``&(v8y)~s<#2eCv- zxj<~&fD{rNndL6@;W|=MEf^ITj0iL(nmvKQ@N*raQ7_*0x1Y`dTRfjH*;Bv{MqaXA zc8~E$L{u0tj7X5o-!p`rO`89f(BFY)UA5$(iUS^bV>}b&OKH0EWaum63^ZBscC{}h z?o~s(2COS`sIZ$to|e`42%{RL{8W-~n`>#P&_$@XHI8d&O)JaGr`Az!BlSl#xr)0| z>~jZ*KSo*mU}c z`9lS^(>ZY|{t_>h$FwqRUnI_pXA6FmiJ8PrMx5Up8Z}px5llI38Qm@{$CdMS)m(fYVqm z=MC8J>7)w%{o)|!2NLMtolbgk9+}pTmKhl=i!w%AloxdaJNm1%nnogtuu5;QaD@iC(P9+k*izw zJt0=);PmAa4C~>pUNu&ZD*YVCWFt?IkL}Y z)M}fz{5gK`JaKjoBw#d|M7wxcm`cI-rY#QlSx2YBku8<#G~Y z)Sc3Tw4*mP?4xi6=qG2%cvxvK4h)`g=%MWhZp{ ze-vcW<|>Sun3Inb6_=K5p+;|YPl@9CA~{d~{NB4RyMy2lr8N4&cX8Uoo<#PyqsMSC z;05+Q9a@4(WNGiZM)@lB$&Nt~>QldLUdULiv=qHfWXbWUf7p}raXiOR-GtzS_3LbB zG`&-zLEW|opGaj^3fR$^^aD1QGpDrs!HC&?OGT$E5(*QZy^TsUN`20%v5WBXf;}p( zjX9h|ZHs;8g_E`}!>4D1gyn3mm5P@*v5`OM;H}MRs2^E&90UpOFe(wXQeE_OCr%B@1=V^YL7HlGVIi z-3z2DGELUc?z+$ceXTbah@KoXLvHj3 z9?8#aR7si^)-d&YBOX({*?0%x)^kZPbvTG0+TwTQmJ zl+=b5mzf&F66_1g6><_L8PB-w?U)cTPoFVA}9|R4h^jE`3gw{o%L=eeZ9AJ2{-%Yy5=Fe>7*`#$W zOw8-u9LW-8R+Ax}LDNV_Xyd1+qA$?BnKov3^|^4OA_s55M;^ScN*PDb&jvW4*jfgtyDgOfO+&NEjUsl$^~ z>Fh=Y?teOs_{X-ExpD8wyUBrpAjLn(sLW#lgZb#?gIO+yf_YV^c+ocyW3lYIB`_%4 zR_efE3;?_>9;1c<1Sd--E*2=awlnzFje<{L~UKQJ1Lyn?7ggCLsIm zi}{V8$Z*c<+|JEc>mDx9fnu%;4Hh~w5b$|c^Usv|Yx-tSA)CJ8t{x$*zp(nD{t(a3WYATsV4Ho$XSa7{uBj2J znizcPoR?>*-iXw^ls;bZS z+evzfJWjSic%)0BW}$Lc5TkDG2tTuKEhR8Y&Mv?CjA@tVS6TdsBeMvHQAbwK$NH-| zpIbV0Vp^UK*h(JNur9OjNoz81+ZUfC=Mr()X9j@NVbx z|Au)I>G}e!OlEx}?#d-Ec+71Pnb~6))q9+9f&VH#%9KiCXN!|bp!EO;xR`d2pDfn| z8ox*0ny#OUE*F3QMLEaB{e5)8>s-IeN;ltkKRJ3f@IZ9bmq-TfuOrOb&GYsAKIvEG z7IEeEp@l6eMR-LZGjXr^?ohS@Ne%FN&y2wnc^EZIB>_LF)8O&5AsG>h@j?H8=y>F{ z>O9P^Xv*60AeSdw;l8Ikk=eYb5moPeEP`2;K4kvA;h`}`?jen5eJ`zIgyX9)Lw}+( zP$(RQ9~R?7;aQFP^;@pLC%WeKr2oIzCt1StimehYoqGN~MD4h!@45`d-4^yBw8oe| zHv04Xu;4J)^u^imEtX>UIg|l!pclrx}+8`F9+;BAiLT&!93fLjr`&1#z>o!Td4$Mm?dN-XTr2jY%=vXuM3JZ658 zpHQI_@lt~HmbeE5tddPW*ROX?h!CK^FstnZFVGk)E7#Bq3tLK8Lx{t7p)geZKoZjVb?T#&H1nuFQLBN4)0`9V{0w9Co&N2+Tqq7dKu& zVg(Q%rhK>|9&kS@V!bUA7`po6pj@FMs9Cz8UsHF=<-ocXDS+xjlvN8fY?Y<(xEZs( z4BNRzhZZz09SJpVTm(}TD58XdJ+3F=f@G~W&t`zIIc72R_YTS4K3q8YUd7TP&u+J4 z14&f#yzu%z`y+p7lIFZQr+WNlr0-$Ld| zq&Fh7P8hKl+xSJ*ZGXE$SG7&(GP?EJw#CZCJ4>^zZ)Pm_(OWh4s`UFlv&%h=2BTzxv?{Y4^3vA}7Uw44 z8RHL+S-x~kaqX}IqV$h8#SrMp2$z8 zUB`RKRT?b_a@1%px^rWx%Dg~8&mFRNhXUq;4AHmgB5%K2)0Sv~}{;s6YN^ zNEcZN`Ob3p(kU;S^dPpVK*;;ZS7AEnl zdxlrcVU0cgM_Z&k4#UPhYB4)XkN)49tes=-gx1>%R~kD`wcESxO=SrsXoh)4TqkcC zaj#VY+!d`{-fP?j=FXVZ$m$uB>tnN$dW2<&{0RK6bggzriu*uH%M!+fbQle@LPR7}_#I*+np2 zpQ;HG-iGDtH3~buix{=ujY;voXKH^hv4A;^ja@09#g6kl-(B*jq_ctib(aS5Rv+VC z0=fM1!p_acmei=zd-Bn(j_RLSLW?|R9<85GVk?)*qA&!=FyfP9eBZrARV?iz6Zs}G zWIKYI;a|>tX&l3t*wocSpVb)>H@ov{)827M6|yNNOG$uOTVZYBG5O%iD94G2L;a2Q zEi?NEI*OKkDeE2fYob@qsM5Tk97n`Qjp;TP&KX6Qd@@P&n`}>zt1BH{$%Hn0JKGU@LSk z`0tzW-`%zr5xE0v#**ZXr$jn!m5MLTqAU&H{DcG}A2jIarE^+QNqf7Al`R-*JC#aG z^_e_NV*xqN8&-~`lJ)_|>R2n5Z1roqcx*-ST?8nzG$}i~EWK)hyOOirUwOWMzW3L- zX)eU!pMf)AB;IPVe3#8Fqw=^GBS$M1=GK4uSvYm+5Tyj91^-6A)Kd%p`fhoo^XQM? z^w9|a`sF41d(Z;lZi-OCtM>>6@c&4-g&l(5aHnEi{-);#V1EWm4MJkpn5<#(p<@?_I^pK<3mmL{?xO+sf{M(X)WX>V1e;)f@ z{heE+z51LAizQV|%Nd1?-_3%}$`DFsMrS^hKVpL|!SNN3UQ-hOz6^|1U>TIFq6~gp z9*pAHJAtVG_d|YLmj9EM3nM|5okl(>JTo&h-=&NQ#*g_SEDUt};ruy?(!X8ER|=%v zKLV(ku&}VMSje@u#vrXhxD@saW3J(Ce|O8J;LfXJ_IoHl{)1?AQ}p{0fb=Zq{vUT7 zKLfZ3%Th-E9FY*?klHVZ$mYWH#sB_Q^xp^fVm?j9Z*j>$n2LlbspEzbmHYSqAH2M| z?5}%qqT8*qvOv2E9#@qKLXVWI?Owffx3I`HB<$Uusse5S?WF|E!U#Z3_Uk20V(j@f zM^eeaO-En8fIvfO5OYIR0c=RhKETCMModi13_LZCTfe#Ekl7KMw(Qf2(^T3 zD$45Z7he!Od;M0kajUd@30TKYvP_2Y{{GH$h|Ki%_G<%VQqs~6=H-p0C624|JU&;| z-7c%RGucHRM*L&vpMo`QCd+d`sEz`2!_koJ&&=%XL`n&lZ9dPFd^6k7^73-oRnsaF z!?8nP6(g%nQng==jf^A*AyK_fT>+!<>tfkx?%Uf=ba;-W@N7>y&C*Ps=h*lO&2AU# z+2X!8<#3{~e#40J43zu-oH|64v^_BRnPHnGSZU+&;#Uqc&SO$h)N)2U(=}i6F2l*5 zXZl=UI2`tJ$$Wkhn)&?w!vkP5FE7G?OBM|bbH$PO@_of2>RKP_? zU(hCFTi&DdZH$O@0sj;O&_Kt6fld4__*@QWZ*UZ0i>%CMrN2triLr_Dg!?ULYAe{S z#uWw6m$2K@HETc)qs+z0HUr##SZ+4>{nNVCYF?S;Sm77l1WJ46$xAUJJSHupNQnt| zzSMSy8&tEQU*O<5@ZrL=^UHF(1<^7ekc-*{R8bMPp}&Iu!|A&-D;8*RunFpi5_0Gi z9&h9oC2WHs1hYVw?!(uJusb*%_P<0u8O?V6P_U^#Az5E{e?i|WYPzYFP2tx(67d3! z$iYE3OYp^gP) z2_E7K7*C6vH%-T*+C%m3j*j_`wkW!zoR)8dvFY#Ld+_wGtA+N_OKZ>d;p~sV+}i%& z9XD{DnNO5vNxfM+KT-I$-OlUlyAXhHwEwGhsK(KhfX5*-kOA1(xX1Nhb#}=`aU>`X zE^;h<4#Z_z&3oA{KH%bgxn0#KhbdRQ=9kI)bUnbWE~!Vl5p~-4_S#{}x+;FNt+h3N z*W)(Hm-(B)h!>7-H zovzKQHk`NO{X4;Vi(jHh^glDo3a&uF9`&Z^;x)dmIy=*N&EKLR~95&JB7I+1x{W?+u4iw`|fpjbo)wBOj zfiy`thv8SMxR-ZGDg)8@H%;+dkefUf!Ou#`|F8i{GNV^$VP8P^&>inz11@@;YlFNGEXN zc-dJyiSMT$Z@ue$#`JJN$~JqV(-rb|=>Bq?e!_ci@AtK%=Lf;uarZFHg$=l z(`6$bUf#)NyX!0i1xB+XOeS86K*zzi&F4XaW*f2??O{Z0?=8sN1lL}-IVR6+T~1rq zh4b##ZZbzz59r}1Wc}RznWxTGv}rc8die1E{ZcO2t{&Eao**wXcpIxr%c2GoJr0N2 zzW+SE!p|8B51t3FC!Pe}1x}O)q4GjWJ!jLelfMQ+Vbdr}ZXu|b##=@HYaZ)ES-mUS zDIQ%%Is++4CoJB`i6Dd$Ji6|Ix15+Kh1rY2n=U|z<}?s)p@T_YDrfuDZ844D)@IGM zP0`%U`DC|9H<(W7xbUIRu9q&(;ckm$6vdjAind3ef$(f&fB`b35Sb>iTWh%MCaO%Q zUDBO5NOO3LKMG!La5z_DdD@~DTzbu(Y#z?=K_)4rqFhc6Ktblci5N0hJSKU1|KA|N zj|1`OcKc$Z3h#PAIyJF;FX6+hd32}_)FHXruCP^*u<#_!ZigrxeSgwl1gUpqOxQ^l z6=e2(toaqh(9@j2>z0j2^jVZ-9wZDH_ooPiA^CXkjlDnE3QEa7=F{h^Tb$V*MzCWq zNf#h;sz+m*e7p$in5%2GVWRg_qH9D)P)HK@8Ow=yHL_!;>u(~XcsWEO!^25;>kq@E zRLmZ4jR~Yy@q`Q2Q}6u>X5oDiJlcfBdoTF90+UEqZERa8SkIF3zZ!!MYy|I}8nBzm z&CGe9CZFqNh@l+TN7LYEDud^iG*biyfBN)jIE#*xbM!%Y4*D(c(=7Sb&%R{Nxr*0E z`q|7s)mfdMcEatfnvzEqm@}p%zM|PLeO3BBkZAHjm6L0eEDZn&aw~W+|1rQH>Dgj3hi^sV2d>yq%&~T za!@v%sdRp+a#{8Zb13g#I=31ZpnKQm5cO+OE2+~rt*^i+$}YTUqN z^BKd{e;z<#z=Pne`=iE;{JH7lOaQ&|gu}4$3G^+C)lcDWwj2eH^)wWyH%6Xj*_U%@ z4L~U?Pl-Of^hD0rsZsVg-k|!+u&4Cgl&D0=&a(8mr=8iTQZ~y>sc~?Q0z-$J^`!^6 zg|ZaWMXB8le3@Ej_P=1t`-07a*Qu;+0QjQ^#XiV0XqCJc9~{#!H-oh4<|wAWA&?Q( zw;g;&#crNHtQGc{tB;a>3+2J;CimE9ly@P^qMIX!N7r1Jei;Dmx#nz$*6Yd}Q0YU< zxmrQ0!p<65rmy;z(Cy@%>j`-NHIP)R4S}xs-&;qs2ShG`{h8s&1jQl;W*u}6(+(H8 zv|%)Sr*?fhLC|ZH0hx#C!s2b?NqU*lI7uVxXnOlv&tqQB7hqpw+u_{wxCX<5pgI`C zOmbQ~v4F=2e@C6ny=uO8_r$Qz=|!$8m#n9&`2_Jv0Zf%doBvFLf?7ws@PV%-z1;UgQTa}e4<7>T41ZoXkXjHpTPBG3Ec{_pUu|Ib?^u~Jio9j z65xk>N z0^B@nXGY%tcc{P);?c2-x3QjQyycK+@L}5aPXB8L2#jHV|3^TRvPFLw9JbcmWEAPG z<&jBANv+hK)DEaCdF8C(l=Gf_i3PDuQgO_>UODdN|M@aNUr>rMfKIyYU%E+lu|O9X z%vd}g;wRUgHZqdxRqgf=z*@^5Ant*$8TFuNgbo? z7QugQH-EJ#q0(8ha zCz!30&aQt+YFj1fp9|i|1P)(%{(fdMKjXTT#9e&94l03jocqW|bj^9>nnUn$%75_n zU;kFm1e&lZSHI1__j7Q5I2Mc*N;6*}{kvNK>uYt>1}$CH?wzsULMg$ZgAsILMpAHV zr^_l&O-YZ$diIOzA%N7yc^59?3~=po-uvOmK4W zXb?%w^ZTzz2V z|4aGKfauMIVOhu)7jqG_OoJfh-b8hg?9eZmjcfO1*}Klg2EN2&E{}(&>1sm&>~)~S zR@-{Hq=K)i@y3LkNf6iU7e2a%a%zhTduqrMUX(;PmIK-CK?|^TQpQbsXs*%N>U*Ch z=WCZJ66yKQ$_(THN7(~m2QW-c3Ln7oWe+0w^JzF-KV9Ap`*cgvk z#KP6Zp@(81-+>k3S;zMKPEjtTlSTG0v>@2Eqden+994IO60VZYBfy9fT{}B}ymZ)> zlan3#uD4vl^f<9Kw9++&ZWM34ib3tQD@pie-7FPL{c%WzKUJ+PglqOj$o*H=`^;|~ z&P12M)kaln@Rndz*mF@apCPRXBA0yIcs19d7e>mVSuuCwNyf-Oa`lAUr5N~>V{yk_ z&)yz+`8Jl<=4MPgdZTr>Nf{vPyP7#O%lt*4cXHXp$qNGiS(rzIzc-{Z?nR z$NYv|u|&%~p4B!4he_>+SJw{9_Lt-oOtYh=iwylfaeeGTJ#|$Jwa5<9h`u_F$~579 zEG6pPMG0)<_4=5~{jgYR(W__cduG}mQyP0d*jNw(L?^}-nin^;-$clFPtB%d#MHf`<7C1A@)Kr%Jn$JYGNm;z>ba$*njQS2 zoBG66@pwRYe29zxxm{?&SR6{3L`Rf2ab$QghWkn%zH#?EYl5)XxCqdE%DvSvZi1)I zfz!T*Oy;iEAu*y9c+dkeaM!qhm(D^?(oYjxH*-|{r8I^>uzi;uk5PH=D#i{9G-3_S zZ5+Nbw}sD_$_wyE9sO&i^Z0D`E#cMiw~zQe;77iKete&C39sjSmD|qP=p?6fvT*B`cep@ zi7Yk+k`Oce*?8lwZwuoJ>;ex>!1EHD-$3&4i=xInAH;+Y7!Yt5eq=ZE$U^)~N$Co? zbZP6V*F^2vQaUbd{BAE9>aj|!QfWQ8Fb;pNq=o|NNrx2n$N&KY8zR@);j)8ci!>!O zYiBW8I4HHygBco^qWfzj*%#}Rk*Vql>xwPkTVy?bk{dd_nl|RvF&ic&nSrUuow^tl zP=W#L4>+aAg@jikLOCi8qA9w;LEZ}UPDAGBURSc3H=DbxC!4NM%4C?%d`ir%mI-ma ziw4V)5up6k#cn_DMkbu>ZhpHRowWR3bkG}FaL|5<4phEJ^~aAmaWzH3ra)ywA#(Ov zSWz*2`dsnxFje(jlx>&wX=P;Z=52)g9Ao$>k=B6tIEgL2^$SuYh~eBPMmp1%Jq!?i zx%lMu9_9u<85O5N*{KNwGz2->5o;aoQNV=T3UcWXay3bh7L1dk`sz^gN;=l{RcTNt zW`LSn1)=)P+W$nAl6Crtc2^}!t|CI!Y6&Jx7?;!@^Q&u0wYTW}%0n*ct8|Kk)*rT3 zx36Z*1l=3bdz}xew_yQTpFp~2Ncj)cv*dmeI7zcd=VHD!w&mFH4e~A6{9Zbo z8Pto#(c5@vyJg7x=2Nh9%WA3F?tYZZ?j^?H=CDo6q@(#< zm{JAdCtEIHsi3eEf$(xzoYTkY50pIlD-^+i39fu=qWvexnb-3Z?A*~E{}*KV5B3ox z1xNtN1|s*{&JBJ%1xR4Jt{B{izisPY!r)6spN1y<9;I>zvI8#9YS&i`f1rmmKY#>C zs!`bg$Q6T5qlQ=8?S5DL{bMlp5I_YJw8J+0^O3yO_+VB%8}RoaZ8*l5zYC7qYo2-l z`p4VZv4B%;K-KMNC4fPHOr-;{AXSMy>O%>*Cv(Zetuj~ysKg{`mwLH%k*)_ zZOb)Z@IkcQuo0+MSaqvuICN?nuPsz#zpiEInW4lT#R^Zu+$Jn836N3IqY{pDr4}** z>VM)CZW_ZH_)fa}3Otu4@j@xN-}cAWd+}BCL(a+fPE*{Z6#Bh#y5jJnAg{>cU5mjG z4}L+XaitV{D;QiLl^Gorn-3Mt8G>`%Jz0_pKG_b5;YuN*=BwIr8PO-r@Z+DYiz=_# zHGu;YhNqiRJgn>6IRI2yym?A^2?XT7nz!@&PVuy zKbZ-mP9grDq3lw@4?kAMtWZw1J&d{?zpjVv!`Cz!BJ%D=Ma2n0_VB+{!H!pAm|K3F$$FIT6j z$(@M#f`)!lEurUgyBf*(K*wj_UsC?Dx!<;>7a*bd9UMWUR^%VM$BqVOI zNG|%_*w47N$X27Bv8H=3=EcAoWe6~fzVXkrSynEkVOEl#jGTC8{JEFY4P4!-;BL)B zvP53W69$~Aaaa8_<#G*7%`zwNM!m#fcXiTQ75kcsMY(vwXRF=rCfdpGIM}ug{VSlN z&!0b$3J$friN$RyjO7_#l`2`Ittshs9=#uHHhn*H>c!IINmCHCiUh!FZC5mAYK=fx zC~)A)!H%c;8|WQm=GG4`WA9RTC@UcvAF(lI$wkqRK1leA(UEoMx!NjL*f1!7e$5FGLAMHj*q)G+5^k!-1Q4<#=c7df9f(ouV2aDk$$4n8X zZt4!!7+Vu?8pa%@)@r=)Eqg&NFgGa#NsmEZ^1l-p>?OQ{1!YISOwr)j5e~CdxkWJ{?Ta+d zSndv-dlW>Z-4|+qa6Gb`^;(vvW@p6`68~Wwv$$N?$nC3BaW8dbiIbIH3neq>c36LP zurm|_2Qb2OK5sxjXM3MAm50F}6cPq&Hc6eS(vtck7j%@5$fqVz)h>efuecZSCu|=l zokp1M#*t3VTWKA69@nZG?@!~FZl($-=lQJMj;t7B*QgNRf5PMRW8|jwZ4sO9GH9DJ z2X8l`syirK?m_b@iUm%-_UM(!5vnjz^ln^nDONok$jOovxe+o*u9Kro!2neqMSKIk z7denU&AoMtDj$fas=b~w40}JOqtZ&}L!0Jr&wP9A3J_cFqAJ3+af!u(7Rp1ESn0}d zo^+$Qj|2=q#NUkbd@r$;t)wc5?f$VVG1*rC!C|%)%vCjH=Ourcuk*R5kI<@%sx_RZ zL6f`nyF&sJXEK$f zh+*Yv3~qVdmV~)YUGD&Q0kf-lI#%~HcI?bX`Xhsno|%SmC-B>_6n9_=7oZo&bJFqA z)?dSMwsEF&x8jZ3jlK1p8B>H)kpxlJ{w^=@1CbvfXNb*15Z_pRp2)7_<78%*2kh|l z_Up$GVtmO6qlx6&&c$P8GWZ6(30beq*?YLdM`>Q^8`d4oL`6nM);Mc4`Cd2$`R%>; zQr#Pr+Xv7wbb5imkPXqXf2>DiAWdYX@mTsITzNzHgrM3``|X$o!zlRek)8`36PK8tgrzjZI>In|p!# z8EEzaTfI3YvG_aCD27i%Ea&typ8xkJ0GtB+MF4;tZ-3tZ9e`-Shb|SnEQ7yO-}7VO zh_5bA2Hk$gIr;FDoIH(N`wg{W>{-GTn`{I^C7K}+^BnV1;}*`q8Art+90tZ`74!gt zE1`Tr}PFrQ%iKzZm>{L(YveTok2uaS~KizRH@0Ph*ZgS>U{1enM|wB?|31R;TYB2 zVBzpr+b589qJeV0CD!6+ZztVFdE9PV05%_-P`=%^i%-EASo-zAPpIA|Nu&KsRHpTl!-^`b>1Lb}7?D+n8VCx1N$vA9@T;TG3kcHS%Q!{T(ckbaKSr3(cvP2d%XbDrx+SQDq6vtKIA+UEMbWTnmU82Wyb6s*bCXLA9sn zpzlf_Z*jO7F|U~(9Tu%p0(a3QB+;e4yYgCMIp(tHnN;vdxsz0dx0|zRnZ-)?U3q6!I)g73^2b6 z)~}C&jl4L-m^K9lfo%oNwYZOsSE45z6yi>l%LG&NYs5?U+N={@64spZ6MKDc3}fLV zlaDZk4h}BPQoE(MKezBoKPZi9y6_a@3MJIu!u=<>#8Vb3g z09D0z2bZa$*iSwn+n?3vwTw=5o{pLax_jIAK`gBouou0X-ESu-mO2H|r6e^z@H?&s zn*>dVw3pa0!Qh~EQR3s&O`~g^;uP&cbTjtAnE%B`ccm2XYdUl1cC>@8j@2y3Q%_0` zj-N+AQ1~&)Uy#~C<&$|V-=LLU-`qNW|IAuw%Am=9<>UTE_imt23gxcvsl>bi1|0++ zG_k)R;oMMIJ&t5asQuF)oKNS}NqkK2Z9KWy7e37K)YFTq^_CI#)HM5^d+lE(m7Tqd zcO9<*Mn7{Flm+`=n|CV-jPUw2>EqPt8M;?*nf2wbUYPivMAfv7hEDZ@=^gZ=UR0Nt zjIch^@I)r-Nnu^19NX{!s7%KN_lAMgZtrVz)?k3Fcfn)T$f4H0P}?t$cbd{;CmLUw zCY|?@Ad}k314iIXO1L=~(phPBnP&RFvkTF3X)-o+IjhR^X(bGQSHee6%QPmQ%MzwD zky$xXcX7Wx%kqj3k$L6^5oN3n_v=K}7r_tvzJfuaY0O}e$CwToFW$q}1jwZ;$)saPGurL!GnU?YnXYx%hplP@ zHl8K5utT`;>Fdp++|VyDewM1b^^|?{#-Cr2LG{ePc|CLZ;QTDU^lEI*cx!A|QgNWh zvuXaa^~-sTrOMI!r)GxCh=o<&L$hnX$GUx^np7zb*+uXu5twq08w)XvVoCD5 ze6J_hXzW^M-I;oId;Re2RUk_FN|ThVrMMhB*iZ4ROC9LwUe|4hmHGNLO0!-z)$BGtF`#D6Gaq`jn3$pW47&wb6Pbpi{-`|KQ-~e z!RV0p^U0Z5FGl}kG*wRz%2eK!&XYfWQ;H2re=^+N_&fN@14ydAtH1SkxF$@>2Qb0^ z!^ea#=aWZ7L`1gA=IB{J#jpAzY~c}Un&2!2JuS^1{SKFr!>i{_e_Ji^qZdFR i0sXUtgnvpnZ_(M0UNI>+B&XZ~f273a#R^3Y-uy3AsO+== literal 0 HcmV?d00001 diff --git a/examples/static/images/single_model_ocl2.png b/examples/static/images/single_model_ocl2.png new file mode 100644 index 0000000000000000000000000000000000000000..c5e84c68f45123c4cdb377314482cfcfabf8501f GIT binary patch literal 58563 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≥6hZF0}fEQl`tmrW0H0ek~fv%SEsOy_Zp_SCPZ- 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 n