diff --git a/CHANGELOG.md b/CHANGELOG.md index 606f82ac4c..70d66860f0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,7 +4,33 @@ Darts is still in an early development phase and we cannot always guarantee back ## [Unreleased](https://github.com/unit8co/darts/tree/develop) -[Full Changelog](https://github.com/unit8co/darts/compare/0.4.0...develop) +[Full Changelog](https://github.com/unit8co/darts/compare/0.5.0...develop) + +## [0.5.0](https://github.com/unit8co/darts/tree/0.5.0) (2020-11-09) + +[Full Changelog](https://github.com/unit8co/darts/compare/0.4.0...0.5.0) +### For users of the library: +**Added:** +- Ensemble models, a new kind of `ForecastingModel` which allows to ensemble multiple models to make predictions: + - `EnsembleModel` is the abstract base class for ensemble models. Classes deriving from `EnsembleModel` must implement the `ensemble()` method, which takes in a `List[TimeSeries]` of predictions from the constituent models, and returns the ensembled prediction (a single `TimeSeries` object) + - `RegressionEnsembleModel`, a concrete implementation of `EnsembleModel `which allows to specify any regression model (providing `fit()` and `predict()` methods) to use to ensemble the constituent models' predictions. +- A new method to `TorchForecastingModel`: `untrained_model()` returns the model as it was initally created, allowing to retrain the exact same model from scratch. Works both when specifying a `random_state` or not. +- New `ForecastingModel.backtest()` and `RegressionModel.backtest()` functions which by default compute a single error score from the historical forecasts the model would have produced. + - A new `reduction` parameter allows to specify whether to compute the mean/median/… of errors or (when `reduction` is set to `None`) to return a list of historical errors. + - The previous `backtest()` functionality still exists but has been renamed `historical_forecasts()` +- Added a new `last_points_only` parameter to `historical_forecasts()`, `backtest()` and `gridsearch()` + +**Changed:** +- 🔴 Renamed `backtest()` into `historical_forecasts()` +- `fill_missing_values()` and `MissingValuesFiller` used to remove the variable names when used with `fill='auto'` – not anymore. +- Modified the default plotting style to increase contrast and make plots lighter. + +**Fixed:** +- Small mistake in the `NaiveDrift` model implementation which caused the first predicted value to repeat the last training value. + +### For developers of the library: +**Changed:** +- `@random_method` decorator now always assigns a `_random_instance` field to decorated methods (seeded with a random seed). This doesn't change the observed behavior, but allows to deterministically "reset" `TorchForecastingModel` by saving `_random_instance` along with the other parameters of the model upon creation. ## [0.4.0](https://github.com/unit8co/darts/tree/0.4.0) (2020-10-28) @@ -61,7 +87,7 @@ Darts is still in an early development phase and we cannot always guarantee back ``` ### For developers of the library -### Changed +**Changed:** - GitHub release workflow is now triggered manually from the GitHub "Actions" tab in the repository, providing a `#major`, `#minor`, or `#patch` argument. [\#211](https://github.com/unit8co/darts/pull/211) - (A limited number of) notebook examples are now run as part of the GitHub develop workflow. diff --git a/darts/__init__.py b/darts/__init__.py index b436252282..5b2061a7e6 100644 --- a/darts/__init__.py +++ b/darts/__init__.py @@ -33,22 +33,27 @@ class ModelMode(Enum): colors = cycler(color=['black', '003DFD', 'b512b8', '11a9ba', '0d780f', 'f77f07', 'ba0f0f']) u8plots_mplstyle = { - 'font.family' : 'Arial', - 'figure.facecolor' : '#f0f0f0', - 'axes.facecolor' : '#f0f0f0', + 'font.family' : 'sans serif', + 'axes.edgecolor' : 'black', + 'axes.grid' : True, + 'axes.labelcolor': '#333333', + 'axes.labelweight' : 600, + 'axes.linewidth' : 1, 'axes.prop_cycle' : colors, - 'lines.linewidth' : 1.3, 'axes.spines.top' : False, 'axes.spines.right' : False, 'axes.spines.bottom' : False, 'axes.spines.left' : False, - 'axes.linewidth' : 1, - 'axes.edgecolor' : 'black', + 'grid.color' : '#dedede', + 'legend.frameon' : False, + 'lines.linewidth' : 1.3, 'xtick.bottom' : False, - 'ytick.left' : False, - 'axes.grid' : True, - 'grid.color' : '#d0d0d0', - 'grid.alpha' : 0.5, - 'legend.frameon' : False} + 'xtick.color': '#333333', + 'xtick.labelsize':'small', + 'ytick.color': '#333333', + 'ytick.labelsize':'small', + 'xtick.bottom' : False, +} + mpl.rcParams.update(u8plots_mplstyle) diff --git a/darts/metrics/__init__.py b/darts/metrics/__init__.py index 167215072a..1bf69a10ab 100644 --- a/darts/metrics/__init__.py +++ b/darts/metrics/__init__.py @@ -3,4 +3,4 @@ ------- """ -from .metrics import mae, mse, rmse, rmsle, mape, mase, ope, marre, r2_score, coefficient_of_variation +from .metrics import mae, mse, rmse, rmsle, mape, smape, mase, ope, marre, r2_score, coefficient_of_variation diff --git a/darts/models/__init__.py b/darts/models/__init__.py index dd7a26396b..0579b0d583 100644 --- a/darts/models/__init__.py +++ b/darts/models/__init__.py @@ -35,3 +35,8 @@ # Regression from .standard_regression_model import StandardRegressionModel + +# Ensembling +from .ensemble_model import EnsembleModel +from .baselines import NaiveEnsembleModel +from .regression_ensemble_model import RegressionEnsembleModel diff --git a/darts/models/baselines.py b/darts/models/baselines.py index 422ac796a9..a1ea04c6f7 100644 --- a/darts/models/baselines.py +++ b/darts/models/baselines.py @@ -5,9 +5,11 @@ A collection of simple benchmark models. """ +from typing import List, Optional import numpy as np -from .forecasting_model import UnivariateForecastingModel +from .forecasting_model import ForecastingModel, UnivariateForecastingModel +from .ensemble_model import EnsembleModel from ..timeseries import TimeSeries from ..logging import raise_if_not, get_logger @@ -95,5 +97,28 @@ def predict(self, n: int): first, last = self.training_series.first_value(), self.training_series.last_value() slope = (last - first) / (len(self.training_series) - 1) last_value = last + slope * n - forecast = np.linspace(last, last_value, num=n) + forecast = np.linspace(last, last_value, num=n + 1)[1:] return self._build_forecast_series(forecast) + + +class NaiveEnsembleModel(EnsembleModel): + + def __init__(self, models: List[ForecastingModel]): + """ Naive combination model + + Naive implementation of `EnsembleModel` + Returns the average of all predictions of the constituent models + """ + super().__init__(models) + + def fit(self, training_series: TimeSeries, target_series: Optional[TimeSeries] = None) -> None: + super().fit(training_series, target_series) + + for model in self.models: + if isinstance(model, UnivariateForecastingModel): + model.fit(self.training_series) + else: + model.fit(self.training_series, self.target_series) + + def ensemble(self, predictions: List[TimeSeries]): + return sum(predictions) / len(self.models) diff --git a/darts/models/ensemble_model.py b/darts/models/ensemble_model.py new file mode 100644 index 0000000000..6759cc19b7 --- /dev/null +++ b/darts/models/ensemble_model.py @@ -0,0 +1,73 @@ +""" +Ensemble model +-------------- +""" + +from abc import abstractmethod +from typing import List, Optional + +from ..timeseries import TimeSeries +from ..logging import get_logger, raise_if_not +from ..models.forecasting_model import ForecastingModel + +logger = get_logger(__name__) + + +class EnsembleModel(ForecastingModel): + """ + Abstract base class for ensemble models. + Ensemble models take in a list of forecasting models and ensemble their predictions + to make a single one according to the rule defined by their `ensemble()` method. + + Parameters + ---------- + models + List of forecasting models whose predictions to ensemble + """ + def __init__(self, models: List[ForecastingModel]): + raise_if_not(isinstance(models, list) and models, + "Cannot instantiate EnsembleModel with an empty list of models", + logger) + raise_if_not(all(isinstance(model, ForecastingModel) for model in models), + "All models must be instances of darts.models.ForecastingModel", + logger) + super().__init__() + self.models = models + + def fit(self, training_series: TimeSeries, target_series: Optional[TimeSeries] = None) -> None: + """ + Fits the model on the provided series. + Note that `EnsembleModel.fit()` does NOT call `fit()` on each of its constituent forecasting models. + It is left to classes inheriting from EnsembleModel to do so appropriately when overriding `fit()` + """ + super().fit(training_series, target_series) + + def predict(self, n: int) -> TimeSeries: + super().predict(n) + + predictions = [] + for model in self.models: + predictions.append(model.predict(n)) + + return self.ensemble(predictions) + + @abstractmethod + def ensemble(self, predictions: List[TimeSeries]) -> TimeSeries: + """ + Defines how to ensemble the individual models' predictions to produce a single prediction. + + Parameters + ---------- + predictions + Individual predictions to ensemble + + Returns + ------- + TimeSeries + The predicted `TimeSeries` obtained by ensembling the individual predictions + """ + pass + + @property + def min_train_series_length(self) -> int: + return max(model.min_train_series_length for model in self.models) diff --git a/darts/models/forecasting_model.py b/darts/models/forecasting_model.py index d9544f2854..1ba39e8f3f 100644 --- a/darts/models/forecasting_model.py +++ b/darts/models/forecasting_model.py @@ -9,7 +9,7 @@ where :math:`y_t` represents the time series' value(s) at time :math:`t`. """ -from typing import Optional, Tuple, Union, Any, Callable +from typing import Optional, Union, Any, Callable, List from types import SimpleNamespace from itertools import product from abc import ABC, abstractmethod @@ -18,7 +18,12 @@ from ..timeseries import TimeSeries from ..logging import get_logger, raise_log, raise_if_not -from ..utils import _build_tqdm_iterator, _with_sanity_checks, _get_timestamp_at_point, _backtest_general_checks +from ..utils import ( + _build_tqdm_iterator, + _with_sanity_checks, + get_timestamp_at_point, + _historical_forecasts_general_checks +) from .. import metrics logger = get_logger(__name__) @@ -46,17 +51,28 @@ def __init__(self): self._fit_called = False @abstractmethod - def fit(self) -> None: + def fit(self, training_series: TimeSeries, target_series: Optional[TimeSeries] = None) -> None: """ Fits/trains the model on the provided series Implements behavior that should happen when calling the `fit` method of every forcasting model regardless of wether they are univariate or multivariate. """ + self.training_series = training_series + + if target_series is None: + target_series = training_series + self.target_series = target_series + + raise_if_not(all(training_series.time_index() == target_series.time_index()), + "training and target series must have same time indices.", + logger) + for series in (self.training_series, self.target_series): if series is not None: raise_if_not(len(series) >= self.min_train_series_length, "Train series only contains {} elements but {} model requires at least {} entries" - .format(len(series), str(self), self.min_train_series_length)) + .format(len(series), str(self), self.min_train_series_length), + logger) self._fit_called = True @abstractmethod @@ -105,15 +121,15 @@ def _build_forecast_series(self, return TimeSeries.from_times_and_values(time_index, points_preds, freq=self.training_series.freq()) - def _backtest_sanity_checks(self, *args: Any, **kwargs: Any) -> None: - """Sanity checks for the backtest function + def _historical_forecasts_sanity_checks(self, *args: Any, **kwargs: Any) -> None: + """Sanity checks for the historical_forecasts function Parameters ---------- args - The args parameter(s) provided to the backtest function. + The args parameter(s) provided to the historical_forecasts function. kwargs - The kwargs paramter(s) provided to the backtest function. + The kwargs paramter(s) provided to the historical_forecasts function. Raises ------ @@ -125,40 +141,41 @@ def _backtest_sanity_checks(self, *args: Any, **kwargs: Any) -> None: n = SimpleNamespace(**kwargs) # check target and training series - if n.target_series is None: + target_series = n.target_series + if target_series is None: target_series = training_series - else: - target_series = n.target_series raise_if_not(all(training_series.time_index() == target_series.time_index()), "the target and training series" " must have the same time indices.") - _backtest_general_checks(training_series, kwargs) - - def _backtest_model_specific_sanity_checks(self, *args: Any, **kwargs: Any) -> None: - """Method to be overriden in subclass for model specific sanity checks""" - pass - - @_with_sanity_checks("_backtest_sanity_checks", "_backtest_model_specific_sanity_checks") - def backtest(self, - training_series: TimeSeries, - target_series: Optional[TimeSeries] = None, - start: Union[pd.Timestamp, float, int] = 0.7, - forecast_horizon: int = 1, - stride: int = 1, - retrain: bool = True, - trim_to_series: bool = True, - verbose: bool = False, - use_full_output_length: Optional[bool] = None) -> TimeSeries: - """ Retrain and forecast values pointwise with an expanding training window over `series`. - - To this end, it repeatedly builds a training set from the beginning of `series`. It trains the current model on - the training set, emits a (point) prediction for a fixed forecast horizon, and then moves the end of the - training set forward by `stride` time steps. The resulting predictions are then returned. - - Unless `retrain` is set to False, this always re-trains the models on the entire available history, - corresponding an expending window strategy. + _historical_forecasts_general_checks(training_series, kwargs) + @_with_sanity_checks("_historical_forecasts_sanity_checks") + def historical_forecasts(self, + training_series: TimeSeries, + target_series: Optional[TimeSeries] = None, + start: Union[pd.Timestamp, float, int] = 0.5, + forecast_horizon: int = 1, + stride: int = 1, + retrain: bool = True, + overlap_end: bool = False, + last_points_only: bool = True, + verbose: bool = False, + use_full_output_length: Optional[bool] = None) -> Union[TimeSeries, List[TimeSeries]]: + + """ Computes the historical forecasts the model would have produced with an expanding training window + and (by default) returns a time series created from the last point of each of these individual forecasts + + To this end, it repeatedly builds a training set from the beginning of `training_series`. It trains the + current model on the training set, emits a forecast of length equal to forecast_horizon, and then moves + the end of the training set forward by `stride` time steps. + + By default, this method will return a single time series made up of the last point of each + historical forecast. This time series will thus have a frequency of training_series.freq() * stride + If `last_points_only` is set to False, it will instead return a list of the historical forecasts. + + By default, this method always re-trains the models on the entire available history, + corresponding to an expanding window strategy. If `retrain` is set to False (useful for models with many parameter such as `TorchForecastingModel` instances like `RNNModel` and `TCNModel`), the model will only be trained on the initial training window (up to `start` time stamp), and only if it has not been trained before. Then, at every iteration, the @@ -167,16 +184,16 @@ def backtest(self, Parameters ---------- training_series - The training time series on which to backtest + The training time series to use to compute the historical forecasts target_series - The target time series on which to backtest. This parameter is only relevant for + The target time series to use to compute the historical forecasts. This parameter is only relevant for `MultivariateForecastingModel` instances. It allows for training on one `training_series` and predicting another `target_series`. In many multivariate forecasting problems, the `target_series` would constitute a subset of the components of the `training_series`. However, any combination of univariate and multivariate series is allowed here, as long as the indices all match up. start - The first prediction time, at which a prediction is computed for a future time. + The first point at which a prediction is computed for a future time. This parameter supports 3 different data types: `float`, `int` and `pandas.Timestamp`. In the case of `float`, the parameter will be treated as the proportion of the time series that should lie before the first prediction point. @@ -185,9 +202,9 @@ def backtest(self, In case of `pandas.Timestamp`, this time stamp will be used to determine the first prediction time directly. forecast_horizon - The forecast horizon for the point prediction + The forecast horizon for the point predictions stride - The number of time steps (the unit being the frequency of `series`) between two consecutive predictions. + The number of time steps between two consecutive predictions. retrain Whether to retrain the model for every prediction or not. Currently only `TorchForecastingModel` instances such as `RNNModel` and `TCNModel` support setting `retrain` to `False`. @@ -195,16 +212,20 @@ def backtest(self, Optionally, if the model is an instance of `TorchForecastingModel`, this argument will be passed along as argument to the `predict` method of the model. Otherwise, if this value is set and the model is not an instance of `TorchForecastingModel`, this will cause an error. - trim_to_series - Whether the predicted series has the end trimmed to match the end of the main series + overlap_end + Whether the returned forecasts can go beyond the series' end or not + last_points_only + Whether to retain only the last point of each historical forecast. + If set to True, the method returns a single `TimeSeries` of the point forecasts. + Otherwise returns a list of historical `TimeSeries` forecasts. verbose Whether to print progress Returns ------- - TimeSeries - A time series containing the forecast values for `target_series`, when successively applying the specified - model with the specified forecast horizon. + TimeSeries or List[TimeSeries] + By default, a single TimeSeries instance created from the last point of each individual forecast. + If `last_points_only` is set to False, a list of the historical forecasts. """ # handle case where target_series not specified if target_series is None: @@ -216,48 +237,168 @@ def backtest(self, predict_kwargs['use_full_output_length'] = use_full_output_length # construct fit function (used to ignore target series for univariate models) - if isinstance(self, MultivariateForecastingModel): - fit_function = self.fit - else: + if isinstance(self, UnivariateForecastingModel): fit_function = lambda train, target, **kwargs: self.fit(train, **kwargs) # noqa: E731 + else: + fit_function = self.fit # prepare the start parameter -> pd.Timestamp - start = _get_timestamp_at_point(start, training_series) + start = get_timestamp_at_point(start, training_series) # build the prediction times in advance (to be able to use tqdm) - if trim_to_series: - last_pred_time = training_series.time_index()[-forecast_horizon - stride] + if not overlap_end: + last_valid_pred_time = training_series.time_index()[-1 - forecast_horizon] else: - last_pred_time = training_series.time_index()[-stride - 1] + last_valid_pred_time = training_series.time_index()[-2] pred_times = [start] - while pred_times[-1] <= last_pred_time: + while pred_times[-1] < last_valid_pred_time: + # compute the next prediction time and add it to pred times pred_times.append(pred_times[-1] + training_series.freq() * stride) - # iterate and predict pointwise - values = [] - times = [] + # the last prediction time computed might have overshot last_valid_pred_time + if pred_times[-1] > last_valid_pred_time: + pred_times.pop(-1) iterator = _build_tqdm_iterator(pred_times, verbose) + # iterate and forecast + + # Either store the whole forecasts or only the last points of each forecast, depending on last_points_only + forecasts = [] + + last_points_times = [] + last_points_values = [] + if not retrain and not self._fit_called: fit_function(training_series.drop_after(start), target_series.drop_after(start), verbose=verbose) for pred_time in iterator: - train = training_series.drop_after(pred_time) # build the training series - target = target_series.drop_after(pred_time) # build the target series + train = training_series.drop_after(pred_time) # build the training series + target = target_series.drop_after(pred_time) # build the target series + if (retrain): fit_function(train, target) - pred = self.predict(forecast_horizon, **predict_kwargs) + forecast = self.predict(forecast_horizon, **predict_kwargs) else: - pred = self.predict(forecast_horizon, input_series=train, **predict_kwargs) - values.append(pred.values()[-1]) # store the N-th point - times.append(pred.end_time()) # store the N-th timestamp + forecast = self.predict(forecast_horizon, input_series=train, **predict_kwargs) - forecast = TimeSeries.from_times_and_values(pd.DatetimeIndex(times), np.array(values), + if last_points_only: + last_points_values.append(forecast.values()[-1]) + last_points_times.append(forecast.end_time()) + else: + forecasts.append(forecast) + + if last_points_only: + return TimeSeries.from_times_and_values(pd.DatetimeIndex(last_points_times), + np.array(last_points_values), freq=training_series.freq() * stride) + return forecasts + + def backtest(self, + training_series: TimeSeries, + target_series: Optional[TimeSeries] = None, + start: Union[pd.Timestamp, float, int] = 0.5, + forecast_horizon: int = 1, + stride: int = 1, + retrain: bool = True, + overlap_end: bool = False, + last_points_only: bool = False, + metric: Callable[[TimeSeries, TimeSeries], float] = metrics.mape, + reduction: Union[Callable[[np.ndarray], float], None] = np.mean, + use_full_output_length: Optional[bool] = None, + verbose: bool = False) -> Union[float, List[float]]: + + """ Computes an error score between the historical forecasts the model would have produced + with an expanding training window over `training_series` and the actual series. + + To this end, it repeatedly builds a training set from the beginning of `series`. It trains the current model on + the training set, emits a forecast of length equal to forecast_horizon, and then moves the end of the + training set forward by `stride` time steps. + + By default, this method will use each historical forecast (whole) to compute error scores. + If `last_points_only` is set to True, it will use only the last point of each historical forecast. + + By default, this method always re-trains the models on the entire available history, + corresponding to an expanding window strategy. + If `retrain` is set to False (useful for models with many parameter such as `TorchForecastingModel` instances + like `RNNModel` and `TCNModel`), the model will only be trained on the initial training window + (up to `start` time stamp), and only if it has not been trained before. Then, at every iteration, the + newly expanded input sequence will be fed to the model to produce the new output. + + Parameters + ---------- + training_series + The training time series to use to compute the historical forecasts + target_series + The target time series to use to compute the historical forecasts. This parameter is only relevant for + `MultivariateForecastingModel` instances. It allows for training on one `training_series` + and predicting another `target_series`. In many multivariate forecasting problems, the + `target_series` would constitute a subset of the components of the `training_series`. + However, any combination of univariate and multivariate series is allowed here, as long + as the indices all match up. + start + The first prediction time, at which a prediction is computed for a future time. + This parameter supports 3 different data types: `float`, `int` and `pandas.Timestamp`. + In the case of `float`, the parameter will be treated as the proportion of the time series + that should lie before the first prediction point. + In the case of `int`, the parameter will be treated as an integer index to the time index of + `training_series` that will be used as first prediction time. + In case of `pandas.Timestamp`, this time stamp will be used to determine the first prediction time + directly. + forecast_horizon + The forecast horizon for the point prediction + stride + The number of time steps (the unit being the frequency of `series`) between two consecutive predictions. + retrain + Whether to retrain the model for every prediction or not. Currently only `TorchForecastingModel` + instances such as `RNNModel` and `TCNModel` support setting `retrain` to `False`. + overlap_end + Whether the returned forecasts can go beyond the series' end or not + last_points_only + Whether to use the whole historical forecasts or only the last point of each forecast to compute the error + metric + A function that takes two TimeSeries instances as inputs and returns a float error value. + reduction + A function used to combine the individual error scores obtained when `last_points_only` is set to False. + If explicitely set to `None`, the method will return a list of the individual error scores instead. + Set to np.mean by default. + use_full_output_length + Optionally, if the model is an instance of `TorchForecastingModel`, this argument will be passed along + as argument to the `predict` method of the model. Otherwise, if this value is set and the model is not an + instance of `TorchForecastingModel`, this will cause an error. + verbose + Whether to print progress + + Returns + ------- + float or List[float] + The error score, or the list of individual error scores if `reduction` is `None` + """ + forecasts = self.historical_forecasts(training_series, + target_series, + start, + forecast_horizon, + stride, + retrain, + overlap_end, + last_points_only, + verbose, + use_full_output_length) + if target_series is None: + target_series = training_series + + if last_points_only: + return metric(target_series, forecasts) - return forecast + errors = [] + for forecast in forecasts: + errors.append(metric(target_series, forecast)) + + if reduction is None: + return errors + + return reduction(errors) @classmethod def gridsearch(model_class, @@ -266,10 +407,12 @@ def gridsearch(model_class, target_series: Optional[TimeSeries] = None, forecast_horizon: Optional[int] = None, start: Union[pd.Timestamp, float, int] = 0.5, + last_points_only: bool = False, use_full_output_length: Optional[bool] = None, val_target_series: Optional[TimeSeries] = None, use_fitted_values: bool = False, metric: Callable[[TimeSeries, TimeSeries], float] = metrics.mape, + reduction: Callable[[np.ndarray], float] = np.mean, verbose=False) -> TimeSeries: """ A function for finding the best hyperparameters. @@ -320,6 +463,8 @@ def gridsearch(model_class, of `training_series` from which predictions will be made to evaluate the model. For a detailed description of how the different data types are interpreted, please see the documentation for `ForecastingModel.backtest`. + last_points_only + Whether to use the whole forecasts or only the last point of each forecast to compute the error use_full_output_length This should only be set if `model_class` is equal to `TorchForecastingModel`. This argument will be passed along to the predict method of `TorchForecastingModel`. @@ -328,9 +473,9 @@ def gridsearch(model_class, use_fitted_values If `True`, uses the comparison with the fitted values. Raises an error if `fitted_values` is not an attribute of `model_class`. - metric: + metric A function that takes two TimeSeries instances as inputs and returns a float error value. - verbose: + verbose Whether to print progress. Returns @@ -342,11 +487,12 @@ def gridsearch(model_class, "Please pass exactly one of the arguments 'forecast_horizon', " "'val_target_series' or 'use_fitted_values'.", logger) - # check target and training series if target_series is None: target_series = training_series - raise_if_not(all(training_series.time_index() == target_series.time_index()), "the target and training series" - " must have the same time indices.") + # check target and training series + raise_if_not(all(training_series.time_index() == target_series.time_index()), + "the target and training series must have the same time indices.", + logger) # construct predict kwargs dictionary predict_kwargs = {} @@ -354,12 +500,14 @@ def gridsearch(model_class, predict_kwargs['use_full_output_length'] = use_full_output_length if use_fitted_values: - raise_if_not(hasattr(model_class(), "fitted_values"), "The model must have a fitted_values attribute" - " to compare with the train TimeSeries", logger) + raise_if_not(hasattr(model_class(), "fitted_values"), + "The model must have a fitted_values attribute to compare with the train TimeSeries", + logger) elif val_target_series is not None: - raise_if_not(training_series.width == val_target_series.width, "Training and validation series require the" - " same number of components.", logger) + raise_if_not(training_series.width == val_target_series.width, + "Training and validation series require the same number of components.", + logger) min_error = float('inf') best_param_combination = {} @@ -377,9 +525,14 @@ def gridsearch(model_class, fitted_values = TimeSeries.from_times_and_values(training_series.time_index(), model.fitted_values) error = metric(fitted_values, target_series) elif val_target_series is None: # expanding window mode - backtest_forecast = model.backtest(training_series, target_series, start, - forecast_horizon, use_full_output_length=use_full_output_length) - error = metric(backtest_forecast, target_series) + error = model.backtest(training_series, + target_series, + start, + forecast_horizon, + metric=metric, + reduction=reduction, + last_points_only=last_points_only, + use_full_output_length=use_full_output_length) else: # split mode if isinstance(model, MultivariateForecastingModel): model.fit(training_series, target_series) @@ -428,7 +581,14 @@ def residuals(self, first_index = series.time_index()[self.min_train_series_length] # compute fitted values - p = self.backtest(series, None, first_index, forecast_horizon, 1, True, verbose=verbose) + p = self.historical_forecasts(series, + None, + first_index, + forecast_horizon, + 1, + True, + last_points_only=True, + verbose=verbose) # compute residuals series_trimmed = series.slice_intersect(p) @@ -451,27 +611,12 @@ def fit(self, series: TimeSeries) -> None: A **univariate** timeseries on which to fit the model. """ series._assert_univariate() - self.training_series = series - self.target_series = series - super().fit() + super().fit(series) class MultivariateForecastingModel(ForecastingModel): """ The base class for multivariate forecasting models. """ - def _make_fitable_series(self, - training_series: TimeSeries, - target_series: Optional[TimeSeries] = None) -> Tuple[TimeSeries, TimeSeries]: - """Perform checks and returns ready to be used training and target series""" - if target_series is None: - target_series = training_series - - # general checks on training / target series - raise_if_not(all(training_series.time_index() == target_series.time_index()), "training and target " - "timeseries must have same time indices.") - - return training_series, target_series - @abstractmethod def fit(self, training_series: TimeSeries, target_series: Optional[TimeSeries] = None) -> None: """ Fits/trains the multivariate model on the provided series with selected target components. @@ -483,8 +628,4 @@ def fit(self, training_series: TimeSeries, target_series: Optional[TimeSeries] = target_series The target values used as dependent variables when training the model """ - training_series, target_series = self._make_fitable_series(training_series, target_series) - - self.training_series = training_series - self.target_series = target_series - super().fit() + super().fit(training_series, target_series) diff --git a/darts/models/regression_ensemble_model.py b/darts/models/regression_ensemble_model.py new file mode 100644 index 0000000000..965bb05384 --- /dev/null +++ b/darts/models/regression_ensemble_model.py @@ -0,0 +1,98 @@ +""" +Regression ensemble model +------------------------- +""" +from sklearn.linear_model import LinearRegression +from typing import Optional, List + +from darts.timeseries import TimeSeries +from darts.models import EnsembleModel, StandardRegressionModel +from darts.models.forecasting_model import ForecastingModel, UnivariateForecastingModel +from darts.logging import get_logger, raise_if + +logger = get_logger(__name__) + + +class RegressionEnsembleModel(EnsembleModel): + def __init__(self, + forecasting_models: List[ForecastingModel], + regression_train_n_points: int, + regression_model=LinearRegression(n_jobs=-1, fit_intercept=False)): + """ + Class for ensemble models using a regression model for ensembling individual models' predictions + The provided regression model must implement fit() and predict() methods + (e.g. scikit-learn regression models) + + Parameters + ---------- + forecasting_models + List of forecasting models whose predictions to ensemble + regression_train_n_points + The number of points to use to train the regression model + regression_model + Any regression model with predict() and fit() methods (e.g. from scikit-learn) + Default: `sklearn.linear_model.LinearRegression(n_jobs=-1, fit_intercept=False)` + """ + super().__init__(forecasting_models) + + # wrap provided regression_model in a StandardRegressionModel (if not already the case) + if isinstance(regression_model, StandardRegressionModel): + # raise exception if train_n_points value is ambiguous + model_train_n_points = regression_model.train_n_points + raise_if(model_train_n_points is not None and regression_train_n_points != model_train_n_points, + "Provided StandardRegressionModel.train_n_points parameter doesn't match specified" + " regression_train_n_points parameter.", + logger) + + # if it was None, set regression_model.train_n_points to regression_train_n_points + regression_model.train_n_points = regression_train_n_points + else: + regression_model = StandardRegressionModel(regression_train_n_points, regression_model) + + self.regression_model = regression_model + + def fit(self, training_series: TimeSeries, target_series: Optional[TimeSeries] = None) -> None: + super().fit(training_series, target_series) + + # spare train_n_points points to serve as regression target + raise_if(len(self.training_series) <= self.regression_model.train_n_points, + "regression_train_n_points parameter too big (greater or equal" + " the number of points in training_series)", + logger) + forecast_training = self.training_series[:-self.regression_model.train_n_points] + forecast_target = self.target_series[:-self.regression_model.train_n_points] + + regression_target = self.target_series[-self.regression_model.train_n_points:] + + # fit the forecasting models + for model in self.models: + if isinstance(model, UnivariateForecastingModel): + model.fit(forecast_training) + else: + model.fit(forecast_training, forecast_target) + + # predict train_n_points points for each model + predictions = [] + for model in self.models: + predictions.append(model.predict(self.regression_model.train_n_points)) + + # train the regression model on the individual models' predictions + self.regression_model.fit(train_features=predictions, train_target=regression_target) + + # prepare the forecasting models for further predicting by fitting + # them with the entire data + + # Some models (incl. Neural-Network based models) may need to be 'reset' + # to allow being retrained from scratch + self.models = [model.untrained_model() if hasattr(model, 'untrained_model') else model + for model in self.models] + + # fit the forecasting models + for model in self.models: + if isinstance(model, UnivariateForecastingModel): + model.fit(self.training_series) + else: + model.fit(self.training_series, self.target_series) + + def ensemble(self, predictions: List[TimeSeries]) -> TimeSeries: + return self.regression_model.predict(predictions) diff --git a/darts/models/regression_model.py b/darts/models/regression_model.py index 03907e7daa..5d7df8d948 100644 --- a/darts/models/regression_model.py +++ b/darts/models/regression_model.py @@ -14,11 +14,17 @@ import pandas as pd from abc import ABC, abstractmethod -from typing import List, Iterable, Union, Any +from typing import List, Iterable, Union, Any, Callable from ..timeseries import TimeSeries from ..logging import raise_if_not, get_logger, raise_log -from ..utils import _build_tqdm_iterator, _with_sanity_checks, _get_timestamp_at_point, _backtest_general_checks +from ..utils import ( + _build_tqdm_iterator, + _with_sanity_checks, + get_timestamp_at_point, + _historical_forecasts_general_checks +) +from .. import metrics logger = get_logger(__name__) @@ -84,15 +90,15 @@ def predict(self, features: List[TimeSeries]) -> TimeSeries: 'The number and dimensionalities of all given features must correspond to those used for' ' training.', logger) - def _backtest_sanity_checks(self, *args: Any, **kwargs: Any) -> None: - """Sanity checks for the backtest function + def _historical_forecasts_sanity_checks(self, *args: Any, **kwargs: Any) -> None: + """Sanity checks for the historical_forecasts function Parameters ---------- args - The args parameter(s) provided to the backtest function. + The args parameter(s) provided to the historical_forecasts function. kwargs - The kwargs paramter(s) provided to the backtest function. + The kwargs paramter(s) provided to the historical_forecasts function. Raises ------ @@ -107,35 +113,32 @@ def _backtest_sanity_checks(self, *args: Any, **kwargs: Any) -> None: raise_if_not(all([s.has_same_time_as(target_series) for s in feature_series]), 'All provided time series must ' 'have the same time index', logger) - _backtest_general_checks(target_series, kwargs) - - def _backtest_model_specific_sanity_checks(self, *args: Any, **kwargs: Any) -> None: - """Method to be overriden in subclass for model specific sanity checks""" - pass - - @_with_sanity_checks("_backtest_sanity_checks", "_backtest_model_specific_sanity_checks") - def backtest(self, - feature_series: Iterable[TimeSeries], - target_series: TimeSeries, - start: Union[pd.Timestamp, float, int] = 0.7, - forecast_horizon: int = 1, - stride: int = 1, - trim_to_series: bool = True, - verbose=False) -> TimeSeries: - """ A function for backtesting `RegressionModel`'s. - - This function computes the time series of historical predictions - that would have been obtained, if the current model had been used to predict `target_series` - using the `feature_series`, with a certain time horizon. + _historical_forecasts_general_checks(target_series, kwargs) + + @_with_sanity_checks("_historical_forecasts_sanity_checks") + def historical_forecasts(self, + feature_series: Iterable[TimeSeries], + target_series: TimeSeries, + start: Union[pd.Timestamp, float, int] = 0.5, + forecast_horizon: int = 1, + stride: int = 1, + overlap_end: bool = False, + last_points_only: bool = True, + verbose: bool = False) -> Union[List[TimeSeries], TimeSeries]: + """ Computes the historical forecasts the model would have produced with an expanding training window + and (by default) returns a time series created from the last point of each of these individual forecasts To this end, it repeatedly builds a training set composed of both features and targets, from `feature_series` and `target_series`, respectively. - It trains the current model on the training set, emits a (point) prediction for a fixed - forecast horizon, and then moves the end of the training set forward by `stride` - time steps. The resulting predictions are then returned. + It trains the current model on the training set, emits a forecast of length equal to forecast_horizon, + and then moves the end of the training set forward by `stride` time steps. + + By default, this method will return a single time series made up of the last point of each + historical forecast. This time series will thus have a frequency of training_series.freq() * stride + If `last_points_only` is set to False, it will instead return a list of the historical forecasts. This always re-trains the models on the entire available history, - corresponding an expending window strategy. + corresponding an expanding window strategy. Parameters ---------- @@ -148,37 +151,47 @@ def backtest(self, forecast_horizon The forecast horizon for the point predictions stride - The number of time steps (the unit being the frequency of `series`) between two consecutive predictions. - trim_to_series - Whether the predicted series has the end trimmed to match the end of the main series + The number of time steps between two consecutive predictions. + overlap_end + Whether the returned forecasts can go beyond the series' end or not + last_points_only + Whether to retain only the last point of each historical forecast. + If set to True, the method returns a single `TimeSeries` of the point forecasts. + Otherwise returns a list of historical `TimeSeries` forecasts. verbose Whether to print progress Returns ------- - TimeSeries - A time series containing the forecast values when successively applying - the current model with the specified forecast horizon. + TimeSeries or List[TimeSeries] + By default, a single TimeSeries instance created from the last point of each individual forecast. + If `last_points_only` is set to False, a list of the historical forecasts """ - start = _get_timestamp_at_point(start, target_series) + start = get_timestamp_at_point(start, target_series) # build the prediction times in advance (to be able to use tqdm) - if trim_to_series: - last_pred_time = target_series.time_index()[-forecast_horizon - stride] + if not overlap_end: + last_valid_pred_time = target_series.time_index()[-1 - forecast_horizon] else: - last_pred_time = target_series.time_index()[-stride - 1] + last_valid_pred_time = target_series.time_index()[-2] - # build the prediction times in advance (to be able to use tqdm) pred_times = [start] - while pred_times[-1] <= last_pred_time: + while pred_times[-1] < last_valid_pred_time: + # compute the next prediction time and add it to pred times pred_times.append(pred_times[-1] + target_series.freq() * stride) - # what we'll return - values = [] - times = [] + # the last prediction time computed might have overshot last_valid_pred_time + if pred_times[-1] > last_valid_pred_time: + pred_times.pop(-1) iterator = _build_tqdm_iterator(pred_times, verbose) + # Either store the whole forecasts or only the last points of each forecast, depending on last_points_only + forecasts = [] + + last_points_times = [] + last_points_values = [] + for pred_time in iterator: # build train/val series train_features = [s.drop_after(pred_time) for s in feature_series] @@ -186,11 +199,96 @@ def backtest(self, val_features = [s.slice_n_points_after(pred_time, forecast_horizon) for s in feature_series] self.fit(train_features, train_target) - pred = self.predict(val_features) - values.append(pred.values()[-1]) # store the N-th point - times.append(pred.end_time()) # store the N-th timestamp + forecast = self.predict(val_features) + + if last_points_only: + last_points_values.append(forecast.values()[-1]) + last_points_times.append(forecast.end_time()) + else: + forecasts.append(forecast) + + if last_points_only: + return TimeSeries.from_times_and_values(pd.DatetimeIndex(last_points_times), + np.array(last_points_values), + freq=target_series.freq() * stride) - return TimeSeries.from_times_and_values(pd.DatetimeIndex(times), np.array(values)) + return forecasts + + def backtest(self, + feature_series: Iterable[TimeSeries], + target_series: TimeSeries, + start: Union[pd.Timestamp, float, int] = 0.5, + forecast_horizon: int = 1, + stride: int = 1, + overlap_end: bool = False, + last_points_only: bool = False, + metric: Callable[[TimeSeries, TimeSeries], float] = metrics.mape, + reduction: Union[Callable[[np.ndarray], float], None] = np.mean, + verbose: bool = False) -> Union[float, List[float]]: + """Computes an error score between the historical forecasts the model would have produced + with an expanding training window over `series` and the actual series. + + To this end, it repeatedly builds a training set composed of both features and targets, + from `feature_series` and `target_series`, respectively. + It trains the current model on the training set, emits a forecast of length equal to forecast_horizon, + and then moves the end of the training set forward by `stride` time steps. + + By default, this method will use each historical forecast (whole) to compute error scores. + If `last_points_only` is set to True, it will use only the last point of each historical forecast. + + This always re-trains the models on the entire available history, + corresponding an expanding window strategy. + + Parameters + ---------- + feature_series + A list of time series representing the features for the regression model (independent variables) + target_series + The univariate target time series for the regression model (dependent variable) + start + The first prediction time, at which a prediction is computed for a future time + forecast_horizon + The forecast horizon for the point predictions + stride + The number of time steps between two consecutive predictions. + overlap_end + Whether the returned forecasts can go beyond the series' end or not + last_points_only + Whether to keep the whole historical forecasts or only the last point of each forecast + metric + A function that takes two TimeSeries instances as inputs and returns a float error value. + reduction + A function used to combine the individual error scores obtained when `last_points_only` is set to False. + If explicitely set to `None`, the method will return a list of the individual error scores instead. + Set to np.mean by default. + verbose + Whether to print progress + + Returns + ------- + float or List[float] + The error score, or the list of individual error scores if `reduction` is `None` + """ + forecasts = self.historical_forecasts(feature_series, + target_series, + start, + forecast_horizon, + stride, + overlap_end, + last_points_only, + verbose) + + if last_points_only: + return metric(target_series, forecasts) + + errors = [] + for forecast in forecasts: + errors.append(metric(target_series, forecast)) + + if reduction is None: + return errors + + return reduction(errors) def residuals(self) -> TimeSeries: """ Computes the time series of residuals of this model on the training time series diff --git a/darts/models/standard_regression_model.py b/darts/models/standard_regression_model.py index d5a8fa4832..ed0ea80e42 100644 --- a/darts/models/standard_regression_model.py +++ b/darts/models/standard_regression_model.py @@ -5,7 +5,7 @@ from .regression_model import RegressionModel from ..timeseries import TimeSeries -from ..logging import get_logger, raise_log +from ..logging import get_logger, raise_log, raise_if from typing import List, Optional from warnings import warn import numpy as np @@ -21,7 +21,7 @@ def __init__(self, train_n_points: Optional[int] = None, model=LinearRegression(n_jobs=-1, fit_intercept=False)): """ - Simple wrapper for regression models implementing a fit() predict() functions models + Simple wrapper for regression models implementing a fit() predict() functions (e.g., scikit-learn regression). Parameters @@ -35,12 +35,16 @@ def __init__(self, Default: `sklearn.linear_model.LinearRegression(n_jobs=-1, fit_intercept=False)` """ - super(StandardRegressionModel, self).__init__() + super().__init__() if (not callable(getattr(model, "fit", None))): raise_log(Exception('Provided model object must have a fit() method', logger)) if (not callable(getattr(model, "predict", None))): raise_log(Exception('Provided model object must have a predict() method', logger)) + raise_if(train_n_points is not None and train_n_points < 1, + "train_n_points should be greater or equal 1 (or None)", + logger) + self.train_n_points = train_n_points self.model = model @@ -50,7 +54,7 @@ def _get_features_matrix_from_series(features: List[TimeSeries]): def fit(self, train_features: List[TimeSeries], - train_target: TimeSeries): + train_target: TimeSeries) -> None: if self.train_n_points is None: train_n_points = min([len(s) for s in train_features] + [len(train_target)]) @@ -72,7 +76,7 @@ def fit(self, self.model.fit(self._get_features_matrix_from_series(last_n_points_features), last_n_points_target.values()) - def predict(self, features: List[TimeSeries]): + def predict(self, features: List[TimeSeries]) -> TimeSeries: super().predict(features) y = self.model.predict(self._get_features_matrix_from_series(features)) return TimeSeries(pd.DataFrame(y, index=features[0].time_index()), self.train_target.freq()) diff --git a/darts/models/torch_forecasting_model.py b/darts/models/torch_forecasting_model.py index 0f4557636e..648c63513a 100644 --- a/darts/models/torch_forecasting_model.py +++ b/darts/models/torch_forecasting_model.py @@ -23,6 +23,7 @@ CHECKPOINTS_FOLDER = os.path.join('.darts', 'checkpoints') RUNS_FOLDER = os.path.join('.darts', 'runs') +UNTRAINED_MODELS_FOLDER = os.path.join('.darts', 'untrained_models') logger = get_logger(__name__) @@ -31,6 +32,10 @@ def _get_checkpoint_folder(work_dir, model_name): return os.path.join(work_dir, CHECKPOINTS_FOLDER, model_name) +def _get_untrained_models_folder(work_dir, model_name): + return os.path.join(work_dir, UNTRAINED_MODELS_FOLDER, model_name) + + def _get_runs_folder(work_dir, model_name): return os.path.join(work_dir, RUNS_FOLDER, model_name) @@ -137,7 +142,7 @@ def __getitem__(self, index): class TorchForecastingModel(MultivariateForecastingModel): - # TODO: add is_stochastic & reset methods + # TODO: add is_stochastic method # TODO: transparent support for multivariate time series def __init__(self, batch_size: int = 32, @@ -151,7 +156,7 @@ def __init__(self, lr_scheduler_cls: torch.optim.lr_scheduler._LRScheduler = None, lr_scheduler_kwargs: Optional[Dict] = None, loss_fn: nn.modules.loss._Loss = nn.MSELoss(), - model_name: str = "torch_model_run", # TODO uid + model_name: str = "torch_model_run", # TODO: uid work_dir: str = os.getcwd(), log_tensorboard: bool = False, nr_epochs_val_period: int = 10, @@ -205,7 +210,6 @@ def __init__(self, Optionally, a string indicating the torch device to use. (default: "cuda:0" if a GPU is available, otherwise "cpu") """ - super().__init__() raise_if_not(isinstance(self.model, nn.Module), 'Please make sure that self.model is set to a valid ' @@ -263,6 +267,8 @@ def _create_from_cls_and_kwargs(cls, kws): else: self.lr_scheduler = None # We won't use a LR scheduler + self._save_untrained_model(_get_untrained_models_folder(work_dir, model_name)) + @random_method def fit(self, training_series: TimeSeries, @@ -299,7 +305,11 @@ def fit(self, raise_if(val_training_series is None and val_target_series is not None, "`val_target_series` can not be " "specified without a `val_training_series`.") if val_training_series is not None: - val_training_series, val_target_series = self._make_fitable_series(val_training_series, val_target_series) + if val_target_series is None: + val_target_series = val_training_series + raise_if_not(all(val_training_series.time_index() == val_target_series.time_index()), + "the validation target and training series must have the same time indices.", + logger) raise_if_not(self.training_series.width == val_training_series.width, "training_series must have the " "same number of component(s) as val_training_series.", logger) raise_if_not(self.target_series.width == val_target_series.width, "target_series must have the same number " @@ -390,6 +400,9 @@ def predict(self, n: int, test_out = np.stack(test_out) return self._build_forecast_series(test_out.reshape(n, -1)) + def untrained_model(self): + return self._load_untrained_model(_get_untrained_models_folder(self.work_dir, self.model_name)) + @property def first_prediction_index(self) -> int: """ @@ -520,6 +533,20 @@ def _save_model(self, for chkpt in checklist[:-1]: os.remove(chkpt) + def _save_untrained_model(self, folder): + os.makedirs(folder, exist_ok=True) + filename = os.path.join(folder, 'model.pth.tar') + + with open(filename, 'wb') as f: + torch.save(self, f) + + def _load_untrained_model(self, folder): + filename = os.path.join(folder, 'model.pth.tar') + + with open(filename, 'rb') as f: + model = torch.load(f) + return model + def _prepare_validation_data(self, val_training_series, val_target_series): val_dataset = self._create_dataset(val_training_series, val_target_series) val_loader = DataLoader(val_dataset, batch_size=self.batch_size, shuffle=False, diff --git a/darts/tests/test_backtesting.py b/darts/tests/test_backtesting.py index af3cde958c..ee2193a643 100644 --- a/darts/tests/test_backtesting.py +++ b/darts/tests/test_backtesting.py @@ -35,7 +35,11 @@ def compare_best_against_random(model_class, params, series): # instantiate best model in expanding window mode - best_model_1 = model_class.gridsearch(params, series, forecast_horizon=10, metric=mape) + best_model_1 = model_class.gridsearch(params, + series, + forecast_horizon=10, + metric=mape, + start=series.time_index()[-21]) # instantiate best model in split mode train, val = series.split_before(series.time_index()[-10]) @@ -48,19 +52,19 @@ def compare_best_against_random(model_class, params, series): random_model = model_class(**random_param_choice) # perform backtest forecasting on both models - best_forecast_1 = best_model_1.backtest(series, start=series.time_index()[-21], forecast_horizon=10) - random_forecast_1 = random_model.backtest(series, start=series.time_index()[-21], forecast_horizon=10) + best_score_1 = best_model_1.backtest(series, start=series.time_index()[-21], forecast_horizon=10) + random_score_1 = random_model.backtest(series, start=series.time_index()[-21], forecast_horizon=10) # perform train/val evaluation on both models best_model_2.fit(train) - best_forecast_2 = best_model_2.predict(len(val)) + best_score_2 = mape(best_model_2.predict(len(val)), series) random_model = model_class(**random_param_choice) random_model.fit(train) - random_forecast_2 = random_model.predict(len(val)) + random_score_2 = mape(random_model.predict(len(val)), series) # check whether best models are at least as good as random models - expanding_window_ok = mape(best_forecast_1, series) <= mape(random_forecast_1, series) - split_ok = mape(best_forecast_2, val) <= mape(random_forecast_2, val) + expanding_window_ok = best_score_1 <= random_score_1 + split_ok = best_score_2 <= random_score_2 return expanding_window_ok and split_ok @@ -76,24 +80,28 @@ def test_backtest_forecasting(self): linear_series_multi = linear_series.stack(linear_series) # univariate model + univariate series - pred = NaiveDrift().backtest(linear_series, None, pd.Timestamp('20000201'), 3) - self.assertEqual(r2_score(pred, linear_series), 1.0) + score = NaiveDrift().backtest(linear_series, None, pd.Timestamp('20000201'), 3, metric=r2_score) + self.assertEqual(score, 1.0) with self.assertRaises(ValueError): NaiveDrift().backtest(linear_series, None, start=pd.Timestamp('20000217'), forecast_horizon=3) with self.assertRaises(ValueError): NaiveDrift().backtest(linear_series, None, start=pd.Timestamp('20000217'), forecast_horizon=3, - trim_to_series=True) + overlap_end=False) NaiveDrift().backtest(linear_series, None, start=pd.Timestamp('20000216'), forecast_horizon=3) - NaiveDrift().backtest(linear_series, None, pd.Timestamp('20000217'), forecast_horizon=3, trim_to_series=False) + NaiveDrift().backtest(linear_series, + None, + pd.Timestamp('20000217'), + forecast_horizon=3, + overlap_end=True) # Using forecast_horizon default value NaiveDrift().backtest(linear_series, None, start=pd.Timestamp('20000216')) - NaiveDrift().backtest(linear_series, None, pd.Timestamp('20000217'), trim_to_series=False) + NaiveDrift().backtest(linear_series, None, pd.Timestamp('20000217'), overlap_end=True) # Using an int or float value for start NaiveDrift().backtest(linear_series, None, start=30) - NaiveDrift().backtest(linear_series, None, start=0.7, trim_to_series=False) + NaiveDrift().backtest(linear_series, None, start=0.7, overlap_end=True) # Using invalid start and/or forecast_horizon values with self.assertRaises(ValueError): @@ -109,7 +117,7 @@ def test_backtest_forecasting(self): NaiveDrift().backtest(linear_series, None, start='wrong type') with self.assertRaises(ValueError): - NaiveDrift().backtest(linear_series, None, start=49, forecast_horizon=2, trim_to_series=True) + NaiveDrift().backtest(linear_series, None, start=49, forecast_horizon=2, overlap_end=False) # univariate model + multivariate series with self.assertRaises(AssertionError): @@ -118,7 +126,12 @@ def test_backtest_forecasting(self): # multivariate model + univariate series if TORCH_AVAILABLE: tcn_model = TCNModel(batch_size=1, n_epochs=1) - pred = tcn_model.backtest(linear_series, None, pd.Timestamp('20000125'), 3, verbose=False) + pred = tcn_model.historical_forecasts(linear_series, + None, + pd.Timestamp('20000125'), + 3, + verbose=False, + last_points_only=True) self.assertEqual(pred.width, 1) # multivariate model + multivariate series @@ -126,17 +139,39 @@ def test_backtest_forecasting(self): tcn_model.backtest(linear_series_multi, None, pd.Timestamp('20000125'), 3, verbose=False) tcn_model = TCNModel(batch_size=1, n_epochs=1, input_size=2, output_length=3) with self.assertRaises(ValueError): - tcn_model.backtest(linear_series_multi, None, pd.Timestamp('20000125'), 3, verbose=False, + tcn_model.backtest(linear_series_multi, + None, + pd.Timestamp('20000125'), + 3, + verbose=False, use_full_output_length=False) - pred = tcn_model.backtest(linear_series_multi, linear_series_multi[['0']], pd.Timestamp('20000125'), 1, - verbose=False, use_full_output_length=True) + + pred = tcn_model.historical_forecasts(linear_series_multi, + linear_series_multi[['0']], + pd.Timestamp('20000125'), + 1, + verbose=False, + use_full_output_length=True, + last_points_only=True) self.assertEqual(pred.width, 1) - pred = tcn_model.backtest(linear_series_multi, linear_series_multi[['1']], pd.Timestamp('20000125'), 3, - verbose=False, use_full_output_length=True) + + pred = tcn_model.historical_forecasts(linear_series_multi, + linear_series_multi[['1']], + pd.Timestamp('20000125'), + 3, + verbose=False, + use_full_output_length=True, + last_points_only=True) self.assertEqual(pred.width, 1) + tcn_model = TCNModel(batch_size=1, n_epochs=1, input_size=2, output_length=3, output_size=2) - pred = tcn_model.backtest(linear_series_multi, linear_series_multi, pd.Timestamp('20000125'), 3, - verbose=False, use_full_output_length=True) + pred = tcn_model.historical_forecasts(linear_series_multi, + linear_series_multi, + pd.Timestamp('20000125'), + 3, + verbose=False, + use_full_output_length=True, + last_points_only=True) self.assertEqual(pred.width, 2) def test_backtest_regression(self): @@ -147,15 +182,15 @@ def test_backtest_regression(self): target = st(length=50) # univariate feature test - pred = StandardRegressionModel(15).backtest(features, target, pd.Timestamp('20000201'), 3) - self.assertEqual(r2_score(pred, target), 1.0) + score = StandardRegressionModel(15).backtest(features, target, pd.Timestamp('20000201'), 3, metric=r2_score) + self.assertEqual(score, 1.0) # Using an int or float value for start - pred = StandardRegressionModel(15).backtest(features, target, start=30, forecast_horizon=3) - self.assertEqual(r2_score(pred, target), 1.0) + score = StandardRegressionModel(15).backtest(features, target, start=30, forecast_horizon=3, metric=r2_score) + self.assertEqual(score, 1.0) - pred = StandardRegressionModel(15).backtest(features, target, start=0.5, forecast_horizon=3) - self.assertEqual(r2_score(pred, target), 1.0) + score = StandardRegressionModel(15).backtest(features, target, start=0.5, forecast_horizon=3, metric=r2_score) + self.assertEqual(score, 1.0) # Using a too small start value with self.assertRaises(ValueError): @@ -165,23 +200,34 @@ def test_backtest_regression(self): StandardRegressionModel(15).backtest(features, target, start=0.01, forecast_horizon=3) # Using StandardRegressionModel's start default value - pred = StandardRegressionModel(15).backtest(features, target, forecast_horizon=3) - self.assertEqual(r2_score(pred, target), 1.0) + score = StandardRegressionModel(15).backtest(features, target, forecast_horizon=3, metric=r2_score) + self.assertEqual(score, 1.0) # multivariate feature test - pred = StandardRegressionModel(15).backtest(features_multivariate, target, pd.Timestamp('20000201'), 3) - self.assertEqual(r2_score(pred, target), 1.0) + score = StandardRegressionModel(15).backtest(features_multivariate, + target, + pd.Timestamp('20000201'), + forecast_horizon=3, + metric=r2_score) + self.assertEqual(score, 1.0) # multivariate target - pred = StandardRegressionModel(15).backtest(features_multivariate, target.stack(target), - pd.Timestamp('20000201'), 3) - self.assertEqual(r2_score(pred, target.stack(target)), 1.0) + score = StandardRegressionModel(15).backtest(features_multivariate, + target.stack(target), + pd.Timestamp('20000201'), + forecast_horizon=3, + metric=r2_score) + self.assertEqual(score, 1.0) # multivariate target with stride - pred = StandardRegressionModel(15).backtest(features_multivariate, target.stack(target), - pd.Timestamp('20000201'), 3, stride=3) - self.assertEqual(r2_score(pred, target.stack(target)), 1.0) - self.assertEqual((pred.time_index()[1] - pred.time_index()[0]).days, 3) + hist = StandardRegressionModel(15).historical_forecasts(features_multivariate, + target.stack(target), + pd.Timestamp('20000201'), + forecast_horizon=3, + stride=3, + last_points_only=True) + self.assertEqual(r2_score(target.stack(target), hist), 1.0) + self.assertEqual((hist.time_index()[1] - hist.time_index()[0]).days, 3) def test_gridsearch(self): @@ -211,7 +257,10 @@ def test_gridsearch_multi(self): 'output_size': [2], 'kernel_size': [2, 3, 4] } - TCNModel.gridsearch(tcn_params, dummy_series, forecast_horizon=3, metric=mape, + TCNModel.gridsearch(tcn_params, + dummy_series, + forecast_horizon=3, + metric=mape, use_full_output_length=True) def test_forecasting_residuals(self): diff --git a/darts/tests/test_ensemble_models.py b/darts/tests/test_ensemble_models.py new file mode 100644 index 0000000000..e30cbbb226 --- /dev/null +++ b/darts/tests/test_ensemble_models.py @@ -0,0 +1,46 @@ +import unittest +import logging + +from ..utils import timeseries_generation as tg +from ..models import NaiveDrift, NaiveSeasonal, Theta, ExponentialSmoothing +from ..models import NaiveEnsembleModel + + +class EnsembleModelsTestCase(unittest.TestCase): + series1 = tg.sine_timeseries(value_frequency=(1 / 5), value_y_offset=10, length=50) + series2 = tg.linear_timeseries(length=50) + + @classmethod + def setUpClass(cls): + logging.disable(logging.CRITICAL) + + def test_input_models(self): + with self.assertRaises(ValueError): + NaiveEnsembleModel([]) + with self.assertRaises(ValueError): + NaiveEnsembleModel([NaiveDrift, NaiveSeasonal, Theta, ExponentialSmoothing]) + with self.assertRaises(ValueError): + NaiveEnsembleModel([NaiveDrift(), NaiveSeasonal, Theta(), ExponentialSmoothing()]) + NaiveEnsembleModel([NaiveDrift(), NaiveSeasonal(), Theta(), ExponentialSmoothing()]) + + def test_call_predict(self): + naive_ensemble = NaiveEnsembleModel([NaiveSeasonal(), Theta()]) + with self.assertRaises(Exception): + naive_ensemble.predict(5) + naive_ensemble.fit(self.series1) + naive_ensemble.predict(5) + + def test_predict_ensemble(self): + naive = NaiveSeasonal(K=5) + theta = Theta() + naive_ensemble = NaiveEnsembleModel([naive, theta]) + naive_ensemble.fit(self.series1 + self.series2) + forecast_naive_ensemble = naive_ensemble.predict(5) + naive.fit(self.series1 + self.series2) + theta.fit(self.series1 + self.series2) + forecast_mean = 0.5 * naive.predict(5) + 0.5 * theta.predict(5) + self.assertEqual(forecast_naive_ensemble, forecast_mean) + + +if __name__ == '__main__': + unittest.main() diff --git a/darts/tests/test_regression_ensemble_model.py b/darts/tests/test_regression_ensemble_model.py new file mode 100644 index 0000000000..6610a2c5df --- /dev/null +++ b/darts/tests/test_regression_ensemble_model.py @@ -0,0 +1,90 @@ +import unittest +import logging + +from sklearn.ensemble import RandomForestRegressor + +from ..utils import timeseries_generation as tg +from ..models import NaiveDrift, NaiveSeasonal +from ..models import StandardRegressionModel +from ..models import RegressionEnsembleModel +from ..logging import get_logger + +logger = get_logger(__name__) + +try: + from ..models import RNNModel + TORCH_AVAILABLE = True +except ImportError: + logger.warning('Torch not available. Some tests will be skipped.') + TORCH_AVAILABLE = False + + +class RegressionEnsembleModelsTestCase(unittest.TestCase): + sine_series = tg.sine_timeseries(value_frequency=(1 / 5), value_y_offset=10, length=50) + lin_series = tg.linear_timeseries(length=50) + + combined = sine_series + lin_series + + def get_models(self): + return [NaiveDrift(), NaiveSeasonal(5), NaiveSeasonal(10)] + + @classmethod + def setUpClass(cls): + logging.disable(logging.CRITICAL) + + def test_accepts_different_regression_models(self): + regr1 = StandardRegressionModel() + regr2 = RandomForestRegressor() + + model0 = RegressionEnsembleModel(self.get_models(), 10) + model1 = RegressionEnsembleModel(self.get_models(), 10, regr1) + model2 = RegressionEnsembleModel(self.get_models(), 10, regr2) + + models = [model0, model1, model2] + for model in models: + model.fit(self.combined) + model.predict(10) + + def test_train_n_points(self): + regr = StandardRegressionModel(train_n_points=5) + + # ambiguous values + with self.assertRaises(ValueError): + ensemble = RegressionEnsembleModel(self.get_models(), 10, regr) + + # same values + ensemble = RegressionEnsembleModel(self.get_models(), 5, regr) + + # too big value to perform the split + ensemble = RegressionEnsembleModel(self.get_models(), 100) + with self.assertRaises(ValueError): + ensemble.fit(self.combined) + + ensemble = RegressionEnsembleModel(self.get_models(), 50) + with self.assertRaises(ValueError): + ensemble.fit(self.combined) + + # too big value considering min_train_series_length + ensemble = RegressionEnsembleModel(self.get_models(), 45) + with self.assertRaises(ValueError): + ensemble.fit(self.combined) + + if TORCH_AVAILABLE: + def test_torch_models_retrain(self): + model1 = RNNModel(random_state=0) + model2 = RNNModel(random_state=0) + + ensemble = RegressionEnsembleModel([model1], 5) + ensemble.fit(self.combined) + + model1_fitted = ensemble.models[0] + forecast1 = model1_fitted.predict(10) + + model2.fit(self.combined) + forecast2 = model2.predict(10) + + self.assertEqual(forecast1, forecast2) + + +if __name__ == '__main__': + unittest.main() diff --git a/darts/timeseries.py b/darts/timeseries.py index 56151b613f..3bff344a41 100644 --- a/darts/timeseries.py +++ b/darts/timeseries.py @@ -567,7 +567,7 @@ def from_dataframe(df: pd.DataFrame, @staticmethod def from_times_and_values(times: pd.DatetimeIndex, - values: np.ndarray, + values: Union[np.ndarray, pd.DataFrame], freq: Optional[str] = None, fill_missing_dates: Optional[bool] = True, columns: Optional[pd._typing.Axes] = None) -> 'TimeSeries': diff --git a/darts/utils/__init__.py b/darts/utils/__init__.py index c1825825b1..366a9661a4 100644 --- a/darts/utils/__init__.py +++ b/darts/utils/__init__.py @@ -2,4 +2,4 @@ Utils ----- """ -from .utils import retain_period_common_to_all, _build_tqdm_iterator, _with_sanity_checks, _backtest_general_checks, _get_timestamp_at_point +from .utils import retain_period_common_to_all, _build_tqdm_iterator, _with_sanity_checks, _historical_forecasts_general_checks, get_timestamp_at_point, get_index_at_point diff --git a/darts/utils/missing_values.py b/darts/utils/missing_values.py index ae4d983d8e..1f9a4b64f5 100644 --- a/darts/utils/missing_values.py +++ b/darts/utils/missing_values.py @@ -112,5 +112,4 @@ def _auto_fill(series: TimeSeries, **interpolate_kwargs) -> TimeSeries: interpolate_kwargs['limit_direction'] = 'both' interpolate_kwargs['inplace'] = True series_temp.interpolate(**interpolate_kwargs) - - return TimeSeries.from_times_and_values(series.time_index(), series_temp.values, series.freq()) + return TimeSeries.from_times_and_values(series.time_index(), series_temp, series.freq()) diff --git a/darts/utils/torch.py b/darts/utils/torch.py index 7e243241d6..d360c153e8 100644 --- a/darts/utils/torch.py +++ b/darts/utils/torch.py @@ -8,6 +8,7 @@ from sklearn.utils import check_random_state from torch.random import fork_rng, manual_seed +from numpy.random import randint from ..logging import raise_if_not, get_logger @@ -15,6 +16,7 @@ logger = get_logger(__name__) MAX_TORCH_SEED_VALUE = (1 << 63) - 1 +MAX_NUMPY_SEED_VALUE = (1 << 31) - 1 def _is_method(func: Callable[..., Any]) -> bool: @@ -50,17 +52,15 @@ def random_method(decorated: Callable[..., T]) -> Callable[..., T]: """ # check that @random_method has been applied to a method. raise_if_not(_is_method(decorated), "@random_method can only be used on methods.", logger) - + @wraps(decorated) def decorator(self, *args, **kwargs) -> T: + if "random_state" in kwargs.keys(): + self._random_instance = check_random_state(kwargs["random_state"]) + elif not hasattr(self, "_random_instance"): + self._random_instance = check_random_state(randint(0, high=MAX_NUMPY_SEED_VALUE)) - if "random_state" in kwargs.keys() or hasattr(self, "_random_instance"): - if "random_state" in kwargs.keys(): - self._random_instance = check_random_state(kwargs["random_state"]) - - with fork_rng(): - manual_seed(self._random_instance.randint(0, high=MAX_TORCH_SEED_VALUE)) - decorated(self, *args, **kwargs) - else: + with fork_rng(): + manual_seed(self._random_instance.randint(0, high=MAX_TORCH_SEED_VALUE)) decorated(self, *args, **kwargs) return decorator diff --git a/darts/utils/utils.py b/darts/utils/utils.py index 46cb0f28ac..6e9b428615 100644 --- a/darts/utils/utils.py +++ b/darts/utils/utils.py @@ -141,7 +141,7 @@ def sanitized_method(self, *args: A, **kwargs: B) -> T: return decorator -def _backtest_general_checks(series, kwargs): +def _historical_forecasts_general_checks(series, kwargs): """ Performs checks common to ForecastingModel and RegressionModel backtest() methods @@ -161,9 +161,12 @@ def _backtest_general_checks(series, kwargs): # check forecast horizon forecast_horizon = n.forecast_horizon - raise_if_not(forecast_horizon > 0, 'The provided forecasting horizon must be a positive integer.', logger) + # check stride + stride = n.stride + raise_if_not(stride > 0, 'The provided stride parameter must be a positive integer.', logger) + # check start parameter if hasattr(n, 'start'): if isinstance(n.start, float): @@ -177,21 +180,24 @@ def _backtest_general_checks(series, kwargs): else: raise_log(TypeError("`start` needs to be either `float`, `int` or `pd.Timestamp`"), logger) - start = _get_timestamp_at_point(n.start, series) + start = get_timestamp_at_point(n.start, series) - raise_if(start == series.start_time(), '`start` corresponds to the first timestamp of the series, ' - 'resulting in empty training set') + # check start parameter + raise_if(start == series.end_time(), '`start` timestamp is the last timestamp of the series', logger) + raise_if(start == series.start_time(), + '`start` corresponds to the first timestamp of the series, resulting in empty training set', + logger) - # check that trim_to_series and start together form a valid combination - trim_to_series = n.trim_to_series + # check that overlap_end and start together form a valid combination + overlap_end = n.overlap_end - if trim_to_series: + if not overlap_end: raise_if_not(start + series.freq() * forecast_horizon in series, '`start` timestamp is too late in the series to make any predictions with' - '`trim_to_series` set to `True`.', logger) + '`overlap_end` set to `False`.', logger) -def _get_timestamp_at_point(point: Union[pd.Timestamp, float, int], series: TimeSeries) -> pd.Timestamp: +def get_timestamp_at_point(point: Union[pd.Timestamp, float, int], series: TimeSeries) -> pd.Timestamp: """ Converts a point into a pandas.Timestamp in the time series @@ -199,19 +205,48 @@ def _get_timestamp_at_point(point: Union[pd.Timestamp, float, int], series: Time ---------- point This parameter supports 3 different data types: `float`, `int` and `pandas.Timestamp`. - In the case of `float`, the parameter will be treated as the proportion of the time series + In case of a `float`, the parameter will be treated as the proportion of the time series that should lie before the point. In the case of `int`, the parameter will be treated as an integer index to the time index of - `series`. - In case of `pandas.Timestamp`, `point` will be returned as is + `series`. Will raise a ValueError if not a valid index in `series` + In case of a `pandas.Timestamp`, point will be returned as is provided that the timestamp + is present in the series time index, otherwise will raise a ValueError. series The time series to index in """ if isinstance(point, float): - point_index = int((len(series.time_index()) - 1) * point) - timestamp = series.time_index()[point_index] + raise_if_not(point >= 0.0 and point < 1.0, 'point (float) should be between 0.0 and 1.0.', logger) + point_index = int((len(series) - 1) * point) + timestamp = series._df.index[point_index] elif isinstance(point, int): - timestamp = series[point].start_time() - else: + raise_if(point not in range(len(series)), "point (int) should be a valid index in series", logger) + timestamp = series._df.index[point] + elif isinstance(point, pd.Timestamp): + raise_if(point not in series, + 'point (pandas.Timestamp) must be an entry in the time series\' time index', + logger) timestamp = point + else: + raise_log(TypeError("`point` needs to be either `float`, `int` or `pd.Timestamp`"), logger) return timestamp + + +def get_index_at_point(point: Union[pd.Timestamp, float, int], series: TimeSeries) -> int: + """ + Converts a point into the corresponding index in the time series + + Parameters + ---------- + point + This parameter supports 3 different data types: `float`, `int` and `pandas.Timestamp`. + In case of a `float`, the parameter will be treated as the proportion of the time series + that should lie before the point. + In case of a `pandas.Timestamp`, will return the index corresponding to the timestamp in the series + if the timestamp is present in the series time index, otherwise will raise a ValueError. + In case of an `int`, the parameter will be returned as is provided that it is a valid index, + otherwise will raise a ValueError. + series + The time series to index in + """ + timestamp = get_timestamp_at_point(point, series) + return series._df.index.get_loc(timestamp) diff --git a/examples/FFT-examples.ipynb b/examples/FFT-examples.ipynb index 686430e93a..2b69fe6c22 100644 --- a/examples/FFT-examples.ipynb +++ b/examples/FFT-examples.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -21,9 +21,17 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n %reload_ext autoreload\n" + ] + } + ], "source": [ "%load_ext autoreload\n", "%autoreload 2\n", @@ -60,7 +68,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -77,18 +85,23 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 15, "metadata": {}, "outputs": [ { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "output_type": "error", + "ename": "KeyError", + "evalue": "\"None of [Index(['temps'], dtype='object')] are in the [columns]\"", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfill_missing_values\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mTimeSeries\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_dataframe\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Date'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'temps'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'auto'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mtrain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msplit_after\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTimestamp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'19850701'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mtrain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mval\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Desktop/Darts/darts/darts/timeseries.py\u001b[0m in \u001b[0;36mfrom_dataframe\u001b[0;34m(df, time_col, value_cols, freq, fill_missing_dates)\u001b[0m\n\u001b[1;32m 557\u001b[0m \u001b[0mvalue_cols\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mvalue_cols\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 558\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 559\u001b[0;31m \u001b[0mseries_df\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mvalue_cols\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 560\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 561\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mtime_col\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/opt/anaconda3/envs/darts-dev/lib/python3.8/site-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 2903\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mis_iterator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2904\u001b[0m \u001b[0mkey\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2905\u001b[0;31m \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_listlike_indexer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mraise_missing\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2906\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2907\u001b[0m \u001b[0;31m# take() does not accept boolean indexers\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/opt/anaconda3/envs/darts-dev/lib/python3.8/site-packages/pandas/core/indexing.py\u001b[0m in \u001b[0;36m_get_listlike_indexer\u001b[0;34m(self, key, axis, raise_missing)\u001b[0m\n\u001b[1;32m 1252\u001b[0m \u001b[0mkeyarr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mindexer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnew_indexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_reindex_non_unique\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkeyarr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1253\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1254\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_validate_read_indexer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkeyarr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mindexer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mraise_missing\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mraise_missing\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1255\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mkeyarr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mindexer\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1256\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/opt/anaconda3/envs/darts-dev/lib/python3.8/site-packages/pandas/core/indexing.py\u001b[0m in \u001b[0;36m_validate_read_indexer\u001b[0;34m(self, key, indexer, axis, raise_missing)\u001b[0m\n\u001b[1;32m 1296\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmissing\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindexer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1297\u001b[0m \u001b[0maxis_name\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_axis_name\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1298\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"None of [{key}] are in the [{axis_name}]\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1299\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1300\u001b[0m \u001b[0;31m# We (temporarily) allow for some missing keys with .loc, except in\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: \"None of [Index(['temps'], dtype='object')] are in the [columns]\"" + ] } ], "source": [ @@ -131,21 +144,22 @@ }, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "MAPE: 416130884490747.6\n" ] }, { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAEFCAYAAADDkQ0WAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO2deZwUxdnHfz2zu8PeLAvLsXIjh6CgtAQRFTwQQaNijPcRUIlGoxKMJyQEj2i8jzeJJPFCjEajxICiRhBRrsYDkPvGYVl22WXvc6bfP3p6pmemz+rq6d7d+n4+yuxMd9XT1d1PP/3UU8/DiaIIBoPBYLQdfG4LwGAwGAxrMMXNYDAYbQymuBkMBqONwRQ3g8FgtDGY4mYwGIw2RkoU9+HDh0UArv7nBRm8IocXZPCKHF6QwStyeEEGr8jhBRki/6mSEsUdCoVS0Y3nZQC8IYcXZAC8IYcXZAC8IYcXZAC8IYcXZNCDuUoYDAajjcEUN4PBYLQxmOJmMBiMNgZT3AwGg9HGYIqbwWAw2hhMcTMYDEYbgyluBoPBaGN0SMVdX1+Pr776ym0xGO2Q2l11aDjY4LYYjHZOh1Tcd911F8aPH++2GIx2yMqfrMLyUSvdFoPRzumQijsYDLotAoPBYBDTIRU3q/rDYDDaMh1ScTMYDEZbhiluBoPBaGN0SMXNXCUMBqMt0yEVN4PBYLRl0ow24Hl+DIDnALQACAK4HsCWyGcAeEQQhE8dk5Aizc3N8PnYs4pBn1BDCP5Mv9tiMDoIhoobwEEAZwuC0MDz/GMALgZQJQjCBEclc4BAIIDx48cjJyfHbVEY7Yjmo834bPByjHmPd1sURgfB0PwUBKFEEAR5KVgzgDCAHJ7nv+B5fhHP812M2lixYgU+//xzHDhwAC+99JJNke2xatUqV/tn0GX383vRXNGM0o+PoGJNpSsyNFe2AACqN1e70j+DPi1lLdj7530QRRG7nt6DlupWt0WKw4zFDQDgeb4vgEkAHgbwhSAIR3mevx7APAB3qGx/C4BbAGDDhg0AgNNOOw2rV6/GJZdcQkF0a7S0tEQ/NzY2AnBnIU5LS4vrC4C8IAMNOURRxPZ5O1C2uQwV70lKe+TGESmVAQCajjQBAKqqYorbapteOCdekMErchx8NIia/9WCO53Djkd2oqr8GHr8qnvK5SguLlb93pTi5nk+D8AbAG4UBKEFwNHIT+8CuEltH0EQXgbwMgBwHCcCQHp6uq4wTqK8EAKBgKtyuNGv12SgIYcYFrERP0SVNmD9nNIYi7rGOmzDTuTn5aEEh12Twy5ekMErcuyu2QsASNsiqcjc3FzXZVJi6CrheT4NwD8BzBMEYTvP8xk8zwciP58BYJeTAjIYmnglqpNzWwAGbUI1UrHg6k01LkuijhmL+yoAPwEwh+f5OQD+DOC3PM/XAWgCMN1B+RgMTVg8PqOjYqi4BUF4A5KbRMnbJJ1xnDdME3bDp57W1lasW7cO48aNo9eox04ju6zcoSHYCLE1jKy+WfQalVWVR08qC2pmpISnn34ap59+Ohoa2mGuao8YJB2V5Sd9gRWnfEm3UY+fU6a4GSmhpKQEABAOh+k16jVjyKPWmRov/VvE1N9SPBftDVlve1SBmw4HbOu0tsbiMJmrpH3gldO4/+X9botgmduf9cjgRaisEXGoHBje32OK0isXWQIdxuIOhUJui8CgjUduqvIvItGx3hCnTTJ5togRN3hnAKMubo++lHQYxc3wBlTfdrxyn3v0dbotsdXrLy1eudYipFRxeyWqhMGgSuSy9sgLQJvEc2MXNbldlUKTDm1xM193G4edPkf4xxIRB0pTO7ieO5UsHJDBcAb24HWGGY+LuOL3bGwB5uP2FPINz278No5HTh/n8ddqElI9l+/ZW9GjcnWYcEA1/zpT3KnDkfkNr5y+NjR1I4oinvqn21Ik47lbUZ63gGzkuSiLCh3G4mZK2l06xPi3gWPcWwLc82djOVMdR+C5oeOimtuTdBjFrUTOD94hlEk7xjOnL3KTh1u8IpA2NBeu0sSzI+dRwTpMOKBSSVdWViZ9x2iLeOP8yZf1rj/tdlcQBj1kgzvsjWsskQ5pcXuBP//5z7j66qvdFsNziKJo/oHqkXvKa8//dZcJKPnPYcv7iSIQjiiq9ugqEcMWrq3oTs7IYpcOrbjdtLhvu+02vPXWW671n2rMvm1NmTIFGRkZ5hr16E3lNuUrjmLrnO2W95vzah78E9qv4v6o2yfY+TjhW5HHrrUOo7j37NmT9J0oivjf//6HtWvXuiBRx8ToYfnxxx/HJQRrC9RsVq+Ssu/l/Wit8dax6A3/f1Z3Sp0gCaTKhir96Iip7WK5SjymsSO4orgXLlyY8j6nTZum+v25556LsWPHpliaGGvXrsWIEdYK3DIk1B4CzRXNLkiSTEt1K7bcvw27n9vrmgzb5u3Ajkd3mt4+ze+gMAakSj1yJjVe8GhkMCKC7X4m2fBzk5Qq7i1btgAAZs6cmcpuAcQquyvxwuTk2LFj8cMPP7gtRspwOsnUsW+q6LVvi0j8b6t7YRx7nt+LXU+ZVzh+hTbwUmj6Lx4LgzuT0jia9AEdLJcUd3OZNwyBRFKquEtLSwFQTqZvEjWF4QXFzdBm06ZNWLJkiebvqoVcPRrulmpIfNR+n3v3g96t+NrH9PqRLe5D75eg/oB2NaYT648BAMr+V06vc4q4snLSDcXN8AZWHpYnnXSS7j7rpgnJ7Yc88jD2iBiJ6IkVZ3F7aHKS4+j5wKu+rQYAfHfTRuQMzsaZq8fTaTjFuOLjdqOogdrNf/DgwZTLoUVTU5PbIrQLvDKZpPo2kEIaDia7Bo3weVhxO0G4WTIgg2UiuDPDELZ549oxgyuK2ysW95AhQ9wWIcp9993ntggpwazFTerGsmNxl5SLeP1jOjfv2ovXSx88kIPe7Jik+b2puOQR3HvIGfl+LJP+/W6XI807giuK2w3fstf92Tt27HBbBE/R0tJCtqON03z9oyJueNTb14mT+D0aHCw/+86f7cy5cf/Rah3XTtXgwYNT2p/XFfeBAwfcFsFTkJ6vb6d/j4NvBon2bfJmAIFtQo3mXJNu+rj1kGVppH1+LB7j0sJllAUgxzXFvXOn+fjSjsDmzZvdFiElOO0qAYDyz9UjARZ9KuJQuXsP8LoGEX/+wLj/vYdEvLeCnpxb7t8W/aw3rG5GlejhpYeIV/DoyxGjo+PEG9I180VcNS/FykmhdJ54S8RtT4s4WqUvw7mzRPxsLj0563bWmdrO7+ICHD18kTF0WoGbueS88ubOFDcjpdCyuJtKtaNw9Pal/rptQMP+WKywWVdMnfWAEF2Uw6E3rD6FYvSSkcs5rLgT220q04nw8obeZopb5quvvnJbBIYCI8VdtbE6RZLYo+QDsix9VCFo0G33xP7DMXdRVHE73Kc8TP8bukJnI+B/G0R8v8tdDc4Ud4Tycm+ukGpvmLW4DUNGvWQSehy9grehkIhR08PYfsAjpmSEqfdK7qJn3hFRp73A0TR6152Vh5Qoijj3bhGjpjszXq8sFXHrU8bh0kxxdyBOPfVUcByH6667LuV9Wy2iYaTg3bYInYS6xa2zKKmqDvh+F/CPJfHbWB3fpYXLsLRwGY6uqiCRMAlZWc96MSaXrXOuNgQJDZoad4efb9P/KOIvi423M1zyzvP8GADPAWgBEARwPYBLANwNoAHADYIg/GhHWEZqEARpifjy5ctdk4FaVIkDmjuVD4PKGhH/WQXccIFxp5U1IhavAm40sa0aZoac1rFXrqlE4fgulvYxe00cOkoikdyJ9k9t0QgwY3EfBHC2IAhnAtgH4GIAswBMADAXwBynhGN0XIwVd2rkcIpZL4q48TFzCmv2SyJ+YXJbVUwqRhoKjETK9VvNbWcnzp5aNIjDFrfPpA/EcDNBEEoEQZC9TM0AhgDYKghCsyAIXwE4iVRIRscjFXHcdrny92Hknu9sWoYGvcCFhEO3HQljMqpEqbhTaYWGTA61rXBFWnrbacVtctxNZwfkeb4vgEkA7gPQTfGT6nDyPH8LgFv02gwGyVa4OcHRo0dTIk9LS4tmP6kcj1SPfW1tLQCgpKQEzc2SJjI7Fmrb1FTUavbV0NCg0W5PNDc3IxiMvXMrZWhq6gIggLc/1+6XBLmdmtpcADkoKSlBQ0M+gMzob0o5wuEiAP7o3/UNneO2tUpzc6zt0iNpUN6+h0pKAPRATW0txHBMHTQ3NSEYtO6vrq6qtiznkbJ0AF0BAJ+tLsWgni0IhVqRqJ7SfKJu23q/hVvCSdu1trYiGAziSGRMjh07hmCwXlfWdd8fBtDDsD9S/L4eaA1x0baLi4tVtzOluHmezwPwBoAbISnqPMXPqutpBUF4GcDLAMBxnOpzSksoNygsLEyJPMFgULOfVI5Hqsc+JycHANCjRw8UFRUBAG644QZMmjQJ11xzTdL2PXr0iH5Wk7W821HswT7VvjIzMzWOL4yMjIy435TnIxCIN/3k7yfeGcZTt3E4ZYi6OfQ99Fe9yu3k5Urt9+zZE506iXG/KeXgfOG437Kz4v82IlGedH9adN/qFhFK87Nnj54AROTm5IDzxUz7QCBg6RqR+8zLzbV8be2viMl03r3d8ONbJfD7k1WT38+pti33Lf/WWtOK1Reuw5h3RyPQLQAACDWFsQlbott9j81IS5PGpbRW6j+/c2cUFxfons8bHo899Jy4h/z+MNBi3Lahq4Tn+TQA/wQwTxCE7QB2AhjG83wGz/PjAGykIbAX2LlzJ3lyozZOZWUlSkpKUtrn66+/jmuvvVb1NzeiSrTaXPEt8Pgi8ndkMSyidnv8G0IqHUF64YAyHBc/bUA6vqGG5M7q9tQh1JS6jKDVm2tQs7kmvggCpXS/1eYWoRJj1lVixhV+FYCfAJjD8/wKANMAPAtgBYCHI/+1CwYPHox7773XbTFcYfDgwejVq5fj/Xg5qkQPO7f9/r8dwMpxX4FrIctDb/tQFWPp9ANjz/PJNTa/OHUVttynPQOZeHwb96Rhn/V1S4oGVb5THHjLMck4q99TH9e/mUvT6VICZicnDV0lgiC8AclNksjb1kRqG2zdanKKu53htQVItqJKCLWTU8+C+siyd87kJCHtCTA9iztVc8C127TnJBJlmPJgN1PbGRI33rE/wjas/9p6UWNWjw40LW4GI+UYrZz0UoUW2jtrbU4aaXOsRtQstiu3yHGAciqK9vjSeECIIvDie9rHEsXA4k7UelYsbicuu9IK6Zi+3SGaHnemuBOwusKPYcySJUuwf/9+AOrK58MPP0wqI+c1V0kqSTx0K4pFjRpFoIRWG4nDSX14KWhuEcDbyxVun5CIA69qlx8UW0UceO2gdC0pu/fYtXNAqqEOYbv5YXKlWDDDW1xyySWOtn/hhRfq/v7Tn/4Uw4cPj8tJ7rUFOPYsbjrtkcqgHtNlr00z1O2uw+bfbIl0ZL+9RFkPLymNta9A1suH3ivB0S8rkHdSHrIHZif9TgLnkfSAzOJOwAmLu6SkBFVVVdTbtcPChQujx7p4sYnkCJTQUsg1NfHFdY877jjddprLUpuflYqCU1xaZttTJn9S26fWRK5tPWWjbPPAkZgdZ+cuWDXxa6y5eB0OvPYjjn5JJ3cJIPl/41LUtui/PsjFgBGKD4Hc80LyBCog5W0pMSi04aS9YOUaY4o7BfTq1QujR492W4w43Eg0RZOGoHbKuLo9+osoXMPkjSlvdqRSxNBrxeiCoMTdG35swMqxq3B4SSlxv0plUVJBZ9atemMNKlZVwp9NdxbPbMRFFFH9c/Cd+LBX2VZ74GURvabpnyS/A68oSlvRbOtMcaeI3bt3uy2CJ9CyuK1OvOlFStRsrtH+0QIT7wwjZKNqvIzaof17pfF+coa85hb1dlqqWwEAjT/qV15QWtyJbaQqqkQ3isZkG2YjLtT6FhVx3JwNrTeu+kj08yUPpC42PRGmuCPIbgMnJyc5jsNnn33mWPsdCkoLKvRY8S1QSecZEIeRspR/T7wUtSYtg+8c0i1kq+vjlrdJ3IcD3vzERASHHpRPkc9n8UGjPCjFfo0l8YlirNzySot78SrgxyP2DrKlVcSpt0htMFcJAalKauRmStVUU1paivfffz/uO1rjbGY1oBocB3wmiNgdTJZD7f6Vnw+0JyeJmtFop+o78mpAesf175WxH0srRCz+0sbbEoXzPmpQ7HPF6krUaMSGRxWxhqvEFgkXye5D9pojzXjouuLeuHEjLr74YrfFSCmVlZVui5ASrr76akybNs3UtocPH8ZZZ51lvnETFveel/Zh34L9cd+JInDeLBEnzzB3JxsV4rFERHmZ1SFJbo3EDVRMRTV/N6ejNPXCA5XNXz5XxCUPWtR+lI2h4xXz1WsuXIfdT+9R3zAhfPLQeyXY/vDOpM0yijIsyyBGGv7D/m9Q3FRne7KSdIRcV9zz58/Hf/7zH7fFoM57772n6nbhOA6ff/65CxKp46RrqLo62RLUss5aWlqwcqUJx6/cjgmFum3udmy5b5vqbzUq85dqQ9HzUmvKVhezk5OaC3Ckf1dPWYs1F61T3eab679L+k53kanJuO5j2gsfNY9r15MaipUQy96xyA77FxzAwdeTa73kjci1LgM4+ACMrj2KS4/upxoSbuXwXFfcTrkoNm3ahDVr1jjSthk++OAD1e85joPfVmJhZ3n//fc9t/xdjc6n5Ke0P+VlevjDUjRXkIcjmr3ktXzclWuPoeJr9bc2zq9iLChzlWhY8UYKyO6UQqgxjODb9vwKpt9+IgcjGkwsR+e1LMrhU7w52VXcyvPBNYdwerm5RG/tVnGfdNJJOO200yzvR8MCra6uxsKFC1V/a2xs9LTinjZtGqZPn+5Y+7TOdy6BtUSLb278Dpvu+sH6jjYt7neWA0c+KdPdlzO4tBKbNqsMdbczcVy1W2vx/W2bogme4nY3OS5OZ+Yzw6FAFnyQFTdHVXHnLd2LX+3ejMxQq+F94rriTlx44RY0XQZffvml5m9bt26FTyMg9fXXX6cmg5IHHngA6enpprevq6NzhzgboaP9m178MC2RWmtazW+ccBOaVVT9r4jfcPofRXzzi2RXSBwqMXPZDc0xK1EjHDBpyXvCd0qLu//Pw7j+EUmTL+v9GbbO3a4vkwZ1DaLhghcl9TpVg+KIyF1/wFx5eCvXRAvni0aWiLBurevK0SylHvRBNLxGXFfcn376KQBnozqsZPyjoWyM2khLU8808M4779juW43nnnsOra3mFQ0theta3heCS2nZOhE/6huzqpR+dMR4oyjmBNPdymBIOY1gZ7/GpIBcNkwvRloUxTiLe99h4I1I9GGoPoR9f92vvqOqgLGPU34rLXhZZTKjv1UXU0sF/dz6PlHEqDppNehxzfVULW7l4Bi5ljyTqyQUCmkqNLuccMIJhtukKhzQDR+31WNzUuFSG2cdEUkWWEyerS+Xltgbrv3WfCcqoYWiKCaNt50h0jt2UUy25GRL2ufjoHxkxFnbYX0fN+fjDP3JsY1jH7+MKOz7Xza37yfrzXVhGsLLvGuLtOApr9V+2gWtIz/wykFsn7sdxVeo58h33eKWMUrjSYpZJUQz0ZJRn6m2RK2OrZYrxwovvPAC1q1Tj3yggt4QqozvsRp7D4xEhXd0ZQXWXGzu+MpWHNX8LVgGcGeGsSto7mGuFMPKZcQhsoIw4TjkwgBq2QHl78KigY/bwuWivPZJH1ALdq4y6oSsYROcdWJMaB/Mp2HVIu4hHvn3nW0r8P5j+pUk2r3itgptV4mb1cplrI4tjTH4xz/+ofo9rfHQlVHlqi68iP55qFhlLh6/fnek0krkb+UQ7IhkJd28LzYHoTdE9U3650YzvE/jNzMLjETRwOK2crlQ0Km9ms35rs1i5ZLMSAOOpkt1LHdk5lN2lcQ4oUE/KZ2rivv222+PfiZR3A0NDZg8eTKOHtW2aNzASHH/7Gc/U93PKSXvJVdJKmitaYVw9Tdx31m9vE6qq8DMklgMuFNx3Fbb1du+ZlstQnXatbXCaha3zrjIV0E4bKDc2ur1QiB27x2lmFohxYTvzMwz2FqdHY/ujC6UIg2zdFVxv/TSS9HPJIr7u+++w7Jlyzy9gEdNaR47dkx129pavVUO5LjhKtFCmU7WFnpNhIEjywhmGhXM+nEzflqhnaTfDmr36u0vFkQ/N5iNnkhg15+0E5n5Iv5trXDAY7XxvyhPUbefiijVe7kgOJ0NTfSNlK8nrZHmHCzKY0WSoT/8GJ2cDIMjcvfsempPdKGU1v5laQHdNpirJIFURJVoYWXloBXccJVosWjRIjoNtUkjT/8uD5ZZ1AJJmaG0Nx1de1TVxy1fGs/oBDTVNujn1NCKZFEl0r8TMdnHNlSh9KMjKXsBCHFkiluJnmtLD6a4E1i8eLHtXCJ6rhIzSvGxxx7D22+7V4s5Fa4SrQVKtOHS6BwLDS/WwKU7dNsafbOIC+/Vvw9EwidWr+Z6tDaFcey336Bza8yk13KV/PdracFPIs0qxQtC9eZLnyda9k6QmP3PCOLKQhQcaKRqzzOK20t8+OGHtvbXU9xm/M0PPPAArrzySlsy2MGuqyQcDifVkEzEfiEHcwoscQm4MkdJZY2ImvrUme7dv01ezqy8HEorgCWr9duID/s1L3u6GEbD/gY0f1WOicdiclj1sb72cezz5j3WFZdd+yw7ZBybLVz1jeE2tPDbuFVEUYxPYKg4n11b9R8+nlHcdibmvBC5oUWibEeOWFmwQcaqVauwd+9eALC08EbGrsX9xBNPOD5hbFbERD2xZV/sc5epIsb+ushUOzQvMacu19rt2nMk6WJY1T4MmTeWAVHE3rcORXOfrF9uvdIQaTpemXe2rbDXgAp2anlmdSLv981PmcXtKZSKb8aMGXG/BYNBx/s/44wzcNJJJwEgc0nYVdybNm2ytb8pTIrY0KK/YVWdz9VKJnb49qbv4/6u2aKtuDkV/zZgzeIe3FCN8cs24/RIFZii+74yv3OiPB6Yo/BluKv+dv5ovLRdC88o7pClR3/bIVW+3ETkCJXGRv2yVmrYVdx6+//4Y3J6TSWBQABdu3a11b+SzHAIJ96gr5gXG6znAJyzuO20a7VEm5qS1gsHTCQ9Yi6ni9K9yhHEsol0AiupkNFVysd93iwymbLDrdhzSFpAdbCUrA3S0fCM4n700UfdFiGKk4or1ZD4q1OdozsRUzJbEHHzXvPbGmEnnSsNROJTo27deSQmwBX8WdJq1XL9tS6azCjdiW92SIO6xUK6FplQCHhLUckwsC9BEJ1z7ZlcJd99Z5D1zCQlJSW44oorqLTVHiBR3HYnJ+0o/sTcHcXFxfb7EEUq7+YlHxzGtzO+N97QSBzbLViH0+jYisVNA1kED9k2tpBfOkgO5/VlwMFIzcpbD21FZmVFfNs6+3pGcZMg37zKCcCXX35ZN62qGdyc7Cwrs7dwJBGvWdxGNDc3m0sZkGIRRYCK0nYLDkBjSbLbLOUWtwiM/1U4ZdXldaEgg1ZaXDMoF1pdWJnsQvTpyNemFXd7pKjIXJSDGs3NzUmrSN1Q3Hb3V8osiiL279+PYDCIcePGkckDd6xcLWj5uK3QraURW6/dkPS9WTd1r6Y6HN9AXpRYyVcpmLs2hSji6JdHUdCShcp0/ZWKOk0QY+fF1jM+bgaQm2uvqsvzzz+Pyy+/PO47khSyTuUFN0ui4h81ahROP/30hI0stEcgg5ggA00Fe8XvU/8YSTPIx23Egl1f4+bSHbblqFApZuwmay8RMH8/edy3nTNpZcFp0r5GG/A8n8/z/Dqe52t5nh8R+W4nz/MrIv+dR959DK/FYhcVFWH+/PlE+x46ZK+2Hilq1YSczDuiBW2LWzW3i6U+vHNtdW9uwNx/fYrCFuvRPunhEHJD1uPyAUTLbSUy528kY0N+fvc/tIV4X+pEDj0vRD7hLLuaSC55py3uegBTAbyr+K5KEIQJkf8+Je/eu5SVleGJJ54wta0gCNi1axcAYMOGDcSrAu0+vNQUphuK2y7KtwSvPNBpiTGwUXI39G2SwjWNmh1XXQpfxFqec5Dcx87F5X2OXSff7iRuss0jn1PSNALKNogUtw37xtDHLQhCC4AynueVX+fwPP8FgCCA2wVBqEjcj+f5WwDcYlaQ5uZmy4tT5Im8ysrK6L40aljKuUpEUTQl06mnngoAmDlzJrKzs4n7TczXYnU8Eo89GAyiqoos1snOQqGGBnv5kpXjoPyslCncYn5WjcY8ZlMTYcq+BLgETV1eXg6gUHXbwpZGPHhwI97sNgC9musxqpZ8NSqNvBrtjbo6+9k4q6prAeTgaHk5gkFrlrsotoJ0mpF0cvJ0QRCO8jx/PYB5AO5I3EAQhJcBvAwAHJd4uSYTCAQ0Q7+0kBdzFBQURPfNyyPLkaukoEBKsenz+SzJ9Ne//tVWv4kWs9XxSDz2BQsWYN68eUSyFBcXIxQKoby8HN27d7e0r52HFxBfk1MrNDDcEsYmmHvt5kTY1t6BANnklRayldcQ7gotu1te8PLTigPELhIZvQgFEhZu/8LW/pmhVogAGv3uxUdkZ+WgHEk2pyVqm3MAAN26dUVxsbmL7HtsBgBkpJMfO9F7tCAI8qP/XQAjiXu3yeLFix1p1yuv51ZJVPyPPPKIrfbmz5+PHj162JbDKok+7lSTFWpBUYIP2qlSmTc/YdxwmMI7g5aPm5QCm/UW3922HH/bRb5kngqKau2kLPzE2vaH18fegFMaVcLzfAbP87L5cQaAXeTdk1NXV4fHHnvMja4dI1FJPfroo1ixYoU7wgBYv552dVZzmFH8iVn/aPIrReUbL0BD5SpHKyCGMPvHTQiE3U0zYVf50yIxgqjSn2G5DbO2yjeT10Q/OxpVAgA8zy8FMAnAAgB3A/ia5/mVAGYD+J3ZzmQXBA2Uvs9QKER94YobJCruBx98EJMmTdLd5/DhWFFRLy21t4MZi5vzceh3Sx9T7Vn17+a2xlKHZoZaEQiH2ryH2KcYx1G1FZhYdVjXZ54eDplKodqW0XqL2paVn5L+c5uaiF/lTAd+hpQAACAASURBVDlZBEGYkvDV40S9RRgxYgQ2b94c952dV+I5c+Zg5syZScul7WLUVklJCfbs2UOtP6usWLECEydOxO7duzFgwADq7ZOeE5oLeGi4SuxI8+625ShN74TpvjNwt21JYhgd1dD6Y/DLr/I0qjJZfPQ8tm8DhjVUYepwKtG+3oTi05jkFM1fsRJPFo/A8s49Le+b0pkB+Ybs27dvkuK2g1M5ro0U0IQJE7Bjh/1FCaQy7N4t1RgsKyvDgAEDqFvcbvn6aYcw2h2V7gQx19qYG9On9sbcVLRdJdF2da6XYQZVxtsTZsa3ifMhoJNMnPQa691EVsPNU0G+o0aNwj333OO2GFGqqqrw2Wefaf6udFPY4ZxzzgFgP4wuEZIiCjTw2uRkTqgFS374FL0bnSnGTMIjNlbrmaXLuJhrssCgoooVZgfpGV2uIsb9E8XK1Xvh0QP457blxEmzwoT7pVRxyzehmkW1YsUKfP/993jyySdTKZIq77//fvTzv/71L83taFm4F110EdF+JPUs2wK0FffkSin+e3i9ygrMFEOS74M0qkQ5gVvcTNcoaA/EcoMbj6/WVXjr4e22QjVJz21KFbe8iCE/3znn/zPPPGO7DWWYoZ4yTMWqRD3FJf/mhMJesGABPv74Y+MNVUiZxW2ym6vL7M9DpFOKwPjZUYLEzYRoRd6cVC8tMONUxrZ7F0dFAgDcEfTIsncNi1uNqjT9SJPFq8gMjDA4DCUwKFKquKdNm4YnnngiOWEQRexWaE8kFYqb1mTeQw89REMcAMAtt5he9EodkvEY99lYjH7jZN1t/Das9xEesNatktU/y/I+eSq7jK4ppyBNjMnHnC/fZwrNjMHxP/ypeAQe6Ddat6mn3iYTIcxxREmuUqq4O3XqhHvuuYeKwvPCIhkax3HTTTfp/t7S0vZCspyKKikrK8MXX6iv2Ms7MRfdp+inxL3tsMn4bBXxfU5cbybbJO152MNDLO8zVCXCcmJVcnX69sAX30kj27OlAQMaqlGk4U5a0bknDmfoPwT7NtagtZWklBsZKVXc8g1Jkmo0ETXFvXTpUtvtJuK0xd23b99245umhZarpKioCBMmTIj+zaXFtnN6DPMciGk2e/WQhgP6O1m/zzrSpbjjQOzzC3vW4pWdJoqPatC1pQl/JljIfVXZHiKjICWK+3e/k9boyDfkpZdeartNNcU9depU2+0moqUQtm7ditJS+7mFOY4zLNv2yiuv2O4nlaSqEMOg2QNjf0Su5LR8ChGuKveRE5EUWrHVN5bGp+xLXH5Pi7kHv0cnxcTaH29qe+4gRxCBfQFr+XY4iKgmiOwLiGF00gkz1CIlivuaa64BELshMzKsLylNJFWuEi0lsnz5cmrtGxXQffbZZ1W/l8dg+fLlnnAd0cLs5GR6XlrUPSKfp9wT7BWjSCValtbl5ftSJkMXRZjgSf2T3yp6NNenTJZEuuQBf7/XuVcAvUVJ27I6W2yLPvt1Hh4pUdzyTZX4rx3sKKqbb77Zdv+08Pl80QebFonpXhO59957PaW4UxrHnfAz5/LKhJ7TzCflSomoBp0ozxTHJbtK/r7zK2f8+ybo0x346elAoUNBaHpXqdUjTrWHyRUft9GNvWPHDnAch4oK7ZSLJIrqtttuA2DNx+6077RHjx5xaUzVMHOsXlLcdrEy5knHbbDrdaW78PSetQRS6SNb/pm9M03vkxKFmKZ/i3Man5Xku5SzRBSBrp05lH/oQ5r9aTHTkNzxPlHEiN99gQOvHqQmR1l6J+3+qPViAtmSMroxFyxYACC2pFsNEkXltYrnq1evxg033GCouI0sbsBbitvumCmP16rFbcSV5XsxhFLRWzUG3zfI9LZOFjcYv1IqrGyURVEZy61mcXuFz5/1qGARAuEQ0qubsPv5vdTafKNI+1pyJVeJ0Y1ttHpywYIF6NLF+koB2dK2osCdVNxjx44FAKSnp+tup6W4lUrNS4rbLmvWxFJfGh2XmFCm3M758oth3Hx4BzLD1lfCyQrSl2H+2qJd3EBJ3vCIrz/DBzRoLx5SSpvmT13VeTP4FcJ1zqHfvhVXSfPnHD7VqScyvVS/Blz1pmqUf2GtglGLzrWcUsUtK0y7YXQki0PmzJmDWbNmoW/fvrjxxhuxYcMGrF1L/spMU1EqQ9zM9pW40MhJxS2KIl599VXcf//9pvKzpDS80U6iiQQGNtTgogprr7q+DA7DHhmKHhd2R5fxXdDYZP480C5uoEbhX05F+VVf62wRkyHNL0IMi8i2WW3HKo/vXY+tWZ3xavfj475/b37sZJqtRk8DtUsoPU3/wupqkAtGuOZbNAatRgfphCJbbIkI2WKkOTlplZkzZ6Jz5864++67UVBQgIEDBxrvhNTI6vf7UVSkvXgk0eJubGxEly5dsHDhwuh3TsSwy4iiiD/96U9Uwh9J+tb9PZzo407ttRXoHkDf6X0QKAqg3019UGmh5GkqFHd6P31TVakA/H7glA178M62FXHbDHN41eiI+mNJkTQnHw/06xk7l60O1HxwwlVF8/LTky6lPm7ZVeGFBSdecy3ojYlcQV5Gzvny7bffRr+jERuvxUcffYStW7ea3p7m+TU6T1xCGRE7USVEUts4VuNKrM4zoDH2pEnzAT0OJytpvXSmdrnyiHoemcT4gRYnXgJ0xp+08rvm5Ur5XKdEcWdlZeGJJ57AnDlzAJDd2PPnz4/6hFNJqh4yVvpJ9YPvwgsvTGl/Shob9V8vT3x2OIY/Mcxyu8oQswU7V+GCioMgurtsGACpsLiNmBX8IfrZ7xepSrTZRCz0dWXqAQj/mhd/jWdpB1gQc67mUn5pFOb2ORn39OOtNaoYwLq99VhauAzNFc1E14neXZ6yOO577rknmhXQrOJRbjd37lxbPulEzE5uaslK22InUcZee2uQSeWDpVPPTug7I5ZgI9xizjoMvheTsVdzA64soxcNYBYnwwE/32C97XTKIXetNl5/lG4SABg5iMN159uVyBobcrviiju64OC7FsJTFa67iq+leai63fQXMbmyXMELrhK7ips2Xra49di4cSNeeuml6N//+Mc/qD1gf/WrX1neJz1PP0JHJpCRPIapdpU4efOdc7d1xS1Z3N65tg6+GUTlesl1E24J4ydfbafW9qo8/YRkMv17AscVWRgTxbArLw3az2hPK24z8ctucewY3QkbozH55JNPksIGaVnc8sIkEiZPnozbb789+veMGTMgCAINsXTj2xctWoTBgwcnfe8LeKqoky5qk2NpLlzzs3/chDuDPyDNB3Syn40iip2rUxRFbPr1ZqyeLBkBleuOof/aAwZ7WWhf5wFl59HlUzEIyNEeQU9f5V9++aVhHg83+Oyzz6L+eloYKe6///3v0VJk8ra0FDdpoeFwOIySktSn/BRFEQ0NDdGHpyiKWLbO2liULY/PMZ3mI7M1W1pF7DxIdh7UXCWP7t9A1JYaZq+PiVWHMenYIaT5RQztR617W4p770v74v6m/ZKpJxsnSnmySWg43ITvPo9M+MpNiCLRYLju4yZl9uzZmD59uiNtm7X61ZbHb9lCv4KHkTxqv7vt4w6FYjFaFRUVRC4ckpj+cDiMUCgU3XfZOmDybBGrN4vo84veptpY/7MNyG9tttx3IofKgMHXKBZCWdhXbbRollezarz7/fGLXtykck1sHPa/chBrLlqvszVd/BAhD51yqf0nnXsZ7is2hHHo8kjcfNwJpnuvunaafvOb35ja7tChQ470b1bpqSluJ0qWuTk52bVrV9Pb1tTEwseUxYhvvfVWor7VFvTwPI958+ZpVkoSRRGhUCh6bmoj+e9r6oHC082vqPUrw9wo3Vdemi9ODHE3wiCtiSo/GhQYsNS/RqqDH2ZbN5QC3QPY0yU5quWOAT/BH487Ud/iRszXr3yQvdDrBEsyPPCy1AvpNeFJizsV9RppoCanG4pbqyoMDa677jrT2+bl5UU/Ky1umjJlZGRg7ty5mj7ucDiM8pos1He+EaIoQg7l/mS9PRnUajAa0RSJnPh+l4jSCmv7Oz0N+IlFI9Xnozvx/X12F3xcUGx6+1d3fBn9XLu91l7nHFCnEkm6JzMPX+brZ3D0iWLUVaJU3FZnH36UvXEimfLWKyTsecVtFMdrhv79+xPvq3Yhu/HQWblyZdJ3JMpy586dcfI/+eSTxMejtLitMmTIEJx55plE+4bDYRw6lo9jhfPR0hq7uZ56Gyg/Zn5MEr3aJCrrtcgy7VHTRZx2q1XFHb/907fTVeUX3iviQ73V7hSQJd4TyMGmMwbh2+zYG8+7Xfuh0m9+trMgFHNdNZeRu7HyR+VhyIPH626jV1XIh5iSjnvhtvxQU4aVWNwVQEmGdqZJzyvu1tZW1Nbae/q+/XZyJU+zSk9NTjfC8ZQuBVl2K/UoV61ahXfffReDBg3CgQOx2Xk7DyE7ivvOO+/EokWLon+fd955SdtojXM4HEaaT7qx6xolSzEqk4Wl0eliOPZ6Tmisr1aEle21OU97M6V1TqJi2CprLB6YxUu7uLkeL/Ycikf6jMS2n/THQ8qiujbuEzuLNU//32k47mrzln4iWha3FVprYvfGv1dYn5wsSc9Es087sN41xW1W+W3atAm5ufaqmthRtGr7krS3YMGCOIVpFTk0ktQlMXbsWFx22WVJ39spRmzHVaLcFwBGjBgR/dy9u5SGTU9xHy37EQDQ0BSvuDepr6BW5ZWdq/B/u1cDADqlu+CcppRm5d5+o1F8VWzirKx3QfTzs/8ia9MKH3XpjcMZWdihkp+L9M4TQ/TOR/bxyZVk0nSeDMMaqpAZlq7PgYT6/5N+/8OZVZKx9ey/RIQsTjiIBgPnmuL++c9/TrRfqvJw027viiuuQE5OLOGPUeparT7D4TBVf7Kd5eyJytcKiTH6ymPq3Vs/MiQcDuOtNxdGPsdbRZN+I+Ldwn6m5SiOlObKzQI+uNOeW47jrPkyE+9NUsW9ObtL3ENAmDpCe2MjbLxMfq1SltMLiruhLllJj68+orvPRRUHUfcJhxP6kQ/I8ZG87xxEhCqsGUhGwamuKe6RI0cS7UeSoU5N0Xbr1o2of632jMjNzY3ud8011yRF1RhZ8fK+pEo7sf3169dj0aJFOOEEazPlSuwskOrcOX7GX+249CxuWVOJItCU4A59pbv5YgbRvgDsuNt+QWA7ipuEV+Vk+5FTcd7us9GY60BiDwss4YfhzK/jI4IWdzEXphmF4gtQSRlZY1mdks/Qm93Mr3mwk33Q6M4y1EA8z+fzPL+O5/lanudHRL67nOf5r3me/x/P88cRS0cAibJQUwBml1OrKRSrinvixIlxcpC4WpSLbmhY3DzP46qrror7zigveCKWKtUoePfdd3HttdfGfWelgHQ4HMak8ydJ/QK45EH7PgcaLzEcJ8ljWUkp9rfK9iwp/090/H02HwcU5m++HXAccobIb5eSXOtzrRlKpNf4XQPGJH33tcnl7QDw2TPS8ef9MjnyZOpp1mThEv4l21sdMxqoHsBUAO8CAM/zaQBmAZgAYC4AuksIDSBR3GqK1mzdSSuWoBrTpk3DsmXL4uQg8ZvTtrhJtwGAN954w5YsZ599dvR48vPzwXEcrr76ahw8GO8k1TrXzzzzDOrraiMyEImQDC3FLQLlOrUC9Tq1eoP/4vjx2BiJ4pBdtnaLJdOed5fFKWpuMLV930ia2R4X6pSb0WFnZizt4weFfVGeFsDfug9G7sg8nb0U/S/fg/TOacgvTtYPbzxkbXD8kYuTZEjDdn3cgiC0CIJQpvjqeABbBUFoFgThKwAnEchFjJH/Uw03kzJlZ2dHc4zoWdxGy86d8nErMTtO119/fVQWu/1kZGQgHA5j1KhRKCwsjNtO6zgffvhhrPryy8g2RCIk0VJpvyBuKAQ89bZ5gexelQ2KqAN5rDg/53rdyNU/ABfeG39tdBLNzYc8uVcKPs89wX6tsjV5RbhhyJkAxyG9q7k3uh2P7UJLVatqrU6rBYszIk/Tx/ZZT2MgAuirE25OUrqsAIAygYjq4fA8fwuAWwCp+syUKVMIuqJDWVkZcnJyEAwGLe9bXV2dtJ+VBFO1tbXR/RsaGqL/Jrb54osvYtgw47zSixcvjovAMItyBWpLS4vqWDQ3m4+dDQaDcW3Kx2aG8vJy1NXVJckhtyGPWVlZmVYTkK3VksOlAMy/CjvNC+8B0wj3PVRibZWwMha5vl4au0Olh1BXVwAgtqLxrgFj8OyedYbt1e2vR0Od+fMIALU+dRWyRArWIS4WUV1toZRQArFrqmf0uyYr60FEIBQOJd0jdY3WnogZNmIa+/UM4YPflUJ5DEpIFPcxAMr3DtVHqSAILwN4GQCCwaBYXEweV0nK448/jnvvvRc9e/ZEeno6SGTIycmJ208URfzf//2f6f0zMzOj+8uLibKzsy3LIrt2rrzyShw9aq3oKIC4/oLBoGr/nTqZn9QqLi7G9u2xNJtW9h00aJCqHHKUys0334zi4mKD1LuSRpBCB9W1QxjOzL5vzczHsIYqzd/X53bFjEjx2NL0Tujeoq40EtVAV7FAdTstlEedGchENapQfFwxshOi35TuAz12XbQHhWcVAjC/biLHZGFlqwq84SvrET6rI370yx/uiT/M4KAcoQEzj8fq1ZtMt+VP9yfdI3UNIoBd6jtQ4sohZ+Gf279Abk46Rg1XV9oAmeLeCWAYz/MZAHgAGwlldJzbbrsNVVVVGDx4sGoWu6effhqzZs3Ctm3bMHToUFNtlpSUYMeOHaZlULoT7ExOKhchWbFunUR2mQB0lrz7/f64dvRdMfbyQNih2efDPf14FGoUiD0YiL3mv9VtAO46pJ5rQ1Zmpw2X3Asbb7F2KymXRDc2S429+D7wt/9aaiaOhgO0k/6TnaDq761nBW2OOPhX/wCcNyu+38JzuuGKYRNNt6XmKkmFC6rR50e/3w9F3yn6+YNMKW6e55cCGAVgCIC/AngWwAoAjQBusCWpg+Tk5OCRRx7R/F228PSiRBIVklVLWbm/3uSkFerr6VfUAKzJVV9fHxfH7UTu9I0b9RSZseJ2Kta13peGLdnWrGN1JOFP6Aes3RxG9TfaVrz23hLHaiQL/s4X7ElUv5euUWD1Ss8KO1AVGAQPeBXBrd62Vf505Iesx2/3vLEPsnP1OzOluAVBUHNQJ68jb2OQKG6rKPeXFaPdBUFOFZiworhnzZoVJ8fixYupy5MYZRKH6J7FXZUmTXSNHAR8T+nN2UdwHEofd109YH86D0jvko4Wi4tF9JAl3Jplzl0DANv/GsSu8eR90UDN4rZ6re3IzMOptdbcmkYrJmXaRoo+h5AVj9nQQDt9APQsbi8o7mAw6Hg+cH33laj4vzpmRolLt34uWiKv5AON0zPr9y3/S3g5KI/9u110zkVaLon3VA9JriPp2gmTEsmkWIUnKgUFi9tuiLwZQuBMPYA6tOKWLW49xb1t2zYAwNq1a9HUpO7T1EPNxz1mTPIiAdI2aWJFcaelpREteVemhbUnDyVXCcEdEIrcWiETp0HvCLLDrUgLh9E5eIxolZ1yj62ZxhXVzdBvZl8q7cjIx2+pogzhM2ibjlVfa9EDpBYP3ynA4XoLBYuJ9DxnLpyT9uO1TXHRRRdhzpw5uoUEPvjgA6xcuRJnnXUWZs+ebbmPRMW9ZcsW0xOhZtqkiRXF/cEHHxD1YSVlgb5FT8dVIjZZb6A1Mk56p+HfhX3Ru6kOelrotwc3IUMMI3trK54fdrZlOZT5LD4o7INPCmy+AkDdRUAD5SjU+dKQrRONUrawXPM3PRZ36aP525TfWjzPGub1gGIOO002wVt0k1ih3Vrc8mpFPUaOHAlRFJGZqf8ad9ZZZwEgq8aTqHzy8vJsu0qeeuopW/tr0aNHLOJfPmbaWAkb9Gqx6He79gOgb3H/vcdg/L7vybrtFISaowqM5IqI84dyHOr95irc69FwkO7kZHUkH7cyAuZTgxJgh1/QTwClic599a1ZbSujoRmd9A6uz5EMSDNTYO3W4p40aRL1NkkU7mmnWUxwYILXXnuNeptffPEFTjnlFLzyyisA3K9nCRgobhOTk07EcVemZaAmMjmplg0vEdIFKGYgK2+sz9GVdK3E97r2xY7MPDQrtNHeTjSmUZ1F880jHFuhSjODIQC8EzEIcrOMz2u7VdxOYDUapLKy0pJPV8mYMWOwbp3xajdakFajsUKfPtqvsmqYcZXopTkOg4OPcpHWuBA8m9W1lKhVfNfj50MnEFci735BEUo/0rBqKQcrhzgfvsspRLoizG+dxYRTZohmSaSFxjDIK/c5f+wzLUSOw3iTCUTaravEKmbcD1YVd+fOnYlD/woKaMQJk0PT4paX6FtZuASYW4Az4gZtOUkVmx5WR+WL/B6msgXefIG1p0CdDbeIL1P7miRZ+GIG5duBE170f3XrT7U9rWRdUSvbobkAs95BprgjzJo1y3CbVNaadDMxFkBXcZP6y81Y3Hp4wUPe6E/Dyz2NJ6N/cxlF890IN4r9KC5nO3mqlVSkOxA3GKE5qB7LLituzqHYwDOYxU2fVCpTtxX37bff7mr/gIHiNvFgccbidijqwgNzCk6SGFVCgx6Fzt0jTQfUE65FFbcDFveypzg8crO5dpnitkAqlaleiGIquOKKK1ztH5AKCmtjrOgq05yzyKjjhdcDR5HunRX5PdCiUwTXCj4bynN3J/06tj6V6jcAkN5ZeujYzXuuRk4WB7/JY3JVce/cuRM//PCDmyJYQq1avFM88MADKevLqyTm545HX3Hf33c0/trDXry89V7JObbMWp6StoaY8C8N7ChPIUffMCqYqr6gaeCdA3DqO6fAF6CvOq3Yha4q7kGDBtmqeZhqlBn6nKBv39iqtaysLJ0t2xbOvKnoq4CNOV3QSMmyi+vVobeu4KPJ2Ssdww0fd/RfeuNnx11hOAQal44vw4du59CPigFgadaWuUo8xHPPPRf9nJbWfiI19fNqE2LCJ9zkwGRyRVqAepupoNUh37xp5JqpNNt0NHmIftuBHvQLMvs6mTc0PKG4BUHwdHtu4GTiq1TzwAMPYOnSpQgEaCo9YxWwKzMff+g9klqP7xb2xbw+o6i15xZuToSazX5nBo4Dqp4+Hb8cSH+Rm9GL1anvjMaJz1uvRKXF6IUnI2+4vt9diScU9+jRo/GXv/yFSlt+vx+jR48m2veOO+6gIgMpSpeCXYtbEAQi187ll1+On//857b6TiQQCOCCCy6g2qZZ222thQrfRmzN6ozqtjThqYCmwjx310T8ZjRB3lUAy/O1q7pYxsch3DMbB51YiWkwXoGuGej5U7KCxmp0v8DadeoJxQ1IdSlpWAJ2/KnPP/+87f5pYdfiLioqQnZiDSsTvPPOOymdhCXH/LUydfh5+J3LlvLjx53oav80ySjIQE0khnpfwLzSnDr8PHyXozfhbA3Ol5qqNFqk5aZhylEL6QIp4hnFzaBrcbsdB+44Fh/ylkeD8p3BtbM4bflwtlgokEAdG9e44Z4ev32Y4vYodi3uVK7ydAdnFSHtB5+n9ACFofPCY8iexW1wBJ46Ycm097vbNZ5++mnL+yiVBVPcRlhTHVaTOKlx9mhg1PFk+66hlFip93XFyPuL9UIcyjC89C7207/2jIRBu6rfbESVGK6q9fgba3u/uy0zduxY222cfPLJuPvuuy3vR1NxtydXSUaG2oSgw64SFX59mQ83TSVrqdFPJ7xz4F0DkDHcerUb5WgN+8MQ23L893H3VQfHkevXWp/08BpKYSzcwP3Rp8ycOXNs7U9D4ZFOsiqtZGZxxxg0SC1lZ+oVd96J5sO1nEIUgYHFBPspPqdl23+IdHcwT4hpKMRxF52rvoIylXbPkXTrMeHt5+4GMHXqVMydO9dtMagobrvQeADNmzfPdhs5OfZDtVSPxeIY33qxtT77zYzPHX7ujonI7G2+4K1jiCIK862fWycSbgHu+rpPfGY48QM5mqFQq4EUKu6bh51heZ92pbhpMG7cONf6pqm4abRFI9HUL3/5S9ttjB+vFjNsTWWcZXEdTs7ghAdO5EY+/jhr7XgFH+1VhlzcP5b50ESOciPyRpC/Af0YkEJl0/M1/P0OKu4lBfEX0c5F1jtr84r72LFj0cUdNGoU/vGPf7TdRnuxuL3QRllZGV544QWVX6yNcZrFGmKB7gGcs2VC7IvIYUwaQ348d/e3PqmYBKGJKy/A2T/SfkFhANHxuGEy2XhMN7Eey3AS1UZUyfrcbjhnywQEumus5nVQcf+15xA8WRxbddmvZwdU3Pn5+Vi6dCkAoKVFPfm5FWjkCLGruBctWgTAWmHdRGgr3e3bt9tuj4SuXbsiPV3tBjYe47/9lsPDN3EQV/osjweXxiHQPYD+v+pnaT896ihMUJIGx8jJsb67YLhtGYDYtREgXEiaqdjvlNfUF0elZevP8ySe09MsHpqm0pYat9aYBUKcD8s721tB2uYVt5LW1laq7ZFawHYVdyhkv5gdyarJRJQ3ht5YbNiwwVQbVDExxmeNAh68PpLcSK84pQpy5rloBjqCU/rOvPhj5zT/sACp4ibsThO7p9WEQIGiAE55VX/Fq/LySqOY3scDU6+6MMWtw5gxZK+2t912G9F+ciSJ7PKxkwJA3Uq1htnwxFNOOQW9e6v7LJ1LaGTcrp2uZYXtS48o/lbrjf1sQkKbCplJS18FupOZuLQmJ7tfGMmpQdjcoEhETKhRYZxoDK0oAj0uMp8PhGpeNo9r7naluDt3th7fqgeJxZ2ZmYlbb72VqD+e53HllVfi4oulEAhSpafc7+9//ztef/11onaUeC9bocWxsbi5rLjTOqcT7Q/ov21Ei85a4LSPf4L0PLIH8r9OG4m3uva3fBhdJ8bnFhn92snRz8VXelsYnwAAGn1JREFU9cLAuwbo7v/4L+PHoFvkFg3+85Bx5ybekpRD7Ddxu5qtou51xd1ukj4vW7YMPM9TbZPkNf++++4j7q9Tp0546623on+bnWw95ZRT8M0336j+Nn36dGJ5zLpKzLZBF2sqyKqrJFAkWbb9bu6DzOM66ftDdUjzA60R41Je9EFKwankhkmwqDPWdO+Mmyxq7sH3D0L58qNJ33Mch5EvyomzzAcFfPAoh817ANzYCY2HGq0JY4CZlxjTV2MKFPfNg8Zhy1/JAiratMVdU1MT/Txp0iRqCfvffPNNAGRKh6Zlatbi5jgOvXpRihZIaNezmBib7srLwaLCyh4ozRH40n3o+dMeqttsWKA+Pucp7Iej/+Ww/18c8rKBynT3ijCQnsn0zvYeNspL6FeXAkUFHM4ezSF3eCzcUus6t/rC2dZcJYcC2cgfRZaki0hx8zzfj+f5Mp7nV0T+o1bLp1+/fqa3tRN1oYfsciFRXDSVnVnFLYoiCgoKqPUrozwWo+MqKlLPJ+yW8p83nUNedqzvosn0y0110zCALzpdimQBgLxsDn26c+gTGR5fZuptpTsuA166O+Krt+orITh9L9ypuG4AzJ8h/d2tM/1rIUvxLKyopt68Keb2Odl4owhV/tiD0M6tYecq+kIQhAmR/8pstBPHww8/bHpbp5SCrDBJfMw0Y7Hl/o3GhOM4R8bCSpv//e9/qfevj7VzQ+ob1kNreNR8rZ88xeHzZzlXlho+f6dPNTlWWp4JTynBdXX7ZfH7XBdJWR03LmbGIXL9H3+/WsoDiQvGArOvNC+bfDi9DesWmD/uDbn6hYe16GujDoMdH/fpPM9/CeBLAA8KghB3KnievwXALYBUJGHKlCmmGq2oqDAtQElJiWnl0tLSgmAwaGrb8vLy6D5Wqamp0e3HihwyVVX6FcBbWlriZDVq36wMpaWl0c8lJdrFbPXa0hsPkrGIoX/nV1dXIxgkL+6sL5cUg3u49DCA5LuvpvoYgsH6pO8Hdwc2WvS1a8tkPg44tl9P1NbVIxiUrqewaOxfLT1SGve3+rj0TNrmvw+n48KHuqK6ugoHg40AilBfX4VgsA4A0NgY829XHFW/51uapesj1E89WkyW5ewT0/DkP7uhtbUZgH7UzbVnV2Ll9wVYMv8wgkHtc9HaauXaJIvJDoVaEQzq27zFxeqJaUgVdwmAQQDqASwAMA3Ae8oNBEF4GcDLABAMBkUtARKx4qc+7jjz64+DwaDmIGjJoJ6VznhfvX6syCFb3Eb5PjIyMtDc3Bz926h9szIo48m1wv2M+uvVq5fm71bGIhl9BdizKA/FxfH+w++xWXXbtNw0tNbEKwd9uSSF16tnD1U5unTpjOJiddfVJvxAbHTHy6StdM8aBXzxXfJ+15wXxrzp2SguzsH32Ax/uh9hg4nFHj17YBt2aMgg8cztIu5+UcRdlwP8EA7FxcWoDYkAROTn56Nr13wAIrp2yUdxseRfOhQ4jBpID9aCzgXYj4NJ7aanp6O4uBhlheXYg33ofGpnHFt/LEmWw7VSXwET9+vNlxbi5ksBIDYnpHZdpGekm74277o8DPyg/lveSbmo3hibi1Oee78/jfj6J3qvFwShSRCEuoiV/W8A1CqyulnINFEGEveDeiY7ewwePFj3d47jqCzaUWsXkG6Q7t2tv9e98847mD17Nm2xJAyukzsuM98URzippXV16IWlpeLyfiiy6Oji8cDSJ2JSLpzjw8BiRWx+lh9+w9WJ5vudPoXDNZOkHeSAKL8PyM2SPg9R5O2S77GxS8ZoPoMSI4H639oXAODL4MC/dUpMxsi/3enEJsQ3aoJn7tA54Q65c0knJ5XZXc4AsIuOOOqK+6abbkLfvn1pdWEIac6T/fv3R2OwafDrX/8aAwcONJXsyUnFrVc8uFu32KRfjx49cM8990T/vvzyyylXdleirQEvHg9kpJu8YXxA31voXlu60xyE6XTi8qYYID84uuQBF4xVHwfOz6HfzL44Y9Xp+o2ZCbHj4v8FgFDkOH0+oLibFFkz9bTkxvJPzteMae99vfSWJyf8ktPqpuWno2hS8mTzSQONZTWNTX17OJKqNatvfEbJr/JiBtBtl5J3QjqTNp7n+Q0RH3cxgEXEEiSgprhfeOEF7Nu3j1YXhsiK22poX58+fYw3ssBzzz2HXbt2aVr+Q4cOBeC8xa3HkSNHop9LSkrwxBNPUJcDAJYsWYIzzlCmv9RW3FaMnJHfjcDAX/eP+87ICjXqR9fiJvRxW4kjN7P0+4IjkzDgtn5Iy1Hf2BewrhrUFLc8Fn26JwyWnFXVpz4mPaf1QL+bpPsps7gTphw9H9kDsuP2VeuXhAF39Ev+0mab+zvlYOrw85BRGO++WZMXe+DccxV5J0Q+bkEQPgLwEXGvFqGR+MkKshL0ejGC//znP1E3ytixY7F//36q7cuK2wvx3FOmTEHfvn0xYoScVU1HcVtt3OLy80HFwK5gTGEU5gNHFfPHuiv4KLlKhvYBth1Q/03u39RRaWw0cNYA7HyM/EVatiMMbR8O6m8heuOUYNzZvTyH/n4IqjfVoHxFbKERZ1Nzh+DDs3dwwFp7smnhOc2kZnGnerm1nPPESHHPnz8/FeKY4rXXXqOSn0QJqeKePXu2Zly3HYYPH45rrrlG+kMnIsLqjZzo4zba/9u/cyj/kItuNzkhpU0qnvfrX+ZQ9h91QTMjxvnV51F44HLAOdsnWt4t0eJOImpxc5bmtXwBn6Zry+hoexZq/zb6zYRYbJtD18JxmHiK9EahRKS0sqdNKO5UW3xmLW4ri4WcQKlYA4EAeva0lyrSqB+z/OlPf4oLJaTJwoULsXnzZgBhPDLZfu50QJEBMPqF/vHmZHEozOeIXCWmZUozlqGrxoKWQAYgrvThnNHG503z3EbvQw6Brtajq6I+buPmLeVtmXzoPBw/O96ZbfbyHN5f+zd/Jz+mHD0feSPzonLZoVXW2AnC0ZqbbhOKO9WYVdxXXXVVNGpi8uTJjsulhVMPNi+4SMyifCmzbHEn7FDwE3M5QeS9Ei9ZGor7zDWxqj9nfGUwgZiApf61xkq2iAkvgS4R/ddfy5ZQRG5lHud8Sbglj3NYNNfCwdhW3JxqBNGxNMIE5gl4TnGb5fDhw461LStuIxeN3+/H1VdfDQBUo0nMkujKoK1oveTjVqIm14kDlL+Tt50zONswB7RRPzRcJdn9s5DVT1JouUOt1e205LI3sogJGdybw963pbwkRnQ7W2XloYX+zZzvKadx1pbc27zk1+V2S2rnzgE/wb5OdApOt1nFTRJXbJaLL74YkydPxkknGeeAlP3KmZkeKCRLGa8pbD2UkuZlmdun+9RkP3ygewD+TGtzKonDpGfxnvLaKAyarZ8Ktff10sKyNK16iAZYmxIyOMcmLoGwhnWuW5LLgRdrtet1/oxY3hi7bVmh24QuGNonfkwOZ8R0xPuP2Gvfc4rbC66SwsJCfPTRR6aU8fDhw/H666/HJs1SSOLFNXbsWEfa95oCV5OL44C1f+EwbzqHZ+4wKa/NwyKxuHtc2B2D71dJHBLXsPQPv+gUnPrOKfrbqvVvxbA0cJUoydUozhs2mog02X7czxb0gN7hPnSDO9fu+4/6EcjgNE/GJWfYk8tz+bi9oLhlzMjCcRyuu+66FEijLwMgRZY89dRT1Nqtr5fybeTm0nm9o4V8vMrzw3HAmBM4jDnBejvkcqh/T8PHDQCdegTQqYf1rIZUfNzR36UNztk2QfNNxGgiUo3WWnrVqjxmV0jI58Ah2TynuBnmSbQ8A4GAjdwfyfTq1QtTpkzBjBkzqLXpFISVwGyh1aUbssT1T2VyUp48lP4MdNNeABS1uC24aE744zD8uIg0wZg6XlLgcmk6o4LHpLQpV8nGjRtTKIm3rH89nHJlpKenY8mSJY6FGZKifGBNGSt/R9JQ7KNWpXF9OQj6NNWwvd2tWNzyWHadkBDkrAjXM4LE4i44tTNOfEanLDvlyUnT0LrnI+dg4F0D0KmYft2ANqW4TzzxRFx66aUYPlznhKdIFi8g33Ru+Ne9wskRd7Fdxd3jQmmyu9dl5h9SXrDwhqpkWbA0ORnRAInLzmVFnpZj/FIu70rLRUSKF86HjGxx+zP9GPmStNq3MbLSaySFPHSec5UYKct///vfKZKkbShur8voBEqLW75ZSdwTiW8qU46eb3F/6d/EU5DKM7J1oQ+XPRTGv1fGvrM0OSlvnCB0l3FdTI9HIBL8YiZHimlcs7gptaOQqfCMQkw5ej5az5ReTb77h/0nXJuyuFONl2TxAps2bXJbhCTUMtOZJWdotr2+E2SQsXvZWM2TMSyyArwwkn7ckuUrb2tD5l9fBrz2AIeeXck1aNH59kvLecjgdjwSy3OKOxG5Go0beF1xpzpML5bgyV3ULG6rQ+HP8mPQLDp5QGkrbqsa6Pe/4LDnnxwuO1P628rkpGxxizY0d6cAh+sn27sW1WLqzeI1F7cyV7hTeM5VInPXXXchOzsbhYU6mWEYHR6Sm7b4il7ofW1xco4Sq31rPDRS/bxPS+PQvxcQjnRMFA7oto1io3+v+Lb9WX7kn5KHwrOc11mes7hlK/faa6+1VDi4o7Bx40aceaZkWnltYUyq0FqAY5aR/3ciuoyzXy7Fa1ElYUXxAtNdRZ8+QN+ntMvTpRqvv+2qEegRwNjFY+AnyGVuFc8qbi8pJbXl9RMnTnRBEimy5vTTrSUdam/EL7yJKHEX5FDovDjsqpxu55JVDbcb3dH5vHzjjRwi/2TyvuXjtVGHOYadB0YKL0LPKe5p06Zh3LhxGDZsmNuiRBVEp07xcZhz587F559/7oZIcbjxcBNF0ZFc2yTERZWYuJJH/uVE9WonpP1H5QBevIvDGAqX7KQD56D7+WTjS7T0PILdwgF2yRueazmqR0aOZglT0dxkFP+8F0b8SX/Z7rzpHP7yGzrj7Dkfd/fu3fHVV1+5LQYAbevfS28DbuBEmTQrKC1u0YKVWXx5L+ByenIoL4NfTePQuwi4+AHRntFm49qS9RZRdkKvXdIWxlCOW/f5OGs72uxXycg/n2i4zdwb6Q2y5yxuL+JVRe2WXKTFlGnDcRzZhBy1/uP/lbHlnrVxSuXTQnRdePMSt4TbqQZSCVPcJvCq4nYLtxW3bHErLW83yoMmKu4zRwI/OQE4wzgbsE6j5Lva8RRwXtN6Fo5FvgyUt6lemTIzbXkdprh1kBWDXAnn/fffB+COIs/JSU6m79YDxSuuEp/PF73R3NQ7ctedczms+YsPnXOtC5M1IpJC2MY5HWwjKCTHYrEGL6GmuFe9xGHpEwRj2UYUt+d83F5EVpByRXU32L9/P1paWlzrX4nbiltZoUi+aaeelnrNrbVykgi//bbmXM/hmvOs73fW+vHIPC4TJWUl5J27iFwmTfmmM6AXhwG9rLdlpf6lmzCL2wSJJczcsHS7dOkSDUt0O2TyzTffdKVfGdlVo7S4L3chOtOR4bfRZloah8G9rTeQPSAbvgxvqILiq6xr27xsqcrNGSMpnBAXI1Os4I2z5VFkBZmRIRX49Jqv2y15Lr30Ulf6lZEVt9/vj2UfdSMft408KUlYSKPanommenVJfzIfdzsiEJCSyHtNcXdU1FwlbuDE5dDhr7FoxkV3TixzlbQD5IsnP19a1dXaKpVbysoyWY3WYTrqTR5nccsTUy7IIY9/pnZxGNOE6+X16vbbasu4Xue0jbhK2OSkCV566SWsXbsWdXV1AICCggKXJerYyBa3z+eDGCld6EY4IAD84z4Ol51Fvv/YpWPgy/Bh/bUbAHTch3EiXJo74yC6O+9umg7+fDdHYWEhrrvuumhUR3p6uqvyyIorLa1jPnd795bi3kaPHh01kNzSd7+YwiEvm7zzLj8pQOeT89vMK7rjyPMGNjM3klJ8BUEoigt0zDvfJIl+NtlV4rbC9IocbtGrV6/ouXnza8nF0Obt1FamuAHETiRhNZ25NwK5meRXw5CHjseQh45HMEi3kDFtiO98nucfBzAOwD4A0wVB8EaQsQPIr6+yxe22wpQVt9uWvxfo10PKT5Hexp9hIlPcABQ+bsIVVfOmdwwnAtFR8jw/EkCxIAhnANgG4GdUpfIIiRb3wIFSxZSTTrKzptk+Hd3iVvLLi4FNr3LItmFleYGCn7J5EyVu+bjbCqR3/jgAn0Q+fwzgFwDeoiKRh0iM3x4wYIAnErzLCttNxT1v3rxoKgA38fk4jBjgthT2Kb63J8Y8z7sthifIHJGJ/jP7ui2GpyG98wsAyOtjqwAklRPhef4WALcAwMyZMzFlyhTCrujQ0tJi2W91/fXXIzs7G/X19aivr3dNjkRuvfVW9O7dGyUlZEuUacgwY8YMALDVDg057OKWDMf/cyDC9eFo314Zi0FvDADCoquy9H+tD2rSa1ATrHFNBi+cDwAoLi5W/Z5UcR8DEMkQgHwAFYkbCILwMoCXASAYDIpaAqSKYDCoOQh63HfffZ6QQ0lxcbGtQhM0ZKCBF+RwTYaELr0yFv2m9HNVBlkOL4yF2zLoQfqu+zWAcyOfzwfgjcoHDAaD0QEgUtyCIHwHoJTn+S8BDAfwHlWpGAwGg6EJ8eyWIAj30BSEwWAwGOZwPyyAwWAwGJZgipvBYDDaGExxMxgMRhuDKW4Gg8FoYzDFzWAwGG0MzgtLuBkMBoNhHmZxMxgMRhuDKW4Gg8FoYzDFzWAwGG0MprgZDAajjcEUN4PBYLQxmOJmMBiMNgZT3AwGg9HGsFX7iuf5fACfAjgBwFhBEDbzPP8bANMA1AK4URCEEp7nxwN4CkAIwBeCINzP8/xgAO8AGAqgqyAItS7JcRGAhwC0ANggCMKdLsgwEsCfIzJUA7hSEIS6VMqgaOM+AD8TBIG4jpbNsZgA4A0AuwGEBEE4J9UyRPa/ElIFJx+A+wVBWO3CWFwKQL4eBwB4ShCE51IsQyak+zQPQCuAqwVBKHVhLPIALASQC0Cwk53UghwTATwaOe4HBUFYyfN8NqTrswjAfwRBeIJUDjvYtbjrAUwF8C4A8DzfI/L3eABzIv8BwG8BXC8IwjgAY3ie7wXgRwBnAVhjUwa7cnwP4HRBEMYDKOJ5nlRh2ZFhiyAI4wRBOAvABgCXuiADeJ7PBXAiYd/U5ADwtiAIE0iVtl0ZInJcDOCciBxEStuuHIIgvB/pfwKkB9kHqZYBwAUANkeuzVcBzCCUwa4ctwBYLAjCRADZPM+PSYEcj0I6/skA/hD57iYASyP64mye510pk2NLcQuC0CIIQpniq74AfhAEQQTwDYAzIt9vAdCZ5/k0AH4A9YIg1AuCUGWnf0pyHBAEoTXyezOAsAsytCj2ywSwPdUyRL6/E8CLJH1TluMynue/5Hme6O2HggyTATQB+JTn+Td4ns9xSQ4AUcUSEARhvwsy7AKQHfm9AEA5iQwU5BgI4LvI798AODMFcqQJgnAs8vabxvN8V8QXSv8UwGmkctiBto97NwCe5/kApNJmchHhf0OqkrMdwNeCIByj3K9tOXiePxVAkSAI37ghA8/zk3me/xbABEg3S0pliLw+nmjTurQtBwABwBAA5wCYzPP8aBdk6A6gK4DzAKwGcDslGazKITMNdKtMWZFhJ4ATeJ7/AcAvASxySY4tAM6O/H4upIeI03I08Tzfh+f57gBGRPosgOTOBDQKpacCqopbEIRySL7aTyC9YmyL/PQMJLfI8ZAughNo9mtXDp7njwPwLIAb3JJBEISPBUE4GdIFO9MFGe4C8AKNfu3IIQhCrSAIzYIgNAP4EMDIVMsAqRj28ogF9j9I5fmoQHiP/AyR13oXZLgBwCpBEIYDmIuYGyHVcvwNwDCe5z+D5Ic+nAI57gTwCoCXAGyK9GlYKD0VUI8qEQTh9Yg/7H0AKyJfiwAqBUEII/7AHcOsHBG/7j8BzBQE4YhLMgQUu1VB8ZqcKhkADALwEM/zHwM4nuf5B2nJYEWOyCSUzHjQe/uwMhZfARgV+X0UgD20ZLAoByLWHrGbhIIMHGLukXJIyirlcgiC0CAIwnRBEOQi5f91Wg5BEDZE5ll+CaBEEIQaxBdKPxd05ugsYyuqBAB4nl8K6eIewvP8XyH5B4sA7Afwq8hmfwDwEc/zLZCeZmt5ni8A8C9IFtWHPM8/IQjCR6mWA1JESX8AL0bmJX8nCMIXKZbhpzzPz4J0wR4FcD1J/3ZkEARhjaINQRCER0hlsCMHgBk8z98CaSb/K0EQVqZaBkEQRJ7nD/I8vwKSr/saUhnsyBH5noqbxIYMWwG8zfP8zyD5m+1MTtrRF6MgvRWHAbwhCMJep+XgpQir8yEZUndEdv0bgIU8z08H8F9BEH60IwcpLK0rg8FgtDHYAhwGg8FoYzDFzWAwGG0MprgZDAajjcEUN4PBYLQxmOJmMBiMNobtcEAGw0vwPN8PgBwq1gSgDMBKAA/phZDxPJ8FKUfGPkEQXnVYTAbDFsziZrRXvoW0cOJzAFcD+Jrn+SKd7bMA/A7Ajc6LxmDYg1ncjPbKoYjl/CrP800AbgZwO8/zwyCteMuEtCLyQUEQ3oeUIwUAzuJ5XgQwD1J2uEcBXAUp0dKnAG5LSFDEYKQcZnEzOgLyilwewHpILhE5B/nrPM93AvBA5O+tkBT1u5FtfgMpZ8qzkPJY/CVFMjMYmjCLm9ER4BT/DgdwJYAMxe/9EEvVeUQQhH8CAM/zr0S+Uyb9Os85MRkMczDFzegInB/5txBSTorPADwJKf/EVACdIOWJUaMVwIWQqrEA7C2V4QGY4ma0V3rxPH8jpPSgN0BKyfkSpCou2ZBShp6u2L4aUgKjQTzPXwNgFaQMdHxk/88glbrqj5h1zmC4ArMeGO2VkwH8FdJE5CJIlUoWQkrhOwqSu2SZvHGkCtGfAHSObHcGgMci350BqTLQBQCIMkcyGDRh2QEZDAajjcEsbgaDwWhjMMXNYDAYbQymuBkMBqONwRQ3g8FgtDGY4mYwGIw2BlPcDAaD0cZgipvBYDDaGP8P8mTAlPfl6kUAAAAASUVORK5CYII=\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -189,21 +203,22 @@ }, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "MAPE: 300841486646235.06\n" ] }, { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -223,7 +238,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -241,27 +256,28 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": { "tags": [] }, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "MAPE: 23.280281955513267\n" ] }, { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -281,18 +297,19 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 14, "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -305,7 +322,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -486,7 +503,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.8.5-final" } }, "nbformat": 4, diff --git a/examples/NBEATS-examples.ipynb b/examples/NBEATS-examples.ipynb index cd5bea22d7..af41bcd21b 100644 --- a/examples/NBEATS-examples.ipynb +++ b/examples/NBEATS-examples.ipynb @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -45,18 +45,19 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 4, "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -74,7 +75,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -90,7 +91,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -110,28 +111,43 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 7, "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "d34d53b0566541ac8a47f536671e9096", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "6bf0206a57634333868c23352f3b3fea" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "Training loss: 0.0281, validation loss: 0.0326\n" + "\n" + ] + }, + { + "output_type": "error", + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: '/Users/leotaftiu8/Desktop/Darts/darts/examples/.darts/checkpoints/torch_model_run/checkpoint_85.pth.tar'", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m model_nbeats.fit(\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mtraining_series\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mval_training_series\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mval\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m )\n", + "\u001b[0;32m~/Desktop/Darts/darts/darts/utils/torch.py\u001b[0m in \u001b[0;36mdecorator\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 63\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mfork_rng\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 64\u001b[0m \u001b[0mmanual_seed\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_random_instance\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhigh\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mMAX_TORCH_SEED_VALUE\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 65\u001b[0;31m \u001b[0mdecorated\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 66\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mdecorator\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Desktop/Darts/darts/darts/models/nbeats.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 408\u001b[0m \u001b[0mtraining_series\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 409\u001b[0m \u001b[0mtraining_series\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_assert_univariate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 410\u001b[0;31m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/Desktop/Darts/darts/darts/utils/torch.py\u001b[0m in \u001b[0;36mdecorator\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 63\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mfork_rng\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 64\u001b[0m \u001b[0mmanual_seed\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_random_instance\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhigh\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mMAX_TORCH_SEED_VALUE\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 65\u001b[0;31m \u001b[0mdecorated\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 66\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mdecorator\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Desktop/Darts/darts/darts/models/torch_forecasting_model.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, training_series, target_series, val_training_series, val_target_series, verbose)\u001b[0m\n\u001b[1;32m 335\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 336\u001b[0m \u001b[0;31m# Train model\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 337\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_train\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_loader\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_loader\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtb_writer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 338\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 339\u001b[0m \u001b[0;31m# Close tensorboard writer\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Desktop/Darts/darts/darts/models/torch_forecasting_model.py\u001b[0m in \u001b[0;36m_train\u001b[0;34m(self, train_loader, val_loader, tb_writer, verbose)\u001b[0m\n\u001b[1;32m 460\u001b[0m \u001b[0mtb_writer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_scalar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"training/learning_rate\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_learning_rate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepoch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 461\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 462\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_save_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_get_checkpoint_folder\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwork_dir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepoch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 463\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 464\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mepoch\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnr_epochs_val_period\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Desktop/Darts/darts/darts/models/torch_forecasting_model.py\u001b[0m in \u001b[0;36m_save_model\u001b[0;34m(self, is_best, folder, epoch)\u001b[0m\n\u001b[1;32m 523\u001b[0m \u001b[0;31m# remove older files\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 524\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mchkpt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mchecklist\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 525\u001b[0;31m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mchkpt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 526\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mis_best\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 527\u001b[0m \u001b[0mbest_name\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfolder\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'model_best_{0}.pth.tar'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mepoch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/Users/leotaftiu8/Desktop/Darts/darts/examples/.darts/checkpoints/torch_model_run/checkpoint_85.pth.tar'" ] } ], @@ -145,56 +161,48 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 8, "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=96.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "5bcd6981cddd403ca373f430397570f2", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=97.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "034f544c47324cd5bf7c23c5d4ee1355" + } }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2020-10-21 14:20:30,883] WARNING | darts.timeseries | The inferred frequency does not match the value of the \"freq\" argument.\n" - ] + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stderr", "text": [ + "[2020-11-04 15:59:09,089] WARNING | darts.timeseries | The inferred frequency does not match the value of the \"freq\" argument.\n", "\n" ] }, { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} } ], "source": [ - "pred_series = model_nbeats.backtest(\n", + "pred_series = model_nbeats.historical_forecasts(\n", " series,\n", " start=pd.Timestamp('20170901'), \n", " forecast_horizon=7,\n", " stride=5,\n", " retrain=False,\n", " use_full_output_length=True,\n", + " last_points_only=True,\n", " verbose=True\n", ")\n", "display_forecast(pred_series, series['0'], '7 day', start_date=pd.Timestamp('20170901'))" @@ -209,17 +217,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 9, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "../aten/src/ATen/native/BinaryOps.cpp:81: UserWarning: Integer division of tensors using div or / is deprecated, and in a future release div will perform true division as in Python 3. Use true_divide or floor_divide (// in Python) instead.\n" - ] - } - ], + "outputs": [], "source": [ "model_nbeats = NBEATSModel(\n", " generic_architecture=False,\n", @@ -236,28 +236,26 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 10, "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "5f6aec7edc304458a29951354911e1da", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "a59efb366df24a2a8bda799b36298c57" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "Training loss: 0.0495, validation loss: 0.0468\n" + "Training loss: 0.0485, validation loss: 0.0466\n" ] } ], @@ -271,56 +269,48 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 11, "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=96.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "86e3d8ac2ed945cfaa42a42057ff1cf7", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=97.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "48ca03f7c4ba4f0d89108d8b22988217" + } }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2020-10-21 14:21:37,671] WARNING | darts.timeseries | The inferred frequency does not match the value of the \"freq\" argument.\n" - ] + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stderr", "text": [ + "[2020-11-04 15:59:38,082] WARNING | darts.timeseries | The inferred frequency does not match the value of the \"freq\" argument.\n", "\n" ] }, { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} } ], "source": [ - "pred_series = model_nbeats.backtest(\n", + "pred_series = model_nbeats.historical_forecasts(\n", " series,\n", " start=pd.Timestamp('20170901'), \n", " forecast_horizon=7,\n", " stride=5,\n", " retrain=False,\n", " use_full_output_length=True,\n", + " last_points_only=True,\n", " verbose=True\n", ")\n", "display_forecast(pred_series, series['0'], '7 day', start_date=pd.Timestamp('20170901'))" @@ -350,9 +340,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.8.5-final" } }, "nbformat": 4, "nbformat_minor": 4 -} +} \ No newline at end of file diff --git a/examples/RNN-examples.ipynb b/examples/RNN-examples.ipynb index 8a13cff0f2..8a6a1f472a 100644 --- a/examples/RNN-examples.ipynb +++ b/examples/RNN-examples.ipynb @@ -37,19 +37,7 @@ "metadata": { "tags": [] }, - "outputs": [ - { - "output_type": "error", - "ename": "ImportError", - "evalue": "cannot import name 'plot_acfy' from 'darts.utils.statistics' (/Users/leotaftiu8/Desktop/Darts/darts/darts/utils/statistics.py)", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mImportError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mdarts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodels\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mRNNModel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mExponentialSmoothing\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 16\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mdarts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmetrics\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mmape\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mdarts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mutils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstatistics\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mcheck_seasonality\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mplot_acfy\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 18\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 19\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mwarnings\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mImportError\u001b[0m: cannot import name 'plot_acfy' from 'darts.utils.statistics' (/Users/leotaftiu8/Desktop/Darts/darts/darts/utils/statistics.py)" - ] - } - ], + "outputs": [], "source": [ "import torch\n", "import torch.nn as nn\n", @@ -164,24 +152,22 @@ }, "outputs": [ { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=400.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "740ce6c3e7dd46bdaf9f217847fead52", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=400.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "89db9679837f4fef9f67a112a30c5fbb" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "Training loss: 0.0070, validation loss: 0.0171\n" + "\n" ] } ], @@ -203,14 +189,15 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -240,21 +227,22 @@ }, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "loading model_best_260.pth.tar\n" ] }, { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -267,7 +255,7 @@ "metadata": {}, "source": [ "### Backtesting\n", - "Let's backtest our `RNN` model, with a forecast horizon of 6 months:" + "Let's backtest our `RNN` model, to see how it performs at a forecast horizon of 6 months:" ] }, { @@ -278,31 +266,31 @@ }, "outputs": [ { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=18.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "15b81222fe274016a8bc56b26544162c", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=19.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "b7031f127239421ba35def51fbaf0ce9" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "\n" ] } ], "source": [ - "# Perform the actual backtest\n", - "backtest_series = my_model.backtest(series_transformed, start=pd.Timestamp('19590101'), \n", - " forecast_horizon=6, retrain=False, verbose=True)" + "backtest_series = my_model.historical_forecasts(series_transformed,\n", + " start=pd.Timestamp('19590101'),\n", + " forecast_horizon=6,\n", + " retrain=False,\n", + " verbose=True)" ] }, { @@ -313,21 +301,22 @@ }, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "MAPE: 6.21%\n" + "MAPE: 6.15%\n" ] }, { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -335,7 +324,7 @@ "series_transformed.plot(label='actual')\n", "backtest_series.plot(label='backtest')\n", "plt.legend()\n", - "plt.title('Backtest, starting Jan 1959, with a 6-months horizon');\n", + "plt.title('Backtest, starting Jan 1959, 6-months horizon');\n", "print('MAPE: {:.2f}%'.format(mape(transformer.inverse_transform(series_transformed), \n", " transformer.inverse_transform(backtest_series))))" ] @@ -376,24 +365,22 @@ }, "outputs": [ { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=1500.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "302d20b8ebe54b47b3781cce6831c30d", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=1500.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "6801cac6bed54802b5f9d7cc5e082c7b" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "Training loss: 0.0100, validation loss: 0.0814\n" + "\n" ] } ], @@ -423,40 +410,42 @@ }, "outputs": [ { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=18.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "578b36f08c994b0abdcb39690249422c", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=19.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "8656dfce8ec84d54b14593e8890765c8" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "\n" ] }, { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ - "backtest_series = my_model_gru.backtest(series_transformed, start=pd.Timestamp('19590101'), \n", - " forecast_horizon=6, retrain=False, verbose=True)\n", + "backtest_series = my_model_gru.historical_forecasts(series_transformed,\n", + " start=pd.Timestamp('19590101'),\n", + " forecast_horizon=6,\n", + " retrain=False,\n", + " verbose=True)\n", "series_transformed.plot()\n", "backtest_series.plot()" ] @@ -475,24 +464,25 @@ "metadata": {}, "outputs": [ { + "output_type": "execute_result", "data": { "text/plain": [ "(True, 125)" ] }, - "execution_count": 15, "metadata": {}, - "output_type": "execute_result" + "execution_count": 15 }, { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -509,14 +499,15 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -558,22 +549,20 @@ }, "outputs": [ { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "7552c7082a204ca091d39a874c8575b7", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "415bc35c3ed8413695b9cd078e04089d" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "Training loss: 0.0201, validation loss: 0.0352\n" ] @@ -612,43 +601,39 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=49.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "72ca7d1c8a1548bf885c508cf2961522", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=49.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "421007f08fe74588b59bf4e06f9f58ee" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "\n" ] }, { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=49.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "9d56135cff24454ba7b88d888b09115e", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=49.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "676489e0052c425387b6d1c181b39478" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "\n" ] @@ -656,11 +641,21 @@ ], "source": [ "# Compute the backtest predictions with the two models\n", - "pred_series = my_model_sun.backtest(series_sp_transformed, start=pd.Timestamp('19401001'), \n", - " forecast_horizon=36, stride=10, retrain=False, verbose=True,\n", - " use_full_output_length=True)\n", - "pred_series_ets = ExponentialSmoothing().backtest(series_sp_transformed, start=pd.Timestamp('19401001'), \n", - " forecast_horizon=36, stride=10, retrain=True, verbose=True)" + "pred_series = my_model_sun.historical_forecasts(series_sp_transformed,\n", + " start=pd.Timestamp('19401001'), \n", + " forecast_horizon=36,\n", + " stride=10,\n", + " use_full_output_length=True,\n", + " retrain=False,\n", + " last_points_only=True,\n", + " verbose=True)\n", + "pred_series_ets = ExponentialSmoothing().historical_forecasts(series_sp_transformed,\n", + " start=pd.Timestamp('19401001'), \n", + " forecast_horizon=36,\n", + " stride=10,\n", + " retrain=True,\n", + " last_points_only=True,\n", + " verbose=True)" ] }, { @@ -669,22 +664,22 @@ "metadata": {}, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "RNN MAPE: 104.43718984613852\n", - "ETS MAPE: 593.7634916506821\n" + "RNN MAPE: 104.43718984613852\nETS MAPE: 593.7634916506821\n" ] }, { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ diff --git a/examples/TCN-examples.ipynb b/examples/TCN-examples.ipynb index 3698e4cc64..1694212063 100644 --- a/examples/TCN-examples.ipynb +++ b/examples/TCN-examples.ipynb @@ -114,10 +114,11 @@ "metadata": {}, "outputs": [ { - "name": "stderr", "output_type": "stream", + "name": "stderr", "text": [ - "[2020-09-28 09:40:01,456] INFO | darts.models.tcn_model | Number of layers chosen: 2\n" + "[2020-11-09 10:53:09,141] INFO | darts.models.tcn_model | Number of layers chosen: 2\n", + "[2020-11-09 10:53:09,141] INFO | darts.models.tcn_model | Number of layers chosen: 2\n" ] } ], @@ -142,24 +143,22 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=1000.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "48d425646638442bbd1136dadde1dfef", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "34de7d56a52e44a8b855e303bb48471e" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "Training loss: 0.0023, validation loss: 0.0157\n" + "\n" ] } ], @@ -179,18 +178,19 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ - "pred_series = model_air.backtest(\n", + "pred_series = model_air.historical_forecasts(\n", " ts_transformed,\n", " target_series=ts_transformed['0'],\n", " start=pd.Timestamp('19580801'), \n", @@ -229,10 +229,11 @@ "metadata": {}, "outputs": [ { - "name": "stderr", "output_type": "stream", + "name": "stderr", "text": [ - "[2020-09-28 09:40:23,532] INFO | darts.models.tcn_model | Number of layers chosen: 6\n" + "[2020-11-09 10:53:45,584] INFO | darts.models.tcn_model | Number of layers chosen: 6\n", + "[2020-11-09 10:53:45,584] INFO | darts.models.tcn_model | Number of layers chosen: 6\n" ] } ], @@ -258,22 +259,20 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=10.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "391b9798f5204c3fa85f2574275dad5b", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=10.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "c26137b284df4d53aebe5c885626775a" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "Training loss: 0.0282, validation loss: 0.0499\n" ] @@ -295,47 +294,40 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=81.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "9c0bc0338fb44a608f6c2461c34f6a18", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=81.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "7214c921a1524b94bec2fb944577816f" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2020-09-28 09:40:40,376] WARNING | darts.timeseries | The inferred frequency does not match the value of the \"freq\" argument.\n", - "[2020-09-28 09:40:40,443] WARNING | darts.timeseries | The inferred frequency does not match the value of the \"freq\" argument.\n" - ] - }, - { - "name": "stdout", "output_type": "stream", + "name": "stderr", "text": [ + "[2020-11-09 10:54:13,063] WARNING | darts.timeseries | The inferred frequency does not match the value of the \"freq\" argument.\n", + "[2020-11-09 10:54:13,149] WARNING | darts.timeseries | The inferred frequency does not match the value of the \"freq\" argument.\n", "\n" ] }, { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ - "pred_series = model_sun.backtest(\n", + "pred_series = model_sun.historical_forecasts(\n", " training_series=series_sp_transformed,\n", " target_series=series_sp_transformed['0'],\n", " start=pd.Timestamp('19401001'), \n", @@ -361,14 +353,15 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -397,10 +390,11 @@ "metadata": {}, "outputs": [ { - "name": "stderr", "output_type": "stream", + "name": "stderr", "text": [ - "[2020-09-28 09:40:41,451] INFO | darts.models.tcn_model | Number of layers chosen: 5\n" + "[2020-11-09 10:54:15,665] INFO | darts.models.tcn_model | Number of layers chosen: 5\n", + "[2020-11-09 10:54:15,665] INFO | darts.models.tcn_model | Number of layers chosen: 5\n" ] } ], @@ -426,22 +420,20 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=20.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "aedc701826fa48d586f4864ab58c4be6", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=20.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "ac003f13a2d8492b939651adc5a00a65" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "Training loss: 0.0234, validation loss: 0.0327\n" ] @@ -463,46 +455,39 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=96.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "a661ffa17c2e48ab968e064a47a113b9", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=97.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "1dcd97aeb6f04823a88fd350317279e3" + } }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2020-09-28 09:40:54,224] WARNING | darts.timeseries | The inferred frequency does not match the value of the \"freq\" argument.\n" - ] + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stderr", "text": [ + "[2020-11-09 10:54:34,711] WARNING | darts.timeseries | The inferred frequency does not match the value of the \"freq\" argument.\n", "\n" ] }, { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ - "pred_series = model_en.backtest(\n", + "pred_series = model_en.historical_forecasts(\n", " series_en_transformed,\n", " start=pd.Timestamp('20170901'), \n", " forecast_horizon=7,\n", @@ -531,7 +516,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.8.5-final" } }, "nbformat": 4, diff --git a/examples/Transformer-examples.ipynb b/examples/Transformer-examples.ipynb index 41b801f17f..a6dd641d19 100644 --- a/examples/Transformer-examples.ipynb +++ b/examples/Transformer-examples.ipynb @@ -37,15 +37,7 @@ "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Importing plotly failed. Interactive plots will not work.\n" - ] - } - ], + "outputs": [], "source": [ "import torch\n", "import torch.nn as nn\n", @@ -112,14 +104,14 @@ "metadata": {}, "outputs": [ { + "output_type": "execute_result", "data": { "text/plain": [ "\"the 'air passengers' dataset has 144 data points\"" ] }, - "execution_count": 5, "metadata": {}, - "output_type": "execute_result" + "execution_count": 5 } ], "source": [ @@ -182,31 +174,29 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 7, "metadata": { "scrolled": false, "tags": [] }, "outputs": [ { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=1000.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "0a7a135958144457bac4ed587cce27f8", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=1000.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "37342ac7a07949c68ce125f7cb622966" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "Training loss: 0.0109, validation loss: 0.0274\n" + "\n" ] } ], @@ -230,18 +220,19 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 8, "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -266,27 +257,28 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 9, "metadata": { "tags": [] }, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "loading model_best_600.pth.tar\n" + "loading model_best_360.pth.tar\n" ] }, { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -298,72 +290,70 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let's backtest our `Transformer` model, with a forecast horizon of 6 months:" + "Let's backtest our `Transformer` model to evaluates its performance at a forecast horizon of 6 months:" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 10, "metadata": { "tags": [] }, "outputs": [ { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=18.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "efb1ae23f7a449e9bd0ae4d90ea44a71", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=19.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "662c549f7f664f6b9a47f47b7cdd9e80" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "\n" ] } ], "source": [ - "# Perform the actual backtest\n", - "backtest_series = my_model.backtest(training_series = series_scaled,\n", - " start = pd.Timestamp('19590101'), \n", - " forecast_horizon = 6,\n", - " use_full_output_length = False,\n", - " retrain = False,\n", - " verbose = True)" + "backtest_series = my_model.historical_forecasts(training_series = series_scaled,\n", + " start = pd.Timestamp('19590101'), \n", + " forecast_horizon = 6,\n", + " use_full_output_length = False,\n", + " retrain = False,\n", + " verbose = True)" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 11, "metadata": { "scrolled": true, "tags": [] }, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "MAPE: 12.24%\n" + "MAPE: 6.31%\n" ] }, { + "output_type": "display_data", "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeEAAAFJCAYAAACsBZWNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeXxTZdr4/0+27ntLC4WyyjoMFRDKjshaKKCouAyK4OhXUHlgVBAcF4RxHQcdUX4zqCgogoyDCIpYELSAyKqyCAxQCy1l6b63SZPfH+Ec0jZtk7RJWK736/W8Hklyzrl70ul1rnu5bk1eXp4FIYQQQnic1tsNEEIIIa5XEoSFEEIIL5EgLIQQQniJBGEhhBDCSyQICyGEEF4iQVgIIYTwEgnCV7m0tDQiIiIYMGAAAwYMoF+/fgwdOpRdu3a5fM5p06bx9ttv13h9//79zJo1y+Xz/v7779x3330uHw9w2223kZ2d3aDj7rzzTo4ePdqgdtjzySefcNdddzX6eVesWFHlvBaLhYULF9KjRw8GDBjAE088QVlZGQD5+fnExMSovw8DBgzghx9+AOCHH35g0KBB9OvXj6SkJA4ePNgo7bO9n7b3+Y9//CMHDhxolGsAlJaW8tRTTzFw4EB69uzJP//5z0Y7tzOWL1/Oe++9B8DLL7/MU0895fK5Gno8wIEDB7j//vsbdA7hPXpvN0A0nL+/P9u3b1f/vXbtWqZPn87+/fsb9Tq//fYbZ8+edfn4M2fOcOLEiQa1YevWrQ0+bs2aNQ1qg6fk5uby4osvsnr1agYOHKi+/sknn/DNN9/w3XffERYWxmuvvcbChQtZuHAhe/fupV+/fqxdu7bKufLz87nvvvtYvnw5gwcP5vjx49x7773s2LEDX1/fBrXT9n66+v044vnnnyc3N5dt27ZRVFTEgAED6Nu3L7169XLbNe358ccf6dKli0evWZfu3buzfPlybzdDuEgy4WtQTk4OMTExAJjNZubMmcPQoUNJSEigd+/eapZcVFTE9OnT6dmzJwkJCbz44otYLFVrt8ybN49x48aRnp7Oyy+/zI8//sj06dMB2LhxI0OHDmXgwIGMHDmS3bt3A3D8+HFGjhzJ4MGDGTRoEO+99x6VlZXMmDGD1NRUJkyYUGf7i4qKmDx5MgMGDGDQoEHMmDEDs9msXnfs2LGkp6fzzTffMGLECG6++Wa6du3KwoULAUhJSaF///6MGDGC/v371zhOydBSUlIYOXIkDz/8MAMHDiQhIUHNGrOysrjrrrvo3bs3o0aN4v777+fll192+Ds4ceIEt956K8OHD6dr167cc889arYaExPDyy+/zMiRI+nWrRvvvvuu3XOsXbuWmJgYFixYUOX1X375hTFjxhAWFqb+XOvWrQPgp59+Ijc3l1GjRjFw4EDef/99AE6dOkVISAiDBw8GoEOHDgQHB6vfmT05OTnExsZSXFwMwKxZs0hMTFTf79GjB0ePHlXvZ/X7DLBs2TL1+6n+cyhq+x5tWSwWVq9ezbx589DpdISGhrJ+/Xrat29f47NpaWnEx8fz+OOP06dPH3r27MnXX3/NxIkTufHGG5kyZQpmsxmADRs2MHDgQPr168eoUaPYt28fYM1Qp02bxoQJE+jVqxeJiYlkZmayfv16Nm7cyLvvvsvSpUsB6+97UlISvXr1YvTo0Zw7dw6A999/n/79+zNkyBASExNr7X2p7fjffvuNpKQk+vXrR//+/fn000+Bmr/fW7ZsoW/fvgBMmDBB7QHp3r074eHhnDx5kvz8fB5++GH69u1Lv379eO655zCZTIDjv4/CPSQIXwNKS0vV/+F17dqVp59+mr/85S8A7N27l3PnzpGcnMxPP/3EPffcw6JFiwB46aWXKC8vZ/fu3aSkpLBr1y41o7ZYLDz55JOcPn2aNWvW0KJFC+bOnUvfvn159913OXnyJAsWLGDNmjWkpKTw5ptvct9991FcXMw///lPRo0axffff8+aNWvYuXMnGo2Gf/7zn7Rp04b//ve/df48GzZsoKioiO3bt6uZ1e+//67+cVi/fj3Nmzdn8eLFLFmyhG3btpGcnMyiRYvUrtDffvuN9957jx07dlQ5rkWLFlWutXfvXh577DFSUlKYNGkSr7zyCgBz5syhU6dO7N69mw8//LDOYGXPRx99xD333ENycjIHDhwgLS2NTZs2AVBeXk5kZCSbNm1i+fLlzJ8/Xw3QtqZOncrTTz+Nn59fldd79uzJxo0byc7Oxmw2s2rVKs6fPw+AXq9n1KhRfPXVV6xevZp3332XDRs20K5dO4qLi/nuu+8A69DC0aNH1ePsiYiIoGfPnqSkpADWP/4nT56kqKiIo0ePYjAY6NSpk/p5e/fZ19eXbdu2sWXLFhYvXqwGZ4XFYqnze1RkZWVRVFTEtm3bGDNmDAMGDGDjxo3qg0h1aWlpJCYmsmvXLgYPHszTTz/Ne++9x65du/jxxx/Zs2cPx48f5y9/+QsrVqxg586dzJ07l3vvvZeCggLAmvF++OGH7Nmzh9DQUJYtW8bYsWNJTExk+vTpPPTQQ4D1d1P5XFhYGMuXL6eyspK5c+fy+eefs3XrViZPnlzrEJG9400mE/fccw8PP/wwO3fu5D//+Q8LFixQfw9tf799fHzUc/33v/9l+/btbNmyhWbNmvH888/Trl075syZQ3h4ODt37mTr1q0cOnRIHXJy9PdRuId0R18DqndH//TTT9x555388MMP9O7dm/DwcJYtW0Zqairbt28nKCgIgG3btvHSSy+h0+nQ6XR8/fXXAKxcuZJ33nmHixcvkpKSYre7cuvWrZw7d45x48apr2m1Wk6dOkVSUhKPPPII+/bt4+abb+bVV19Fq3X8ea9Pnz4sWLCAMWPGMGTIEKZNm0bbtm2rfEaj0bBq1So2bdrEmjVrOH78OBaLRc3amjdvTsuWLeu9VlxcHN26dQMgPj5ezTaSk5P5/vvvAWjatGmVn9MR8+fPZ+vWrbz11lucOHGCc+fOqW0DGD16tHrN8vJySkpKagTb2tx9992cPXuWsWPHEhgYyOTJk9U/xLNnz1Y/FxsbywMPPMCGDRtISkpi5cqVLFiwgGeffZZ+/foxaNAgDAZDnddKSkpi8+bNtG3blmbNmtG5c2d27NjB4cOHGTt2bL1tvfPOOwFrttWkSROysrKqPAjV9T1GRkaqnzMajVRWVpKamsr69evJysoiKSmJuLg4kpKSalzXYDCoWXubNm1ISEggJCQEsH6fubm5HDx4kMGDB9O6dWsABg8eTFRUFD///DMAAwYMUI/p1q0bubm5dn/GIUOGEBUVBUDXrl25ePEiOp2OW2+9lREjRjBy5EiGDBmi3gtHjj9x4gTl5eXq712zZs0YO3YsmzdvZuDAgXX+fpvNZh5++GE6duzIzJkzAdi8eTObNm1Co9Hg6+vLlClTWLJkiTrHoyG/j6JhJBO+BiUkJHDDDTewf/9+Nm3axMSJEwHr/9CmTp2qdjnr9Xo0Go16XHp6Ojk5OQD079+fl19+menTp2M0Gmtco7KyksGDB7N9+3b1/5KTk+nSpQujRo1i//793Hbbbfz666/069eP1NRUh9vfunVr9u/fz1/+8hcKCwu59dZb1e5WRXFxMYMGDeKXX34hPj6eF198EYPBoP5syoNGffz9/dX/1mg06vE6na5K17xOp7N7/BdffEFJSQlgzer0eutz7YMPPsiHH35IXFwc06dPJz4+vsr5lOsq97/6MEBdcnNzueOOO9i5cyfJycl06tSJNm3aAPCvf/2LM2fOVPm8wWDAbDYTGBjIV199xY4dO3j99ddJTU2t8XBTXVJSEsnJyWzZsoUhQ4YwZMgQvvvuOzZu3OjQg4ltkLe9v4r6vkdFVFQUBoOBu+66C61WS3R0NCNHjmTPnj188MEHak/Q448/DoCPj0+V323le7GldEnbslgsajdt9d8NR39Gxb///W9WrVpFmzZteOutt5g0aZLDx9trm9lsVttW1+/3nDlzKCkp4e9//3uVY2s7FzTs91E0jATha9CJEyc4ceIE3bp1Y+vWrYwaNYoHH3yQHj168NVXX6n/g7z55ptZuXIlZrOZ8vJyJk+erGbU3bt35+GHHyY0NFTtotXr9WpAHjRoEN999x3Hjx8H4Ntvv6V///6UlZXx5z//mf/+97/cfvvtvPHGGwQHB5Oenl7l+Lq8//77PProo9xyyy3Mnz+fW265hSNHjgDWYGg0Gjl58iSFhYX89a9/JTExkR07dlBeXm73j5ftcY4aMWIEK1asAKxjoxs2bLD7h/iFF15gz549gHWsVgmGW7ZsYfbs2UyYMAGNRsO+ffuorKx0+Pp1OXDgAJMmTcJoNGIymfjHP/6hPmjt2rVLnTWcm5vLihUr1DZMnDhRna38xRdfoNfr6dq1a53Xat68OZGRkSxbtoxbbrmFW265hfXr15OTk6P2INhy9j47+j36+PgwatQoVq1aBVjnDWzdupUePXowdepU9UHQ3qz+2ii/w7///jsA33//Penp6fTs2bPO4xz5Pc7OzuYPf/gDERERTJ8+nWeeeYZDhw453Lb27dtjMBj48ssvAdTx6JtvvrnO4xYtWsSePXtYtmxZlQfHoUOHsnTpUiwWC+Xl5Xz00Uf1nkt4hnRHXwOUMWGF2Wzmrbfe4oYbbmDq1Kn8+c9/pl+/fuh0Ovr168f69evVCVtPP/00AwYMoLKykttuu41x48axceNGwPpUvHjxYgYOHMiIESPo3bs3CxYs4E9/+hOffPIJb731lppZ6/V6Pv30UwIDA3nqqaeYMWOG+ocgKSmJAQMGkJ+fj06n45ZbbmHLli3MmDGD7t27M3Xq1Co/z91338327dtJSEggICCAFi1aMG3aNMA66WfUqFF8/PHHjBw5kl69ehEaGkrbtm3p1KkTp06dqjJGplCOW7lypUP39OWXX+bxxx+nX79+hIeHExcXR0BAQI3PvfHGG8ydO5eKigqaN2+uLl157rnnmDRpEuHh4fj7+zvdG1CXW265hR07dtC/f3/MZjNjxoxRJ0W9/vrrzJw5kz59+mA0GnnooYcYMmQIAEuXLmXGjBkYjUZiYmJYuXKl+mAxYMAA3n77bbp3717jeklJSSxevJhu3bqh1Wrx8/Oz2wUMzt/nrl271vo9Kg80in/+85/MmTOHhIQEKisrueOOOxg/frzD9626Tp068cYbbzBp0iQqKyvx9/dn1apVhIaG1nncsGHDqnT72xMZGcmTTz7J+PHj8fPzQ6/XO/WAYDAY+OSTT5gzZw6vvPIKlZWVzJ49m0GDBqlj9NVlZmYyf/58OnTowOjRo9UHmXnz5vHqq68ye/Zs+vXrR0VFBUOHDuXJJ590uD3CfTSylaHwlq1bt3LkyBEeffRRbzelhvfee49u3brRu3dvysvLSUxMZO7cuQwfPtzbTXOLBQsWMG7cOOLj473dFCGuK5IJC6/JyclpcPEOd+nYsSOzZ8+msrISo9HI+PHjr9kAbLFYaNmypQRgIbxAMmEhhBDCS2RilhBCCOElEoSFEEIIL5EgLIQQQniJx4NwUVGRpy951ZJ75Ti5V46Te+U4uVeOk3vlGo8HYanE4ji5V46Te+U4uVeOk3vlOLlXrpHuaCGEEMJLJAgLIYQQXiJBWAghhPASCcJCCCGEl0gQFkIIIbxEgrAQQgjhJRKEhRBCCC+RIOykw4cPs2PHDqePmzZtGps3b3ZDi4QQQlytJAg76csvv+TYsWPeboYQQohrgOwnfElBQQEzZswgPz+fc+fO8ec//5n4+Hjmzp2L2WymWbNmvPbaa6xcuRIfHx/i4+N54IEH2LNnD35+frzwwgu0b9+eu+++m5kzZ5KRkcG5c+cYPXo0f/3rX7394wkhhHDR6tWrMZvN3HPPPY1+7isuCIeFhbnlvHl5eXW+f+rUKSZMmMC4cePIzMxkzJgxBAQE8P7779OxY0eWL1/OhQsXuPfee4mJiaFnz552z5Oenk6vXr14++23KSsro0uXLhKEhRDiKlVRUcGjjz6KyWQiISGBtm3bNur5r7gg7C3R0dEsWbKEDRs2EBwcjNFo5MKFC3Ts2BGA+++/H4CNGzfaPV6pmxoeHs7+/ftJSUkhODiYiooKz/wAQgghGl1OTg4mkwmADz/8kBdffLFRz3/FBeH6MlZ3Wbx4Mb179+bBBx/khx9+YNOmTTRt2pSTJ0/Srl073nzzTdq1a4dWq8VsNgPg5+fHuXPnaNWqFQcPHqRDhw6sXLmS0NBQ3nzzTU6dOsWHH34ohc2FEOIqlZ2drf73xx9/zLx58/Dz82u0819xQdhbRo0axZw5c/j8888JDQ1Fr9fzj3/8g8ceewyNRkPTpk2ZNm0aPj4+PPfcc3To0IEZM2YwceJEWrZsqXajDx48mD//+c/s3r0bX19f2rVrR2Zmppd/OiGEEK7Iycmp8t/r1q3jrrvuarTza/Ly8jyaphUWFhIcHOzJS1615F45Tu6V4+ReOU7uleOu1Xu1bt06Jk+ejI+PDxUVFfTp04dvvvmm0c4vS5SEEEKIWuTm5gIwduxYgoOD2bVrF4cPH26080sQFkIIIWqhjAnHxcVx9913A/DBBx802vklCAshhBC1UMaEIyIimDJlCmBdN1xaWtoo55cgLIQQQtRCCcLh4eF06dKFVq1aUVRUREZGRqOcX4KwEEIIUQvbTNj2/zfWcloJwkIIIUQtlCAcGRkJXK7qKEG4kX3yySe88MILLh2bkpLC1KlTa7z+73//2+lzubpLkxBCiMZXPROWIHwV+fvf/+70MbJLkxBCXDncHYSlYpaN3bt3M27cOAoLC3n66acpKytj6dKlmEwmNBoNH3/8MREREcyePZt9+/ZRUVHB3LlzCQkJAaCkpIT777+fiRMncvr0aXJzc3niiSd45ZVXmDVrFidPnsRisfDMM88wcOBAFixYQEpKCiaTiXHjxjFx4sQquzR16NDBy3dECCGuX5WVlWqwVYLvNR+Ew8a6p+JK3vrCej8TGBjIZ599RlZWFkOHDmXy5Ml89tlnBAQEMHPmTLZs2YK/vz/Z2dl899135OXlsXjxYgYPHkxxcTF33303jzzyCKNHjwas3dFvvPEG77//PpGRkSxevJicnBxGjx7Nrl27+Oyzz9iwYQNNmzZl5cqVxMbGVtmlqbCw/jYLIYRwj7y8PCwWC2FhYej11nDple7ovXv3MmbMmBqv/+c//2Ho0KGMHDmSWbNmqRsbXK369OmDRqOhSZMmhISEYDAYmDZtGtOnT+fw4cMYjUZOnDhBr169AOuXoWxTuGPHDsrKyuzumnTkyBGSk5MZM2YM9913HyaTiezsbJYuXcr8+fOZMGEC+fn5Hv1ZhRBC1K16VzRYlyrB5UpaDVVvJvzWW2+xevVqAgICqrxeWlrKwoUL2blzJwEBATz44IN88803ahboKkcyVnfZv38/AOfPn6egoIAlS5Zw6NAhAG699VYsFgsdOnRg3bp1AOTn5zNlyhRmzZrFiBEjeOWVV0hMTCQhIYFmzZqpuye1b9+e2NhYnnjiCUpLS3njjTcICgriiy++4P333wcgISGBCRMmVNmlSQghhPfYC8KhoaGABzPh1q1bs2LFihqv+/r68u2336rB2WQyNer2Tt5QVlbG2LFjueeee3j77bdJSEhg+PDhJCYm4u/vz7lz5xg9ejShoaGMGjWK22+/nWnTpqnHR0dHM3fuXB599FEsFgsdO3bk4YcfZsqUKRw/fpzRo0czYsQI4uLi8PX1JTw8nGHDhpGUlMSQIUOIi4vjxhtvZOnSpfzwww9evBNCCCGUkpW2Qbixu6Md2kUpLS2NBx98kM2bN9t9/1//+hfJycmsWbMGjUZT57mysrLw9fV1rbXXmbKysqv+wcZT5F45Tu6V4+ReOe5avFerV6/mySef5I477mDRokUAHDp0iMTERDp37sy3337r8Llq22GqQROzzGYzzz33HCdOnGD58uX1BmCwZtDX4nZX7iL3ynFyrxwn98pxcq8cd63dK6U+dHR0tPqzxcbGAo23dWODgvDMmTPx9fVl5cqVaLWy5FgIIcS1w96YsNeXKK1Zs4bi4mJuvPFGVqxYQd++fRk7diwAjzzyiPrfQgghxNXM3phwcHAwWq2WoqIijEYjBoOhQddwKAi3atVKHQ++88471dcba4q2EEIIcaWpXjcaQKvVEhoaSm5uLvn5+URFRTXoGtKHLIQQQthhu42hrcbskpYgLIQQQtih9PbadkfD5SDcGL3BEoSFEEIIO+yNCcPlzFgyYSGEEMINLBaL3dnRIN3RQgghhFsVFhZiMpkIDAysUYREgrAQQgjhRrVNygIJwkIIIa5xxcXFLFq0iP/9739euX5tXdEgQVgIIcQ1bv78+cyfP5/XX3/dK9e3t0ZYIUFYCCHENevQoUO89957AFy4cMErbagrE27M7QwlCAshhLhiWCwWnnrqKXVf9caq0ews6Y4WQghx3VmzZg0//vijOiPZW+WRa1sjDBKEhRBCXIMKCgp49tlnAXjmmWcA72XCtVXLAgnCQgghrkGrVq3i/Pnz3HTTTUybNg2A/Px8KisrPd4W6Y4WQghxXTl9+jQAY8eORa/XqxOgCgoKPN6WuoJwSEgIOp2O4uJijEZjg64jQVgIIcQV4eLFiwDq9oCNuVGCs5QxYXtLlDQaTaPNkJYgLIQQ4oqQlZUFQJMmTYDG7fZ1lhL47VXMgsZrmwRhIYQQVwQlE1aCsBIAvZEJ19UdDRKEhRBCXGOUTLh6d7SnM+HS0lJKSkowGAwEBQXZ/YwEYSGEENcMi8VSY0y4MfftdYZtFqzRaOx+RoKwEEKIa0Z+fj5Go5Hg4GD8/f0B703MUkplRkdH1/oZCcJCCCGuGdW7osF7mfDZs2cBiI2NrfUzjfWAIEFYCCGE1ynZpzIpC7yXCWdmZgLQtGnTWj8jmbAQQohrRvXxYGjc3Yqcce7cOQCaNWtW62ckCAshhLhmVF8jDN5boqR0R0sQFkIIcV2ovkYYvLdESTJhIYQQ15W6MuH8/HyPtkUZE5YgLIQQ4rpQVyZ8JXdHN/QBQYKwEEIIr7M3MSsoKAi9Xk9JSQnl5eUeaUdJSQn5+fkYDAa7mzcoJBMWQghxzbDXHa3RaDw+LqyMBzdt2rTWalkAwcHBjbKdoQRhIYQQXmevOxo8PzlLGQ+uq1AHNN52hg4F4b179zJmzJgar2/cuJEhQ4YwfPhwPvroI5cbIYQQ4vplNBrJzc1Fq9XW2DrQ08uUHJmUpWiMMWt9fR946623WL16NQEBAVVeNxqNzJs3j61btxIQEMDIkSNJTEyss9amEEIIUV12djYAkZGR6HS6Ku95KxOuq1qWojEeEOrNhFu3bs2KFStqvH7s2DHatm1LWFgYPj4+9OnTh507d7rcECGEEN7x3nvvMWXKlAaNbTZEbV3R4Pn60Y52RwM0b94cgNOnT7t8vXoz4fHjx5OWllbj9cLCQkJCQtR/BwUFUVBQUO8FPTXD7VpQVlbm7SZcNeReOU7uleOuh3t17tw55s2bR0VFBVOmTKF79+4unach90oJYqHh0azYZOJCrpbCUi1GE5j0rdV2FhYWunwNZ9sSFhZm93qfbg0g9ZyOOXcV0qJFCwCOHj1ab9uCg4Ptvl5vEK7rhEVFReq/i4qK1EHquvj6+tbaGFGT3CvHyb1ynNwrx13r9+r111+noqICgIqKigb9vK4eW1xcDEBJyL08vrjqmHCXqInAa5SWlnrku1C6xtu0aVPjenlF8NdlQVSYNAztqaNjx44AZGRkuNw2l2dHd+zYkZMnT5Kbm0tFRQU7d+6kV69erp5OCCGEh+Xl5bFs2bIq//YGpTu6XG8NakNuNDHxZmvXeJnFsxOz6trG8KtdeipM1mVLK5INtGnTBoDU1FSXr+d0JrxmzRqKi4t54IEH+Nvf/saECRMwm81MmjTJoT50IYQQV4YPPvigSjeqp8tDKpQ1wmVYZyRPG19BdJiFz7YZqKgMAjzzgGCxWKqsE67u8x8M6n9//ZOeJ8a3BzwQhFu1asXmzZsBuPPOO9XXExMTSUxMdPniQgghvKO0tJQlS5YAcOONN/Lzzz97PRMuNFqrZbVpasbnUrwrMVpX5niibbm5uZSXlxMSEkJgYGDVNuZp+P4XHXqdhZs6VLLrNz3fH43D19eXCxcuUFhY6FKXtBTrEEKI69DKlSu5ePEi3bp149ZbbwW8lwlfvHgRNHpyS4LRaCzERVuICLYAUFzuC3gmCNfVFb1uh55Ks4ah3St57DZrV/nHyT60at0acD0bliAshBDXoX/9618AzJo1y2tbBiqysrLAtyVmi5bYSAt+PhDkDwa9hXKTDrR+HhkTrrMrOsXacTxhkJGRvUxEh5k5dkZHeEtrb7AEYSGEEA4pLy/n+PHjaLVakpKS1JUtXs2E/doC0LqpGQCNBjUbRh/p0Uy4erWs9Isafjysx8/HwugEEwY93DPUmg3n+90OSBAWQgjhINuCFAaDwauZsMViqRaELep7ahA2WIOwxWKxd4pGo2TC1YPw2u3WLHhkLxPBl4pH3jfcGoRPFd4EuiBOnTrl0jUlCAshxHXmzJkzAGqxicbYiMBVxcXFlJaWogvqAFzOhAHCLwVhn8BYjEajup7YXWqrG63Mir59kEl97YbmFm68oZKKSh8IukkyYSGEEI7JyMgALgfhxtqg3hXK8iSfEOsa4TY2QTgixBqEA0Ks7XT3Q4K97uiyCvj5hA6D3sKIm0xVPt886lJb9REShIUQQjgmPT0duFz72Jvd0crypOpjwnC5O9ov2NpOd0/OstcdnV1gLc4RFWKdMGZLydQ1PpFkZGS4VLpTgrAQQlxnlCCsZMLKPgAFBQWYzeZaj3MHJQgbdXGA/TFhg791trK7HxLsdUcrQVjJym1FXFoWHNakLRaLxe4+C/WRICyEENeZ6kFYr9cTHByM2Wz2yCYJtrKyskAfgYlAgv0tRNoEOyXw6fysW+S6MxM2Go1cvHgRrVZbZUvenEtBONJOEA4Psr4WHN4KwKXJWRKEhRDiOtw3VY8AACAASURBVFM9CANeW6ZkOzO6VVMzGs3l99TuXkMk4N5M+Pz581gsFqKjo9HrLxeTzK4rCF9qn3+wtbiHK+PCEoSFEOI6YrFY1CAcFxenvu6tGdIXL14E/3ZA1fFguNzda9ZZN3Fw5wPCyZMngZozox0JwvpLmboEYSGEEHXKz8+nqKiIoKCgKtvPeisIZ2RkgJ91N6LWMVUDnTImbMLaNnd1R5vNZl566SUABg4cWOW9usaEwy51R1t01olt0h0thBBXqIsXL/Lxxx/z2GOPkZKS4rV22K4R1tj0/XprmdLp06fV7ug2zaplwpcCX7nZvTsprV69mp9++okmTZrwxBNPVHkvO7/+TLjCYk3ZXcmEnd7KUAghhOPOnj3LQw89xM6dO9WKT6mpqTUyLk+xNx4M3lumlJaWBnGXMuEa3dHW+1Vq8gfckwnn5+fz/PPPAzB//vwqvQNgs0QptPaJWcXlvmg0Gk6fPo3RaMRgMNT4bG0kExZCCDdau3YtO3bswGAw0LdvX+BysQxvqC0Ie2NiVn5+vjXo+98A1AzCSqZZUu4LaN3ygPDKK69w4cIFEhISuPvuu2u878iYcF6RltjYWEwmk3p/HSVBWAgh3Oh///sfAC+++CJr1qwBrEUh3F0HuTZXUiZ85swZ0BjApwVarYW4JlXviV4HIYEWLGhAH8aFCxca9frHjx/n3//+NxqNhtdeew2ttmZIrGtMONDPutNTaYWGlm2sFb+c7ZKWICyEEG6kBOH27dsTFBRESEgIZWVlXts28ErKhE+fPg2+rUCjpXmUBR87vbi2mzg0dg9CcnIylZWV3HnnncTHx9v9TF3rhG13eopp3gm4PObuKAnCQgjhRidOnADghhusXa7KXrVKdSZPqy8T9ngQrmV5kkIJcj4BzcjLy2vUYiLKA1KPHj3svm+x2GTCwfZ7LqoX7HA2W5cgLIQQblJQUMD58+fx8/NT1+Qq61Cv1CDsyQw9LS1NXZ7Upp4gHNnUustSY2bDx48fB6BDhw523y8qhQqThkA/C/6+9s9RvWCHBGEhhLhCKFlw27Zt1fFGJRNWduzxJJPJRGZmJhqNpkZRCq91R9vZR9iWMhYbEmkN1s5OfKqL7VCBPXWNByvC1Ezd+r1KEBZCiCuEEoRt/8jHxlozJmXHHk/KzMzEbDYTExODr2/V1M4bmfDp06cBCyH+xlq7o5VMMzDU2pPQWEE4NzeXixcvEhAQoO4mVV1dM6PV9lmXMKP1iQKcD8KyTlgIIdzEXqblze7o2rqiwYuZcP4c9n07gaioJnY/o3RH+wZZH14aKwgr380NN9xgd1Y0VN3GsDbKQwL6CMBag9oZkgkLIYSbVJ+UBd6dmFVXEPZ0JpyXl0d+fj4BAQFERUVV2bjBlrqTkq81SDs7+7g29Y0Hg2Pd0crELCPW7SDV/ZEdJEFYCCHcxF4mrHRHX2lB2N/fH4PBQFlZmUub0zvL2hUNLVu2rFI+szolEzbrrJlmY2fCtY0Hg4Pd0UpBEaMfPj4+FBYWUlJS4nA7JAgLIYQbmM1mdWeeqyET1mg0Hl2mZBuE66IEYeOl+syNHYTryoTrWiNcvX15RRp1H2JnxoUlCAshhBtkZGRQWlpKdHR0lXrEMTExaDQaLly4gMlk8mib6grC4NkuaUeDsJppVvgB1lnlZrP9SVzOsB0Trk1WHZs3VG9fbqEEYSGEuGLYGw8GMBgMREdHY7FYnJ7E01C2OyjZ48nJWUoQbtWqVZ2fU8Zj84p1REVFYTQaG1y+0mg0kpqaikajoV27drV+zqElSpfGhHNtMmFnvlcJwkII4QZ1ZVpKl7SnlykpmbBSOKS6KzETVrp7cwo06sNDQ7ukU1NTMZlMxMXFERAQUOvnHOmOtpcJOzM5S4KwEEK4QV0Tf5RlSp4s2FFYWEhBQQF+fn5ERETY/YwnM+G0tDSg/iAc6Ac+lzZJaNbcWtijoUHYkZnRUPc2hopwO2PCtplwaWkpRUVFtR4vQVgIIdygtu5o8M5aYaULVxmTtsdTmbDFYlG7xusLwhrN5e5gpXRlQ5cpOTIzGhybHR3sDzqthaJSDZFNrN+rbSa8cePGWrv/wYEgbDabmTVrFsOHD2fMmDGcOnWqyvtvv/02gwcPZsiQIaxfv76+0wkhxHXBkUzYk93RShBWsjV7PBWE8/PzKSgoIDAwsNas3JbSJR0a6blMuLLSOs4LNgU57NBobKp6hViDrW0mrFyrNvVWzNqwYQNlZWUkJyezZ88ennnmGT799FPA+kX961//Yv/+/ZSUlDBgwADGjh1b3ymFEOKaVlJSQnp6Onq93u7EI2/Uj1aCcJMm9itTgee6o5Wu6FatWtW5RlihBLmgcGvW3NAgbK+caHV5RRrMZg1hQRb0unraF2QhKx98g6wPV7YTx5Rr1abeTHjXrl0MGzYMgF69evHzzz+r7wUGBhIXF0dJSQnFxcW1lv4SQojribI+uE2bNhgMNTfJ9Ub96CspE1YmZdU2Qaw6tXRlYMNLV1osFqeqZdXVFa0Ity5hRudXc4lSgzPhwsJCQkJC1H/rdDpMJhN6vfXQ5s2bk5CQQGVlJbNmzaq3seXl5fV+Rlh5omrNtULulePkXjnO1Xt18OBBAFq3bm13/1vlb2pGRkaj7o9bFyVwhYWF1XpNHx8fALKzs51ulzP3SglMzZo1c+g6wX5awKCWhjxz5ozL9+3ixYvk5+cTGhqKn59frec5c84HCCQs0FTvtUL8DYCOcpN1pvX58+cpKCjAYrGowxK1qTcIBwcHV5nZZTab1QCcnJzMuXPn+OWXXwCYMGECffr0oWfPnrWez9fXl+Dg4PouKy6Re+U4uVeOk3vlOFfulbLnbefOne0er0zWOn/+vMe+C6WLuUWLFrVeUxmrLioqcqldjh6jjJm2a9fOoWNiIq0xR+vTBB8fH3JyctDpdHUuL6qNEq/at29fJcGsrtRkvWaTcG29bYwKv9RfbYggICCAkpISNBoN+fn5asGW2tTbf5yQkMC3334LwJ49e+jSpYv6XlhYGP7+/vj6+uLn50doaKhHd+AQQogrkTLWW1t3a3h4OL6+vhQUFNS5fKUxKYHPkTFhd3dHKxN865sZrVC6o3OLtOq2g8qDjrMcnRntyBphRbhNwQ7l/l64cMGha9UbhMeOHYufnx8jRoxg3rx5vPTSSyxevJivv/6afv360b17d4YNG8bw4cO54YYbGDJkSL0NFkKIa5ky1hsTE2P3fY1G4/GCHcqymdraBHikdrTRaGTXrl0Adfaa2gq/FAhzCjVqEK5vXHj58uVMmDChxgOFkgl37ty5zuMvrxGuv0Smula4UKPe3/Pnzzs09lxvd7RWq2XRokVVXrM94bx585g3b169jRRCiOuFknUqgdae2NhY0tLSyMzMrLN+cWO5UiZm7dmzh6KiIjp27Fjn+llbaibsYNWs9PR0Zs+eTVlZGevXr+e+++5T31MeAPr06VPnNbOcmphlv2pWo2TCQghxtXj++ecZOnSoV3YosqUE4boCnicLdlgsFjUTrqs7Whn7LCwsbJRNEuz57rvvAJzqNVUqVp3PcywIv/TSS+pEse3bt6uv5+bmcvToUXx9fYmPj6/zmo7UjVaE11I/WoKwEOK6YbFYWLZsGfv27eO+++7z2ixws9nsUCbsye7owsJCSktL8ff3JygoqNbP6XQ6QkJCsFgsFBQUuKUtW7duBeCWW25x+Jh2zaxB7kSGlhYtrOPstQXhQ4cOqbUsAHbs2IHFYj3+p59+AqBHjx74+vrWeU2nxoRr2UlJgrAQ4rpx9uxZNXDs3buXmTNnqn98PSknJweTyaQugamNJ+tHK1lwdHR0vcUx3Dk5Kzc3l/3792MwGOjfv7/Dx0WGWogMMVNUqsE/zBrQagvC8+fPx2Kx8NBDDxEREUF6ejq///47cLkrum/fvvVe06l1wnYy4ZMnT5KZmYmfn1+d66ElCAshrglHjx4FrGtzAwICWLVqFe+8847H26FktnVlweDZ7mhHxoMVjTkuvH79epYvX67++/vvv8disZCQkEBgYKBT5+oYZ+0eL9O2AezXj/7+++9JTk4mODiYOXPmqIE+JSUFcHw8GJwt1nF5pyflHu/cuROwLsPS6WovuSVBWAhxTfjtt98AGDp0KEuWLAHgueeeq7diUWNTuqLrmoUMnq0f7UjJSkVjzZC2WCw88sgjzJgxQ91XwJWuaIUShPON1vt2+vRpTCZTlc+88sorAMycOZOoqCgGDBgAWMeFy8rK2L9/PxqNht69e9d7PVe6o/OKqs6Ohvp3apIgLIS4JiiZcKdOnRg/fjxJSUmYzWb279/v0XY4mgkrpStdXe/qDGcyYWVDBdvSi67Izc2luLgYgCeffJK8vDx1UpYrQbjDpSB8KtOX5s2bYzKZqmTDZrOZAwcOAPDggw8CMHDgQMAahA8cOEBFRQWdO3dWHzRqU26EghINOq2FEAfqgYQEgFZroaBEQ1hE1Qed+tYjSxAWQlwTbIMwQMeOHQHU8UBPcTQTVoJwZmYmlZWVbm2TM0G4TRtrd2/1HfOcZTvWff78ee677z7OnDlDREQE3bp1c/p8HVtYg/CxdC3t2rUDLtfoBmv3dFlZGTExMWqQ7dSpE5GRkZw9e5aVK1cCzo8HO7IlglYLYYHWbNgvsOr3LpmwEOKaZ7FYOHbsGHC5CIOye5Gng3B9hToUvr6+NGnShMrKyipb37mD7cSs+tgLcK5Q7sMNN9yAr6+vOi578803u7TZT8eW1iB8/Iz9IGxv/2atVqt2SSszph0ZD95/3DqG266548u0lE0cykwBVcpcSiYshLjmpaenU1hYSFRUFFFRUcDlIKxsm+cpjixPUjiy5rUxODMmrAS4hmbCyoSzm266iblz56qvu1pVMTbSQrC/hewCLTEtugJVtwmsbTmQEoSV8WNHgvD3v1iD8M3xjvdQqMuUbGZIA/UWYpEgLIS46lXvigbrLGm4crujgQbXQXaUEoQdaZMShOvbB7c+SibcrFkzHnvsMfr27UtISAgjRoxw6XwaDbS/1CVtCLV2Z9s+KNjLhOHyuDBYH3oc2T5x28+XgvCNpno+eZm6TMlmrXCLFi3qnQUuQVgIcdVTgrBtPeDmzZuj1+vJzMyktLTUY21xdGIWeD4TdqQ7Ojo6mqCgIPLy8sjJyXH5mrb3Qa/Xs27dOo4cOeLQg0BtlBnSFfq2QNXu6Noy4Y4dO6o9AAkJCfVeI/2ihv9l6Aj2t9CjvePd0TERl8asz2jV+1zfeDBIEBZCXAOU5Um2mbBer1ezHntrSt3BYrG4lAm7Mwg7WrJSodFoaNu2ZpBzljIxS3kY8fHxqbNalyOUIJxTFoNWq+X06dNUVFQAlzPh6kFYo9EwePBgAIcKhChd0f3/WImh3t0VLhve09p1vTbFoAZhR2qCSxAWQlz17HVHg+e7pAsKCigtLSUgIMChfXI9kQkXFRU5VLLSlhI8GhKElUxYmQXeGDrEWQPdiQwDcXFxmM1m0tLSKC4uJiMjA4PBYHd7xBdffJFXX321ykYOtfn+F2vkvTne8a5ogBE3mQjyt3DghI4/9BxLeHg4o0ePrvc4J+K8EEJcecxmc42Z0QpPB2HbLLi+8pBwOQi7c0zYtivakTYBaibckHFhZ7rlHdXpUiZ8PF1Lx3btSEtL48SJE5SUlADWduv1NcNabGws/+///b96z2+x2EzKutG5ZWP+vpDY28Sa7w3k6IZx6tQph+63ZMJCiKvamTNnKC4uJjo6Wi00ofD0MiVnA48nJmY5Mx6saOgMadtlVw0ZA66uVYwFX4OFjCwtca3/AFiz9domZTnr6Gkt53O1NI0wq13fzpgwyAjAf1P0Dj/wSBAWQlzVauuKBu9mwo6IiYlBr9dz8eJFt+365MzyJEVD1wpfvHgRs9lMVFQUPj4+Lp3DHp3u8trdwCY9AOuDgiO7FTli26UseHB8JQ7G0Cpu6V5JSKCFQ6k6/pcuQVgIcR24koKwo4U6FDqdzu27KTlTqENhmwm7shOVska4MbuiFUrlLE1gF6BqJqy021Xbfr40HuzE0iRbvgZI6mM99r8pBoeOkSAshLiq2ZsZrVCCcFpamke2NXSmUIdCGRd21wxupU3OBOGIiAjCwsIoLCxUg7gzlCDcmJOyFErlrGKzdQLWyZMnGyUTNppgx6HLmbCrJgy0dkmvTXFsypUEYSHEVa2uTDgsLIzQ0FCKi4vJzs52e1tcGQd19+QsVzJhjUbToKId7piUpVAy4cyCMPR6Penp6epOWa4G4cpKeG6ZL0WlGjq0qCQ20vUHtsHxlUQEmzl6RseRtPpDrARhIcRVy2KxqFlQ9ZnRCk92SbsSfNw9OcuVMWFo2LiwO7ujld2Ujp7WqxPvSktLCQ8PJzIy0unzFZXCpJf9WPKlD3qdhWcmVTSofQY9jO1n7ZJ++RMf6uuAkSAshLhq5eTkUFxcTGhoKOHh4XY/48kZ0g3JhN21VljJhJ2dpawsU3JlhrRtycrG1qGFmZBAC2nntTRrM0B93ZUs+FyOhlFzAtj4k4GwIAtrF5Qyvr9r48G2Zt1RQUiAhfU/Glj2Td1jwxKEhRBXLWUcVckm7bneM2FXxoShYZmwO7ujDXoY2t0aKC0Rierrzi5Pys7XcOtf/TmUqqNdrJktbxQz8I+Ns6Vk66YWFj1qne0+7z1fDv9ee6iVICyEuGop2WNdRfk9FYRLS0spKCjAYDDUWK9cF3eWrnS2ZKUtJai5MiaszPR2RyYMMLKXNQhfNPVSX3MmE84rgtue8+foGR2d4irZ9FoJ7WIbd+Le7YNM3De8grIKDVNf86v1cxKEhRBOq6ys5O23327wTjsNpQQupUvXHk8FYWerZSmUBwh3ZMKulKxUKN3RqampmM3OFa5wZ3c0wLCelWg0Fk7lxIHO+nNVz4RNlZCZXfN7yMjSMHF+AL+e0tG2mZkvFpYSFeqemfOvPFxOx7hKjp3R1foZCcJCCKdt3LiRZ599loceesir7XAmCLt7X2FXK0SFhYUREBBAYWEh+fn5Ll27oKCAF198scaDhhLYmzRp4tSDAUBoaChRUVGUlpaqE60cUV5eTnZ2NjqdTt3bubFFhVro1dGMqVIHYcOAqpnwuRwNI54KoPMDQXR/OJCn/j9flnxpIGmeP12nBrL7qI4WTcysW1hC0wj3LV0L9IMPZpcRFlT7NSQICyGcpmTABw4c4NChQ15rhyNBuEWLFmi1WjIyMtQdd9zB2UIdCo1G0+Au6Y8//ph//OMfPPbYY1VeX716NQC9evWyd1i9HBkXNpvNvPzyy2zbtg2o+jCi09WeATaU0iXtFzuB8PBw2rRpA8Dh37UMeyKA/f/TodFYSM3UsvQrH+Yu9WP7QT0+ehjf38iGl0qIi3b/2vE/tDZz8P2iWt+XICyEcJptxvXxxx97rR2OBGEfHx9iY2Mxm81u3a3IlUIdioauFVbWyW7fvp29e/cCUFJSwrJlywB45JFHXDqvI0F48+bNvPrqq8ycOROj0ejWSVm2RlwKwoEtJ/LNN9/i6+vLlv06Rs0OID1LS+9OlRz9qJjk14uZc085dw428s7/lXJ8RREfPV1G66buD8CK4IDa35MgLIRwmm0Q/uyzzygvL/dKO5SgVVcQhsYdF16+fDlPPPFEjVrPDdmwoKGZsO3Y/JtvvglYv5e8vDx69uzpciasZJd13bfk5GQAsrOz2bp1q1vXCNvq2tpM8ygz2QUGSnUd+c/3eu560Z/CUg23DzLy5d9KiAm30KuTmbn3VrD0yTL+NMxEaKBbm+U0CcJCCKelpqYCEBkZSU5ODhs3bvR4GyoqKjh37hxarbbeCUCNGYQXLFjA+++/z8yZM9VSmCUlJWzZsgVwbTJSQzNhJVPVaDRs2LCBo0ePsmTJEgCmTZvm0jnBsSC8efNm9b9Xr17t1pKVtjSay13STyzx46E3/DBVapgxoYKlT5Th13j7RriVBGEhhFOMRiPp6eloNBr+7//+D4AVK1Z4vB1nz57FYrEQGxtrdw9ZW40VhEtKStQlP6tWreKdd96hoqKC+++/n59//pnmzZs7tJF7dUom7Er96KKiIjIzM/Hx8VE3rZ86dSrHjh2jWbNmjB8/3ulzKuq7bydPniQ1NVWdef3VV1+pFczcnQkDjLjJGoT3HddhsWh4YXI5L04pR3sVRbZ6m2o2m5k1axbDhw9nzJgxNaqnJCcnM2zYMIYOHcoTTzzhkSLpQgjvycjIoLKyktjYWCZNmoSPjw/fffedW8db7XFkPFjRWDOklUzV398fgOeee47x48ezefNmoqKiWLt2rUszghuSCStZcNu2bZk5cyZarZYjR44A8NBDD2EwOLabjz3KfUtNTbX7t13pih4xYgR9+vShrKxMnQzmiSA8qFslIQEWNBoLbz1Wxsw73Dfxzl3qDcIbNmygrKyM5ORkXnjhBZ555hn1vcLCQp577jlWr17Nli1baNmypUeKpAshvEfJilq1akVERARJSUlYLBZWrlzp0Xa4EoQbmgkrmepNN93EnDlzMJvN/Pjjj4SEhPD555/ToUMHl87bGEG4Xbt2tG3bVs18/fz8eOCBB1xqjyIyMpKgoCAKCgrIy8ur8b7SFT1s2DBuv/12wJqZg/vWCNsK8IMNL5ew+e8lTB5pdPv13KHeILxr1y6GDbOuw+rVqxc///yz+t7u3bvp0qULzzzzDImJiTRp0sRt68KEEFcGJZApge1Pf/oTAF988YVH26EE4bpKVioaq360beCfM2cO9957L02aNGHVqlXEx8e7fF7b0pWVlc6VTlQmZSnFKp566inCwsJ47LHHnKrcZY9Go6n13pWWlrJ9+3bAGoRHjx6Nn9/lylCeyIQBurU107ODc8VEriT1bnhYWFhISEiI+m+dTofJZEKv15OdnU1KSgopKSkEBgaSmJhI7969na7hKYS4eih/jJVJO3379kWr1XLs2DHKysqq/CF2J2cy4aioKAIDA8nPzycvL4+wsDCXrnn69GnAWuVKq9Xy7rvvYjab0TZwEDIgIIDmzZuTkZHB6dOn1XvriOob2nfp0qVRq4O1adOGw4cP8/vvv9O9e3f19R07dlBWVkZ8fDzR0dEUFhaSmJjI2rVrAfdPzLpW1BuEg4OD1e4FsI4RK5MgIiIi6N69uzolv1+/fhw8eLDOIOytpQxXo+pLIETt5F45rqH3Spl4ExMTQ2FhIWAdjzxx4gT79u2jW7duDW6jI5RAExkZqbajLnFxcRw9epTDhw873Mbq90q5ZpMmTRy6pjPatm1LRkYGv/zyS509ihUVFfj4XJ76q6wRjo2NbfQ2KecF677Ntuf/+uuvARg4cCCFhYWUlZUxbtw41q5di6+vLzqdzi3tuVoFBwfbfb3eIJyQkMA333zDbbfdxp49e+jSpYv6Xnx8PL/99hvZ2dmEhoayd+9eJk+eXOf5fH19a22MqEnulePkXjmuIfdKyUA7d+6snic+Pp4TJ05w6tQp+vfv3yhtrI9SFKJ9+/YO/Txt27bl6NGjXLx40amf3/azzl7TGZ06dSIlJYUzZ87YPfcvv/zCk08+ya+//sqmTZu48cYbsVgs6nKxbt26ueV/A8o4d2ZmZpXzf//99wCMGTNGfT0pKYmxY8fSunXrKj2oonb1BuGxY8eybds2RowYgcVi4Z133mHx4sW0bduW0aNH8/zzzzNhwgQAbrvttipBWghx7ak+Jgzwxz/+kc8//5yDBw96pA0Wi8WhHZRsNcYMaWViliNd4M5Sah8rPQ2KgoIC/va3v7F06VJ1I4WVK1dy4403kp2dTX5+PiEhIU7vkuQoe5PaUlNTOXnyJKGhoVUKgRgMBq8sV7ua1RuEtVotixYtqvKa7QzA22+/XZ0VJ4S4tuXl5ZGfn09QUFCVLtM//vGPAB4Lwvn5+RQVFREUFERoaKhDxzR0hnRlZaW6RZ8jk8GcpfxdrR6EZ8yYwRdffIFOp2PcuHF8+eWXbNq0iVdffbXKeLCzGzQ4yt59U+pE33zzzfWu0RZ1k7snhHCY7fIk2z/6ShA+dOhQo0xUqo/tpCxHg09DZ0ifP38eo9FIkyZN1HXCjUnJhJUxXrAGfmUZUHJyMvHx8XTs2JG0tDSOHTtWY2a0O8TFxaHRaEhPT8doNGIwGNi5cycAAwYMcNt1rxdXUV0RIYS3KeOPtl3RANHR0epELWUGsTs5MzNa0dBM2Nnub2fFxsYSGBhIdna2Wm/h+PHjFBUVERcXR48ePdDpdAwfPhyATZs2qWuE3RmEfX19ad68OWazmTNnzmCxWNQg3K9fP7dd93ohQVgI4TB748GKrl27AvDrr7+6vR2uBOGWLVsC1nFdk8nk9DXdOR4M1jW51ceF9+3bB0DPnj3Vz40aNQqAb775Rv2cu5eF2j7AnD59moyMDMLCwujcubNbr3s9kCAshHBYXUHYtkva3VwJwv7+/jRr1gyTyeRSZSpXrums6uPC+/fvB6oG4SFDhqDX6/npp584cOAAcHmNsLvYBmElC1bWh4uGkTsohHBY9UIdtjw5OcuZalm2GjJDWsmE3dUdDTVnSCuZcI8ePdTPhISE0L9/f8xms/ow4Y0gLF3RjUOCsBDCYY5kwp4Mws5mpQ2ZnOXu7mi4nAkfP36c0tJSDh8+jFarrVESU+mSBmt5SHevkbcXhD21HvxaJ0FYCOEQ2y0M7WWD7dq1w9/fn/T0dHJzc93aFlcnSSlB+GrIhA8ePIjJZKJTp07qVoEK2yDs7iwYLvd87Nmzh5MnTxIYGOixymjXOgnCQgiHpKenU1lZSfPmzfH19a3xvk6n4w9/+APQeNlwTk6OWqBCUVZWxtmzZ9FoNE7v1NOQGdLunh0N1qpeGo2G33//nR9//BGoOh6saNOmjZo1e6JW3GxM1wAAIABJREFUv3LfMjMzAWslRVkf3DgkCAshHGK7Rrg2ygzpxgjCe/fupV27dgwePJg9e/aobUhMTMRsNtO+fXu7DwN1cSYIZ2VlUVxcDFiLgxQUFBAQENDgnYnq4ufnR6tWraisrOQ///kPYD8IA+qWhbW935giIiKqdHnLeHDjkSAshHBIXePBisacIb1jxw4sFgsHDx5kxIgRPPjggwwePJgDBw7QsmVLli5d6vQ5HQ3Chw8fJj4+njvuuAOz2exScRBXKRmu8iBjOynL1uzZs1m3bp26laQ72W5pCBKEG5MEYSGEQ5TCEG3btq31M405Oevo0aMA9O7dG51Ox+eff05+fj4jR47khx9+cGn/3piYGPz8/MjOzq51h5+SkhKmTp1KcXExhw4d4uuvv/ZIV7RCGRcG67Kq2tbiGgwGBg8ejE6nc3ub4PIDjK+vb60PBsJ5EoSFEA5RgnBdE4GUDVyOHTtGRUVFg6537NgxAJ5//nm2b9/OnXfeyUsvvcSnn37q8n7AWq223slZ8+bN49ixY+q+yIsWLfLIzGiFbW3++Ph4DAaD26/pCGVy1k033eSxPaOvBxKEhRAOcSQIBwUF0bp1a4xGo1rX2BUWi0WtodypUyc6derE0qVLmT59eoMLRNS1TGndunV8+OGH+Pr68uWXXxIeHs6+fftYvXo14PlM+ErKOAcPHgyg7ponGocEYSFEvSorK9WgVVd3NFzOhn/77TeXr5eRkUFRURFRUVFERka6fB57lCCs1MFWZGVlMWPGDAAWLFhA7969mTJlCoA6MczTmbAnJl05atiwYaSmpjJ16lRvN+WaIkFYCFGvM2fOUFFRQbNmzQgMDKzzs0oQPnLkiMvXU7qiO3bs6PI5aqMs6bHdrQggJSWF/Px8+vbty0MPPQTAAw88QEBAgPoZT2TCkZGRREdHA1dWEAYIDw93+8S0640EYSGucC+99BLdu3evsc+sJ506dQqoPwuGy0H48OHDLl9PmZTVqVMnl89Rm9omjyn/7t+/vxpowsPDmTx5svoZT2TCGo2GZcuW8eGHH9Y5E11cGyQIC3GFW7VqFampqTz44IOUl5d7pQ2OjAcrGqM72p2ZsFJQ5Lfffquym5IShJUgrXj00UcxGAwEBQURGxvb6O2xp3///tx6660euZbwLgnCQlzBbPfn/fXXX3nhhRe80g5nNo9v164dBoOBtLS0WpcB1cedQTg0NJRWrVpRXl5epXdBCcLVyzG2aNGCDRs28Pnnn18xM5XFtUOCsBBXMCUYNWnSBL1ez5IlS9i0aZPH2+FMd7TBYFAnFyndys6wWCzqce4IwlCzS/rChQucO3eO4OBguxXBEhISSEhIcEtbxPVNgrAQVzBlctOQIUN49tlnAZg+fToXL170aDuc6Y6Gql2+zjp//jz5+fmEhoYSExPj9PGOqB6ElQpfXbt2lT1yhUfJb5sQVzAliHXp0oXHH3+c/v37k52dzbp16zzWBqPRSFpaGhqNxu4+wvYoVZ5cmZylZP+dOnVy20zcuoKwEJ4kQViIK5iSCXfu3BmtVktSUhJgHR/2lNOnT6u7JzlaKakhy5TcOR6ssA3CSn1q29eF8BQJwkJcwZRMWMkslUlDngzCzkzKUjRkhrQngnCLFi0ICwsjOzubc+fOSRAWXiNBWIgrVFZWFhcuXCAoKEgtEqEEiSNHjmA0Gj3SDmfHg8Ea5EJCQtSfoS55eXls2LBBXX7lzjXCCo1Go97L3bt3c/z4cXQ6nVuvKYQ9EoSFuELZZsHK2GhISAht2rShoqJCzRjdzZmZ0QqNRqNm73V1SaelpTFs2DAmTZrE5MmTMRqN6s9lW77RHZQg/Nlnn2E2m+nQoQP+/v5uvaYQ1UkQFuIKVb0rWqFs4ffLL794pB2uZMJQ/7jwkSNHGDVqlNrd/c0333D//feTlZVFUFCQ26tTKUFYWfIlXdHCGyQIC3GFqi0Ie3pcWAnCzowJA3Vmwj///DOjR48mMzOT/v3788UXXxAUFMTGjRsBaxbs7hrFykxopWqWBGHhDRKEhbhC2S5PsuXJIFxWVsaZM2fQ6XR2i1jUpa5M+G9/+xt5eXmMHj2azz//nJtvvpmVK1fi6+sLuHdSlqJjx45VKmDJ8iThDRKEhbgCWSyWKsuTbClB+NChQ5jNZre24/fff8disdCyZUunSzYqQfjo0aM12qk8YCxcuFBd9jRo0CA++ugjunTpwsSJExuh9XXz8fGpMhFLgrDwBgnCQthhMplYuHAha9as8cr1z549S0FBAZGRkTRp0qTKe9HR0TRr1ozCwsIae+I2NlfHgwEiIiJo2rQpJSUlpKWlqa8XFRWRnp6Oj48PLVu2rHLMqFGj2LlzJ0OGDGlYwx2kdEE3a9asxn0WwhP03m6AEFeiZ599liVLlhASEsIdd9zh8T1U7c2MttWtWzcyMzP59ddfXQqQdcnJyeGnn37ixIkT6qQlZ2ZG2+rSpQvnzp3j8OHDarUtZdOEG264Ab3eu3+ClCAsWbDwlnozYbPZzKxZsxg+fDhjxoxRlytU/8wdd9zBBx984JZGCuFJH3/8MUuWLAGgoKCgShbnKbVNylIowaOxxoWzsrJYvHgxY8aMoX379txzzz08++yzbN++HYAePXq4dF57RTs8tQTJEXfffTcTJkzgiSee8HZTxHWq3sfQDRs2UFZWRnJyMnv27OGZZ57h008/rfKZhQsXkpeX57ZGCuEpu3fv5i9/+Qtg7U7Nycnh4MGDHt9cXRkPrj4pS6EsU2qsIDxlyhRSUlIA0Ov1DBgwgC5dutC+fXv+8Ic/0LdvX5fOa29y1vHjx4ErIwiHh4dL8iC8qt4gvGvXLoYNGwZAr169+Pnnn6u8v27dOrRaLUOHDnVPC4XwkNzcXCZNmkRFRQUPP/wwAQEBvPnmmxw8eJCxY8d6tC31ZcLK5KxffvkFi8XSoO7yyspK9u7dC8C///1vRo4cSWhoqMvns2UvCHuiLKUQV4t6g3BhYSEhISHqv3U6HSaTCb1ez5EjR1izZg3Lly/n1VdfdeiCSmk6Ub+ysjJvN+Gq0Rj36rPPPuPChQv06NGDp59+mq+//hqAAwcOuLw5vSvKy8s5cuQIGo2Gli1b2r12eHg4oaGhZGVl8f+3d+dxVdX548dfl1WRxdBIkUnEDVJBU0KzLBJFBNw1y2Eqssy0bJsmLc2osbQsN2xGTUvSErPSIkREUXPJ7asouQBuUSA4SoJswr2/P/idIyTLvRfuvaDv5+PRY+Kewzmf8w7mzWc5n3daWhpt27bV+/p/jdXp06cpKirCw8ODkJAQgAZ7Xnd3d6ysrEhPT+fSpUvY29ur21J6eHiYNa7GkN9B/Umsaufk5FTt53UmYScnJwoKCtSvtVqtupji66+/Jisri/DwcC5cuKCudlR6ztWxt7evsTHiZhIr/dU3VklJSQA8+eSTuLq6ct999wEVvVJz/nc4deoUpaWleHt74+7uXuN5vr6+7Nq1izNnzhg8tFv5eZQdq/z8/Br8OZ2cnPDy8iI9PZ2srCy6du3KuXPn0Gg0+Pr6NoltIuV3UH8SK8PVuTArICCALVu2AHDgwIEqc1RRUVEkJSURFxfH448/zpQpU2pNwEI0Vvn5+SQnJ6PRaBgyZAhQ8VpO8+bNyczM5MqVK2Zry4EDBwDo06dPrecp88J/nSIylDKvrAxxN7TKO2edOXOG8vJy7r777iaRgIUwtTqTcHh4OM2aNWPw4MHMmDGDOXPmsGTJEnWoTohbQVJSEqWlpQQEBODm5gZUTL1069YNuFH83RyU+Vl/f/9az+vduzcAhw4dqtf9lCSsJPWGVnmFtMwHC1FVncPRVlZWfPLJJ1U+q27oa/r06Q3XKiHMTPmjMjQ0tMrn3bt35+DBgxw7dowBAwaYpS369oSV4wcOHDB6cZZOpzN5T7jy4ixHR0egcayMFqIxkB2zxG3v+vXrbN68GYChQ4dWOaa8j2uunnBOTg4XLlzA0dGxztq2Hh4etGnThry8PHVnK0OdP3+eP//8k9atWxu0uMsQlZNwY3o9SYjGQJKwuO3t3r2bq1ev4u3tfdPuU0oSPn78uFnaogxF33vvvVhbW9d6rkajqdIbNkblXrCpdgXz8vKiWbNmZGZmqu2U4WghKkgSFre9uLg44OahaKjoxWk0GnXFsqkpSbiuoWiFMm+sfJ+hTD0fDBVz60rSVfa6liQsRAVJwuK2ptPpapwPBnB0dKRjx45cv35dfb/VlPSdD1Yoi7MaoidsSpU3HXFzc6Nly5YmvZ8QTYUkYWFxyrao5eXlZr/3kSNH+P3333F3d6dnz57VnmOueeHy8nIOHz4M6J+Ee/XqhZWVFampqRQWFtZ5fkpKijovq3wNpk/CyipzkPlgISqTJCws7sUXX2Ts2LGsWbPG7PdetmwZUPEqnpVV9b8OSoUdUyfhEydOcO3aNdq3b6++JlWXFi1a0K1bN8rLy+t8X/j8+fMEBQURFhbG6dOnycnJITs7GycnJ7XCkalU3l9AkrAQN0gSFhZ15MgRYmNjAdizZ49Z7/3bb7+xfv16rKysmDx5co3nmasnrO/7wX+l77zw/PnzKS0tpaioiMjISPbv3w9U/JFR0x8gDaXycLQkYSFukCQsLEan0zFr1iz164aqCKRIT09n4cKFfPPNNxw5coRr165VOb506VLKysoYNWpUrVWSKidhnU5X73bVdA0liSrzvPrSZ4X0uXPnWLt2LVZWVri7u3P8+HG1WpSph6IB2rZtq84Dy6IsIW6QJCwsJikpiZ07d+Li4oK1tTUnT57Ua15TX9OnT+ftt99m4sSJPPzww3h5efH5558DFYXrv/jiC6BiOLw2bdq0oW3btly9erXei7OysrLo3LkzL7zwwk3JWEmihvaE/7ppR3U++ugjysrKGDduHMuWLcPGxoacnBzAPElYo9HwxBNP4OfnZ/DzCXErkyQsLKK8vJy3334bgNdee42uXbui1Wob9H1cZfh48ODBeHt7U1JSwksvvcSHH37IsmXLKCwsJCgoqM4kpNFoeOCBBwDUmrvG2rNnD5cuXSImJob58+erny9evJhTp07RokULteetr06dOuHi4kJ2dja///77TcfPnj3LV199hbW1Na+//jp+fn5q7ME8SRjgnXfeYceOHequWUIIScLCQtatW0dqaioeHh4888wz6srk+hYjUOTl5ZGdnY2DgwNff/01+/bt4+OPP0aj0fDvf/+bjz76CICXXnpJr+spSfjnn3+uV7vOnDmj/vt7773HTz/9xOrVq5k5cyZQMW9rb29v0DWtrKzU3nB188Iffvgh5eXlPProo3h5eQEwZcoUIiIiCAkJqbJoSghhXpKEhdkVFRXx73//G4C33nqLZs2aqZtFHD16tEHuoRQK6Ny5s7roKDIyks8//xw7OzvKysrw9/enf//+el3vwQcfBCqSsFarNbpdymYVSm934sSJ6h8Cc+fOZfz48UZdV0nCymIrRVZWFuvWrcPa2pp//vOf6udWVlYsXrxY7SELISxDkrAwu2XLlvH777/TvXt3xo0bB9DgPeGaqvUMHz6cb775huDgYD788EO9t2rs0KED7u7uXL58mRMnThjdLiUJv/fee4wePZrCwkK0Wi3Tp09n0qRJRl+3X79+wM0rzHfs2EF5eTlBQUEmfw1JCGG4OqsoCdGQLl++rM6FRkVFqb3UHj16YGVlxcmTJykqKqp3rVklCVdXBGHAgAEGV0RS5oVjY2PZtWtXlc0nDKEk4Q4dOrB48WKcnZ3p2LEjU6ZMMep6Cn9/f2xtbUlJSSEvL09diazMYSs9eSFE4yI9YWFW8+fP5+rVqwQGBvLII4+onzs4ONC1a1fKy8v59ddf630fU9Stre+88LVr18jOzsbOzo527drh4ODAJ598wtSpU+tdPKFFixb07t0brVbL3r171c+VtiptF0I0LpKEhdmcO3eO5cuXAzB79uybjivzwg0xJK28SlRXOUBDKL3n3bt3GzUvrPSCPT09TTIP+9cV3BcuXOD8+fO4uLgYvOJaCGEekoSF2cydO5fS0lLGjRtXbdWehkrC+fn5ZGZmYm9vT/v27et1rcrat2+Ph4cHV65cITU11eDvrzwUbQqVF49V/t/7779fFl8J0UhJEhZmodPpSExMBCreC65OQy3OSktLA6Bjx47Y2DTcsofK7wsbMyRt6iTs7++PnZ0dx44d48qVKzIfLEQTIElYmMXFixe5dOkSzs7OdO7cudpzevTogUaj4cSJE5SUlBh9L1MMRSvqs2mH8o6w8q5uQ3NwcKB3797odDr27Nkj88FCNAGShIVZKLtXKYm2Oo6OjnTp0oWysrJ6Lc4yxaIshZLQ9uzZY/C8sKl7wnCjfWvXruW3336jZcuWahUoIUTjI0lYmEXlJFybhpgXNmVP2NPTEw8PD/Ly8gx+X9jUPWG4MfQcFxcHQP/+/U1eIUkIYTz57RRmoSThunpl9957LwDbt283+l6m7AkD3HfffQAcOnRI7+8pKSkhMzMTKysr/va3v5mkXXBjXlghQ9FCNG6ShIVZ6NsTDg8PR6PRkJCQQF5ensH3KSoq4vz589jY2Jisx6n8oXD48OEaz7l+/TonT55UqxpduHABnU7H3/72typJsqE1b968SpUiWZQlROMmSViY3LVr18jIyMDGxqbOIeJ27doxYMAASkpK2Lhxo8H3SktLQ6fT0bFjR5MlO6Xeb3U94fz8fJYsWUKvXr3o27cvS5cuBcwzFK1Qer+urq5SnEGIRk6SsDC5X3/9FZ1OR9euXfWqEPToo48C8PXXXxt8L1MPRUNF6T9ra2t+/fXXKvWPd+zYQbdu3XjrrbfIzMwE4NNPP6W8vNwsi7IUoaGh2NjYMGzYMJkPFqKRk9/QW1xxcTGjR4/G19dX/efFF1+ssfi7Keg7FK0IDw+nefPm7N27l/Pnzxt0LyUJd+nSxbBGGqBFixb4+PhQXl5OSkqK+vmcOXO4evUq9913H2vWrKFDhw5kZmaSmJio9oTNkYR9fX05fvw4c+fONfm9hBD1I0n4FpeYmEhSUhIXLlxQ/1m9ejUHDhwwWxsMTcJOTk6EhYUBEBsbW+u5BQUF/PDDD6xYsYKlS5eqG4KYYmV0ZX8dkr548SL79+/H3t6eb7/9ltDQUJ566ikAVq5cqfaEzTEcDdCmTRuD6xILIcxPkvAtTnlV5ZVXXuHIkSM899xzAPznP/8xWxsMTcJwY0h63bp11fbav//+e8aOHYuXlxcRERG88847zJgxQ61HbOq50L8m4c2bN6PT6Xj44YdxdHQEYMKECdjZ2ZGYmKieJ+UEhRCVSSnDW1hZWRkJCQkAjB8/Hk9PT1544QWWL1/Oxo0byczMxMPDo973ycnJYejQofTr14/FixdXOVZeXq7us2xIEn744Ydxc3MjPT2dw4cPq0kPKlYaP/nkk0DFVpIBAQHcc889as+vc+fOJk/CygppJbn+9NNPQMV8rKJVq1aMGDGC2NhYLl++DFS8ZyyEEArpCd/C9u7dy5UrV+jUqZM6R9quXTtGjBhBeXk5K1asaJD7LFiwgPT0dGJiYti9e3eVYxkZGRQVFeHh4cEdd9yh9zVtbGwYM2YMcPMCLeUPi8DAQE6fPk1CQgJRUVF88MEHfPDBBzz99NP1fKK6eXt74+DgwPnz5zl37hzJycloNBpCQkKqnBcZGan+u7u7Ow4ODiZvmxCi6agzCWu1Wl5++WUGDRpEaGiousBEER0dzcCBAxk4cCAffPCByRoqDKcMRVfunQFMnjwZgM8//5xr167V6x7Z2dmsXLlS/XrWrFlVho/13aSjOuPGjQMqhp7LysrUzzdv3qwev/POO41qd33Z2Niou3t9+OGHlJSUEBAQcFN7lF46SC9YCHGzOpPwjz/+SHFxMYmJicyePZs333xTPXbu3DnWr1/Pli1b2Lp1K9u3b+f48eMmbbDQj06nq3aIFKBPnz74+/uTl5fHunXr6nWfBQsWUFxcTFBQEG5ubhw6dKjK+73Kz4Mx9Wz9/Pzo1KkTubm5ajGCgoICdu3ahUajYdCgQfVqe30pQ+RfffUVcHOcoWK4XJmHr658oxDi9lZnEt63bx9BQUFAxZZ4lff0bdeuHRs2bMDa2hqNRsP169dp1qyZ6Vor9Hb8+HEuXLiAm5sbffr0uel45QVaxr6ulJWVxapVqwCYPXs2b7zxBgBRUVGUlpYCxi3KUmg0GkaNGgXAhg0bAEhOTqa0tBR/f39at25tVLsbipKElUIOQ4cOrfa8iIgINm3axPTp083WNiFE01Dnwqz8/HycnZ3Vr62trSkrK8PGxgZbW1tatWqFTqdj5syZ+Pr60qlTp1qvV58Sdbeb4uJio7/3u+++AyAoKKjaIefAwEDc3Nw4ffo0e/bswdfX1+B7zJs3j5KSEoYOHUr79u1xd3cnOjqajIwMIiIiyMzMVBdldejQgfz8fIPvERwczLx589i0aROzZ8/mxx9/BCoWblW+Xn1iZazKG4J06dIFNze3Gp+xV69eAEbFoKFZIlZNlcRKfxKr2jk5OVX7eZ1J2MnJiYKCAvVrrVZbpVB6cXExU6dOxdHRkfnz59fZEHt7+xobI25mbKy2bt0KwIgRI2q8RlhYGCtXrmTXrl3079/foOv/9ttvrF27FoA333xTvcfs2bOJiIhQF0+1aNGC8ePH07179xpLGNamd+/edOvWjdTUVH755Re2bdsGwLBhw256LnP/XPn4+NC6dWsuXbpEeHh4k/q5bkpttTSJlf4kVoarczg6ICCALVu2AHDgwIEqr37odDoef/xxunfvzoIFC7C2tjZdSwUAW7ZsYfjw4bXuJHXs2DFSUlJwdHRkwIABNZ4XHBwM3FhtrK/y8nImTZpESUkJo0aNolu3buqxsLAw/vWvfzFx4kTWr19PRkYG8+fPNyoBK0aPHg3Au+++S05ODh4eHlXuaSkajYahQ4fSrFkzdSW3EEIYQpOXl1frhKBWq+XVV18lNTUVnU5HdHQ0W7ZswcvLi/LyciZOnFhlzvHtt99WS71VJz8/X/5a0lN1sQoLC+Pnn38mIiLipndyAQ4ePMjYsWO5cuUKEyZMIDo6usbrFxUV4eXlRVFRESdPnqRNmzZ6tWvevHnMmTMHNzc3du/ebfIVyufOnaNnz57q1xMnTuSjjz6qco6lfq5KS0spKCjA1dXV7Pc2lvwO6k9ipT+JlXHqTMINTf5D6e+vsSotLaV9+/YUFRVhb29PampqlcVJSUlJREREUFhYSHBwMKtWrarzvdRHH32UhIQEFi1axD/+8Y8627Rv3z6GDh2KVqvlu+++IzAw0PgHNEBQUBAHDx4EYP369TetjJafK/1JrPQnsdKfxMo4sllHAyspKaGwsJDCwkJ1hXBDSUlJoaioSL3P559/rh5LTk5m/PjxFBYW8thjj/Hll1/qtTGEsrmE8u5tbf73v/8xceJEtFot06ZNM1sCBtRV0g4ODlIjVwhxy5Ak3IBWrFhBmzZtcHd3x93dnbZt29ZZgMAQe/fuBW5UCFqxYgWlpaXk5uby7LPPcv36dSZNmkR0dDS2trZ6XXPw4MFARRKvbXXjwYMHeeihh8jMzKR379689dZb9Xwaw4wbN44uXbowceJEeQ1OCHHLkCTcgD777DN0Oh329vY0a9aM8vJyZs6cWe9dqRT79u0DYNq0afj4+JCdnc13333H5MmTycnJoX///syZM8egGrLu7u74+vpSWFiobohRmU6nY9myZYSEhKgJOCYmRu8k31Bat27N/v37iYqKMut9hRDClCQJN5CMjAxOnDiBs7MzmZmZZGVlce+993Lx4sVaF0fpS6fT8csvvwBw//33q5ttvPrqq2zdupU77riDZcuWGbVCvbZV0p999hmvv/46169f59lnnyU+Ph53d/d6PIkQQgiFJOEGomwRGRwcjK2tLRqNhnfeeQeARYsWkZubW6/rZ2RkcOnSJe666y48PT0ZN24crq6u6jvcS5YsoV27dkZde8iQIQDEx8fftHtWTEwMULE/8rx587Czs6vHUwghhKhMknADqW6f5gcffJDg4GAKCgqYN29eva6vzAcHBASg0Who3rw5zzzzDADPPPNMtfsW66tXr164ubmRmZmp1uOFileDjh49iqOjIxEREfVqvxBCiJtJEm4Aubm57Nu3Dzs7OwYOHFjl2Ntvv42VlRWrVq0iPT3d6Hso88F9+/ZVP3v99ddJTExk7ty5Rl8XwMrKihEjRgCwevVq9fNNmzYBFT1lWQwlhBANT5JwA1CGcR966KGb3pO75557ePzxxykrK2PRokVG30NJwv369VM/s7a2xt/f36CFWDV56qmnAIiNjVX3N1aScHh4eL2vL4QQ4maShBtATXV7Fcqw8bZt24yqWJSTk0NGRgYtWrQwqhqRPnx8fLj//vspKCggNjaW3377jYMHD+Lg4GDxkoFCCHGrkiRcTwUFBSQnJwM3Fjj9VY8ePXB1dSUzM5OzZ88afA9lVXSfPn2qFM9oaJGRkUDFiugffvgBgEGDBum16YcQQgjDSRKup23btlFSUoK/v3+Ney9bWVmpuzwpCdsQyqKsyvPBphAeHk7r1q359ddfWbhwIQDDhw836T2FEOJ21mST8Lp165g5c6b6z/r16y3SjrqGohUPPfQQADt27ND72jqdjv/85z8sX74cwOByg4ayt7dXV0FfvHgRe3t7GYoWQggTMt3YpgkdOHCASZMm3fS5p6cn/v7+ZmuHVqtV69sqG17UREnCu3btQqvV1rmY6urVqzz//PNqEfvnn3/eLHsmP/HEEyxYsACdTsfAgQNlQ3YhhDChJtkT/uCDD4CKsn5RUVHq6t1Zs2YZtfDJWKmpqeTm5uLu7o63t3et53p5eeHh4cF4r2GhAAAPmUlEQVTly5c5duxYndcNDAzkxx9/xMnJiS+++II5c+bUqyavvjw9PdU/KKRGrhBCmFaTS8L79+8nKSkJJycnFi1axIsvvsiSJUtwdXVl7969xMfHN9i98vLyuH79eo3Ht2/fDkBgYGCdCVKj0TBgwAAAdu7cWeN5a9asISgoiIyMDHx8fNi+fbvZ52U//fRTvv76a0aOHGnW+wohxO2mySVhpRc8adIktZC6i4sLr7/+OgDvvPMOZWVl9b5PTk4Offr0wc/PjxMnTlR7jjIUrW9Jv7rmhWfMmMGUKVMoKipiwoQJbNy4kU6dOhnR+vq54447GDJkiFl63kIIcTtrUkn4l19+Ydu2bTg5OTFlypQqxyIjI/H09OTUqVOsWbOm3vdauXIlly5d4o8//iAkJIT9+/dXOV5YWKiuWn744Yf1uqbSE96zZ89NtYazs7NZunQptra2LF68mOjoaJo3b17v5xBCCNF4Nakk/P777wMVveA77rijyjE7OztmzZqlnldYWGj0fUpKSvjss88A6NmzJ3l5eYwYMYKtW7eq5+zdu5eSkhL8/Pxo3bq1Xtdt27YtXbt2pbCwkIMHD1Y5ppQRHDBggOzTLIQQt4kmk4T3799PcnIyzs7OTJ06tdpzRo4ciZ+fH9nZ2WzcuNHoe23YsIHc3Fy6devG1q1bmTBhAoWFhUyYMIG0tDTgxlD0I488YtC1ld7wX4eklST8wAMPGN1uIYQQTUujSMJbt26lX79+zJ49m+zs7GrP+eSTT4CKLSBbtmxZ7TkajYann34agC+//NKotijv5gJMnjwZGxsblixZwrhx4ygpKeGFF15Aq9VWWZRlCGVeOCkpqcrnShI2x2tIQgghGgdNXl6e+d7pAfLz86u8e1peXk5AQIBaYcjOzo5x48Yxa9Ys3NzcADh58iR9+/alWbNmHDt2jDvvvLPG61+9ehVvb28KCws5fPgwXl5eBrVv9+7dhIaG0rp1a44fP65WD8rLyyMgIICLFy/yyiuv8PHHH+Pg4MDZs2ext7fX+/rXrl2jc+fOFBYWcvToUdq3b09WVhY+Pj44Ojpy9uxZbG1tq42VqJnESn8SK/1JrPQnsTKOxXvCcXFxpKen4+HhwbBhw7h+/TpffvklY8aMUed1lS0U//73v9eagAGcnZ3VsnzGLND69NNPgYqqQpXL97Vs2ZL58+cD8PHHHwMVO1gZkoABWrRooe4x/f333wM3esF9+/ZVE7AQQohbn0WTsE6nY8GCBQBMmzaN1atXc/DgQTp06EBKSgpTp07lwoULrF+/Hmtr6xrngv/q73//OwBr16416HWl9PR0fvrpJ2xtbdVh7crCwsKqvDtr6FC0YtSoUUDF3DNU7KIFMhQthBC3G4sm4Z07d3L48GFatWrFhAkTAOjYsSNr167FycmJb7/9luHDh1NWVsbIkSPx9PTU67r9+vWjY8eOZGVlqQuo6qLT6XjjjTfQarU89thjNRZjmDdvHq6urmg0GqP3VR40aBDOzs6kpKSQlpYmi7KEEOI2ZdEkrAwzP/fcc1XK5fn4+LBs2TI0Go1a+m/atGl6X1ej0ai94ZiYGL2+Jz4+nq1bt+Ls7MzMmTNrPO/OO+9ky5YtbNy4kc6dO+vdpsrs7e0JCwsDYMmSJZw5cwYnJyf8/PyMup4QQoimyWJJ+MiRI2zbtg1HR0e16H1lISEhajIMDg42uJj9Y489hrW1NfHx8eTm5t50PCMjQ92SsqioiOnTpwPw5ptv1jnv3KlTJ/VVI2ONHj0agNWrVwMVvXdT1goWQgjR+FgkCV+6dEnt2T755JM1vnL08ssvk5CQwLJlywy+R5s2bRg0aBBlZWVqolOsXLmS3r1706tXL5YuXcrcuXM5f/4899xzT7VzwaYwYMAAWrVqpRackPlgIYS4/Zj9FaWTJ08SERFBWloa7du3JzExUX0VqaFt376dkSNH0rZtW1JSUrC1taW0tJSePXvyxx9/3HR+XFycyWv2VvbKK6+wcuVKta29evWqclyW/OtPYqU/iZX+JFb6k1gZx+w94ZEjR5KWlka3bt1ISEgwWQKGij2dvb29ycrKUnfQio2N5Y8//sDHx4c1a9bQt29fACZMmGDWBAw3Vkk7OzsbPNwuhBCi6TN7Es7KyqJfv37ExcXVuAK5oWg0Gp577jkAli5dilarZdGiRUDFQq/Q0FA2b97M8ePH1c/NqX///syePZvo6GiZDxZCiNtQncPRWq2WV199lePHj2NnZ8fixYur7EL1xRdfsGrVKmxsbHjttdfUjShqMnbsWFavXm22CkGFhYV069aNK1euMG3aNBYuXIiHhwf/93//1+g3xpDhHf1JrPQnsdKfxEp/Eivj1NkT/vHHHykuLiYxMZHZs2fz5ptvqscuXrzIf//7XxISEtiwYQNRUVGUlJTUer3PPvvMrCX6HBwceOqpp4Abr0RNnTq10SdgIYQQt746k/C+ffsICgoCwN/fnyNHjqjHDh06REBAAPb29ri4uNChQwdSU1NrvZ4lCsU//fTTWFtbA+Dq6iqlAoUQQjQKdU5E5ufn4+zsrH5tbW1NWVkZNjY2Nx1zdHTk6tWrtV6vrp6yKTg7OxMeHs7333/PU089hVarJT8/3+ztMFRxcbGlm9BkSKz0J7HSn8RKfxKr2tU0VF9nEnZycqKgoED9WqvVqouI/nqsoKAAFxeXWq9nb29vkXmDhQsXEhoaysiRI5vUIiiZY9GfxEp/Eiv9Saz0J7EyXJ3D0QEBAWzZsgWAAwcOcM8996jHevfuzd69eykuLubPP//k9OnT+Pj4mK619eDi4sLYsWObVAIWQghxa6szI4WHh5OcnMzgwYPR6XRER0ezZMkSvLy8GDp0KJMmTSIkJAStVstbb71VpfyfEEIIIWpm9h2zZBm7/iRW+pNY6U9ipT+Jlf4kVsaxaBUlIYQQ4nYmSVgIIYSwEEnCQgghhIVIEhZCCCEsRJKwEEIIYSGShIUQQggLkSQshBBCWIgkYSGEEMJCzL5ZhxBCCCEqSE9YCCGEsBBJwkIIIYSFSBIWQgghLESSsBBCCGEhkoSFEEIIC5EkLIQQQlhIgybhgwcPEhoaCsCRI0d45JFHCAkJ4Z///CdarVY9r7CwkAceeICtW7cCcO7cOUJCQggJCeHZZ5+lsLCwIZvVKOkTq8cee4zg4GBCQ0MZM2ZMle+fPn06K1euNHu7LcHYWJ08eZIhQ4YQHBzM5MmTKSsrs9gzmIuxsTp69Cg+Pj6EhoYSGhrKt99+a7FnMBdjYxUZGanGqUePHkRGRlrsGczF2FjVlgdEhQZLwgsXLuTFF1+kpKQEgJdeeon333+f+Ph4XFxcWL9+vXrua6+9hkajUb+eNWsWkZGRxMfH88ADDxAdHd1QzWqU9I3VmTNn2Lx5M3FxcXzzzTcAXLp0iTFjxhAfH2+x9ptTfWIVFRXFzJkzSUhIALjlY1afWB09epTnn3+euLg44uLiGDVqlMWewxzqE6uVK1cSFxfHmjVrcHFxYc6cORZ7DnOoT6xqywOiQoMlYU9PT2JiYtSv//jjDwICAgAICAhg3759ACxevJiAgAC6d++unnvq1CkGDRp007m3Kn1ilZOTw59//sn48eMZMmQImzdvBqCgoIA33niDRx991CJtN7f6xComJob+/ftTWlpKTk4Ozs7OFnkGc6lPrI4cOcKWLVsICQlh6tSp5OfnW+QZzKU+sVLMmTOHZ599ljZt2pi17eZWn1jVlAfEDQ2WhIcPH46NjY36taenJz///DMAmzdv5tq1a+zYsYOMjAyeeOKJKt/bo0cPfvrpJ6Cit3KrD0frE6vS0lKmTJnCmjVriImJYcaMGeTm5uLp6UmfPn0s1XSzq0+srK2tuXDhAn379uV///sfPXr0sNRjmEV9YnXvvffy7rvvEh8fj6enJ3PnzrXUY5hFfWIFkJuby86dO5kwYYJF2m9O9f3/q7+eK6oy2cKs6OhoPvnkE4YNG0br1q1p1aoVMTExnDhxgtDQUJKSkpg1axYpKSm89957xMfHExoaikajwdXV1VTNapSqi9Vdd91FZGQkNjY23Hnnnfj6+pKWlmbpplqcobG6++67OXz4MJGRkcyYMcPCrTcvQ2IVFhZGz549AQgLCyMlJcXCrTcvQ3+uNm7cyJgxY7C2trZwy83PkFhVd66oymRJOCEhgeXLl7Np0yYuX75MYGAgK1asICEhgbi4OAYOHEhUVBS+vr5s376dWbNmERcXh5WVFYGBgaZqVqNUXaySk5N58skngYoh6BMnTtC1a1fLNrQRMCRW48ePJyMjAwBHR0esrG6vlwEMidXo0aM5dOgQADt27FAT8u3C0N/B5ORkgoKCLNhiyzEkVtWdK6qyqfsU43Ts2JFhw4bh4ODAgw8+yODBg2s8t3PnzjzzzDPY29vj7e3NRx99ZKpmNUo1xSopKYmgoCCsrKyYOXOm/BWJYbF6+eWXef7557G1tcXBwYFFixZZuPXmZUis5s+fz7/+9S9sbGy46667WLBggYVbb16G/g6mp6fj6elpwRZbjiGxMiQP3K6kipIQQghhIbfX+JwQQgjRiEgSFkIIISxEkrAQQghhIZKEhRBCCAuRJCyEEEJYiCRhIZqgXbt20bJlSzZs2FDl8/vvv5/JkycbdK3U1FR2794NVOxeV1xc3GDtFELUTpKwEE1Uly5dqiTh1NRUo7Z83bRpE6dOnWrIpgkh9GSyzTqEEKbVvXt30tLS+PPPP3FxcSE2NpaxY8eSmZlJbGwsn376Kfb29nh5ebFw4UJiY2NJTEykqKiIs2fPMm3aNAIDA1m7di12dnb4+fkB8Morr3D+/HkA1qxZQ8uWLS35mELc0qQnLEQTNmzYMH744Qd0Oh2HDh0iICCAy5cv8/7777Np0yY2b96Mi4sLq1atAuDq1ausW7eOr776igULFuDu7s7jjz/OlClT6N27NwARERHExcVx9913s337dks+nhC3PEnCQjRhY8eO5dtvv2X37t3069cPAJ1Oh7e3N05OTkDFPPHJkycB1EpS7dq1q3HuV9k3+q677rrlK5oJYWmShIVowjw9PSksLOS///2vWmNao9Fw6tQptWzc7t276dixo3rsr6ysrNBqterX1Z0jhDANScJCNHEjR47k999/p1OnTgC4uroyffp0wsPDCQoK4vLlyzz99NM1fn/Pnj1Zvnw5O3fuNFeThRD/nxRwEEIIISxEesJCCCGEhUgSFkIIISxEkrAQQghhIZKEhRBCCAuRJCyEEEJYiCRhIYQQwkIkCQshhBAWIklYCCGEsJD/B6s/zapHXSLRAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -392,18 +382,19 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 12, "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEECAYAAAA4Qc+SAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO2deXgUxfb3v5OFNWEJCIqyySIqYEQRguASdiMgKu5GLwiucMWNG1FARTbhIngRN0BFZVH5IRoWIYblBrkCEkRBVHYUWRNIkJCEyftH3mpreqq7q7p7ZjIz5/M8PGSmu7pravn26VNVpzz5+fllIAiCIMKemFBngCAIgnAHEnSCIIgIgQSdIAgiQiBBJwiCiBBI0AmCICKEqBL0wsLCUGehQkPlYwyVjTFUNsYEu2yiStDLymiGphlUPsZQ2RhDZWNMsMsmqgSdIAgikiFBJwiCiBBI0AmCICIEEnSCIIgIgQSdIAgiQiBBJwiCiBBI0AmCICIEEnSCIAgBRUVFyMnJCXU2lCBBJwiCEPDqq68iLS0t1NlQwlTQS0pKMGTIEPTu3RupqalYunQptm7diksvvRRpaWlIS0vDokWLAAATJkxAamoqevTogc2bNwcl8wRBEIHi8OHDoc6CMnFmBxcsWICkpCS88847yMvLQ5cuXfDcc8/hsccew9ChQ7XzcnNzkZOTg6ysLBw8eBDp6enIzs4OeOYJgiCIvzEV9FtuuQX9+vUDUB6TIDY2Frm5ufj111+xdOlSNGvWDOPHj8eGDRuQmpoKj8eDhg0borS0FMeOHUPdunVNb15YWBjUWAdFRUVBu1c4QuVjDJWNMZFaNqWlpQCAgoIC29cIVNkkJiYKvzcV9ISEBADlPyg9PR0vvPACzp49i/T0dCQnJ2Py5MmYOHEiatasiaSkJJ90p06dshR0dv1gYlQQRDlUPsZQ2RgTiWUTF1cuj05/WzDLxnJQ9ODBg+jTpw/uvPNODBgwADfffDOSk5MBADfffDN++OEHJCYm+oSJLCwsRM2aNQOXa4IgiADj8XgAhFc0SVNBP3LkCG699Va89NJLuP/++wEAt912mzbouWbNGiQnJ6Njx47IysqC1+vFgQMH4PV6UadOncDnniAIIsCEk6CbulymTJmC/Px8TJo0CZMmTQJQPpXn+eefR1xcHOrXr4/XX38dNWrUQEpKCrp37w6v14vJkycHJfMEQRCBIpyEnOHJz88Pv1zbpKCgICJ9fW5B5WMMlY0xkVo2Q4YMwcKFC3H8+HHExsbaukawy4YWFhEEQZgQTpY6CTpBEISAiBsUjXa8Xi+6du2KX375JdRZIQgiyBw5cgQAsGrVqhDnRB4SdBPOnDmDzZs3Y/bs2aHOCkEQQSYvLw8A8Ouvv4Y4J/KQoJvAXrkIgoheyOVCEAQRIZCgRxjhVKEEQUQvJOgmkMuFIIhwMuhI0CUIpwolCMIdwrHfk6CbQBY6QUQvJOgRBqvQcKxYgiDcIZz6Pwk6QRCECSToEUI4VSRBEIEhnHSABF2CcKpQgiDcIRxdriToBEEQJpCgRwjhVJEEQRAk6BKQsBNE9BJO/Z8E3YRwqkiCIAJDOOkACboE4VShBEFELyToJpCQE0T0wvr/hAkTcMEFF4Q4N3KQoEtAwk4Q0c2ZM2dCnQUpSNAJgiAEhKMhR4JuQjguLCAIInohQZeABJ0goo9w7Pck6CaEY4USBOEO559/fqizoAwJugQk7AQRffTo0SPUWVCGBJ0gCEJAOBpyJOgmhGOFVmTy8vKwd+/eUGeDIKQIx/5Pgk4EjdTUVCQnJ4c6GwQRsZCgSxCOT+qKyJ49e0KdBYKQJhz7vamgl5SUYMiQIejduzdSU1OxdOlS7N69G7169ULv3r3x1FNPwev1AihfHpuamooePXpg8+bNQcl8sAjHiiUIwhnh2O/jzA4uWLAASUlJeOedd5CXl4cuXbqgdevWGDlyJLp06YLhw4cjMzMTDRs2RE5ODrKysnDw4EGkp6cjOzs7WL+BIAhCiNfrxSeffIJ7770XHo9HOt22bduwZcuWAOYsMJgK+i233IJ+/foBKH9axcbGYuvWrejcuTMAoFu3bsjOzkbz5s2RmpoKj8eDhg0borS0FMeOHUPdunUD/wsCCK0UJYjwZsWKFXjiiSfQuHFjdOnSRTqd6NwzZ86gatWqbmbPdUwFPSEhAQBQUFCA9PR0vPDCC3jxxRe1J11CQgJOnTqFgoICJCUl+aQ7deqUpaAXFhYGVSyLioqUzi8oKABQ7npif0cyquVjl3Asy2CVTThSkcvm5MmTAID8/HzH7S4lJQXr1q1TShOosklMTBR+byroAHDw4EHcd999GDRoEAYMGIDRo0drxwoLC1GzZk0kJiaisLDQ73sr2AMjmBgVhIiSkhIAQFxcnFK6cCYYvzNcyzJc8x0MKmrZMIu6atWqjvO4d+9eW9cIZtmYDooeOXIEt956K1566SXcf//9AIA2bdpoT6lVq1YhJSUFHTt2RFZWFrxeLw4cOACv14s6deoEPvcEQRAmMG9CtLhNTS30KVOmID8/H5MmTcKkSZMAlM9mGTFiBF5++WW0bNkS/fr1Q2xsLFJSUtC9e3d4vV5Mnjw5KJkPNORDJ4jwhgSdY+LEiZg4caLf90uXLvX7LiMjAxkZGe7lrAIRLY2BICKNaBN0WlhEEETEQoJOaERLIwgWMTHU3IjgwtpctPRl6mFE0CBBJ4INs9BXr16Nw4cPhzg3gYd6mAk0KOouKiv1CMJN3n77bQwYMCDU2VDiiy++QGlpqVIaEnQiaJCFTgQb3og4duxYCHOixv79+/HAAw/ggw8+UEpHPUwCstDdgSx0ItjwRgQLJBgOxMfHAwAOHTqklI4E3QQScnchC50INrwREU6CzvqKargC6mFE0CBBJ4INL+jnzp0LYU7UYMYkCbqL0KCou5DLhQg2fJs7fvw4Pv300xDmRh6mOX/99ZdSOhJ0Img4FfSDBw+6lBMiWtC3ucGDB4coJ/agWS4BgCx0d3Ai6AcPHkTr1q2xcuVKF3NERDrh+lbINOerr75Smj9Pgm4CCbm7OPGh5+XlAQD27dvnVnaIKCDcBR0A1q9fL52OBN2EBQsWhDoLEYWTzsUaeLh2UIJQwa4xSYJuAtvMgyx1d3BioVcEQb/jjjuwZs2akN2fUCdcDQAS9ApEaWkpDeAJCHcL/euvv8aYMWNCdn9CnUgQ9A8//FA6HQm6BKpPy5dffhmtW7cOUG7Cl0iYhx6uAhGtREJ9ZWdnS58b/j0sCGzZskXp/G3btgUoJ+GNG50r1B001Pcn1AjX+tIbkbJGJQm6BHv27Al1FiKCcPehE+FHuLYX8qETFZ5IEPRQ35+ITshCDyHU6cWwcrETJIlmGhF2CNd2Qy6XCgQJuhhmoTsR9FCXbajvT6gRroK+ePFin8916tTByZMnLdORoEuiOjBK+OOGhR5qQQ31/aOdTZs2Ye/evaHORkA5deoUXnrpJb/vZTboIEGXZNKkSdLnUqcX48RCZ2lCXbahvn+0061bN1x55ZXS54ejhW7UP2QiL5KgE0GDieEPP/ygnLaiWOh//fWX1KsvEThURDocBd2ILl26WJ5Dgh4AQi06FRVmoffo0UM5bag7Jrv/tm3b0Lhx45DmhZAn1O0m2JCgB5Boa0xWuPGgKy4uDklYhXDa7YaIXuJCefP8/HwAQK1atUKZDSlUxJkf/IuNjQ1UlsION5b+P/nkkwD+bjvBIpz2oySil5Ba6M2aNUOTJk2Cdr/c3FzUqlULRUVFAb3PiRMnAJAI6HFioYfajUV1GZ5E21tySAU92K+xq1atAhB4627Tpk0ASAT0hLOgR5swRApO623q1Kku5SQ4RJUP3cm0OTuCQiLgSyREWySii5SUlKDf04luRFUPY6Jsp8DspHn55ZeV00QyobaynUBvW77cddddaNSoUaizYYlToyoUbdZJW5MS9E2bNiEtLQ0AsHXrVlx66aVIS0tDWloaFi1aBACYMGECUlNT0aNHD2zevNl2hgIJP1g5YcIEHDlyJKD3e/PNNwN6/XDDTQs92G8/9Lbly/Lly3Hq1KlQZ8MSp/UWirdKJ3m2nOUybdo0LFiwANWqVQNQLuiPPfYYhg4dqp2Tm5uLnJwcZGVl4eDBg0hPT1cKyh4seAt9woQJ+P333/HGG2+EOFfRgxs7FjGCPYOILPTwJNoE3TK3TZo0wdy5c7XPubm5+Prrr9G7d2888cQTKCgowIYNG5CamgqPx4OGDRuitLRUKu5AsNH70MnqCi5uhM81+hxoqK1EJx6PB5deemlQ7xlQC71fv37Yt2+f9rldu3ZIT09HcnIyJk+ejIkTJ6JmzZpISkrSzklISMCpU6dQt25dqUwUFBTYyLo6TMjZLJeSkhLpe5eWltrKZ7B+mxsEejonb+Wqlos+jsWpU6cQHx/vSr5kOHPmjM/ncKrXQFJQUBDwdmN0XxlE8U9U6u6vv/7ymY2nWu92ysbsHuxYYmKi8LjywqKbb75ZWwh0880347nnnsNNN92EwsJC7ZzCwkLUrFlT+ppGmXMbJgCVKlUCAMTFxUnfW+VcnmD9NrcIZH55AVa9T9WqVX0+JyQkaPUYDPLy8nw+h1u9BgpWDsEuD9n7Va5c2XZadi57s7z++uuDogGnT5+2fS3ld+DbbrtNG/Rcs2YNkpOT0bFjR2RlZcHr9eLAgQPwer2oU6eO6qWDBrlcQoPbPvRgQm0lPHG6mUpMTIz2ec2aNaZi6xYBdbnomTJlCkaMGIG4uDjUr18fr7/+OmrUqIGUlBR0794dXq8XkydPtp2hYGBH0NeuXRuo7EQNvA89Ly8PtWvXlk4bah86DYqGlvz8fDzyyCPK6USLF99//308+OCDhmn4utYbIUuWLMHdd9+tnA8VnLQ1KUFv3LixtsoyOTkZK1as8DsnIyMDGRkZtjMSDJgI2CkwmVjEhDm8oI8aNcrRDCMaFI0uVq5cieXLlyunE/X1J598UlrQeQsdCM68dFpYJAkrKPZwok4aPF588UWsX79e+1xaWqqUPtQuF7LQQ4vdGVJOFxHGxMTgpptucpwPu/dXJaoEnTF27FgAwRH07du3B/we4cCsWbN8Ph89elQpfahdLvTwDy121xw42R0LKBfw0aNHo3Xr1gDIQq/QBKOTlpSUBPwe4Qh7S7ILCXp0YdcydiroHo8HHo9He6CQhV6BCEWnrF69etDvGYmE2uVCgh5aQiXo7L6s/oMh6Cz8th1I0AMMbXBRTjgH5gJI0ENNKC10nmC0427dutlOG1WCricYnbSwsBB//vlnwO9T0XHaEULtQ6dB0fDEzp4L7777rva3PkKrajtevHgxzp49q5TGyT4RUSXowRCFzz//3OfzTTfdhFatWrl+n2iHXC7Rhd36tpNu9erV2t96QT958qT0dY4ePYqhQ4firbfeUs6DXaJK0PUEopMOGjTI5zPF/HAHstCjm2AKulmaYcOGobi4WOo6bEJEMNewRLWgE8FD9KratWtXXHLJJVLpQy3oZKGHlvT0dFvp3NrMhv9OVtCDOZDKUF76H86EWhQIX5xshEJ1R8jgNJaL6DvZRXF2/e5OiGoLnUQhfAj1tMWK4nLZtWsXjh8/HupsaFSUcjHCaf5E0Rpl15aQoAcZEvTwIdRvVxWlrVx11VW4/vrrQ50NjYULF4Y6C6bYmTHCHgJffPGFFrbZicvl2LFjQduuL6oE3WmndJJethEQYkIt6BXJEj148GCos6BR0Qf97dQbewgY7ekgY6Fv374dnTp1AgC8/fbbrm2o/eGHH5oej2pBVxUFJyISil1dKhJuv3bStEVCBieCzsPXv4zV36lTJ59Nf9xi2LBhpsejStD1qFa2kwn/0S4ITl85yUIn7GBHVP/44w8AvkZIqOp/9OjRSudHtaCrMm3atFBnIWoJtaATYoIx4OdETMeNG6ec5vDhwwCMBT2Yba9hw4ZK50eVoOsbhmrF/Pbbb7bvTQLkjFDPcqH6ExOMchHVtWo8fTvwgs6/nQezLajeiwRdAXK5RC/6tnPgwIEQ5ST6EPU71fgoPLJvFRXBQidBNyGUgk4+WGeE2uWiv1+bNm2Cev+KSqhcLo5ihkuu3OTPC5WFrkpUC7oqTl7znDwMiNALOj2QQ4eo7B966CHb15MVdP5hxbc3stArCE4tdCeCToLgLk7Kc9asWcouk4pslUU6orqW2TDayIiyI+jkcqmAOBVVcrmEDjct9KeffhqPPPKIo/sTwcNuv5swYYLwe9lNZy6++GLHeXAKCboJ5EMPX9wS9Fq1atlKLzq/S5cutvJAqGG3rrdt2yb8XtZCr1SpkvY3WegVEBVBFx2zcrmYXY986M5wY9qiaK9Iu/cHjAWDcBejurZqA0Z1XFhYiK+++kopD6EaFO3Zs6fS+VEj6MuXL8ecOXOkzxc1FqupUmarIemV3V3slCcfg0N1dga9YYnxeDzYsWOHo2mEVhiV/WeffWaajrlWunbt6nfsm2++UcqDiqDffvvtwu+//fZbpXsCQJ06dZTOjxpBf+qpp/y+U7Woa9eubXqPI0eOGB6LdkFo2rSpo/RuuFz4AGluWOhEebn06NEDo0aNCtg9jN5urXYCYnV83nnn+R1Trc8ZM2ZIpd29ezdWrVolPBaMQGZRI+gizCpG5F5p0aKF6fXMRDvaXS4dOnRwlN4Nl4sTC72iRxUMNXv37g3YtY3q2uqhzCx0UV0XFRUZGmBXXXUVbrzxRp/v+vTpo/1tphv79++3zE8gCWtBLysr0wLpyJwr8x1DJMCHDh0yvYeZyES6hX769GnT4999953taxcXF/uFLHXqcomPj5dOt3btWjz44IPK96uolJWV4dChQ3jmmWdw6aWXOrrWxx9/DMD+AqN27dph06ZNpucY9R0rgTQT9Hnz5qFly5bCdAkJCabGm1nbMysHEnQLFi9ejMsuuwz5+fmW57oxo2XhwoX4+eefDdPwDW/w4MGGxyKNoqIiXHjhhVi8eLHhObt377Z9/Xbt2vktJHHqcrFyn/Hs3LnT8FioNngwswStmDlzJi699FK89957lkaKFVu2bHGUfvfu3XjvvfdMzzF6u42LM99B08lenmbCbNf9pmJE2CWsBZ2JhN3QrGYVwwS4c+fOPt9v27YNJ0+eNE0D+DeISHa5sFjvubm5Abm+aEOHsrIybNy4UTjgZQRvoatYS2btxMhfGmjatm1rO20gZucEMgSAUfk//PDDphFQ7VrEZWVltn+PWbqEhARb11QhrAWdPfHsruCU8aE/8cQTuOaaa7TvBw8ejOuuu06Yxky0I9lCD8XeiWVlZZg2bZrSRtO8oKvUB01HtcZO3cu2G7O6MosXzix01bw5EXSzt4JgDKxLCfqmTZuQlpYGoNwq7tWrF3r37o2nnnpKK+wJEyYgNTUVPXr0UN7NvVevXorZLoc9gWW2hLLrQz///PPx9ddf+xzbt2+f9D0YJOjucuzYMeU0vMvFrfqI5HoNNLJlZ7eMzXzoZlgJr10fejDaiqWgT5s2DcOGDdPmmT7//PMYOXIkli1bhrKyMmRmZiI3Nxc5OTnIysrCrFmz8MwzzyhlYsOGDbYyz3xoZ86csTxXVAnZ2dmGlcMEXcUPZ1ZhkTztzUrQA9GQn376aeU0/IN//fr1rmwLGCwL/eTJk8rhCio6sn3CbhnbtdCt0oS1oDdp0gRz587VPm/dulXzK3fr1g1r1qzBhg0bkJqaCo/Hg4YNG6K0tNSWBaUKc7nceuuttq/B/zYe5nJR8cNFqw/dStBnzpzpyn3YDuxA+VuS6kOSF/Tff/8dL7zwguM8BWOjBaB8B/r58+cH5V52sCOagbbQWTqrwVM9Ri4XNjhuV9BVN4pfunSp0vkAYPlL+/Xr5+Ni4H9sQkICTp06hYKCAiQlJWnnsO/r1q0rnRE783yZSJ44ccIyvVGj+OWXX4Rp2UDr2bNnhcetvtMvZigsLKzwc5ntWqzsdxUXFwt/45IlS6TSyzB79mwMHDgQALBs2TKl9PrB7J07d0qlNSsXo/bhNqI82L2v3kXpRv5LS0tNr/P999+jSpUquOyyy7Tv2Ft/SUmJaVqr/BkdZ2Vm9kAQpS0tLRXmiU3NPX36tOU9RWRkZFiGHPj111+1vxs3biy8z8SJEzFixAhherVHF3xdEIWFhahZsyYSExN9NmNl36uQmJiomhWfUWM76YHy3yNKy6zBGjVqCI+LvqtSpYr291133YWxY8f6HLObx2Ciksfrr78eJSUl2nTFypUrC9Nbua1k7+nxeHD11Vdrn1lHlU2vt9RKSkqk0lauXNn0eDDqlW9bTu+rLwc38h8fH296nX79+gEA8vPz4fV6kZSUhHfeeQdAeRAss7T8m5kIo7Ts7VpUdmZpY2JihG2ZiXXVqlUN71m9enXDe23dutWyrHkLv1atWsLrvf/++4aCrjzLpU2bNli3bh2A8ilbKSkp6NixI7KysuD1enHgwAF4vV7lGAR2cGNep9FrEPs+kl0uS5cuVY5pwbN161Zs375d+91O5v3K4PF4hPUh63rR17Wsm0A1iJsZP/30k9SYj9P7BBsVlwvrC7Jtz27fYelUXS5GyPxGpxMD+PRGDwezNw7lHvjqq69i/Pjx6N69O4qLi9GvXz8kJycjJSUF3bt3R3p6OiZPnqx6WVuoCLpRh2jcuLHw+759+wKwL+ih3tRYhnvuucfR+AODvYkYNeYaNWpof1944YW27+PxeITpZcVOZjaUKqr1eu211wrjCllRkQTdqXGiOu5g97ezdLygp6amSqUNxMIitzBrc1KPrsaNG2sLKJo3by501mdkZCAjI8NmFu2h8uQ1qoQGDRoIvz9+/DgA+4Jer149tG7dGj/++COA4A2ehYKPPvoIQLnFvmvXLjRr1szneJ8+fbBixQoA5TOLjJZcW2E2i0bm7UAv6G5Ms7TzoN6zZ4/j+4YS/TReFRYtWqQFanNjHroZjRo1AgBceeWVAIAxY8bgnnvusWx/RoOi7Ds339j0HD582PIcs3uE9cIiN1b7ff/9967d47///a/2d6VKlXw+//7779LXCVeWLVuGq666yu97JrbXX3896tWr5/p9w8nlYhc37+P0WiLjRLYsBw4c6Bf4ygq7bwT169fHhRdeiMsvvxxAeV+uV6+ez8CsCCeCbjXeYoWRb5zHVZdLRcLu/HUes6XDgNpbgJmriVn80QjrCG76F3lkLLhvv/3Wbx53qCx0oDwcK9s9SYZAPjhKS0tx9OjRgF3fikBZ6EyY9WW3fft2y3QigmGhy6SPWEF//fXXA34PtyKkWUUjjGTcEnQjZDqByG8dSkH/8MMPHd/bLcaMGWMZGprHzHpVQTamjBNB59PLDtofPnzY9DeqrrGx2oiDRyaPESvoKth9cjqduTFlyhRH948EAi3oMh1eVP6yQhGIulOdoRXI9rN161bH17BTt1aWMsOuy4VZ6KyeZYyzkydPYt++ffjiiy8Mz3n88cdN76mnW7du2t9z58419SyI8rh582Z06tTJ9B6MiBB0mXm0djuE0ylPgwYNQq1atRzFAw93rDo7GzC1ex27gp6TkyN1Xz4t37Fk7y2C34A42OjLolq1agAq5kwswH6oYL2gyxhnbEqpKNwza39OtpocOnSoaewqURtv1qyZT3TNiBd0mSD9dgXdjstl0aJFPp/z8/OxZs0aW/ePBKws9NWrV0tdxyhssUzdumXh6uvWLsx/LjOrAXAv/4cPH8bnn3/u8x0byJNdmh7st00zi9iMjIwM7N+/X+vDVguUAPP+LvMW4rRsjB46/HUdT1us6ASyQ9sRdNm5rtGC1fQ0p24tuxY6UL70W2WlpP43yIiEng0bNmjTZWUXGbkloo8++qifC4OFZpC9h9uCHugona1atcJbb70l3LxZJVSuHZ2ZPXu2XCb/P+RDh/ORYTPc3Daqor7SBhq9oOsHs512aCf137BhQ6X9MPV5tTsNk22dOH/+fMfbwKlgZ5WqHlF5BzN0sioejwd33XWX0H2q32ja6b7A+rLp3r27ZC7lIUGHfTF1czl7RQ/OFSj0gq73ITotY6f1/+eff0rfi89rkyZNcP7550unFTF16lSpbeCC4eZwcg87gm53gZlTbrjhBu3vV155xeeYWTthMWHYQiURRmX45JNPKuTQH/5NMOJ96MH0oTohWqcu6gVdL+BO34KcuFxk0vNpeeFq0KCB47euirSCONguFyaQwbbu27Vrp/2dl5fnc8zMCq9WrRquvvpqU5eqUdk4fQt79tlntU2GyEJHxXB3BCKWSDigrx+9oAfDQndre0A+rzExMY7bleyUPNmZQFa4EaMk3Fwuevg6VI25ZFXn/PUmTpwovKcZRnVQvXp13HvvvZZ5rFCC/uijj9oK6g6Ub1BsVBher9d0BF8Um+KBBx5Az549beXFCBL0cvSd36kYyIgqs4RbtWrld0zF4vR4PPjmm28wa9YsxMTEBC2KZlZWlt93FeGt0wkVMf9uCjofYsCNsTh27bBxucybN09qitIrr7yC5557Tvu8ZcsW3HDDDVi4cKHw/JUrV5peT5QuEI1t2LBhrl8zHGBlyWKZuy3oMnXFHqYiS0nVym7Xrh1uu+02xMbGKqX9z3/+o3QfK1RnUFgRbJcLiy9uVv9sEww3cbJNXH5+PqZNm2a4GIsvG17E9YJu581OptwrjKAzS0emc0+ZMkULjs9z4MAB4flWsxisYje4xfr16/HUU08pb0UV7rDyNdoHNBg+dGahi2Y62N0UOCYmRknc3NjyjsfOvqoVyeUis6OZzICxKmZ5tXrjOnLkCAC5OFLJycmG9zRaLNWlSxfD68m08woj6EbWtQpGwmDV2EQNNFCvg7Nnz8aWLVsCcm0V3Ji+pkKdOnUM/YgbN250dG0VQbezQYaZoIcyfIAdnBopP/30EwYNGuTKdWXKzs1pwww+r6o+dLbC12gwm78eW4ELyFvorVu3Nrx3WFno+fn5jq9ht/KNBD2UwaQCye+//44LLrggaPfTl6V+2XtWVpYWN97u9a0ws9BVZrnwqAh6RRiUt0KmHJ1M3wkAACAASURBVEePHu3a/WTeynnh/PTTT7F8+XLH95Wx0C+++GLhcdZ+jCx5s7Yiuo9selkqjKDLTN/q3r27zxxSPXZnS4g6WyAFPdSw18ZgwpdlQkIC3njjDZ/jTqZ0bt682fIcJ4Ju1Pk8Ho/0oGigBk+DGSd99+7dyM7OFh6z01c2bdpkeQ7vnuzevTs6duwodW32W8aPH+93TMaHPn/+fOFxFQvd7J52BD2sXC4yISY3btyI3Nxcw+N2BT3Ys09CbaEHG9HDke0mw3Dy8HzggQewfv1603NYB2SbFevzZ4ZRR1IZFA2Uhc4HbZLBSTnfcMMNhkK0efNmV96y9djtm6xORZa2jIXOu0t4mEGgKui7du3y+aya3uoYo8IIuhshPO360EWNVC9Cop147BJqQQ/2m4dI0GUfviLLXZRWdvCsU6dOfpua2LXQVVwuVha63TZhNBEgEPDL5PUDmrt27cJDDz3k+j3tLrwqLCwEIG7rZvPQ2Wcr962qIOuvF/EWOsOJJTNixAip1zg9MoKelZVlOmBhBgt+xF8bKJ+2deLECVvXdIJTQR81ahQWL14sfb5I0PWfjQRZNDVPJOjHjx+XEsW4uDjDTmyEkUtnx44dmDdvHubPn29pndp9aAQTq3LgY7iLBI3Fp1HFrD3anRH26KOPGl7bbFCU1YORwWG1a5FRPcoOikaMhc5w+mo6atQov+/0AXj0mPlIeXj/q9VepDzXXXedz2dWMbfffrvh4EsgcSro06dPx4MPPih9voyF/sADD0jvBCPK/3PPPYeZM2dapo2NjfXrGP/+97+xd+9eQ0EyWsfw22+/AQAeeeQRn3URIuy2Qbcxq3u9W8AMUT8NxIwUGZcLW0HJwzbPEAmzjA/d6rc4FXQ7LpewsND79u3r89lpwxYViNXIfHFxMUaNGuUTuF50HV7QzXY0kc0jv4l0MAl2kDBZlwt7TbbCqEPKlKeoo27cuBHJycmWmwebYbbpQW5uLi655BLT9MGaBWMmZvzOOlaIfm+oBD0zM9MvP2Yhm2V86FYWulV6/RunG7NcwsJCv/baa30+G/3Qb775JmB5yMnJwfTp0332eRSJkOq2YUaE2od+9913B/V+soJuNNtIFtl5zYEofzNf76+//mqZXtaQadq0qXSego3dSQlmIvnll19KXUNvpMgKutE8dKvfYrTZCqtHfZz8qBF0/WwHox9qNruFx4mlYxVzxC0LxKmglJSUOBoMM7MmA4GsoIvKReRDldnVxYhQCLoMsoKu4uoKNNdcc43PZzdDTTNmzZrl990vv/zi951+OiqrYyuXi10f+rvvvis8fu7cOSmdiFiXS+/evX0+O+0Y//vf/wyP3X///aZp+cK0crk4EQWnbqWJEyeiTZs2Ibf0ZZkzZw4OHjzo852shS4SdCd7i8bGxirNWJKdiud06qtsXYpWaa5atUr6Pm7OcHI7DLIsdjcVYZi59qx86DKD3zLlEDWDooEUKSsLwspCd7Jh9Jtvvqn9/fPPP9u+DvC3hcJfsyIj2t1ddgn+0aNH/b4zCnIlK+h8jA0rZDeSDlYY3YSEBL/vRFurBQO7U1GtrsOj35TbCKMxCtG1J0+erP190UUX+RyzcrlYTY81stD1K7OjZtpiILFqcHyBidwETiyQCy+8UPv7+eeft30d4O+gPzVr1nR0nVAiGo8QNdg5c+b4fXfbbbcJrxmI2CBGC0xUkLGKzQRd9qHiRl6sZuPw6DdtCITLpUWLFrbSmblceNFs1qyZzzHZWS5GGAm6fiu6xx9/HIMHD7Z1DzNI0Dn0gqBv/Fbhb+Pj44Xxto2w+/rLrLQ6derYSl8RsBP10AojQedDsFq9ZenHavgFNLt377aVL5l6NpsGy3aqccrRo0cNl+4zzKL96etHv6zeqH85eXux64I1GxStXLmy9rc+b1Y+dCtOnTolNXf+8OHD+PTTT/2+jxoLXaWz2w2Ha+VD51//RMdbtWqF/v37S+Xp3LlztgWMNbqKsBjFLjIWulncHhFGDZ4PtWzVUfX35K+ZlJSklB8V7rrrroBdm/H7779bnqMyF50XRsDYqnUi6E7buJWgG81ysWuhP/PMM0qLofQ++bKyMtSoUUPolg1LH7obGDUgpy4XqweC1+uVtrrN9iW0gjVyOx3l22+/tX1fWRo2bGjZ+ESWsr7zys5sMkrP4EMFs45qNnjOEw5REmUJtAHAyjY3N9en3Kzu6yQ+uRFmLhf+u61bt2LHjh1+9wtWeIwmTZr4fC4rK0PdunWFm49XeEE3CvIuQqWAzWJvmGHlcuHRRwsEygtc9lXNbuyaRo0aaRsl2LHwRTvcuz0QXVBQYHlN2WmLKsgu/QfKHzoyuCHosm1X5ferDOwyArFojycmJgaFhYW44YYbfKb1VWQL/cMPP0RKSor22ev1SvVhN2M76XEyi8u2oF933XVIS0tDWloaHnvsMWzcuBFdu3ZFz549MWHCBKlr1KhRw+7tTeEbAV8IVv5TK5eLFWaC7oZolpWV+cwht9PYRY2ldu3a0itf9dMPjbD6veeffz6GDx+ulMYKowbP/2ZmReoXfqheUwVZQVe5lx0L0umUYKvt4GJiYrR78O4dJ6LsNM+icjIbe5KddhioCK1mYbsDZqEXFRWhrKwMmZmZyMzMxJtvvonhw4fjvffew/Lly7F582ZXoifyWO0LysM3IP5vq/1K+Y14jQr2qaeeMkwv+3S3w5w5c1C7dm2f75yEH9AjG4bgsccekzrPqvHFxsb6hWRwKugywsHqJxAi6xRZ8Wrfvr3fw1AGN10uojcEIyHk7yvaNk/G5SLb7hhmLhczwZbtw/v37xfGjXKKmaAHzEL/8ccfcebMGfTv3x99+vRBTk4OiouL0bRpU3g8HqSmpmLNmjV2Lm2Iiu/XSNATEhIwadIkw3T6SI2iguWnOekLWMWHrsrnn3/u950dQXfy9Af+3tjXCjtC6FQ8N23aZDol9K677lIe7KqIgr5y5Up07txZ+fpuCrpox6vvv//ecPcvRp8+fZTuc+7cOaSnp2PcuHFK6cxmucydOxczZszAeeed53dM1kLPz8/H9OnTXXdXnjt3ztCToF+EKcLWSpmqVati6NChSE9Px65du3D77bf7zIlOSEjAvn37LK9TWFgoLBCV4FGXXXaZ38KVkydPak9ZPp52UVER7r77bmRmZho+cNi92SuVPi/8a+fJkyd9Cv/cuXMoLi4W5t9sRx6r31tUVIRt27bZSqvH6LX57NmzUmItOkcUF/zUqVN+syCs8nr69GnLc6yOv/nmm8jIyPD5jv3mypUrS5UXfw6/qtAsrdfrNTxutH9rfHy8z6t7fn6+6QNk+PDh2j30qx3379+PmjVrmlqXsm1F5jzR7/3zzz/x9ttvA4BPP+DjnojmuRv1GaC87szK1ijfrBz/+usvv7R16tRB3759sXjxYu3Nn51z+vRpeDwe6bI6efKk9gBgv23IkCFaer6/dO3aFZdeeqnfwjj+XkwnRPevXbs25s6da7ri3ZagN2/eHBdffDE8Hg+aN2+OGjVqIC8vTzteWFgotehFtOoNABITE6Xy0aFDB+Ey3mrVqmnX4K2SKlWqIDEx0fQJzNLFxsYiPj7eLy+877V69erallSHDh3C7t27fe6tz5PVPY2YNm2aYTAg2bJiGPmO4+PjtfIxQzZ6XUJCAqpUqeLznejab731Fh555BEAkLq/zO/Vn8PyIXN9fXr+N5iljY2NNTxuVPdVq1b1EfSqVaua3qNbt26Gx9u2bYuRI0fi2WefNUyvf8AaYXSPdu3aafPlWd/o0aMHvv76a+0c1k75vvPdd99px6tXrw6gfApo586dsWTJEmE/Y3g8HstyEeWbtcnExETDtCwvfNpKlSqZ1qWeqlWrauX6f//3f9o1+PTsb/aWrRf06tWraw/iuLg4v/Q89evXN82PLZfLRx99pM20OHToEM6cOYPq1atjz549KCsrwzfffOMzcqyK7Gq1FStWCC0ao0FRhkyYViNfFv8dfx+2ejEQmy/L7sYjg1OXi+xru6yrgp9/HWj3hp3xDdk8mZWfUZnrg6RZlS2ff1GHt9rcxe7CKNH92d8LFiywHJsaOnSo6XGzstuyZYutOeEy7Vm/WTlQXgcq7YR/ILO3ddX88u5Uq+BeVi5dW4J+//334+TJk+jVqxcGDhyI//znP5g+fToGDx6M1NRUtG3bFldffbWdSwP4e7cRM+bNmwcAwvmafCGL/JIyGyksWbJEuFMNX6B8Z2c7D8ksFVeNu20WtlfVh+dkwMXoPNE17c4SCiSBFHQ73HrrrT6frXzo+vzfeeedPp/Nyu/YsWP417/+pZhD4/vzg8tWAiYq9xYtWmj5Ncr3xo0bkZeXJ7UJuBFmZSISdCsf+tKlS30+83XG+r7qpjW8e8VK0K3asC1Br1SpkjajZdmyZejQoQPat2+PVatWITs7Gy+++KKdy2rIDPaxAQKROL7++uva36JpdrJWJtuRhocXL/2TFTB+OrOG9cEHH+Af//iH1P0ZZpUoGiw1w00LvWfPnobXtCPOZuJZrVo1YVwXGVj+7Fh6ZnniZ17xi1Nkad68uc9np1P0zLC7PRwP3w5VVl3zeDwebNiwAQsWLNC+KykpEYbEZaso7WzTKNP+RC4oq1kunTp18pnhw5creztXHfjl2+XUqVOxceNGw3MDIuhuI5rKJIvo4cFPmRStyDQS9BtvvNHyfnxDZj4z/ppGI9TsqX3JJZcoz4QxO//48eOuXUsGvuzY5iT33Xcftm7dilq1amnH7Fi2Zp3wjz/+8AmroBJp8pVXXgHg//a0evVqy7Rm843bt2+vbTghO/uHd5XoBcXK0AhlqIeSkhJs2LBB+8y3I15kRNa0/kHQqlUrn7Yyd+5cv9jqwN9CZ6fNHjlyBID7Frr+mnw4ENnNMfSo/L6AuFzchg2K2UE/8AaIxYSfY27UMVggJjv+UKsYEE2bNkV+fj5atWql3EDN8iOzGw6PUwudtyKHDh2K/Px8TJ06FY0bN/aJKCkKmWuF1+sVvhWJkF0YxKMXdJnVllYLSFh9mz3AWJknJSX5iLi+Lqws9FCGIdBbjXze+b/5AVCG3bUZZmsGRowYIfVQVxV0VR86D6sf1f6t8uYYFoLu9txtUcNv2bKl9reRoLN0ZivirARdJma6vsHwM4T0tGzZUrjzPeO9996zvJ8MdlwuZvX21VdfKedh+/btuPrqq31mTRhhx6UjGt9Yvny5aRomsnwMbR5W37LWs1nsclVB15eB080RzLDaUs3sfkauGqv8m90jIyMD99xzj2kerDAKEGf124wWTZrNfefZuXOnz+fZs2djz549pmkYYeFyERWAmTVitbenKK1+vrgI9r3Z6zOf1+zsbE38rVwuRtcA4PMqq4e9OrqFnZ1S7Jxnx5pkg3Yy/l47cbJFVn3Hjh39vhs7dqwW86akpAQJCQl+A5AMGUHny2z8+PHaoiB9WVoJulXZr1y50vAco+/1waEA+Oyty9C/CRu5XETInqsvQ9VVvaqI8mLHQmdjO7IuF/0Mpc2bN+Mf//iHVFiNsBV0s1ddq2lQXq8X586d85nuxwutUcexY6Ez69pqUNTsGsGK7AY4F3SzRsf/djf9vaLZGW3atBHuZmSGbFzxyZMna/O5//jjD9OyYSuHza7NW27sH/89w6rMZB6SRiFyja4temsZNmyYX9707VqlzbKJC48++qjfphhmeVQVdKtVqnqMtkG06sN6V82///1vn3tZia7I6PN4PJg6dappOnaeGRVW0I1iCj/zzDMYOXKk6fW8Xi9effVVn8bDV5LRpH3WYZiFLrICjcSYpbEj6MHEztZXsvAN3Ym/V18+l19+ufA89qYmigsjgh+Is4KVx5gxY0xX+TKfuFn0Rv30PPa//u3AjUFRkV8Y8K0PfnDZaLGRUZxwhorL5eKLL0aHDh0wfvx4qQ2aGaqDoqpt2EjQLa1g3XG2rkVW0GVi3sje2++45RWCgKjCeCuar6gGDRpIjUJv2bLF5zu+IDIzM/HZZ5/5pWMFyh4mH330kVReeey4XIIp8EaiNm/ePKXdlkSINtGW2VRB5bp61qxZg++//17oOnGCqjjo/aI8bPqd/nd07tzZZ4MDpz50AHjiiScs0/LtTTSpQHRt/b07dOig/S2KicJTWloqZejoBY3lM1AWuihPMha6Pp8stIPsoKhIlD0ej1zwrXAQdBG8hc7/UH3EQcB3v04AuPnmm02v3bhxY3Tr1s3ve3Yf5u4xauw8KgM5jFAKutnybzNLVI8o2h8f7oGV5cMPP6yQu3JU9nK94oor0LhxYx+BcQNVQc/OzvZbdMJgZcV+h9G13RB0owFlI+vPjqCvXbsWDzzwgPb57rvvNk1vFHBqxIgRpnlU3WxCJIiyLhf2QJbxoevzye4r60M3+j0RbaHzgs770/v16+d3rn5Qkd8HUgVW+axjGfm6eIxmP5ihv8bRo0eVd+exC5uT7RQ2B52Hj1HBGjezXow2djaC75wygZJiYmKEC7YCvfqUh58aK8IqFruVoDvZsNrI+lN1uTzxxBNo27at0qCokaC3bdsWH3zwgWEeVd12LM+yscr5fLN2+ttvv1nOOOnVq5fPZ5ZPWZeLETKC3qRJEzz33HOGxyusoPONm68gUWElJibimWee0T5bBeI3Qr9Xp4yg66cNSgWh1/2Gxx9/3HL/zCVLlhgeU2n4VjvI//TTT4bH+Fjwot/Jv3qzPLF6NNpr1Qi+/mVjkLRt29YvFIRMfYjmo8s+CMaOHav9PWvWLNOdbJigz5gxw2efU4YoABvLx5AhQ/w2cDbKo6g9uOVyUY1LDpTXpZHbjP9ePx1QVdBZH+HdrbIWOjvvk08+sdQP/iHE59PuPHT9dcyIi4szDRFdYQWdt9BllkQPHjxY+3vmzJmWu5sD/qva9CIkI+h2sHON6667zuczv9uT0xgdPNdee61hw+Lnw1sJnv7hqLoajq9z2Z2tYmNj/drK4cOHAcBnqbnofnpkBb1evXo+n802WWbRRevXr4877rjD7/jAgQP9vmPl161bN+kyFFl6fH/q3Lmz9uCWtdBVrU8+vZkPnR/E1QehY+2wR48eUvd86KGHAPi2l0BMs9VPm3ZD0D0ejyszwyqEoIsaCW+Vq1rcsnErmjVr5hMpTu9DFzXCUAk6T25uLjZt2oR27doBEA/e6jl8+LAwXoYImd2LrDoKc5PYFXSW7r777pOOfRMXF4fS0lKMHDlSm17J/LtmfnjVwTS7sIByRohcBWbTYY3cWCJx4h8gDz74oDYWxcRJH1DKyEJXdSd8/fXXyMnJMbTQeXHUzxRi99T72nkWLVqEl156Sfu8f/9+jB8/Xipv/NuqG7FuvvnmGwD2+ndZWZlW104mJ1QIQRcVwKxZszRrSyZOBruG1Yi7nldffVX7mxWomYWut8j0GMV45zGqcNmwwU2aNEG9evUwc+ZM6XQpKSnCeBkiZKwVI8FjmwMvWbIEJ06csL2LOkt37733Gk7F0xMXF4f8/HzMmDFDq1cWWVNGiD799FOlPDKSkpIMj/FWV6NGjZSvbSboN910kzCNjMuFn0Hyyy+/+IXfMPJnqwr6HXfcgd27d0u5XPRvV1bhNIDyWE3MsAHK3XN8cD8zPeD7jdmmEbLwG2PbgdU1r0mqVChB55/Qc+bM0aYWGs1J52EzLJzEhWENyMyH3r59e9Pt8Bo3bmx5H6NOYbQMXfQqDpgLiR6ViHXsQcGj960bCTo/aH3y5Emtk9q10FXiXIhWA8ssx2bndO/e3ed7ZkhYDeg++eSThsdUXqP5cSCGlZCKXDwyD2S+POrVq+dXzk4tdH16I0Hn76t/Q5FtA/xvYS42Br9lpNm9VXF772C+zTt5g69Qgn7ZZZf5bBDx3Xff4fjx41IWeuXKlZGfn497773Xdj5YI/zxxx8BGDdC/Wo31cEbowrTf3/27FlUr14dbdq0AeAfB4SfzaMy5dCKFStW+H2nn9ViJOi8Ne3xeDQLWTUEKpu/LjOvn8Gfy8RBRoj0i2DYdyySp8jfzaOvf34WgkpIXJE/m3Vyo/zXqVPHb/m+2fRGNmhsNcfbqaDrzzMSTz6vekGXvSd/nL+GzDianhtvvNFnPE6WvXv3KqfRY1XXMlQIQWeV3ahRI59R99mzZ6NZs2bSgWsA+1MWgb8LlHVk2Se47DQpRqdOnaRcM7fccou2xyFQ/krHB/LyeDzasmr9ZglWWMXDsUL2IcZ25THzy+sfwh6PRxsEVmncMuEdRPDixWbUlJWVae1OJZwqAJ8ZLCr5+Oyzz/zWR8i4HfQuKX3d8G8JLIa7XUGXtR715xmFKjab/CDrkzbadIaFNjZC3wcOHDgg/RDQ50km9LYVzJAKews9Pj4ec+fOxbPPPiv087JASTKoWHR6vF6vz0i7WcGuWrUKQPl+gDIuIZ4LLrjANCbK4cOHMWPGDM21w3c+fZ6Yv+1///ufUh7Wrl0rfa7ZDBFZzIRtxowZPp/5LQLtWujs1ZvVp9kuVaJtA71eryZqVnkQva2w36victm5c6ffNnLMr28m6HrL3kzQmVtT346s3sD+/PNPVK5cWcoQEV1fpg9PmTIFtWrV0lyJoqmdIkTTDwHrervkkkt8PjNXo8wG9/rxEGZoWS1qZLz11ls+n53sysRTIQQdKN/lo169epg+fbrfMaNd02V5//33pc7zer2mm+zyXH311Rg1ahQaNmyobKFbkZGRgZEjR2od1ezBYvf1rFGjRtpvFb1ishkxpaWlwtWeqrNAVCxV3mVhV9D5JfVAufVlxDvvvINly5b5fHfu3DnpV2DR28qYMWMAyP3uuXPn+nxeuHAhvv76azz99NPaJipmgq73E0+ZMsXns+ihorfQW7Vq5SMq+vo9ffo0EhISpN9aZa3M66+/Xvv7hx9+AODMhaki6C+++KKPsLL+JjPJQB/SmpWL7Iw8fi9dPa1bt5a6hogKI+gMkR+RTUuSdRPol6XrB7uMOHfunJJQxcfHo6SkRLPQzQI0ycAaJuuAbKDXrHPYfSPxeDwYOXIk8vPzhddYt24dAGPfvGqnswp3a7QgR2XgihdPff7MyrBWrVp+m5qXlpZKuxlEbYaJk9mMKYZ+y7J//etfeOihhzBr1izTKbQM/QNHv6u8jKDr76H/TSUlJdKzjfTXNSMmJkYYzsMoIJvRNRj8ALVV36hUqZLPTCGVQckrr7xS+7ty5cravfhtCa3Iz88XakadOnWkr6Gnwgm6CNa4ZDu3fqGNbLqtW7dKTx0EygW9uLhY63SffPKJdFoRLIwA+72sA6kGGJLByO/IePrpp7Fu3TrDe+sFUARv/dx3332m54oGYgG1Bxbv+tJb5Kp+SV7QrR7youNMZJigi2YOGcELMJvP7+QtTVbQjVwXZWVlOHTokFJdbN26VdpaFeVfJaib0e+X6Rt8WpmHr4izZ8/aXp3Oxz9yg7AQdIase0FvyatUkMrIeHx8PM6dO6eJm4oFI4LNrrGKdMcj02j17gfAWtCBcreL6NjGjRst5+MDvoJulU+jOlJxKfEWur6DiaxAMzZs2CD9FiIS9DVr1gD4W0xVLE7ehceCRqkKOj9mMH/+fL/jHo8HgwcP9tnPl68Dvh+89dZbmDx5slL7Xrt2reZ2AiAMhsdwMn0QMB6nkHmIOxF01TUvIpz+dj1hJegqr3E8bhcaf90//vhDG8RzOnOEobLxgdVv27t3r3BXGpmyfPrpp4WiJjPX3s79RKjUnUhYL7roIgD+M2mMmDhxovY3W0JutX+pWZQ/2Z2s+Fg+xcXFjiNyNm/eXJsqKgoN4fF48Nprr/lEKuXLml/7wGKsyLRvfrxl//792t/6lag8Tud027WOAd9yVV374MZAZlQLut2KD1R4Wr2/zG1BZzNhzASdL5MdO3b4HWdTv/TIWOhGx+z47Z1uFCzDzTff7Ld6smnTpmjZsqX0dfgxHPYWcvXVV5umYVNH9Zw4cULa6uMt+NLSUqU2a/TbVGPRW+XRrAxr1aqFO++809RtY4RVYDorVGeZ8YjmsMuKbI0aNTBo0CCf71Tdrm4vUAorQTeL5R0K9AuenLpcgPJX7MzMTJ/vzGbR8J0wJSXF7yFj1EmdCLqdRhiMmO/x8fF+2xOuW7dOOoYN4NuZ2d6aVnkXhXQGyveD/e677/yuK8JKlMzyYHRs1KhRfisnzTDKI7v+9u3bDdPu3bsXb7/9tk9e+PjwZoL+xhtvSOdRhMzCQyNELheVtqpvbyq7Yunv7wZhJej6qWVuMX36dJ9Ra1n0FrldQecHRkQbNXz11VeGafXugAEDBvh8FvlPAeOpXnqcbCWnyqxZsxxfw8qatsJqVagKMTEx2naJVtavPg6IGxZ6dna2MG696nVUEM3pB8zbWHx8vN8mNSo4sdD5cmZz5VXKwelbeVS7XOzs9C5Denq6LUHXV4aqK+KGG27A8OHDTeekAuW78hhh5pvMy8vD+vXrhcf4Dmb2yqsX9AcffNDwXDNkBEoUM0V1U4f4+HhtOzrVcANA+VugHWETTT/zeDzaSlnVtsGvCAbMjQXR7lEMfnDUaiBb355LS0tRXFwsHY8eMI6XbjVTSDTOAwBvvvmm5T179OiBIUOG+HwnG3KZr2vmnnQi6CrrLQDna2z0hJWgq8CP3sugWhGA/yi36tN68eLFGD16tGUDMtsAWSSUoo0S9PCd95ZbbjE8Ty/osnP69dh1uai+wgJ/P/j1KwFlMQvoZIQo8iFfr1a/3+yhDQAtW7Y0PNa8eXOL3JVj5XrSt0O22E9lbYaRxWl1jZdffln4vcw2kNWqVcOkSZN8vjPaik+PqF5UHr6ih6AKTteu6AkbQRdFojNDVUDsrPbUV4ZdH7/Va5fVLAu9q+Ltt98GYOwu2bFj/RlVpQAADKZJREFUh7QV8uuvv/p8lilXUQyNYO6bylZe2l3By+9CJLu5gqismQ8esA4B4PTVu2XLltLL8o3QvwWYRRVVxcp1d9VVVwm38LNq+0bIPAgAcbtUqYvExESfz/pdpazQu4vM3rhlCBtBd+Jjk6F69erKaf75z3/6fLYrWk5/mz4uzLhx4wAYx5VQ6ST6kL4yDwKREKjOA3eCU3Fs37699rc+sqYRIgt02rRp2t9OFpBYbYwBlEcmPXjwoLZrjx1iY2OFQbScTAtkyG6vpkel3JghAzhrAypp9Q9B1bd0vdFh5j6TIWwEXXXAsW/fvkrnm7k1jIiLi8MTTzwBwP7mCAB8dlC3g2hPTEA8jRGQt15EyDy09Nc/77zzbPml7Q4yOxV0lTjzDF7QRa/RTjZ4ZmMCMhhNoZRFvw0c8HcEStGAvSwybiFRfau01TvvvFP720kbsBtOQ2WsgaHPp9O3rLARdFURYvN6ZQdH9K9OsowdOxb5+fm2fcuAcwHS7zdqRM+ePQE4m/5pR5jtvoHYrZPevXv7fBa9yssiGwqCt0B5VwsADBs2zDI9e1CK2pHdeDZ26NSpk993LPyA2UblPPrZaO+//77f9D4Rooee3TbgRBjNNiwxw44hMG3aNJ+ZVaqGqB5XBd3r9WL48OHo3r070tLSbD2xRHTr1g1du3ZVSsOERz/xPxJRdfWIzp84cSK+/PJLYZgAHjtxn1XeXh588EEMHjwYL7/8Mj7//HPlewH+A2xGgb9kkB1Y5QVdL6oyLi5WJ6L9YVUsRraBhd23PjMXh6whoI/zc9FFF0kZAo0bN/bZcWzixIm2Z7apPAj0Y1CqfuwqVarYfjNq0KCBT5hgp8adq4L+1VdfoaioCCtXrsSYMWO0ObhO+eyzz5RnO3g8Hvz4448YNWqUK3kIJKyxP//88wG9T0ZGhuEimIcfflhz3fAzLvRBruy8jqrEvHj99dfx2muvYdiwYYauJCucuDf0yI438BsZN2jQwOeYil9bJJoqb0V9+vRBTk6OrZk6DNkZIrKobDrDxn8AXxeKKipGjtUWg1bs27dPi91jl5SUFEeb8zBcFfQNGzZoQXjat2+P3Nxcx9eUdZmIuOiii2wNVD722GM+gYUCTXx8PDIzMzF8+HC/IEZ2B1pFr27Jycn44IMPLNOyGNyA8T6nVsyZMwfp6emGC5sCiZsriq3WCDAaNGiAvLw8rFu3zs/FJNNR+WmJX375pc8xFXejx+PB5Zdf7vdQs4p2yXPNNdf4TaN84YUXpNMDQE5Ojva30RxzEfzDy80Hsyx8LB9ZKleu7HiB0bJly/Dbb785ugYAePLz89V2KjBh6NCh6Nu3r+YHbN26NXJzcw2tusLCQuHsgG+//RbVqlXDgQMHUL9+fZ9ZB04oKioy7RybNm2Cx+Nx9IrulB07dmDNmjVo3rw5cnJycM8990i9dk6cOBGVK1dGv379MHLkSLRo0QJbt25F06ZN0bBhQ3Tq1MlycI0vn3nz5mHVqlWatVa1alUsWrTIUfD9YDJ79mxs3LgRGRkZfrvLyLBx40Z4vV5tINCq7ej54YcfMG7cOKSmpvotehFx5swZHDhwwEfYs7Ozcf3119satyguLsbo0aPx3XffoUWLFn475Fhx6NAhfPHFF6hevTp++OEHvPbaa4bnGpXNiRMnEB8fr+wH3759Ow4dOqTsZgXK3yhLS0stt5/Ts2vXLqxduxbp6emurt5UbTeyGJWpq4L+/PPPo3379ujfvz+A8hF3s/gPwaagoMD2IEs0QOVjDJWNMVQ2xgS7bFx1uXTo0EGz6DZu3Oh4ChVBEAQhj/0dlQX06dMHq1evRo8ePVBWVua3+S9BEAQROFwV9JiYGEydOtXNSxIEQRCShM3CIoIgCMIcEnSCIIgIgQSdIAgiQiBBJwiCiBBI0AmCICIEVxcWEQRBEKGDLHSCIIgIgQSdIAgiQiBBJwiCiBBI0AmCICIEEnSCIIgIgQSdIAgiQiBBJwiCiBAiRtA3bdqEtLQ0AMDAgQORlpaGtLQ0tGnTBgMHDgQAfPzxx+jatStuuOEGTJo0CQCwd+9e9O7dG71798aQIUOkd3kPN/jy+eGHH9CtWzf06tULjz/+uM8Gx8eOHcNVV12FoqIiAEBeXh4GDBiAXr164e6778bRo0dDkv9AIlM2K1eu1DYrf/rpp1FWVhZ1ZZObm4vU1FT07t0bzz77rE+72b17Nzp16qR9joZ+JVM2wdaciBD0adOmYdiwYTh79iyA8u3HMjMz8fHHH6NmzZoYN24c9uzZg9mzZ+Orr77CN998g+LiYpSUlGDUqFEYOHAgli1bhs6dO0dkDHd9+UycOBHPPfccli9fjuLiYqxYsQIAkJWVhf79++PIkSNa2ilTpqBjx45Yvnw5Hn74Ybz88ssh+Q2BQqZsCgoKMGrUKCxYsABZWVlo1KgRjh8/HnVl8+STT2L8+PFYtmwZatasiU8//RQAMH/+fAwcOBDHjh3T0kZ6v5Ipm1BoTkQIepMmTTB37ly/78eNG4chQ4bg/PPPx+rVq3HllVfi0UcfRVpaGjp27Ij4+Hjs3LlT2wO1Q4cO2LBhQ7CzH3D05dO2bVvk5eWhrKwMBQUF2ga3MTEx+OKLL1CrVi3t3J07d2obV0di+ciUzXfffYfLLrsMI0eORO/evXHeeeehbt26UVc2f/zxh7bHKv97a9WqhczMTJ+0kd6vZMomFJoTEYLer18/v42ojx49irVr1+Lee+8FABw/fhzr16/HG2+8gQ8//BAjRoxAfn4+2rRpg6VLlwIo33k7El8N9eXTrFkzjBgxAtdccw2OHj2Kzp07AwBuvPFGJCUl+aRt06YNli1bBqC8fM6cORO8jAcBmbI5fvw41q1bh5deegmffvopZs6cid9++y3qyqZJkyb473//CwBYvnw5Tp8+DQDo1asXqlev7pM20vuVTNmEQnMiQtBFfPHFF7j99tu1HbyTkpJw7bXXIjExEeeddx5atmyJXbt2YezYsVi2bBnS0tLg8Xj8BC0S+de//oVly5Zh48aNuOuuu/DCCy8Ynjt8+HDs378fvXv3xv79+3HhhRcGMafBR1Q2SUlJuPLKK1G/fn0kJCSgU6dO2LZtW9SVzYwZMzB16lT07dsXdevWRZ06dQzPjbZ+JSqbUGhOxAr66tWrtddhoPzVJicnB0VFRTh9+jR27tyJiy++GNnZ2Rg1ahQyMzMRExODG2+8MYS5Dg61a9fWdiI///zzkZ+fb3ju+vXr8cADD2DZsmVo2rSp9loZqYjK5oorrsCOHTtw/PhxlJaWYtOmTbjkkkuirmxWrFiBd999F0uWLMGJEydM+0q09StR2YRCc1zdU7Qi8dtvv6FJkyba58svvxz33XcfevbsibKyMjz77LOoXbs2WrRogcGDB6Ny5cpo1aoVJk+eHLpMB4np06dj0KBBiI2NRaVKlTBt2jTDc1u0aIFHHnkEAHDBBRfgjTfeCFY2Q4KobM477zyMHj0at956KwCgf//+uOyyy1ClSpWoKptmzZqhb9++qFatGrp06YIePXoYnhtt/cqobIKtORQ+lyAIIkKIWJcLQRBEtEGCThAEESGQoBMEQUQIJOgEQRARAgk6QRBEhECCTkQ869atQ61atfD555/7fN+pUyc8+uijStf66aefkJOTA6B8NSQLYkYQFQESdCIqaNmypY+g//TTT7aWXC9ZsgQ7d+50M2sE4RoRu7CIIHhat26NX3/9FSdPnkTNmjWxcOFCDBgwAAcPHsTChQsxc+ZMVK5cGRdffDGmTZuGhQsXYuXKlThz5gz27NmDf/7zn7jxxhvxySefoFKlSrjiiisAAE899RT27dsHoDxUKh/YjCCCDVnoRNTQt29ffPnllygrK8PmzZvRoUMHnDhxAuPHj8eSJUuwfPly1KxZE3PmzAEAnDp1CgsWLMC8efPw+uuvo0GDBrjnnnvw+OOP46qrrgIA3H///cjMzESjRo2QnZ0dyp9HECToRPQwYMAALFq0CDk5OUhJSQEAlJWVoVWrVlr8lk6dOuHnn38GUO4jB4ALL7zQ0FeenJwMAKhfv37ERRQkwg8SdCJqaNKkCf766y+8/fbbuPPOOwEAHo8HO3fu1ELB5uTkoFmzZtoxPTExMT479YjOIYhQQYJORBX9+/fH77//jubNmwMoD6uckZGBPn36oFu3bjhx4gQGDRpkmD45ORnvvvsu1q5dG6wsE4Q0FJyLIAgiQiALnSAIIkIgQScIgogQSNAJgiAiBBJ0giCICIEEnSAIIkIgQScIgogQSNAJgiAihP8HbWeJ5MSNsbsAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -423,18 +414,18 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 13, "metadata": {}, "outputs": [ { + "output_type": "execute_result", "data": { "text/plain": [ "\"the 'monthly sun spots' dataset has 2820 data points\"" ] }, - "execution_count": 25, "metadata": {}, - "output_type": "execute_result" + "execution_count": 13 } ], "source": [ @@ -450,7 +441,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -491,28 +482,26 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 15, "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=50.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "b3f166c747104a0a9cbce7bb71ba599b", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=50.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "b857c8e60cbe47ae8dbaf1360d6d5f84" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "Training loss: 0.0266, validation loss: 0.0198\n" + "\n" ] } ], @@ -522,89 +511,84 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 16, "metadata": {}, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "loading model_best_15.pth.tar\n" ] }, { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=49.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "87ccba5d955e4029b5dff289e82ba204", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=49.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "7c297b04116243c092c683eb48c6f0b7" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "\n" ] }, { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=49.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "f4ac951bd0f7493b85d532f8d4ebe7f4", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=49.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "85bbcf96798845a5bb02cb5761ab22e1" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "\n", - "Transformer MAPE: 784.4277371860912\n", - "ETS MAPE: 593.7817328101518\n" + "\nTransformer MAPE: 797.8750218172952\nETS MAPE: 593.7634916506821\n" ] }, { + "output_type": "display_data", "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAEECAYAAAA1X7/VAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd7gU5dn/vzuzO7P19MIpHOA0kCLSFUX0FVE4QQP2EnsLvrHEWEksKeTVX2wRoyaixorRxBAwFkRQVBAQQZp0DpzOaXu2z87O/P5YnmF2d7acPbunwPO5Li8Pu7Ozz87OfPee73M/963r7OyUQaFQKJQBC9PXA6BQKBRKz6BCTqFQKAMcKuQUCoUywKFCTqFQKAMcKuQUCoUywDkuhdzpdPb1EKLSX8fWX8cF0LElCx1bcvTnsUXjuBRyWe6/GZX9dWz9dVwAHVuy0LElR38eWzSOSyGnUCiUEwkq5BQKhTLAoUJOoVAoAxwq5BQKhTLAoUJOoVAoAxwq5BQKhTLAoUJOoVAoAxwq5JQ+Y9WqVQMyZ5dC6W9QIaf0CZs3b8bcuXPxySef9PVQKP2I7du34+uvv+72637+85/js88+S8OIBgZUyCl9Qnt7OwDA6/X28Ugo/Yn//Oc/2LVrV18PY8Ch7+sBUE5MBEEAAHAc18cjOfEQBAGHDh1K+X7Lysqifp9dXV244447YLfb0dTUhKuvvhpTpkzBgw8+CEmSUFRUhCeeeAJvv/02OI7D2LFjcd1112HDhg0wGo149NFHUVVVhcsvvxx33XUX6uvr0dTUhNmzZ+PXv/51yj/LQIMKOaVP8Pl8AACe5/t4JCcehw4dwsSJE1O+340bN6KyslLzuf3792PevHm44IIL0NjYiFmzZuGdd97B4sWLMXz4cLz++utoaWnBlVdeicLCQkyYMEFzP3V1dZg0aRKee+45eL1ejBw5kgo5qJBT+ggSkbMs28cjOfEoKyvDxo0b07LfaBQUFOCFF17A8uXLYbPZIIoiWlpaMHz4cADANddcAwD46KOPNF9PJsWzs7OxadMmrFmzBjabTTmPTnSokFP6BBKR+/3+Ph7JiQfHcVEj53SxaNEiTJ48GTfeeCO+/PJLfPzxxxg0aBD27duHiooKPPPMM6ioqADDMJAkCQBgNBrR1NSEIUOGYOvWraiursbbb7+NzMxMPPPMM9i/fz9ee+01mvkEKuSUPoIK+YnF+eefj/vvvx///Oc/kZmZCZZl8dRTT+F///d/odPpMGjQIPz85z8Hx3F4+OGHUV1djTvuuAOXXnopysrKkJWVBQCYPn06brrpJqxfvx48z6OiogKNjY19/On6HirklD7B7XYDoEJ+onDmmWdi7dq1yr8dDgdsNluElXLeeefhvPPOU/79s5/9LGJfWumJL7zwQgpHO/Cg6YeUPoF0YRFFsY9HQqEMfBIS8o0bN6Kmpibi8Y8++ghnn302zj33XPz9739P+eAoxy80IqdQUkdca+XZZ5/Fu+++C7PZHPK43+/HQw89hFWrVsFsNuO8887DrFmzUFBQkLbBUo4fXC4XAKCjowN+vx8Gg6GPR0ShDFziRuRDhw7FG2+8EfH4rl27UF5ejqysLHAch1NPPRXffPNNWgZJOf4g1sqDDz6Im266qY9HQ6EMbOJG5BdeeCFqa2sjHnc4HMjIyFD+bbVa0dXVFfcNnU5n2tOF+vOy7/46tt4el91uV/5esWIFHA5H1G376zED6NiShY6t+9hstqjPJZ21YrPZlKgKCAp0ZmZm3NdZrdZk37JbxPrQfU1/HVtvjoukHwLBRUHx3ru/HjOAji1Z6NhSR9JZK8OHD8e+ffvQ0dEBQRDwzTffYNKkSakcG+U4Rh316HS6PhwJZaCwZMkS1NTUYMaMGRg8eDBqampQU1ODhoaGlL5PbW0tJk2ahNtuuy2l+00n3Y7I33vvPbhcLlx33XX4wx/+gHnz5kGSJFx99dUoLi5OxxgpxyGBQED5m2FoFiwlPpdffjkuv/xy1NbW4sYbb8SHH36YlvfZsGEDZs6ciT/84Q9p2X86SEjIhwwZotT6veSSS5THZ82ahVmzZqVnZJTjGirkfYfgBw61pP4uqKxABhcl+cjv9+P222/HwYMHEQgEcMMNN+Cqq65CTU0Nnn76aVRXV+OVV15Bc3MzrrzySlxxxRXIzs7GzJkzceedd8Z837feegtvvvkmZFnGgw8+iF27dmHZsmVwu93Izc3Fm2++iffeew8rVqyAx+PBgQMHcOedd+Kqq67Cyy+/jHfeeQcMw2DcuHH4xS9+gUWLFsHn86G8vBwTJ07E/fffD4ZhYDQa8eyzz0KSpJDxffrppxg9ejR27twJi8WCqVOnYuXKlbDb7fjggw9gsVhw9913Y9++fZBlGQsWLMC0adNw2mmnoaKiAhzH4ZVXXunRsacrOyl9glrIqbXSuxxq0WHibamfq9r4ohOVJdqJDK+++ipyc3Px17/+FQ6HA9OmTcP5558fdV/Nzc1YvXp1wmWOs7Ky8M4770CSJKxduxZLly4FwzCYN28eNm3aBCBYSvdf//oX9u3bh8svvxxXXXUV3nrrLTz55JMYP348Fi9ejKKiIsyfPx+HDx/GjTfeiLPOOgt//vOfcfLJJ+PDDz/EggUL8Lvf/S5kfJ9++ikmTJiAxx9/HBdddBFMJhP+/e9/47bbbsNXX32F5uZm5ObmYtGiRWhvb8fs2bOxbt06OJ1O3HvvvRg7dmz3D3YYVMgpfQIpjATQiLy3KSuQsfFFZ/wNk9hvNHbv3o3p06cDCE4kVlVV4cCBAyHbqLPZhgwZ0q1a9VVVVQCC5xLHcbjxxhthsVjQ0NCgLDobM2YMAKCkpESZo3n++efx3HPPoba2FpMnT47IqGtqasLJJ58MADj99NPx2GOPaY6PiHFmZqZS0TErKws+nw87duzA2rVrlYqToiiira0tZNw9hQo5pU+g1krfwRkQNXJOF9XV1Vi7di3mzJkDh8OBXbt2YciQIUqFw+rqamzZsgVFRUUAun9OkO23bduGDz/8ECtXroTb7cZZZ52liLPWnd/f//53PP300zAajZg3bx6+/fbbkOcHDRqEbdu2YfTo0fjqq69QUVGhOb5Yd5VVVVUoLi7GPffcA4/HgyeffBLZ2dlJfc5oUCGn9Ak0Ij+xuO6663DHHXfg/PPPh8fjwV133YX8/Hzceuut+NWvfoXS0lJFxHtCeXm5stIcAAoLC9HU1BR1+1GjRmHWrFmwWq0oKirCxIkTQ1rNPfvss7j33nsBBNNkFy1a1O0xXX/99bjjjjswe/ZsOBwO3HTTTSk/53WdnZ3HXTFfUlmtP9Jfx9bb45o0aRL27NkDACguLsaOHTuibttfjxlAx5YsdGyphYZClD6BRuQUSuqgVxClT6BZKxRK6qBCTukTqJBTKKmDCjmlT6DWCoWSOugVROkTqJBTKKmDXkGUPoFaKxRK6qB55JQ+QS3k6ug8nE8++QR/+tOfsGLFit4YFiWNrFmzBtdffz2GDx+OQCAAlmWh0+mUBTtbt25FZWUlTCYTLrvsMlxyySX45S9/iaamJng8HhQUFOCZZ55BTk5OH3+S/gcVckqfoBbyWH07Dxw4gIMHD/bCiCi9wZlnnolXXnlFM1dbXUALAF5++WUUFhbihRdeAAD85S9/weOPP47HH3+818fd36FCTukT1FF4LCH3+/0hok/pOZIgwVfni79hN+FLeTBc6tza/Px8vP7665gyZQpOP/103HrrrWnvLjZQoUJO6RPUQi4IQtTtfD4fFfIU46vzYdOMLSnf7/jPxsJUboq5zZdffomamhrFWjnvvPNwxx13aG574YUXQqfT4Y033sD8+fMxcuRIPPHEExg1alTKxz7QoUJO6RMStVYEQYjpoVO6D1/KY/xnPS+dqrXfeMSyVsJZv349pk+fjgsuuACBQABLlizB/Pnz8cUXX6RqyMcNVMgpfUJ3hJxG5KmF4Zi4kXN/4P3330dubi7uv/9+sCyLUaNGgefj/1iciFAhp/QJkiTh+eefR3t7Ox5++GHIsqyZhkiF/Pgi3FoBgoJtMkX+sPzmN7/BvffeizPOOAMWiwVmsxnPPfdcbw95QECFnNInBAIBZGVloaCgALIsIxAIQK+PPB2ptXL8MG3aNOzduxeAdoXB8B6cNpsNL774Yq+NbyBDFwRReh1ZliHLMliWhcEQbPIYzV6hETmFEh8q5JReh0TYDMMoQh4tc8Xn89GInEKJAxVySq9DImyWZZW+h9EicvI4FXMKJTpUyCm9jlrIE4nI1a+hUCiRUCFPkg8++CBm2hwlKM4ffPBBxONElHU6XVSPnDTPJY9TIadQokOFPAnq6+tx/fXX49VXX+3rofRr3n77bVx//fU4cOCA8ti0adNw9dVXA4hurbz99tu46KKL8Omnn2pG5C6XKyXCHnAFUPdSAwJeattQBjZUyJOAiIjT6ezjkfRvSJ3x1tZW5bGtW7di9erVAKJbK8uWLQMAeL1e5XG1cJeUlOCBBx7o0dgkn4Sdt+5C7eOH4NjQ1aN9USh9DRXyJCACRSfgYpOVlQUA6Ojo0Hw+WvphS0sLAMDj8ShCHn6sV65cmfS4JL+EXXfsgWunG4yZga8heq0XCmUgQIU8CUgFNirksSEi3d7ervk8wzCKtSIIAjZs2AAAaG5uBhC0UKIJebLNKGRJxt779sO+tgujXhsB0zAjvA2prwRIofQmVMiTQBRFAKAlNeNAouwjR45oPq+OyP/617/i3HPPRWtrqxKRu91uTWslWWRZxv6HD6Dtk3aMXDwc1jFW8MU8BCrklAFOXCGXJAl33303zj33XNTU1GD//v0hzz/33HOYPn06zj77bMXbPN4hQk4j8tiQ40SEORx1RL5u3ToAQGNjoyLebrc7ZemHsiyj9vFDaH7vCEa8WI2MSRkAAL6Yp9YKZcATt9bK8uXL4fV6sWLFCmzYsAELFizAO++8AwDo7OzESy+9hE2bNsHtduOMM87AnDlz0j7ovoYKeWKQ40SsknDUEfnhw4cBQMlwKS0tjZl+2F1rpe4vDah/uREjFlUj+8ws5XG+hEPHKm0Pn0IZKMSNyNetW4cZM2YAACZNmoTNmzcrz1ksFgwePBhutxsul+uE6YZOrZXEICIcbbKTYZiIQlm1tbUAgGHDhqUsIm/51xEcevIwqh6vQO75of0e+WIevkYBskS/S8rAJW5E7nA4kJGRofybZVmIoqhcgCUlJZgyZQoCgQDuvvvuuG/odDrTLoBerzet++/qCqar+Xw+OByOiOe/+uornHLKKbBarb0+tmRJx7hcLpfyf63j5PV64XQ6wXGcYqfU1taCYRjk5OTAbrcrj3d1dYXsQ5IkzX1qcfhv9ci5JBummcaI1wQyRch+GR0HO2DIN3T7M/bX7xOgY0uW/jq2WI044gq5zWYLyZeWJEkR8RUrVqCpqQlbtgTbRs2bNw+nnnoqJkyYEHV/WuKWDuJ1H+kJpLi9KIqYP38+nnvuOSXVDgCuuOIKXHzxxXj55Zd7fWw9IdXjIvWmRVHU3HdGRgZsNhsMBkOIYFssFmRmZqK5uVl53GQywWazhRTcSmS87r0eeHd5UfWHCs3t+WoewAEY7AbYypP7/P31+wTo2JJFPbaNGzeipKQERUVFfTii2MT1QqZMmYJPP/0UALBhwwaMHDlSeS4rKwsmkwk8z8NoNCIzMxN2uz19o+0nEGtl06ZNWLZsGT766KOIbQ4dOtTbw+p3EGslWoRDrDjikwNAW1sbzGYzzGZzSB45sVa6a7G0Lm8FX8LBNk47gDDkGqDjdHTCkxKVGTNm4KSTTurrYcQkbkQ+Z84crF69GjNnzoQsy3j++eexaNEilJeXY/bs2Vi9ejVmzJgBhmFw6qmn4uyzz+6NcfcpRMiJEJF/qyG2wokMOS7E5w6HHD+SuQIEV4GaTCZYLBY4HA4lAt+8eTOqqqqUfSYy2SnLMo4sa0PeT/Kibq9jdOCLOPhoCiIlDna7HZmZmX09DE3iCjnDMHj66adDHquurlb+fuihh/DQQw+lfmT9mHAx0YoSqZDHF3Jivagnydva2pCRkQGTyRQySXrLLbcgMzMTp512WsLv79rhhveAF/kX5Mbcji/m4aunQk7RpqioCI2NjVi1ahV++tOf9vVwNDkx0kxSDBEoIuBaEbnb7e7VMfVHiLVChDw8XZMIufrxtrY2pT9jZ2dnyPYNDQ3dslZal7XCVGGEeYQ55nY0l5wSCzInRizm/ggV8iQgwu3xeEL+rUYrIv/hhx/w2muvpXVs/QlyXIhHHl6qlkTianH2eDwwm82wWCwRQi6KYsLWiizJaF3ehrw50W0VAl9CrRVKdERRRH5+Pr777ru07F+WZbh29uwOngp5EhAxIWKtFnKSWqkl5BdeeCF+85vf9MII+wfh1kp484jwiJxMeppMJpjNkVG03+9PWMgd3zvhaxCQ95PYtgpArRVKbERRRGVlJerr69OSOu34zonNNVvh3pP8XTwV8iQgEWQsIddCPal3IqCOyGVZjojIiZCT45mTE1ysY7FYlNtZNYFAIOFmHq3LWmEZZYa53BR3W76Yh2gPQHTS5hWUSPx+P4YOHQqn06ncJT7//PN44oknUrJ/x/fBtQ2dXyef8UeFPAnCI3K1Hx5r2b46ze5EQN1vUxTFiIicWCvkxy87OxsAYDabNYXc7/cn5JHLoozWD9uRNycvoXHyJUcrMFJ7haKBKIoYNmwYgGOlJBYsWICFCxemZP+OzcF1OvZvkq+LT4U8CYiQk1WCiQp5+HL04x2/3698ZnWTCEJ4XXci5GRtQjhqjzwW9nVd8Lf5kV8T31YBAK4o+F7UJ6doIYoiBg8eDIZhUFdXl/L9O7c4Yaowwr6uC7KYnHVDhTwJwm/v1UIeK2IkEfmJUqMlEAjAYrEACPrj4ZOX4dYKEXKLxaJpQyXqkR9Z3grbBBv4ksgfAy1YIwNDroFmrlA08fv9MJlMKCoqSrmQC0cE+BoElNxajIAzAOf25CY9qZAnQbhYqyc2E7FWEokqjwf8fr9SksHtduPMM88MeT5cyAsLCwEErRWj0Rixv0Q8ckmQ0PZxO/LnJBaNE/gSjk54UjQhtaUyMzOVOkvhyLKMt956q9sN2R1bnAAD5M3OBV/CwZ6kT06FPAnChTiatRK+NJ0IOUlbPJ7ZsmULli1bpgi5VpegcGtl0qRJAIJ5u9Ei8ngeeecaOwLOAHJn5cTcLhyaS07RQpIkpb5UeN0pNTt37sTtt9+OJUuWdGv/zi0umKvNYM0sMqdmovMbKuS9RqJCTiZGCETIo610JLT8+wjs6wd2Q+Dp06ejs7MzppCHpx9OnjwZQLACopZH/uqrr2Ljxo0x3/fIslZknpYJLr97GUJ8Mc0lp0RCrnWDwQCr1RpVyEnQ1t1aQM4tTtjGBq+RrKmZcHzngOTrfp8DKuRJkKiQHzx4MGS7RCPyhr81ouWf2u3RBhrEI29ra4t4LjxrpaKiAkCwUJuWkDudTtx7770AtD3ygCeA9s86kJ9A7ng4fAnNJadEQqwSvV6v1P/RgmhCdxIaZEmGY4sT1lOCQp45NQOST0bXpsTKM6s5sdIoUkSiHjnpdkMgX3K8iNzXKMCQO3BTFevr65W/Ywl5uBjrdDplQjRaV6FYdHzeCdkvRzSPSAS+mIevWYAsytDpk2vsTDn+UAu51WqF3W7XvH7V2yWK56AXAUcAtpOD1wiXz8FcbYL9my5knda94lw0Ik+C8Ihc3ZOSCDnHcUlF5AFPAGKnCF/jwI0O1c2WY1krsdCKyOO+77JWZJ2ZBX1m9+MTvpgDAoDQQn1yyjFI0EaslfAmKeH1lrqzVsS5xQnGxMBcdWwVc+ZpmbAn4ZNTIU+C8JnppqYmxTsjQl5aWoqGhoaQ7RLxyIXGoJD4GoUBm6aoPj5aQm4yJbDaMo6Qh0fzAU8AHas7k7JVACipitReObFZtWpVSKAVHpE7nc4Qnzy83lJ4RL5x40ZkZWVpFtFzbHbCOsYScgeYOTUDjh+cEB3dy2yjQp4E6oh8xIgRAID9+/cDOCbkFoslqawVX1NQyCW3hEDXwFwyrl74wzAMDAZDiJAnErXEE/LwHznXDjdkQUbGqRlRXhEbfbYejJGhmSsnOHPnzg1Zeq8l5OoURHItR7NWvvjiCwDAnj17It7LucUJ69jQhieZUzIAGeha3z2fnAp5Eqg98mHDhsFgMChCTp6zWCwRkXdCEXnTMSEZqFkU6h86n88HnudDPPLwkz08vxxA3Ebe4fMUzm0uGPIN4AuTq2ej0+loLvkJDgnCWltblcfIeRYrIv/HP/6Byy+/HEBkgEHSaH/88ceQ/Uk+Ca6dbiVjhaDP0MM6xtLtNEQq5EmgFiqz2YyysjKl+zs5Gcxmc9QWZzEj8kYBxiFG5e+BiNpaEQQBHMeho6MDOTk5WL58eURE/v7770ekasYjfJ7Ctc0J62hL8oMGySWnQn6ioq4NFP6YwWCAxWKB0+kMsUk8Hg8WLVqk/Ds8wCDzRTt37oQoisjNzcXSpUvh2umC7JcjhBwIpiF2t+4KFfIkCI841TYKOQlMJlOEkJMvOVaXbqHRB+MQHoY8w3Eh5D6fTxHygoICnHHGGREROcdxCTXiXbFihfJ3uJA7t7pSJOQD85hTeo6WkGvlkautQ4/HE3I9hwt5U1MTAGDv3r3K6z755BM4trhgyDOAK468g8w8LRPuXW4IrYmvEqVCngSiKCo5zw0NDeA4TjkJyK2VlrUS3mhBC1+jAG4QB76IgzBAM1fUJ7rX64XBYEBnZ6eSikgWAnUXsvITCL1gAu4A3Hs9sJ6s3WA5UWiDiRMbcn1qReQsy8Jms0EUxRBrxe12x6y1RNJo3W63sv+Ojo7gQqBTrJrrIWwTbdBxOtjXJm6vUCFPgkAggLKyMgBBITcYDBHd3rWslYQi8iYBfBEProgbsBG5Olom1kpXV5ci5Kko56t+D9dONyABlhRE5N5634DNFqL0jPCI3Ol0KvM3BoNBuWtsbW1VghGv1xtyPYffKRIh93q9yvXf2dkZzFjRsFWAYBG3jAm2btkrVMiTQBRFZRKjvb0dHMcpQq62Vvbv348///nPyuvIc7EmO31NAvhBXPA2f4AKud/vV0Tb6/Uqx4o8lpGRXGaJGvUF09OJTgJfzEFySQg4Bma2EKVnhPfi3b59u/KcXq9HeXm58rjFYgHDMHC73TGtlSNHjqCgoABer/dYD9t2Ad6DXmUhkBaZUzNpRJ5uSJ3tl19+GR999FGItaKe7ASAhx9+WInwyIkSrV5DwBOA2CGCKxrY1orf71fSBwVBUCJwckzefPNNvPLKKz16j5CIPAUTnQDNJT/RCb+G1QKt1+uRm5uLoqIifP/99+A4DmazGR6PJ8JaOXToEL7++msAwZ4FhYWF8Hq9yjmb3Rks1xwtIgeArKkZ8B7ywVsX/e5dDRXyJBBFEQaDARdffDEmTJgQYq2ECzkQWVAn2ipHknrIF3GKtTIQb/P9fr8ShZPJTgBKadqSkhLMmzevR++hjnxSMdEJAFwhB+hAJzxPUMI9cnX9fBKMjB49Gjt27ADHcTAajfB4PCGeeiAQwIwZM1BTU6M0U8nPzw8R8iJXMUzlRugzoq9Ato6xgrWysH+dmL1ChTwJAoFASOaF2lpRe+QEsoCAPKdVdwQ4thgoONnJQxZk+NsGXu1ycseycOFCvPrqqxFCngqU2+AUTXQCAMMx4AoMNCI/QQmPyNX55OR6J/aKXq+HyWQK2QYInpekZAdZyp+fnw+fz6dc/+UojxmNA4BOr0PGZFvC+eRUyJNAFMWQzItY1gpw7AuNJ+RCowDWykJv04MvOtpHcgDaK36/HwaDAfPnz0dVVZUi5MnUT4mG0jc1RROdBL6E5pKfqMQSchKRk/ISxFoJF3L1nSK57gsKCuDxeJRztlo/XDN/PJysqZmwr+1K6K6cCnkSkI4hBLW1Qg56UhF5owDuqIBzBRzADMxFQcR6IiQr5OPGjcMFF1yg+Rw5lqma6CTQXPITl3BrRS3SZKUxOZc5josakRPIdV9QUACfzwdRFFHAFCKbyY4bkQPBCU9/qx+ePfEb0dAytkkQLuRaEbm6MJQ6Is/Ozo4RkfvADwqeKDq9DlzhwExBJBE5gfzdXSFftWoVACArKyviOVmWIUlSyiY6CXwxh66N3a8HTRn4kGuYBAnhIg0csweJtRI+36WOyImQ5+XlweVyYfHixajWV8MvC7CMMCMe5uEmGHL16PzGDnN17O1pRJ4EWkIVPtlJUu0AwG4P+lyiKCI/Px9tbW2at0u+pmMROYABm7mizlQBkFKPfM6cOcrfoigGJzrHpFLIaYOJE5Xw9EMtIQ+PyMODsnBrRafTIS8vDwDw8ssvYzg7HPsC+yDr49slOp0OOTNzEHDF7xhEhTwJ3G53iHUSb7JTHZEXFBRAEATNFEThaA65st9B3IC8zQ+3VpKNyLX4+9//jn/+858AAF+XEJzoHNPziU4CX8JDaPFDErrfbosysAlfna3VaJkEIwaDIa614nA4YLPZQu7Oq/UjsFvcHbe5DKHyD+UYfHtJ3O2okCeB2+0O+XLiWStqjzw3N1gvWysFMeiRHxM7vmhgLgoKv2NJZUTOMIzyg+Dc4QQk4IeuLT3eL4Ev5gA5tAol5cQg3CPXautGzmWDwQCz2axE5F988QVyc3NDIvKOjg5kZGQo5z0DBpX6SuwSfwwpY5EK4gq5JEm4++67ce6556KmpkYp10pYsWIFZsyYgXPOOQf33HPPgMx77i5utzvEOolnragjciLwRPhnz56Nr776CgGvBLFDVLJVgKPWStPAu82PJuSpyloh8xOubS60S+346fU/Tcl+AdWiIJq5csIR7pFrCTk5h4m14na7YTQaMXbsWAwdOjREyNva2mCz2RQhH8IOgVFnxG5xV+8L+fLly+H1erFixQo8+uijWLBggfKcw+HAww8/jHfffRcrV65EWVlZ1Im844lY1opW+qE6IleveASAb775BjfffDN2rd0FAKHWShEHodkPOTCwfhzTLfqXNh0AACAASURBVORk3+7tHuwVIwv29wTWxoK1sgPS0qL0DCLkJDLXEnL1ZCf5m1zrer0+RMiPHDkSIuTD9SPgkBxokBoStlYSJW7Wyrp16zBjxgwAwepzmzdvVp5bv349Ro4ciQULFqC2thY/+9nPFGM/Gk6nM+1Re6yiVKnA5XJBp9MpX7QkSfD5fHA4HIr3rf5Cm5ub4XA4lIUyQHAClAh8Y2MjbrvkVvwx4wkINkGp9RHIFCGLMjoOdsBQkN5mzKk8ZmTJMjk+5PuWJClqF/J4TJw4UXktueDcO9zYE9gT8l6pwDBIj679XTA54ltB6T7XegIdW/cg55DH40FbW1vIGMPXguh0OuVaNplMcDgckGU5ZLl+W1tbiLhXsdXYHdgNIGi7aGVjxSJWqee4Qu5wOEKKHLEsq6TftbW1Yc2aNVizZg0sFgtmzZqFyZMno7KyMur+SA/HdJNIfetk8Xg8yM3NVd6DlLdU//rm5uYiPz8fpaWlaGlpgc1mgyzLyufnOC4kas1l8sFaWWQVHfty+UoewAEYHAbYKtL3eQipPGZms1nZH4nEs7Ozk3qPH3/8ETk5OUpkn52dDR48AoclJSJP5dhNpSagTZfwPtN5rvUUOrbEIcIsiqJSXvb666/Hzp07lbFmZwfrpLAsi8zMYKd7q9UKm80GnudDaggJggCj0ajMi5WwJdgX2AsgtJpiKohrrdhstpAMC0mSlA+ck5ODcePGobCwEFarFVOnTsXWrVtTNrj+iCiKEAQhwloJn+xkWRZ79uzB3LlzUVdXByDUWvH7/SGdgvKZPHCDQhe1GPIM0Bl0PbrNl/wSnDtcSb8+GcKzVkhEnqy1YrFYFBEHgse7XF8OSEi5tQIEJzypR37iQSwVn8+n3C3ffPPN+Pjjj5VtyHkoSZKiAeT/JMglOJ3OEAumgClES6BFeY9UElfIp0yZgk8//RQAsGHDBowcOVJ5buzYsdi5cyfa2togiiI2btyI4cOHp3SA/Q1y66TOStGa7CRL+EtLS1FXV6fULSZfqt/vD7kNy2PyQiY6AUDH9HxRUN0LDfhh3jbIYu/57GoLCTh2TFJVa8VgMKCSrYIuG2iXtQuQ9QS+hOaSn0h0dHSgsbFRCcacTic6OjoARN41kGBEkiRNj1yN2+0Gy7IwGo1gwCCPyUOLFBTyVE92xrVW5syZg9WrV2PmzJmQZRnPP/88Fi1ahPLycsyePRuPPPKIUslu7ty5IUJ/PELEV52VopVHTpb0Dh48GD6fD4MGDQKAqBF5HpMfEZEDPVsU5O8U0fByI2RBhtAsKBkZ6UYQhJALgAh5qiY7eZ5Hpb4KumE6YF9Kdhm6/6PL9GVZ1uzgQjm+OOOMM1BfX4+nnnoKQHAO7J577gEQXchlWVaCuWidr9xuN/R6fbAELpMLVsf2nZAzDIOnn3465LHq6mrl74suuggXXXRRSgfVn9GKyLWsFSIApaWlIa+PGZFrCHlPOgU1/K0BuqPnlrfel3YhP3z4MMaMGYPS0lLMnDlTeTzVQk4icmlIehbt8MUcpKPpoIac9E4ypxO73Y6tW7di6tSpfT2Ufk19fT2A4DWZkZGBrq4upalELCFXN08Bogs5ADx484PAe0CLFOwY1Ovph5RQiPiqPfJwa4VE40DkiWAwGMAwjEZEngeuOFLokl0UJLT60fBaEwbfNRiMiemVdLqDBw8CAOrq6jStlVQJOSvqMZgdDHGwdnNadfPnZDheGkz85z//wQ033NDXwxgw+P1+5OXl4ac//Sl8Ph+sVmuEOKutlbPOOgsAlEy98G1dLpdyHZw95n/gkT1wyMHsl173yCmhRLNWAoEAAoFAhJCrJ+mA4JdtMBggiqIi5Bw4ZDJZmhF5stZK/Yv10GfpMejyguCy816YvFOfyFp9OVPlkYv7RbA6Ft5BkVXhmpubkZ+fj2+//Tbp/XMFHMAO/AYTXV1dIXd9FG3IeUsm6cM7WqlRR+TZ2dmoq6vDokWLABzzyF966SUAQSEn+w40B5SJTnXglypo9cNuEs1aAYK/6LIsxxQ0IuRqayWXCaYnhU92AgBXzAVrf/glMIbEfnd9jT40vtmM8seGgeEZ8MUcvL0QXap/wLSyVlIl5J4dHrRL7fCyx7JxZBn4ZjuLbzbJQMnd+P2bZgz9lkdrlw5tdgZuH6BnAZYh/8lgWYDTA5UlEsaUBzBmmIQRZRKMnA58ITfgI3Kn05nyyO94xGq1wm63QxAE6PX6mAvY1BE5eS2BnP9Wq1URayLugRZJsVXUc2oAUN+qw1dbWZh4IMcmIydDDv7fJoNL0NmjQt5NomWtAEHfKxAIhAiaTqcDy7Ihk6DkSyY+eh6TDwDKZOcz73OQZeCuiwXwRXyw9keLH8YEPe7Dz9fDUMjBc3o+Nu1mIGUYoeuFiFx9cqqFPNXWinObC/vlfTB3Hv1hyDwTM35lxne7WVj4oUDRbdjXysFSwCA3Q0Z1qQgzDwQkQJIAMQAEJB0CEuAVgG0HGCz53IAutw56VkZ1qYRfySbUrxEx7CwGo4ZICLtrHhAQIaeTtrGx2Wyw2+3o7OxUJieByLtpIFLI1aizs4xGY0j2lr/Rr0x0chyHVrsOi/9rwPtf6rF2ux4mToYgBs/LkLGZZNxUI+CRa2NH8FTIuwkpmKVln/j9/ghrBQiKGhFyvV6vWCuBQAB5eXm4/5L74V7iBmMNvu7FZQY0tTPYdpDBs9cE/V6hwRdVyFvtOvzmFR6b9zLQtXjxx++O4JmSUVj18+BCrivbrLjRlljvv56gjv7UQj5ixAgAqRNy1zYXDuoOQl9/MjDyP0BuDfKzRHyzyIUD25bhqquuwk9uuQVP/OaJhPcpy0Btsw5bD7DYdoBBx24jSr9uxj8uAbbl5cE8KROTTwGmjhZxSoWUcKTUl5D1H+oeqpRIyDxWa2triLWSSESuhuSQ8zyvHG8i5EKDgCNyB1BwLVylP8OC/0yH1aTDT04T8atL3Zg+NgBGB3S5gQ6HDu0OHdq7gv8fUhg/dZgKeTdxuVwh/jgQGpFrCTnHcSEz28RakSQJJpMJVsGGRimYx9ruNKKpncFvr/fimfc5zG3KwGO8LuqE53+/ZXHnIiOsJuCqc/wYtXQfUGzEL5/LwO+zXPD4gD/cZIS3Lv2RmXpJs1o4br75ZtTU1EQcl2QgPTp3552Hr7+bCxjWAVumY8my5QCATWuC+b8NDQ3d2q9OBwwdJGPoIBFzTgN855Sg5V8csj/pxPlb6yHt1+HHj3PwZy4POwrysHyxhOLc/l0Dhwi51+uNEHJZltHW1ha3pMaJABHytrY2GAyGkAqH4RDbNJaQG41GRfBZloUsy/A1CGgp+AlQ8hOw3s9x2fil+H8PzYAx7Pc1ywpkWWUMK+reuUUnO7uJw+GIKDNAvF/SUTtcsNQZHAzDQK/XK1krZrMZerserVIrvF4vvt/LgGVk3DTbj5VPumF369DEGHF4R2gmRpcb+N8/87jy92bMOU3EmmddmD/Jjoz1zRj1UCmmnSJh1FAJ46skuKxGwCMh0BVAOlELOVm+DATtpZKS+DWVE2HVB15AAvZkjsL0/EXAlmlA11fK86Tz+eHDh3v0Pnwhh8E/L8Hkf4/ClI0TcNKfKjD9DGC+ex/+tHUtfvi2Z5kxPUW9gvCpp57CDz/8ELGNyxWcQ9CaWFuyZAkqKyuxdOnSbtf8ON5QR+TkjhnQtlYIWvWi1BE5EXK9Xg9/mwjJK6HFUgUc/iNKuu5BVc6OEBHftm0bVq5cmfRnoELeTZxOZ4SQk/oLnZ2dER45EPrLTiZT2tra8Mgjj0Cv14O1s2iVWuHz+fD9HhYjyiSYjcCwIhmf/j83vBk8Pvh3AJ99F4wGvtrK4oxfWPDZd3q894gbT833wWoCDj9TB8sIM3LPz1Hej2GA7PLg+6d72blayNMlDnu/cMPBczC2zkGG//OI54mQazUFSBZDtgH5F+Zh+DNVmLJuPAyyhKbv4vdRTBfNzc3Iy8vDunXrAACLFy/G6tWrI7YjhZ60Jjy///575bWAdoR5okDmu8KtlVhCPnTo0IjHolkr5LprsVYAnl3gOC7iOznjjDN6tB6HWisJEggEwLIsnE5nRG44EfL29vaoHjmBWCv/+te/ACC48MCkQ6t0BF6vF5v3shhXdSxyzrICE6bqof/Bg0t/a8LsKSI+XKfH3DNEPPlzL7KPDsW104XW5W046W/DoWNC7ZOykwyQPwouCrKclLq2aGrq6upCTk5yTFKNvsWLrhwzjH69IkbAsfx9srS6p7nk0WCNDJwWI7r2egH0TdEnYpl89NFHOPXUUyGKouYPF4nItYSciA758fV4PBGW4YkCia7DrZVoQr5mzRpUVFREPK4WcnLN6/X6YPaTXod2zga4d0VkraQCGpEnSG5uLp599lnNiJzjOFitVnR0dECW5ZhCToqOkQYdubm5kNvko9aKD9/vZTCuMjQ6MpbwqDZ68bvrfdi8h8XLv/LilfuOiTgAHH6uHtZTrMj+n8hIeFQl0MHx8NWnJy+6s7MTo0ePxptvvqk8lq6IXG8XIGYGK0fW1dUpJSGIcBMhV5cRTjVCvhGB+r4rw0o+6549e5R/a7UOjBWRE9EhYq9enHaiQe5GvF4vWJaNmbUCAGPGjNHMMVd75OSaZ1kWvnoBUi4PGTLg3Que56mQ9wXkF/uRRx7RFHIgKFwkIg9f4aUWcp/Pp/z7iiuuwIZvNkC2y2iVjqC2KYBWO4NxlaEiRDoF3f5TP7a96sJFZ4ohz4t2Ee2fdaDkxiLNyczRwwJoYo1o25ceISfCoq5Vny4h51wC5CyDcoynT58OAHj//ffxySefoKOjQ0n9ShdcmRF8qwd91QyLCDMRclEUNeuxE3HXEnJyfIiAn8gLh9S2UqLWihYkeNCyVlw2HvAeBCSvprXSU6iQJ4D617OpqUlTyHNyctDR0aHpkavFVS3k48ePh8kT/GVvlVqx9aARBr2MUcNCI3K+iAtOmPi0fcy2T9uhM+iQfba2eJ40RMIRzoi2fenxyNUTb4R0CbnZLYDNPXYhFBQUAABuv/12XHbZZejs7ER+fn5ahTyrikeBx4Pmjr7JzSafjdQI0RJySZKUaFtL5InoqK2VExX13ZvRaEy6oxX5XtQRObFWWjkj4Ak2lVDXZkoVVMgTQH2Sb9u2TVPIs7Ozo3rkarxer/IlZ2ZmKj05W6VW7DxswsghEviwrCfSkDlaCmLrf9uQ/T9ZYM3aq1YsRsCfbYQ3TdaK1kmpbkaSSqxeAYY8ThGp8PS577//Hvn5+Zo/LqmiZAyPAr8Hu/bH3zYdkB8xEkVrWSsul0u5k5wzZw42btwY8rzSZenoPtIdkctyMNOqP6KOyE0mk3J9aqUfxoKcc+qmMUTI62ACPLuUx8jx9/v9KeluRYU8AdQneWdnZ9SIvLOzE5IkRdgb6n9PnjxZsQVsNht8TQIYMwOX7MKuBluErQIcW7rv06i54u8UYf+6C3mzc2N+BmMJB6Y1PRG5lh+dipzxcERnACYpANMgg/KdECFXC3q6I/Lc4UawAA5u7ZsURPVnc7vdmhF5uLDv2LFDcx/dEfJOJ/DO53pc8Xsjzr/PhM5IW14TWQZufcqIs+/un5Op6vNXPVHZ3YicCDnDMEpUH/TIfdgjmAB3UMjVEfm1116LwYMH9/gzUCGPASlsFd5fUKtFkzoiD/fICZ988glKSkqUiMpqtUJoEMAXcWBYFvuaszCuKtI+0WfowVpZCBoRefun7dBxOmSfFdvKyK3gYHILkITUp5mlM/pVY68PnvyWIr1yl5SfHyxvoBaydEfkxrLgBd6ys28mPNX+aktLC2RZhsPhwPr165GdnY1AIBA3yiNCQmzDaNZKq12Hv39iwEWPmFB5tRW/fN4IlgEa2hhc80cT/Akc5uc+MOAfqw3Y18Cgoa3/lQpQC7nJZIq5ICgW6nNO8dkDHER7AHv9xyJysiAQAP773//2aOwEKuQxuPLKK1FUVKREK6QOu1ZEnpubi9bW1pjWCvlyyYVIInJuEA9z9ki4fDxO0YjIgeh1yVv/24ac/8kGa4pdDKRslAEMAHtt6u2VcNGcO3duyt8DADoOBU/+zMEGRXjIwiO1uBUUFECSpLTlRrMmFh4rB/eBvilIpf6sjY2NAII/ZEuWLIEsy2hvb9fMYlETHoETq0rN3c/zqL7GggWLeWRZZSy+14u9bznx5kNevPuwB5v3srj3RT7mpO9n37F45DUef7jRC5aRsWl3/ytaoz5PeJ5XslZSIeRGVzBHvcWgba2kCirkMSAt7ohonHPOOQBCC2YRioqK0NTUFFPIyQlCIvyMjAwITcGInMudCj0j4qQybfHhiyL7SPo7/Oj82o68mti2CgCMmBg8sfZsTr0doD4px4wZg1dffTXl7wEAXfV++HU6ZA2KXS6X2CzptFekQSagsW8mCP1+v/K5m5qaAASFnHzelpaWiIg8XKjDhT48Im/u0OHVjzksvNGHvW86sfheLy48XYTlaJ2yk4ZIePV+D15fYcBflmoL3t56HW74fyZcd54ft//Uj5FDJWza0/8kJ5pH3l17UFPInUdXfWfwgBD80aWTnb0MmbAj0cs111wTddtBgwahpaUFgiBEzVohXy4RcqvVCl+jD1wRB1gnosDShHeXvBHSgYnAF/ER1krbpx1gjAyypsfPEBk8lIWbZVG3PfXipr41JXnc6cDVJKKT5ZBzbPW/ppATuyWdQm4aakRmlxdd7t63Cnw+HywWCzIyMkIicvJ5W1tb0dXVFXIehi8YChfy7du3hyw7/2S9HjaTjOtn+SPqgRDOGR/A47f48OtXeHy8PjTStruAK39vwqihwW0AYEJVAJv29P+InFgr3a1L9NhjjyndmJRFRQ4OPiuHYSobXG2tpAoq5DEgqxPb2toAAMOHD8cXX3yBSy65JGLb4uJiSJKEpqamqB65lrVCInI/fzLyjbV47LHH0NLSEmFXaFkrbR8etVWM8b9GnQ5wWo1o359ea6W9PfXNkAneJgEdBh421Q2RlpCTlMR0+uS5w3kUCW7sa0jv4ugHHngAu3btCnlMEARwHIf8/HwlIpdlWfm7paUlYgVyPCF/7rnn8P777yv//u96Pc4ZL0ZkUIVzc40fN83246Y/mbDtQPA8DASAW/5kgturw+sPeJVKkeOrJWzaw6K/VQMI98jJOdVdIZ83b57ieSseuZ1Dh9mIqtJjH5paK71MTk6wZkltbS14ngfDMBg7dmxEt2wASnPl+vr6qCcAeZ3SGUgXzA83FHJwsyOQye5Fa2srgGPeJ4Ev4kKyVvxtfnSuTcxWIch5fFoaTKgFkxyzdCC2+uE0ctDpgIceegjz5s3TFHKy6i6dQl4wkscgvwd7D6cnwtywYQOysrLw4osv4uGHHw55jgh5RkZGyA/n7t3BPOWWlhY0NDSELLm32+0h+9CaDCV1atxeYPVmFrOmJHb8/nizD5NHBHD570xo6dBh4VscvvyBxZsLPMjPOhblT6gOoMulw76G/jXhGS1rpScoKYx2Do2sEZUlEkaPHo2pU6eC4zjs3LkTr732WsTrtIpxJQKttRIDEpHX1tZq+uJq8vPzwbIs6uvr4052EmtFaD7qabI8ArBC792ibFtfXx+SlsQX8Qh0BRBwBYK9/z5xgTEyyE7AViGYSjmw3/sgy8EIPVUQwVy2bBnKy8tTt+Mw5HYBXnPwe7jvvvsAhArSI488gnXr1inHOd3Wil6WUf9jALgg9cXJSUEsIHKFoc/nA8dxMJlMIZE2Kd37+OOPo6urC1VVVcpz6u1EUdScDCVW4uotLPwiMHNiYkKuZ4FX7/fgvHvNmHmfGQebGCy+14NTwkpNDB8swczL+G43i5pJCe26Vwj3yJO1VtQo6YedehwQTZhWKuGrr4JVOh999FE0NzfjrrvuinhdIBDQDBTjQSPyGJBb09raWs3aCmpYlkV+fj4aGxsT9siFpqDNsd1pBqvzwd547OIlq/YIXHHwxPA2+FBaWoqti7cid0YOGD7xrzC3gkO214va5tRGRETIJ06cmLJytVroOv0QbKGipha58847D++++65ibaVTyI1lwUmszr3peQ/15yJ/C4IAURQhCAJ4nofFYomItIFjoq1+Ti3k0VITyZ3iR9/qcerIQEgtn3hkWoAlD3vg8QG/utQXUUYCCAr+2Mr+55OHr+xMRkjDUeyZDj2a9CZUloRaK9FI9pylQh4D8gUnEpEDwYbMTqczrkdOIgBfow+MmcGmeg55xjo0NhyroV1XVxfyWrIoyHHQgQxdJkwHzMit6Z6NUTqSQ4Hfi237U/u1EyFPxS1pLAwOAVJmqJCr35P82JLH0mmtsBYWgo2DcDg9Qq7ub0qEfMiQIZgxY4ZirZjN5gjvW/1D2tLSovyt3k5L/IFgZoskAR9v0Cdsq6gZOkjG9ldd+PXPos/DTKiS+p2QqyNy9RL9nqDX66GHAQYHgxbOiIriY+8Ra/9UyNMAOaiNjY0JCbnJZILb7Y6bfvjggw9i3LhxEBoF8IM4fL+PRXFGo3JrXF1djebm5pDXsiYW+iw9HLUOTOVOh8AIyJ7WvXom1jIevCxh147UVgYkghntBywVyAEZvFsAskN/LNTHmnjCvSHkAKArNoJv9cKXBi1XX+xkhaHH48HmzZtDhDxclAsLC0P+/dlnn+HGG29U/G8gUshXr14NvV4Pt9uN73YzONLJYNbk5I6dPs4pML46gB/2MRB6Zw1ZQoQLebKTnWr0ej3ymWAaLFvAw6RaJKoOPqZNmxbyumTPWSrkMSAHlXTyiQcR+3ge+f33349Vq1bB1xhcDPTDPhZDco4o2xUWFmqutOOLOLgOuzGNm4adxh3dslUAgD9qz4R3G+opoiiCZdm0tpHzd4hgZIDNix71k+OvNLxNo7UCALZyHkWCB/sbUn8ZqS/2aB65xWKJiMjJpDsQ9LwnTpyIiRMnKpPoQKSQn3LKKRg3bhzcbjc+Wq/H8MEBVBSHTrrJsgzRLsK5w4W2T9vRuVY7qo/H+KoABFGHHw/1n6an4dZKKoRcp9OhgAn+qGZVhH5/5PycPn06XnjhhZDnkj1n6WRnDNQHNdGIHIgt5Op9Ck0CvBkcXId1qBxkV7bJysrSFHKuiEPXzi6M0Z+Mxbq/ApjfnY8DrpCDzAAd+wQAqbuQRFFMia8YC/+R4O06nx95W1pRUYF9+/ZFWCvpFvK8EUYUf96O3XUMThqS2pw6tbiECzlppqxlrRQVFQEIBgMffvghgGA6ZldXFzwejzJByjBMxCSf2+3GmvV6JRpvfKMJHas74av3wdcgIOA8OiYWQACo/L9yFF5a0K3PNaRQRm6GhM37DDh9bLdemjYCgQB0Oh1kWQ7xyHsi5AzDoIApgFvPYsjQyB6+QPBHI1xXqLWSBtQHNZHuKfGEPNx68DUJaNEbYTXJGFYYfC+bzQaTyRRR3wUIZq6I3wXglb3Y6NsY8Xw8dKwOyOWBI76UVqITRTHt/rhwJHh8zIMifzDuuOMOAMeOO7kQ022tmIfxKPK7sas29Xci6nMvvHiTOmslvEEBsVYqKyuVv8kCKeKZ2+12ZGRk4Msvv1T6RJrNZjTbLdhRG0w7dG53Yf8jB8FaWeTV5KL8saEYvWQkJqwZh6k7p2DIrwZj70P70fZpYusGvIe86PzaDp0OmFAtYfO+nvvQqUJdH8loNCoC3pPCbwzDoIAtQAtnRFVJ6I+8ut65ei4EoNZKWlAfVBLpxCKekIcjNPpwwG/EyeUBFBUFIxuWZWEymaJaKzpZh7X+b9DhTG4FpamUQ77fix0HU+dnE2slnfiP+OFi9cjMiTy21157bciK0t6KyE1DjDBIMup3pf591OdeeM0YddZKOCTTSh3pEUE/ciRo3xEhP/nkkzFhwgQAwUBlT/tw5GZImFgt4dCTh5Ex0YbqZyox+BelKJibj8zJGTCW8NDpdSj5eTGKrxuEXXfsgf3b2P1R21d2YPOcrdh5yy5IgoRxVQFs2d+31srhw4eVFEwSkQNBIc/Ozsbvfvc73HnnnUnvX6fToYAtRSNrDlkMBKiW79OIvHdQH9REhJz8usZqLEGQfBL8bSK2O0wYVyUpOeN2uz2qkJMUxK+ENZoReyLYhvAohUdZhZcKesNa8TYLaGd5ZNu0F0yoj3FvReTGISQFMfWLrNSRtt/vD/m3erIzHPKYOtLLzc2FTqdTIvKuri6l2Jj6ddsbh4FzfgbXpi50rO5E2a8GR7UXdDodhj40BHmzc7Hz5l1wbo8suiVLMg79uQ47b9mFnHOyIXkkODY7MaE6gD31ejj6sD75mDFjlBXa6vpIJCL/xS9+oVnlNFEYhkGBvgwtBmNUIec4LkIr/H4/du7ciblz53ZrcVDcq1mSJNx9990499xzUVNTo/SaDN/m4osvxiuvvJLwGw8E/H6/0ukmESEnF1H4l6P1hfiO5pBvbDdjXGUApaWlAIIXaTQht42zwVnpwPf+TUlX9+OLOQyWvQNOyJ0NfnToOWRHFp6MoLeyVvQZegSsekh13pQvO1cHEeGNI4i1oiXkJMJTC7ler4csy7jyyivR2tqKjo6OCCFn+Vwgczoat76E2j8dRvb0LGROjt0cRMfoUPl4OTIm2bDjuh/hOXgsuBC7RPx4227U/aUelY+Xo/qpSpjKjbB/bcf4KgmyrMPmfX2bhkgWXUmSpJR1SEXqIUA88nx0mDgU5YRe/+qIPBy/349t27Zh1apVUdNENd8v3gbLly+H1+vFihUr8Oijj2LBggUR2/z+978PSW86XhBFUbl9LS4ujrs9+WISsRmEo8vtG2DEuKpAyC1WNCE3DTHix5odEBEUqGRuw/hiHtk+L7al2FpJt5B7moNCnmWNH6X0VtYKALAlHPLcHhw+kp5FVuRvsoiHYRhlt++GFQAAIABJREFUslPLWtEScjXffvstfvzxx4gu8I3esYAsYoLzCLo2OFB2T2LNDhgDg+GLqmAcymP7tTshtAhw73Fjy9xtcG53Ycw/RqHw4qBIZk7NROc3XcjLlDE4X+zzkrYkwAoEArjrrruwdOnShLLTEkIC8mABctmIVdSxeoKqv2tSOycR4gr5unXrMGPGDADApEmTQhrsAsDSpUvBMIxS4vV4wu/3K2KgTuuKRrSI/LLLLovY1nvYh4CJBZOhx7BBoeIUbbITCF2Vl0wnbr6EB+/yY+9+GalqNN8bQu5r8aPdEN1aUdMbKzsJtmEGFAlu7D6cWpcyPCIn3ztp3EsmOwlPPvkk7rzzTuUcDA8mfvjhB7Asi6uuugpffPEFxowZE/L8rtZq6Do+xzXGK1BfUgfr6MS7+bAmFiNfHgHWxGDrFTuwZd42cIUcTvnPGNhOPnYLlXV6JpxbnAi4Ahhb4e8XJW3/9re/QZIkcBynNPJOBbyHhx4MjBrxX6wOROq7r/C1JLGIe/U5HI6Q/ossyyoX7o4dO/Dee+/h9ddfx+OPP57QGzqdzqQLwyRKsv5xOIIgYPTo0fj8889htVrjdl0hAs6ybMi2N9xwA2644QY4HA5lbF37HLBbjRgzVIDLFdx2/vz5KCgogE6ng8vl0ny/9vZ28DwPn8+XVMlYMfNo9ofTh2373CgvCm3CmwwulwsMw6Sk96AWXq8X4hEfOvQ8WLkLibyNwWCAw+FI25gI3GAGZZILP+z149ThkT5xsqitFLfbrVzUHMfB6XRGBAuXXnopgGN2gSAIId9pdnZ2SLXE8vJy5dgIIlDnGo2prU9jGDsJ87ffilmO87o3YAYY8vxgHLi9FjkXZaPozkJ49V54HcfGwIxmIEsymr5oxuiyPLzxeWbav59wZFnG22+/rfz73nvvRWZmZsiPZSr0g+kIfj+mIiHiM5IfaRJ9T5s2DdOmTcPChQvR1dWlVFs9ePAgxo8fr7wulmcfV8htNlvISSVJkhJ9LVmyBI2NjZgzZw4OHToEjuNQVlamRPBaaHXXSQc9maggBAIB1NTU4I033kgo/ZD4jqWlpTHf32azobG5GY16MyaOODbWhQsXAgDefPNN+Hw+zX14vV7k5OSgsbERPM93+3Oaq8wA9qFI8uBASwbGVh+7hU/2mOn1enAcl5JjHg2dXYSrwIC8nMTew2AwwGAwpHVMAGAeZsYgrx1rjxhhs6UuwlQLtU6nU+ZDOI5DQ0MDysvLlbRC4Nh3R5pqGAwGGI3GkM9PBGXs2LE49dRTlej9iy0sJNmInwllWOn/DHVSHaxWa/fzqG1AzscxykbYAOsoC4RNAiaeJ+P//qGHR8xAQXZ6Azs1P/zwAx544IGQx2RZhsViCTlWPT1vLJ4MeHUMSiukiH0RnSDfz7Jly+DxeLBw4UIYDAblTruzszPhccQ986ZMmaJ0ytmwYQNGjhypPPfb3/4WK1euxIcffogrr7wSt99+e0wRH2iQTiyJiDhwzFohEyex8BzyYo9owrjKyFkys9mM9vZ2rFixIuI5QRCULzcZ64C1BJf6n2xNXeaK3+9Pa/qh5JHAeAIQbYlPRKWj5rMW/GAOhoCEhj2pnVj1+/047bTTcOmll4ZEiy6XC42NjRg2bJhmUETsFq27XkW4v/gixAv+77d6XMvVo8QwCG973gIQbHOo1f6tpxCffMxQPxhG7nV7Res8jdXVK1kCbTYcMRgxOC9yrkurA5E6ZZYEzin1yOfMmQOj0YiZM2fioYcewsKFC7Fo0aKUNQ3tz/j9/m55v2SCKbzehRauWh8aWLNmj06yH60GFqQ7DBlfMvDFHKp4D7Ye6Ln4+v3+tC8I8rcFRVLKTlzIWZbFhx9+mHYbjys7Wsxsf2obMZNzj6wGJl2qyCT4sGHDNGu/xxLyZcuW4Z133gl5TJaBFWsZ/OTgAYhn+nFECqYofvTRRyGldFNF1tQMuH90g3P5MaJMwne9POGpdT0HAoGUByK6ThtaDCYMzotMTdUScvW8DvnRTqlHzjAMnn766ZDHtFqRPfjggwm/6UChuwJFZqHjCXnAK0Fu96NlqBGD8yMvOPUklsPhCLm9EgQhBULOo9TuxfYeRuSBQAD5+fkoLy9XarenA7E1KORMtgFAYjO0HR0dWLZsGVauXJnWu0Q2kwUsLKydXrTaeeRlpuaHg2SmECFX+7YMw6CsrExTfGIJ+YgRIzBixIiQx3bUMhi1qwFGrx/MpTzwz2PPxQpivvvuO2RmZqKyshKdnZ1Kmm48bBNt0HE6ODe4+qT1m1ZKajqEPFvOw34TgwnjTop4jmiK+j11Oh0MBkNIrfiURuQnMuomt4lAbkXV3qUWvrrgr7SQY4TW+aMW8gMHDoQ8pxbyZLJWgGDmSrbHi7pWBh09mGsi4rJ///60Zq2IrSIkRgc+r/vvsWfPnjSM6Bg6nQ7GIUYUCx7sSmHmSnhErhbywsJCcBzXbSHXYs164Iq2/Si5fhAySkP92Fgpxeeccw4mTpyI7du3Y+jQodi2bVtC78eaWGRMsMG53oXxR0vapvmmKQSt4EeSpNQXfDsigCvRnmeI1tyZfNdOpxN6vb5bETkV8jAWLlyIpUuXAui+tUJue8MXW4TjPRy8KPVFkelHQGgOcPgCLEEQFG802QUvfDEH3h4cQ0/yydU/JOn0yP2tfriNBmTZun+xbdmyJf5GPcRabsRQ2YU9dakVcoPBAL1ej1WrVuHXv/71sfeLkTCQSHE3Na0ft8MsB1B6S3FEVJ3I2hDyQxnemjAWmVMz4VznxPjqADocOhxs6r3Wb1pCnuoSE7Isw2T3wTRY+/qOJuRkXsfhcGDo0KGptVZONJ544gkAwJ133glZlrsVkV999dXweDwRiy3C8R32wWPhkJenfeEnGpH3xFoRmwWUDgvgtqeMmDQ8gBGDZUw+icXYCgm5CdoDaiFPd0TexfPITmAxUDjhjYvTgXGoEWVf2fFdCiNyYutpnX+xJt/1ej1++ctf4qabbor7HrIMsD92wVueAX2mHiWZJdixY4eS0JCIkBM/tzvnYtbUDBx68jBOYtwwcmZ8t5vFsKLeKVAebZypFHKxUwQnBpBboT2nQ94rWkTucDhw0kknYe/evXA6nQll+tGIPArPPvssgO51vbFYLLjrrrvizoB7D/vQYTGhMEd7Xbf6tjg8c0At5Ha7PeFbWjV8CQdZkPHG/C7cNDt4Yr+zyox5j5hRcbUVo6+34L6XtKMJNT7fsYmcdE52im0iOvVcQouBwknVmoJYmIYYkev2YPfh1EWWgiBECDm5U4uXRfXwww8ntBL5UIsOw9rtyJ58zFJRvy4RISc+rroJdDysY6xgrAyc67swtqJ3JzyjCXkqs1ba9wUDnNJR2kJOrm8tISceeWVlJYDEJzyPCyGvO6LDN9vTczKkI9L0HvaimTNiUI62MA0fPhxPPPEExo8fH3HiqYX89ttvxxlnnNHt9+eLgyJdyXlw9yUCXnvAi6+ebkHtEgeWL3TjvEkiFv/XEHflZ29F5P5WEa0sn9Dy/HDUPzbpwjjECE4IoH5/6jovqa0VArHsEk2HjcfG9RIGCy6UnxMa8b300ksoLCzUXHAmy7Jy1woAhw4dAoBuLU7T6XWwTLDA/rUd46oC+D5KCmJjmy5t/WXDSWVEfmirgAB0qBitfU2QNQFaQi4IQoiQJzrheVwI+V+Wcrjmj0a0dKTea0tHpOmr8+GwzhRVyHU6HW655RZYLJYIIVILeXc8NDWGPAN0nA6+htDJ0kwLcMaYAK6c4UdA0qGlM/bxVI8tnR652CqiWU5seT7h8OHD+OMf/9hLQn707qXRC2dk2nBSaFkrZIW1WsgTzRbR4sBqJySdDtkTQoX8sssuw/Tp05WIvLm5GXfeeSckSYLdblcWrgFQSnZ0d5WxbYoF9rV2TKgQsWUfC78YtHo272Xwf+9wOOtuM066zoqz7zaj0xl/f4miDoyWLFmi/J3K87d5t4A2jkdJlOS1yspK3Hfffbj22mtDHud5Hk6nE4IgYPDgwTAYDCGdnWJxXAj5gqt9yLQAdywypnwGPNVCLssyvId82C+ZURhnRRvHcZoReU8L++gYHfgiDr56bZH7/+2dd5hTZdr/Pye9zSTTO0ylIyj4Q4FFERUQGy66a13Xfe3o2nl1m++6a9+1sq6vvrrKqmtbG81eERALIr0OzAzTSyaZ9OT8/gjnkMwkM0kmgcHN57q4mEl95pznfM/93M9dinOC42ps71/ID6VF3iposRhjP7kZGRmYTKZD4lpR56oRDAqKPA52NiTnkorkWpEs8tDz/+WXX/LJJ58k9B3uDTbshUZUpr4iZjabZSH/+9//znPPPUdnZ2ef4/nDDz8A8Qu5aYoRb7uPo1Q2nB6B/3pQx5hLjZx4o5GXPlQzZbSfV//gQKOGB18e2M0XK6HXU2goZjKjVux7PfRk6PoUy5JQKBTccccdfXzfGo1GdlGZTCZycnL+s4TcqIP/vdnJ+18rWfJecoU32QLl7/bjt/tpVOspjOIjlwhN15WQmgqEXuCJJL1oi7V9LHIJ36sN/HX3Whra+58eh8JHLgZEfO0+OtXx+8i1Wm3CIZrxIAgC+uE6hvsdbE9S5EqsrpXi4mImTpwY9+fbHJDfaEU3IXIKuMVikYVcslY9Ho+cmNSbeHzkANoqLeo8NaYdVsZX+mnuELjyDC9rFvew/qke7rvCzSmT/fz2YjdPLlWze39yhDbUtRIaHZbUzc4mN/6c+G8+Go1GrrNiMpnIzs6Wfx+IH4WQN7/aQu7Svdz6cw+3P61lT1PyTkqyBcrTELQImtXRXSsSkYRIaioQOq5EwhC1xRrc+/ta5C1vtLLv/n2MdHbTsrf/zz0UrhVfpw/80KmK30eu1WrDLMjf/va3XHXVVckeIgD6ch01yuRVQYzkWpEEPBn1ir7ZKFDj7KZiZuTPMplM8ka7dDNxOBwR0/bVajVvvfWW3LgiFgRBwHx8JtYvrXz+iIOV9zu5YYGHUcMCsiVr39jDbF8Lo4YF+MM/kmOVh1rkqRJydYcbTXFiQi6tbDIyMsjNzf3PEnLRL7L//xr59WwHo4YFuPGJLHxJ2ndKvpB7EJUCHRot+ZaBXSuxCHkifmBtsbaPa6VrlZWdi3ZTeHHQuWfb0b/DN3RsqajLAQd7dXYmELWi0+nwer3y5tLjjz8e5hdNJrrhOsp8Dj5er0qKe0+yyEObhxQUFFBaWhqxLHK8bPnQgVoUKfpJZIvcaDTK1rck5D09PREt8gkTgl2UX3jhhbjGYJlqxvpVNwFv35Vp+wcd/HDeJnbdtos/X+rindVqvvghOSUlJEKFPFlRK34/ZPa4MFfE36BCrVbLK5uMjAxycnL+s4Q878xcBJVA55utPHmTk837VDz8WmKdPnQ6Heedd96A2ZmJ4mnw4s3WkmUG9QBem2iuld6WWkJ1yXu5VpzbXWy9ejt583OpvLMcl1aFd0//Qh56A/nqq6/iHkMseFsPVIJTa8iMc2tAqvd8KDY8pRDEb7YrWbN58IIjnefe7quNGzcycuTIQX9+19c27Jk6tIWRrxOj0Sinig9kkd9www1Mnjw5bj+5eZqZQE8A+4bwz2x6sZmtV20n+5Qs/HY/Ryu6OW2Kl9/8n3bQnZi8Xi95eXlyOWiJZFnk++oCZPq9FIyMX3+0Wm2Ya+U/ziJXGpTkL8ij8Z/NVBUF+N2F3dz7kiZqWFN/eDwezjjjDLm+uj9Z3Rekz6/30GPWDbjRCcETG2pBBAIBvF4vWq02rLtIYha5Bl+XD3+PH3ejm9pr95JxjImqP1UgCAKOXAOqxoEtcsmqSVV5Yk+bF79OiS5DSbxGUzQhT0ULOF25Dmw+Thnp5LE3Br+Kk1wroWNPpLVfJPx+MO7pRhwdvUSqwWCQRVsSuWhCLlmP8bQmA9CVaNEN12H9Mvg+URTZ+9c6dv12D+X/PYwRD1ejLdFgXWXlrsvcbKpV8K+PB7dnJa10FApF2AZnsizyuo3B67VsbPxzQK1W097ejkajQaPRkJ2d/Z+12QlQdFEBrloXXausXDTLwcyJfq78qw5HHEELfr9f7hZy9tln8/LLLzN6dN+iN4PB0+Cl06Dv08cvEr0vZEnUNRpN2CZYop2CAHq2Odj8y60os1WMfHwECnVwSvhLDBjb+u+OK7l51q9fz8qVK+MeQyx4Wrx4TOqEYsh7C7kUvhdPMaJYkRoxXzm5mxVfqdhRP7jNOUlwUiHkm2sFamxWiqZFF3KTyYTP5+PJJ5+UH4vmWjEajWFRLvFgnppJ1yorAW+AnYt20/DkfkY8XE3JfxUH/ehTzXSt7qaqWOTyeV7uel5LzyACkaLVT0qWkLdvdeFHIHdE/D5yrVZLd3d3WG35WDeRfzRCrq/QY5lhpvH5ZgQBHrveRZtV4A/PxX5AJaGU7tizZ8fZJSUGPA0emtQ6CmIQ8t4+cumilu7Y8mcmIOTSZszWa7bjt/upeHxYWBiaplxHnq2nX3+vFEFTXl4eU+neRPC2enAa1Aml50tCLm14Sk0X6uvrkzfAA2jy1Sh0Co7SOxhZGuBvbw2uia9U5ycVQv79Zx4y/V6qTo6+ipJCHBctWsSmTZuAYC2hSEJuMpnColziwTLNjO07O1v+axvtKzsY8+wo8s7MlZ83H2/G9nU3AXeARee7cXkFHv134sc2WkXTZLlWHLtddBp0skEUD9I1La1u4zmmPxohByi6uJDOjzrxNHgozBZ5eKGbp5ZqWLe1/z/T7/fT1tYWJuSpQAyIePd7qRMMFGYNfFH2jiMPtcgHu9mp1ClQ56gIuAKM+cdo1Hnhf3PmSD25HhedbdFdS263O2LfwWTiafVi1yWWni+5faTjI0V9xFPgKVYEhYBumBb3PhfXzvfw0kdqWgdIqOoPl8uFTqcLE5hkCXnj5zZcGhXGEdELbIWGOErF4KK5VoxGIxaLJW7XCoD5uExEr4hju4PxL4/BMjW84JxlaiYBt4jtOxsWE/z3+W4efV1DQ1tix7a3RR6tgFWi+Oud2LPiK1zWeyySkEtN2GMJLz7kQv7Tn/6UtWvXpuSzs060oC3W0P5qcNPlzKk+po718fDr/d/B77nnHqqrq1Mu5J5mD6JXZKffQGHO4CzywbpWAMpvH87Y50ZjqO478QrG61AA9Ruif7bUBDiVeFq9WDWahFwr0tik4yYdp+7u7uQNMAR9hZ6erQ7OO9FHpkHk6eWJzyOr1YrFYuGWW27h3nvvBZIn5IptNlwVGQiK6GIYuuch+Wl7u1akOWgymRJ2raiz1Yx6YgRHvT4O4+i+pQc0+Rr01Xq6vgyes8vmeinNC/DH5xMzIHpXNJXcbcmyyDUtLnwFiQm5ZBRJrhWDwUAgEIjp+j7kQv7hhx/ywAMPyL9v3rw5LOV3MAhKgcILC+h4o5OAOzjprz/Hw/K1KnY2RJ+033zzDRBu8aYCV11QULa49TFtdvYWcunnZLhWAPLPySNjQuTldckYDW5BQfvG6Bueko88lXhbPXQoE6t82Nsilxtfp0jIs2ZZ6Py4C6Xbz5VneHl6mTquPRoJl8uF2+3GbDaTkZHBFVdcAUBNTc2gx9jcKTCsvQvLsf33ggzNHpWE3OFwhAl5aBGvRC1ygJzZ2XL9n0hYpmZiXR38bLUK7rrMzcsfq9lUG7989XatSKKZLCHPsDpRl+kGfmEEpHFJY5KOr7Qi6o/D4loJXbZdffXV3H///Vgslj61txOh4Lx8Ao4AbcuCYTunTvYzsjTA429EFxzpJEoHLFXp5u56N4JeQSeaAbM6oW/4oXSj6Z3ZmYrwOoNBoFlvwN5PLPmhsshbhcQKZvX2kUvHKVHBGYic2dkginS818Flcz043QL/+jh+q1wan5TJqVAoWL9+PVdfffWgx/jVaj/FHic1p/QfZRR6jba2tgJ9XSvS8dVoNJjNZqxWa9JWDaGYjzdj/74Hnz3o5pt9rJ/sjADfbItffHu7ViSLPBmuFZ/dj8XtJqMmMSGXjqe0GpJupkNWyKOFqkl1GwaDOluNZXYmjUuCkQkKBSw8J+izjFZUSzqJUm3lVFrkYr4GBCHm8MNIrpVkxJHHQofZgH9f/xZ5Kn3kflcAf7efJlGLJQEfuTQ26fhIgt7e3p6SY6bKUJF9Sjatb7aRlQEXneJl8ZuaAatI9qa3kAOUl5cnRWxqP7bjEwRyJvdfQTHUIpciJ3p6eiIKOQQ35gKBgBx7nkzMx2Ui+kW61wVXUoIAFUUiexJoSJFK10rjpuD1mTc6sWui92an1JdgyAp56N0+NJYzWbHIOT/Lxv59D7bvg5Pq3BN8ZGWI/O+yyNaRdBKlJXeqfOSuOheeAzUYBkrPh76ulUNpkQO48g2o+4klT7VF7m0L/u37/YlZ5NLYelvkzz77LCeeeGJyBtmLvLNy6frSirvZwzVnedjTJLDiq/hWeJGEPFm4v7dhKzKh1PcvXJGErbdrpaSkRP552LBhQNBVmmxUZhXGsUasXx50iVUUBtjTGL989bbIJTdGMm6STRtdeAWBsih1yAci0mYnELW+TSiHRcijJbMkK83bMN6AabyRpn8GrXKtGq46w8vTyzQRy4xKk1ayyFMl5O46N7aMYDlWbQxfoVaraWlp4dtvvw2+P8mbnQMRKNVj6nQg+iKLaKotcu+B9Pw6n46sBO7xgiCg0+lwu9189tlnOJ1OuUl0KgQHwDLDjMqsou2ddsoLRc6a6uPxOBOEUiXkTjfkNFjRTshM6P0OhyPMLfXiiy+ydOlSICjko0ePZsWKFUkZa29C/eQA5UUB9jQNXsiT6Vrp3OamSWOgMCex90fa7IQhbJGHindDQ4P8c+id55577pE3eRKh8OICWt9px9sRFINL53jw+eGf70ePIU25RV7vpsOgjyn0EA6e2JNOOomuri7WrVsnj2/GjBny61Il5LpKPaqAKPcY7U2qLXJPqxeU0KVIzCKH4E3P7XZz5plnApCfn5/MIfZBoVaQe3oOrW8F/crXzfewZouKrwYIgQ3FarViMBiSfmy/2wiVThsVMxNrTGGz2ejo6GDmzJmcc8455OXlhTU2mTFjhjxHk415qpmezQ75ei4vDAp5vHVtogl5Mlwr7r1OOjL0ERuqx0Lvzc4hb5FLA3M4HGERBKF3nvvuu49XXnkl4e/IPT0XpUFJ86vBC8pigktne/nbW5o+BbV6C3kqxCngDuBp8tCk1seUDAThN5Q//elP/O53vyM3Nxe9Xs/ChQupra0lNzc3ZUJuGaEnADh3RxbyVFvknhYPiix1sPlBAj5yCO78h6Y5SxZ5Ksk/O5eeTQ4cOxwcMyLA1LG+fjfbe2O1WlPiVtnygQMVIsNO7D9iReKjjz4KMxg6Ozvp7Ozk1FNP5ZlnnunzerPZHHVV/dFHH/GrX/0qsYEDmZMzENQC1jXBa7SiUKS7R4i76UQ0IU9KPfL9Lpw5iYUeQt/NziHvI5d8ltL/K1eupLKyMqkV9JQ6BQXn5dH0QjOiPygCV53pYX+7wFurwn2WvYU8FVEr7gY3iLCvn85AvQm9oaxevZrLLruMrVu3yuO1WCxotdqU+ciLCqFJo8e6NfJESnVCkLfVC5bgMUjUItdqtezdu1f+XYqqkC7gVGCaaEI3XEvrW8EbyLVne3lntSrmDlYbN26UrbJk0rWuG6tZjyY3thXnMcccw/Dhw+XfOzo66OzsJDs7O+LrQysmAqxZs0YO7b3lllt4/fXXEx670qAkY6JJrstSURQ8j/H6yXuHH5aWlgLJqamkb3dCceJCLl3voX57rVY7NIV8ypQp8sAkAdJqtej1+piWEPFQeGEB7v1u2t8N7rqX5on8dIaPR17XhC3JDkXUiqs++Lfu8hljdq2EjmPTpk3U1NT0uclIroNUUJwrUq8x0rkl8kSy2+0pERwJT5sXX2bwGCQSRw7Bi2Lnzp3y79KGcTQxSgaCIJB3Vi6tb7UhBkSmj/chigJb9kW/3BwOBxdccAFfffUVzzzzDDk5CTpaoyCKoN9tQxwd3w1MWsHk5ubS0tKCzWaLuqoxGAxh1/CcOXOYNWsWkByLV6q7AlCYJaLTiHH7yXtHrVxyySW8/PLLYRu3ieDr9qF3edEOTyz0EPpudkLQKo/FwD3kQn7UUUf1EXKNRhN2N09WwoauTEfeWbnUPVqPGAgKwXXzPWzYreSzDQcdWZKQp9JH7qpzo85R02BXx+xa6X1DqaqqiviaSJ3B/X7/oDNoi3MC1GmNOHZFdq3Y7faUVT2EYMEst0mDVi2iT9Dwt1gsbN26Vf596tSpQPIaGEcj76xc3A0eur+2YTZCYXag3+5BGzduZPny5Tz44IMASa+bvrMOqrutFE6L73wVFRUBwVroUmhhtJtgf8ZYf0JusVh47rnnBhyL+fhMXHtcuBvdKBRQXhB/5Epv14pSqUxKTSXnnuA1kjUicSHv7VqB4A1+4cKFA+49HHIh1+l0sktF8u1qtdqwspnbt28HkiOoZQtLcOxy0r4yaJWPqwgw6xhfWOEdaVnV3d2NIAgp6XbjrnOhLdPS0qWMqfIhxC7kkSzyJ554gtmzZw8qrtdshGajAXGfI2K9h9BKbanA2+rBoddgNgai9j8ciKysrLDaKldeeSW33XZbylvA6Sv0mCaaZPdKTWn/Qi6dp02bNlFSUpJ0H/m3H7kxBnyMHCARqDfFxcUAYUXRolnkvV0roUQTcmlexVI9M2OiCYVegfWAVT68MH6LPFrRrMFi3eHCJSgoqk7cLRvJIpfm6UDJkodcyKVCMBBukYcuyySrRLIGBvV9FXryzw63yq8/x8OH36rYuEcRNo7u7m40Gk1SG7FKuOrcKAq1eHyxJQPBwRvMnXfeyUMPPURlZWWf16hUKpYvX94no66urg4gorUeK4IArgIjCqctVFN0AAAgAElEQVRfDgUMJeUWeasXu1aDxZh4tmBv0dHr9eTk5BySpsz5Z+fStqydgDvAiJIAO/oR8ubmZiAYxSX5bZNJ8xc2HFo1xjizDiUhD3VHRLPIDQYDbrc7or9ZuqZ6z1NJC2K55hQaBZnHZtAV4iff0xjftdrbtZIsWje72K8xUFaYeHsoySKPtH8zkMF0WIU81CIPvZtv2LCBMWPGJK0BQOm1pUGrfEXQKp9xlJ8JVX6efEcdNo7u7u4UJgO58eQEL6JY0vPhoM++urqaX/7ylxEn+6ZNm9iwYQNr1qwJe1w6doMVLGFYcMyOnX395DabLWUWuSiKeNu8dKq1mJMo5BqNRo4tj8arr76alAqJufNy8Pf46fykixFlgX77eYb2u0yFkAtbbTgqMuM2UiQhD12RRdsoluKee3p6+qzgpO/tfdwlLYg1jts81Yx1dTeiKFJRGGBvc3wSlqr6QLadLvZrDZTkJi7kvTM7QxnoOh7wKAQCAW688UZOOeUU5s2b18fEX7x4MbNmzWLWrFlylbb+0Ol0ETc7Qy1yu91OdnZ20pa/+nId+Wfnse/RekS/iCDAvON8rNsadKFIVqvVak1dMlC9G3tmUBRjtcinTZvGggULmDlzZtTXvPbaawBhkRlw8OY02I3Q7EIVDr0a565wIRdFMaUWua/Lh+gVaVdqMCe40QkHhXzKlClAUGxCmzKvWrWKm266Kew9ixYt4p133kn4OyXUOWqyfmKh9c02RpQG2N+uwBZlPz9UyKWws2Th8UJJqxX9xPhvupJLRTIMsrOzo7oepX0Hp9MpGyES0YRccqfGeoOxHJ+Jp9GDa4+LiqIA+9sFXHHIRFtbm1yXPpl461x0ZugxJO4ip7y8nLFjx2KxWPo8N1DkyoBCvnTpUlwuF++//z533nknv/nNb+TnamtrefXVV3nvvff44IMP+Pjjj9m4cWO/n2cwGPpY5KGuFUkgsrKykurHLF1YgnO3k7blwWJaY8sD7GhQ4PIcHIfNZkuJkPu6ffi6fLTr9WQaAjGfbJPJxNNPP93vxtyMGTMYO3ZsVCEfrEVekhug2WjsI+Rutxuv15uyMD7JldMsJse1ct5559HV1YVarUav18vH5eabb+aZZ54JW/253e6ESrJGIu/sXDo+7qQyM3g+djaEX3KiKPKPf/yD2tpazj77bB555BGuvfbapHy3xNb1Pgq8LobNiH+DV6VSMXz4cC6//HLuvfdePv/886ivDU1gCe3fKYqibHH3FnLJeItVyI1jjKjMSrpWd1NRGEAUhbis8ubm5qQnhYmiiLLZiSdvcDfgyspKVq1aFbZikPYOBi3ka9as4eSTTwbg2GOPZf369fJzJSUlvP766yiVSgRBwOv1hnWmjkToZmcki9zpdBIIBMjKyhqUf7c3+uE68s/JC/rK/SJjy/34AwLb6hQpd61IoYeNaj35luT2AIVgevS+ffvCHkuWa6UoR2SvxtjHtSJtzqWsV+cBId8f0GI2JS7kkriUlZXJj0nFyAKBgLwPE7rSdLvdcTcSjkb2KVkIagHN2jaMOrHPhmd7ezs33HADy5YtIy8vj1/84hdJby9Y+2mwUFb1CYlF6nz//fecdtppXHXVVf2G6YW6VkKPX+gcjOZaEQSB7du3D1g9UVAKZE7JxPqllWEFIoIgxuwndzqddHd3U1hYGNPrY8XX4UPt8qMsHYQ5HoXjjjuOysrKAYV8QK+/zWYLs7qUSiU+nw+VSoVarSYnJwdRFPnd737HUUcdRXV19YCDs9vtXHPNNVRWVqJUKnE4HCiVSmw2m7zpYzQa8Xg8fZZosRBNvLIvtdDyRit1rzeQNduMSW/gm60e+SBZrVays7MT+s7+sG7vBiXsdivJzfQl/fOLiorYsmVL2OdKlk5nZ2dM3xftmGUZdKwSjfTsaA77HKnvpSAISf97ALr3daMwKGh2KhmvdWCzJXZDkir36XQ6eZySWLS1tck+/pNOOom1a9diNBrx+Xy0trYO6riFYj4pg+Y3mqksHMbG3T5Om3zwc0OzTseNG5fUYymNrWudlR6zCaevB5J/qmQkv3hbW1tY7HNjY6N8zDs6OsjKypLHJpXI7enpYdq0aTz33HP85Cc/6fd7dJO0ND/RitvRTVG2nq21XqaNHjjWWjJ2TCZTv8c5XuOnZ3PwWlOXqVJyLWi12gFXiAMKeUZGRlgIWyAQCNv1dblcLFy4EJPJxF/+8pcBB1VUVIQoirz44otMnjwZrVZLRkYGRUVFdHV1yUusgoIC/H4/BoMhoXDAiJtwo6Hgp1banmqj7KcljC0X2dVkDNtlNxqNSd/A626zoy3S0u7QUZjtTfrn19TU8O6774Z9rnThKBSKmL8v0uuqShXs1Yj4Gn3o0aPKUIV9fmFhYUo2PLvtNjR5Grp7lOSZY/8berNgwQLee+89jj32WNk6l9wtGo1GvmjtdjufffYZZ511FhAUlsEct1CKFxSx6RdbmXyJm9pmHaEvD53b55xzTtKPZUZGBoY9dVgrMlMaKgoH/5azzz6bO++8U35cFEVZM1QqlTyO0PE0Njbi9XrxeDwDjlM5U8X+e5pQ1CupLIbGLj0ZGQO7VyQdq6ysHPA74jlWjmYnTqWS0hodGRnJj4gxGo0Dtnsb8K+fMmUK7733HgDr1q1jzJgx8nOiKHLBBRcwbtw4Hn744ZgEd/r06bKrRhRF2R9UWFhIa2urfOeRLrZkulcASq8txrXXTes77Ywt97OpVhHmi09FooirzoWuTEtTh0BBjFmd8TBy5EgaGhrCrAHpuA12s7MoR6ROe2ATK6TmyqFwrWjy1XT1CJiNiW925ufn8+abb4ZtIIbWsOjs7OTyyy9nzpw5LFu2TJ4LvS2gQCCQcNME8/FmVNkqJrW39AlBlFaDTz/9dEqENuAOkNduQz8htSIO4Zu0d955J8cddxwQXNVH2+yUVo579uwJ+73f76nSoa/U0fJqCxWFAWoHSApav349U6dO5amnnkKlUiU9q9exx0WDxkBpiuqxhQaIRGNAIT/jjDPQ6XSceuqp3HHHHdx99908/vjjLF++nKVLl7Jq1Sref/995s2bx7x58/jqq6/6/0KFgtdee41Ro0bR0tIix05KlvquXbuAg0Ke7MQNXamO/HPzqHusngJ9C2s29IR9R7IjBiBYvlZbpqWpU5ESH/mIESMA2LFjh/yYdOIH6yPPt4h0aTSIOiXOED95e3tw0zhVQu5t9aLKVWN3ClgG4SOPhDTnJF94WVkZ559/PitWrJCT0XoLeXV1NQsWLEjo+wSVQM6p2ZTuaGNXoyKsaJt0flJVH73pqx5UokjJT1IX7y/Re8NSWt1YrdYBhVz6P5b5KggCRZcW0vxaK1Vm74ANJjZs2MDmzZt57bXXyM3NTVqjZYmu7W7qNUaG5SffSIPwAJFoDLgOUCgUPPTQQ2GPScIBBxMZ4sVsNrN37145FEjadJLEKFUWOUDpNSW0vNZKxqqvcQXOxubSIwgCoiiGdUZJFq56NxnHZNC8QyA/K0Cyw/dLSkowmUxs3bqVY445BjhYbmCwFrlSCYU54OrW4wiJXHnjjTeYOnVqytrieVo8CMOD5yLZQi5tyLtcLtlne/rpp5Ofny8Xduq92dnR0cFHH32U8HfmzMmm+V9byRzhZm+zQFVxcJUhXaADBQkkyp5PemhR6/jJMWog8ZVNPMyfP5/bbruNmpoaHnroIX744YcBhTza79HIPyePfX+pY9TW/extriYQCHYDi0RoDfVUVJV07HaxX2OmNC81xzcpFnmqMJvNOJ1OeQLn5eWhUqnYuXMnGo1GtvRSkUqtK9FScG4eVV8JqAIBOr3D5BtHsoVcFEXcdS78eVqcHoGCFFjkgiBQWVlJbW2t/Jjk+khGBmNxjkinxRAWgrhy5UrOP//8QX92NDxtXjymoNttMAlBkZAs8oceekgWcqVSSV5enrw5mqzwQwnz8ZkozUqm2lrYFpIYJJ2fVKwEAbq/sbHHbCbXfGhE/Ouvv+bJJ59k9OjRqFQqZs2axQcffCA/HyrkZ555JrfcckvY+yMJ1o4dO/qEPSoNSgrOLyDz4/14PSL726Nb5aFCnuxwWVEUCex30mrQk5OZmmMcmkQZjcMm5NIBlXzkCoWCwsJCduzYgdFolMMAU1UTo/S6UnQ9Gk5t3UBAN0YOwk+2kHtbvQTcInZz8EItyEq+kEP4prTX65WjAZJRGbEoJ0Cj4WAIotvtxuFwJKWEQjS8rV7cpuAcsAzCRx4JyXh4+eWXgYNz0WAwyJa4y+WKePFYrVZOP/30sGiTWFCoFeScnM0sZzM76g/uJblcLtRqdUrq+4iiiGZnN/by1JXs7U11dXVYHPTUqVP59ttv5XDY0Pn42Wef9Xl/JMPj2GOP5YwzzujzeNHFBYgdXqZ2t1AboeaK1Wrlf//3f8OK8CVbyD0tXhTuAP5CfcL1gAYiNO8hGofVIofwBq5lZWVs3LgRo9EoT4Zkpen3Rlug4TPDp5zf0YLWMEG2yJNtGbnqghO3XR8Uj3xLavxoJpNJXpauXbsWh8MRFrM/GIpzRWpVRlz7XAQ8AfnCSMUyFcDT6sHX5cOeGTwXmUm2yEPP8ejRozn22GOBcCGHg1Z5aMTA559/zhdffMFbb70V9/fmzM2mytrFvm0H57TT6UyZNe5p8KJzeNEdlfqNzmhYLBbsdnvMmcbxlLLWFmnJnZvNgq59Ef3kDzzwALfddluY+zfZQu7aE7zZa4alxjUG/VeVlBhSQj5mzBj8fj8ZGRmykKfKIhdFkefb/4Em4Ocsf6Us5MmOWnHVuVHoFTQHNBh1IiZ9apZfRqNRjt395JNPGD16NJWVlUmxyItzAmwJmMAPrr0uWchTldVp/bIbhVagvTiTTIOIKsnGql6vl113f/7zn2Uh1ev1YS4V6efQ8Fuppk1oadxYsUwz49co0XzTLj/mcrlS5h/v+c6BS6Gg9NjUicxAZGRkEAgEZPdG78qnoahUqpiaKIRSfFkRNXYrHV/1rfIpfUdo3Zxkz1lnrQunVk1eafJXVBJD2iLv7VqBYEIEBGPIU+1aaW5uptXRyqvCdyzodpNnCBYHSrZ15K53oS0NRqzE2hkoEYxGoyw4TU1NVFRUyDVFGhsbZVdLIhTniPzgMCCoBBw7nSkX8q4vrGQem0mnSzmoOiv9IYX6hWYqGo3GMItc+jnUx7p69Wog6AuOF4VWgWtCNsN3tcqNTUL3iZJNy1oX23VmxvStfnzIkG6YUpSTdD1LFuatt97KvHnzAGLKYOxNxgQTTYWZZH/S0Oc5KTpl//798nlO9irSVeuiWa+nLD911/YRZ5GPGjUKCCZGSAKfiqgVOJiS/Y7jZZwKFZNagp1Mku5a2ec+EEOuSEkMuURoPfeuri7MZrNc5W/06NHU1NQk/NlFOSJ2rxLNMB3OXakVclEU6frSinmama4eIeHOQAMhCYxU3Q+C5z6SayXUSpdKVMTrI5cwn5rNmO5OmvYcLKGQKtdKz/cOthrNjBqWunk3ENJxlpLupBWiJNjz5s3jZz/7GRCMhotXyAFaZpQwfHdbsJ1iCJKQNzY2UlFcyc90P8cUSG4YpnO3i71KI6V5qTvGOp2OzZs39/uawybkUlB+aOzplClTePbZZ7nwwgtTapH39PTwP//zP2RkZOB2buGl3DJqduWTIyQ3xlQMiHSv68Y40kBzp5BSi9xkMslCLjXvDa3yNxhKcoOTNFAcDEFcu3YtSqUyJaGazj0uPI0eLNPMdNqEhHt1DoSUrBKahGMwGIIFkJRKLBaLLOChFrnf76eioiLhqJaa0814FAp2vRl8f6p85D67H1WdE2tpJrrkV22Nmd55BpKQS3PVaDRy4okn8ve//528vLyEhNx4Yg7tGi2NS5rCHpeu5cyAmcubr+ASw6WM+mzMgFmS8dCzx8VepYGyFIUeQnDDuL8KqHAYhXzy5MlAsJ62PBiFgvnz56NUKiNa5K+88kpCJ7o3n3zyCWvXrj2QCennfXUbPUY1F+gvTOpJtq6y4trrJn9BHo3tsTeUSIRQH3lXV1dSGzNLNyBHnoG6tfXcfffd+P3+lDTgsH5hRZWlwjjGQKdNICsjNcfsgQce6JO8Jt2YtFotFotFts6l0hFSH82KigpsNltCq8XcfAXfZ+Xg+CjoakiVRW7/3o4ggnZ86hOB+iOakEuuAoPBQGZmJj//+c8jhtnF0hS5okTkLcswGl9qwd9z8PUKhYJhyuH8NfMhtCodd9n+h6yGbJpeSCz3pTeiX8S970BWZwot8kmTJvHGG2/0+5rDJuSSz6q+vj7i8703O7u6urjiiit49NFHBy1OkmtAKsnrd2zkw9HDOEV7Kpr25HWFb3qxBfM0M/oKPc2dCopyUneyJR95Q0MDLS0tYa4ViURvUjoNZGcE6LAYUbWoEEhRnBXQtcqKeWomgkLAak+dRa7T6cIS2+CgkGs0mj4WeWZmpuxKkjrLJ2qV14/IQ7+1C5/VlzIfue07G80GPdWjU5OwFSu9hVy6OUpCHhpcECmDMTR0MFqJhPKCAO9mlRDwQ8vrB/eCMuvNPJDxFxoCDdRdWssa72r2TtpD7d37wpLbEsXd6AavSKNWP6iGEsngsAk5wKOPPsoLL7wQ8TmpNK4k5NIE2L17NxUVFWFJBrHy8MMPs27dOtrb26moqODWW28NPtGzgWXKUvb4d1O0qrj/D4kRd7OH9g86KLwgWIChuTP1FrnD4WDs2LE0NzdHtMi7urr61C2PleJckf16A+qAmlxFXrKGHYboE7Gu7sYyLbh/0mlPnY88EpJlrNVqycrKChNys9ksi055eXlwfAmWulVMzsIvCLz5h7dpampKiZB3fW3nB62FMcMPn38cgpEoklGWn59PXV0dXq83opBHymCUErQgeuhicY6IX6vEMb2A/c82IQZEWt5o5f99ehyrvV9yp+33VI8PVmUtXzgc41gj22/cScAzuGPjOtBwOVCgR31475eHV8gvueQSece6N4IghHWIly6a/fv343A4uO222+K2zO+8804WLFhAR0eHvEwGoOcHmqxannW/QtaObGzfJ96wWKLllRbU2WqyT87C5gC7M7U+cqPRGGa9mM1m8vLy5No1EIy0mDBhQkyNbntTnCOyRxG86MqUZQO8OjHsP9jx2/1YpgeFvMsOWYcwBFoSFcm1ErrZaTabZVeSZJEnKuSVFQI/ZOWw77V9vPPOO0l3rYgBke5vbWzWWRhbnpoEtHiQhLyqqoq6ujqqqqpYuHAharU6rP5/JNdK6P5EtOtdqYThBQG2TyzBtc/F1mu2s+PmXWwoX8/DPX/Fh0/e15g+Yzoj/lqFq9ZF3aORvQGx4qx14TJpyC9OXehhrBxWIR8IjUYjW+TSnVkKY9q3bx9LliyJ+zOdTift7e3hQu74AYCLHn0A8/GZ7H1gX5R3x4boE2n6VwsFP8tHoVbQ3HmgNG+KLfLQ5Cmz2cy4cePYsGGD/JhUEGqgjtyRKM4JsLdbRZ1/H3Ny5nLRRRcNftC96PrCim64Ft2BAv2dKXStRCLUIi8rK5Pr/litViwWi7y0HzZsWHB8CQr5iNIAH+gKOEY9CT2GpFvkzl1OsPupzcpkWArD4mIlVMi3bdtGd3c3Nputj/87kmslNIa/v/2xiiKRbV4D2adk0flRFzUPVLG68Ev5+dCuQLoyHZV3llP/xH6sX3VH+riYcO4JtndLpX88Voa0kKvVajnqQrpoJNfAmDFjwqzNWPF4PLS1tclC/sEHH/Dxe69SmB0gYBzP8NuGYf2ym67V1gE+KTodn3TiafZQ+LPg5GnqCB7mWJsuJ0LvRCaLxcJRRx0V9phksSdSjrUoR2R/KzzveI6p3mnce/V9iQ82CkH/eNAaF0XoOsRCHuojnzJlCj/88ANLly5l+fLlmM1m+bhlZ2eTmZkZs5CLohjWHLumNMBXpjxE4P9p/l/Smy13f2vHq1ViqtZGLSR1KJGMsClTpoRtEPeehwaDAZvNFraXEyrk/a3AhxcG2NOkoPruSia8M578n+aFxV73jrDKm59Lztxsdty8E193YtnjrloXjRoDZWkh75/Q+iHSZJAiM0pKSuKyiEInUKhrZfLkyRx99NGMLQ+wqVZBxgQTWSdYqF/cN8EgVppfaCFrZhbakuDGaXOngE4jYk5+qXOZ3kJuMBj6bOZJqxlRFFmyZIlcZnQgtm7dStPer9nfruBL7yoUYxXsvrM2qRE+/h4/tu/ssn+8xwVe3+ERcgiKjt/v56KLLmLfvn1hFrnZbCYrKyvMf9sfH374IXPmzOH7778HYFi+iF8r8K3QyEUjLu7T/Hmw2L61UZ9tZuSw1JS3SBSpD0E0ampq6OnpCQuACBXy/kJpKwoD7GlUoM5Ws3T9O9TW1vabRCMIAlV/qkT0iez+Y23sf0QIzloXuwRjyqoexsOQFnKz2Sz7yEJFW6/Xk5eXF1fUQGjrqT6uFTgg5EFfV+nCEqxfdmP7LoE2c3UuOj/rkjc5gQMNJcSUFdWB8MSWp59+mvLyctRqNRMnTgSCFrqUxLJ8+XKuu+46Pv3005jCu2688Uae/fuf6OpRgkJHxtVGbOtttL7VPuB7Y6V7XTeiT5Qt8i578GClKvwwEpKQ+/1+cnNzw26EZrNZPlYZGRnk5ubGnBQkuQSk9ngKBRRkWvnS4KO0vRS1P7l9Ym3f2vhebWb0sNQk08XL448/zosvvkhRURErV66MGuAwevRoFAoFP/zwg/xY6HUrCbkoitx///1hNVQqigI0tAm4vXDllVdy9dVXh703EmqLipoHqmn9dxtty+KbywFvAFedi21+I2UpqkMeD0NayDMzM7FarWzYsIGWlhb5cYPBEBZVEAuhJ7W1tbVPl5Cx5X421yoIBCBzUgbm4zOpS8Aqb/5XC9piDVkzLPJjTR0KilLoVoGgD3DlypW89NJLLFiwQN6Ye/PNN3nmmWcwmUxymr6UZg7hzSiiUVlZCZ4DVpKmBPPYTIouLqT23r347MnZTOv6woppnBG1Jbj933lAyA+lRT5y5EjmzJnDL3/5S+Bg0hCEC7lKpaKgoEAW5oGQNvQk11ZdXR3Zuha+yy5CDEDHB8lp9Azg7fTi3OVinZA1ZCzyiy66iNNOOw0IHtN58+YxY8aMPpu8er2empqaMCG32+1yHaTQOi133303V199tfw6v30HoiiwcWfQghcEQb6BTpo0KerYLNPNFF1ayO47a+Nysbjr3eCH/RpD2iIfCLPZzO7du5kxYwbPPPOMbHV6vV45YcNqtbJo0SK8Xi82my2quIcKeWdnZ59O2mPLAzjcArUHqqiVXlNC50dd2DcN3NRVIuAJ0PxKKwU/L0BQHjS/mzsFClIYsSJx3HHHMXfu3LDHLBYL55xzDnq9PqIrQEo57w9RFMF94KamDTaxGPbrUkSfSP3fEndBhdK1qhvztIN1MGSL/BAKeVZWFv/617+48sorAZg2bZr8nF6vDyvbW1hYGHNTFWnutbS04HK5GD9+PBvXvU6PcRQ5s7PZftNONl2yhda32vA7B3djtH1nR1TANr2ZUWVDwyKPxPPPPy83Qw7lhBNO4KWXXpJdoTabTW4+s2zZMl599VX5eK5du1Z+31WXzgbg203Bm6LFYsHhcPDggw/y4Ycf9juWYTcE9yjiMdyctS5EARo1+rRFPhBms1nuFwoHLyy32y1b5GvWrOHJJ59k3759TJw4UY7x7U3vZVboLjYEIwlUSpGNB9wr5qmZZBxtikuo2t/rwGf1UXBeeJy15Fo5nOh0uoiugEgXU2/sdjv4rQiiAzQlGI1GVGYVw28pY/8zjTj3DC65wtPqwbHNIYcdAnTaBJQKEVNqypDExIIFC3juueeA4PxZsmQJK1asAJAt8s2bN0ftnN7e3o7T6ZTnXlNTk1xsy2/bhEc5nKoHqhnzfyNRZirZsWgX66Z8y847dtP9rS2hPQjbtzZchUay8hWH9CYYL0qlMiz0UOL666+ntrZW3hzu6emRhfyxxx7j8ssvl/3mPT098jGyd7eCu4GNBxJ9TCYTNpstplaEqkwVw28to/EfTTh3xzaXXbUu/FladBkKMpNfqSJuhrSQ9y7KdMMNNwAHhbyzs1OOXGlpaZE380LZtWsXTzzxBBdffHHY4wUFBWG/a9Qwoiy44QnBpVnptSW0r+yQGyoMRNOLLWTPzkKTF17coqkjtTHksWAwGCJWQIxlw04SKsGzH4V+mBxOVnBuPoYRBvb8ObEkIwmpbG3mpINB4132YHp+KvcVBkKpVHLCCScAQb94Tk4Oxx9/PBC0yHft2sXs2bOZPXt2n/eKokhVVRWXXnppWFXKL774IvgCxxZEQUt9p4KsE7MY9fgIjl0zieG3ltGzuYcfFmxi/dwNeFriqzVk+85OfU7mYU8ESpTS0lIyMzPlDU+73U5mZmaY6IcaZS0tLQfdg65d7KwPXmd1dXXY7XY5VHQg8hfkYRgZ+1y2fWfHnqUfEhErMMSFXKqQeP311/P5558zZswY+TmLxYLH45FrtUQr0/qHP/yB22+/vU8pAOkuH8q48oNCDpA104JxtIH6Jwa2yh27nHSv6abwgoI+zwVL2B7eEx4tVjkeIQ8496EyDpf974JSoPL35XR+1EXHx4n7eaWytQrtwWPfZQfL4S0TAgTn2dKlS7niiivCHi8oKJDD4TZv3tzHiJD8vO+++64sPPX19Wzbti34AucOBES21x/8m9UWFUUXFzLhzfEcvTIYOrr12h0xZyCKPhHbejsbNBbGlA8NgUmEkpISGhqC15zdbsdoNIbN31Ah37t3r9wYBOdu1m8L7kNILsOqqthq+AoKgco/lNP5cRfdX/Qf5ND0UjNty9rZMKZkSPjH4QgR8urqasaPHx9WpElqzfbdd98B0bmcZHgAABX+SURBVIU8WjuySMu60MgVOGCVX1NC69ttOPf2X0Ww6cVmdBU6zMeFryKcbujuESg8zK6VaNmD8Qg57gYU+vCszszJGeSdncueu/YScMcvHnLZ2unhdaI7bYc2Pb8/pk+f3me+SGWBpT0JSXgkPv30U/lnyX21adMm9u/fz+WXX87rr/6TsvxwIQ/FMMLAqCdG4NjmoPbu2KxE67puAs4AH7uyhkRGZ6IUFxeHCbnJZAord91byGVcu+jxFTB//nycTicmk6mPC7U/MidlkHtmDo0PNEW9eXZ9YWXX7/cw/LZhrM3MZ9gQ8I/DEBdySbgj+b2lE7RlyxYgmLofiXiqJY4t97OnUYE95C05c7LRV+hpeDLy50Ow43vL660UXlDQpyKgnNV5mF0rkYS8uLg4JiG32+3B93saQF3S5/nhi4bhafWw/x+xRXGEElq2NhTJtTJUqaqqoqWlhccffxygTwRLQ0MDxxxzDHq9nn//+98UFRXR3d3N2rVrKS8vZ9asWYwoDbC9LvolqK/QM+KhahqXNNPy7/4bg3R/Y2Pr1dvRTs1ij2j4UVnkJpNJNtwgaLQJgsDIkSP59ttvD77RtRt0lYwbNx4InqN4K3SWLxqGp8lL4/N9N7IdOxxsvXY7+T/No+SKIupaFGmLPBak2PFQP1deXh7z58+noKAArVaLKIooFIqwcrhutzus2NYFF1wgP/foo49y3XXXRfw+afJv2XvwsAgKgdJriml5vTVY7SyEgDtA/d8b+GbWetTZagoW9C0m1dh+IKtzCGx29mb48OExW+RFRUXgrsevKuzzvLZAQ9l1pdQ9Uo9jR+w9FyGkbO3o8B2jVNYiTxYajQaNRkNubm5YOzEINjOorq7mlFNOoaenh2OOOUaOU5eir0aUBdgRxSKXyJ6VRdl1Jez6zW7sGyNHUHV+1sWmS7aQNcNC45WjUSqDm/dHKiUlJbz33nts2rRJdq2EakB9fT0mk4mxY8fyxBNPAHDVVVcFhVypR20MvnbkyJFxf7e2SEv+r/Koe7QeT9vBqB9Pm5fN/7UN0zgjVXdVAAL1rcKQiFiBIS7k5557LuPHjw9LYd6xYwfPPvssCoWCsrLgMn/s2LFs3LhRfs2kSZOYOnUqEBTyrKwsjj76aCBYqOuuu+6K+H1F2SJZGWKYewUg7/RctEUaGp4KXqyiKNL+Xgffzf6eusUNlC0s5egVR6Ey9y2B1twpoFaJZGce/s1OgF/84he89NJLQHBVEyrkFouFf/7zn2HvE0XxoJB79uNT5OKLsGov+VURpglGtl23A78r9skdWrY27PGeoS/kEkVFRX1WhPv376eoqEhuCJCZmSknGEmhryNKA1FdK6GUXV+K+XgzW6/ehrczPKSwbXk7Wy7fRt7ZuYx4qJrN9SpqSgJok5tjdEiZNSvYrWvx4sXs3r2bsrKyMBdJXV0dRqORJ598Un5s4sSJ4AwGPjjFooOPJUDeJTmoLCr2/aUOCBpsW6/ahkIjMOpvI1CoFbR2Cbi9wpCoswJDXMhramr4/PPPUaki14iUqtCddNJJYZuZVquVnTt3AsHKdVlZWbz99ttyinQ0BCHoXgnd8AQQVAIlVxXT/FIzXV9Y2XTRFrZevZ3MKZlM+mgipVcWh23UhXIosjpjQbLIQ6v4ZWVl0d3dHVZWdPny5UAw6cLn83H//fcjimLQinTXI6KkpavvHyMoBUY8VIOnzcueu2pjGpNctna6pc9zR4JFLuHz+bjvvvu47rrrmDdvHlu3bqWxsZHi4mJGjx4NBF180s/Svk1NaYD2bgXt1v4nh6AQGPFQNYJKYPuvdyL6g8el+eUWtl2/g+LLiqj6UwWCUmBTrYKxFUNDXBJl8uTJXHrppbz44os4nU5OP/30MGOuvr4eo9GIWq2WfefFxcXgaweflYaO4FwPDY6IB4VOQfntw2h+pQX7D3Z23LoLZ62L0U+Pko21+tbgOUtlZ6B4GNJCPhDDhg2jqKhIDi2UMsBCkSzyjIwMWfj7Y2x5gI21fQ9L/vw8VNlqNl2yBdErMuGt8dTcV9Un1LA3qW7xFiuSj7y8vFwWlOnTpwPBDU/JMpeyF8vLy5kzZw733HMPcCBc80BSUGN7ZOHRFmqoeaCK5pdaaFs+cMqzXLZ2Wt/en0PdRx7K/PnzAViyZAmrVq3i4YcfprGxkaKiIrkPbV1dHbfffjvz58+XRUlyf8RilavMKkY9MZLub2zs/UsdDU/tZ+ftuxl+Sxnli4bJN+fNe5VHbOhhKNK1OmXKFLKzs7nuuuu44447gGAkkGSYSKGw8rXv2oXKFHSpTJw4EWsPrPhKyR1Pa5m7SM/tT2lZs1nJQHXjcuZkYz4uk40Xb6H9vQ5G/30k+uEH3ZN1rQrUKvGw54dIHOZy6INj3rx5FBQUUF1dzR//+EfGjx8vX1QSkpDHytjyAC99pEYUCbOiFVoFIx+uxtvhI/vUrAE3UWwOaGhTsKlWedhDD+FgpbmKigqGDx9OV1eX7NdtaGiQN4UDgQA+nw+HwyEnr8ycOZMJEyaA928ohACffq/CqPNRmB3AbAw/Ttkzsyj+ryJ2/vduTOOM6IZFDnt07XOx+4+16Kt0ctlaAIcLGtoEOrqPHIv8tttu48ILL2Ts2LEAvP/++/j9fkaNGiVv0hkMBoYNG8azzz4rvy/XHHTl7ahXcPzYgaNMjKMMVN9byfZf7wQBqu6uoPDnB8NdHS7Y3Sgw5giOWJGQhFxKrzebzdx2223U1dWxZMkS6uqCbg8pmkjOOXHtYUvjUdzwsINz/qhi/a7gTfLo6gATq/x8/oOSJ97WUJgd4IzjfZw5zcfUMX6UvUqKC4JAxe/K+eG8TdTcV0Xm5PDC+HWtAiW54pCoLglHuJCffPLJckW166+/vk96/ocffojL5YpLyMeV++nuETjlVgMGrYheAzqtiE4Deo022AnkgGsuNPHO6w9ubNa3CdS3KujuOahuv71o8H0zB4uUTh4aAVRQUIBGo2Hfvn1yo1q/3x+23zB9+nTeeOONAz0DA1QXdPLH53P44/PBJa1GJZKfFbRMsjNEtBoRvaKG04123v/ZLr64eCIanQKF4uDBKtrQzOjlO+nJ1fPVvPE8+Ccd9a0K6lsFOmzBcSgUIpVFh/8GGCuhYa7t7e1ccsklsk/8ww8/jJiYIghBq/x/ntew+C213EBPEA7+M2jBoBMx6ESMWjDoShg9W8CTqeEdWy7+JyHgB38guIoJBATGHsERKxLSPkLvEr+PPPIIS5YskevWSBa5FKqsdG1m9aafYnMIzDjKz60/dzN1rD+s8uju/QJvf6nm7S9VPLVMQ645wKQRATQqMXh9i0r0OjUalRb1VdMI7BfwL4aAGDzOgYDA+p2KIeMfhyNcyHsT2hEd4Nprr8VkMsnL21iYUBXgrstctFsFnB4BlwecbgGnGzq6Ffh7nTvJGlUqgvXGJ40QKckLUJYnUpIboDhHxJD8Tl5xI6Xnh14Y0obxvn375Auhq6tLtsThYLz05MmT0ev1rLzPjkavoblToLlTQUunQFOHQEtX0Ip2ewU8PgUrTxjDuW98TeHSWt4bX40ogtbrY8532xm3r5lVI4fzydgK1HaB0jyRcRU+SvNEyvIClOYFKMkdGsctVhQhpllxcTF33nmn/Ht/RZv+dJmLVRtVslEgctBA8AeCeQg9LgGHGxwugeYOBbuzSgkEQFkbnHfSP4UC/us0z5Dx2w6Go48+mgsvvJDzzjsv7HFFLxNYsshNJhOPPPIIY8dNoHqkrd9ksspikRsWeLhhgYe9zQLvrFaxvU6B1yfg9QWvd5cXfH4FXl/wuCqEA/8rRBQCVJcEOHv60ChKBjEIeSAQ4Oabb2bjxo1oNBoee+yxYDW8Azz33HM8++yzqFQqbrnlFubMmZPSAfeHstf6qKmpiW+++SZqUlDkz4Dr5g/dYkOJcs8993Dcccf1SWwpKyvjwQcflDv+tLS0sGnTJtRqNV6vV44WKCsrCwuxM+lFqor7W8ILtM2oRLtwB7+4xYDKrGL7jTsRfSI1L4xm+vFmFtF/ktWRiFKpZOPGjX0EJxrHjgpw7Kj40vD/E9Dr9SxevDjic6FdrySLXKVS8Ytf/CLu7xleILLw7PDr3Waz9TEKhzoDCvnSpUtxuVy8//77rFu3jt/85jdy+FpzczNPPvkkH3/8MS6Xi7lz5zJz5sywLKxDTWlpqRzBcswxx8Scovtjp7KykhtvvLHP41qtlu7ubv72t78BwZvf8uXLOfnkk1mxYkVcbqne5J6WQ9f5VrbfsBO/00/OydlU3V2BOusIjo3rh23btqFQKGIW8TSJEeqmmj59ekKdwn5sDDjj1qxZI/uhjz322LCyp9988w1TpkxBq9ViNpupqKgIS8w5HJx++unyz+eee+5hHMmRwX333Sc3wD755JOZMGECzc3NnHnmmTzwwAMJWTmhVPyuHMsMM1V3VTDybzU/WhGH4J5DXl7fpLA0qeOBBx5g69ath3sYh50BLXKbzRZWhVCpVOLz+VCpVH2eM5lMYZ3cI2G325PaIqw3ixYtYs6cOdTX13PKKadELTF6uOivXdXhICcnh/vuu4+amhrOO+88srKyePHFFznhhBPIyMjA5/MN+hiW3BN0bYW27YqHoXbMQkmPLTGSOTaj0ZjU63yoHrf+3D0DCnlo30wI+sylBJ3ez9ntdnnTLBqx1AceLJMmTeLEE09M+fckylDzv2VkZHDzzTfL47r55psP84j6MtSOWSjpsSVGemzJY0DXypQpU+TmDuvWrQvLlpo0aRKrV6/G5XJhtVrZvn27nGySJk2aNGkODQNa5GeccQaffPIJp556KqIosnjxYh5//HEqKys57bTTuPLKK5k7dy6BQIDf/va3Uetep0mTJk2a1CB0dXUd+UGnvRjK4UNDdWxDdVyQHluipMeWGEN5bNFIx0mlSZMmzRFOWsjTpEmT5ggnLeRp0qRJc4STFvI0adKkOcJJC3maNGnSHOH8KKNW0qRJk+Y/ibRFniZNmjRHOGkhT5MmTZojnLSQp0mTJs0RTlrI06RJk+YIJy3kadKkSXOEkxbyNGnSpDnCSQt5mjRp0hzhHHFC/vXXX8utydavX89JJ53E3LlzufXWWwkEDra4dzgcTJ8+nQ8++CDs/V988QVjx44dUmOrra1l7ty5zJ07lyuuuAKHw3HIx3X++ecze/Zs5s2bx4IFC8Le/+qrr3LKKackdUyDHVt/x/dQju2FF15g1qxZnHjiidx///1h7z/ccy3S2FI912IZ2wcffMC8efOYN28ep512GtnZ2Wzbtk1+/+Gcb9HGdijm22A4ooT8kUce4frrr8ftdgNwww03cM8997BixQrMZjOvvvqq/NpbbrkFQRDC3l9fX8/ixYvxesO7Zh/usf3+97/nsssuY8WKFUyfPj1q9/BUjmv37t2sXLmSZcuW8dprr8nv//7771myZElK2vMNZmz9Hd9DNbY9e/bwzDPPsHTpUj766CM8Ho88tw73XIs2tlTOtVjHdvLJJ7Ns2TKWLVvGnDlzuOGGGxg5ciRw+OdbtLGler4NliNKyMvLy1myZIn8+/79+5kyZQoQ7GS0Zs0aAB577DGmTJnCuHHj5Ne6XC5uuukm/vKXvwy5sW3btk22QEJfe6jG1dLSgtVq5ec//zlz5sxh5cqVAHR0dHDXXXdxzz33JG08yRpbtON7KMf2ySefcPTRR3P11Vczb948jjvuONRq9ZCYa9HGlsq5FuvYJBoaGvjXv/7FokWLgKEx36KNLdXzbbAcUUJ+1llnyf1CIXhivvjiCwBWrlxJT08Pn376Kbt27erT/f3WW29l4cKFFBcXD7mxjR8/nuXLlwOwYsWKpC53YxmXx+Ph2muv5YUXXmDJkiXccccdtLS0sHDhQv785z+nrM9qomNrbW2N+NpDPbb29na+/PJLHnvsMZ5//nkWLVpEV1fXkJhr0caWyrkW69gkFi9ezDXXXINWq8Xv9w+J+RZpbAO9dihwRAl5bxYvXsxDDz3EmWeeSW5uLjk5OSxZsoQtW7Ywb948PvzwQ37/+9+zdu1aVq9ezX333ce8efPo7OzksssuGxJj27BhA3/6059YsWIF8+bNQxAEsrOzD+m4CgoKuOyyy1CpVOTl5XHUUUexfft2du/ezU033cSvfvUrtm3bxn//93+nbFzxjG3Hjh0RX3uox5adnc20adPIyMggLy+PESNGsGnTpiEx1yKNbdeuXYd0rkUbGwSbuL/77rv89Kc/BYL+6qEw3yKNrb/XDhWOaCF/9913eeqpp3j77bfp6Ohg5syZPP3007z77rssW7aMWbNm8cc//pEpU6bw9ddfy76vrKwsnnnmmSExtqOOOoqPP/6Y3//+9yxbtgyFQsHMmTMP6bg++eQTLr30UgDsdjtbtmxh9OjRrFmzhmXLlvF///d/jBw5knvvvTdl44pnbCNHjoz42kM9tilTprBq1SpcLhc9PT1s27aNMWPGDIm5FmlslZWVh3SuRRsbwObNm6mpqUGv1wPBRu5DYb5FGlt/rx0qDNh8eShTVVXFmWeeicFg4Cc/+Qmnnnrq4R6STDxjq6mp4fLLL0er1TJq1CgefPDBQz6uDz/8kJNPPhmFQsHvfve7w2JxxDO2Q33uo33fRRddxOzZsxFFkVtvvZWsrKyUjmOwYzuUc62/se3cuZPy8vKUfncyxzaUtQbSZWzTpEmT5ojniHatpEmTJk2atJCnSZMmzRFPWsjTpEmT5ggnLeRp0qRJc4STFvI0adKkOcJJC3maHyWff/45FouF119/PezxqVOncvXVV8f1WZs2bWLVqlVAMAvX5XIlbZxp0iSDtJCn+dEyYsSIMCHftGlTQinpb7/9dlh1vjRphhpHdEJQmjT9MW7cOHbs2IHVasVsNvPKK69w7rnnUl9fzyuvvMITTzyBVqulsrKSRx55hFdeeYX3338fp9PJnj17+PWvf83MmTN58cUX0Wg0TJgwAYCbbrqJvXv3AsFSsRaL5XD+mWnSpC3yND9uzjzzTN555x1EUeSbb75hypQpdHR0cM899/D222+zcuVKzGYzzz77LADd3d28/PLLvPTSSzz88MMUFxdzwQUXcO211zJp0iQALr74YpYtW8awYcP4+OOPD+eflyYNkBbyND9yzj33XP7973+zatUqjj/+eABEUWTUqFFkZGQAQb/51q1bgaAPHKCkpCSqL3zixIkAFBQUpKQxQ5o08ZIW8jQ/asrLy3E4HDz55JP87Gc/A0AQBLZt2yaXIl21ahVVVVXyc71RKBRhHWEivSZNmsNJWsjT/OiZP38+DQ0NVFdXA5Cdnc3tt9/OGWecwcknn0xHRwe/+tWvor5/4sSJPPXUU3z22WeHashp0sRFumhWmjRp0hzhpC3yNGnSpDnCSQt5mjRp0hzhpIU8TZo0aY5w0kKeJk2aNEc4aSFPkyZNmiOctJCnSZMmzRFOWsjTpEmT5gjn/wMjzMy4H6GAQQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ - "# this function is used to backtest the model with a forecasting horizon of three years (36 months)\n", + "# this function is used to backtest the model at a forecasting horizon of three years (36 months)\n", "def backtest(testing_model):\n", " # Compute the backtest predictions with the two models\n", - " pred_series = testing_model.backtest(training_series = series_sp_scaled, \n", - " start = pd.Timestamp('19401001'), \n", - " forecast_horizon = 36,\n", - " stride = 10,\n", - " retrain = False,\n", - " verbose = True,\n", - " use_full_output_length = True)\n", + " pred_series = testing_model.historical_forecasts(training_series = series_sp_scaled, \n", + " start = pd.Timestamp('19401001'), \n", + " forecast_horizon = 36,\n", + " stride = 10,\n", + " retrain = False,\n", + " verbose = True,\n", + " use_full_output_length = True)\n", " \n", - " pred_series_ets = ExponentialSmoothing().backtest(training_series = series_sp_scaled,\n", - " start = pd.Timestamp('19401001'), \n", - " forecast_horizon = 36,\n", - " stride = 10,\n", - " retrain = True,\n", - " verbose = True)\n", + " pred_series_ets = ExponentialSmoothing().historical_forecasts(training_series = series_sp_scaled,\n", + " start = pd.Timestamp('19401001'), \n", + " forecast_horizon = 36,\n", + " stride = 10,\n", + " retrain = True,\n", + " verbose = True)\n", " val_sp_scaled.plot(label = 'actual')\n", " pred_series.plot(label = 'our Transformer')\n", " pred_series_ets.plot(label = 'ETS')\n", @@ -625,7 +609,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -642,7 +626,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -673,28 +657,26 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 19, "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=200.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "db76c5a3c79a482196489971f7bb42f2", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=200.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "211cf7a106bf4670b275d8315068ec54" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "Training loss: 0.0226, validation loss: 0.0411\n" + "\n" ] } ], @@ -704,69 +686,64 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 20, "metadata": {}, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "loading model_best_140.pth.tar\n" + "loading model_best_185.pth.tar\n" ] }, { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=49.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "829665a827e6477abb04264d22007fbe", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=49.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "0bf7dbec05b4470486e84b155173004f" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "\n" ] }, { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=49.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "dbb7a3e35e8c4fcaaebe535f3c45a5c3", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=49.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "29f8c15308874b36a485b77e9a6b4b69" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "\n", - "Transformer MAPE: 81.02573214593866\n", - "ETS MAPE: 593.7817328101518\n" + "\nTransformer MAPE: 66.44409793467437\nETS MAPE: 593.7634916506821\n" ] }, { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -791,9 +768,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.9" + "version": "3.8.5-final" } }, "nbformat": 4, "nbformat_minor": 4 -} +} \ No newline at end of file diff --git a/examples/darts-intro.ipynb b/examples/darts-intro.ipynb index 0f1bd51aff..6abc5bfe38 100644 --- a/examples/darts-intro.ipynb +++ b/examples/darts-intro.ipynb @@ -81,14 +81,15 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -114,14 +115,15 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -147,14 +149,15 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -183,14 +186,15 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -212,8 +216,8 @@ }, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "There is seasonality of order 12.\n" ] @@ -240,14 +244,15 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -273,14 +278,15 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -313,10 +319,10 @@ }, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "Mean absolute percentage error for the combined naive drift + seasonal: 5.77%.\n" + "Mean absolute percentage error for the combined naive drift + seasonal: 5.66%.\n" ] } ], @@ -342,8 +348,8 @@ }, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "model Exponential smoothing obtains MAPE: 6.50%\n", "model Prophet obtains MAPE: 9.72%\n", @@ -418,8 +424,8 @@ }, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "The MAPE is: 4.40, with theta = -3.5102040816326543.\n" ] @@ -439,14 +445,15 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -472,7 +479,10 @@ "\n", "Backtesting simulates predictions that would have been obtained historically with a given model. It can take a while to produce, since the model is re-fit every time the simulated prediction time advances.\n", "\n", - "Such simulated forecasts are always defined with respect to a *forecast horizon*, which is the number of time steps that separate the prediction time from the forecast time. In the example below, we simulate forecasts done for 3 months in the future (compared to prediction time)." + "Such simulated forecasts are always defined with respect to a *forecast horizon*, which is the number of time steps that separate the prediction time from the forecast time. In the example below, we simulate forecasts done for 3 months in the future (compared to prediction time).\n", + "\n", + "Using the `backtest()` method, you can either look at the performance of the model evaluated over the whole forecasts it produces (each point in each forecast is used to compute an error score) or only the last point of each historical forecast.\n", + "In the latter case, you can get a time series representation of those points by calling `historical_forecasts()` with the default setting (`last_points_only=True`)" ] }, { @@ -483,22 +493,90 @@ }, "outputs": [ { + "output_type": "display_data", + "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=69.0), HTML(value='')))", + "application/vnd.jupyter.widget-view+json": { + "version_major": 2, + "version_minor": 0, + "model_id": "1463a044af2d416595281c7bfaa92f1d" + } + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n" + ] + }, + { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=69.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "c8178579206c438dbd43a701e1a8a56a", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=70.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "da0750f72b2c4dd8a5d5e3c0fb8432a0" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { + "output_type": "stream", "name": "stdout", + "text": [ + "\n", + "Average error (MAPE) over all historical forecasts: 6.194975084052747\n", + "Median error (MAPE) over all historical forecasts: 4.2892317587628455\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=69.0), HTML(value='')))", + "application/vnd.jupyter.widget-view+json": { + "version_major": 2, + "version_minor": 0, + "model_id": "f2c63003f7bb414fb116f761ac6521c7" + } + }, + "metadata": {} + }, + { "output_type": "stream", + "name": "stdout", + "text": [ + "\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAEHCAYAAACOWawdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAXcElEQVR4nO3de5hsVXnn8e8LNBDkFkMi2oDGAzLCiGgtJ1wEETwqCeEYo0FxBETmQJw2BogxJsIgUeOoT0QjgWDCOIoQBiI2Y/DG+HARyeDq6DBGI+GE22kuQ4ADKhcb2PPH3g1Fnerqruqurl7w/TxPPWfXXvvy1qrdv7N77drVUVUVkqRybDLqAiRJ/TG4JakwBrckFcbglqTCGNySVBiDW5IKY3CvcBFxWkSc10zvEhE/jYhNF7De2RFxSo/2KiJ2Xcr6tHgRcXxEnNFMv6B5nzabY9k/joi/Xt4Khy8irouIPUddx0rW9YDQ0oqIm4Hjqqq6fDHbqarqVmDrBS57wmL2peUXEZsDHwD2WcjyVVV9ZIHbvQI4r6qqUkL+E8DpwG+PupCVyjNurQjdzirnOtPsZxvDtsT7XAP8c1VV00u4zaEaUp9fCrw6Ip47hG0/LRjcyywijomIb0fEJyLivoi4KSIObWv/1Yi4MiJ+EhHfBHZoa3viV+eIeEtE5I5tnxgRlzbTn4uID7W1vTci7oiI2yPi2I71roiI4zprbHv+qYi4LSIeiIipiDigj9d7WER8PyI2RMR3ImKvtrabI+J9EXE98LOI2LV5fe+MiFuBb0XEJhHxgYi4JSL+X0R8PiK26+iPJ5bvsv8dIuIrzf7vjYirI2KTpm3niPhSRNwdEfdExGea+X3vMyKOjYgfNe/p1yPi+c38iIhPNtu5PyKuj4h/P0d3HQpc2WX+2yLi1oj4t4j4k7bX1j6MtmVEnNe8jg0R8d2IeE5EfBg4APhM1MNss69xv2aZ+5t/92vb7q9GxFXNMXh5RJzZtp+5Xv9FEXFns72rom2oozkW/zIivtrUcE1E7BgRZzT99c8R8bLZ5auqehiYAl47Rz894xnco/FrwI+pQ/ljwN9ERDRt51MftDsAfwocPcc2LgV2j4jd2uYd2az/FBHxeuAPgNXAbsBr+qz3u8DewLOb7V8UEVvOt1JEvBw4Fzge+CXgr4BLI2KLtsXeCvwGsD3waDPvVcCLgdcBxzSPVwMvpB4q+kzHrtqX73QysB74ZeA5wB8DVdTXCb4C3AK8ABgH/rZZp699RsQbmu2+sdnP1cAFzXKvBQ4EXtS8xiOAe7rUCfAS6uOi0yuB3YFDgFMj4sVdljka2A7YmbqvTwAeqqrqT5p6Jqqq2rqqqomIeDbw98Cnm2X/HPj7iPilZlvnA9c1bacBb++yv84+/yr1sfUrwD8CX+xY/neoh4F2AB4Brm2W2wG4uKmh3Y+Al3bZrwCqqvIx5AdwM/CaZvoY4Ma2tq2ACtgR2IU6vJ7V1n4+9fgk1AFTAZs1z88DTm2mdwN+AmzVPP8c8KFm+lzgo23bfFGznV2b51dQj8HTVuO3e7ye+4CXNtOnzdbXZbmzgD/tmPdj4FVt/XJsW9vs63th27z/Bbyr7fnuwAz19ZmNlu9Sw+nA5OxrbZu/L3D3bF92tPW1T+rQemfb802AB4HnAwcDN1CPW28yz3HyL8Dru/THTm3zrgPe0tn3wLHAd4C9umy38/19O3BdxzLXNu/77DG4VVvbeWx8DPbq8+2bZbZrOxY/29b+buBHbc9fAmzo2MaHgXNH/bO7Uh+ecY/GnbMTVVU92ExuDTwPuK+qqp+1LXtLj+2cT33GCvXZ9pfbttfuecBtC9zmRiLi5GYY4P6I2EB9ZrfDfOtRB9fJza/uG5p1d27qmXVbl/Xa5z2vo95bqAP0OfNsY9bHgRuBb0TEv0bEHzXzdwZuqarq0S7r9LvP5wOfanuN9wIBjFdV9S3qs/Uzgbsi4pyI2HaOWu8Dtuky/8626QfpfoH6C8DXgb+NejjsYxExNsd+Ol8fzfPxpu3ejuOo53sUEZtGxEcjYl1EPED9HzI89Ri5q236oS7PO1/TNsCGOep/xjO4V5Y7gF+MiGe1zdulx/LfAHaIiL2pA3yjYZK27e7cY5s/oz7zn7Xj7ETU49nvo/5V9xerqtoeuJ86mOZzG/Dhqqq2b3tsVVXVBW3LdPt6yvZ5t1MHY3vtj/LUH/w5v+KyqqqfVFV1clVVLwR+EzgpIg5patslul9c63eftwHHd7zOX6iq6jtNDZ+uqqoF7En928575yj3+qa9b1VVzVRV9cGqqvYA9gMOA47qUits/Pqgfo3T1MfKsyOi/XjYmY21b/NI6gurr6H+T/0FzfyFHCNzeTHwfxax/tOawb2CVFV1C5CBD0bE5hHxSuqwmWv5R6nHBz9OPf78zTkW/R/AMRGxR/MD+V862r8PvDEitor6s93vbGvbhjq07gY2i4hTgbnOGDt9FjghIn6tuUj3rIj4jYjodlY5lwuAE5sLZlsDHwEunONMeSNRXxzdtbmG8ADwWPO4jjqkPtrUtWVE7D/gPs8G3j97QS4itouINzfTr2he/xj1f5APN/vv5jLqseO+RcSrI+Ilzdj9A9RDO7P7uYt6rL59Py+KiCOjvtB9BLAH8JW2Y/C05hjclx7HYGMb6nHre6hPABb0McUer2ULoMXcx/MznsG98hxJffHyXuqA/fw8y59PfaZz0VzBUlXVV4EzqD8BcCMbf/rik8DPqX/A/ztPvbD0deox3Buof51+mN5DE+37zcB/oh4quK/Z9zELWbfNudTDAFcBNzX7f3cf6+8GXA78lHoc9y+rqrqiqqrHqANpV+BW6guYRwyyz6qqLgH+K/UwxQPAD6g/IQL1f3KfpX79t1CH2yfm2NT/BP5dRDxvjvZedqT+T/wB6gt7V1KPTQN8CnhT8wmOT1dVdQ/1GfnJTT1/CBxWVdW/Ncu/jfoawD3Ah4ALqYN5Lp9vXts08EPgHwaov93hwBVVVd2+yO08bUVzIUDSChARa4E9qqr6/VHXMisiLqT+fHnnb2rD2t//pr7Y+4Pl2F+JDG5JTxERr6D+je8m6o8zfhnYt6qq7420MD3BW94lddoR+BL157jXA79raK8snnFLUmG8OClJhVmu4K4Gfdx5550DrzvMh3VZl3WtnMfTuK6uVvwZ92OPzfWR19Gyrv5YV3+sqz/PtLpWfHBLkp7K4JakwhjcklQYg1uSCmNwS1JhDG5JKsy8t7ynlLah/na1Pan/isdNwCXAltRfG/mOnPPNQ6xRktRmIWfcD1F/BeTFzfNHqcP6QODPmPtL4SVJQzDvGXfO+VHg7pTS7PNHqL93F+ova1/QF9pLkpbGwN8OmFIaA04FjpujfS2wFmBiYoLVq1cPtJ+ZmRmmp6fnX3CJTU1N9WxftWpVz2VardZSl7Qgo+qv+VhXf6yrP0/XusbHx7vOX8zXup4DnJ1zXtetMed8TrMM9Ljnfj7T09NzFj9MO+20U8/2yclJ1qxZM2f7qL51cVT9NR/r6o919eeZVtdAnypJKX0AuCnnfOES1yNJmseCzrhTSpcBewO7p5TOov5biNeklA4Grs05v3+INUqS2iwouHPOv94xa74/YCtJGhJvwJGkwhjcklQYg1uSCmNwS1JhDG5JKozBLUmFMbglqTAGtyQVxuCWpMIY3JJUGINbkgpjcEtSYRbzfdzqISIGXndU3+UtqQyecUtSYQxuSSqMwS1JhTG4JakwBrckFcbglqTCGNySVBiDW5IKY3BLUmEMbkkqjMEtSYUxuCWpMAa3JBXG4Jakwsz7ta4ppW2Ay4E9gX1yzj9IKR0BvAd4GDg653zbcMuUJM1ayBn3Q8BhwMUAKaUx4CTgIOCU5iFJWiax0C/tTyl9DvgE8DjwBznnY5v51+ac9+2y/FpgLcDExERr9erVAxU4MzPD2NjYQOsuxtTUVM/2VatWsW7duqHsu9VqDbzuqPprPtbVH+vqz9O1rvHx8a5/kWWQv4CzPfBA2/NNuy2Ucz4HOKd5OvCfdJmenmZ8fHzQ1Qe200479WyfnJxkzZo1Q9n3Yv4Czqj6az7W1R/r6s8zra5BLk7eB2zb9vyxJapFkrQAg5xx3wjskVLaHHgFcP3SliRJ6mVBwZ1SugzYG9gdOAv4JHAl9adKjhpadZKkjSwouHPOv95l9oVLXIskaQG8AUeSCmNwS1JhDG5JKozBLUmFMbglqTAGtyQVxuCWpMIY3JJUGINbkgpjcEtSYQxuSSqMwS1JhTG4JakwBrckFcbglqTCGNySVBiDW5IKY3BLUmEMbkkqjMEtSYUxuCWpMAa3JBXG4JakwhjcklQYg1uSCmNwS1JhNhtkpZTSJsB/A17YzDom57xuyaqSJM1p0DPuvYEtcs4HAKcDE0tXkiSpl0GDez1ASimA7YG7l6wiSVJPUVVV3ys1QyXnAS8HtgD2zznf3rHMWmAtwMTERGv16tUDFTgzM8PY2NhA6y7G1NRUz/ZVq1axbt1wRodardbA6y6mv+Z7zb3MV/Oo3sf5WFd/rKs/i61rfHw8us0fNLgPBd6Uc35nSunlwB/mnN/SY5X+d9KYnp5mfHx80NUHFtG1v54wOTnJmjVrhrLvQd6TWYvpr/lecy/z1Tyq93E+1tUf6+rPEtTV9YdyMZ8qua/5dwP1cIkkaRkM9KkS4BvA21NKV1IPlZy0dCVJknoZKLhzzo8BRy5xLZKkBfAGHEkqjMEtSYUxuCWpMAa3JBXG4JakwhjcklQYg1uSCmNwS1JhDG5JKozBLUmFMbglqTAGtyQVZtBvByzCYr5fWpJWKs+4JakwBrckFcbglqTCGNySVBiDW5IKY3BLUmEMbkkqjMEtSYUxuCWpMAa3JBXG4JakwhjcklQYg1uSCmNwS1JhBv5a15TSQcApzTb+POc8uVRFSZLmNlBwp5S2BE4GDs05/3xpS5Ik9RJVVfW9UkrpYOAEYDvgQeB3c853diyzFlgLMDEx0Vq9evVABc7MzDA2NjbQulNTUwOttxCrVq1i3bp1Q9v+oPbaa6+R9Fer1erZvpj3cZisqz/W1Z/F1jU+Pt71r8EMGtxvBU4C9gcOAdbknE/osUr/O2lMT08zPj4+0LrD/As4k5OTrFmzZmjbH9T69etH0l/zHUeLeR+Hybr6Y139WYK6uv5QDnpxcgPw7WaY5FvAHoNWJUnqz6DBfR1PhvXLgH9dmnIkSfMZKLhzzvcAl6aUrgI+Cpy+pFVJkuY08McBc85nAmcuYS2SpAXwBhxJKozBLUmFMbglqTAGtyQVxuCWpMIY3JJUGINbkgpjcEtSYQxuSSqMwS1JhTG4JakwBrckFcbglqTCGNySVBiDW5IKY3BLUmEMbkkqjMEtSYUxuCWpMAa3JBXG4JakwhjcklQYg1uSCmNwS1JhDG5JKozBLUmFWVRwp5TemlK6e6mKkSTNb+DgTiltArwJuG3pypEkzWcxZ9xHAhcDjy9RLZKkBYiqqvpeKaW0KXAJ8Abgupxz6rLMWmAtwMTERGv16tUDFTgzM8PY2NhA605NTQ203kKsWrWKdevWDW37gxpVXa1Wq2f7Yt7HYRplXb2Oz/nex/n6e1h8H/uz2LrGx8eja0NVVX0/Wq3W0a1W6z8203kB6wxs/fr1A68LDO0xOTk51O2XVtcw38dhGmVdi3kfR8X3sT9LUFfXTB10qGQP4KiU0teA3VJKnxxwO5KkPm02yEo55/fNTqeUcs75xKUrSZLUy6I/x91tfFuSNDzegCNJhTG4JakwBrckFcbglqTCGNySVBiDW5IKY3BLUmEMbkkqjMEtSYUxuCWpMAa3JBXG4JakwhjcklQYg1uSCmNwS1JhDG5JKozBLUmFMbglqTAGtyQVxuCWpMIY3JJUGINbkgpjcEtSYQxuSSqMwS1JhTG4JakwBrckFWazQVZKKbWAM4DHgbuAt+WcZ5ayMElSd4OecU8Dr8s5vwq4EXjD0pUkSeolqqpa1AZSSh8Evp9zvqRj/lpgLcDExERr9erVA21/w4YNrFu3blE1DsOqVausqw/z1dVqtZaxmieVenyNqr9mZmYYGxsbyb57ebrWNT4+Hl0bqqoa+NFqtXZptVrXtFqtsXmWHdjk5GQFrLiHdS1tXaNif/Vn/fr1I9t3L0/jurpm6sAXJ1NK2wJfAN7h+LYkLZ+BgjultCnwReD0nPMNS1uSJKmXQc+4fwfYDzglpXRFSumIJaxJktTDQB8HzDlfAFywxLVIkhbAG3AkqTAGtyQVxuCWpMIY3JJUGINbkgpjcEtSYQxuSSqMwS1JhTG4JakwBrckFcbglqTCGNySVBiDWytCRIzkUapnYn/1qmtqampkfTKK/jK4JakwBrckFcbglqTCGNySVBiDW5IKY3BLUmEMbkkqjMEtSYUxuCWpMAa3JBXG4JakwhjcklQYg1uSCrPZoCumlD4O7APcCrwj5/zzJatKkjSngc64U0ovA56bcz4A+CHwpiWtSpI0p0GHSvYFvtFMfw3Yb2nKkSTNZ9Chku2B25vp+4Fndy6QUloLrG2eHp9zPmeQHR1++OFUVTVQkcNmXf2xrv6s1LpGZb7+eCb116DBfR+wbTO9PXBv5wJNUA8U1pKkuQ06VPIPwGub6dcB1yxNOZKk+QwU3Dnn7wF3pJSuBvYA/m5Jq5IkzSmeSeNCkvR04A04klQYg1uSCmNwS1JhBr7lfRjmuo0+pbQZ8FlgV+Afc87vWcaaWsAZwOPAXcDbcs4zTdtBwBeAdcBjOedDlrGuFwDfBf6pmfXmnPPdTdso++s/AB9rnj4XuCznfGLTdhDL3F8ppW2Ay4E9gX1yzj9IKR0BvAd4GDg653xbxzonUt8NfB/1+33/sOsCbgIuAbYEHqM+/m/uWOcnwFTz9N055/877Lqa/voXYLpZ5MM55292rDOK/rqBJ28C/AVg85zzyzrWWY7+2igfgDcy5ONrxZxxz3Mb/W8C003bViml5bxTcxp4Xc75VcCNwBs62i/MOR+0nKHd5spm3wfNhnZjZP2Vc75utibgauDLHYssd389BBwGXAyQUhoDTgIOAk5pHk9IKf0ydf+9ErgA+M/LURfwKHVYHwj8GfDeLuv8uO39XvIQmqMugPvb9tsZ2iPpr5zzz9uOs79g4+MMlqe/uuXD0I+vFRPc9L6NfmS32Oec78w5P9g8naH+AWv32ymlq1NKy3ZW22b/Zt8fSSlF2/yRfyVBc9a/D3V4t1vW/so5P9rxn9puwD81P/jXAC/pWOUVwBU554oh9l1nXTnnR3LOs2e13Y4zgFUppatSSmellLZcjroaW6eUrkwpnZ9S6rxLeiT91eHNwEVd5i9Hf3Xmw4tYhuNrJQX39sADzXTnbfS92pZFSmkX4DXAV9pmZ2B34BDg9c2vTcvlDuqhkAOBXwF+q61t5P0FHEz9G8HjbfNG2V+z2vsGYNMe7cved81vBKcCn+7SvGtzRn4H8K5lLGv/5ozya8BpHW2j7q9tgJ1zzj/s0rxs/dWWD99mGY6vlTTG3es2+nlvsR+mlNK21GOz75gd3wbIOf+0bZlLgZfy5JjaUOWcHwEeafb9d9Rn2V9qmkfaX403A19snzHK/mrT3jdQjyd3tu/aTI+i784Bzs45r+tsyDnf00xeBLx/uQrq2O9xHc2j7q/DgUu7NSxXf7XnA3VQD/34Wkln3L1uox/ZLfYppU2pA+j0nPMNHW3tb9AB1GNcy1XXNm1PD+zY90i/kqAZJtkXuKpj/sj6q82NwB4ppc1TSvsD13e0Z+rxSVj+Y+0DwE055wu7tD2rORZh4/d7mDVtnlLaosd+R9Zfja7DJMvVX13yYVmOrxV152Tnp0qAv8g5H98EwV8Dq4Dv5Zx/bxlreivwGWD24sZZwMFNXcdRfwPio8A1OeduF5SGVdehwIeAB6k/kXAscOao+6upbTXwWznndzXP/2qU/ZVSugzYG7iF+v17BPh96qv+R+Wcb0sp/RH1hdObluNTEnPU9Tc8+YN8bc75/bN1AdsB5wI/beo6apnqOhv4PeBn1P127Arqr0uoh+Ne3rbMsvbXHPkAQz6+VlRwS5Lmt5KGSiRJC2BwS1JhDG5JKozBLUmFMbglqTAGtyQVxuCWpML8fwcq/Mglfr8pAAAAAElFTkSuQmCC\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=69.0), HTML(value='')))", + "application/vnd.jupyter.widget-view+json": { + "version_major": 2, + "version_minor": 0, + "model_id": "116a71b79758458bb4e6cb19c10c3b12" + } + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", "text": [ "\n" ] @@ -507,15 +585,24 @@ "source": [ "best_theta_model = Theta(best_theta)\n", "\n", - "historical_fcast_theta = best_theta_model.backtest(series, start=pd.Timestamp('19550101'), \n", - " forecast_horizon=3, verbose=True)" + "average_error = best_theta_model.backtest(series, start=pd.Timestamp('19550101'), forecast_horizon=3, verbose=True)\n", + "median_error = best_theta_model.backtest(series, start=pd.Timestamp('19550101'), forecast_horizon=3, reduction=np.median, verbose=True)\n", + "print(\"Average error (MAPE) over all historical forecasts: {}\".format(average_error))\n", + "print(\"Median error (MAPE) over all historical forecasts: {}\".format(median_error))\n", + "\n", + "raw_errors = best_theta_model.backtest(series, start=pd.Timestamp('19550101'), forecast_horizon=3, reduction=None, verbose=True)\n", + "plt.hist(raw_errors, bins=np.arange(0, max(raw_errors), 1))\n", + "plt.title(\"Individual error scores (histogram)\")\n", + "plt.show()\n", + "\n", + "historical_fcast_theta = best_theta_model.historical_forecasts(series, start=pd.Timestamp('19550101'), forecast_horizon=3, verbose=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Let's see what this backtest forecast looks like. You can see it produces more accurate predictions than the one-off prediction done above, because here the model is re-fit every month." + "Let's see what this backtest forecast looks like. You can see it produces more accurate predictions at a 3 months horizon than the one-off prediction done above, because here the model is re-fit every month." ] }, { @@ -524,14 +611,15 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -554,14 +642,15 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -585,62 +674,52 @@ }, "outputs": [ { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=69.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "2f017fb60a4c4bab91dd228f32b255b1", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=70.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "b8ac13be305e4e958356c31f6e0618ea" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "\n" ] }, { + "output_type": "display_data", "data": { - "text/plain": [ - "" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXMAAAEVCAYAAAASFwXVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd3zUVbr/399JMum995BKeoChCCggNgQ7rvqTFdRVLuuqV9d2vWLb4l51F+Xu7nX12nZFF+W6tsUOKDZ0kN6SkD6Z1EmvM5nz++M7GRIySSbJRCF73q/XvGC+53xPmZl85sxznvM8ihACiUQikZzeaH7sAUgkEolk4kgxl0gkkimAFHOJRCKZAkgxl0gkkimAFHOJRCKZAkgxl0gkkimAFHOJRCKZAkgxl/wgKIpSpihKr6IoYSdd36soilAUJemk6w/brs856foaRVH6FEVpVxSl1Xb/ClvZYkVRrLaygY8zJmlOi2xj/PUIdRRFUf5LUZRG2+NxRVGUAeUFiqLsVBSlRVGUKkVRHhxQlq8oyiFFURoURbljwHUPRVF2KYoSPxnzkpyeSDGX/JCUAtf0P1EUJRfwPrmSTex+CpiA1Q7a+VoI4QcEAc8DryuKEmIrqxZC+J30+NrVE1EUxQN4Gtg1StWbgUuBfCAPWAGsHVD+KvA5EAIsAtYpinKxrewx4C7bvQ8oihJlu34n8H9CiEoXTEUyRZBiLvkh+Rtw3YDnq4G/Oqh3JhAD3A5crSiK1lFjQggr8ALqF0Kya4c6Kr8EPgKOjlJvNfB7IUSVEMIA/B5YM6A8CdgkhOgTQhwHvgCybWXTgG22+4qABEVREoArgA2umohkaiDFXPJD8g0QoChKpqIobsBVwCsO6q0G3gU2256vcNSYoijuwM+AdlSxGxOKorynKErzMI/3RrgvEbgBeNSJbrKBfQOe7+OEWAM8BVxnM51kAGcAn9jKDgLnKYoShyr6x4GNwD1CCLOT05T8i+D+Yw9A8i9H/+r8M9RVrWFgoaIoPsCVwHVCCLOiKFtQxf3NAdXmKYrSDFiAYuAyIUSLzRQdYysbSKwQouPkgQghHH5JOMFGYL0Qon2A+Xs4/ICWAc9bAD9FURShBkZ6D/XXyV2AG/CoEOI7W927gP8BooA7gAVAG1CiKMrbqGamPwoh3hjnPCRTCCnmkh+av6HaiKfh2MRyGapIb7U93wR8oihKuBCi3nbtGyHEwmHarxZCxLlywANRFOUiwF8IsXnUyirtQMCA5wFAuxBC2Oz8HwC/QLWdRwFbFEWpFUL8WQhRDlxo69cH+Ao4H/hv1F8t/wQOKoryqRDC5ILpSU5jpJlF8oNiE6hSVJF600GV1air2QpFUWqANwAPBmycugpFUd534PnS/3h/mNuWAjpFUWps47sK+HfbStkRh1A3MPvJt10D1c7fJ4T4qxDCIoSoAv6OTcBP4kHgf4UQtUAuoBdCtABVQOpY5i2ZmsiVueTH4EYgWAjRYbN7A6AoSiyqWC4D9g+o/++oIr/RlYMQQiwbx23rgd8NeP40UA38apj6fwXuVBRlKyBQN07/21ZWiOq88/9QRTwC9cth28AGFEXJAhajmllA/TI8W1GUFiANqBjHPCRTDLkyl/zgCCGOCyH0Dop+CuwVQnwkhKjpf6CKeJ6iKDlONB/jYJV9hQvH3nbS2LqAjn4zh6IoZyqK0j7glr+gbuYeQN3Q/KftGkKIVuByVHt4E7DXVuc3J3X7J+B2IUSf7fl/ALehrvB/axuH5F8cRSankEgkktMfuTKXSCSSKYAUc4lEIpkCSDGXSCSSKYAUc4lEIpkC/GhiXlNTI1BdtabkQ87v9H9M9TnK+Z22D4f8aGLe19c3eqXTGDm/05+pPkc5v6mFNLNIJBLJFECKuUQikUwBpJhLJBLJFECKuUQikUwBpJhLJBLJFECKuUQikUwBpJhLJBLJFECKuUQikfxIlJaWcvjwYZe0JcV8BB5++GGefPLJYcvfeustl70REonkX49HH32UK664AleEIpdiPgGkmEskkonQ0NDA0aNH+eabbybclhTzk/jNb35DRkYG55xzDseOHQPgueeeY/bs2eTn53PFFVfQ2dnJV199xTvvvMPdd99NQUEBx48fH1TvpptuorOz80eejUQiOZUxmdQ83C+88MKE2/rRMg0ZDAYRGxs7bHlvby9lZWUu7zcpKQmtVuuwbPfu3axZs4Zdu3ZhsViYOXMm//Zv/8b1119PaGgoAA888ACRkZHceuutrFmzhhUrVrBy5UoAGhsb7fVuv/12UlNTufXWW10+h1MBg8HASO/fVGCqz1HO78cnMzMTs9lMbW0tNTU1+Pr6OnOb4ujiKZvQuaysjIyMDJe3e+zYMdLT0x2W7dy5k8suuwwfHx8ALr74YgAOHjzIAw88QHNzM+3t7Zx//vkO7x9Yr6WlhQsvdJRkXSKRSFRMJhN3330369evZ8uWLaxevXrcbZ2yYp6UlGQ3c7i63ZFQlKFfemvWrOGtt94iPz+fl156iR07dji8d2C9DRs2sG/fPheMWCKRTEWEEJhMJpKTk7niiit44YUXJl/MdTrdYmC9rf4fAC/gdqAbWK3X6yt1Ol0WatZxd2C9Xq//ZNyjArRa7bAr6MnirLPOYs2aNdx3331YLBbeffdd1q5dS1tbG9HR0ZjNZjZt2mT/6ebv709bW5v9/oH1/vGPf5CcnPyDjl8ikZw+tLe3Y7FYCAkJ4eqrr+aiiy6io6PDWVPLEEYVc51O5wX8Elim1+t7dTqdB/AFcCYwG1XkbwZ+C9wA1AIfABMS8x+DmTNnctVVV1FQUEBiYiJnnnkmAL/61a+YO3cuiYmJ5Obm2gX86quv5qabbmLjxo1s2bJlUL2UlBSXuBtJJJKpSf/mZ0hICL2EQNw9mExN4xbzUTdAdTrd2cC/AYFAJ/AE8DO9Xn+DrfxrvV5/hk6n26XX6+farr0LXK/X6xuGa3e0DdDTndNh82UiTPX5wdSfo5zfj8uePXuYOXMmFRWVrPpdEJ8f8OGLJ4+yYE7WaLeOewM0EpgGLACWAg8DA52r3Rx00AKEAIPEXKfT3Yy6imft2rVTeoPQbDZjMBh+7GFMGlN9fjD15yjn9+NSWFgIwEsfevD5AdXp4sDhSpJiA0e8b7gvKGfEvBn4wmZi2Qb8FagaUN6fm8k64FoQYDq5Ib1e/yzwLMiV+enOVJ8fTP05yvn9uGg0GrQB0/mvN8K54ULBC1sVui3e4x6zM2L+LfDvtv/PAD4CsnQ6nRbVZr7fVlaj0+nSUG3mISOZWCQSieRfHZPJhHvSvUyLgidv0fDCVkFtY8+42xtVzPV6faNOp3tHp9N9jrr6vgFVxD9D9Wa5zlb1fuAFW5sPjntEEolE8i9AY2Mjbt5zmZ0JQX6AsFDfZB53e065Jur1+j8BfxpwqQTYfFKdw6geLhKJRCIZBZPJhKINIyxQPd/iJtpobO4b/cZhkLFZJBKJ5EfAZDLRpwkhLFD1HfHQdNDUNn53ZinmAygrKyMnJ2fC7ezYscPhSa4dO3bw1VdfjavNsrIyXn31VYdl5eXlzJo1i4KCArKzs3nmmWfG1cd4OXlsL730Er/4xS9c2sdo4YjHy44dO1ixYoXDsltuuYW8vDw2bNjg8n7Hw1NPPTVi8LaVK1dSUlICqCedc3NzKSgooKCggNtuu82lY7Fardx2223k5OSQm5vL7NmzKS0tdWkfA9m7dy9bt261Px/p8zB//vxx9/Pee+/x0EMPjfv+sWAymbAQQJjNecXTrYuWjvG3J8X8B2SyxDw6OpqvvvqKvXv3smvXLn73u99RXV09kaG6bGynKzU1Nej1evbv388dd9zh1D0Wi2VSxzSSmB86dIi+vr5Bp463b9/O3r172bt3Lxs3bnTpWDZv3kx1dTX79+/nwIED/OMf/yAoKMilfQzkZDEfifH+jQEsX76cd9555weJeNpoaqbH6msXc2+PHlq7xh9hRYr5SVgsFlavXk1eXh4rV660v6mPPvoos2fPJicnh5tvvtl+urO4uJhzzjmH/Px8Zs6cyfHjxwe199133zFjxgxKSkp45pln2LBhAwUFBezcuZP6+nquuOIKZs+ezezZs/nyyy8B+Oyzz+wrqhkzZtDW1sZ9993Hzp07KSgoGLJS1Gq1eHp6AtDT04PVasURO3bsYNGiRfzkJz8hPT2d++67j02bNjFnzhxyc3PtYy8vL2fp0qXk5eWxdOlSKioqADX2zG233cb8+fOZP38+W7ZsAXA4turqai644ALS0tK45557AOjr62PNmjX21ZyjFe+7777L3LlzmTFjBueccw61tbX2ssOHD7N48WKSk5MHidMrr7zCnDlzKCgoYO3atfT1qXbHdevWodPpyM7OHrTa+uCDD5g+fToLFy7kzTffdPhanXfeeTQ0NNjfq7179zJv3jzy8vK47LLLaGpqAmDx4sXcf//9LFq0iKeffprdu3ezaNEiZs2axfnnn4/RaBz2c9Le3s7SpUuZOXMmubm5vP322wB0dHSwfPly8vPzycnJYfPmzWzcuJHq6mqWLFnCkiVLhox306ZNXHLJJQ7n0o/FYmH27Nn22EKPPfYY//mf/wmoK/l7772XOXPmMGfOHIqLi0dsy2g0Eh0djUajSkhcXBzBwcEA+Pn5ce+99zJr1izOOeccvv32W/v79s477wDQ3d3N9ddfT25uLjNmzGD79u3DXu/t7eXBBx9k8+bNFBQUsHmzul033OfBz88PUEV98eLFrFy5kunTp3Pttdfa/263bt1q/wzcdttt9l9niqKwePFi3nvvvRHn7wrqmyyAhlCbmPt5mens8Rh/g0KIH+VRVVUlRqKn1yqOVbj+0dNrHbbP0tJSAYgvvvhCCCHE9ddfL5544gkhhBCNjY32eqtWrRLvvPOOEEKIOXPmiDfffFMIIURXV5fo6OgQ27dvF0uXLhVffvmlmDlzpigvLxdCCPHQQw/Z2xNCiGuuuUbs3LlTCCFEeXm5mD59uhBCiBUrVtjH0NbWJsxms9i+fbtYvnz5sGOvqKgQubm5wtvbW/zxj390WGf79u0iMDBQVFdXi+7ubhETEyMefPBBIYQQTz31lLj99tvt/b/00ktCCCGef/55cckllwghhFi9erVYuXKl6OvrE9u2bRMpKSn2dgeO7cUXXxTTpk0Tzc3NoqurSyQkJIiKigqh1+vFOeecY6/X1NQ0ZIwmk0lYrep79Nxzz4k777zT/tqdccYZoru7W9TX14uQkBDR29srDh8+LFasWCF6e3uFEEKsW7dOvPzyy0KIE++ZxWIRixYtEvv27RNdXV0iLi5OFBYWCqvVKq688kqHr2tpaanIyMiwP8/NzRU7duwQQgixfv16+2u1aNEisW7dOiGEEL29veKMM84QdXV1Qggh/v73v4vrr79eCOH4c2I2m0VLS4sQQoj6+nqRkpIirFar2LJli/jZz35m77u5uVkIIURiYqKor68f+sYKIc466yyxf/9++/PExESRk5Mj8vPzRX5+vvjDH/4ghBDi4MGDYvr06eKjjz4S2dnZoqenx17/17/+tRBCiJdffnnEz5oQQlRWVorExESRn58v7rzzTvH999/bywCxdetWIYQQl156qTj33HNFb2+v2Lt3r8jPzxdCCPHkk0+KNWvWCCGEOHLkiIiPjxddXV3DXn/xxRfFLbfcYu9juM+DEEL4+voKIYR4/fXXRUBAgKisrBR9fX1i3rx5YufOnfbPQElJiRBCiKuvvnrQfF955RXxi1/8YsT5u4LwhIWCM/vE0XL18z7jJ9+KgPmfOXOrQ009ZaMmltVAxrWuj21ybJNCevzw5fHx8SxYsACAVatWsXHjRu666y62b9/O448/TmdnJyaTiezsbBYvXozBYOCyyy4DwMvLy95OcXExN998Mx999BExMTEO+/rkk08GZSpqbW2lra2NBQsWcOedd3Lttddy+eWXExcXN+q84uPj2b9/P9XV1Vx66aWsXLmSyMjIIfVmz55NdHQ0ACkpKZx33nkA5Obm2ldHX3/9tX3F+tOf/tS+sga49NJL0Wg0pKenD1o1n8zSpUsJDFSXHFlZWZSXl5OdnU1JSQm33nory5cvt/c9kKqqKq666iqMRiO9vb1MmzbNXrZ8+XI8PT3x9PQkIiKC2tpaPv30U3bv3s3s2bMB6OrqIiIiAoDXX3+dZ599FovFgtFo5PDhw1itVqZNm0ZaWhqgvsfPPvvsiK9tS0sLzc3NLFq0CIDVq1dz5ZVX2suvuuoqQA2vfPDgQc4991xA/SUSHR1NW1ubw8+J2Wzm/vvv5/PPP0ej0WAwGKitrSU3N5e77rqLe++9lxUrVthjBI2E0WgkPDx80LXt27cTFhY26Fp2djY//elPueiii3j77bcHxfa/5ppr7P+OZlqKi4vj2LFjbNu2jW3btrF06VLeeOMNli5dilar5YILLgDUz5WnpyceHh7k5ubacxR88cUX9lj/06dPJzExkcLCwmGvO8LR5+Hkv5U5c+bYrxUUFFBWVoafnx/Jycn2z9Y111wz6DMQEREx6WZKIQTNHar89ptZAn0FvX3e427zlBXzpChVeCej3ZE4OQSuoih0d3fz85//HL1eT3x8PA8//DDd3d0jBtKKiIjAarWyZ8+eYcXcarXy9ddf4+09+A287777WL58OVu3bmXevHl88onzMctiYmLIzs5m586dxMfHs3btWkA1EwUEBNjNMaCeQOt/rtFohrX5DnxNBt4/0vwH1nNzc8NisRAcHMy+ffv48MMP+dOf/sTrr78+JMPKrbfeyp133snFF1/Mjh07ePjhh0dsUwjB6tWreeyxxwa1U1paypNPPsl3331HcHAwa9asobu7e8h8XEF/YCQhBNnZ2Xz99deDyltbWx3et2nTJurr69m9ezceHh4kJSXR3d1Neno6u3fvZuvWrfzHf/wH5513Hg8+OPLRDW9vb/v8RuPAgQMEBQVRX18/6PrA18WZ18jT05Nly5axbNkyIiMjeeutt1i6dCkeHh72+4f7jA332RnpM+Wo/376Pw/O1Bmtj+7u7iF/k66mq6sLswhAowiC/NTXKiRAwWwdX5AtOIVt5loPhfR41z+0HiN/SCsqKux/jK+99hoLFy60/5GEhYXR3t5utxUHBAQQFxfHW2+9Baj26n4be0BAAP/85z+5//777TbKk0Pmnnfeefzxj3+0P9+7dy8Ax48fJzc3l3vvvRedTsfRo0eH3DuQqqoqurq6AGhqauLLL78kIyODuXPn2jfA+hNtOMP8+fP5+9//DqiCs3DhwhHrjzS2gTQ0NGC1Wrniiiv41a9+xffffz+kTktLi/0488svvzxqm0uXLmXLli3U1dUBqodAeXk5ra2t+Pr6EhgYSG1tLe+//z6grvZKS0vt+wOvvfbaqH0EBgYSHBzMzp07Afjb3/5mX6UPJCMjg/r6evvnx2w2c+jQoWE/Jy0tLURERODh4cH27dspLy8H1P0GHx8fVq1axV133WV/nUZ6nTMzM0e1cwO8+eabNDY28vnnn/Pggw/S3NxsL+u3RW/evJkzzjhjxHa+//57++rVarWyf/9+EhMTR+2/n7POOotNmzYBaoySiooKMjIyhr3u7GfMGaZPn05JSYn9V0L/vPspLCx0iVfbSJhMJvAII8CnDzc3VZNCA93o0wSMO9rqKSvmPxaZmZm8/PLL5OXlYTKZWLduHUFBQdx0003k5uZy6aWX2n/Sg/qHvXHjRvLy8pg/fz41NTX2ssjISN59911uueUWdu3axUUXXcQ//vEP+6baxo0b0ev15OXlkZWVZXcpfOqpp8jJySE/Px9vb2+WLVtGXl4e7u7u9sQXAzly5Ahz584lPz+fRYsWcdddd5Gbmzvu12Djxo28+OKL5OXl8be//Y2nn356xPojjW0gBoOBxYsXU1BQwJo1a4aspkF1Obvyyis588wzh5gIHJGVlcWvf/1rzjvvPPLy8jj33HMxGo3k5+czY8YMsrOzueGGG+ymMy8vL5599lmWL1/OwoULnRagl19+mbvvvpu8vDz27t3rcKWs1WrZsmUL9957L/n5+RQUFNg9Kxx9Tq699lr0ej06nY5NmzYxffp0QF0592/o/uY3v+GBBx4A4Oabb2bZsmUON0CXL18+JGnKkiVL7Bvp1113HQ0NDdx33308//zzpKens2bNGm6//XZ7/Z6eHubOncvTTz9tfx/feecdh3Otq6vjoosuIicnx/7+j8Ud9ec//zl9fX3k5uZy1VVX8dJLL+Hp6Tns9SVLlnD48OFBG6Djxdvbmz//+c9ccMEFLFy4kMjISLtJEFTz1PLlyyfUx2ioYh5KSMAJ4Y4I0YJbEB0d4/RPHM6YPtmP0TZAT3fk/E5/Tqc5dnZ2irlz5wqLxeL0PQPnN9Lm6unKSO9fW1ubEEIIq9Uq1q1bZ98grqmpEWeffbbo6OgQ33zzzaSNbfv27YJp/yXmre21X/vvVwoFZ/aJ4pLK0W53qKlyZS6RTAG8vb155JFHTumQr6cSzz33nP2QXUtLi31vqaKigt///vfcc889DjfoXYXJZELxCCMyxM1+LTpcDYNbaRyfOemU3QCVSCRjY7hE487Qbz/+V+GOO+5w6LEze/Zsjh49yjPPPENfXx9msxkPjwn4fg+DyWTCwyfW7skCEBetbn5W147PzCJX5hKJRDKAe++9F39/f4BBG8SuxGQyofGKGCzmkephp+p657ySTkaKuUQikdjYsWMH77zzDr/73e+AyRVz3MPsQbYAwoJUk0vdOGOaSzGXSCQSG08//TTLli2zh0aYTDHvU4LsR/kBPLUKirVr3DHNpZhLJBKJDYPBwIwZM+xBw/pj8LiahsZmzPgOMrMAuNFGY4vj2EqjIcVcIpFIbNTX1xMeHk6X2ROP8AsnbWVeZzIDmiFirp1ATHMp5hKJRGKjoaGBsLBwrn1UYEl/bdLEvKFF/fdkMfd066alY3yyLMVcIpFIUGOytLe382XZDN7fBULjR0Njy6T01dSmSm/YSSHgfbS9tHW5ObhjdKSYSyQSCaqJBZ8cXtiWzmW2QJW1jeNzExwJYYuYqChWAk+Kq+XnZaazd3x+7VLMJRKJBNXEQuIjzEg188gNqstgfVOvy/tpbW2l1+pPoI8FjWZw4D9/bytdZq9h7hwZKeYSiUSCbWXuncL5c90IVs8M0TBON8GRMBqN4BFKaMDQjc4gP0Fvn8+42pViLpFIJNjE3DOe5BgPgtTDmOP2LBkJVczDiAgZahsPCdBgFuOLaS7FXCKRSIAqYwu4BxEfAb7eoNBHc7vrxbympgY3r0iiQoaGxgoNcsc6zpjmUswlEokEKDGoJpWESDXTkpdHL22drs92ZjQa8fSNGXT6s5/IEA9wD6K9fezBtqSYSyQSCVCpJqsizpZK1dfTQkeP6yMmGo1G3E4KstVPZJgXKO4YasbuEinFXCKRSICaJg+8NK14eaqrcT+vPjp7PMadxm04jEYjwj10UJCtfmIj1c3PqnHENJdiLpFIJEBDuw+BXidWxIG+AqvG355f11UYjUZ6RZBDM0tclLrzWjWOmOZSzCUSiQRo6Q4g1P+EcAf5K+AW6PIj/VU1HfRavUmKGloWH636RBrHEdNcirlEIpEAXX2hRAVb7M9DAtzAPdDlkROrm7wBSI0dWhYSoAFhpXYcMc1HTRun0+mSgO+AQ7ZLVwJnA7cD3cBqvV5fqdPpsoC/2Npcr9frPxnzaCQSicQBO3bsYPv27TzyyCOT0n5fXx9mTRQJESdOfIaHaMHdtSvzrq4u2i2RaN37iAkbKr8ajYJGtFFpbB9z286uzD/T6/WL9Xr9YqAZuBNYDKy3PQB+C9wAnA88OuaRSCQSiQOEENxzzz28+OKLk9ZHY6MJPOOZFqu1XwsP1rrczFJTUwNeKcSHm4cc5e/H172JMmPfmNt2VswX6HS6nTqd7rdAOnBIr9f36vX6L4FcW51ovV5fpNfrW4FGnU4XNubRSCQSyUl88803fPfdd7S0TE4EQ4DC0ibQeJGR5G2/FhKgQdGGuNTMYjQawTuVtLjh/ddD/dqoNnmOue1RzSyAEUgFOoHngEuA1gHl/WdSB46uBQgBGgY2pNPpbgZuBli7di0XXnjhmAd8umA2mzEYDD/2MCaNqT4/mPpzPF3m99hjj+Hp6UlraysVFRW4uTkXInYs8/tqdyWQSph/l/0eq9kbxT2QsrIyl71OBw8eBO9MEsJ7MRhMDutEBHSyrzZg2D5jYx0Y23FCzPV6fQ/QA6DT6f4P1ZQy0Amy//fAwFxHQcCQker1+meBZwEMBoMYblBTAYPBMOyLPhWY6vODqT/H02F+FRUVbN26lVtvvZWnnnqKgIAAe0q30RjL/BrbK0BYWDQvDXd31WCRFCcQml6EGF5Ax0pvby8anzRmZAYQG+vANxHISmnk22IfIiIi8PBw/tDSqGYWnU7nP+DpWcB7QJZOp9PqdLoFwH5bWY1Op0vT6XQBQIher284uS2JRCIZC3/84x+Jj49n9erVwOQlWC4z9qGx1NqFHCDID4TiQX3j2Dcjh+2nshGre4RDT5Z+ctMCQBtPaVnlmNp2xsyyUKfT/RrVzFKKuuHZDXxm+/c6W737gRdsbT44plFIJBKJA/75z39y3XXXERISAkyemBsaNHgpdUC8/Vp/4ghXxjQvqlINGCOJ+ezccNB4oN9vID0t2em2nTGzvA+8f9LlzbbHwHqHgTOd7lkikUhGoaqqipSUFLtpZbI2QetbPfHzGLzR2R8Gt8GFYl5R54EGC/ERw5tPclJ9AMGeI838vzG0LQ8NSSSSU5LW1lZaW1uJi4vDz88PRVEmbWVu6vAj2GewOSXQJuYmF8Y0r2nxI9inGTe34b1ZgvzATbRzpHRsp0ClmEskklOSfm+OuLg4NBoNgYGBk7Yyb+sNIiJg8KnLfjNLiwtjmjd3hxIT1DliHUVR8PNopKxmbP1KMZdIJKckVVVVwAlPksBA18dJAbBYBD0ihJiwwQd1PLUKHhoLrR2ukUmLxUK3EkdSlGXUuuEBndQ2j43sngMAACAASURBVC0XqBRziURySlJVVUVwcDC+vuoSOSgoaFJW5g0tgOJGfORQO7aPp5n2buf82kejrq4OvFLISBzd7yQhvI+W7uAxtS/FXCKRnJJUVVUREzcNq1U1N0zWyryuSW0/IXroStjPu48usxar1TqkbKyUlteAZxx56aPn+MxI1GJ2i6G93Xm3SCnmEonklKSqqorqkJe4ZYMqtpO1Mq+oUcPeJscPPcQT4CPALZDW1tYhZWPl/e3HANBlj37oKS8jEDzjKSoudbp9KeYSiWTMVFdXq0GjJpHyylqardN55m3YtlsQFBQ0KSvzYyWNYO0mPSVmSFmQn+KSyIltbW3894tf4K6YSY0b3cwyKycMFHe+2290ug8p5hKJxGm2bNnC/PnziY2N5dprr53Uvo7X+CJwY8kMuOkJgY9/2KSI+fGKVjA3EB8fN6QsJFAD7hP/Enn88cfp9r2A8+aAh/voSaLTbIK//5jzv0SkmEskEqcQQnD99dcTHh7OddddR3l5+aT2V90WS4BXF5sfUWjpgH1Nl06OmcXYibtoxstrqM08LEgNgzueyInHKgR9fYKqqiqe3PA/iODzuGqpdvQbUbMcudHOsTLnk1RIMZdIJE5RW1tLe3s79913H+eff76amNjFyY776ezspFOTSWZ8B+FBCndfrXCkIXdSVubGBgs+Wsc5N8OC3dFog6mtrR1Tm1arYMaNgsdegSeeeILg5KsRuHPRAufbCNSaKK8bfRXfjzOxWSQSiYSioiIA0tLS6O7uprOzk7a2NgICAlzel8FgAD8dugz1eXIMtPf44j4JK/PGFgj0MTssC/JVcPcKo6pq19jabIWuHvivVwVZnSUEJj9EbopCsL/z4hzm305jnfOvrVyZSyQSpyguLiYwMJDQ0FCio6MBW7KFSaDwuBF8Mlk0Sz1THxUCFqsbzW24/NdAc6cHYQGO2wz0A8UjiMrKsUUwrGlU/9Vo4EDLlZS1ZXP5Wc4LOUB0cC/t5nCn60sxl0gkTlFUVERaWhqKoky6mH+1vwsUDYtmqpl/ItWgiViUULq7x565fiQ6e32JCnMc+CrID6yKv/00qrPU2LI5PLKmm66gVfSYtVyycGzjSoqy0quJcfrLS4q5RCJxiuLiYlJTUwEICAjA29t70sR8T7EbHn3VRASrq9kom5ijjXKp3dxisWAmgIRob4flgb5gFl5UVo0t01CNCQJ8YUHyEWjfy+yMXqJCx7YyT4v3QHjEYGp2bM8/GSnmEonEKfpX5qAGg4qKipo0MS8yBhLsUWJ/7u8DXloraKNc6tFSXW0E9zBSEhzbptUwuBoqq8f2BVJjUr+Ajh8vwrN4Ja//auw5PXNSvUHRsOdwo1P1pZhLJJJREUJQXFxMfGKG/Wd/dHT0pIl5dVss8cEnPEgURSEiSIBHpEtX5ocLDaDRkp4c6rC8PwxuTUM3ZrPjTVJH1DQKokKgsLCQ1AQfEqPGLrUFmWpslgNFcmUukUhcRL9b4iPvXcaTf1evTZaYm1oFndYoMuMGi1hMmOLylfmR4noAUodZmfeHwUUTMKYTr0bbyryoqIj09PRxjS0uOgR6jRwrdy45hhRziUQyKsXFxeAehKHRi99tErR1CqKjoyflSH+xba8xL3XwpmR0qAY371iXrswLS9XDQOFBju3Z/dmGcA8c0yZoTeMJMe83TY0VNzc33PuqKHXy+1KKuUQiGZWioiJ8w+cA0GOGP705eSvzkmozWM1kpoYMuh4VCm7eMS4V83JDO2AldBh37gBf0HqAm0/82MTcBFGhCoWFheNemQP4auowNDp3alSKuUQiGZWioiLCEs4kNBDuuUbhyc2C4LD4SRHzQ8Wt0GsgIX5w1uOoEAXFM9qlZhZDXS+ebp3DpnHTaBRSYyEgYuaYxdzfs52mpqZxr8wBgr2bqGsdPWQuSDGXSCROUFxcjGfwDLIS4bYrwNIHesNsmpqaXO73fbyqF3oqiYqKGnQ9KgSsbuEuXZnXNVnx9xx5/Onx4BGY7bSY9/QKmtrA3KnWn4iYRwR00Nx94hdKfn7+sHWlmEskklEpKirCok0jK0kNAnX9Mth1XI0y6Gq7eUWtFXqqCA0d7GESGQxmJYim5onHFu/H1O5GiH/fiHXS46BPm+y0mNfaYnK1m4rx8/Mb8qU0FuLCzJiFL01tgu7ubg4cODBsXSnmEolkRPrdEpt7o8lKUs0R2dMUjE1qlEFXm1qMJne8NQ24uQ1O1xYVCuBGrWniWX8AWlpa6LUGEBEyclq49HiFDmus02Lef5TfVHPYfmJ2vCTHqPeWVsPx48dHPA0qA21JJJIRqa2tpb1LgQ5fspLUa8nRYGrT4OYZ4nIxb2j1JtC7bcj1/lOg9S2uyclZUVEB7mHERox8oCc9HrotPpRXO5fCrcakxmSpKt0zIRMLQFqCD4heSo2euDUXDfmCG4hcmUskkhEpKSkBn0yAE2JuS8oTEjPLpWJusQjaenwJ8+8aUhZpy29sanMcR2WsVFRUgDacxBifEeulx6v/1jT709c3skkGVDEPD4LjxRPzZAGIigqH7nKKDVYKCwtJSkoatq4Uc4lEMiJGoxGNXy6BvhBtM2PHR4C7GwSE57tUzKsbQaAhOsQypMzLU8HLvZuWLsdxVMbKkSNHcPOKIip0ZANFRDD4evXRp02hrq7OYZ2Ojg46OzsBm1ti8MR8zO19R0RAdxlHy7pHPYAkxVwikYxITU0NPmGzyErCbv91c1NIigJtYKZLxbzSppXxEY7tzIE+XbT1jLySdpbt27ej0YYTPkp+ZUVRSI2xgneaQ7u5EIKLL76Ym266CYAak8Dfs4P29nZmzpw5oTGqYl5CUWXfqF8OUswlktOYhx56SD2dOYnU1tai8cshe9rg68kxgNc0l4u5IrpJiHYs2CF+vXRZJp4Mw2w289nObzAL71HFHCBrmjuKb4ZDMd+2bRvbjuXxzvepCCGoaQRrjxF/f38yMzMnNE5VzEspq9GMegBJirlEcprS0NDAo48+yqWXXkpHh3PBmMZDTU0NZo9UuydLP8kx0KPEulzMNWYjkZERDsvDA/swE4rFMtQMMxZ2795NR4/qjRMWOHr9jAQN7v5ZQ5JUCCF4YP16PBLvoD3oFo4eO47RBB1NxcyZM2fEDUtn8PX1RWs1UNvsidFYK1fmEslU5OjRo4Bq0163bt2k5eM01LTQJSLtm5/9JMcotJnDXepnXlErsHaVqStSB0SGANpIWlsn5mu+fft2YpIKAJxamafHQ5/HNCorB8c1/+CDD/hmTx1mtzjwCOMvr5dR0wh1hgOcccYZExojqCaeUJ9GQrQl4B7gGjHX6XTX6HS6etv/r9LpdF/pdLptOp0u3nYtS6fT7dTpdF/rdLpzJjwLiUQyIkePHiUoIps33tjCpk2beOmllyaln7I6dQWbmTj4enI0mDr9qa1rdMrLwxlKDL2I7sphxTw23G1ckRM7OztJT09n586dgGoayZ2xBHBuZZ4eD1bFiyOlg10mH3roIWYsvZdgfwjR7OHtbwKoMQmM5XuYN2/emMY4HHHBJgLLLkKr6SQhIWHYek6JuU6n0wArgUqdTucB3AksBtbbHgC/BW4AzgceHf/QJRKJMxw4VEhr+i7qxWJWrVrFG2+8MSn91LV4o1H6iDspHWVKLPRZNQiPmDFnr29pF1z1kBVT6+BfE+U1VuipJDzcce7LhCgv8IiioaFhTP1VVlZSVFTE2rVraW9v58svvyR5+lx8vMDHa/RDPWnqYVeKBlhZTCYT3333HT4xF7N0FizJqqCsLY/uXgV6a5g7d+6YxjgcERERFBUVkZKS4hI/8/8HbAGsQBpwSK/X9+r1+i+BXFudaL1eX6TX61uBRp1OFzaB8UskklHYc6QVq+LNe18Lpk+fTllZmcv7EELQ3OVHiF83Gs1g0ZsWbfuPVzIGw9jSqu0pgte3wzNvD75ubNRAT9WwK/OMaYHgEcyxovIx9ddvCiorK+Oaa66hq6uLDk0BucnO3R/gqxDg1Ull4wm3SHXj2Y395aGcN1vhhktCwKrGHk+I8iQszDUSGBkZCTCqz/qoJ0B1Op0b8BPgUuCXQBAw0GDV/1Ux8J1uAUKAQV+fOp3uZuBmgLVr13LhhReO1v1pi9lsHvMH/HRiqs8PTv05Hi23Qji8/00fcy4IoLS0lKqqKqePjzszv9bWViyaSML8ujAYhtqpg/0iaPZJYf/+/cTExDg99t2HvIEgNr5h4Zqz6tC6q6F1Te3RaCzVg/y2B+JudQfC+eq74yxZNPLYB87v0KFDeHp6cvfdd/Poo48yLTmV97/zYu2KVgwG5zaPY0PcOXI8jkOHDhEUFMSuXbvQhi2krUtDbnwtYX6xKKa3EeHXkpcZ4bLPjre3+gUSFRWFwWAgNjbWYT1njvOvAl7X6/VWnU4H0AQM9A3qN5YNDJgQBJhObkiv1z8LPAtgMBjEcIOaCoz0ok8Fpvr84NSeY3d3N/UdIXjHmmls9cAvciHd3d1otdphV7Un48z8Ojo6wDOe5DgtsbFD202Ns3K0Kpeurq4xvVbN3VYSo8DY6MYXR2P46fkKJdUCEIT6dRIXF+fwPg8ftU5lXd+o/Q2cX29vL9HR0axfv553332X5BnX839FbtxwUSCxMU7sgAL56W0cOZhGV1cX2dnZmEwmgqddiX8szCtQg2llBj3G4ZYEzv/JPJd9dlJSUgCYOXPmiG06Y2bJAq7T6XQfoJpYbgaydDqdVqfTLQD22+rV6HS6NJ1OFwCE6PX6sRm1JBKJ0xQWFoJ3BvMye5kWDUfrkgAoLx+b+WE0ampqQBtLSpzj+CXJMeARkDmmWN8ApUaYlQ7XngsbXhcIIewHhiKDhk+TFh4Ebkovx6vG5ppoNBqJjo7G3d2dL7/8ksjsdczKgGkxzgfBKsjwRfFJ5/jx44AtkqTfEs6bfaLOsgXBsH8xZ5zhms1PwP7lPJqZZVQx1+v19+r1+vP0ev0FQJFer78D2AB8Bvza9gC4H3gB+BB4aNwjl0gko3L06FEUn+nMmO7DBXPhq8P+aLVal9vNa2trwSthWDFPiQWhTRyzSaHUqH4R3HGlwp4iePxV2LEHPDTdRIUNf1xfURRCfTuobhxbjECjsZb2wJ9RUSvw9PTiHzs1XLl4bNEM0+MVhGcShUWlABQWV9DUl8bSWSfaWb58OXFxceTl5Y2p7ZHoD6E7YZv5QPR6vc7272Zg80llh4Ezx9KeRCIZH0eOHEXjey6ZiRoiguDZdwWJSTkuF3OjsQ600SREOha+5GiFLhE9rpX5tecq5KYo3HaF4LevCFo7INC9ZtgDQ/3EhvWxpyiQnp4ePD1HjnjYT0m14EDvGs5YJ7h/lYKxEa5YNKYhqwG3FHf2F6p7B8cqNVhT3JgxwPV7yZIlQw4WTZRFixaxdevWUfck5KEhieQ0ZO+hKvo0gUxPgCUzQaOAb+zFLhfz4sp2UNyHuCX2kxwD3X2+VFQ7f4inq0dgbDzhDfP07Rqa/qlQ/JpChuWeUW3+ybHuoE2gtLTU6T4NjWqkxcxE+MVTgoI0SI0b28o8JQbAyrEKKyaTiVZLPF7aPhLHn3vCKdzd3Vm2bNmo9aSYSySnIQdLzABkJIC/j8KCXOj1Xexym3m5UfVviB9GX/v9rw2N3k6fQC2znf63uzai5tpMiVVoazg8qphnp/iBV4Lddu0MDe3++Hl288ETCvf/FNZfN/aEEV6eCsE+7VQ2eKtuiT7ZZCb0DXHZ/LGQYi6RnGZYrVbK67zw9eyxn16clwVtItXlK/OqBgUNFiKCHZfHhIGXRx89mkSnc3OW2sQ8ycGKtq6ublQxT4nzQPFOorjYOTHv7e2l3RxGVHA37u4Kv7lJw+WLxifAieG9NPeEcejQITQB+czI0I6rnclAirlEcppRWVmJ2X0aKdEWu095XopCfUc4pWUVLo3RUt/iib9n27CrT41GYVpUH/ikO203LzXavgQ8B7dpsVhobGwc9vRnP4lRIDT+HC6sdqq/uro68JpGUuTEX5fMJDfwSuPjjz/GzT+PvORTY1UOUswlktOOo0ePgncGuaknNv9yk8Hc506nNZrGxkaX9dXc5ecw689AspLdwDvdaY+WUqMYZGLpp/+I/mgr80T1QCSHS5w77GM0GsErifSEiWcompHpD95pfPDJN5g10eQ4eYL0h0CKuURymlFWVoabfxY5ySfEKSMBPNwE+Oa6zG4uhKDDHExU8Mg+3ZmJbrj5j+xrvq9Y0NaproxLqnEo5v1ZfEYT89hwULBSWu1ccK+amhrwmkZWysSTWmRP8wCvRJrMqornTBvlhh8QKeYSyWlGeYWRPo9EMgYE0PNwV8hMBI1/vsvs5i0tLVg9YkiIGlkmMhIUhGcqlZWOxbywUjD33wS//JMq5qU1ExNzD3eFYL9uapu1WK3WEesClFXWgzaS1LiJJ4LuzwdK6CX4e3URGSLNLBKJZJwcKesBxZ3pJ0VDzUtV8Aqd7TIxr6mpAc84kmNH3uRLjwOr4kNR+VCzh9Uq+Nl/CTw9YNPH0NwmKDXCtOihIlhfX4+Pjw++vr6jji0+3IrFLZbq6tHt5sfKugHHXyBjJSkKFCwQeimp0T0Tb9CFSDGXSFxEe3s7ubm5HDlyZFL7KTF6oNBHyklhOnKTFYR3tsvE3FBdC9oYMpP9R6zXv1otrh4qJ395B745DJ/8QcHDHZ7eAi3tqn/6ycmRa2trnY4rkxavBc9Ep9wT1ZgvVrutfSK4uyuE+rSAZywzMiZug3clUswlEhdRVFTEwYMHef755ye1H2OzLyE+rWg9Bq9u81Kgi1iOl40ttvhwFJa1guJGRtLwx+sBgvwVfLXtGEyDV9T1zYJ7nxE8cJ3C7EyFNRfAE39XTS2iq5To6Gi+/fZbe/2PP/7Y6WPwaQla3HyThxXz7/TfU1GhnsSsavDAx60ZT61rTCLTolVb/Zyc0X9B/JBIMZdIXET/ivjVV191WeadkxFC0NQVSkxI95Cy/tjchVVji1syHIXlqhdLfMToIhgT3EFjZ+iga98dgbZO+OVV6vN1lyp0dIGHOzRU78NqtbJhwwYASktLef/997n55pudGltCpILi7XhlbrEIzrpVYdUD6gnR+jY/QnwnlmZuIAtmqr8e8lNOHXs5SDGXSFxGWVkZgYGBGI1Gtm3bNil9tLa2YvFIIjV2qM90TBj4evZQ1RQyZl/zwsJC5s2bN8gjpbTajCJ6ncqRmRJtoUeTOCgGeWElJESCr7cqehkJCktnqddKS4pRFIU33niDqqoqnnvuORISErjgggucGm9iJFiUUIpLhrpD/uqFJro98inpXIypqZWWnmCigoZ++Y2X9Hh1PifnRP2xkWIukbiIsrIyZs6cyVlnncUrr7wyKX1UVVWBdxo5KUMDTCmKQlp0Nz1uaTQ1NY2p3W07D7LLdCOXXHUHZrOZgwcP8sG2gwR4DX9gaCBZ0zzAO22Qr/mxSkFG/OB6f/iFwu/WKhw/fpyzzz6b2NhYNmzYwPPPP8/atWudzmbfHw+lqGKwSFc3CB7f7IN7/fPgHs5j/7OLbhFFYuToXi/OcvlZ8Oc7FQJ85cpcIpmSlJWVkZSUxKpVq3jzzTfVxA4upri0GjzjmZUV4LC8IF0zLl/z7fu0EHUj3/O/LLn6Fc668iXc425mRmaIU/fPyvIHr2mUlZ/wLimsHODKZyMvRWHlYoXi4mIyMjK49dZb2bBhA01NTdxwww1Oj7d/M7P8pO2BX/5J4CEaOTdlKyHuh3h5qxnhmURavGtMTwCRIQrrLj21hBykmEskLqNfzK+88kp6e3t5++23R79pjOw7qtp+s6Y5dhecm+MLvrmUlpaNqd3iak/8lUKuOMPAl3U/pSXsES5eEsOf73ROImZk+IDizp6jLfZrxypV04rD/oqLSU1N5cYbb8THx4fLL7/cnuvSGXy9FQK8ezG1+9HTo7oIVtYK/v4pKKV3c8F5S1g2q5l6sQjcA8lJPbU2KycDKeYSiQsQQtjFPCgoiKVLl/LRRx+5vJ9Dpb0gLCQN4zNdkOYGHqEcOFbnuMIwGJqCiPStYcuTWbz4888p/FsHrz7sSWaScyvQ5BhA9LGvUN00be8UGOqHrswBenp6qKysJDU1leDgYN59912eeOKJMY0XIC7cCl5JVFRUALC7ENw0gtbyNznnnHP491XxoKhmm5lZzv3COJ2RYi6RuIDm5mZaW1tJSkoCoKCggAMHDri8n1KjOz5udXi4OxbZ/k25vYVjS6vW1BNDUoRqFlpzzdmkJDnn792Pp1bB162Ww2WqeBbZ9lFPtpmD+gvGarXac1suWbKE+HgHFUdBN90d/GbZvYj2FAnC/RqJjgohMzOT6HBPYn0OgLWX9MSJH+U/1ZFiLpG4gH5B6RfznJwcDh8+7HIXxeomX0J9ht/cDPBV8HVvoNjoXAYegNYOQa8mmqzEiW0SJocaKDGpx1ILK8FTq8ZBLy8vZ9WqVWzfvh1QTSyKopCcPLEoVfNzPVAC59hNSnsKQdO5j3POOcceTXL9jQHkRR/Aze3Us3G7GinmEokLKCsrw93d3Z7aKzc3l+7ubjWJgQtp6g4lNmTkKIbRgU1UNw8TgNwB+4rURBe6rJEPB43G3Ix2Wsmhu0dwrBLSYuEvf/kfcnJyeO2113jmmWcAVczj4uLw8vKaWH9ZINyC2WPbR9hbJKgv/Zhzzz3XXmftVRnse2P2cE1MKaSYSyQuoKysjPj4eNzdVa+JjIwM3N3dOXjwoEv76RKxpMSMvIJOi+mhxRzndJtf7mkBs4ncjJHjiI/GsvneoPHiw2/aKKwUhPs1ccstt3D33Xfzhz/8gY8//pi+vj6OHz9OamrqhPoCyJ4GbvSwr8SLxhZBZb2CuelbFi9ePOG2T0ekmEskLqB/87MfrVbL9OnTXWo3r61vQ2hjyHbgYz6QvFQP+jwzaGpyLvPP98d6oPMgCQljt1sPZN7MJOg4xNs7WjlWCe7mEiIjI1m/fj0rVqygqamJ7777juLiYru9fCJ4uCtE+RspawhjT5F6LTaoYVz296mAFHOJxAWcLOagmlpcKebf7KsHYFZW4Ij15ucHgHsAu/Y6l4nnSLkGt55jBAc7b5pxRHR0NO4dX7DzoAfHKqCzcR8zZ85EURRSUlJITU3lww8/tLsluoKMmBYaepPZUwQ+mjoWzstxSbunI1LMJRIX8EOI+fdH2sBqZk7eyJ4mi2ZHgLDy5d6WIWW7jwkeeVGw5HYr3xxRfdXLG/wI9TLaNw3Hi6IoxPkXUVwbRlsn1JR+xqxZs+zl559/Plu3bqWsrMxlYj57usCszebrg330teiZP3++S9o9HZFiLpFMkIE+5gPJzc2luLh4ULySiXC4xIzGXE5QoN+I9QL9PXC3VLDftrHZzxf7BbqbBH/9UNDcDnc9G0h1g6Ctx4+4kKHCPx7yE5sAWxKKwx8OEfNvv/0Ws9nsMjE/e7Y/aLx47ytBT+M3UswlEsn4OdnHvJ/c3FyEEBw+fHjCffSaBfvLA/DROGc6CfCooqh6sG392yNqkKvi1xTef1zB1Kph9W9V4U2LNTtqZszkTI/Fx3qMQB8z1p76QWK+ZMkSPDzUGOATdUvsZ/7MGOitw9znhqflCPn5+S5p93REirlEMkFO9jHvJyEhAX9//wl7tHy+V1Bwg6DUFEe63w6n7okJbMLYOvjU47EKQWaiag6JClW456o2PtGDu2ggLWli9vJ+0tLSsNS9TUxADWFhYcTFnfCq8fPzY+HChURGRuLvP3LCC2fx8/NF27sPgJnpGvuXxb8iUswlkglyso95P4qikJOTMy67+bZt2whPuYzca6pYdJvAmzLYncOlZzkXVTA1ppcWcyxW64lQuEcrTpzINBgMXHt2O7rpoOk8MEh0J0JaWhq9ReuZ1nk7s2bNGmKHv/HGG7n88std0lc/4Z4l0FvL4vnpLm33dEOKuUQyQUpKSgb5mA9kvJugL75loCH2/zh46DBJrdezZ1MqD913Iw888IBT9xekuSMUL0qNJ64dq4TpiQr79+8nOTmZ/33uL7z1azO9B69zmTtfeno6YOXjj7YOMrH0c+211/LnP//ZJX31Mzv2azhwLgsW/Ovay0GKuUQyYUpKSob1mx6vmO897k2AWznfPh9MZkw9b731Fv/5n//ptMfJnNwgEBa+OaBuvja3CWpNkBxt4brrrsPNzY0XXniBjuZy6K122co8NDSUoKAgzGYzM2fOdEmbo5GWHAWdh5g3b94P0t+pihRziWSCHD9+3L6h19Qm6DWfMG1kZ2dTU1Mz5mQRhiY/YoPbmD17Nlu3buXiiy8e0/3pqQnQvo9Pv1ODZx1T02Hy/v9toKSkhE8//ZT6+nqeeuopAJetzBVFsa3OcbgynwwWLlzIihUrCA0NHb3yFGbUiO06nS4H+AtgAdqBq4DlwO1AN7Bar9dX6nS6LFs9d2C9Xq//ZNJGLZGcQvRnzalrEsRdIeizQmKk4Il1CguzsgA4cuSI025zQghaeiM5K35sqd8GEh8fD23v8vWhaQAcLQcfTyv//Yf7+d/nnuOMM87goosu4tlnn8XHx4egICdywzlJWloaxcXFJCYmuqzNkbj44ovH/GU3FXFmZX5Mr9cv0Ov1i4BvgcuAO4HFwHrbA+C3wA3A+cCjrh+qRDI2hBDs27dvzPkwx4LFYqGsrIyUlBT0R8HSB5sfVshMhN+9KoiIiCAkJGRM7omVlQasnmnMzBx/QgWtVkukVxFFxkC6egTHKgVhvg2EhoSwZs0aAH72s5/R19dHfHz8hA8MDeTiiy/mxhtvdGmbktEZVcz1ev1AB1QfoAI4pNfre/V6/ZdArq0sWq/XF+n1+lagUafThbl+uBKJ8+zZs4eCggJeffXVSeujsrISi8VCSkoK+ptEbgAAIABJREFU3xeq3iIrFyvc8RMF/VGoboCsrKwxifkX+jJw82HRbOcz7zhiRkonfcIN/VF1Ze7ZV0ZeXp5dZPPz81mwYAEJCQkT6udkfvKTn/D444+7tE3J6DiVGE+n050LPA6YgbeB1gHF/b5SA7+GW4AQoOGkdm4GbgZYu3YtF1544fhGfRpgNpsHJbedapwO8/v8888BuOWWW8jIyCA6epj0PMPgzBx37doFgLe3N1/u72J6vMBgaCY1HAJ8IvnrP9tITEzk+++/d/r1+viLCmA+UYFtGAyto9YfjoxpgXzaUME/vwjiUIk3nY17mJY9zT4Os9nM73//e7q7u0/593I8nA6f0fEQGxvr8LpTYq7X6z8GZuh0unuARcDAbLL90fcHxuUMAkwO2nkWeBbAYDCI4QY1FTAYDMO+6FOB02F+RqOR/Px8LBYLDzzwAO+///6Yfvo7M8eWlhbCw8PJyMjgcIWV21cqxMaq5pEV8618djCQC3Q6Pv/8c6dfr9IaLVrqyUiNGb3yCMyfP5+NH37G7uJVlNYqeBi+Yd6NZ9nHYTAYmDt37oT6OJU5HT6jrmRUM4tOpxt4JrgFdRM0S6fTaXU63QJgv62sRqfTpel0ugAgRK/XN5zclkTyQ3LkyBEKCgr461//yqeffsrmzZtd3sfx48dJSUmhoVlQUQszB5xbuWShwrbvIfH/t3fvcVVV6ePHP4dr3m/gjfQHoigKSrDJTPCCeSmLSsussYuOl5xqUmtycszGb41aM42Z36+WlVo5qc0MloqXqcB7CgszIUwNxLumeQtRbmf9/jiHMxC3c+AAcnzer9d5HVl777XXksPD5tlrrxUYyvHjx7lyxb6r7MzTnvg0/LnabQsNDUVf3E7CXsgvgJzzewkNDa38QFEv2XMDdLBhGFsNw0gEBgEfAvOBrcDr1hfADGApsBl4tQbaKoRDDhw4QPfu3QkPDycmJoaEhASnn6MomBfNpx1WbP6oYdaL3jO5lvlCfvjhB7vqPHe1JQFtcqvdti5duuB5PQmzNmFCQ24GPXr0qHa94sZUaZpFKbUeWP+r4tXWV/H90oFo5zVNiKq7fv06mZmZBAcHA5abfUU5dGfKyMggNjaWvYcg0A+aN/lvGqdpIxMx4Zod6S1p0qQJ6enp3H777aXquJar+d3fNTOfMNG+5XWumzoSEphd7bZ5eHjQPcCdw55XucUjnxb+7WnUqOojZMSNTR4aEi7p0KFDmM1mWzDv2bMnqampmM3VW7S4OK217cp87yFNRBlTg9wfZWLDbujWPZQDBw6UWc+7X2iWb4RXPsjnu7QM8O5AnzDnTHzVMzSUZuznFp0lKRYXJ8FcuKQDBw7g7e1NQIDloZmePXuSk5NDZmam085x7tw5srOzCQwMJOUQhAeVvrl6bx+4lA0+AfeVOTwxO8fMnxZfhl+SWPW1iVWbLeMGoiOqNyyxSGhoKB5Hp9L0p+kSzF2cBHPhktLT0+natSvu7paRs926dcPDw4P9+/dXcqT9MjIyAPBp25mMkyVvfhbp0MZEr85w9ZaYUsG8sLCQQWM+41qeiddG74PrmSyMD8Ckr+Hfzjk/mqGhoRzPSCYjfasEcxcnwVy4pKKbn0W8vLwIDg7mu+++c9o5MjIyaNiwIaevWJZxKyuYA9x3J2Re7MaRI0dKrDr08T/+TdLp/owZeIGZ059m6kN5mD39aOpxFjc35zw9GRJiWRMzPz/f9m/hmiSYC5d04MABW768SM+ePZ16ZZ6ZmUmnTp3Yug8C2kGrZmUH4HvvNHHiQmO0dyAHDx60lf8zEdw8mvDOdEsqaO7UEHybXqd3z4oXbHaEn58fzZs3x9vbmy5dujitXnHjkWAuat3Vq1e5//77bU9POltBQQEHDx4sFcx79erl9DRLp06d+WgTPHZX+ftFdgPf5uDZ9sESqZYDJ5vSusERWlhHwHh5mvjP/AYsfLFleVU5zGQyERoaSnBwcJnzrQvXId9dUau01jz99NOsXbuW2267rUaeQMzMzCQ/P79EmgUsV+aZmZn88ssvDi9b9vNlzdETF0jZFcf69etJTU0lKyuLURPfIysdxt5TflrEzc3E8D6af/88kvT0tbbyM9l+RHYuuZByWBfnT041ZswYrl696vR6xY1FgrmoVe+//z6ffvop3bt3r9KiDfY4cOAA7u7updIKPXv2BCAtLY0+ffo4VOfUNw/wydZAPC56c1e3Tvzud9EEBwfz0Z7BDPCGQL+Kg/B9d5r4aONtfJf2DgA51wq57taFiG4pDrWjKiZOnFjj5xB1T4K5qDWHDh3iueee4/XXX8dkMrF06dIaOU96ejqBgYF4eXmVKG/bti0+Pj589913Dgdzr5/eoatbWzyNmWzOGkOMn4k+0TByvub9P1R+NT04EtxMsPeILwBffXMG3NoxuLdzxpMLITlzUWtWr15N+/btmT59OiEhIfz4448lRnc4S9HUt79mMpmqfBM0LXUfsXfksH+5O/831cSMJZq+v9N4e8LI/pUf36ShidCOFzidF0Fubi5f7bkI+T/Tr3ftLOAgXJ8Ec1Fr4uPjuffee3Fzc7NMAqW1Q/N82ys5ORnDMMrc1rNnT4eHJxYWFpKammqbC3zyAya+/LuJc5fhiaHQ8Bb78tz39jVBi2GkHziE+kHjnZ9G48byeL1wDgnmolacO3eOpKQk2xz2HTt2pGnTpk7Pm58/f56srKxyg3l4eDj79u2joKDA7jozMzPJycmx5dwBBtxmImu1ibeesf+G5ZP3tgLPVqzb8hOHTzejbeNTdh8rRGUkmItasXHjRm655RYGDBgAWFIeISEhTg/mKSmWG4rlLSYcGRlJTk6O3TMYAuzfvx9PT0+6detWorxxQxNenvYH8863enBL4WHikxry8/W2dPOr/mRaQhSRYC5qxYYNGxg0aBANGjSwlYWGhjo9mCcnJ9O1a1eaNm1a5vagoCAaN26MUsruOvfv309wcHCpG6pVEdAsnZQTYWg86N3DvfIDhLCTBHNR4woKCti8eTPDhw8vUR4SEkJaWppTz6WUKjfFAuDm5kZERATJycl217l///4SKZbq6Bt8kUK8Ie8neofdPKvgiJonwVzUuF27dnHp0qVSa76GhoZy5swZzp933qJUycnJREZGVrhPZGSkw1fmzgrmg+9oBnk/QfZeunYtZzIXIapAgrkA4MsvvyQvL69G6l63bh2hoaGlVoEvmsXPWamWU6dOcerUqQqvzAEMw2Dfvn3l9ldrTWJiIgUFBVy5coXMzEynBfPQkO5w9M+4n/sAf39/p9QpBEgwF8COHTsYMmQIa9eurXxnB127do3ly5fz6KOPltrWsmVL2rdv77RgnpKSgpubG7fddluF+0VGRpKXl1duiufzzz8nJiaGd99917ZPr169nNLGzp0743H+Q4Ja/WCbnlcIZ5BgLnjllVcA2LdvX5XrKCwsLPMBoE8//ZSrV6+W+0i5M2+CJicn06NHDxo2bFjhfgEBAbRs2bLMVIvWmrlz5+Ln58dbb73FihUr8PX1pU0b5ywW4enpSZcuXQgKkhSLcC4J5je5hIQEtmzZQlhYWLXm+n7mmWdo1KgR/v7+PProo1y6dAmtNfPnz+eJJ56gVatWZR4XFhbm0M3IIps3b2bOnDklyiq7+VnEZDJhGEaZ501ISCA5OZn169fTu3dvFi9ebHtYyFl++9vf8sgjjzitPiEAy5VIXbxOnDihXVl96J/ZbNZ33nmnjo2N1fPnz9e33nqr3cf+un+GYeiHH35Yv/XWW9rf31+Hh4fr1atXa0Cnp6eXW8+6deu0m5ubvnTpkkNtf/LJJzWgly9frrXW+j//+Y/28PDQK1assOv4GTNm6LCwsFLlgwYN0vfcc4/WWus9e/bopk2b6hdeeMGhttUX9eEzWh0u3L8yY6oE8xpSH/q3ceNGDehvv/1WJyYmakCfP3/ermOL989sNuvGjRvrjz76SGut9bFjx3RgYKAG9LBhwyqs58KFCxrQGzdudKjt/fr10z4+PrpBgwZ6xYoVukmTJnr8+PHabDbbdXxcXJx2d3fXOTk5trKkpCQN6O3bt9v6mJ6ebvf/SX1THz6j1eHC/Sszpkqa5SaltWbWrFmMHDmSsLAw2w2+qqRaTp8+TXZ2Nl27dgWgQ4cObNu2jaFDhzJr1qwKj23RogUhISHs2LHDoXNmZmbypz/9ib59+zJmzBj69u3LokWL7E6H3H777RQWFtqeGAVLfj88PJyoqChbWXBwcLkpIiFuJBLMb1Lr169HKcXs2bMBS1Dt2LFjlW6CFi2FVhTMAdq3b8+mTZvsmmo2KirKoWCem5vLyZMn6dy5M59++ikzZ87ks88+w9PT0+46/Pz88Pf3L3HeHTt2EBMTY3cdQtxIJJjfhMxmM7NmzWL06NH06NHDVh4WFlblYN66dWuaN29epfZER0ezZ88ecnNz7dr/6NGjaK0JCAjA19eX1157zeGVg4rOWxTMs7Oz+fbbb0tclQtRn0gwvwmtWbOG/fv38+qrr5Yo79WrV5XSLD/88EOpSagcERUVxfXr19m7d69d+x85cgSwDDGsjqioKHbu3InZbGb37t0UFhbSt2/fatUpRF2RYH4Teu+99xg1alSJtAhYrszT09PtvkIucvDgwVJ1OaJjx4507NjR7lRLZmYmbdq0qXQ8eWWio6O5dOkS33//PTt27CA4OBgfH59q1SlEXZFgfhPat28f0dHRpcrDwsIoKChweMGI6gZzcCxvfuTIETp16lSt8wF069aNVq1asWPHDrZv3y4pFlGvSTC/yZw9e5Zz587Z5kUpzt/fnyZNmjiUarl27RpZWVnVSrPAf/PXZrO50n0zMzOrnWIBy8NDUVFRJCYmsnv37jJ/wQlRX0gwv8kUzTUSEhJSapubmxu9evWyO3cN8OOPP6K1rvaVeZ8+fbhw4QIZGRmV7uusK3Ow/EWwZs0acnJy5Mpc1GsSzG8yqamp3HrrrbRoUfaq8IMGDWLdunWWJ8rscPDgQTw9Pas9A2D37t3x9vYuMe67PEeOHHHKlTlYgnlBQYFtqKIQ9ZVHZTsYhhEBvA2YgbPAb4ARwPPAdeBJpdRxwzC6A+9Z63xFKfVVjbVaVFlqamqZKZYijzzyCLNnzyYpKYnevXtXWt/BgwctMwF6VPpRqpCnp6ftr4LRo0fbys+fP8/8+fP5+uuv2bx5M1prLl686LQr8/DwcBo0aEBUVJRT518RorbZc2V+EhiqlOoP/Ag8AEwDBgCvWF8Ac4BxwFDgf5zeUuEUlQXz4OBgQkNDWb16tV31VXdYYnHh4eElrsz//e9/4+/vz9KlS0lLS2PVqlVOG5ZYxMvLixdffJFx48Y5pT4h6kqll1NKqTPFvswHgoDvlVJ5wE7DMP5m3dZOKXUYwDCMnw3D8FFKlVhCxjCMicBEgEmTJpVaecaV5Ofnc/LkSYeOWbVqFdOnT0drTYMGDYiPj6dz585Oa5PZbCYtLY0xY8ZU2La7776bjz/+mKlTp+LmVvbv+6L+paamEhUV5XBfy9KpUydWrlzJiRMnMJlMzJs3j/79+7NgwQJeffVVFi9ejMlkwsPDA5PJ5JRzguWzCJSqryrfw/pE+lc/+fmVs9xgeZO2/PoVERHRMSIiYmdERET/iIiIt4uVJxV/t/57RURERFBF9bnwJDha66pN8hMTE6PvvvtuvWbNGt21a1f93HPPObVNhw8f1oDet2+fXftt27atRHleXp7euHGjHj9+vA4KCtLdunXTHh4eetmyZU5p3969ezWgMzIy9Pnz57Wbm5tet26d1lrrb775RgP6iSee0IGBgU45X2XkM1q/uXD/yoypdiU6DcNoCnwCjAXcgeJLnxda34uPKWsOXHDkt83N7sqVK2zbto2VK1fywAMPcPz4cWbOnMncuXNp1KiRw/UtXboUPz8/hg4daitLTU3F3d290rRI586diYiIYPXq1SWG6z399NMsW7aMvn37EhsbS+vWrfH09GTEiBEOt68sPXr0wMvLi5SUFPLy8vDy8rLNldK7d2+Cg4NZsWKFzJ8iRBkqzZkbhuEO/AP4H6XUISx58+6GYXgZhtEX2G/d9YxhGF2sgb/lr1MsomJffvklAIMHDwbgiSeeoKCggJUrVzpc1+nTp5k8eTLjxo3j2rVrtvLU1FSCgoLw9vautI5HHnmEf/3rXxQWWn5XFxQUEBcXx8KFC9m+fTtTpkzhD3/4A1OmTKFp06aV1GYfLy8vQkNDSUlJIT4+noEDB9qe8jSZTIwbNw6z2ey0m59CuBJ7boCOAu4EXjEMYwuWkSzzga3A69YXwAxgKbAZeLV0NaIiGzZsIDo6mmbNmgHQrFkzHnvsMRYvXmz3MMEib7/9Nj4+Ply5coX33nvPVp6Wllbhzc/iHnroIc6ePcvOnTsBSEpK4tKlSzV+nyMiIoKkpCQ2bdrE8OHDS2x7/PHHcXd3d9rNTyFcSnn5l5p+uXA+S2vtWL6usLBQt23bVv/tb38rUa6U0oDes2eP3XVdvHhRN2nSRL/99tt65syZunXr1jo7O1trrXW3bt30a6+9Zndd4eHh+vnnn9daaz1r1iwdFBRk21ZT3793331Xm0wmDegjR46U2h4XF1druVD5jNZvLtw/WZziRvXtt99y5syZUle9ERERhIeH88knn9hd16JFi/Dy8mL8+PFMmzaN3NxcXnrpJaZOncqhQ4fo2bOn3XWNGDGCuLg4tNZs2rSJYcOG2X1sVUVERKC1pnv37mU+xPPggw+WfzdfiJuYBPMbQHx8PAEBAWXemIyNjWXTpk121XPlyhXefvttnn/+eRo1akSLFi148cUXWbRoEYmJifzlL38plbqoyMiRIzl+/DibNm0iOTm5xM3UmhIaGoqnp6dLD1sVokaUd8le0y8X/hNIa136T7zY2Fi9ZMmSUvudPXtWd+rUqdxhiEVD8jIyMio957hx43S7du30xYsXbWUFBQX65MmTDrb+v7p37667dOmivby8bOkarWv2T9jly5frY8eO1Vj99rrZPqOuxoX7J2mWunL16lXi4+N54403SswKePr0aQYMGICXlxczZswo89jIyEhatGjB5s2bKzzH+vXrWbp0KR9++GGJFX/c3d1p3759lds+YsQIDh8+TL9+/ao0RLIqnnzySTp06FAr5xLCVUgwrwVKKQoLC8nIyOCrryxT1ly4cIEBAwbg7u7Oli1baNu2bZnHuru7M3jw4ApTLefPn2fChAlMmDCBu+++26ltHzlyJECtpFiEEFUnwbwCCxcuxNfXF19fX0JDQzl79myV6tm9ezcBAQEMHjyYd999F4Bnn32W3NxcEhISaNOmTYXHDx06lISEBPLy8kptO3z4MNHR0TRq1Ii33nqrSu2rSK9evZgzZw6PP/640+sWQjiPBPMKfPjhh0RFRfHmm29y+fJl5s2bV6V6du/ezR133MHTTz/N2rVrWbBgAStXrmTZsmX4+vpWevzQoUPJzs7mm2++KVGekJDA7bffjo+PDzt37qzSosaVMZlMvPzyy5X+whFC1LHykuk1/brRb04cP35cAzoxMVFrrfWSJUu0t7e33TdVivYzm826bdu2esGCBTo/P1+3b99eA/r3v/+9Q+0JCQnRf/zjH21fm81m3alTJ/3www/r3Nxch+pyhhv9++cMrt5H6V+9JTdAHbFhwwaaNm1qW639qaeeon379syZM8eheo4dO8aZM2e444478PDw4IUXXiAsLIy5c+c6VM+wYcPYsGGD7ev09HQyMzN5+eWX8fLycqguIYTrkWBejg0bNjBkyBA8PT0By+IJs2bN4v333+fo0aN217N79268vb0JCwsDYNq0aaSkpDi8svzDDz/M/v37betzfvHFF3To0MFWrxDi5ibBvAy5ubl89dVXpR6wGTNmDO3ateOjjz6yu67du3cTHh5e4uq5vDnCKxIZGUmPHj1YtmwZYAnmsbGxsjqOEAKQYF6mrVu3cvXq1VLD/Dw8PBgyZAjbtm2zu66im5/VVTRr4CeffEJWVhZJSUnExsZWu14hhGuQYF6G+Ph4DMMocwRHv3792LVrV5nDBH8tNzeXvXv3OiWYg+UvgytXrjBx4kSaNGnCgAEDnFKvEKL+q94qvLUsOTmZNWvWABAYGMi4ceNqJM2wceNGHnvssTK39e/fn2vXrqGU4s477yy3jqtXr/L73/8eNze3Egs8VEfr1q257777WLNmDaNGjZIbn0IIm3pzZZ6Xl8fIkSP57LPPSEhIYPz48SQkJDj9PMeOHePw4cMMGTKkzO0dO3bE39+frVu3llvHkSNHuP/++/nmm2/YsmUL7dq1c1r7fvvb3wJw//33O61OIUT9V2+C+cqVKzl79izbtm1j9+7dxMbGMmvWLIcXbqhMYmIijRo1IjIystx9+vfvX24wT0xMJDIykltuuQWlFL1793Zq+4YNG8bChQt58MEHnVqvEKJ+qxfB3Gw288Ybb9jGegPMnj2bXbt2VToBVXn1jR49mn/84x+ltiUmJhIdHW0bkliW/v37s3PnTgoKCkqUf/jhhwwePJjhw4fzr3/9q1oTXJXH3d2dZ599lgYNGji9biFEPVbe00Q1/XLk6ay4uDjt5uamf/zxxxLlI0eO1IZhaLPZ7MjTU/rLL7/UgDaZTPqDDz6wlZvNZt2hQwf9xhtvVHh8RkaGBnRSUpKtrKCgQDdr1ky/9NJL2mw2u/LTZ1prl366zsbV+yj9q7fq5xOgWmvmzZvHqFGjCAwMLLFt9uzZpKSk2L14Q5HFixczaNAg5s6dy/jx41m6dCkAmZmZHD9+vNLV3wMCArj11ltLpFrS0tK4fPlyjd2UFUKIitwwwXzDhg2cOnWqVPnOnTtJSkpi+vTppbb16NGDu+66i+XLl9t9nlOnTvHFF18wefJkpk+fzuzZs3n22WfJysoiISGBZs2acdttt1VYh8lkon///mzZssVWtmPHDnx9fQkKCrK7LUII4Sw3RDBPSUlh+PDhdOrUiWeeeYbTp0/bts2fP5+BAweW+9j6mDFjWLt2LZcvX7brXB988AGtW7e2PXAzY8YMgoKCeO6550hISKBfv364u7tXWs+wYcP4+uuvyc7OBmD79u1ERUXJVbkQok7cEMF8wYIFGIbB4sWL2bRpEzExMfzyyy8cOXKEzz//nClTppR77IgRI3BzcyMuLq7S8xQUFLBkyRLGjx9vu8Hp4eHB4sWLWb9+PXFxcZWmWIrce++9FBYWsnHjRrTWtmAuhBB1oc6D+enTp1m1ahXTpk1j7Nix7Nq1i8uXLzNx4kQWLlxIQEBAhYsQN27cmAceeMCuFew/++wzzpw5w4QJE0qU9+nThwkTJpCXl8fAgQPtanfz5s0ZNGgQcXFxZGVlcerUKac9HCSEEI6q8ydAFy1ahK+vLw899BAAbdq0YfXq1QwcOBCtNfPnz6807TFmzBiGDx/O8ePHy1078vr168yYMYNJkyaVuc+bb75Jjx49CA0NtbvtI0eOZOrUqcTExNCwYUOZwVAIUXfKG+ZS068TJ07onJwc7ePjo+fMmVNq7M38+fO1n5+fvnz5cqXjdPLz83Xr1q31vHnzSpUXDVucN2+ebtKkif7pp58qrc9eP/30k3Zzc9P+/v46JiamxDYXHhaltXb9/mnt+n2U/tVbN9bQRK01L730Ejk5OUycOLHU9ilTpnD06FGaNm1aaV0eHh785je/YenSpbYnQrOzs+nQoQPR0dH885//ZM6cOcyYMcOuZdrs5evrS79+/cjKypIUixCiTtVZMJ85cyZLlixh1apVtGrVqsx97BlVUmTSpEkcOnSIxMREAD7++GOys7Np1aoVo0aNonnz5jz//PNOaXtxRavXy81PIURdqrOc+apVq/j8889LzRleVV27dmXgwIEsXryYAQMGsGDBAsaOHcs777xDWloanp6eNfII/OjRo0lOTrYtLyeEEHWhzoL5smXLnBbIi0yePJnHHnuMZcuWcfjwYeLj4wEICQlx6nmK8/HxcWjlISGEqAl1lmbp16+f0+t84IEH8PHxYfLkydx333107tzZ6ecQQogbUaVX5oZhNAG+AnoAdyil0gzDeAR4HrgOPKmUOm4YRnfgPWudryilvqrBdpfJ09OT8ePH8/rrr1f4oJEQQrgae9Is14B7gb8CGIbhCUwDooFI4BVgIjAHGAecBTZh+QVQ66ZMmUKrVq1kSTUhxE3FVDSUrzKGYSwH/gaYgReVUuOs5d8opfoYhrFHKdXbWrYOGKuUOv+rOiZiCfxMmjQp4p577nFaR240+fn5Fc6JXt+5ev/A9fso/auf/Pz8ypwAqio3QJsDV4p9XTR+sPgJLgMtgRLBXCm1BFgCcPLkSe3n51eF09cPJ0+eRPpXv7l6H6V/rqUqN0AvAsWf5Cm0vpuLlTUHLlS1UUIIIRxTlSvzH4HuhmF4YcmZ77eWnzEMowuWnHnLX6dYhBBC1By7grlhGBuAMKArsBiYD2zFMprlCetuM4Cl1jpnOb2lQgghymVXMFdKlXWncvWv9knHMsJFCCFELavz+cyFEEJUnwRzIYRwARLMhRDCBdj90JAQQogbl1yZCyGEC5BgLoQQLkCCuRBCuAAJ5kII4QIkmAshhAuQYC6EEC5AgrkQQrgApy/oXM4ycy8AI4Fs4Cml1Cnrvm5AGrBIKfW/hmHcCnxkbddapdRbzm6fM9jbR+uCHj2Aq0C8UuqvhmHciWVOdx+lVNu66UHFqtm/J4HxgCewXSn1hzrpRAWq2b+ngD8BJ4GTSqnf1EUfKlLN/k0EHrNWFQxMVEp9UeudqEA1+1cvYkxVOD2YU3qZubbAcKAv/11mbrJ130eBY8WOfRmYo5T62jCMtYZhrFJKnayBNlaXI30cq5RKK3bs98DtwLbNloM5AAAEcklEQVRaa63jqtO/T5VSH1mPSzAMo4NS6nittdw+1ekfwAKl1P/WUlurosr9K76AjGEY3wFf1l6z7Vad7199iTEOc3qaRSlVoJQ6V6zo/wHfK6U0sBeIAjAMwx14GPis2L6dgH3Wf+8H+ji7fc5gbx8BDbxvGMaXhmH0sh57WSmVU7stdkw1+5cPYBiGB5YVp36uvZbbpzr9s/qdYRjbDcMYXUtNdogT+odhGLcBB2/Ez2o1+1cvYkxV1EbOPAOINAzDG7gLaGEt/w3wT0quUHQAiLEGggFYViyqD8rr44tKqT7Ac8B7ddU4J3Cof4Zh/AE4BPx8IwaDMjjSv8+BEOAeYJphGO1qu7FVUJXP58NYfj7rA0f6V19jTKVqPJhbVxx6F/gPMBQ4aL0qfwRY9avd5wKjgXjgKHCmptvnDGX10Vr+s/X9B7D9NVLvONo/pdRfgS5Aa8Mw7qiLNjvCkf4ppS4ppcxKqV+ARCx55RtaFT+f9wAbarelVeNg/+pljLFHrYxmUUotV0r1B74AEoC2QBss/6EvYPmzNUIpdU4pNRLLB8kb2FIb7XOGMvqIYRhNre+tAW+lVGEFVdzQ7O2f9eoIa1+vAvXhytyR/hWVuQO9gcw6arJDHPl8GoYRBhxWSl2tq/Y6yt7+1ecYU5mauAFaYpk5wzAWY/mP88Xym/AZpdQ1wLDu+xTQWCmVYhjGMGA6ltTLm0qp7JponzNU1kfrbisMw2gJuGP5pYVhGMHAQiDIMIyvgBeUUt/VdvsrU9X+AS8ZhjEIy2frK6XUfm5A1ejfVMMw7gZMwEqlVFatNtxO1egf1IMUSzV+/upNjHGUTIErhBAuQB4aEkIIFyDBXAghXIAEcyGEcAESzIUQwgVIMBdCCBdQI0MThagrhmH4A0esX76ilHrdWr4UGAuglDJVse7uwChgi1Jqi7VsOfAkEKmUUtVpuxDVIcFcuLKxhmH8BWiIZex0dXUHXrX+e4sT6hPCaWScuXApxa7MM7FMqhQDBACLgPOAH5b04gxgItASUMCzSqnvDcP4M5aA/X/AECzzfPwOSOa/V/xFBgJPYbkynwM8juVhoseUUttrqItClEly5sJVHQD2AOOsr8+BS9ZtY4HXscya9ycs06Z+YRiGZ7Hj78IS0JsB84BzwNvWbf/GMn1zerH9B2KZOvZW4M9O740QlZBgLlzZUizplb7AsmLl91jfpyml3sEyn0cgEFRsn78rpRZgucL3t85TstO6LU0ptUop9VOx/f9szc/nAv5O74kQlZBgLlzZKqAQOEHZiyxUlGO8YH0v4L8/J/buXy9nxxT1mwRz4bKUUlewpFgmKaWKz5sfb33/u2EYzwGxWObEPlRJlRet79GGYYw2DKOBUxssRDXIaBbh0pRSq8soXo7lRugELDdIk7HcAM03DKOi6nYAXwP9rMd1cGpjhagGGc0ihBAuQNIsQgjhAiSYCyGEC5BgLoQQLkCCuRBCuAAJ5kII4QIkmAshhAuQYC6EEC7g/wPK8+uI3jX7xgAAAABJRU5ErkJggg==\n" }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAESCAYAAADtzi4UAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd3hUZdr/P2d6ymTSe08IkEgHJQuK0sHesPsisoi4dl0L6Ltr+SEKrAqruEhxVVzR1cWX6KqgdBFRQAEJpJCeCUkmdZJMO78/hgyEtEkyEYjP57pykTnnOU+ZCd9zz33u+36kqqoqGYFAIBCc9yjO9gQEAoFA4BmEoAsEAkEfQQi6QCAQ9BGEoAsEAkEfQQi6QCAQ9BGEoAsEAkEfQQi64DcnLy8Pf39/pk2b1urcvHnz8Pf3p6KiwnXMarUyYMAArr/++lb9BAYGMnbsWNfPmDFjePfdd9s93/xjsVg8spbbb7+dxx9/vN3zS5YsYdSoUQwbNoyFCxciyzJVVVWt5hMYGMjy5ctd78GYMWO49dZbsVqtAFRVVTFp0iSampo8Mm9B30R1ticg+H2i0+nIzs4mPz+f2NhYAOrr69m9e3erths3biQtLY39+/eTmZlJ//79Xee8vLzYsWOH63VxcTHp6ekMGzYMvV7f6rwnee211/juu++47rrr2jz/1Vdf8Z///IctW7agVCq57rrrGDBgANdee22LOb311lts2LCBe+65h4MHD2I0Gtm5cycPP/wwmzdvZurUqbz44os8+uijaLXaXlmLoG8gLHTBWUGpVHLttdfy0UcfuY793//9H9OnT2/V9u233+byyy/nuuuu48033+yw38jISJKSksjOzu7SfNqymseOHcvixYvbbL9t2zY2bdrEXXfd1W6fGzdu5MYbb8THxwedTsdtt93Ghx9+2KJNTk4Oixcv5q233kKtVqPVamlsbESWZerr69FoNPzyyy8UFhYyderULq1J8PtDWOiCs8Ytt9zCPffcw6OPPgrABx98wMKFC12uB4AjR46wd+9e3nvvPYYOHcrll1/Os88+S2BgYJt97tmzh5ycHEaMGIHdbqehoYGxY8e2aDN69OhWQu3v7++2JV9SUsKTTz7JJ598wpo1a9ptV1RUxLhx41yvo6KiKC4ubtHm+eefZ86cOcTExADQr18/0tPTufjiixk5ciSXXnop1113HUuXLnVrboLfN0LQBWeNoUOHolAo2L9/P8HBwdTV1ZGamtqizapVq5g8eTIBAQEEBAQQFxfHmjVrXDeB0wXbbrcTGBjIypUriY6OJi8vz22XS1VVFVdccUWr49dccw2PPfaY67XVamXWrFksXLiQ8PDwDvt0OBytjimVStfvhYWFbN68mddff71FmwULFrBgwQIAPvzwQ4YPH45er2fWrFmYzWbuueceLrvssk7XJPj9IQRdcFa56aab+PDDDwkODuamm25qca6+vp4PP/wQrVbLoEGDAKitreXtt9/mgQceAFr70LuLuxb6vn37yM/PZ/78+QCUlZVht9tpbGxk2bJlLdpGR0dTWlrqel1cXExkZKTr9YYNG7jiiivQ6/VtjlVbW8s//vEPPvvsM5YsWcLkyZO5+uqrueyyy9p81iAQCEEXnFVmzJjBxIkTCQgIYOPGjS3OffTRRwQGBvLjjz+6LNuqqioGDx7Mp59+ykUXXfSbz/fCCy/k0KFDrtcLFy6ksrKSV155pVXb6dOns2jRImbOnIlKpWLdunXceuutrvM7d+7k6quvbnesRYsWcd999+Hj40NTUxNqtRqFQoHZbPbsogR9BiHogrNKZGQkKSkp+Pn5ERAQ0OLcqlWruO+++1q4Kfz9/ZkzZw5vvvmmW4Lelg8d4I033mDw4ME9X8AZrF69mn379rFs2TKmTZvG4cOHmTBhAhaLhenTp3PLLbe42ubk5LgifM4kMzOTw4cP88ILLwBw1113MXv2bBYvXtzCBSQQnI4kyucKBAJB30CELQoEAkEfQQi6QCAQ9BGEoAsEAkEfQQi6QCAQ9BHOqqDX1dWdzeF7HbG+85u+vj7o+2vs6+s7k7Mq6LLctwNsxPrOb/r6+qDvr7Gvr+9MhMtFIBAI+ghC0AUCgaCPIARdIBAI+ghC0AUCgaCPIARdIBAI+ghC0AUCgaCPIARdIBAI+ghC0AUCgeAscvjwYQoKCjzSlxD0DmhsbHTtlNMWa9euxWq1/oYzEggEfY0///nPPPzwwx7pSwh6D1iyZAl2u/1sT0MgEJzHVFZW8s0331BUVNTjvs7pHYssFgv5+fke7zc2NhaNRtPmubq6Ov74xz9SVVVFYmIiADt27GDRokU4HA7q6+t5++232bVrF2VlZcyaNYt3332Xhx56iKKiIkpLS5k+fbprk1+BQCDoCJPJhMPh4IMPPujxblRndcei2tradjfIBcjKymLkyJEeH3fv3r0kJye3eW7ZsmVUVVXxzDPPsHfvXu666y4efPBBLr/8ciIiIliyZAmyLPPYY48xaNAgfvjhB4xGI1u3buXOO++ksbGR1NRUcnJyOl3f+Y5Y3/lPX1/j+bC+8PBwIiIikGWZn376CYWi+46Tc9pCj42NZe/evb3Sb3tkZWUxefJkAEaOHIlarSYiIoInnngCHx8fSkpKWu1lGRAQwE8//cT27dvR6/VYLBaPz1kgEPQ9GhoaaGxsZN68eTz++OPs2rWrzT1w3eWcFnSNRtOuJd1b9O/fnx9++IHLL7+cAwcOYLVaefDBB9m3bx96vZ65c+e6KrgpFAocDgfr1q3DYDDw6quvkpOTw9q1a393Vd4EAkHXMZlMAIwaNYrRo0fz3nvv9UjQ3bLtly5dyqRJkxg3bhz//Oc/ycnJYerUqUybNo1HHnkEh8MBwEsvvcT48eOZPHkyP/74Y7cndTaZNWsWx48fZ+rUqbz99ttotVpmzJjBtGnTmDJlCnV1dZSWlgKQnp7OjTfeyLhx49i0aZPr/UhKSqKkpOQsr0QgEJzrNAt6QEAA1113HZs2bepRf51a6Nu3b+f777/nyy+/xGw2s2zZMp5++mnmz5/PxRdfzMMPP0xGRgYxMTHs3LmTzZs3U1hYyJ133sm3337bo8mdDXQ6HWvXrnWr7YoVK1y/79y5s9X52tpaT01LIBD0QU4XdFnXjwrNjciyjCRJ3eqvUwv9m2++IS0tjdtuu42bb76ZqVOncuDAAdfXgokTJ7J161Z2797N+PHjkSSJmJgYbDYb5eXl3ZqUQCAQ/B4wmUwolUo0Oj1vfHspctyL1NfXd7u/Ti30iooKCgoK+PDDD8nLy+OWW27B4XC47iC+vr7U1NRQW1tLYGCg67rm48HBwe323dTU1O2Jnw80Njae7Sn0KmJ95z99fY3n+vpKS0vx9/fn+Xck8sr1oIKCwiyioyI6vK69yJ1OBT0wMJB+/fqh0Wjo168fWq22RQB8XV0dBoMBvV7fYv++5uMdodVqz/mQop4i1nd+09fXB31/jefy+hoaGvAKm8CbG325Nr2ST78LpLpOZmA359ypy2X06NFs3rwZWZYpKSnBbDZzySWXsH37dgA2bdpEenq6q53D4aCgoACHw0FQUFC3JiUQCAS/B0wmE7UBDzB+qJ05Vzg9FsVlDd3ur1MLferUqezatYvx48fjcDhYvHgxcXFxPPDAAzz33HOkpKRw9dVXo1QqSU9PZ9KkSa52AoFAIGifyspK7MowRg2wExXqBYCxovtuIrfi0J977rlWxz7//PNWx5566imeeuqpbk9GIBAIfk+YTCbskj9BfjKBBiUAxoruF/wTxbnO4P333+cvf/lLt6/fvn07s2bNanX8H//4R5f7OnToUJvhkCtXruSyyy5j/PjxfPrpp92aZ1cwmUx89NFHANx77709jpVtxpN9gTOHoNkV2Mzx48cZNWoUc+fO9dg4XeX09+9Mli5dyr59+3j//fe54IILuPzyy10/jz/+uEfGz8nJYcaMGVx77bVMnDiR//3f/3XljniSgoICvvjiCwAuv/xyjh492uL8zz//zKJFi7rc7+rVq9m6datH5niuUWky0STrCfKT8dEBspWKKlu3+xOC/hvRHRfUZ599RmZmZotjFRUVrF69mq+++ooNGzawYMGCXs9KPXjwoOs/6vnGd999x+TJk1vkDPzWtPf+FRYWcujQIYYNGwbADTfcQEZGhuvnlVde8cj4zz33HHPmzOHTTz/l66+/Jisri4yMDI/0fTrbtm3j+++/b/f84MGDeeKJJ7rc75133snixYv7ZGXTClMjDllNoJ+MJIFSrqWypvs323M69d9ihfyy7gXYd0RsqIxG3f75PXv2cNVVV1FbW8uTTz7JlClT2LBhAytXrsRmsyFJEu+99x6BgYH8+c9/5scff8RisfDUU0/h5+cHgNls5o477uDWW28lPz8fk8nEo48+yksvvcTDDz9MdnY2siy7ErSef/55tm/fjs1m46qrrmLGjBmsW7cOjUbDkCFDGDFiBABBQUFs374dlUpFfn4+Wq22VRJCXl4es2bNIioqivz8fK6//noOHz7Mzz//zJQpU3j22Wc5cOAATzzxBAqFAp1Ox2uvvYbD4WD27NlERUWRm5vLiBEjWLp0KUuWLOHgwYOuhKs1a9bw2muvUVVVxauvvkpaWhozZ86kpqaGhoYGnnnmGcaPH++aj91ub7caZXNfNTU1LF26lBEjRvDWW2/x8ccfI0kS1113HXPnzuXw4cPMnz8fu91ORUUFS5cu5aKLLmLlypX885//JDw8nBMnTrR4HwoKCli6dCkNDQ0kJiYycuTINtd8yy23EBAQwOTJk5k4cSJPPPEEsizj5+fHihUr8PPza/U5T506tc01ffbZZ7z22muo1WrCw8NZvXp1i/dv5syZrvmtXr2aq666qsO/1ZqaGiZNmsTq1atRKpXMmjWL//73v0yaNIn09HSOHDmCv78/q1atwsfHp80+QkJCWLduHb6+vowYMYK1a9eiUqnYvn07r7zyCt7e3hQVFTFr1iy2bdvGwYMHmTt3LnfffTfffvstL7zwAlqtlsDAQJYvX46/vz/z589n9+7dgPNGNGfOHF599VUaGhq48MILAVi0aBFlZWWYzWZWrVpFQUEBa9asYfXq1QwfPpyLLrqIrKwsQkJCePfdd7FYLMydO5fS0lKioqLYtWsXR44cQaVSMXjwYL788kumT5/e4ft1vmGqU0IABPk5jTK1VI+prpOLOuCcFvT8MomRc3093u/eFXUkR7Vv1fr4+LB+/XrKy8uZMGECkyZNIisri/Xr1+Pt7c1DDz3E5s2b8fLyoqKigm+++YaqqiqWL1/OuHHjqK+v5+abb+Z//ud/uP766wGny2XJkiWsWrWKoKAgli9fTmVlJdOnT2f37t2sX7+ejRs3Eh4ezrp164iMjOTWW28lLCzMJebNqFQq/vGPf7Bw4ULuueeeNtdw/PhxPvnkExobGxkyZAi//vorXl5eDBo0iGeffZYHH3yQ119/ncGDB5ORkcH8+fN5/vnnycrK4pNPPsHb25shQ4ZgNBp59NFHWbNmDTNnzuT7779n6NChPP7446xatYp169Yxe/ZsKisr+fjjjykvLycrK6vFXAoLCxk1ahTLli1zVaNsFvTmvt5//33WrVuHj48Pn376Kf/9738BuOaaa5gwYQJHjhzhhRdeIC0tjY8++oj333+fhIQEVqxYwa5du1AoFIwbN67FuDExMTz00EMcO3aMu+++m0svvbTNNRuNRrZs2YJGo2HixIksX76cAQMGsHLlSl5//XWGDh3a6nO+4IIL2lzTv//9bx544AGuvvpqPvjgA2pqalq8f6ezY8cObrvtNtfrjz/+mB9++MH1+o477uDmm2/mjTfe4MEHH0SWZdcNxmw2c+ONNzJmzBieffZZ1qxZw5/+9Kc2/xZeeOEFVq1axV//+lcOHz7MlClTePnllwFnHPTOnTvZv38/M2fOZN++fRQXF3P77bcza9YsHnzwQf773/8SGRnJm2++yeLFixk7dix5eXls2rQJm83G1KlTueSSS1zv9fTp0/n73//O5MmTuemmm1i4cCEbNmxg+PDhLf4+P/vsM6Kjo5kyZQo//fQTe/fuJS4ujnfeeYejR48yevRoV/u0tDR27NjR5wS9qt4pwYEnBV2rNFNj7qvVFkNl9q7owe2qg347YvTo0UiSREhICH5+flRWVhISEsK9996Lj48Px44dY9SoURQVFTFq1CgA/P39WbBgAdu3b2fnzp2kpqa2WXXx8OHDfPfdd64qkjabjYqKClauXMlf//pXjEYjkyZN6nQNc+bMYebMmdxwww1s27aNjz76iJycHIKDg3nuueeIj4/HYDCg1WoJCQkhICAAwGXNl5aWMnjwYADGjBnDX//6VwASExNdcbvh4eFtJmYMHToUcFp+ZrOZgQMHMnPmTGbPno3Vam11k+moGmVzX2FhYZjNZn799VcKCgpclmtVVRXZ2dlERETwyiuvoNPpqKurQ6/Xk5uby4ABA9BqtQCtbnxn0t6a4+LiXPXxjx49yqOPPgo4E9/69euHr69vq8+5pqamzTW9+OKL/O1vf+Ott96if//+XH755e3Op6KigpCQENfrG264oc3nNyNGjMBgMKBWq13zV6vVjBkzBoALL7yww2cR27dvZ968ecybN4+6ujqeeeYZXnnlFaZOnUpKSgpqtRqDwUB8fDwajQZ/f3+ampqoqKhAr9cTGRkJwB/+8Aeef/55QkNDSU9PR5Ik1Go1I0eObOUahJafrdFobHEuKCiI6OhoAKKiomhsbOTo0aNMmDABgJSUlBZJieHh4Wzbtq3dNZ6PNDU10WhzfqsK1Ds1Saduoq6xA/dBJ5zTPnSNGpKjZI//dORuAfjpp58AMBqN1NfXo1arWbhwIatXr2bZsmXodDpkWSYlJYV9+/YBUF1dzXXXXQfA5MmTee+993j55ZddRbqa/dz9+vXj+uuvJyMjg48//phrrrkGX19f/vOf/7Bq1So2btzIunXryM/Pd1VzPJ1jx45x++23I8syarUarVaLQqFg2bJlZGRk8M477wB0WgsiPDycgwcPAk5LMSkpqd3rzpzHmW0OHTpEXV0d69ev58033+TPf/5zi/PN1ShXrlzJn/70J8xms+v9OLOv5ORkBgwYwMaNG8nIyODWW28lLS2NJ554gqeeeooVK1aQmpqKLMskJSVx5MgRGhoasNvt/Pzzz91a8+n1p5OTk1mxYgUZGRk8/fTTLtE783Nub01r167lySef5PPPP0eWZTZu3Njm5wjOG2J1dXWHcwbYsGEDPj4+qFQqNmzYAIDVauWXX34B4Pvvv2fAgAHtXv/ss8+yY8cOwJnBnZSU5LoJdvR3EhQURG1trasY3c6dO0lKSiIlJcXlbrFarezZs4fExMRO/05Op61zAwcOdH1Dyc3NpaKiwnWuqqqqxc2vL1BVVQWqYLw0NnQn99vx0VgxN3Vf0M9pC/1s0djYyJVXXkl9fT2vvvoqfn5+XHTRRUyaNAmVSoW/vz+lpaXcdtttbNmyhalTp2Kz2Vo88AkNDeWRRx7hvvvu49///jf9+/dnzpw5LFu2jAceeIDp06dTW1vL7Nmz0Wq1BAQEMHHiRHQ6HZdddhkxMTEMHTqUZ599lpSUFC655BLAeUO44IILmDRpEpIkMXHixG6V23zttddcURRKpZLly5e32zYhIYHDhw/zxhtvtHk+KSmJRYsW8emnnyLLMk8//XSL8+PGjWP27Nns2bMHrVbbYTXKQYMGMW7cOKZOnUpTUxMjRowgMjKSGTNmMHPmTPz9/YmMjKSiooLg4GAeeughJk+eTHBwMN7e3j1e89KlS5k7dy52ux273c6bb75JUlJSq885Ojq6zTWNGDGCm266CV9fX3x8fJg6dSqNjY2u92/evHmuscaOHcuPP/5ITEwM0Nrl4ufnx6JFi3jxxRf54osvcDgcTJs2zfUQ9bXXXqOwsJDo6GgWLFiAyWTi/vvv57333muxpjVr1vDEE0+wYMECNBoN8fHxLFmyhP3793f4fkmSxOuvv84dd9yBQqHA39+fN954g6CgIHbs2MGkSZOwWCxce+21DB06FEmSWLJkCUOGDOmw3/a44447mDdvHtOmTSMmJgadTuc6t3fv3hbPZfoCJpMJ1IEE+J562OvrZaPcpOvgqo45p3csOt8R6zu/6e315efn88wzz7i+VXWF5t2yThe97nAufYbff/899fX1jB8/nuzsbK6//nr279+PzWbjmmuuYcOGDSiVyi71eS6t70y+++47ps3dw+Bxj7PtdafL7sr7D7InU4vxq37d6lNY6ALBWSI2Npa0tDT27dvnsrp/z8THx3P33XezaNEirFarK9R37dq1PPLII10W83Mdp4UeTLD/KZefvx6sctvRSu4gBF0gOIuc+bzBXZr9532JsLAwNm7c2Or47Nmzz8JsnGn5xcXFXHDBBb3Sv8lkQu0dQfBpNQyD/JQ4FH7drol+Tj8UFQgEgrPFvffe225YsCcwmUwotaGukEWAoAAVKP27XRNdCLpAIBCcwdatW/nyyy9dOwr1BlVVVaAJdiUVAYQFqkHpRVl5Tbf6FIIuEAgEp2G325k/fz4Gg8Epur2EyWTCoQhsIegRIc6Ki0VGYaELBAJBj/nXv/5FZmYmTz/9NGazuc0EQU9QWWnCiqGFoEeGOkNvS8rM3epTCLpAIBCcxooVK7jzzjtdpQpqarrn/uiMclMTMioC9K0F3VjRve05haALBALBaZSUlDB48GDXFpq95XYpr3YK+ekWetDJmuhlld2riS4EXSAQCE7icDiorKwkKCiIBnsg+P3BrfIM3cFU5xTv0wVdowbJYaa8unulgoWgCwQCwUmqqqpwOBz4+Ycw7+8xkPxGrwl6tdlZsyVQ3zJZX0n3a6ILQRcIBIKTlJeXA/Cv3YM4lKcCdWCvuFxsNhsNVm+8NNZWxQLVkpnquu7tAyEEXSAQCE5SXl4O/pNYtzWMK9KtSCr/XrHQTSYTqIIweLfebq4nNdGFoAsEAsFJKioqIOElZlxq4Y5JVmSFD5Umz0e5lJaWgjqohf+8Ga8e1EQXgi4QCAQnKS+vQPJKZsJwO34nqzGfqGy9yUtPMRqNoA4mLKh1wTEfrRWzRdOtfoWgCwQCwUmKjHXISl+igmUMvk7rubyqtVukp5SWlqLyiiDEv7UE673sNNq03epXCLpAIBCcJN/oFPHoEAd+3s7fK7oZQtgRZWVlqL3D23S5GHxkLI7uldAV5XMFAoHgJMUVKsBBRJBM08ncnqra7oUQdkRpaSmSJrhVyCJAgB5ssm+3+hWCLhAIBCc5Ua3FS1mLVq1ArQQJR7cjTjrCaDTiUAS0aaEHGhTdrokuXC4CgUBwElODLwadM6pFoQCtqqlXBL3UaMTi8GtRC72ZkAA1qPypq+t6xUUh6AKBQHCSOmsAwfoG12tvjRVzU/dCCDui2FiPA2Wbgh4WqAFJSbGx6+GSQtAFAoEAkGWZBkcwEYGnCmP56mw0WDXIcmvh7ck4ZdXOuuexoa3988010Qu7URNdCLpAIBAAZrMZWR1FTOipY3pvGYfki9ncvfrkbVFTU0OTIgaVwkF0cOsbRVS4M8KlOzXR3Xooeskll6DX6wGIi4vjrrvu4sknn0SlUnHZZZfx5JNP4nA4ePTRRzl48CAajYZly5aRmJjY5QkJBAJBW3zyySdUVlb22qbRZWXloE0hPiLXdczfFziZ/u/j071QwjMxGo2gSyIq2IKydV4RMRHOCJfcgq6XHOhU0BsbG5FlmYyMDNexsWPH8u677xIfH8+MGTM4cOAAeXl5NDY28vXXX/PDDz8wf/58Pvjggy5PSCAQCM7EarUyf/584uPje03Qs/NrQKEhJc7LdSxArwCVgerqaiIjIz0yTmlpKXglkxTZthvH4COhcNRzLL/rGaqdCvrBgwdpaGjg2muvxWaz8eSTT2KxWEhISABg/PjxbN26ldLSUiZOnAjAqFGj2L9/f5cnIxAIBG2xYcMGSkpKCAwM7LUxjuY7dwlKTToVAx7krwKlZ/cWNRqNKHxSSIlp2+MtSeCtLON4adf77lTQvby8uP/++7nzzjvJzs7mhhtucO3kAeDr60teXh61tbX4+fm5jiuVSmw2GypV+0M0NXVvm6XzhcZGz9eAOJcQ6zv/OR/WKMsyy5YtQ6vVUlVVRW1trdvXdmV9R/PM4LBg8GqkttZ5nZ+3D6gMlJb+2qVxOyIvLw/JaxpRgQ3U1rbtJw/wrqbEpGt3zGYX+Jl0KujJyckkJiYiSRLJycn4+fk5Sz+epK6uDoPBgNlspq6uznXc4XB0KOYAWq223Yn1FcT6zm/6+vrg3F/jnj17OHDgAHPnzmXdunVdnq+77cuqtKgcRgwGf9ex0EA1Ck0AFovFY+/Ticp67KoIBiaY0evbcKID0cHF/FQe0OUxO41yee+991iwYAHg3GuvoaEBHx8fcnNzkWWZb775hvT0dC666CK++uorAH744QdSU1O7NBGBQCBoizfeeIP09HTGjRtHbW0tDofnU/EBSqvU6BTlLY4ZfACVv0ddLrnFzn8TI9pfR2KUkiYpHIvF0qW+O7XQ77jjDubNm8fUqVORJInly5ejUCj44x//iN1uZ/z48YwcOZLhw4ezZcsWJk+ejCzL/P3vf+/SRAQCgeBMZFnm66+/ZtGiRfj5OdPha2pq8Pf37/ziLlJe641ebWpxzM9HRlb4eXSTi4IKHRJ2YkLbj21PTfSGHTEczztMSj/3owU7FXSNRsPbb7/d6vimTZtavFYoFPztb39ze2CBQCDojOrqaurr60lISHA9u+stQa9p1BPp2/JJpMFHRpY0lFfWtXNV1zlR64d/aDVqVfsZqCNSA0GhZv/hsi4JukgsEggE5yxFRUUAREVFuYIuemvT5np7EGGGloEafj6er4le3RRCuKHjG8SABB0APx/tWvq/qLYoEAjOWYqLnQ7n8PBwV1RcTY3nt4SzWMFKEJFBLWufN9dEr/RQTfSGhgasyhjiwjq+QRh8QCHXcTTfwz50gUAgOFsUF3snYJkAACAASURBVBcTHByMTqdDo9EgSVKvWOgllRJICmLDWjotDCeTQ00eqoluNBrBK5mU6I5rw0gS6NXl5Jd1zYkiXC4CgeCcpaioyJWhqVAo0Ov1vWKhF59wWuAJUboWx5tdLtX1XatL3h4FRWWgjeWCZK9O2wb71ruKeLmLEHSBQHDOUlxcTFhEPM3FDv38PBtx0szxonqQHcRFtYz71mlApbBR1+AZqTyYVQ+SgsEpndeFiQ6xUWPpWmasEHSBQHDOUlRUzC7LKl77twYAg8HQKxZ6fokZbCbCQoNanfPSWKhr9Ix3etdPRpAdJER03jY5WoVNGdWl9QpBFwgE3eL48eMeTbhpizyjgnpbIP/vfQ1HCxQYDIZesdDzSsxgPUFERGul9dHaabRpe5zQVFhYyBfbSgjyrUHrxp4ZaUm+oI0hOyfP7TGEoAsEgi6xevVqxo4dy9ChQ11Z5L1FSV0UKoWdockO7l+mQ6/vHUEvLrOglmrQarWtzvl5O0DZ828Gzz33HMqwG7jhMl3njYGhA/1BUrH/1/LOG59ECLpAIHCbiooKHnnkEYYMGcKUKVMoKCjotbFqampoUKaREFrD8gca2XdMwQn19b3icikzOfDRtF0oy5n+372Ki5kFCmQZ9u/fz/oNe2hSp3LVGPcs/cRIpzz/csz9omBC0AUCgdvk5OQA8Mwzz3DhhRc6w/B6iZKSEvAdwbBkGykxDm6fZKXYMrZXLPTKWiX+3tY2zwX5K0Fp4MSJE13qs7RS4qJ5PqzfomLRokUkXPgIIQYHowe6F9Pu7wsqaskucD+pSQi6QCBwm+zsbHx8fAgLCyMsLMy5WUMvUVBYDL4j+MNg5wPR+HAHTbJ/r1jodY06ggxtnwv21yBpAlxJTu5SXO4MdXz+XS0HfsnEEXANl4+2tblLUXv4qioorXbPRQNC0AUCQRfIyckhISEBSZIIDw+nqqqq12qq7ztiBpWei1KdESah/jJmm75XLPQGuy8RwW1Hshh8QeMVQmFhYZf6NFZJSJKMqRaK1feSZ4riyj90rYRAgHc1leZ27jRtIARdIBC4TU5ODklJSQCEhYUB9Jrb5UCOGoVsJiXa6XMO9Zdpsumorm3bNdJdrFYrdimA6PC2k3gMPjJKbWCXLfQyk4Jgg8wtYwsh+hF8vexcPKhrJQTCDGbqrCFutxeCLhAI3CYnJ8e1+Xt4eDjQe4KeVeqPQZntclGEBpzM2mxoHYnSE/LyS0HlR1JM25tJ+HnLoDR0WdCNJolQf5kLo3aCpYTpF9nQuBGueDrRwVYapZahlO9+3X5MvBB0gUDgFrIsk52d7RL0oKAglEplr/nRS2qjiNSfEtGwk4JuJcijbp7DWWUA9E9sOyvT4Ctjl3y7YaFLhAXIFBUcI7bqThbO7vo3i6RICVkdSW2981pTLdz/evvlAISgCwQCtzCZTFRXVxMR3Q9w1lYJDQ3tFQvdYoUaRwLJ4af85YF6GYUkgybco370Y7nOTS3ionzbPO/nDRa7F4VF3bDQA2SysrIYGK8myNBxQa62aC6j+8sx54Pgo4UdS7YQdIFA4BbZ2dmg0HHn3yfw6Xbn1/6wsLBeEfRf8xXIkpahyaesWqUSAvU20IR7NNIlt9AZ5x3SzrNHPx8ZGYnSE3XY7e77wI0mBWEBjhbPHbpKWpKz5suhLGeMfGaBEoNP+zcGIegCgcAtcnJy0AUOxdykYOE6DXZ7Lwr6cSs4mhic0tKvHervAHWYZ7eEK21EQSPe7UQHNguoXfbpUix6sw89Ozu724IeHRkETcUcOxmLfqxQQf+Y9hOThKALBAK3yM7OJjj2EjQqmexiBf/ZqSI8PLxXBP1Ibj00FRIdFdnieESQBBrPCnpphQ0vVX2750OaXSWaCLf96LLs9KH76cyUlZWRnJzcrbl5e3ujsOaRW+qMaT9aqKBftBB0gUDQQ3JycvAKGkFqvIObx9t45V8aQkPDe+WhaHahBZoKWhXLCg+SUOgiPepyqaiR8NO1/5A1PFDGWyuj8O3v2hKvM2oboMEiYWtwxq43P0juDl5SKUUVzuSqo4UK+se07/YRgi4QCNwiJycHh64//WMcPDajiWNFCoz2sb1ioReXK1DaS9DrW7pcwgIcKHSRHrPQZVmmql5DgL59q1eSICnKgU/wMLct9DKT06Kur8xGp9MRFRXV7TkatBWcqPGl0QJ5RonFz/+x3bZC0AUCQac0hyzW2qMZEOMgIUJm6oU2Misu4MSJE116WOgOxioN3soKJKnlTkEh/rJHH4pWV1djw0BYYMdSmBzpQOOX5ragG03O/ipKD5GYmIhC0X2pDfKpoaoxgOxiBQ6HRE3JnnbbCkEXCASdYjKZqK5poLzOn/6xTvEeGOvA1BCAw+HocuGqTscz+2DQta4yGBYgY1cEU1XlGQu9oKAA1MFEhXacrJQU5cCuSeySha5VyxQeP9QjdwtAZEATVtmbPb8qUSns0Jjbblsh6AKBoFOys7PBKwWHLDHgZJRFXLiD0mpvAI/60S1WqLf6EuLX2q8d6i8jS1rKqzyT/l9YWAjqYGIjvDtslxzpoF6OotBNH3pzDHpOTvcjXJqJD3c+lP3qRyWB3pVER7e/3ZEQdIFA0CnHjx9H7T8UrVomLswpMPHhMjVmJaj8PepHL66QAAXhAa0LWYUFOG8mZVWeka7CwkIU2rDOXS5RDqwOHQWl7t1IyqqcWaI9CVlsJi5SDXIT2w6o8Ca/w/6EoAsEgk4pLS3FJ2Qk/aIdrtoqCeFOcTWEDfWooBeVO2UpNkxqda65nktFjWf2+MzMPIZDGUCgX8dZnEmRzrWWVuuR5bbbVldXY7FYAKcP3d+7kaqqqh4LelhoCFJTHvWNEnL94Q5DIIWgCwSCTikrK0Phe4HL3QIQESijUcnoQ4Z61OVSVC4hOcxEhbV2g/h5g1KyUGX2TIGurTsPgKQiuBNBD9CDwduCTZ1IRUVFq/NWq5UJEyawaNEiwOlDl6xGJEniggsu6NEcg4ODkc1Ov3lt2d4OffJC0AWC8xiLxcKzzz5Lebn7+052h7KyMiyqZAbEnhJ0pRJiw2Q0hgGetdBPKJAshYSEBLc6J0ngq62nprFjn7c7GI1Gjh131nEJNnS+LVxCuA28+rUZi/7BBx+QZZ/DJzucNxqjSaLelMOAAQMwGNyvZ94WISEh0OjcKaqycJew0AWCvsqhQ4d4/fXXmT17tsdDB0+n1FhJvSOS/rEthS8+zIGkS/SohZ5vdOBoyHcKWRsYvBowW9suddsVduzYgdrb+YAxqBMLHWBAnBK8UloJusVi4eXFryNF3Ueu9QbMZjNGk0R5yUFGjhzZ43meLuiYM4UPXSDoqxw9ehStVsv333/PSy+91GvjFFbokFEy4IwsxfhwB1ZlDGVlZR4bK7fEBk0FBAe3ttABAn0tNNj9ezzO9u3bSU79AwqFjH/bhRZbkBIDSv3AVqGL7777LmWN/ZAlHfgM4aPPj3KiWqIg+wdGjRrV43kGBgZC1Vek+H6NUmokLi6u3bZuCfqJEydIS0vj6NGj5OTkMHXqVKZNm8YjjzyCw+G8Y7/00kuMHz+eyZMn8+OPP/Z4EQKBoHOOHTtG4sBx/O1vf2Px4sVs3bq1V8Y5UR+MUrKTENHSko0Ld1BrC/WohV5YJkFTQbsWerCfHZsU1OVvJIWFhQwZMoSsrCwAtm3bRnzySGdZXjeUMCnSgUMdT17+KQu9qamJJUuWcMHFj5AWb0dty+HtL3xwOCQaqnM9IuhKpZJgr1LsR+8jLi4Otbr9XTI6XYbVauWhhx5Cp3OWInv66aeZP38+X3zxBbIsk5GRwf79+9m5cyebN29m1apVPPbYYz1ehEAg6Jx9v1bwqz6DpKG3kp6ezmeffebxMex2O7WWAIL1ZlRnbHCcEC5T3ehHaVlFu9Ef7XG8VGLOEh3WM6ITjVVqaCps10IPD3QW6DKZTF0aLzMzk7y8PB577DEKCwvJyckhNCqt0weizSRHOZAlNYdzzK5jR44cobi4mHpNOuOH2UkN2sfBskEA+Grq6N+/f5fm2B4hISFuhUB2KugLFixg1qxZru2mDhw4wNixYwGYOHEiW7duZffu3YwfPx5JkoiJicFms/X6QxqBQACZBSpAwZd7VaSkpJCfn+/xMSoqKpA10YS1ERceH+7AISuwSmFtRn90xM6DStZvUfOfHadCEBuaoLZRi7eqAq227UiWpFgf0ISTl5fXpfGMRiNqtZpt27bx6KOP4u3tTWFNHKnxnT8QhVNhmtnFp+5qOTk5aHyiySz0YvwwG9eObUDGaUEPuyCqRyn/p9P8baUzQe8wmPP9998nODiYCRMmsHTpUsBZ06G5voKvry81NTXU1tY6/TwnaT7e3h22maamps5Xch7TW7uhnyuI9Z1dbDYbxSY9GOCrHySmhYexc+dOamtbp8y3hztrzM3NBW00EYF2amsbWpwL8pEAH9AlkpWV1a4It8XRfOeDzWWfKpky3IQkQW6JEtDj71XX7jqiQ7Wg9ufgwf+QkpLS4Rinry8/P5+4uDguvvhi1qxZQ/rF09n2s5plfzJRW+veZ+3vJVNS5NQ3SZI4fPgwgYk3YFLLpMVWEaRM4C/rtoPPIIaNGtClz6LDcf2dzwyioqKora1tVbSsmQ4F/b333kOSJLZs2cIvv/zC3LlzW9RsqKurw2AwoNfrqaura3W8M7RabbsT6yuI9Z3fnMvry87OxqFNxltr5+ccDTNHDqKw8HV8fX1bFbXqiM7WWF9fD5po+sV5ode3FGy9HoL9HJTrEqmqqurS+1Vi0tEvyjn3gwX+/CHNjinHaf1GBtnb7SsxWgGSkuyC9oWt5RydbaqqqggPD+cvf/kLX375JVGD5rI/E64cq8ZH597uzfFhFvZnx2C1WgkKCqKoqAhl8J2kp9kJDdITEjgIv7qHqbFMYcyYMR77+2kuI5yWltZhnx1+H/jiiy/4/PPPycjIYNCgQaxYsYKJEyeyfft2ADZt2kR6ejqjR49m8+bNOBwOCgoKcDgcBAUFeWQhAoGgbTIzM8F7ANddbMVLI2NsGkRDQ0OXXR+dYTQakbxiiA9Xtnk+PkLGO2hQlzdRzjdKTB5l5+LBNt7Y4BTUonIJtVRPWHD7cebRIU6f95Fcc7tt2sJoNBIeHo7BYOCHH36gVjeZSSNt+LSzU1FbNIcu5uY6E32yc3KokkYxfpjTHSVJEpdeUAlHbvFIyGIz7rpcuuzgefHFF1m4cCGTJk3CYrFw9dVXM3ToUNLT05k0aRJ33nknixcv7t6sBQKB2xw7dgyl70CGJMPYQXYOl8YCeNyPXmqsQFaFExnctq85IdyBWt+/y4KeZ1QQH+5g3tUWMnar+OdXan7MVKKlrEN3bYhBRilZyS1xz/fdTInRRKF0K1V1YMOHb/epuGZs6+cCHTEoWYfk3c8l6McK7NRb/blk8KmImylTpjBixAiPGrWhoaFotVqio6M7bOd2QYSMjAzX759//nmr80899RRPPfVUF6YoEAh6wqEj+diVofSLMmO321i83he1Rkt+fj7Dhw/32Di5xU0gKYgKbjsaJC7cgayN75KgN1qgpFJBXJiDicPtXPUHG0+8paXBImGw5bUbsgigUECAdx2leV1L/88zRVOivJopf7Yz41IbCgVMGtE1QU+OciBrYsjKKaSmpobKxiiUCgepcaduLrfddhu33XZbl/rtjGuvvZaEhASUyra/JTUjEosEgvOUX7Kdlf/6RTuYOMJGebWC0ITJHrfQC8ucQt6eoMeHO2gkkuLiErf7zDc6pScuzBkD/s6TjRSur+P7N+rxLnq404CKiEArtRZ/GhoaOmx3OpVmP3RqC95aeP5dLROG29B3sYJAUqQDJAW/ZJmdVrp3GvGhFjTuueC7jV6v5+KLL+60nRB0geA8RJZljhu1aFRWIoNkkiJlYkMdaMKudG7a4EFKKtUoJUu76fFJETIWhzcFpe6La57R+dA2NrRlbZiUaDtVJ451aKEDJEQqQRvH8ePH3Rqvrq6OJiKICjSzcaGZ2dMt3H9t12uqx4XJSNjJKlKQk5ODQj+YwcnnjoyeOzMRCARuc+LECRqIITa4AUlyFq0aNcCO3Wuwxy30ijodftpa2gucSY5yinJJlfsRHXlGBWEBDrzO8JrU19fT0NDQqYU+IN4LdHEuX3ZnlJWVgS6B2FA7PjpYfG8To1O7XvtGrYJAnxpKTD7k5OSgMgwjNb5rCVW9iRB0geA85OjRo+DVn4Hxp3yqafEO6uQEjwt6TZOBIH371newQcZHa8UsR7sdd+18INpaCJsTEjsT9PgICcnLfUE3Go2gi6dfTM/rqMeGNFFrC+fng5lYVfEt/OdnGyHoAsF5yLFjx1DqU0lLPCVQqXF2TA1B5BWc6HIafnvYbDYaHcFEtJEl2owkOeOz8epHSYl7fvQ8o0RcWGshbM5z6czlEhMqIyv8yMx2r2yvU9ATSInVuNW+IwbEKsArmW93lyCjJDWu96pcdhUh6ALBecjxvAIc2iT6RZ0SxbR4BzISZuK6XOekPcrLy0EbRXRox4lK/WMV4JXSYaTLj0cVWE66rY+XKohtR9AlSWqRed4WMSHOazOPu5fhWVBcAZrwNr8VdJUh/b3BK4UaWwwapdW1Jd+5gBB0geA85Fh+E7KkdfmvwZlwo/eyg88gj7ldysrKQBtDUnTHlu3AeAUK34Ftbv4AsOMXJRMe9WHZp85+8oyKNi308vJyAgMDUak6do1EBsmATL7RPTHNKnDeSdoas6sMiFWAJgL80okLqXOrUuNvxTk0FYFA4C55Zc6niacLuiRBWryM5Duky4Wr2qOo5ASow0iJ6zi+LznSgaxNpKi4dRndhiZ4YJkOP2+ZNV+oqayB6nqpTcu2vLy8U3cLgEYNAd5mjNU6t8ro5p0Mk4wJ7bk1nXhyf1GCriY1vsfdeRQh6AKBB8nPzyc9Pb3Xq42WVhsw6Kpbpa2nxTvQBo7wmIWelVcPkoL4yI4t5qQoB7Kk4Wh+64J7L32gobJWYsMLZoorJf6R4bTS48Lsrd6nsrKOs0RPJyrYjkMd3e63gtMpMenwVprQ9dyFTnSwjEKygjaKUaldqBvwGyAEXSDwIAcOHODXX3/lk08+6bUxZFmmqimYyID6VufSEhzYdakei0XPLXE+DI1uJ+2/maSTVmtuScsMmyP5CpZ9qmHhHxsZ1s/B1FE2ln2iQaWUOXbwW9LS0lyCLMsyW7ZsIS0tza25JUapQNt+pMu27buorKwEoLxOT4B3tVv9doZCAaG+zr7SzqGQRRCCLhB4lGbLeP369b02hslkwq5JdNXnPp3UOAdWAjiWV+ORsQqMMgq5iYBOQsx9dKDXVFFS1XIvtx2/KAnyk7n5MueNYfZ0K/WNEtEhMplHDtPU1MTbb78NwK5duzhy5AgzZ850a26JkUqUPoltJheVm6xc/XwK9z2/H4A6azDh/p4rhzwyzVlN1t1a6r8VQtAFAg+Sn5+PwWBg7969rq3OPE1RURHokhkY39oNMvBkCF12qU+X+925cydXXnlli1jykkoVXsqKdpOKTifCUEtlY0v/d1axgn5RDtf1lw61kxjhIC7MQW5uLpIksWbNGsxms7NGeXo6AwcOdGu+MaEyki6uTffSo6/XImsT2J03CIvFQpMUQWxo1+q2dERSlINAvYNQf2GhCwR9lvz8fKZPn05MTEyvWen5BSWgi3OGz52BwQcCfWox1oZ0ORZ94zfZbC++iTl/egZZltm6dSuHsqoJD3RPCOPDLTQS02LjmqxCBf2iT1mxCgW8fn8jj9xoITc3l2uuuQar1cry5cvZsGEDd999t9vzjQl1YFMEk5vXMvb95xwFn+2NQVe5GptuCG+v2w66BJKje55U1MztE628fE+TWze63xIh6AKBB8nPzyc+Pp4ZM2awfv16jyX4nM4vWWaQlPSPbbvyXnJEA02qFKqru+Yz/j47GiLv5YvS/8eMeeuZ8fAOvKJvZvSQcLeudybc9GuxYXRWsYLkyJZuibGD7IwbYicnJ4dhw4Zx6623snDhQgwGA1deeaXb8405WRc9u+DUDcThgMfe1OHr2Mft6T+gthfx2norqPwZmOC5B5j9omVuGOc5i99TCEEXCDyELMsUFBQQGxvLjBkzOH78OHv27PH4OJl5NpAd7cZUD06SwPuCLocuFlcFEOW1j5GJxXxdOBt71NPcNNGHp2+3uHX90P7eoIsjJ88p6E1WyC+TSI5uPU+r1Up+fj4JCQncc889yLLM7bff3qUt7KJPJhcVnDglY7t/VbLniJL6A3czfvyljIrPxsgVAAzp3/kuauc7QtAFAg9RXV1NTU0NsbGx9O/fn/79+/PNN994fJzjRjVeihPthuBdmOYF3qkcP961SBeTJYqE4BN8/UYSL9/4H468U8ff/mRtt2zumQw96QL66bDzgWxuiQKHQ2ploQMUFhZit9tJTEwkOTmZdevW8dBDD3Vpvnpv8NU1UWk2uNw8+7MUBPqYkRoOM2bMGObdGABKL5CtxEd4zuVyriIEXSDwEM0WcWysc+egQYMGcfjwYY+PY6zWE+hV2e75tAQJlF7sz3Q/0sVihSZFLP1jbEiSxJw7JxAc2LX9MGPDQJIb+SnT6Yo4VqRAqZDbTLfPyckBID4+HoDp06e7NkLuCgOim8B3OIWFhQD8nKPEV8pixIgRGAwGxo0MwstxDLWjlE72hugTCEEXCDxEfn4+KpXKtaHvwIEDe0XQTU3BRLQRg95MvygHkmzj8HH3+zyUYwFJzdDk7luxKiUEa45yqNCZGJRd5KyoqFbBoUOHuOOOOzhy5AjgFPTw8HB8fLoejXM6o9MUoB/linT5OUdBXekOxo0b52rzx6kmxvb3bI34cxUh6AKBh8jPzycqKspVhyQ1NZWcnBzM5q5tZtwRsizTSDQJ4e2nu2vUoFcbyTW6vx3P7l/qwN7AsNSuW8mn0z+siGJzf8BpoSdH2lm4cCGXXnopGRkZfPDBB4BT0BMSEno0FsDoNCX4DCYrt4hGCxzNV1CZv5nLLrvM1ea5+wfy6d8G9Xis8wEh6AKBh8jPz3e5W8Ap6LIsO2uXe4iy8mpkTQwD2ohBP50IQyXGOvdS6AH2ZVqg4VdioiN7NL/0gY1YFFEcL4HsIgkaj7F06VJefvll7rvvPjZv3gxAbm4uiYmJPRoLYESKHSQVPx5xcCRfgc0hobEeZuTIkT3u+3xECLpA4CHOFPTY2Fj0ej2HDh3y2Bg/HqwEScGwAb4dtkuKaKTWHud2v5mFalSWoxgMPYsEuWyUH9hqyNjVwLEiBU1VPzNkyBDuuusuJk6cyMGDByktLSU3N9cjFnpEkIxOUcGvhXp+zlaiUdQzPC0IjcYDRVvOQ4SgCwQe4kxBlyTJ4370A8fMINsZkdZxvfDBiQoc2mROlFe51W9BhR5/TWGP55fSLxGqt/HpNgUVNQrKC75jyJAhAIwePRpvb282bdrE8ePHPWKhA0TpCymsiuDnHAVqy2FGX3SRR/o9HxGCLhB4gNNj0E8nNTXVo4KemedAYS3EoO84SeaiQXpQaPhuf8tqhrIMOw8q+ctaDVc87cWxIhXmRqhsCCDS0PNNMYKCgtA1fcePOUEAHD/8pUvQtVotF198Me+//z5NTU0eE/T+UTVUOfqx7xiYy3Zy4YUXeqTf8xEh6AKBBzg9Bv10PC3ox40qvKX2dwVqZvTQYHA0sfdwyweyH21VcflT3ny1V0VppYKnVhk4WqgAFCRF9Lx4lSRJxAfkIiPhrbVTV3mMoUOHus6PHz+e7777DjgVsthTRvaXsavjOZCtRK7dJwRdIBD0jDNj0JtJTU3FaDRSUVHR4zFqzZBvCiPAq/O+vHRq1NZsDp5RWXZvppI/pNnYtdzMO082sPeohr+8o0Uh19Mvxv0szY4YlAAaqYYQXxMajaZFsa2JEycCEBgY2K2487YYN9wHZAc2h5LogHK366n3RYSgCwQe4MwY9GZSU1MBemSlyzL833cqRt/nQ63FwJCIn926zk9dxPGylqGLWUUK+sc4MzfT4h3MnlbPlv0qpIbDREdHdXuOp5OUlIBXw7foOUpaWhpq9aka6YmJicTFxXnM3QIwoF8UmA+Do5Gxw3+/Yg5C0AUCj3BmDHozgYGBhIeHd0vQ33vvfQb84VEunGPljv/nRajqR6zf9eOKSzrfog0g0lCJsa5l26OFCte2dUVFRTx8fS2RQXbs1T8RFeUpQU+i6eCd+FcsaOFuAadLZtasWUydOtUjYwH4+PigtR6AugOkjx7lsX7PR4SgCwQe4Pjx463cLc1014/+zlcaSgNXcOyXb0gwXc+hDZew/NXnufnmm926PimiiXp7OI0na2uZG6HwhIKUaAebNm0iLS2Nbzf9H2/ffwSOL/CYoCcnJ9PYUMf3u3e1EnSABx98kMcee8wjYzWTon4HMm//XfvPQQi6QOAR8vLy2o2r7q6g55SHE284xL9fVJEQWsPGjRu5/fbb3b5+UJIEkorMAud/86xi579hflXcf//9eHl5sXLlSqx1uWCrJDKyZ0lFzTS7U6xWqyvCpbdJitXjpymnf//+v8l45ypC0AUCD5Cbm+uK2qisAdtpmfkDBgwgMzOzy7XRq5pCSYqwMmHCBD755JMuW58jUgPAWs6OA1bA6T/XqmVef+UxlEol//rXv/jpp5/47LPP8PPzw8/Pr0v9t4fBYCAkJAS1Wu327kM9ZezYsdxwww0oFL9vSeu0Eo/dbueBBx4gKysLSZJYunQpOp2OefPmuRInFi9ejEKh4KWXXuKrr75CpVKxcOFCRowY8VusQSA4q9jtdpeF/nOOgkse9EGtkokPc7DsgSYGDBhATU0NpaWlrR6atkd5eQV2dRKDkjrf0b494uJioWYXosHqxgAAIABJREFUW35K577rlBwtVBDmV8vHH33Ihg0bGDduHKNGjWLt2rX069ev2+O0RVJSEg0NDV2qb94TZs+e/ZuMc67T6e3siy++AODLL79k/vz5PP/88zz99NPMnz+fL774AlmWycjIYP/+/ezcuZPNmzezatUqj/vIBILuYLPZeqXi4ekUFxdjsVhISEhgz69KgvwcvP1YI34+8OZnalJSUgDIzMx0u889+46DOoDRQwK6Pa+YmBiU9d/xU5YX4NwOTmPPYfjw4a5qhHfffTd2u91j/vNmrrrqKm666SaP9inonE4F/YorruC1114DoKCgAIPBwIEDBxg7dizgjCvdunUru3fvZvz48UiSRExMDDabjfLy8o66Fgh6nc8//5wxY8awc+fOXhsjN9cZ7B0fH8+BbAXDkh1cPcbG/0y2svknFVovP6KiolylY91h98/Oeuej0rrvBlGpVMQHFFJR70tBmcTRQgX22l9JS0tztZkyZQoxMTFER0d3e5y2mDdvHvPmzfNon4LOcav4sUqlYu7cuWRkZPDOO++wZcsWpJO7o/r6+lJTU0NtbS2BgafqSzQf7yjI//TNZPsijY09z7w7lzkf1rd//35kWebee+/lyy+/xNe346JWp+Pu+o4cOYK/vz9KpZJ9x+DSIQ3U1tYyNk1BfWMYX+62kJSUxMGDB6mtrXVv3pmNKOUqNAozbl7SJoMSbOSWN/Htj1aOFXmjKfqOpEuTXPOw2WysXbsWX9//396dx1VdpQ8c/1xAUBNEXEdcMFBZREFcILdUUBAFc89tFM0ts3Is0yabrHAZ917tMeaQY5pLYogKiEqKpQS4IRIKLvlTUVEQ9HK59/cHwx2J7V64gF6f91/T937v+Z5nxMfD+Z5zngY69+1p8jT8jFaGpWXpxUd0Ps3+iy++4MaNGwwcOJC8vDzt9ZycHBo2bIilpSU5OTklrpfHwsKizI4ZC4mvdl26dIl+/fqRnJzMypUrWbt2rV7f1yW+69ev8/zzz2Ne15KUq3V4++UCLC0tsbSEHo5qYk5Z4uzsTFJSks7/f13OrEcjixtYWlZt5Ym7mwsRPyUQfqIbeY9MyLv+C+7u7xXrh7G/63rSf0YNqcIpl++//541a9YAUK9ePUxMTHB3dyc2NhaAqKgovLy88PT0JDo6GrVazZUrV1Cr1TRu3Lh6ey9EBVJSUvD09GT9+vVs3LixWoo2Fx0Fm5xhQr5KQRf7/y1xGdJTRcSvZnTo6Mj58+d1XulyM7sRrRpXvTCGs7Mzj25GE3nyv/XX8lK0u1eF8akwoQ8bNoxTp07h5+fHyJEjWbZsGatWrWLZsmX4+PigVCoJDAzEzc0NLy8vfHx8mDx5MqtWraqJ/gtRJpVKRVpaGo6Ojvj5+eHg4KAdiBhSUUJPSjPFuoGGNs3+l7SH9Mzn/+6YYGLVnbt37+r0Xik/P59cWuNY+j4lvTg7O8P9o6g1CqwscmhqU5emTXXbaSqePhVOuTz33HN8++23Ja7v3bu3xLVFixaxaNEig3RMiKrKyMjg0aNH2lUmnTp1MmixCSg8NvfSpUu0bduWhDQTutgX8N/XSwC0b6WhvW0BF24Xrsc+f/58qQn15l0FS761IHjaQ65fywCLznR1uljl/rVs2RIrzpKNmudMrtJBRudG7dlehS+MWkpKCiYmJjg4OADg4uJi8IR+9+5d7t+/rx2huzmUrPU5xFPFoVMNaNasWZnl6FZtNeX7g3X49Eczjsb/HyhM6d216lOWCoUCF8fWNK57FXXOWZluMXKS0IXRunDhAu3atdNubnFxcSE1NdWgKx+Kliy2atOOM5dM6GKvLnGPb/cCzmWY0rZjv1KXLmZcz+ebcFPI/pVPdqg5djofNPm0b12nxL2V4eLigl3eWzxIflsSupGThC6M1vnz57XTLVCY2NRqtV7rwSty6dIlLCwsyFbZ8ii/+AvRIt0dC2hkqaFO8+ElNhfl5eUxdPYRUP7B4oCjKB89IizJg+dMrlNH5zVo5XN2dubUr2Hk3E0vtgZdGB9J6MJoXbhwAUdHR+1/FxVtPnPmjMGeUXSGy6mLZljW09CuRclVLGam4OOh4rbGs0RCX7H2O67k+/L2OBVvz5+Ob5c01HVsaWapWy1QXTg5OaFUKlEoFM/84VXGThK6MEoajYYLFy4UG6ErFAqDz6Onp6djZ2fHz6fNcGtfQFlnQ/n2UJF2uzU3buVw9+7/anfuS2pNfbP7/G1ScwA+e9cRC7N8XuzRwmB9LDogy87Ojueee85g7YonjyR0UStu3LjB8OHDtaXbDO3atWvk5OSUGJEaeqXLpUuXsG3jSNgxM0b3VZV53wB3FRqNCTTyKTZKv3qvJfaN07XTKzZW8ONH+bw9sX4ZLenP2tqaVq1ayfz5M0ASuqhxKpWKadOmcejQIX7++edqeUbRapI/nyLo4uLCmTNn9D7KFuDqLQWnkq/z2WefMXLkSFxcXDh27Bg59Yag0cDwPvllfte6AXi5FGD+lxHahK5Wa8hROOLaTlnsXi+XAv7SWP/+lWfixIm89NJLBm1TPHkM9NpFCN0FBweTkJCAnZ1dtZ2EmJKSQqtWrUps+3ZxceHOnTvcuHGDFi30m9aY9sFFfrnogEWWNYNdHJk71xtHR0eCw/sxvLcKqwoG1b49VPxyypfk5H8AEH/2FpjZ06tLPb36URnvvPNOtT9D1D4ZoYsaFRsby5o1a1i/fj39+/ev1oT++Px5kaL55Mq8GLW4uhB36820cJ7O/tvrsXF8jZYOAzmRUoeJPmWPzov4dleRr2jMif8usok+ngVqJd5ezfTuixClkYQuatTWrVvp1asXo0aNwsnJqdoS+qlTp3B1dS1x3dLSEjs7u0rNo58/l8iEATnEf5nLvBFKZq6px6Tguti3VOPlXHK54p852Gpo8twdLmQWbnQ6cV6DmTKZ5k2t9e6LEKWRhC5qjFqtJjIyUlvx3dnZmRs3bnD79m2DPkepVHLmzBnc3d1L/bxoHl0fN2/e5ObNm7i4uGBmCu9OVLLx7Tyu3DRhiq+y2Hb/8rzgeJfsOv24f/8+KX80wMY8Xa9+CFEeSeiixpw6dYobN24waNAgAO0mF0Nvxz937hxKpbLUivMAXbp0ITExUa82i/r4+EqRl/qoSN6Uw6uBFU+3FBnRrw40cOPnE5f5vxxb2jW9o1c/hCiPJHRRY/bv30/btm21c9uNGjXiL3/5i8GnXRISErCxsaFt27alft61a1dSU1O5f/++zm2eOXOGNm3alDjj37oBZa49L82Q3tagyiJkXz1UWOJWys5SISpLErqoMZGRkQwaNEhb7QoKR7yGTui//fYb7u7uxZ7zuKKRe1JSks5tnj171iDb5s3rKLBR/MLhFGdQP8Kr87NTfEFUP0nookZkZmYSHx/P4MGDi113cnIiOTnZoM9KSEgoc/4coEmTJrRu3ZqEhASd2zRUQgdwan4RlcYcHiTh5GhvkDaFAEnoooZERkZSr149bXHxIs7OziQnJ6NWlzylsDJyc3NJTk4uN6FD4bSLrgk9Pz+flJQUOnXqZIgu0s81DzQqyClciy+EoUhCF0DhCpSoqKhK7aDUxb59++jbty9169Ytdt3Z2ZmcnBwuX75skOecOXOGgoKCChO6u7s7v/32W5mf5+fnExcXh0ajITU1FaVSabARururHVz+kL+YRmmP9hXCECShCwB++OEHRo0apffqD11cv36dvXv3MmrUqBKfdezYERMTE4PNoyckJNCiRQtatiy/uLK7uzsZGRncuVP6KpOvvvqKMWPGsGPHDs6ePUu9evV4/vnnDdLHDh06wOWP6NQm2yDtCVFEErpApVKxYsUKAE6fPl3pdpRKZanFI0JCQmjatCmBgYElPqtXrx729vYGS+i//fZbmcsVH9elSxeAUv8Be/ToEZ9++iktWrRgwYIFREVF4eTkhKmpqUH62Lp1a+rXr4+9vcyfC8OShC7YsmUL165do2PHjlVK6C+//DItW7bEw8OD+fPn8+jRI/Ly8ti4cSOvvPIKdeqUXoHH1dW13OmPsnz//ff8+9//LnYtMTGxwukWKDyB0MHBodTnbt26lTt37rBr1y5atGjB1q1bDVoYwsTEhGnTpuHn52ewNoUAOZzrmadUKlm5ciVTpkxBoVDotZTvzxITE5k6dSqtWrViw4YNXL58GR8fH3Jzc5kyZUqZ3/P09GTFihVoNJoylxqWJjQ0lLi4ONq2bUu/fv3YvHkzKSkp9O3bV6fvu7u7l3gxWlBQwPr165k4cSKtWrXiiy++YODAgaUeI1AVH374oUHbEwJkhP7M++6777h16xZvvvkmrq6unDlzplIrTu7cucPt27cZMWIEb775Jnv27CEhIYGFCxfy8ssv06hRozK/6+Xlxe3bt0lNTdXrmRkZGTRq1Ijp06ezZcsWXn/9dd599128vLx0+r6bm1uJhL5nzx7S09N57bXXtPccPHiQCRMm6NU3IWqDJPRn2MOHD1m9ejXTp0+nRYsWdOrUiezs7EqtOClKxkXnj3fq1Inw8HD69u3L3Llzy/2us7MzVlZWHD9+XOfnKZVKrl27xsqVK2natCmzZ89m/PjxLFiwQOc2PDw8+OOPP7h27Zr22g8//MCQIUOK7TLt0qWLVPoRTwVJ6M+wTZs2kZWVxRtvvAGAo6MjZmZmnDp1Su+2UlNTsbKyomnTptprjo6OhIWFVbg6xNTUlB49ehAXF6fz865evYpGo8HJyYnNmzezePFiVq9erdeUjbu7OxYWFtp/SDQaDcePH9d5ykaIJ40k9GdUbm4ua9asYebMmTRp0gQACwuLSr8Y/f3332nfvr1eCfVxXl5eeiX09PR0oLDwc7t27Xj77bfLfOlaFgsLC7p27apN6Kmpqdy+fRtPT0+92hHiSSEJ/RkVEhJCbm5uiemQTp06Var4w4ULF0qUe9OHp6cn6enpXL9+Xaf7MzIyaNq0KQ0aNKj0M6HwH5Jjx44BcPz4caysrKT2pnhqSUJ/Rn377bdMnz4dGxubYtddXV2rNEKvLA8PD8zNzfnll190uj89Pb3M0xT14eXlxblz58jKyiIuLo6ePXsabL25EDVNEvozKCcnh7S0tFJXg7i6unL16lXu3r2rc3v5+flcunQJBweHSvepbt26uLu76zztkpGRYZBzULp37w7AiRMniIuLk+kW8VSThP4MOn++sKhlaVMLReut9Zl2ycjIID8/v9QanvrQZx7dUCN0a2trXFxc2LVrF+np6ToveRTiSSQJ/Rl07tw5rKyssLW1LfGZjY0Ntra2em0wSk1NxcTEpMpnnXTv3p2zZ8+Sl5dX4b0ZGRkGSehQ+A/Jtm3bMDc3p2vXrgZpU4jaIAn9GXTu3DlcXFzKXJHSt29fIiIidG7v999/p02bNlU+OdDNzY2CgoIKfzu4d+8ed+/eNVhC9/T0RKVS0bVr1xKnQQrxNCk3oefn5zNjxgz8/PwYMGAAe/fu5eLFi/j6+uLn58f8+fO1uwqXL1/OgAEDGDRoEPHx8TXSeVE5586dK3clx4gRIzh27JjOK05SU1Or9EK0SMuWLWnatGmJ3w6uXLnCggULGD58OAUFBWRkZAAY7CzxonlzmT8XT7tyE/rWrVuxsbEhIiKCHTt28Pbbb7N48WLeffddIiIi0Gg0hIeHk5iYyNGjR4mOjiYkJESv3Xqi5lWU0F988UWsra3ZvXu3Tu0ZKqErFIoSBZy//PJLunbtSlRUFIcPH+bQoUNkZGRgampa6pRRZdja2jJlyhRGjhxpkPaEqC3lHs41fPhw7ZGnGo0GU1NTkpKStFVnvL29iYmJwcHBgQEDBqBQKGjdujUqlYrMzEzthpWyPHr0yEBhPJlKO0q2ImvWrGH9+vVA4Xz2wYMHyz0HRV+3bt0iMzMTOzs7srPLPo/b19eX7du3l3uGSVF8Fy5cICAgoNz2dOXk5ER0dDTZ2dloNBrWrFnD5MmT+fvf/87kyZPZuHEjbm5u2Nra6jTXrquiw7Iej6Eyf35PG2OP0Vjjs7QsvRZtuQm9aNNGdna29i/Ve++9p517bdCgAffv3yc7O7vYeuai6xUldAsLizI7Ziz0iU+j0bBr1y7Gjh3LkCFDmDdvHmFhYRWehaKPoukwDw+Pcvs2btw4AgMDycrKonXr1trrubm5REVFERYWRmJiIgqFgtu3b9OpUyeD/Fn26NGDzz//nDp16nDhwgVu3LjBtGnTaNSoEVOmTGHWrFmYm5vTrl27GvnZMfafTzD+GI09vsdV+FL06tWrDBs2jLFjxzJ69GhMTP73lZycHBo2bIilpSU5OTklrgv9pKamkp6ezowZMxg2bBjjx49n48aNla63uX79+hIFHM6ePYutrS3W1tblfrdXr140bdqUH3/8sdj1cePGERQUxN27dxk5ciSTJk1i5cqVBpt/7tKlCyqVinPnznHgwAFatWqFk5MTAP7+/tSvX58ff/zRYC9EhTAm5Sb0mzdvMmLECD744AMmTZoEFK5Tjo2NBSAqKgovLy88PT2Jjo5GrVZz5coV1Go1jRs3rv7eG5n9+/fTrFkzbTWdoKAg0tLSOHLkiN5tJSUl8f777/P6668XqxNa0fx5ETMzMwIDA9m5c6f2WmZmJrGxsWzevJkdO3Ywd+5c5s2bx4wZM/Q+R6UsrVu3xsbGhsTERA4cOMDgwYO1vxHWrVuXMWPGoFarpbiyEKUoN6GvXr2arKwsVq5cib+/P/7+/vz9739n2bJl+Pj4oFQqCQwMxM3NDS8vL3x8fJg8eTKrVq2qqf4blcjISHx8fLS/Bdnb2/Piiy8SEhKid1vr1q3D3t6e06dPEx4err2enJys81klgYGBJCQkaI/TjYmJwcLColpPI1QoFNozyE+cOMGgQYOKfV40py8jdCFKUmRlZVVPmXcdZGdnG/X8lj7x3b9/n+eff56QkJBitTd3795NUFAQp0+frrDwcZG0tDS6d+9OaGgou3fv5syZM/z8888AtGrVirVr1zJ27NgK2ykoKKBjx47Mnz+fOXPmMGvWLG7evKkdtVfXn98HH3zAunXrsLCw4OLFi9SvX1/7mUaj4fvvv2fo0KHV/rNj7D+fYPwxGnt8fyYbi54QMTExQOGSwccNGTKExo0bs2PHDp3b2rBhAx06dMDPz4+FCxeSkpLCsmXLeO2118jNzdW5PqapqSlDhgxhz549qNVqDh48yMCBA3XuR2W5ubmh0Wjo27dvsWQOhSP4l19++Zn6SyqEriShPyEOHDiAl5dXiZfJderUwdvbm+joaJ3auXz5Mlu2bOGNN97AxMQEe3t7xo8fzz//+U9+//131q5dq1fB44CAAI4fP87Bgwe5efNmjST0oncIPj4+1f4sIYyJJPQaotFo6NevH1FRUSU+S0tLIzw8nMGDB5f63YEDBxIXF0dubm65z1Cr1bz22mu0b9++2CaZVatWkZqayv79+5k6dapeRSj69u2LpaUlCxcuxNbWlo4dO+r83cpq27YtK1asYMyYMdX+LCGMiST0GpKWlkZSUhIbNmwodv3ChQv4+/vj5OTElClTSv1u//79USqVHD16tNxnhISEcOzYMb744otiq04sLCyKlYbTh7m5Ob6+vqSlpTFw4MBKVyTSh0KhYObMmbL0VQg9SUKvIb/++isAR44c0RZUTk9PZ+jQoTg4OLB9+/Yyq+/Y2Nhot7+XJS0tjffff5933nlHewSuoQQEBADUyHSLEKLyJKFXYMmSJdjb22Nvb4+vr2+ltxKfPHmS3r174+DgwMaNGykoKGDWrFnY2tqybdu2CqvKDxgwgIMHD5bZtr+/P66urrz++uuV6l95fHx8WLhwocxpC/GEk4RejoKCAkJDQ/H39+f999/n9OnTbNy4sVJtnThxgh49ejBlyhT+85//sHr1ahITE/nyyy9LrOQojbe3N6mpqdqTBots374df39/unXrxo4dOzAzK/c0h0qxsLBg0aJFOvVTCFF7JKGX48SJE9y9e5e//e1vTJ48mVmzZrF27doKX07+2YMHDzh79izdunVjwoQJPHz4kODgYN577z2dq/x4eHhgZWVVbJSel5fHvHnzmDZtGv/+97+rXDBZCPF0k4RejgMHDuDo6KjdlTh37lwePnzIN998o1c7CQkJqNVqunXrRqNGjfjrX/+Kj48Ps2fP1rkNMzMz+vfvz4EDB7TXjhw5wsOHD5k/f36xM3aEEM8myQLlOHDgQLF540aNGjF79mzWrVun11GxJ0+epG3btjRr1gwoLAaybds2vZPw8OHDiYqKIjMzE4C9e/fSs2fPCk+1FEI8GyShl+HatWucOXOmxFkic+bM4eHDh/z00086t3XixAltdXkoXJZXmeV/Q4YMoUGDBmzbtg21Ws2+ffsYMmSI3u0IIYyTJPQyREZGYmVlVeJY2IYNG9KjRw+OHTumUzsajYaTJ0/SrVu3KvfJwsKC0aNH89133xEfH8+NGzfw8/OrcrtCCOMgCb0M+/fvp3///qUeC/vCCy9UuMmnyJUrV7hx40axEXpVTJw4kXPnzhEcHEyHDh1wcHAwSLtCiKffU5fQDx48yNKlS1m6dKnONS/1pVQqOXLkSInpliK9evXi4sWLFRZRzszMZObMmTRp0sRgm306d+5M586diYmJkdG5EKKYpyqh37lzh0mTJrF3714iIyOZOnWqdtelIZ08eZIHDx7Qv3//Uj/38PDAwsKi3FF6UlIS/v7+ZGZmsm/fPszNzQ3Wv6JiIzJ/LoR43FOV0L/66ivq169PTEwMhw8fxtnZmZUrVxr8OUeOHMHBwaHM88fr1q1Lt27dykzoO3fuxNfXFycnJ6Kiogw+LVJ0eqKhpnGEEMbhqUnoOTk5fPnll8yePZt69ephYmLC4sWL2b59O8nJyXq39+DBA0aPHq09h/xxsbGxFVbl6dWrV6kJffny5QQFBTF79mxCQkKq5YCp5557jldeeUXWngshinlqMsKmTZsoKChg2rRp2mt+fn64ubmxfPlyvdvbsWMHkZGRjBs3jsjISO31vLw8Tpw4QZ8+fcr9fq9evbhw4QK3bt3SXrt9+zbLly9n9erVLFmyBFNTU737JYQQlfVUJHSlUsmnn37KtGnTio14FQoFixcvZvfu3Zw/f17n9jQaDSEhIUycOJFJkyYxYcIE7UmGv/76K0qlkt69e5fbRvfu3alTp06x5YvHjx/H1NRUp/JuQghhaE9MQler1YSFhZGVlVXis127dpGZmVnqVnlvb2/s7e3ZsmWLzs9KSEggKSmJ6dOn889//pMxY8bw6quvcu/ePY4cOYKzs3OF54fXr18fDw8Pba1OKEzonTt3ljNVhBC14olJ6D/99BOTJ0+mc+fOfPjhh9y7dw8oHE1/9tlnjB49Wrt1/nEKhYIxY8bwww8/oFardXpWSEgIXbt2xc3NDYVCQXBwMAqFgo8++ojY2NgKR+dFBg4cSEREBBpNYZ3tuLg4vLy8dIxYCCEM64lJ6J9//jlDhgxh4cKFhIaGMn78eFQqFXFxcSQlJTFr1qwyvzt27Fj++OOPYqPlsmRlZbFz506mTp2qvWZlZUVwcDAhISHEx8dX+EK0SEBAAFevXiUhIYHc3FwSExNL7CwVQoiaYvjDsyshMTGRuLg4Dhw4QI8ePfD29mbAgAF8/PHHpKam0qdPn3I35tjZ2dGzZ0+2bt1aYTIOCQnB3Ny8WM1NgJdeeonQ0FAOHTqk8wi9Y8eOdOjQgT179pCTk4NKpZIRuhCi1jwRCf2zzz7Dw8NDu666Y8eObNiwgWnTpqFQKNi8eXOFbYwZM4Z//OMfrFq1inr16pV6z61bt1i3bh1vvfVWiWINCoWCTz75hIMHD2Jtba1z3wMCAti1axd169bFwcGh0rU7hRCiqmp9yuX69evs2rWL2bNnFzuBcOTIkcyZMwdnZ2cGDx5cYTsvvfQSDx8+JCIioth1lUql/d/Lli2jUaNGzJgxo9Q2WrVqxeTJk/Xq/7Bhw0hLS2Pz5s0y3SKEqFW1OkJXKpUsWLCAZs2aERgYWOLz4OBgCgoKdFrPbWNjw+DBgwkNDWXEiBFA4cFYnp6e9O7dm1GjRrFp0ya++uor6tata7AYOnfuTJs2bbh8+bJMtwghalWtjtBnzZpFbGwsmzZtKvVUQ0CvzTlBQUHExMRw8eJFAL7++musra3JycnhlVdewd3dXZvsDUWhUBAQEAAgCV0IUatqdYT+66+/EhYWhpubm0Hae/HFF2nXrh0bN25k4cKFbNq0ibfeeou5c+cSHx9PixYtKlVYoiJTp07lwYMHtGvXzuBtCyGErmo1oW/dutVgyRzAxMSEqVOnsm7dOpo3b05BQYH2ZEIPDw+DPefP7O3tWbt2bbW1L4QQuqjVKRcXFxeDtzlhwgQePHjABx98wIQJE6rlcCwhhHgS6ZTQT548ib+/PwAXL17E19cXPz8/5s+fr92duXz5cgYMGMCgQYOIj4+vvh5XoHHjxgQGBqJSqcrdjCSEEMamwimX9evXs3XrVu267cWLF/Puu+/Sp08f3nzzTcLDw2ndujVHjx4lOjqaq1evMnny5FKPpa0pixcvpm/fvjKnLYR4plSY0O3s7AgNDWXmzJlAYSWeop2U3t7exMTE4ODgwIABA1AoFLRu3RqVSkVmZiZNmjQpt+1Hjx4ZIISSikbp2dnZ1dK+rh4+fFirz69uEt/Tz9hjNNb4LC0tS71eYUIPDAwkIyND+98ajUa7UqRBgwbcv3+f7OxsbGxstPcUXa8ooVtYWJTZMWMh8T3djD0+MP4YjT2+x+n9UvTxKjk5OTk0bNgQS0tLcnJySlwXQghRc/RO6K6ursTGxgIQFRWFl5cXnp6eREdHo1aruXLlCmq1msaNGxu8s0IIIcqm9zr0jz/+mHnz5rEjoE5cAAAGz0lEQVR06VI6dOhAYGAgpqameHl54ePjg1qtZtWqVdXRVyGEEOVQZGVlaWrr4dnZ2UY9vyXxPd2MPT4w/hiNPb4/q/XTFoUQQhiGJHQhhDASktCFEMJI1OocuhBCCMOREboQQhgJSehCCGEkJKELIYSRkIQuhBBGQhK6EEIYCUnoQghhJCShCyGEkai2hP542brExEQGDBiAn58fb731lrZsHUBubi69e/cmKioKgPT0dPz8/PDz82PGjBnk5uZWVxerRJf4Xn75ZQYPHoy/vz+jRo0q9v1Fixbxr3/9q8b7ravKxnf+/Hl8fX0ZPHgws2fPRqVS1VoM5alsfElJSTg5OeHv74+/vz87d+6stRgqUtkYg4KCtPG5uroSFBRUazGUp7LxlZePnnbVktDXr1/PvHnztBWJ3njjDZYtW0ZERAQNGzbkhx9+0N67YMECbcEMgCVLlhAUFERERAS9e/fm008/rY4uVomu8V28eJF9+/YRHh7O9u3bAcjMzGTUqFFERETUWv8rUpX4li5dynvvvcf+/fsBnsg4qxJfUlISc+bMITw8nPDwcEaMGFFrcZSnKjH+61//Ijw8nM2bN9OwYUOCg4NrLY6yVCW+8vLR065aEnpR2boif/zxBz179gSgZ8+eHD9+HIBPPvmEnj170qlTJ+29KSkp+Pj4lLj3SaJLfDdv3uTevXuMGzcOX19f9u3bBxQW/3jnnXcYO3ZsrfRdF1WJLzQ0lF69eqFUKrl58yZWVla1EkN5qhJfYmIiBw4cwM/Pj7lz59Z6mcOyVCXGIsHBwcyYMYMWLVrUaN91UZX4yspHxqBaEnpgYCBmZv87at3Ozo6ff/4ZgH379vHgwQMOHz5MWloaf/3rX4t919XVlb179wKFo7snccpFl/iUSiWvvvoqmzdvJjQ0lMWLF3Pr1i3s7Ozo1q1bbXVdJ1WJz9TUlMuXL+Pp6cnt27dxdXWtrTDKVJX4unbtyocffkhERAR2dnasWLGitsIoV1ViBLh16xZHjhxhwoQJtdL/ilT17+Cf7zUWNfJS9NNPP2Xt2rUEBATQpEkTGjduTGhoKMnJyfj7+xMdHc2SJUs4deoUH330EREREfj7+6NQKIrVKn1SlRZf8+bNCQoKwszMjKZNm9K5c2dSU1Nru6uVom98bdq04bfffiMoKIjFixfXcu8rpk98Q4cOxc3NDYChQ4dy6tSpWu69bvT9M9y9ezejRo3C1NS0lnuuG33iK+1eY1EjCX3//v18/fXXhIWFcefOHfr3788333zD/v37CQ8PZ+DAgSxdupTOnTsTExPDkiVLCA8Px8TEhP79+9dEF6uktPgOHTrElClTgMJpluTkZDp27Fi7Ha0kfeIbN24caWlpQGGx8Mdr0D6p9Ilv5MiRxMfHA3D48GFtcn/S6fszeujQIby9vWuxx/rRJ77S7jUWepegqwx7e3sCAgKoX78+ffr0YdCgQWXe2759e1555RUsLCxwdHR8KsrZlRVfdHQ03t7emJiY8N577z21IwF94nvzzTeZM2cOderUoX79+mzYsKGWe18xfeJbvXo1CxcuxMzMjObNm7Nu3bpa7r1u9P0Z/f3337Gzs6vFHutHn/j0yUdPGzk+VwghjMST//uwEEIInUhCF0IIIyEJXQghjIQkdCGEMBKS0IUQwkhIQhdGLzY2Fmtra3bs2FHs+gsvvMDs2bP1auvs2bMcPXoUKNzV/PDhQ4P1U4iqkoQungkdOnQoltDPnj1bqWMlwsLCSElJMWTXhDCYGtlYJERt69SpE6mpqdy7d4+GDRuybds2Ro8ezdWrV9m2bRuff/45FhYWPP/886xfv55t27YRGRlJXl4ely5d4vXXX6d///785z//wdzcnC5dugAwf/58MjIyANi8eTPW1ta1GaZ4xskIXTwzAgIC2LNnDxqNhvj4eHr27MmdO3dYtmwZYWFh7Nu3j4YNG7Jx40YA7t+/z9atW9myZQvr1q2jZcuWjB8/nldffRUPDw8AJk2aRHh4OG3atCEmJqY2wxNCErp4dowePZqdO3dy9OhRvLy8ANBoNDg6OmJpaQkUzqufP38eQHtSpK2tbZlz5UVnuTRv3vyJPBlUPFskoYtnhp2dHbm5uXz55Zfa8+gVCgUpKSnaI1SPHj2Kvb299rM/MzExKVbhprR7hKgtktDFM+Wll17i2rVrODg4AGBjY8OiRYsYNmwY3t7e3Llzh2nTppX5fTc3N77++muOHDlSU10WQmdyOJcQQhgJGaELIYSRkIQuhBBGQhK6EEIYCUnoQghhJCShCyGEkZCELoQQRkISuhBCGIn/B7L/GySAoTiYAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ "model_es = ExponentialSmoothing()\n", - "historical_fcast_es = model_es.backtest(series, start=pd.Timestamp('19550101'), \n", - " forecast_horizon=3, verbose=True)\n", + "historical_fcast_es = model_es.historical_forecasts(series, start=pd.Timestamp('19550101'), forecast_horizon=3, verbose=True)\n", + "\n", "series.plot(label='data')\n", "historical_fcast_es.plot(label='backtest 3-months ahead forecast (Exp. Smoothing)')\n", "plt.title('MAPE = {:.2f}%'.format(mape(historical_fcast_es, series)))\n", - "plt.legend()" + "plt.legend()\n", + "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "This much better! We get a mean absolute percentage error of 4.07% when backtesting with a 3-months forecast horizon in this case. " + "This much better! We get a mean absolute percentage error of 4.08% when backtesting with a 3-months forecast horizon in this case. " ] }, { @@ -649,14 +728,15 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -674,7 +754,7 @@ "\n", "For instance, in our example of a \"less naive\" model above, we manually combined a naive seasonal model with a naive drift model. Here, we will try to find such combinations in an automated way, using `RegressionModel`s. A regression model is a model that predicts a *target* time series from a bunch of *features* time series. If the features time series are themselves obtained from forecasting models, their future (predicted) values can be combined using the regression model to obtain a final forecast.\n", "\n", - "Here, we will first compute the historical predictions two naive seasonal models (with 6 and 12 months seasonality), and naive drift model. To compute the historical predictions, we can simply reuse the `backtest()` method:" + "Here, we will first compute the historical predictions two naive seasonal models (with 6 and 12 months seasonality), and naive drift model. To compute the historical forecasts, we can simply reuse the `historical_forecasts()` method:" ] }, { @@ -685,64 +765,58 @@ }, "outputs": [ { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=42.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "7af81fbfd1334e91b6b4141ed158ec11", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=43.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "a66cc1dfb2e34330a4fc005453f6d750" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "\n" ] }, { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=42.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "5f49723652f84ab5801695a03fbd832d", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=43.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "e6adf2676a3e4876a6a7f6a5d10fd838" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "\n" ] }, { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=42.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "aee8d84170c14b18b2fb90deab086349", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=43.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "8ecaa5e4f7c648d38490ac6e5a5e1d87" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "\n" ] @@ -751,7 +825,7 @@ "source": [ "models = [NaiveSeasonal(6), NaiveSeasonal(12), NaiveDrift()]\n", "\n", - "model_predictions = [m.backtest(series, start=pd.Timestamp('19570101'), forecast_horizon=6, verbose=True)\n", + "model_predictions = [m.historical_forecasts(series, start=pd.Timestamp('19570101'), forecast_horizon=6, verbose=True)\n", " for m in models]" ] }, @@ -772,22 +846,20 @@ }, "outputs": [ { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=32.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "0f2f2b50d40f402ba0d604edaafb6589", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=34.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "14ed478d84134a67a9855540a85b58a8" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "\n" ] @@ -805,8 +877,7 @@ "\n", "\"\"\" Here we backtest our regression model\n", "\"\"\"\n", - "ensemble_pred = regr_model.backtest(model_predictions, series_target, \n", - " start=pd.Timestamp('19580101'), forecast_horizon=3, verbose=True)" + "ensemble_pred = regr_model.historical_forecasts(model_predictions, series_target, start=pd.Timestamp('19580101'), forecast_horizon=3, verbose=True)" ] }, { @@ -824,29 +895,30 @@ }, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "MAPE Error for Naive seasonal model, with K=6: 21.25%\n", - "MAPE Error for Naive seasonal model, with K=12: 8.16%\n", - "MAPE Error for Naive drift model: 21.75%\n", - "MAPE Error ensemble: 5.30%\n", + "MAPE Error for Naive seasonal model, with K=6: 21.17%\n", + "MAPE Error for Naive seasonal model, with K=12: 8.25%\n", + "MAPE Error for Naive drift model: 21.44%\n", + "MAPE Error ensemble: 5.10%\n", "\n", "Coefficients of the features time series:\n", - "Learned coefficient for Naive seasonal model, with K=6: 6.98\n", - "Learned coefficient for Naive seasonal model, with K=12: 1.01\n", - "Learned coefficient for Naive drift model: -6.64\n" + "Learned coefficient for Naive seasonal model, with K=6: 5.33\n", + "Learned coefficient for Naive seasonal model, with K=12: 1.06\n", + "Learned coefficient for Naive drift model: -5.08\n" ] }, { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -916,7 +988,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.8.3-final" }, "pycharm": { "stem_cell": { @@ -930,4 +1002,4 @@ }, "nbformat": 4, "nbformat_minor": 2 -} +} \ No newline at end of file diff --git a/examples/data-processing.ipynb b/examples/data-processing.ipynb index eba13bdba8..0d9abe24af 100644 --- a/examples/data-processing.ipynb +++ b/examples/data-processing.ipynb @@ -10,7 +10,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3-final" + "version": "3.8.5-final" }, "orig_nbformat": 2, "kernelspec": { @@ -112,10 +112,12 @@ "output_type": "display_data", "data": { "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {} + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -204,10 +206,12 @@ "output_type": "display_data", "data": { "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {} + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -231,10 +235,12 @@ "output_type": "display_data", "data": { "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {} + "metadata": { + "needs_background": "light" + } } ] }, @@ -254,10 +260,12 @@ "output_type": "display_data", "data": { "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {} + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -285,7 +293,7 @@ "output_type": "execute_result", "data": { "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -295,10 +303,12 @@ "output_type": "display_data", "data": { "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {} + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -330,7 +340,7 @@ "output_type": "execute_result", "data": { "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -340,10 +350,12 @@ "output_type": "display_data", "data": { "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {} + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -392,10 +404,12 @@ "output_type": "display_data", "data": { "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {} + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -417,7 +431,7 @@ "output_type": "execute_result", "data": { "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -427,10 +441,12 @@ "output_type": "display_data", "data": { "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {} + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -466,7 +482,7 @@ "output_type": "execute_result", "data": { "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -476,10 +492,12 @@ "output_type": "display_data", "data": { "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {} + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -507,10 +525,12 @@ "output_type": "display_data", "data": { "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {} + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -535,10 +555,12 @@ "output_type": "display_data", "data": { "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEFCAYAAADzHRw3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy9d3Qc53W//+yiEgDRQfS6aCTYOaSswiKKVqEky4ol2XJcEhfRjpzj4xLLSb7ukf1znBxHkR3JtBW56MRRi6QoKpRYREIU27CIIAkWdGBRFh0gCrHt98dilovFAju7O7MAifc5R0cE5t25Mwvgs3fue4vB6XQiEAgEgmsf41xfgEAgEAi0QQi6QCAQXCcIQRcIBILrBCHoAoFAcJ0gBF0gEAiuE+ZM0Ds7O53AnPw3V7YX4j2L93vh2F6I9zxHtmdkzgTdbrfPlek5s70Q73kubS/Ee55L2wvxnufatjci5CIQCATXCULQBQKB4DpBCLpAIBBcJwhBFwgEgusEIegCgUBwnSAEXSAQCK4ThKALBALBdYIQdIFAINCZixcvUl9fr7udSN0tCAQCwQLnsccew2az8frrr+tqRwi6QCAQ6ExHRwfNzc04nU4MBoNudkTIRSAQCHTGYrHQ2dlJe3u7rnb8euiSJEUAfwBygUbgEaAWME8ueVyW5XclSaoEdk6e83uyLO/R55IFAoHg2sJisQAgyzK5ubm62VHjod8PNMqyfCtwHvgLYFCW5S2T/707ue6nwBeBO4Ef63K1AoFAcI0xMjLCyMgI4BJ0PVEj6Cbg1OS/TwCbgARJkvZLkvRfkiSlTh7LkWX5kizLQ0CfJEnpOlyvQCAQXFN0d3cDsG7dOo4fP66rLTWboudwed0vA9uAFOBmWZZ7JUn6HPAj4G+Z+uEwCKQCPZ4nkiTpEVwhG3bs2MH27dtDvoFgsFqtmM1m/wuvE7sL1fZCvOe5tL0Q71mN7TNnzgBwyy238Nxzz9HW1hbSxuhsIRs1gv5/wBZJkvYCZ4FOWZZ7J4+9BHxp8t8Oj9ckAX3eJ5JleSeuODtms9mpZyxpNsxms65xrPlmd6HaXoj3PJe2F+I9q7F98uRJAB566CGeeOIJHA4HBQUFulyL35CLLMtOWZa/JcvyVqAXeE2SpJjJwxuBusl/d0iSZJIkaTGQKstyj6/zCQQCwVzgcDjcm5PhxGKxkJaWxrp164iKitI1jq4myyUL+DMuD3wPcAH4QJKkEeAK8IXJpf8I/B6IAH6gx8UKBAJBsLzxxht89rOfpbu7m6ioqLDZ7erqYsmSJcTExLBixQpkWeYv/uIvdLHlV9BlWe4EbvX69jof687h8tgFAoFg3tHU1MTg4CAXL16kqqoqbHYtFgtLliwBQJIkXT10UVgkEAgWBEq2yYcffhhWu56Cvm7dOmRZxumcddZz0AhBFwgECwJF0E+fPh1Wu94een9/P42NjbrYEoIuEAgWBMqG6Fx66JWVlYCr+6IeCEEXCAQLgu7ubuLi4ubUQ4+LiyMzM1N46AKBQBAK3d3dbNq0ifb2dnp6wpNV7XA46O7uJjMz0/294uJiIegCgUAQCt3d3dx2221A+OLo/f392O12t4cOQtAFAoEgJOx2O319fZSXl5Ofnx+2OHpXVxeAEHSBQCDQit7eXpxOJxkZGaxatSpsgq5sxApBFwgEAo1QUhYzMjJYuXJl2EIuFouF6OhoEhMT3d8rLi6mr6+PoaEhze0JQRcIBNc9noK+atUqzp49i9Vq1d2ukuHi2V2xuLgYQBcvXQi6QCC47lH6tyQmJrJy5UomJiZ0ywX3xDNlUSE/Px+j0SgEXSAQCILBYrGQkZGBwWCgrKyMRYsWhSWObrFYpqQsAkRFRZGfny8EXSAQCIKhu7vb7SlHRERQVVXlHjyhJ748dNBvY1QIukAguO7p7u4mIyPD/XVxcTHNzc2621Va53pTXFxMU1OT5vaEoAsEguseb0EvLCwMi6ALD10gEAg0xlvQCwoK5oWga91GV83EogjgD0Au0IhryPP9wDeAMeDzsiy3SZJUiWteaCTwPVmW92h6pQKBQBAkvjz09vZ2rFarbtOLxsfHGRoamlHQR0ZG6OnpmXJdoaLGQ78faJRl+VbgPPAXwDeBLcD3ge9Nrvsp8EXgTuDHml2hQCAQhIgvQXc4HJjNZl1tAjMKOmifi65G0E3Aqcl/nwB2ALWyLE/IsnwQWDl5LEeW5UuyLA8BfZIkpWt6pQKBQBAEDoeD3t7eaSEXQNewi3Ju77RFgKysLGJiYjQXdL8hF+AcLq/7ZWAbrg8Bz5rViMn/e344DAKpwJQelZIkPYIrZMOOHTvYvn17cFcdIlarVddP5vlmd6HaXoj3PJe25+s9Kx0PAfcap9NJQkICp06dorS0VBfbjz/+OKtWrcLpdPo8npeXx6lTp7jlllsCspebmzvjMTWC/n/AFkmS9gJngQEg0eO4ffL/Do/vJQF93ieSZXknrjg7ZrPZOduF6YnZbJ71Tbne7C5U2wvxnufS9ny95+HhYQCWLVs2ZU1RURHDw8MhX7Mv20ePHuXtt9/m3XffJS8vz+frysrK6Ovr0/Q98yvosiw7gW8BSJL0Q+Al4P+TJCkakACly02HJEkmwAKkyrIcng7yAoFAMAtKx0PvzUc9M13+4R/+ga1bt7Jt27YZ1xQXF1NXV6epXTVZLlnAn3F54HtkWd4vSdK/Ae8B48DnJ5f+I/B7XCGYH2h6lQKBQBAk3d3dREREkJycPOX7hYWF1NfXa25v9+7d7Nmzh8OHD8+6rqSkhHfeeUdT22o89E7gVq/vPQ887/W9c8BGTa9OIBAIQqS7u5v09HSMxqk5IIWFhezdu1dze//yL//Cxz72MW644YZZ15WUlNDc3IzNZiMyUk302z+isEggEIQVrYtp/OGdsqhQWFhIS0uL5tfT2trqV8wBTCYTNpuN1tZWzWwLQRcIBGHDbreTnZ1NdXV12GzOJOgFBQWMjY1pPjB6cHCQpKQkv+tKSkoANA37CEEXCARho7e3l66uLt57772w2fTstOhJYWEhoH0uulpBX7x4MRkZGULQBQLBtYmScXLixImw2ZzJQ8/OziYqKkpTQbfb7Vy+fFmVoIMr7NLQ0KCZfSHoAoEgbCjl8PNB0I1GI3l5ebS0tGhmS8l5D0TQhYcuEAiuSRQPvaWlRfPYtS/sdjstLS3k5OT4PK51G93BwUGAKUOhZ6OkpER46AKB4NrEYrG488FPnjypu70jR44wMDDA1q1bfR7XS9AD9dC1yrQRgi4QCMKGxWLBZDJhMpnCEnZ54403qKysdGeUeFNQUKBpyCVQQS8pKWFoaIje3l5N7AtBFwgWIL/5zW/4z//8z7DbVQY+rF27NmyCfvfdd894fK5DLiaTCUCzsIsQdIFgAfLyyy/zu9/9Lux2lRTCcAh6W1sbH374oV9B7+3t5fLly5rYHBwcJD4+XnXlZ3Z2NrGxsZptjApBFwgWIN3d3Zw8eRKbzRZWu54eel1dnduj1YM333yTxMTEWdvTKh6yVk2yhoaGVIdbAAwGg6Ybo0LQBYIFSE9PD+Pj45w7dy6sdi0WCxkZGaxZswaAU6dO+XlF8Lzxxhvcfvvts46YKygoICYmhosXL2piU21RkSdapi4KQRcIFhhOp9OdMijLclhtKx56RkYG+fn5uoVdxsfH2b1796zhFoCIiAhKS0u5cOGCJnYHBwdVx88VSkpKhKALBILgGBkZYXx8nNjY2LAK+pUrVxgcHHSX4esZR9+/fz+jo6PcddddftdWVFTMuYcuQi4CwTXOwMAAL730UtjtKt755s2bwyroil1F0NesWaNbLvqpU6coKyvzOc/Tm4qKCk099GAE3Ww2Mz4+HrJ9IegCwRzx2muv8dBDDzE6OhpWu0r5/Z133snp06eZmJgIi12lSlQR9IqKCk2LajwZGhqaNtBiJsrLy7lw4YIm1xHopii4Qi5Op1OTgdFqJhYZgf8ETIAB+BLwNK7JRHbgGVmW/zQ52eiPQDzwlCzLz4V8dQLBdYzFYsHpdHLhwgX3JmE4UDzlO++8k2984xucPXs2LPa9R8GVlJQwPj5OZ2cn2dnZmtoaHh5m8eLFqtZWVFQwNDSExWJR5dHPxuDgIBUVFQG9pri4GIPBQENDA0uXLg3JvhoPfTUQI8vyRuDvgW9Ofv8uWZa3yLL8p8mvHwP+GdgMPCpJUmxIVyYQXOcoAhfuTJPu7m6SkpKoqKggOTk5bGEXi8XC4sWLiY11SYNSvallLxOFQAS9vLwcQJOwSzAhl5iYGDIzMzWpWFUj6G2AQZIkA5AC9OCaL/qmJEn/K0lS4eS6DcBeWZZtgAwsD/nqBILrmLkS9J6eHjIyMjAYDEiSFDZB9+5LnpaWRkJCwpwLelpaGmlpaXMm6OBKn9RicpGacqYewAqcB2KBm4F/lWW5V5KkzcCTwMeAKFmWHZOvGQRSvU8kSdIjwCMAO3bsYPv27SHfQDBYrVbMZvOCsbtQbc/3e1Y8suPHj2t6nf5sNzQ0kJiYiNlspqKiggMHDmhi35/d+vp6kpOTp6zJz8/nww8/nLF5VrC2e3p6KCwsVH1fRUVFHD9+PChN8rQ9MDCA3W4P+P1MT0/nwoULql6Xm5s74zE1gn47YJNluUKSJAmXmH8SQJbl/ZIk/evkOqskScZJUU8C+rxPJMvyTmAngNlsds52YXpiNptnfVOuN7sL1fZ8v+ehoSHi4uJoaGjQ9Dr92b5y5Qo5OTnk5uZy6623snPnTtLS0tyhEL3sjo2NkZeXN2VNRUUFPT09Id+/t22r1UpWVpbq865YsYL29vagrkOx7XQ6GR4epqioKODzlJeXc+LEiZDfBzUhFwOgtALrAZIkSUoEkCRpGdA/eewYsEWSpEhgHXA2pCsTCK5zuru7ueWWW6ivr9ckZS0Qu8rG5Nq1a7FardTW1upuVykq8qS4uHjOQy6gTS76yMgIDodjTkMuagT9XSBfkqT9wH8DPwb2SpJUDfwG+Nbkup/j2jQ9ADwty/JYyFcnEFynOJ1OLBYLW7ZsweFwaFbYooaenh7S09MBV8gjIiJC87mavlDK/j3ResCDQqCCXl5eTn19PVarNWibgbbO9SQ/P5+2tjYcDof/xbPgN+Qyucn5Sa9vSz7WdQAfDelqBIIFwvDwMFeuXGHDhg3ExsZy7tw5Vq5cGRbbnh56ZGQkubm5YRF0X8OaS0pK3EU1oYZ8PAnGQ7fZbDQ2NrqzXgIlVEG3Wq10dXWFlMIpCosEC54TJ05gt9vDalPJcMnOzqaysjKsmS6eHjpo3xN8JnyFXJTURa3tByroJpMJg8EQ0pNSKIJeUFAAEHLYRQi6YEEzPj7ODTfcwPPPPx9Wu55Vk8uWLQuboNtsNvr7+6eEPsIh6CMjI4yOjk4T9KKiIkDbXPSJiQkmJiYCEvTY2FiKiopCSl0MdLiFJ5mZmURFRQlBFwhCoaOjA5vNxrvvvhtWu93d3RiNRlJTU1m2bBlnz4Ynh6Cvrw+n0znFQ9d6DJsvvMv+FWJjY8nJydFU0IeHhwECEnS42gIgWIaGhoiJiSEmJibg1xqNRnJzc0P+OQhBFyxo2tvbAdi9e7cuPUVmwmKxkJ6ejtFopKqqikuXLoWlp4pS9h9uD9277N8TrTdGgxX0kpISmpqagrYbbFGRghaZLkLQBQuajo4OwDWu7NKlS2Gz6xlPXrZsGXa7PSz2lcZc3jH07u5uXZuE+bKrUFxcrEljKoVgBb2wsDAkDzlUQc/PzxceukAQCu3t7eTn55Oamsru3bvDZtdT0EtKSoiOjg5LHL2np4eoqKgpcV6tNuRmw2KxkJaW5nPW5nzx0JXQU7BPaloIuvDQBYIQ6OjoIDc3l61bt4Zd0D1TBysqKsIi6N3d3aSnp2MwGNzfUwRdz7CLrwwXBUXQtQp5heKhj42NuZ8m1LBx40beeustQIRcBII5p729nZycHG677Tb27dsXtvRF75zsUOO3avFOWQSIj48nPT1dV0FvbW2dsTVtSUkJw8PD9Pb2+jweKMPDw0RFRQW8OVlY6OozqPZ96Onp4f3336e6uhoIrhe6J/n5+XR2doa0lyIEXbCgaW9vJzs7m23btjEwMKDbSDRvvD3WwsLCsAi6Z1GRJ3pmujidTt566y22bNni83hxcTGgXepioDnoCllZWURGRqp+H44fPw5ATU0NoI2H7nQ6Q2qUJgRdsKDp6OggOzsbk8lEQUEBe/bsCYtdb0EvKioKS3GPLw8d9M10OXPmDI2Njdx3330+j2dnZxMTEzPngh4REUF+fr7q90FpO3zu3DlsNltQA6I9yc/PB0LbyxCCLljQKCEXg8HAtm3bwhJHdzgc00IuhYWFtLa26h7ymclD11PQX331VQoLC1m1apXP40ajkZIS7SbfByvoENj7IMsy69ev58qVK9TW1obsoScnJxMfHx/Sk5IQdMGCZXx8nP7+fnfvDEmSwlLg09fXh8PhmCKsRUVF2Gw2d168XszmoesVcnnttde47777pmzEelNeXq5Zg7JQBD2Q0JMsy3zqU58iPj6eEydOhCzoBoMh5I1RIeiCBYuSg56TkwO4Bgd0dXWF1HFPDb6qJgPdkAsWZVqRNwUFBbS1tWn+hNDa2srx48f5+Mc/Puu6srIyzfLww+Ghd3Z20tbWxvr161m+fLkmgg6hpy4KQRfMC/74xz/y5z//Oaw2FUFXPHRlSEFnZ6eudpW0OE9BT01NJT4+XteNUafT6U5b9KawsFCXJ4T//d//JSUlhY0bN866br546GoF/fjx4xgMBtasWeMW9FCzXOBqcdHo6CinTp3iypUrAb1eCLpgXvCHP/yBb3/729hstrDZbG9vJyoqirS0NODqaC+9x9ZZLBaio6OnbKAZDAbdN0ZHR0cZHx+fMYYO2j8hvPbaa9xzzz0+C4o8KSsro7e3l76+aYPOAibUkEtfXx+XL1+edZ0syyxdupSEhARWrFiBLMtMTEyELOgFBQXs2rWLxYsXs2bNGp599tmAXi8EXTAv6OzspL29nf/7v/8Lm82Ojg6ysrIwGl1/BkuWLCEyMjIsgq4MafZE79TF2crv09LSWLRokaZx9OHhYfbt2zdjdosnSg9yLcIuoXrogN/3QZZlXBM5Yfny5e6JU6EK+mc/+1l+8pOf8Oqrr7J27dqA3w8h6IJ5QWdnJ7GxsTz99NNhs6lkuCgYjUays7PDIui+qib19tCV2L0vQTcYDJpnurS3t2Oz2Vi+fLnftdnZ2cTHxwcl6N3d3VMEOFQPHWZ/UnE6nVMEvbS01D2cI5S0RXDl5H/3u9/l3nvvpbKyctp1fPrTn5719X4nFkmSZAT+EzDhmi/6JSAd+GfAAXxVluUaSZKygD8C8cBTsiw/F8T9CBYgV65coa+vj69//es88cQTNDQ0uAcf6ImSg+5Jbm7unAl6YWGhrmmThw8fZsmSJWRlZfk8rrWgKyX4akTOYDBQVlYWVBz9n/7pnzh69CiHDh1y2w1W0GNjY8nMzJzVQ29vb6ezs9Mt6JGRkaxatYojR46E7KF74uv34YMPPpj1NWo89NVAjCzLG3HNDP0m8DhwN/BpXLNEAR7DJfKbgUclSdJunpTguqarqwtwPW4WFxezc+fOsNhVqkQ9CYeg+xrFBlcFNdS5kjOxZ88etm7d6g4xeVNQUKCpoA8NDQHqe6qUl5cH5aG3tLTQ1tbm/joUQYep70NLSwunT5+ecvz48eNERERMyatfu3YtEHrIZabrANfgDn8ZMH49dKANMEiSZABSgBHALstyP9AvSVLq5LoNwLdkWXZIkiQDywHZ80SSJD0CPAKwY8cOtm/frurGtMZqter+Rzuf7M5328ofjMFg4FOf+hQ7d+7kkUceCWpQQCB2W1paWL169ZQ1SUlJ1NbWhvxezWa7ra1tml2AuLg4rly5wocffjhjI6tgbdtsNvbu3csPfvCDGa8rPT2d3bt3B33v3nabmpowGAwMDAy4p/nMRlZWFvv27QvYfnNzM52dnbS2tmI0GhkaGsJmswV9H0uWLKG2tpa2tjbuv/9+nE4nr7/+uvt4dXU1JpOJ/v5++vv7sVqtlJSUEBMTQ19fH/39/UHZ9SY+Ph6LxUJdXR2LFi2ioaHB74e9GkHvAazAeSAW2Aj8u8dxmyRJ0UCULMuKtUEgFS9kWd4J7AQwm81OJasg3JjNZubC9lzZne+2lRSwlStXkpqays9+9jP6+vrcj7R62e3u7qaiomLKmoqKCqqrq0N+r2azPTAwQHFx8bTjERERgCsEFYp9X7YPHTrE5cuXeeCBB2Y8tyRJ/OIXvyAzM9NvVooau1FRUSxevJi8vDxVr1+3bh3PPvusu3JXLT09PdhsNqKiosjMzOTy5csUFBQE/R5WVlZy5MgRTpw4wYkTJ0hJSZlyLovFwrJly6ZkRf3t3/4tN910k+p7VcO6desAV2Vxbm6uu2fMbKgJudwO2GRZrgA+Afwr4BkUi5RleQKwTsbbAZKA0POPBAuCzs5OMjIyiIyMdG9SKht4eqHE7T03ReFqyEWv6UXj4+M0NTW5Z2l6kpmZSWxsrC4bo3v27MFkMvm0q1BaWorNZtPM/vDwcECbhGVlZQwPD7tDcGpwOBzuuoHW1lbGxsZwOBwhh1waGxv5x3/8R8rLy+nv75+STnnp0iVKS0unvCYmJoabbropaJszXQdc3aCtr6+fFiL0Ro2gGwClr2UPsBiIlCQpWZKkfK4K9zFgiyRJkcA6IDxDEgXXPJ2dne6NuujoaJKTkwPqSR0M3kVFCrm5uYyOjqoKEQTD4cOHuXLlCps2bZp2TCn91iN1cffu3dx2222zrjGZTADU1dVpYnNoaCggYQ0mdbG3t9dd2dvW1hZ0L3RPCgsLMZvNnD9/nmeeeWbaNdXV1VFWVhb0+dWSkJBAamqqW9AbGhrcP6OZUCPo7wL5kiTtB/4b+DHw/4A3J7/++8l1P5/89wHgaVmWx4K5CcHCw1PQwTV3MlyC7stDB/2Ki9577z0qKipm9LT0aJI1MjLCoUOH2LZt26zr4uPjycnJ0bQEPxAPPS0tjZSUlIAyXZSfY2RkpKaCDvDlL3+Zm2++mbi4OPeH3ODgIN3d3dM8dL3w7LFTX1/vN/vLb6BMlmUb8Ekfh27yWtcBfFT1lQoEk3R2dk4RuCVLlugecmlvbycyMnJaTranoFdVVWlud9++fTP2BQd9ctHff/99JiYmuPXWW/2uLSsrmzMPHQLPdFFaFVRWVmom6JWVlfzVX/0V3//+9zEYDJSWlrqvSXlvwuGhw9QP+IaGBh544IFZ14vCIsGcM1ceemZm5rQUvri4OJKTk3Xx0MfGxjh8+PCswqpHteiePXtYs2aNz4IibzzFK1QC9dAh8J4uHR0dpKSkUFRUpJmgx8bG8uyzz7p/Jz0bh126dInY2NiwJRgogu50OjULuQgEuqKU4CuEy0P3Drco6JWLfvjwYSYmJti8efOMaxQPXctN2YMHD85q05O59tAD7bqo1BJkZ2dPEfSEhISA7M5GaWmp+z2pq6vDZDLNmMuvNUoueldXFyMjI35DLkLQBW6ampr44Q9/GFabSnfDcHvoH374IZWVlT6P6SXo+/bto7KycsZKTXB5ZCMjI5rN1wRX/3V/2REKpaWlNDQ0aNIkLRgPXflAUfuB1tHRQU5ODjk5OW5BX7RoUVBpl7Ndk6eHHq5wC7h+H9ra2tz2hYcuUM0777zDj370I3p6esJmc2hoiPHx8WmCrqeHbrfbef/992ds6aqXoL/33nt+49h6dD0cGhpSLaxlZWXYbDZNmnQF46EXFRUxPj6u+ufv7aEHY9MfpaWl7tTFurq6sG2IwtW2xgcPHiQ+Pt5np0xPhKAL3Cj5v8rw23Cg5BB7h1z09NBramoYGhrymToI+gj66OgoR44cmXVDFFxZN5GRkZoKeiCzLhUPUKuuh4F66EqevNp9BMVDz87OZmJigoaGBs0FXfHIL126NCceOsDevXsxmUx+C66EoAvcKF6RMvw2HPgS9IyMDEZHRxkZGdHFZnV1NUuWLHHnPXujh6AfOnTIb/wcrg4q1mpj1G63MzIyorrHiJK6qEUcPRhvecmSJcTExKj+QFMarCkhpdraWs0FPTs7m7i4OI4fPx7WlEVwtWNYtGgRBw8e9BtuASHoAg8UDz3cgh4TEzNFcJQ+Jnp56dXV1dxyyy0zeju5ublYLBZNR9GdOHECk8lEZmam37Vapi4G0vFQQatMl2A8dKPRqDrTx+l0uj30jIwMjEajLoKupC6+/fbbQPhSFhXbBQUFjI6OqupAKgRd4MZisRAbGxt2Qc/Ozp4irkqcUA9BdzqdHDhwYMZwC1wdRacUrWhBb2+v6oZbWqYuKh0PAy3BD9VDdzqdQXc9VFtc1dfXx8TEBNnZ2URFRZGVlUV9fb3mgg6uD7k9e/aENWVRQQm7CA/9GsThcLB9+3bN5isGQldXF1u3bqWtrS2gfhqh4J3hAlcHMOixMVpXV0dXV9esMy71qBbt7+8nJSVF1Votq0WDFfRQPfSRkRGcTmdQAx/UfqApRUVK+ml+fn7IfVxmoqysjNHR0bCmLCoogi489GuQvr4+3nrrLfbt2xd22xaLhTvuuAODwRC2jVFfgh4VFUVKSoouHnp1dTWLFy+e0svam4yMDKKiouZM0LUMuSg9aQINuTQ2NoaUuhhoL3RP1N6/dz8epdOhXh665//DidKkS3jo1yCKiJ0/fz6sdq1WK319fZhMJpYuXRq2sIt3UZGCXqmLBw4c4Oabb3a3qvWF0WgkJyfH7zCBQAjUQ1fbQ9wfwXroVqs1pNTFYGL3CoqH7i8Xvb29neTkZBYtWgToK+hK3Dyc8XOFkpISoqKi3J76bAhBn2coOeAXLlwIq13lg2TJkiVIkhQ2QffloSvXoZeHPlu4RaGgoEBTQe/r6wvIQwdtctGHhoZYtGgRUVFRql+jRepiqB76yMjIlJa1vvAeIXi9euif+MQnqK6uVvUzFII+z5grD12JmWdmZrJu3bo5F3Q9qkUtFgsNDQ3ccsstfuGACJUAACAASURBVNcWFBRoUlyjEIiHnpeXh9Fo1GRjNJCiIoX4+HiysrJoaGgI2m6oHjr4/0Dzbt+gp6Dn5OTw4IMPsnXrVs3P7Y+YmBhuuOEGVWuFoM8zFBFrampibCx8HYiV8IbioXd0dLg3nfTCbrfT3d09o4eudchFeW/VTJWZS0GPiooiJydHEw89kKIiT0wmE/X19UHbHRoawmg0EhcXF/BrleIqfx9o4fTQDQYDL7zwwpyEXAJBCPo8o7u7m4SEBJxOp2Zd79TQ1dVFYmIisbGxrF69GqPRqLuX3t3djcPh8NlnRA8PPZB4spaC7nA4GBwcVC3ooN3GaDAeOrjitqF66IsXLw5olJyCUlylxkMPl6BfKwhBn2d0d3ezdu1aoqOjwxpHt1gs7qKXuLg4li5dysmTJ3W16atKVEGPTdFAMj4KCgro6upifHxcE7tOpzMgQdcqF31oaCioSfRaeOihDplQ46F7hlxycnLc4aKFit+WZJIk3Qj8bPLLHOANYA0QAdiBZ2RZ/pMkSVnAH4F44ClZlp/T55Kvb3p6esjKyqKsrCyscfSurq4phS9Klzc9OX78OIsXL/bpoSubok6nMygvzxdDQ0PExsYSHR3td62SKtbW1hbyRpgyBT41ddrc9BkpKipi165dIdmF4D10RdCDff+DqRL1xN8TitPpnOahR0dHU1dXp6oa93rFr4cuy/IhWZa3yLK8BfgAeHXy0F2T3//T5NePAf8MbAYelSQpVo8Lvt7p7u4mIyODysrKsAq6p4cOrtxeLSslffH222+zdetWn7v3GRkZjI2NadrPJRBxUwRdi7CLIuhz5aEHG3IZGRkJKOzlmZWit4fe39/PxMTEtJ72WVlZmjkA1yKqmwZLkhQNbAC+ADiANyVJGgD+Vpbl5slj35Jl2SFJkgwsB2SvczwCPAKwY8cOtm/frs1dBIjVatVtZmSodtvb21mxYgW5ubns27dPs+v0Z7u5uZmCggL3moSEBFpaWjSx78u2zWbj3Xff5bHHHvNpQ8lBrqmpcYtrqHZbW1uJi4tTfU9JSUl8+OGHVFRUhGRb2QsZGxtTbTs+Pp6enh4uXboU8Maip22LxYLJZAr456jYPHz4MOvWrfO7/oMPPuAzn/kMx48fJyUlhY6ODmJiYoL+/UlMTKSpqWnG158965pBHxkZidlsnrO/aQi/nszWeiCQLvDbgD2Tgv2gLMu9kiRtBp4EPgZEybLsmFw7CEx7vpRleSewE8BsNjvD3RNBwWw2h70fg1q7AwMDmEwmFi9ezDPPPENOTo4mHoc/20NDQ5SUlLjXlJeX88ILL2jyPvmyfejQIQYHB/nkJz/p04ZS+GM0GoO+Bm+7BoOB1NRU1ecrLCxkeHg4KPuetiMiIoiOjlbV/lRBkiTAJRaB2ve0feXKFXJycgI+hxKPVnv/7777LhMTE4yNjbF8+XIcDgfp6elB/+zWrFnD4OAgCQkJ9PX18fjjj/PUU0+5n+aOHDlCZGQk69evd4v6QtMTXwSyKfog8CKALMu9k//fjyuuDmCVJEk5XxIwe1WAYBpOp5Pu7m7S09OprKxkZGQkbJ/83jH07Oxsurq6sNvtutjbtWsXpaWlM/anSEtLA7Rt0BVoCp9WmS5KymIgH8zKU0momS7BbooaDAZKSkpUbYzabDZeeeUV4Or1hhpDV3LRL168yIMPPsgzzzwzpb9RQ0MDhYWFmk4muh5QJeiSJEUB64H3J79OnPz/MqB/ctkxYIskSZHAOuCs5lcbRjo6OnQfg+bN5cuXmZiYICMjw/2YH444utPp9BlDdzgcur0Hu3bt4o477pjxeFRUFKmpqZraD1TctBL0QKpEFWJjY8nKytJE0IMVVrWZLvv376enp4ekpCT39YYaQ1eKq774xS/S0NBARETElDTehoYGVc2qFhpqPfRtwF6PkMpeSZKqgd8A35r83s+BvwcOAE/Lshy+qhgd+NrXvsbXv/71sNpUxCsjI4PExERycnLCkrrY39+PzWab5qEDumyM9vf3c/To0VkFHbRPXQxU3LT20ANFi43RUARdbS76Sy+9xA033MDy5cvd1xuqhx4dHU1OTg41NTX84Q9/oLi4eIqH3tjYSHFxcdDnv15R9bwiy/JbwFseX0s+1nQAH9Xu0uaWjo6OsLWQVfAUdICKioqweOiKaHp66Eoub0dHB2vWrNHU3u7du4mIiPA7X1Prfi5DQ0MBpbQpgh5q6mSwgl5UVERjY2PQdu12O5cvXw7JQ//zn//s18b//M//8J3vfIdjx45p5qEDbNmyhaKiIu69916eeuqpaR66v3F+CxFRWDQDPT09NDQ0+G0QpCWKeCn5yuFKXVQ+uDw99JiYGFJTU3Xx0Hft2sXNN99MQkLCrOu09tCDiaGPjY3R29sbkt1gBV2Lak0gqBg6uAS9o6OD0dHRGddUV1djsVj4xCc+QV5enmYeOsCf/vQnfvKTnwCuTXrFQ3c4HDQ1NYmQiw+EoM+A8kcczoHJPT09pKSkuHfyS0tLQ6rWU4vFYiE6OnraH75euegnTpzg5ptv9rtO634uwYRcIPRc9GAF3WQyBSzoBw4cYGBgAAiuda4nimDO9pTw4osvIkkSRUVF5OXlaeqhe+I5dKO9vZ2JiQkh6D4Qgu4Dm83mLgYJ5zg2pahIISsrKyxhHyXDxTusoJegDw0NqRI4LUexKXYD8Vazs7OJiIiYU0Hv6+tzC7Q/rFYrd911Fy+++CIQuqAXFhZiNBpndSqqq6u56667AFd+9NDQEH19fSGFenxRXl5OR0cHw8PD7g85EUOfjhB0H/T39+N0OiksLJxzQR8dHeXy5cu62vXOcFHQS9DVPo4rHqpWqZOBeuiRkZHk5uZqIuiBlP0rKB6o2qe0U6dOMTo66m7ZEMy0Ik+io6PJz8+f9SmhubnZ3T89Pz8fgHPnzuF0OjX30ME1QrChoYGkpKSgPiSvd4Sg+0AJt9x5551zKuiKyOrtpXvnoCvo6aGr+WMvLS3FarVq0lPG4XAEFdfVItMlWA89NzeX6Oho1WGXgwcPArjfr1A9dJg9dXFgYIChoSF3znhWVhZGo5GampqQ7XqTn59PTEwMFy9edKcsLuQS/5mY14K+Z88eli5d6ncUldYoU4PuuOMOWlpawpaPrhQVKSiCrnQl1Itweug2m43x8XHVHjoQ8gR6CH7gQqiCHkzrXIWIiAiKi4tVe+iKoCvFaMFMK/JmNkFX4uWKoEdFRZGXl+cWdC099IiICEwmE5cuXaKxsVHEz2dgXgv6uXPnOH/+vO5d/7zp7e3FaDSydevWsA5M7unpmeKhp6amEhERMeceupYfqIqwqvljT0xMJCMjQxNBV7zVQDM+QhX0YFrneqK2WtPpdPLBBx9QVVU1RdBD9ZKrqqrYu3cvf/3Xf82BAwem/C60tLRgMBimlL0XFhbq4qHD1UwXUVQ0M/Na0JXQh/ILEi56enpITU0lKSmJioqKsIVdvEMuRqORzMzMsAj6TB76xMSEe4NYCwKdNRlqX25vu8F46KFUawbTadETtZkuzc3NtLe38/DDD9Pf38/IyIgmgv7Vr36VX/3qV1y8eJHNmzfzwgsvTLGZk5MzpR1xUVGRLh46uOLoiqCLDVHfCEH3QU9Pjzv0Ec6Byd6CDq6wi54hlwsXLtDQ0MDq1aunHdOjWjTQ0EdpaammHnqgAldYWEhnZ2fQgy6UOoZQBF3NB9rBgweJjY3lvvvuA1xiG+z4OU+io6P50pe+xMGDB9m0aRMffPCB+1hzc/O0SfSFhYUMDg4GPX5uNsrLyzl79iydnZ3CQ58BIegz2FWaQ4VrYPKVK1cYHh6eEkMHdPfQd+7cSVlZmc+qOz0FPdweupLxEajXqHiCgXjpY2Nj7vsM1UMvKSmhtbWViYmJWdd98MEHbNiwwb3v0NLSoomH7snSpUupra11f93S0jKttbEi8MGOn5uN8vJyd8aXEHTfCEH3gbeHbjabdd+YVDZivT10PXPRx8fH+f3vf8+OHTswGqf/KiQkJJCQkKCpoAfqKSvFVaHG8YeGhoiJiSEmJiag1ykCFUgJ/t/93d/xxS9+EXAJenR0NIsWLQrIroLJZMLhcPj9QDl48CA333wzixYtIj09nebm5qA7Lc6Et6D78tCLiooA7ePncDV10WAwTLMrcDHvBb2yspLa2lqsVmtY7SqCrnQ9DKWnhhq8+7go6Omhv/TSS4yMjPD5z39+xjU5OTmae+hRUVGqhbW0tJSRkZGA3wOn0zlFBIMVt7i4ODIzM1X//J1OJ6+//jrHjh1jZGQkqNa5nihPCLM9pQwNDVFTU8NNN90EuNIdFUHX2kNva2tzP33MFHIBfQY1Z2VlkZCQQF5enqoxgguReS/oW7ZswWq1Tum0pjc9PT3ukEtaWhqRkZG6j2NTBN1XyEWvp4Onn36aBx98cJpNT7ROXQy0JDzY1MX9+/ezadMm91NeKOJWXFysWtAvXLhAS0sLVquVDz74IOgcdIW4uDiys7Nn3Rg9cuQIDofDLeh5eXm6hVzA1dL5ypUrdHZ2ThN0JQSjh4duMBgoKysT4ZZZmPeCfsMNNxATExPWsItnyEXJNNE75NLd3U1cXNy0jSS9PPSamhoOHjzIV77ylVnXaS3ogRb3pKenk5iYGHAc/eDBg9jt9im9RUIRdLUtCHbt2uXuZ//ee++FLOjgfx/h6NGjlJeXu6tRFQ9di01RT/Ly8khISKC2tpbW1laAaTH0mJgYsrOzdfHQATZv3qyqD9BCZd4K+sTEBMPDwyxZsoRly5aFVdA9N0XB9agXDkH3DrcotvUo/3/zzTcpLCx0e3UzoYegB/LHbjAYMJlMAXvoR48eBa421gpF3ALx0Hft2sXtt9/OTTfdxL59+4Iu+/fEn6CfP3+eqqoq99d6hVwMBoM7BOpdVORJYWGhLh46wC9/+Usef/xxXc59PTBvBV1J90pLS2PFihVhE3S73U5fX9+UMEQ4BN27qEhBr2rR/v5+VfNK5zrkAoGnLjqdTo4cOQLg9iTDEXIZHx/nvffe48477+TGG2/k2LFjtLW1heyhK210nU4n3//+9/nRj3405fiFCxemDLLOy8vDbDbT29ur6aYoXN0YbWlpISUlxefP8qMf/Sjr16/X1K5AHX4HXEiSdCPws8kvc4A3gJeBfwYcwFdlWa6RJCkL+CMQDzwly/JzoVyYEvtUBP3Xv/51KKdTzcDAAE6nM+we+rlz53x6O579XEpLSzWzNzAwQHJyst91cx1yAZeHumfPHtXr29ra6OrqIj4+3u2hh5LxUVxcTG9vr9+ni/fff5+xsTFuv/12urq6sNls7Nu3jy9/+ctB2VVQPPQdO3bw29/+lsLCQn7wgx8Arg+v8+fP8+ijj7rX5+bmuscHau0pL126lN///vesXr16WrhF4cc//rGmNgXq8euhy7J8SJblLbIsbwE+AF4FHgfuBj6Na/QcwGO4RH4z8KgkSbGhXJi3oDc1NblT3vRESR8Mp4c+NjbGrl27uPvuu6cd06v8f3BwUJXAZWdnc/nyZc1CPoGGXCBwD/3o0aNERUWxceNGzTx08J/ptGvXLtasWcOSJUtITU1l5cqVjI+PaxJDHx0d5bnnnuO73/0uzc3N7pa6SkvZyspK93rPUnw9BL2+vp5Lly6J1MF5iOqQiyRJ0cAGQAbssiz3y7LcAigBwg245o7aJtcsD+XClH4qSUlJrFixAoAzZ86EckpVKIIeTg99z549jI2Ncc8990w7ptemrFoPXREHpT9IqAQjrCaTif7+ftXTo44ePcqqVasoKipyC3ooMfT8/HyMRqNfQX/77benzElVirVCFfTly5dz55138s477/DNb34TgNOnTwNXh4h7hlySk5Pd06D0EHS73c7evXuFoM9DVM0UnWQbsAdIAjxdZduk2Ed5DJEe5KrQu5Ek6RHgEYAdO3awffv2GY3V1dWRnJzsbg6VnJxMdXW1Jr9EVqt1RoG6ePEiBoOB0dFR95ro6Gg6Oztpa2sLqfptJrv/9V//xfr165mYmPB5PDU1lUuXLoUkqt62LRYLJSUlfs+p3O+HH37od2ScGts9PT1kZmYGdC/x8fEAHDp0yGeLAm+qq6upqqoiKyuL1157DbPZTF9fH06nM+j3MCcnh1OnTiFJ08bpAq5N7TNnzvC9730Ps9mM1Wp1OyIQ+gfi7373O8CVLJCZmcmBAwcwmUwcOXKEjIwMRkZGGBkZAVwdLXNzc7lw4QLj4+OafRiDK4slMjKSzs5OkpOTp5x7tr8rvVlItj2fwLwJRNAfBJ4FBgDPj/1IWZYnJEmySpJknBT1JGCaOyXL8k5gJ4DZbHbOdmEOh4OMjAz3xS9dupSenp5Zb0YtZrN5xvM4nU5SU1OnxAerqqqwWq3ExcWFlLHgy67dbmfPnj185zvfmfGa8vLyGBsbC+nevW2PjY2Rn5+v6pyJiYmMj48Hbd/T9sTEBNnZ2QGdKzs7m9jYWAYHB/2+zm63U1NTw44dO7Db7e7GY6Ojo6rv1xelpaX09fXN+HolJLRt2zZSU1Mxm83cf//9fPWrX2Xp0qWa/N4qrF69mubmZnJzc+ns7GTZsmVTzm82mykpKeHChQuUlZVpahtcFZu1tbWsWLFiml2tballodr2RlXIRZKkKGA98L4sy6NApCRJyZIk5XNVuI8BWyRJigTWAWdDuTBfqYPhGMfmbVexDdr2NFE4cuQIFovF3VTJF3qEfAYGBlRvEubm5mrWwjiYkIvRaKS0tHTK1PeZOH/+PJcvX2bDhg3k5OTgcDhob28PuQzeX6ZLfX09KSkpUz7w09LSOHPmDNu2bQvari9WrVo1JeTiGT9XUJ5k9UgfVAqMRMhl/qE2hr4NV3xcCan8P+BN4L+Bv5/83s8n/30AeFqW5bFQLmyuBN2zqEhBz0ETr732GlVVVbNmsOhRXDQ4OKgqhg5X0+C0IJhNUXA1ZlIj6EePHmXx4sVUVFS4vabm5uaQp9D7E/S6ujp3VasnFRUVREREBG3XFytXrqSmpga73e5X0PUo8BGCPn9RFXKRZfkt4C2Prw8AN3mt6QA+qtWF+RJ0ZSKLnniW/SsoTar0EPRXX32VBx54YNY1Wgu61WpldHR0Tjz0YIW1rKyMvXv3+l139OhR1q9fj9FoJCUlhdjYWM6dOweE5q0WFRXR2NiI0+n0uY9SX1+vaVrpbKxatYqxsTFOnz5NS0vLlA1RhWXLlpGenq5Lz5N169aRmprqcyiKYG6Zt4VF3oIejvJ7xa6v3iZ6hD1aW1u5ePGiz3RFTxRB12pykNJKNtweut1uZ2RkJCQP3d97cOLECffGpcFgID8/350dFaqHPjIyQk9PD62trfz4xz+eMrx6Jg9dDyoqKoiOjuall14C8Omh33vvve4MGK35+Mc/zoULF8RMz3nINSPoWVlZ9PT0aDYBfiZ8eeiKfa0FXTmf0nJ0JrQu/1dymMPtoSvXH4ygl5WVMTAw4E4rnYnGxsYpnnJBQQFnz7q2c0IVdICTJ09y55138oMf/MB9XqfTGVYPPSoqimXLlvHCCy8QGxvrs8DHYDD4/D3WAoPBMGtDN8HccU0JulL9prfdcHnonsVTs+FZLaoFwXjoFovF75AFf4Qyhb68vBxg1jj6yMgI3d3dU2K7nh56KJui2dnZxMTE8PDDDzM6OkpCQgInTpwAXD/HwcHBsHno4Iqj19XVUV5ernmMXnDtMi8F3el00tfXN03QQZ+NSU98bYqC6w9aD0GPj4/32xtca0EP1EPPy8vD6XSGnOUT6LQiT5YsWcLixYtnbaOslPl7PvHk5+e7nYBQNgiNRiOFhYU4nU7eeust1q5d6xZ0pXFWuDx0cMXRAZ/xc8HCZV4K+tDQEDabbVoMHbQTNV84HI5pHyQKenjoM314eKOU/2tlf3BwkIiICHfBjj+UbJFQwy6hCLrBYPCb6aJ0APQMQSj/DmZakTdPPvkk+/bto7Kycoqg19XVERcX53Y6wsHKlSsB3/FzwcJlXgq6r1BEbGwsSUlJunroAwMDOByOsIZc1MQ5jUYj2dnZtLe3a2JXKftXu6mlZEsEszH66KOPcvLkSSC0kAtcnfo+E01NTWRmZhIbe7WNUH5+fkg2Pbn99tvdnvHatWs5deoUdrud+vp6TCZTWDcJlesQgi7w5JoRdNC/p4qvPi6etnt6ekKOI3uiVtDBtSk329SaQFDbmEvBYDAEtTFqt9vZuXMnBw4cAFweekRExBTBDQQ1Hrr3BrOWgu7J2rVrGRkZ4dKlS2HNcFHIyMjg+eefn7UgTbDwuKYEXc/5muDqbwLTx8DB1Ri+skYL1IZcwP+Qg0BQ25jLk2BSF81mMzabzR3bVnLQg/Vky8rKZk1dbGpqmlbsogi61n3BKyoqWLRoESdOnAhrhosnDz30kOqwmWBhMG8F3ddmod4e+qFDh8jNzZ1V0LW0H4iHbjKZ5sxDh+BSF5Wxbcrrghlu4Ul5eTmjo6Mzhp58eeiLFy8mOTlZcw89MjKSVatWceLEiTnx0AUCX8xbQQ/XxqQne/bs4bbbbvPpQS5ZsgSDwTBngu45tSZUwuWhewt6sGX/CmVlZQAzxtF9eejg8tL16Gmydu1a9u/fj8VimRMPXSDw5poSdD1DLleuXOHAgQMzNlKKjIwkIyNDU0EPNOQyNjamif1we+hmsxm73R5yP5WUlBTS09O5ePEiXV1dbNiwgbfffhtw/fw6Ojp8CnpJSYkuRTZr165FlmUA4aEL5gXXlKDr6aEfPnyYsbExbrvtthnXaG0/UA8d0CSOHqyH3t7ejsPh8L94kqamJnJzc7HZbO6Oh6E2iyorK+PUqVPcc889HDt2jBdffBG4OjvUV9Xtr371K37605+GZNcXa9euBVyVm0qsXiCYS645Qe/r69M000Rh9+7dLF26lJycnBnXaCnoY2NjjI2NqRb09PR0Fi9erImgB+uhW63WgCp1m5qauPXWW93/DtVDB1cc/emnn6atrY0vf/nL7gwa5WnAl4eel5enS454VVUVUVFRFBUVERkZyGgBgUAfrilBV4qLtMw0UVDi57OhpaCrLftXMBgMmm2MBuuhQ2DFRY2NjaxZs4aEhAQaGxtDjqGDK/86ISGBN998k7/8y7+krq6Ojo4OmpubSUtLC3qqUjBER0ezYsUKET8XzBuuKUHXq/x/aGiIo0eP+h1EkJOT4360DxVfw6j9UVJSEpSHfujQIXbt2uX+OpDhFgpZWVkYDAbVG6M2m43W1laKi4vJy8tzD/kOVdC/9rWv0dDQwJo1a9iwYQNRUVFUV1fPuCGqN9/4xjf44he/GHa7AoEv5uVz4kyCrvRf1lrQ9+/fj9PpZPPmzbOuKyoqcpeXh0qgHjq4Nt7ef//9gG39/Oc/p6GhgS984Qs4nc6AhlsoREVFkZWVpdpDVzZCi4qKyM/P1yzkEhUVRUZGBgCLFi1iw4YNVFdXMzg4OCeC/pnPfCbsNgWCmVAl6JIkbQG+h8uj/3fg60AEYAeekWX5T5IkZQF/BOKBp2RZfi6YC2pra6O5uZmqqqppx6KiokhPT9c802X37t2sX7/er8gVFhbS1dXF2NgYixYtCslmb28v0dHRARWGmEwm/vCHPwRkx+l0cvjwYS5fvozT6eTy5cs4HI6gCm1yc3NVe+hKTFtrD92bjRs38uabb5KcnMy6des0PbdAcK3hN+QiSdIi4FvAXbIs3yrL8iuTh+6SZXmLLMt/mvz6MeCfgc3Ao5IkBVXf/fLLL5OWlsaWLVt8Htdj0MXhw4fZtGmT33WKB6hUPoaCkrIYSNVkSUkJFovF3eRKDU1NTXR1dTEyMkJXV1fArXM9yc/PV33vTU1NJCUlkZycTEFBgdtD11rQN23aRE1NDWfOnBEj0QQLHjUx9BuBMeB1SZJemfTEHcCbkiT9ryRJyl/RBlxzR22ADCwP5oJeeukl7r///hmzBvRqkpWdne13nSIYWoRdAklZVFBynWebbenN4cOH3e/lxYsXA26d64lS3KSGpqYmdwphXl4eLS0tDAwMaF7gc9NNrkmIfX19QtAFCx41IZdMoBT4CK5h0T8EHpRluVeSpM3Ak8DHgCiPIdKDQKr3iSRJegR4BGDHjh1s3759yvHOzk4OHjzIV77ylRkf7RMTE2lqagppJJrVap3y+r6+PhwOh6pzpqWlcerUKZ8hoUDsNjc3k5CQENB9GI1GIiIiOHr0qOoPg927d7NmzRouXbrE0aNH3RkZY2NjAb+HSlGPmtedO3eOrKwszGYz2dnZ2O12RkdHmZiY0GzgtEJVVRVnzpwhLi5uyrm9f87hZCHaXoj3PBe2lXbWvlAj6APAQVmWJyRJ2gP8vSzLvQCyLO+XJOlfJ9dZJUkyTop6EtDnfSJZlncCOwHMZrPT+8JeeeUVkpOTeeihh4iKivJ5McXFxRw7dmzWm/KH2Wx2v97pdDI8PExxcbGqcxYXFzM4OBiUfU+74+Pj5ObmBnyewsLCgOzX1NSwadMmbDYb3d3d7ontFRUVM77HM7Fu3Tp6enpITEz0Gzrp6upi9erV5Obmup8KANXvcyBs3bqVM2fOsH79elJSUtzf93y/w81CtL0Q73mubXujJuRyDFgqSZIBWA00SJKUCCBJ0jKg32PdFkmSIoF1wNlAL+bFF1/k4x//+KxCo3XIZXR0FJvNpjoEoVWmSzAhFwis6+LY2BgnT57kIx/5CCUlJVy6dInBwUHi4+MDFnO4OpFHjf2mpib3HM6kpCR3qEXrGDq4hhavXr06qH0BgeB6wq+gy7LcA7wC7Me16fljYK8kSdXAb3BtmAL8HPh74ADwtCzLY4FcSGdnJ9XV1Tz44IOzrsvKytI0yyXQTcLCwkJ3BkcoBCvogcSxT548ic1m4yMf+QjFyYs2UgAAFd1JREFUxcXuGHqwwpefn09kZKRfQbfZbLS1tblj6AaDwf1vPQT91ltv5eTJk2IKvWDBoyptUZblXwO/9viW5GNNB/DRYC/k9ddfJzExUVW15tDQEKOjo8TFxQVrzk2gm4RFRUU8//zzIdsNxUPfs2ePqrWHDx8mLy+PvLw8SkpKqKuro7+/P+je4JGRkRQXF1NXVzfrura2NncOukJRURGnT5/WpeuhQCBwMW8qRZubmykvLyc6OnrWdUoTJK0KfBRBD8RDN5vNIfeTCaTToielpaU0NTVhtVr9rj106BAf+chHAFfs+sqVK9TU1IQUmigtLfUr6L76qijhFz08dIFA4GLeCHp/fz+pqdMSY6aheH1ahD3gashFrdeqTH4PZWCy1WplaGgoKA+9vLwcm82mKnXx8OHDUwQd4NixYyFN71ETw29qaiI5OXnKB0dRURFGo1GTpyqBQOCbeSXonhkKMxEbG0t2dnZAudizMTAwQFxcnOpNQi1y0fv6XAlAwYZcDAbDrMOSATo6Omhra+OGG24AICEhgaysLBoaGnT30Ovq6tztfhW2bt3Kww8/LOLcAoGOzBtB7+vrUyXo4PI2tRL0QFvJKtWPoTwhBNOYSyE2NpaioiIuXLgw6zplmPKyZcvc3ysvLwdCm69pMploa2tjfHx8xjW1tbXu9EiFlStX8txzQXWDEAgEKpk3gq7WQwdtBT2YrI/CwsKgPHS73Q4E15jLk/Lycr8eekNDA4mJiVPeU2WEW6geutPpnPX99yXoAoFAfxa8oAcz7KGoqChgD/3UqVMsX76choYGent7MRqNQXvKFRUVfj30hoYGSkpKpoQ4tPDQi4uLMRgMM8bRrVYrly5dEoIuEMwB16SgFxUVXXMe+qFDhxgeHuaHP/whvb29pKamYjQG9/ZXVFSo8tC949haeOgxMTHk5+fPGEevr6/HZrMJQRcI5oB5IehOpzNgD72/v9+doRIKwXjowQh6TU0NSUlJPPfcc+zfvz+o+LlCeXk5HR0dDA0NzbimsbFxmqBr4aHD7JkutbW1REREiKHJAsEcMC8E/fLly9jt9oAEHQLrOjgTwXjoRUVFtLa2umPiajh9+jQPPPAAGzZs4LnnngtpCn1FRQXArF66Lw/dZDKRmJgYcldCz0yX1157bcpmZ21tLaWlpX7rCQQCgfbMC0Hv73e1g1Er6Pn5+URERGgi6MF66MokezU4nU7OnDnD0qVL3dPnQxH03NxcFi1aNKOgj46O0tnZ6f7gU4iNjaW9vd3dcjZYSktLqa+v55133uGBBx7gO9/5Dk6nExAbogLBXHJNCnpkZCT5+flz6qGD+uKm1tZWBgcHqaysZOvWrdxzzz3ueHYwGI1GysvLZ9wYVd4Xbw8dCGhC0kwow6ofeOABbrvtNjo6OqipqQGEoAsEc8m8EnQ1laIKWmW6BOOhp6amkpSU5M719kdNTQ0Gg8EdKnn11Vf5xS9+EfC1ejJb6mJjYyMGg0G3gQ+lpaXY7XY2btzI66+/Tm5uLrt27cLhcHD+/Hkh6ALBHDFvBD0iIoKEhATVr9FK0IPx0A0GA5WVlX5TBxVqamowmUzuOaQREREhV0zOlrrY0NBAXl4eMTExIdmYiRUrVvD73/+e559/nqioKG6//XbefvttzGYzIyMjQtAFgjli3gh6SkpKQCKnhaDbbDZGRkaCyvqorKzk/PnzqtbW1NSwYsWKgG3MhpK66HQ6OXXqFA888ABjY66Oxb42RLXEaDTy+c9/3v0BfMcdd/D+++8jyzLgem8EAkH4mReCHkjZv0JxcTFNTU3uzbhgCGVgckVFxZwKenl5OSMjI9TW1vKJT3yCl19+mXfffRdwCbr3hqiebNu2DavVytNPP01+fn5AT1oCgUA75oWgB5KDrlBcXMzo6CgWiyVou4G2zvWksrKShoYGv21srVYr58+f10XQAe6//36sViuSJPHqq68CvnPQ9SQtLY3169fzzjvviHCLQDCHqBpwIUnSFuB7uD4A/h3oxjW9yAF8VZblGkmSsoA/AvHAU7Isq+7EFKygg0u8MjMzA3qtQqCtcz2prKzEZrNRX18/a4jhwoULWK1WzQU9OTmZJUuW0NDQwIEDBzhy5Ag//elPsdlsuodcfHHHHXdw9OhREW4RCOYQvx66JEmLcI2Zu0uW5VtlWX4FeBy4G/g0rtFzAI/hEvnNwKOSJMWqvYhgBD0rK4vY2NiQ4uiheOgmk4mIiAi/YZeamhpiY2Pd8zi15OGHH+bJJ5/kxhtv5L777qO7u5vXXnuN0dHRsAv6nXfeCSA8dIFgDlHjod8IjAGvS5I0CvwNYJdluR/olyRJyTXcAHxLlmWHJEkysByQ1VxEf39/wAKkzKkMVNBfeeUV9+T5wcFBIiIigsrNjo6OpqSkRJWgL1u2jIiIiIBt+OPf/u3f3P8uLi5m5cqV/PKXv3R/HU42bNjA/fffz7Zt28JqVyAQXEWNoGcCpcBHgG3AjwDPJiI2SZKigShZlh2T3xsEpiWVS5L0CPAIwI4dO9i+fTsAXV1dlJeXYzabA7r47OxsampqVL9ucHCQhx56iG9/+9tkZGTQ2NjI4sWLVVd8elNUVMTJkydntX/s2DFMJhNmsxmr1RrwPQbCrbfeyhNPPEFsbCw2m22KLb1tAzz55JMA0+yEw7Yv5sruQrW9EO95Lmzn5ubOeEyNoA8AB2VZnpAkaQ8uQR/2PMfkMaskScZJUU8C+rxPJMvyTmAngNlsdioXNjIyQkFBwawX6os1a9Zw6NAh1a87ePAgNpuNpqYmcnNzMRqNpKSkBGxXYfXq1VRXV8/6+vr6ev7mb/6G3NxczGZz0LbU8LnPfY4nnngCk8lEXl7elGN6256NubK9EO95Lm0vxHuea9veqMlyOQYslSTJAKwGzgGRkiQlS5KUz1XhPgZskSQpElgHnFV7EWrniXqzfPlyzp49qzp18Y033gBwdwoMpqjIEyUXfSb7Y2NjNDU1hS2uvGbNGvLz88MePxcIBPMDvx66LMs9kiS9AuwHnMAXgFzgzcmv/2Zy6c9xZbn8E/C0LMtjai4g0Na5nlRVVTE0NERbWxv5+fmzrnU4HLz11lssW7bM3SkwmLJ/TyoqKhgYGKC7u5slS5ZMO37hwgWcTmfYBN1gMPDTn/6UxMTEsNgTCATzC1Vpi7Is/xr4tce36oGbvNZ0AB9Va7ihoYHc3NyAW+d6oszLPHv2rF9BP3bsGN3d3fzsZz/jS1/6Ej09PZp46ADnz5/3Kei1tbXExsbq1lPFF5/5zGfCZksgEMwv5qyw6Lvf/S4QeKdFTxISEigqKuLMmTN+177xxhuUlZVx7733Ai7vOVQPPS0tjfT0dHemi8ViweFwuI/X1tZSUVGhS4aLQCAQeDNngq7Evvv6XCH4YAQdXHF0tYJ+9913k5GRQVJSEufPnw/ZQ4ercfQnnniCvLw8fvvb37qPiVayAoEgnMyZoA8ODtLa2hqShw6uOPrZs7Pvv3Z0dHDixAnuvvtuDAYDJpOJ8+fPh+yhgyuO/h//8R98+9vfJicnh927d7uPCUEXCAThZM4E3Wg0curUqaBa53qyfPlyzp07NyXU4c1bb71FQkICmzZtAlz9vC9cuKCJh75p0yby8/M5cOAA3/jGN6iursbpdGKz2bh48aIQdIFAEDbmTNBLS0s5efJkUK1zPVm+fDmjo6OzTg86evQoN9xwg3vOpZYe+uc+9zkuXbrEjTfeyMaNG+nq6qKurs7duEsIukAgCBdzJuhVVVVuDz3YcAu4YthGo9EdRzebzdMm+Zw+fZpVq1a5v1ZGqGnhoXuyatUqFi9ezIEDB6itrcVoNIY0ak4gEAgC4ZoXdKXx1dmzZ3E4HNx333187nOfcx93OBzTBF0ZoWa320P20D2JiIjg5ptvprq6mtraWkwmk25TgwQCgcAbVXnoelBVVUVTUxONjY1BVYl6n+vMmTM8++yzHD9+nKioKMbHx93dGEdGRli5cqV7fWFhIZGRkdhsNk09dICNGzfyzDPPhLWgSCAQCGCOPfT/v717j5GqPOM4/kV2syUWLRsR4q4plFoWiLjEh7KLLOKlKdJWolVDhXjBy/aC1VhJSvBCozWVRGOhwVhti7VptNZaY6um1LIG5VIfoTQqbeUSa7fUqihUaXSx9I/3HXZYV3Zmz5kzevb3ScieuZ3feZfZZ95558z7AnR0dCTqoUMYR9+wYQOLFi1i3rx5dHV1sXHjRgA2b95MTU3NQcW1traWMWPGAP2bC/1Qpk+fzvbt21m9erXmBheRTFWtoNfX19PY2MjOnTsTF/QJEyawbds2ampqWLFiBY2Njaxfvx4IBb2pqel9Qx9jx44F+jcX+qFMnjyZuro6Xn75ZfXQRSRTVV2Crrm5Gej/OegFhfHxW265haFDh9LS0nKgoPccPy8o9J7T7qHX1dUxZcoUQIs9iEi2clHQm5qa2LRp04F5TFpaWli3bh0QeujF4+cFEydOpL6+ntra2kTZvWlraztwXCIiWanah6KQXkEv3hdAa2sr11xzDVu2bGHHjh299tDnzJlDa2tr4tzezJ07lz179qTe+xcROZSq9tAnTZoEpFPQe+63trb2wLwqvfXQBw8eXLF5w8eNG8eyZcsqsm8RkQ9S1YI+evRoFi5cyNSpU/u+cxmGDBlCc3Mz99xzD8OHD2fkyJGp7l9E5MOoqgV90KBBLF26lBEjRqS+79bWVnbt2sXEiRP7Pa2AiMhHSVULeiW1tLQA9Dp+LiKSR31+KGpmowjrhRbmqD0XWAsUlrn+rruvMrMmwgLQNcB17v5E+odbOhV0ERloSj3L5Ul3P6dwwcx2u/uMHve5GbgEeAV4DKhqQR81ahTLly/nzDPPrOZhiIhkZtAHrVhfEHvo64CtwBpgMbCFULg7gQXuvsvM1rt7S3zMI8DF7v5aj31dDlwO0N7efuKsWbPSbU2Jurq6KnL++Yc1d6BmD8Q2VzN7ILa5GtkNDQ0f+KFgKT30ncCngb3AXcDZwEnu/rqZXQB8B7iCg8fjdwP1wEEF3d1/SBiWobOzc39DQ0MZzUhPZ2cn1ciuVu5AzR6Iba5m9kBsc7Wze+qzoLv7O8A7AGb2K6DF3R+MN/8SuDRuFy8ZdCSwK8XjFBGRPvR5louZDS262AZsNbO64stxe6eZjYn3r+853CIiIpVVypDLNDO7iTDksgO4HVhrZm8Teu7z4/0WAyuBwcAN6R+qiIgcSilDLo8RzlopdmIv93uB0GMXEZEqyO0Xi0REBhoVdBGRnFBBFxHJiT6/WCQiIh8N6qGLiOSECrqISE6ooIuI5IQKuohITqigi4jkhAq6iEhOqKCLiOREqSsWlczMjgRWAeMJU+0+Z2bfIsyj/hZwkbvvjDM2LgOOA/7j7rPN7EvAtUAX8Ky7X5lh9gnAHTF7DzDH3d/OIrtoH98GznF3y6jNM4B7gW3Ae+5+Wqm5abTZzOYQFjw5DFjk7usyavdZQOG59SngVnf/fga5Q4BfAEcA+4Dz3f2VjNp8BPAzYCjg7r6w1Nwys+8ExsaHTQGOIfw93RWP51l3vyqj3OGE33cTcJS7v5Vhm6eRoJb1VyV66HuBLxDmSsfMRsbL04Dr4j8Ii2I86u6nFhW1zYTFM6YBR5tZyYUthewX3H2qu58MPAuclWF2YZri48vMTJwL3O/uM8ot5kmzzewYYDZwWswvuZgnzXb3h2LmDMKL2a+zyAXOAJ6Lz7GVhCUbM2kz4YXzYXc/BTjczD5biWx3b4+/14uAde7+BvBF4J/u3hazWzPK/QdwMrC+zLamkZ20lvVL6gXd3bvc/dWiqz4JPO/u+4GNdM/IOJMwNW+HmbXHx/7d3ffF29/l4EUzKp3dVfS4IcBfs8qOrgR+UE5mSrlfNrM1ZlZ2DyJh9kzC9MurzOxeM/t4htnAgT/QOnd/KaPcrcDhcXsYPVb0qnD2GOBPcXsjML1C2QXnAg/E7anA7+L248BJWeS6+153311qVsrZiWpZf2Uxhr4NsPg28HTC0nQAxwJ/jNedb2aNhQeY2WTgaHffmGW2mc00s03ADLoX7qh4dnxrd3w/eqmJcgEnvFU8DZhpZu+bFrmC2SOAo4DPEdasXZBhdsHZwIMkU07ui8B4M3se+Crw8wyzXwBOjbefTnhBqUR2QfHvdhhh2AW6l6fMIjdtZWenWMtKUvGCHlcuuoPwCn0G8Jd405vAH+Kr2FriGFR88t0OXJh1trs/7u6TCP8p7e/fY8WyrwKWJ8nrT667v+Xu77r7u8AjwAlZZcfrVsfezhPAhAyzC84hvp3OKPdC4Cl3nwBcT/cQSRbZdwPjzOz3hPHff1Uou7Cw/F53/3fR8RwRtxMtT1lmbqrKzU6zlpUqk7Nc3P2ncdzwIaAjXv000By3TwB2xHHk+4D2tP5TysiuK3rYbsL4WSbZhEW4rzWzx4HjzGxxFrnxg7KCaSR/V1JOm4uvawa2Z5iNmY2gzOGWFHIH0T3M8hqhuGWS7e7/dff57n56vP43FcqG8EL5QNHltYQeLcDn4/FlkZu6UrMrUctKUZHZFs3sUcIT6iXgTsKY3tHx8jfcfW/8g1pJeOVe5e5LzOw6wlvRF+OubnD3JzPKng1cDewHXgcu8DLOckmS3WMf7mWc5ZKwzZcSPizbBzztZZ75kLTNZnYzYXz1HWCul7kObcLsrwFD3P22rNoch9buBz5GWKrxEnf/W0bZzYTe4v+Ae939J5Vod7zfWmB2YfzZzGoI7xDGAJvc/ZsZ5Q4jFNkTCZ8fLPWwAlsW2YlrWX9o+lwRkZzQF4tERHJCBV1EJCdU0EVEckIFXUQkJ1TQRURyIvXJuUSqLX7JY0e8eL273xiv/xEwH8DdB/Vz3+OB84AOd++I160kfHlksrt7kmMXSUIFXfLuIjO7iTCHynkp7G88cEPc7khhfyKp0XnokjtFPfTthOlxTwVGAysI39BsIAw3LgYuI8zJ4cACd3/ezJYQivbdhHl9PgF8HXiG7p5/wSmEWfYuBG4lTNB0GGFq3DWVaaFI7zSGLnm2BdhAGGaZT5gm981428XAjcCfCYV9MvCwmdUWPb6NMAPmkcD3gFcJ37aEMN/PVwiTXhVMJcz73QgsSb01In1QQZe8+zGh13wSUPx191nx59Xuvgx4mPDV9M8U3ec2DwtfbAdGxakgCvOQPOfu9/WYp2OJu99EmMpgVOotEemDCrrk3X3Ae4TFDlb1cvv+Hj+LFWYF3Ef338qhxiiL7z+4vMMUSU4FXXLN3fcQhlva3b14kYHfxp+3mdkVhNWTtgF9TZb1RvzZZmZzLCwrJ/KhoLNcJPfc/f5erl5J+HD0MsKHps8QPhTt6mO1sKcI87dPj487NtWDFUlAZ7mIiOSEhlxERHJCBV1EJCdU0EVEckIFXUQkJ1TQRURyQgVdRCQnVNBFRHLi/yhr70TKMhinAAAAAElFTkSuQmCC\n" }, - "metadata": {} + "metadata": { + "needs_background": "light" + } } ], "source": [ diff --git a/examples/multivariate-examples.ipynb b/examples/multivariate-examples.ipynb index 1362c92c2a..e066fedccf 100644 --- a/examples/multivariate-examples.ipynb +++ b/examples/multivariate-examples.ipynb @@ -49,14 +49,15 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAEXCAYAAABBFpRtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy9eXxU9fX//5ot6ySTdbLMECALCclMBAKJtIqiARJA61pRAa1aW4pi3Vup+qmt28+2fFyo9lM3aK0fa237+xQMArVQqgIBJNwBspEF7s2+TTIhM5nt+8d4h0nIMstdh/t8PHw8ZO7c9/ud97zf555z7jnnLRsYGHBDQkJCQuKSQM73ACQkJCQkuEMS+hISEhKXEJLQl5CQkLiEkIS+hISExCWEJPQlJCQkLiEkoS8hISFxCSFooW+xWPgegoRE2CDtJwlA4ELf7ZZSCCQkmELaTxKAwIW+hISEhASzSEJfQkJC4hJCEvoSEhISlxCS0JeQkJC4hJCEvoSEhMQlREhC/8iRI1i1atVFn1dVVWHp0qVYtmwZtm3bBgAYGRnBunXrUFlZiVtvvRU9PT2hdC0hISEhEQRBC/1XX30VmzZtgs1mG/O53W7HU089hb/97W/YuXMn3n//fXR1deGdd95BYWEhqqqqsGbNGrzyyishD15CQkJCIjCCFvqzZs3CH/7wh4s+r6urQ3Z2NhISEhAREYHLL78cX375JQ4ePIjy8nIAQHl5Ofbv3x/8qCUkJCQkLoLqkeGdT1VTfkcZbOPf+c530NraetHnQ0NDiI+P9/5brVZjcHBwzOdxcXEYHBycto/xVoSEhETwWK1WvocgwTAuF0C0qLD3WBT2HouEqSUCmhgX7l1pn/SeoIX+ZMTFxY1J97ZYLNBoNGM+HxoagkajmbatyMhIxMXFMT1ECYlLFmk/iZ8RG/DvEwpUHVLis2ol2vvkmJ3hQmWpAy/efx6Xz3VOeT/jQj8/Px9nzpxBf38/YmNj8eWXX+LBBx/E2bNnsXv3bpSUlGDv3r1YvHgx011LSEhIhCVd/TLsqlZi12EF9h1XwmoHSvOd+OH1dlSUOjBH74JM5l9bjAn9jz/+GMPDw7j77rvx/PPP46abboLL5cLatWuRmZmJe++9Fxs2bEBFRQVUKhXefvttprqWkJCQCCvcbuBUqxy7Diux67ASR+rliI0CrpnvwK82WLF8oRMpmuBqKcmEfDD60NBQwObol19+iXfffXfS67fffjuuvfbaUIcmGsxmMzZv3jypP3fOnDl44oknOB4Vv7z66qsgCGLCaxEREfjFL36B5ORkjkfFPpPtpwMHDnhDqydi7dq1uPrqq1kcmbDo7+/Hz372s0nfKRYWFuKRRx5hvN9RO/CFSYGqbwT92S459CkuVJY5UFHqwBVGJyKnfkfrF2GXnPX+++/j8OHDcLvdF/339ddf43/+53/4HiKnHDhwAB9++OGE89Hd3Y0XX3wRw8PDfA+TM+x2O55//nm0t7dPOCeffPIJPv/8c76HySnvvvsujhw5MuF8HDt27JKzyvft24c///nPE85HZ2cnXnjhBcZeivcNAh/9S4nvvRyF3LVq3PhMDI7UKbB2mR0HXhsG8e4wXvmhDdcuYEbgAyz49PmGIAjccccd+MlPfnLRtd/+9rfYunUrD6PiD4IgkJ+fj3feeeeiaxRFoaioCKdPn8bChQt5GB331NfXY3R0FK+++ipyc3Mvul5eXg6CIHDrrbfyMDp+IAgC69atw6OPPnrRtddee23CtRPOEASBwsLCCf/ulpYWzJs3D7W1tZg3b15Q7TdSMlQdUqLqsBIHTysQoQSunufEL+6xYcUiB9KT2HW+hJXQt1qtqK+vh8FgmPC6wWAARVHo6+tDUlISx6PjB5PJNOl8ZGZmIjExESaT6ZIR+iaTCTExMZg9e/aE1w0GA0wmE8ej4o/h4WGcOXNmyj3T2toKs9nsV8RdODDVnpk5cybi4+NhMpn8FvoOJ3DotAK7DnsEfSMlhzbBhYpSBx68aRRXFTsRE8XkXzA1YSX0a2tr4XQ6YTQaJ7xOf04QBK666iouh8YbBEHg+9///oTXZDIZjEbjpP7tcIQgCBQVFUGhUEx43Wg0YufOnRyPij9OnToFt9s96Z6hhd/JkyfxrW99i8uh8QZBEHjooYcmvCaTyVBUVDTtnjEPA58f8wj5PUeV6B+SoXCWEzd8247KMgfm57og58m5HlZCnyAIxMfHIysra8LriYmJ0Ov1MJlMl4TQHxgYwNmzZyfd0IBnUx89epTDUfHLVFoc4JmP7u5udHZ2Ii0tjcOR8YPJZEJSUhIyMjImvK7VapGWlgaTyXRJCP2enh60t7dPu0YmsgZbO2Vebf4Lk0epuMLgxE/v8LhtZqYJI2Ym7IS+wWCAbIqAVYPBcMlotidPngSAKRew0WjEtm3b4HK5IOdL9eAIt9sNgiBw/fXXT/qdwsJCyGQyEARxSQh9giBgNBqn3DOXkjVIC/Pp9sxHH30Ep9ONrxs9SVJV1UqcalEgMc6N5QsdePsxK5bOdyA+hquR+09YCf3ptDjA82Pu2rWLoxHxi8lkQkZGBlJSUib9jsFgwPDwMFpaWpCdnc3h6Lino6MDvb29U66RuLg4zJ49GyaTyVsrKpwxmUxYtGjRlN8xGAyXTK0sgiAwY8YMJCQkTHh92AqYlVdjMO1XmLMuGr1DKuTpnKgodeJXP7ShtMAJ5cSeQ8EQNqqd2+2GyWSa0pUBeJ7SdXV1GB0d5Whk/EFrcVORn58PlUp1SWhyBEFAJpOhsLBwyu9dKpqty+XCyZMn/dozp06dgsPh4Ghk/DHRnmnvleH9XSrc9vNo5Nypxn99VAhE52KFwYQjb1lQ/dZ5/OIeG75VJHyBD4SR0D979iwGBwf9WsB2ux11dXUcjYw//LF8IiIikJ+ff0kIOZPJhOzsbKjV6im/d6lE8DQ3N2N4eNgv69hms6GxsZGjkfGHyWRCUZEBJ5rkePnDCCx9OAZz71bjmfciERPlxmsPWtH4RwsKRn+EmYpPkKsThp8+EMJG6BMEAYVCgYKCgim/N2vWLKjV6rAXcna7HadPn572IQhcOpqtP5YP4JmPhoYGnD9/noNR8QdBEIiIiMCcOXOm/F5ubi6io6PDeo3Y7EDVQRdO2x/Au8TPsOShWHywV4XSuU78/788j8Y/WvDek1Z892oHEuPEvWfCRuibTCbMmTMHUVFTB7zK5XIUFRWFvSbX0NAAm802rRYHeDQ5+qVvOOOP5QN45sPlcuH06dMcjIo/6MS9iIiIKb+nUCgwd+7csNszPWYZPtirxLoXopB9hxp3vBAPd0wxbl86hC9eH0bN28N4+X4brrrMiYhx2bBitgbD5kWuv1ocIO6ntL/QSUj+vJw1Go0gSRL9/f1ITEzkYHTcMzw8jMbGRr/WiE6n8yatlZSUcDA6fvDnHRhNOOwZtxuoOyf3hlUerpUjOgJYOt+Bl+63Yqj1I7z03MN47vstkMtdU7ZlNBrR0tKCwcHBMeeHiIGw0vT90eKAC09pt1t8/jh/oVPJJ0tC8sU3aS1cOX36NNxut19rRCaTXRKhvXSIsz+IVbO1Ozy153/6+0gs+EEsLt8Yi9/9Q4XCmU7879MjOPOBBR9stmLdMgfONlajqKjIr9Bl36Q1sREWmr7ZbEZra2tAWkt/fz8oioJer2d5dPwQiBZHJ60RBIElS5awPDJ+IAgCSUlJyMzM9Ov7RqMRx44dY3lU/NHb24u2traA9kxXV5coktYGLMDeo55KlXuOKmEeluGyHCe+e7UdlaUOXJYzce35QB6CdNIaQRCiOxskLIS+P0lIvsydOxdyuRwmkykshT6dhLR69Wq/7wn39xy0JThVEpIvBoMB27dvD9ukNfq39lfoFxUVee8TotBvbpfh00NK7KpW4quTCijkwJJiJ55Zb0NFqQO6lKmtejrk+7bbbvO7T7FaP2Eh9AmCQHp6OlJTU/36fkxMDHJzc0EQBCoqKlgeHfd0dnaip6fH7w0NeDZ/OCetEQQxbRKSL0ajERaLBa2trZMWZxMzBEFAr9dPmoQ0HjppjSAIQZxH4XQC1XUK7DrsqT9fd06BFI0LKxY5cf9qK5bOc0Ad7X97586dg9lsDnjPiDFpLSyEfiCuDBqj0SjKp7Q/+JuE5IvRaMSrr76K0dHRaaM5xAadhHTPPff4fQ+dtHbixImwFfpi2zND54HPv/a4bXYfUaB3UI6CGU6sLHPgtQetWDjHBT9eYU2IyWTyK+TbF6PRiLfeegsOhwNKpXhEadB2q8vlwsMPP4xly5Zh1apVaGpq8l47ceIEVq1a5f0vLS0Ne/fuRX9/P7Kzs72fv/nmm4z8EYH44mjC+UWdv0lIvoRz0pq/SUi+0Elr4aoYBBL4QMPHniG7ZXh7pwo3P+vJhr33lShQPTI8dtsojv/egoO/PY9n7xpF2dzgBT7gkSF5eXmIjvbfPDAYDLBaraJLWgv68bRjxw5YrVbs2bMH1dXV2Lx5Mz788EMAQHFxsbc87d///ndkZmaivLwc+/btw80334xXXnmFmdEDcDgcOH36NDZt2hTQfUajEc3NzUEdySh0gnkI0klrwVhNQsdkMvmVhDSecFUMbDYb6urq8OSTTwZ0n9FoxEsvvYSRkZGAhGMguFxAzRk5qr4JqySaFNDEeoqYvfmwFdcucCDBf13Gb4JZ93TSmslkCshC4JugNf2DBw96C1ItWrQIx48fv+g7w8PDePHFF/HSSy8BAI4fP46amhqsXLkSd911Fzo6OoLt3ksgSUi+GAwGuN1unDp1KuQxCI1gFjCdtBaOQs7fJKTx8O3OYIu6ujo4HI6A1whbSWsjNuCzagV+/EYkir4Xi6WPxOIv+1VYUuzEP17wZMP+/jErbl7CjsAHglOU6KQ1se2ZoDX9oaGhMUkJCoXiIt/WH/7wB3znO9/xHjKdl5eHp556CldffTX+/Oc/44knnsD27dsn7WOyg4l9qa6uRlRUFLRaLYaGhvwef0xMDFJSUnDkyJGAfN9C5/z582hoaEBOTk5A8wF4/Ng1NTUB3yd0jh8/joKCgoD/rpycHJAkibNnz4ZF0hp9rmt1dTXUajWSkpICmhONRgONRoMjR44gLy8vpLF0Dcjx+ddR2H0sEgeISIzaZSiZM4rvrbBg2QIrcjId3rBK6wjAzIm0EzM0NISWlpag9kxBQQGOHz8uuD0zlfciaKEfFxcHi8Xi/bfL5broZcbHH3+Mbdu2ef+9ZMkSxMR4CkyvXr0aL7zwwpR9REZGTut6aWxsRFFRkd9RCL7QNVbCyb1TV1cHt9uN0tLSgP+uBQsW4B//+AfUarXfoY1i4PTp09i4cWPA81FaWgrAcy7qZAfziI24uDg0NDTAYDAEdfxhsHvG7QZOtcpR9U1Y5ZE6BdTRblwz34EtG21YXuJEssYNQAaAHdfRZNDWXDB7Zv78+di7d6+oZEjQ7p2ysjLs3r0bgEdzGK8tm81m2Gy2MXHwmzZtwv/93/8BAPbv3x/0wcK+hOKDDkfz3WQyITEx0e8kJF/opLW2tjYWRsYPfX19oCgqqDWSlJQEnU4XlmuEiz0zagf+9bUCT/wuEsX3xeLbD8bi/V0qzMtx4pOfn8eZDyzY/lMrbr/G8Y3A5wc690Cr1QZ8r2/SmlgIWtO/7rrrsG/fPixfvhxutxtbt27FG2+8gezsbKxcuRJnzpy5SDt69tln8cADD+Dtt99GbGwsXnvttZAG73a7ceLECaxcuTKo+w0GA37/+9/D6XT6Va5ADPhzEtJk0ElrBEFAp9OxMDruof2twQq5cHuZSyfu3XrrrUHdbzAY8Mc//nHSpLW+QWDPUSWqDinxz2NKDI3IsCDPiXXLPGfDGmZNnA3LJ8H482mEnrQ2EUELfblcji1btoz5zDc6YsGCBfjTn/405vqsWbOwY8eOYLu8iGCSkHwxGo0YGRnBmTNnAo7sECqhFAkLx6S1QJOQxmM0GvHZZ58xPCr+IEky4CQkX4xGI4aGhsYkrTWQnrNhPz2sxKHTCkQogasuc+KX99qwfKEDGcnCrnFFEETQZ2YLLWnNH8STUTABtJkZ7IvYvLw8REZGessyix2XywWTyYS777476DbEmlo+GcHEo/sSbklrBEFALpdj7ty5Qd2fn58PhTISH+/uxJCqAFWHlWik5EhLdGHFIgc23TSKq4qdiJm6wrlgoEO+N27cGHQbYtszoi4qQhAEsrOzg36JolQqRRlyNRktLS0BJyGNJxxK6PoSTOapLwaDAXa7HfX19QyOij9MJlPASUgAYB4G/nZAiQff0ABlbXhhxzJ8/rUCN1xhxz9/PYzT7w/jtQdtqCwVj8AHPIEgVqs1pDUitj0jaqEfqhYHiO8pPRUEQUClUiE/Pz/oNgwGgzdpTeyMjo6ivr4+pDUye/ZsxMbGimpTT0Ug/uvWThl+9w8Vbng6Grlr1bj/N1HoMctwWeLfcXXM9/DF6+fxs7WjKJnjglhr0plMJkRFRSEnJyfoNgwGAxoaGjAyMsLgyNhDpD+Vh1C1OEB8T+mpCDYJyRej0Rg2SWu1tbWw2+0oLi4Ouo1wO2ltqsgdlwuorpXjF9sj8K0HYnDZfWq89GEktAluvP2YFWc+sOCvz43gpsvb0Xjyc45Hzg70uROh1M4xGo2iOmlNtD798+fPo7GxkRFNv6OjA93d3X5X6RQqTDwE09LSkJKSApPJhLKyMoZGxg8mkwlqtRozZ84MqZ1wUQyGhobQ3Nw8Zs8MW4F9x5WoOqzA7molugbkyNM5UVnmxK822FBa4IRyXGAbfdLawMBA0C/IhQIT3gK9Xg+NRgOTyYQFCxYwNDL2EK3QP336NFwuV8hCjv7BTSYTli5dysTQeOPkyZPYsGFDSG3IZLKwEXK0KyPUevgGgwF/+9vf4Ha7RZ20VltbCwDQzpiH96pU2HVYif0nFLA7gMsLndh08ygqSx3IyZw62obeMwRB4Morr2R93GzCRKSa2PaMaIW+yWRCQkJCyPHkGo0GWVlZohf6fX19IEmSkWJpBoMBX331FQOj4hcmtDjAo9n29fWhra1NlPkLbjdwokmON/4vEcqFR7HksdmIj3GjvMRTknhZiQOJAcRCJCcnIzMzEyaTSdRCv7OzE11dXYysEYPBgJqaGgZGxT6iFfqhJCGNR0xP6ckINQnJF6PRiLffflvUSWt0EtItt9wScltz586FTCYTVdKazQ4cOKFA1SElPqtWguyRI1ZRgPTY/2Drc3OwuNCJCFXw7YfDnqHf09AJVqFgNBrxwQcfiOKkNWGPbgqYLAEcDuUY6KMfmSgMRiet+Z6RIDYoisLAwAAjayQ2Nha5ubmCXyM9Zhk+2KvEuheikH2HGrf+PBpEswL3rLTjqzeGkdNfgZvn/QdXXRaawAfCZ8/Mnj17TOHIYKGT1s6ePcvAyNhFlEKfTkJiwiwDPKZZXV2dtwqhGCEIghGNBbiQtCZmTS7UJKTxCLEcg9sN1J6VY8vHEVjxRAzy1sXi8bei4HIDL91vRd22Yex+5TweuXUUebpR1NXWMrpn6OgosRJK+YXx5OfnQ6lU4sSJE4y0xyaiFPqtra2wWCyMavpOp9P7okuMMGn50ElrYtbkgk1CmgyhaLZ2B7C/RoGf/j4S8++PxeUbY/E/O1QonOnER8+M4MwHFnyw2Yp1yxzQJl54IXvmzBnYbDZG9wydByFWmNwzkZGRojlpTZQ+fYIgoFQqQ0pC8iUrKwvx8fEgCIKRyp9cQx9z+PjjjzPWphA120Bg0hIEPPPR1NQEi8US0DGUTDBgAfYe9ZwkteeoEoPDMlyW48RtS+2oLHXgspzpi5iZTCZERkYiNzeXkTH5Jq0xZWFyidVqDTlxbzxi2TOiFPqtra3IyspirBaKTCZDdnY2WltbGWmPayiKgt1uR3Z2NmNt5uTk4PDhw4y1xzUtLS1Yvnw5Y+3l5OTA7Xbj3LlzjLmMpqK5XYZPv6k9/6VJAaUCWFLsxH/dZcOKRQ7oUgIrYkafCcDUAd5yuRyzZs0S7Z4hSRIulyukTNzx5OTk4O9//ztj7bGFKIU+SZKMR1HodDpQFMVom1xBj9v37IJQoedDrLHpFEUxOh/0+QQURbEi9J1OoLpOgV2HFag6rETdOQVSNC6sWOTE/T+xYuk8B9QheKooikJGRgZzA4ZnvYl9zzApR8QiQySh/w16vV60pQdIkkRsbCyj2ZE6nQ7Dw8MYGBgQ3VGBIyMj6OnpYXSNREdHIyUlBSRJMtamZQT4/GtP7fndRxToHZRjbpYTqy534PVNVpTkucBUxCxbilJLSwujbXLFuXPnoNFoGHXV6fV6mM1mDA0NCfokLVEKfYqivIeyM4Ver8eePXsYbZMrKIqCTqdjVCOntWSSJEUn9OmTv5jU9AGPkAtV6JPdntrzuw4r8e8TCrjcwLcNTjx2mycbdlY6O7XnmUrc80Wv1+OLL75gtE2uYNoSBC6sN4qiUFBQwGjbTCJKoU+SJCsbWqzuDFroM0lmZiZkMlnQRw3yCS2YheACdLmAmjNyr3+eaFJAE+vG8oUOvPWIFdfMdyCBg/fCbLh3xL5nmJYhvi7AsBT6LpcLjz76KEwmEyIiIvD666+PeZH45JNP4uDBg17z6U9/+hMcDgfuu+8+WK1WpKenY+vWrd6D0v3FarWip6eHlae0zWZDT0+P6AqvsfEQVKlUSE9PZ9SdwRUkSUKj0TBuYuv1er8qKY7YPGGVuw57BH1HnxzZGS5Uljnwwn02XD7XCRWH6tbQ0BDMZjMrLlGLxQKz2Sy6wmskSXpP/mIKNlyAbBD00tuxYwesViv27NmD6upqbN68GR9++KH3ek1NDf76178iOTnZ+9kTTzyBW265BXfeeSe2bNmC9957L+ATa2jTnQ0tDvA8pcUo9OfPn894u2J5MTUeNiwfwCPk9u7dO+G1zn4ZPqv2VKvc97USNgdQVuDEhuvtqCh1YI6ev7Nh6d+Q1kSZgp5jkiRFJ/QpisIVV1zBeLtMuADZJujkrIMHD3r96osWLcLx48e911wuF86cOYOHHnoIK1aswB/+8IeL7ikvL8f+/fsD7vfcuXMAmBf66enpUCgU3vbFBBsv6QBxLOCJYMPyAca6M9xu4GSLHL/6KALlj8Wg4K5YPPV2JCKUwG82WtGwfRhVL4/goZtHkT+D38PAaaHPtHuHdgGKbY243e5Les8ErekPDQ2NqVmhUCjgcDigVCoxPDyM+++/Hxs3boTT6cR1112H+fPnj7knLi4Og4ODAfdLURTi4+MZqZfhi0KhQEZGhug0W9q8njFjBuNt6/V6HDt2jPF22YaiqJBr6E9EWsYM2KKvxKZX3dhHqHGuSw59qguVpQ789A4brjA6ERliTRs2IEkSycnJjGUn00RERCAtLU10e8ZsNmN4eJgVxUCv1ws+sz9ooR8XFweLxeL9t8vl8iZ+xMTE4Ic//KHXX79kyRKYTCbvPdHR0RgaGoJGo5myD5vNdtFnTU1NyMjIYOU4v4yMDNEdFdjQ0AAASEhIYHzctH9STPMBeKzBkpISRsbdPyTD58ejsPdYFD4/fjVgvBaHTg3gtqssWLbAirlZDq8WP2r1/Cc06D3DRm2p9PR0NDU1iWqN0KUj2Ngzqamp2LNnD+/zMdX7rKCFfllZGXbt2oUbb7wR1dXVKCws9F5rbGzE9773PRw4cAAulwsHDx7E7bffjrKyMuzevRt33nkn9u7di8WLF0/ZR2Rk5EWD7+7uRlZWFitxsDNnzkRXV5egY2zH09/fDwCYM2dOwC/FpyM7Oxvt7e2IiYkRTYllt9uNtrY2ZGdnB/07NpCesMpPDytx6LQCEUrgqsuc+MU9Vjx+z1w8/fuXcN111wFgVnNmi66uLmRlZSEqKorxtZ2VlYXu7m5R7Zm+vj7IZDLk5eUxltVPQ+8ZtVot2IimoIX+ddddh3379mH58uVwu93YunUr3njjDWRnZ2PlypVYs2YNysvLoVKpsGbNGsydOxePP/44NmzYgO3btyMpKQlvv/12wP1SFMWKKwPw+OPEdngIRVFISkpiXOADwIwZM+BwONDV1cW4P5gtzGYzLBZLQKa7wwkcOu2pPb+rWolGSo60RBdWLHJg002juKrYiZgoz3e3pMhE586gKIqxOlXj0ev1Y97niQGKopCWlsa4wAc882G1WtHb24uUlBTG22eCoIW+XC7Hli1bxnw2Z84c7/9v2rQJmzZtGnNdq9Xik08+CbZLAB7/5OWXXx5SG5MhxmgVtl5IAWMjmsQi9P0tSTF4HvinTxGz/iEZDLOduOEKTxGz+bkuTHQWhhjXCEVRuPbaa1lpW6fTYefOnay0zRZsRXcBYyOawk7o8wWbP5her0d7e7v3hbQYYCtSBfD4J1UqFUiSxMKFC1npg2noyImJHlKtnR63TdVhJb4wedxVVxqdeOpOTxGzLO302bB6vV7w0Rm+uN1uVhKRaPR6Pdra2kRxYhQNm4pSeno65HI5SJIUbMVecUi2b6DrWrC1gHU6HVwuF9rb21lzITENRVFjLCwmkcvloghB84U23SMjI+FyAUfr5V5Bf6pVgaQ4F5YtdOLtx6xYOt+B+AC9YjqdDgcPHmRn8CzQ29sLq9XKqqJkt9vR1dWF9PR0VvpgGjYFslKpRGZmpqCtQVEJfVr4sKm10P2IReiTJMnqge5iE/rNrZ2IzbodD7wWid3VSnQNyDFH70RlmQO/3mBDaYEzpCJmYnPvsFWSgsbXnSEmob9q1SrW2hf6nhGV0Gcrs5AmKSkJ0dHRotnUbJvugDjK57b1yvDZN9r83mP/BXeUApkdbmy62VPELCeTuSJmYnMBkiQJuVyOjIwMjIyMMN6+VquFSqUCRVGicAHSlvylvGeEv2p9oCgKWq0WkZGRrLQvk8lEpcn19fWxaroDngX8r3/9i7X2g8HtBk40yVH1TbXK440KxMe4UV7iQK7rJXy70IItLzzNSt9icwHSL+HZekDJ5XJkZmYKWrP1paurC3a7nVWhr9PpcOjQIdbaDxVRCX02X8DQiOlFHV0ygu0FLIT5sL066bAAACAASURBVI4CB05cKGJG9cgxM82FilIHfn63DYsLnYhQAZd98D5yKr/P2jhoQc9m6DCTsG0JAsJZI/7AtruLblvI8yE6oS8t4AtQFOU13dlCr9ejq6sLNpuNNQtrMnrMMnxW7RH0n3+txHkbsCjfhXtXesIqC7LG1rRxuVxoa2tjVRgnJSUhKipKNGuEK0VJLNYxRVFQqVTQarWs9SF0F6DwRjQFbBwEMR6dTieKw40BzwJOT09ndWHRAqO9vR2zZs1irR/A47apOyf3JkkdrpUjOgJYOt+Bl39gxYqFTqQmTO6f7+7uht1uZ1XIic0FSFEUSktLWe1Dr9cHVTyRD0iSRGZmJqvhpbQLsKOjg3UlNRhEJfQpikJFRQWrfYjJvcOV5QN4XElsCH27A/jypMIbVtnSIUdmssdt89h3bbiy2IkoPxMnuTDdAfGtkZtuuonVPsRkHXNl+dB9SUI/BLgw3QHPD9bX14fz58+zUtqASdhMVKOhDyNhUrMdsAB7jni0+T1HlRgcluGyHCfWXONx2xRnB1eKmCRJqFQqpKWlMTbWiRCLkHM4HGhvb+dEyHV2dvLiAgwULt5xJCcnIyoqSrDWoGiEfnd3N0ZHR1lfwL6lB/Ly8ljtK1RIksSiRYtY7YN2Z4Qq5JraZKj6Rpv/6qQCSoWniNnP77JhRakDmcmhh1WSJImMjAzWM0N1Oh1MJhOrfTBBR0cHXC4XZ9YgFy7AUCFJEldffTWrfTC1Z9hCNEKffmpKQv8CFEXhxhtvZL2fYHzYTidQXafArsMKVB1Wou6cAikaF1YscuKH13myYWOjmB0nF5YP4IngEeqG9oXtZEYaX3eG0IU+V2tEEvoMQJIklEol66a7Wq1GQkKCYH8wGq5Md8D/6AzLCPD510pUHVJi9xEFegflmJvlxKrLHXh9kxUlea6QsmGng6swSp1OJwoXIEVRiIqKGnNkKRtoNBqo1WrBujNobDYbOjs7OfGzCzmiSVRCPyMjg5O67mJ4UdfR0QGn08mZkKuurp7wGtl9oYjZgRMKuNzAtw1OPHabJxt2Vjpz2bDTQZIklixZwno/tNBoa2tDbm4u6/0FC63Vsl3XXejuDJr29nYA7HsL6D6E6gIUjdDn4gUMjRhC8rhydwFjH4IuF1BzRo5PvwmrJJoUSFC7sXyhA289YsW1CxzQxLI+pAnhao341psRstA/d+4cJ+sDELZmS8OVuwvwuACFOh+iEfpchj/p9Xo0Nzdz0lewUBSFyMhITmp2p2hnYFB5JTb8Ro5/1USjo0+O7AwXKsscePE+Gy4vdELJ88Fao6Oj6Ozs5ETIqdVqaDQawWu2XPmvAfEoSvRvxzY6nQ69vb0YGRlh/GziUBGN0KcoCldccQUnfen1ehw4cICTvoKFjjdmy3Tv7P+miFm1Ap8fqwAKV+BU83n86Dset02enju3jT+0tbXB7XZLmq0PFEWhqKiIk750Oh2OHDnCSV/Bwvae8cU3IERo1qCohD7X7h232y3Ycy6ZTjJxu4GTLRdqzx+tV0Ad7ca1Cxz4/+634KG1uXj6x79DeXk5Y30yCS2AuaqHI4b3Plxbx2J4CHIpQ+g+w0Lou1wuPProozCZTIiIiMDrr7+O7Oxs7/WtW7fir3/9KwBg2bJl+MlPfgK3243CwkLv90pLS/Hss8/61d/o6Cg6Ojo41eKGh4cxMDCAxMRETvoMFCY29Kgd+MKk8MbPn+uSQ5/qQmWpA5vvtOHbRiciVQAgwy8SZIIWciRJIjY2lhPTHRC+C3BkZAS9vb2cCn36kCOhHpLORTYuTVxcHDQajbcoopAISujv2LEDVqsVe/bsQXV1NTZv3owPP/wQANDS0oKPP/4Y//znPyGXy1FRUYHVq1cjJiYGxcXF+OijjwLur729nVPT3fdFnVCFPkVRKCwsDPi+vkFg9xFPSeJ/HlNiaESGkjlOrF/uyYYtmjVxNqzQozO4ilSh0el0+M9//sNJX8HQ1tYGgJsX/b79UBSFgoICTvoMFJIkUVJSwll/Qn3PEZTQP3jwoNfMX7RoEY4fP+69ptPp8Mknn3hDK+12O6KionD8+HG0t7dj9erViI6OxgsvvOB38hPXpntmZiZkMhkoimK9wFuwBGKqNpAXsmEPnVYgUglcNc+J5++1YfkiB9KT/DsbVogLmIZL0x248BAUqguQqzpENGIQ+lyvEaFG8AQl9IeGhhAfH+/9t0Kh8JYRValUSE5OhtvtxtNPP43i4mLk5uais7MTjzzyCG644QZ89dVXuP/++6c9nMNmswEAGhsbER0dDYVCgaGhoWCGHDBarRaNjY2c9RcIIyMj6OnpQVJS0oTjcziB6voI7Dkahb3HotDcoYQ2wYlr51vx/QorrjCMIjrygqD350/UarWoq6sT5HwAHgtTq9VyNr6kpCQMDw+DJEkkJCRw0mcgNDY2el1d9JxYrVZW+0xKSkJjYyPrVT2DwWKxwGw2T7pn2CA1NRUtLS287JmpXGxBCf24uDhYLBbvv10u15jyvlarFQ888ADUajV+/etfAwDmz5/v/c7ixYvR0dExrZYUGRmJuLg4r2/S90HDNjNmzEBvb68g/ZNdXV0AgLy8PO/4zMPA58c82vzuI0oMWGQwzHbi5qscWFlqw7xcFzwlaSK++S8wZs+ejf379wtyPgBPstqiRYs4Gx9tpQ4MDAjyMJWenh7odLqL5oPN+dHr9ejp6RHkGqE1bt89wzazZ89GdXW14OYjKKFfVlaGXbt24cYbb0R1dfUY37Lb7cYdd9yBJUuW4Mc//rH385dffhlJSUl46KGHQBBEQP5XPkqUCtUfB1ww3Z2qLLz1fyrsqlbiP4QCMhlwpdGJzWttWLHIgSwts2fDCjmiiWvTXeguQK7nAxC2C5DLZEYaoe6ZoIT+ddddh3379mH58uVwu93YunUr3njjDWRnZ8PpdOKLL76AzWbDnj17AADPPvssHn74Ydx///347LPPoFQq8dvf/tbv/rh8606j1+tx7NgxTvucDpcLOFovx28/zYR8IYErHk5HUpwLyxc58c7jniJm8SyVgtHpdLDZbOjp6UFqaio7nQSJxWLBwMAAp0IuIiICaWlpghZyM2fO5LRPnU6Huro6Tvv0F5IkkZyczGmilE6n87qVhOQCDEroy+VybNmyZcxnc+bM8f5/Z2fnhPf9+c9/DqY7UBSF+fPnB3VvsOh0OvzjH//gtM+JGLYC+44rseuwAp9VK9E1IEdy9Awk4h/440uzUFrgZLWIGQ0tUCmKEpzQpwUvH9agUCOaSJLEt771LU77nDFjBj7//HNO+/QXPrwFvtVHhST02S08zhB8afptbW1wOp2c9gsAbb0yvFelwm0/j0bOnWqsfzEKzR1ybLp5FEd/Z8Gq9CdQkvQxFhdxI/ABID09HQqFQpBxx7TgzczM5LRfoboz3G43L+4d36RGocGHDKFdgEJTDASfkUsnSfHxlHY4HOjq6mL14HHAkw17okmOqsOe+PnjjQrEx7qxrMSB1x+0YtlCBxLUF75PURSysrJYHdN4FAoFMjIyBCnkKIpCUlIS52WOdTrdmHBloWA2m2GxWDgXcjqdDlarFb29vZzUhAoEiqKQn5/PaZ8RERHQarWC2zOCF/p8mu50/2wIfesocOCE52zYXdVKUD1yzEzzFDH7+d02fKvICdUkvw5FUVi8eDHjY5oOoWq2fJ1FqtPpsGPHDs77nQ4uq0n64uvOEKLQ56OEiBD3jOCFPtdJJjSpqamIiIgASZJYuHAhI232mGX4rNpT9uBfXytx3gYsynfhvpV2VJQ6UJA1/dmwbrebVyEnNFMV4Md0Bzwbur29HS6Xi/UjGgOBoijIZDLWLdTxpKenQy6XgyRJzJs3j9O+p4J2d/GxRoS4Z0Qh9BMTEzk33eVyOTIzM0P6wdxuoPas3KvNH66VIyYSWDrfgZd/YMWKhU6kJgTm/+TLdAc8C/jgwYOc9zsdFEWNCSTgCr1eD7vdjq6uLqSnp3Pe/2RQFAWtVsv5IeVKpVKQLsDe3l5YrVbe9kxNTQ3n/U6FKIQ+H1otEFysvt0BfHlS4fXPt3TIkZnsKWL22HdtuLLYiajAc6O88OXuovsU2oYGPHNyzTXXcN6vb40mIQl9viwfQJhrhC93F93np59+ynm/UyF4oc+XWQb4Xz53wALsOeLR5vccVWJwWIZ5uU6sucZTxKw4e3q3jb/wFakCeIRce3u7t+SGEKDdXXysEa1WC5VKBYqiGHMBMgHfipLQ3BkkSUIul/PyYKajAIXkAhTGzp0CPutR6/X6SesDNbVdKGL21UkFlArg6suc+PldNqwodSAzmZ2wNb5Md8CzoV0uF9rb2wVTeqCvr483050JFyAbUBSF4uJiXvrW6XQ4fPgwL31PBh2MwYeiotPpBOcCFLzQJ0kSV199NS99+2r6TidQXadA1WFPxE3dOQVSE1xYvtCJDddbcfU8B2Kj2B8Tn1ocLehJkhSM0KfzBviaEyEepkKSJFauXMlL33q93nuWhlDgc8/4RjRJQt8P+HzrDgBJqTPR5bwC9/9KhX9+HYHeQTkKZzqx6nIH3thkRckcuogZd/Dpr01KSkJUVJSgfLYURUEul3MeqUIjtBpNLpcLbW1tvLp3hOYC5FOGCNEFKIxfZRIGBgYwMjLC6QI+1yXDrmrPS9h/11wHFKxEa7sNj98GVJQ6MCud32xDPgt8yWQywb2o49N0Bzya3L59+3jpeyK6urpgt9t5fQ/mcrnQ0dHB24NnPBRFoaysjJe+hegCFMabhUngojKeywUcq5fjl3+MwBWbYmC8V43n/xiJ5Hg3tmzoBw5q8bMb/o0fXm/nXeAD/JqqgPBe1PFp+QDCi1bhM7rLt19pjVxAaHtG0Jp+W1sbK0kmIzZgf82FsMrOfjmyMzzZsC9934bLC51QKgAgAj+NcQtmU/NtugPCW8B8mu6AZz46Ozths9l4ebk+HpIkoVKpoNVqeek/OTlZUC5Ah8OB9vZ2STHwQfBCPyMjAyqVKuS2Ovtl+OywElXVCuz7WgmbAyib68TGG0ZRWepAnn5iLV5IPtvu7m5eTXfAs4BNJhNv/Y+HoigsWrSIt/7p36K9vR2zZs3ibRw0JEkiIyODt/BAmUwmqD3T0dEBl8vFq6Kk1+uxf/9+3vofj+CFfrACzu0GTrZcKGJ2tF6BuGg3rlngwJaNVixf6ECSHwdxCSk6g88kExohzQfgmZMbbriBt/593RlCEPp8VNccj06nE0w1ViHsGaFZx2El9G124AtCgapqJaoOKUF2y6FP9bhtfrbWhm8bnIgI0GgQktZCkiSUSiVvpjvgmY++vj6cP3+e89IY4xGC6a7RaKBWqwWzRoQi9IU0H1FRUUhOTuZtDEJzAQpe6E/31r3XLMPuo57Y+X8eU8IyIsOCPCfuWuHJhi2aFVo2rF6vR3V1dfANMAhJksjMzISCqyL6E+B7mAp9TixfdHR0wOl08pozQEc0CUWTI0kSV111Fa9j0Ov1OHnyJK9joKFf4vJ5XCG9Z4TiAgxa6LtcLjz66KMwmUyIiIjA66+/juzsbO/1bdu24b333oNSqcRjjz2GiooK9Pb24r777oPVakV6ejq2bt06pbY4kabvdgMNpBy7qhWoOqTEoVoFIpXAVfOceOFeG5YvciA9ibkoGyGZZny/tATGlpzmW+jzce7pRAhNs+V7PoT04pLvyB1AeC7AoIX+jh07YLVasWfPHlRXV2Pz5s348MMPAXiOS/zd736Hf/3rX7BaraisrMTSpUvx8ssv45ZbbsGdd96JLVu24L333sPGjRsn7aOjowM6nQ4OJ3Dw1IVomzNtcqQlulBR6sCmm0dxVbETMSxlw+p0OgwODmJwcBDx8X68BGARIZjuarUaGo1GEA9CiqIQGRnJe+12oQj90dFRdHZ28i7kdDodent7MTIywumZtBMhhIegRqNBbGysINYIEEKc/sGDB72HEixatGjMCUJHjx5FWVkZIiMjodFoMHv2bJw8eXLMPeXl5dO+0XYm3oTth8qRu1aN1U/FYH+NAjddacfnvx7G6feH8eoDNlSWsifwgQulB4Twg/Edo08jFHeGEEx3wDMfQnhx2dbWBrfbzfsa8XUB8o0Q9ozQXIBBa/pDQ0NjNF+FQuFNvR5/Ta1WY3BwcMzncXFxGBwcnLqT/G0YHrXh0VvMWLbABl3KhfNqh4eDHXlgxMXFAQAaGhp4Xzznzp1DcnIyhoaGeB1Heno6WlpaeB9Hc3Mz0tPTeR9HcnIySJLkfRwNDQ0APJrlRGOxWq2cjEOj0QAA6uvrkZaWxkmfk0Gf4sX3b5OWlobm5mbOxkHLrYkIWujHxcXBYrF4/+1yubyp8OOvWSwWaDQa7+fR0dEYGhryLo7JOP5WO2bqkyCTKQDwEykSFxeHlJQU9PX1TTmRbDM6Ooru7m7k5ubyOg4AmDVrFpqbm3kfR1dXF2bOnMn7OHJzc70KDJ9j6evrg1qthl6vn9T64WJ8cXFx0Gg0vO+ZkZER9PX1CWbPdHZ28j4OIAT3TllZGXbv3g0AqK6uRmFhofdaSUkJvvrqK1itVpjNZtTX12Pu3Llj7tm7d++057wmJ0TwbroDwnBn0KY73/5JQDgvt4Xwkg4QjjuD9l8LYc8I4T2HUF7002MQggsQCEHTv+6667Bv3z4sX74cbrcbW7duxRtvvIHs7GysXLkSP/jBD1BZWQmXy4Wf/exniIqKwuOPP44NGzZg+/btSEpKwttvv83k38IaQlrAfLuYgAvz4Xa7eRUwQnixDVw40IaiKBQUFPA2DiG8tKQRQgSP0IQ+3/NBE7TQl8vl2LJly5jPfM8pveuuu3DXXXeNua7VavHJJ58E2yVv6PV6nDp1itcxkCSJ2NhYJCQk8DoOwDMfw8PDGBgYQGJiIi9jGBkZQU9PjyCEfnR0NFJSUni3foTw0pJGr9ejpaWF1zGcO3fO61bmmxkzZsBsNmNoaIj38Qi6yqZQEIrWIiTTHeC3kmJbW9uYsfCNEFxeQnF3AcLQbIVk+fjmt/CNJPT9wNedwRdCWsCZmZmQyWS8LmBawAplTiQhNxah7BmhWD6+LkC+kYS+H+j1ethsNvT09PA2BiGZ7hEREUhLS+NVsyVJEvHx8bwnzNHw/bLfYrFgYGBAMMdY6vV6WCwWmM1m3sYgpD0TExPjDe3lG0no+4EQTDMhme4A/5qtkLQ4gH8XoJBeWgLCOExFSJYPIAwXICAJfb9IT0+HQqHgNeRKEnJjEep88OXOEJq7KyMjAzKZjDchR5+vLcQ1wjeS0PcDhUKBjIwM3n4w2nQX0gLmO+5YiJaP1WpFb28vL/1TFIXk5GTea93QREZGQqvV8rZnzGYzLBaL4NaIpOmLCD6f0kIz3QFhuHeENh8Af+4MoT0EAX7XiBAOTxmPpOmLDD6f0kIU+nq9Hu3t7XA6ndN/mWHcbregXtIBF1yAfAp9Ic0HwO/LbYqiWDlfOxT4dgHSSELfT/h8SpMkiaSkJN5PqvJFr9fDbrejq6uL876FaLorlUpeXYBCs3wAfhUlkiSh1WoFcVIVDd8uQBpJ6PsJ36aqEDc0wE9Ek5BKUvjC5xoR2ktLgP/5EOqe4duvLwl9P6HdGQ6Hg/O+hWi6a7VaqFQqXhYw3Sed8CIU+HJnCNHdBXhKD7S1tcHlcnHetxDnIyMjA3K5XBL6YkGn08HlcqG9vZ3zvoWoxcnlcmRmZvKygCmKEpzpDvCn2fb19cFqtQpSs+XLBShE65hvFyCNJPT9hM9kEyEKfYC/9xxCng8+1gcdOiu0OZH2zMUIIYJHEvp+kpSUhOjoaM5/MNp0F5rWAvD3ou7cuXOCnQ8+XIAURUEulyM9PZ3TfqeDdgFyvWdcLhfa2toEKfSFEKsvCX0/kclkvJjvQjXdAX41fSHOB+0C7Ojo4LRfiqKQkZHhPblOKMjlcmRkZHAu5Lq6umC32wW7RiRNX0Tw8ZQWYpIJjeTeGQtd7IyPNSLE+QD4cXkJNboLkNw7ooOPBUySpFdjEho6nQ6dnZ2w2Wyc9elyuQQr9JOSkhAVFcX5phaq5QPwI+RIkoRKpYJWq+W0X3/Q6XRoa2vjJQqQJiihPzIygnXr1qGyshK33nrrhCWHn376aSxbtgxLly7Ftm3bAAD9/f3Izs7GqlWrsGrVKrz55puhjZ5j+DDNKIpCenq64Ex34ELcMZcRTd3d3YI13flyAQpZ6PMxHyRJesMjhYZer+fFBehLULPyzjvvoLCwEFVVVVizZg1eeeWVMdf//e9/o6mpCXv27MGuXbvw3//93xgYGEBNTQ1uvvlm7Ny5Ezt37sSGDRsY+SO4gi9TVYhaLcBPdIaQTXfAMy6uC9FJ7p2xiGHP8OniCUroHzx4EOXl5QCA8vJy7N+/f8z10tJSbN26FYBH+3E6nVAqlTh+/DhqamqwcuVK3HXXXbw+7YJBr9ejr68P58+f56xPoUbuAIBGo4FareZ0U587dw5KpVKQpjvAvWbrcDjQ3t4u2DXChwtQyA/B5ORkREVF8RrBM63Q3759OxYvXjzmv8HBQe+JRXFxcRgcHBxzT1RUFBISEmC327FhwwbcfffdUKvVyMvLw1NPPYVPP/0Uq1atwhNPPMHOX8USfJQeELLWIpPJOPfZUhSFzMxMKBQKzvoMBK41246ODjidTsGuEXpcXLoAhb5n+I7gmdZRvH79eqxfv37MZ2vXroXFYgEADA0NQaPRXHTfwMAA1q9fjyuuuAKPPPIIAGDJkiXeomGrV6/GCy+8MGXfXGoH/kD/nQ0NDZzFRJ89exaVlZUYGhripL9ASUtLQ3NzM2fja2pqQnp6umDnIyUlBSRJcja+hoYGAEBCQsK0fVqtVi6GNAZ6z9TX1yM5OZmTPs+dO4fk5GTBrpH09HQ0NTWxOr64uLhJrwX1drCsrAy7d+9GSUkJ9u7di8WLF4+5PjIyguuvvx4PPPAAvvvd73o/37RpE66//nrceOON2L9/P+bNmzdlP5GRkVMOnmvi4uKQkJCAvr4+TsbldDrR2dmJ7OxsQc2DLzNnzkRHRwdn4+vu7sbMmTMFOx85OTno6+uDUqnk5ECT/v5+REVFYebMmZDJZNN+n+t5U6vViI2NRX9/Pyd9j46Ooru7Gzk5OYJdI1lZWejq6uJtfEH59O+9917U1taioqIC77//Pp588kkAwDPPPIOjR4/i3XffRUtLC7Zt2+aN1GlpacGzzz6Ld955B6tWrcJ7772Hl156idE/hgu4jNWnTXehHHY9EVy7M4RsugPcv6ij3/n4I/D5gHYBcrVG2tra4Ha7Bb9GBO3emYiYmBhvGKYvzz33HACgpKQEGzdunPDeHTt2BNOlYODyBxPauacTwXXCmpBfbANj3/vk5uay3p/Q5wPg9uW2kJMZafg8XAaQkrMChssfjKIoREZGIiUlhZP+gkGv12NwcJAT/+no6Cg6OzsFLeTUajU0Gg1nYZtiEfpc7pnY2NgJ3zMKBZ1Oh97eXoyMjPDSvyT0A4RLrYVOuhGq6Q5w685ob28XvOkOcGsNCt3dBXCvKOn1elHsmba2Nl76l4R+gHB5zqVQq0n6Qh9kwsWmFoPpDkhCfzxcu3eEvmf4PkFLEvoBotPpMDw8jIGBAdb7EsOGjo6ORkpKCiebmjbdExISWO8rFLjSbEdGRtDT0yP4NTJjxgyYzWZOXIBi2DNxcXHQaDSS0BcLXD6lhVxTxReufLZicHcB3Gm2tHtA6GuEy6RGMWj6AL8lliWhHyCZmZmQyWScLWChay0Ad0JfbBuabRegGKK7gAsuQEnoX4DPCB5J6AdIREQE0tLSWP/BxGK6A9z5sMXyENTr9bBYLDCbzaz2Q5IkNBqNYJOQaGJiYpCcnMz6nhkaGoLZbBZ0XgsNn7H6ktAPAi5MM7GY7gB3WotYtDiuXIBicf8B3FiD9J4Uw5zweWyiJPSDgAshJxbTHbhwMATb7gyxCDnaBcjFGhGD5QNwK/Rpd5KQ4coFOBGS0A8CrhZwfHy8t5qpkNHr9bBarejt7WWtD4vFgoGBAVGY7rQLkG1rUAyRKjRcuDMoikJycrK3qKOQ4coFOBGS0A8CLtw7YtPiAHbdGWIy3QFu1ohYLB+AG6EvhrwWGj4OIKKRhH4Q6PV6tLW1wel0staHmLS49PR0KBQKSej7wLYL0O12i0ox4CKpUUx7JiMjg7MowPFIQj8I9Ho9HA4Hurq6WOtDTFqcUqlERkYGqwuYJEkkJSWJwnQH2HcBms1mWCwW0awRnU7HugtQTHsmMjISWq1WEvpigYt6M2KJVKFhW8iJcT7YXB9CPyt4PFy4AMVk+QD8RfBIQj8IUlNToVKpWHdniGkBs+2zFeN8tLW1weVysdI+SZKQyWTIyMhgpX2mycjIgFwuZ23PuN1uUa4RSeiLBLlcjszMTNZ+MLpOiaTZXkCMG9put7PmAqQoClqtFpGRkay0zzRsuwD7+vpgtVqlPeMHktAPEjaf0mKpJumL5N4ZC9vuDLHNB8DuGqHPLxDTnEjuHZHB5lNaTEkmNHq9Hu3t7XA4HIy3LUbTXavVQqVSsbZGxOa/Bth1AVIUBblcLhp3F+CpPsqmC3AyghL6IyMjWLduHSorK3Hrrbeip6fnou/cfvvtWLFiBVatWoVbbrkFANDU1ISKigpUVlbikUce4fyPZRI2FzBJkqIy3QHPQ9DlcqG9vZ3xtvv6+jAyMiIqLY5tF6CYIlVo2FSUSJJERkYGlMqgToDlBZ1Ox6oLcDKCEvrvvPMOCgsLUVVVhTVr1uCVV1656DtNTU3YtWsXdu7cib/85S8AgKeeegqbN29GVVUV3G43du7cGdroeYRN947YtFoA3kxZNja1GN1dAPsuQGk+LiDGPcPlqXO+BCX0Dx48iPLycgBAvjzJ+QAAGytJREFUeXk59u/fP+Z6V1cXzGYz1qxZg4qKCuzatQsAUFNTgyuuuGLS+8SETqdDV1cXbDYb422L0V+blJSEqKgoVhawGE13gD3N1uVyoa2tTXRCTqfTseYCFKPlQ7sAufbrT2sLbd++HW+++eaYz1JTU701YeLi4jA4ODjm+ujoKDZu3IgNGzagv78fK1asQElJCdxut/cADLVafdF942FDoDJFYmIiAKChoQEzZ85ktO3W1lYUFRVxctIQk2RkZODMmTOMj/vMmTPQarW8HSQdLKmpqfjiiy8Yn4+uri7Y7XYkJiYG1LbVamV0HIGSmJgIl8uFM2fOMP6+qrW1FSUlJaLbM+np6azsmanKbU8r9NevX4/169eP+Wzt2rWwWCwAPDWsx588n5aWhnvuuQdKpRKpqakoLi5GQ0MD5PILhoXFYpn2xPrIyEjB1gqfM2cOAKC/vx8Gg4HRtjs6OrB69WrB/u2TkZWVhe7ubsbH3dPTg6ysLNHNR05ODv7yl78wPu76+noAnjUYaNt8zmF+fj4Az56h/58pOjo6kJ2dLbo1MmPGDPT09HA67qDcO2VlZdi9ezcAYO/evVi8ePGY6/v27cPdd98NwCPcT58+jfz8fBiNRhw4cGDS+8SERqOBWq1m3HwXq+kOsOfOEKPpDnjmo7Ozk3GLlSRJqFQqaLVaRttlm+TkZFZcgA6HA+3t7aJcI3wcphKU0L/33ntRW1uLiooKvP/++3jyyScBAM888wyOHj2KZcuWIScnB+Xl5bjpppvw9NNPIzk5Gc8//zxefPFFLFu2DKOjo/jOd77D6B/DJTKZjJU42+7uboyOjopyAbMVdyzGdxzAhZhxpiOa6EgVX8tZDMhkMlYimjo6OuB0OkWrKAnOpz8RMTEx2LZt20WfP/fcc97/f+mlly66npubi08//TSYLgUJG09psdVU8WXGjBmsRe/ccMMNjLfLNr7lc2fNmsVYu2KMVKFhI4JHzHtGNJq+hAc23BkkSUKpVIrOdAc889Hb28voC1en0yla050tF6CYhT4be4aiKERFRSE5OZnRdrmAdgGOjo5y1qck9EOADa2FJElkZmZCoVAw2i4XsBF3TJvuYjgxazwymYy1NSJWoc/WfOh0Om9koJjQ6/Vwu93eM7G5QBL6IcCGP06sLy2BCz5sJoW+2A5PGQ9bmq1Y54MNd4ZY3/kA/CRoSUI/BPR6PQYHB6fNNwgEMWtxarUaGo3GW/yKCUiSRGRkJFJSUhhrk0uYVgxGR0fR2dkpWiFHuwDPnz/PWJtiFvoajQaxsbGMrpHPPvtsyuuS0A+B3NxcABfippmgvr4eOTk5jLXHNXl5eYzOR11dHXJyckRpugOe+airq2OsvYaGBrjdbu/aExts7RmxzodMJkNubi6j83Ho0KEpr0tCPwQyMzORmJgIgiAYac9qtaK+vh5Go5GR9vjAYDAwNh8AQBAE48lvXGIwGNDa2gqz2cxIewRBIDY2FtnZ2Yy0xzUzZ85EfHw8Y2tkeHgYZ86ckfaMDyaTacrrktAPAZlMBqPROO0k+0ttbS2cTqeoF7DRaARBEIwdgG0ymUQ9H/QD6+TJk4y0ZzKZUFRUJLoYfRqZTIaioiLG9sypU6fgdrtFvUaYlCEApn2AiHPlCAgmn9InTpyARqMRZaQKjcFgQE9PDzo7O0Nua2BgAGfPnhX1hk5NTUV6ejpja0Tslg/A7J4hCALJyclIT09npD0+MBgMaGtrY+TQ+J6enmmTASWhHyJGoxEnT55k5GwAk8kEg8EgWv81ABQWFkImkzGiudDasdiFHFOanNvtFr3lA1yYDyasQXo+xLxn6PXNxBrxpw1J6IeIwWDA8PAwmpubQ24rHLS4uLg4zJ49mxFNjiAIZGRkiDZyh4Ypzba9vR29vb2iXyNGoxGDg4M4e/ZsyG2Fw55JSEjAjBkzcOLEiZDbIggCWVlZU35HEvohkp+fD5VKFfJT2u124+TJk6LX4gDmNNtw0GoBz3ycPn065DryJpMJMpkMhYWFDI2MHwoKCqBQKEJeI06nE6dOnQqbNcLEnvHnISgJ/RCJiIhAfn5+yJpca2srBgcHRa+1AMxptuGgxQGe+bDZbGhoaAipHYIgkJOTg9jYWIZGxg/R0dHIy8sLeY00NzdjeHg4bNYIE3vGH0VJEvoMQEeshILJZIJSqURBQQFDo+IPo9GIxsbGkBJw7HY7amtrw0KLy8nJQXR0dMiaXLhYPgAzmq3JZEJERIT3bAsxYzQaUV9fH1IZbjrkW9L0OYCJBUwQBObMmYOoqCiGRsUfBoMBLpcLp0+fDrqNhoYG2Gy2sNDiFAoFCgsLQ1YMwsXyAZjRbAmCQEFBAVQqFUOj4g+j0QiHw4Ha2tqg26itrYXD4ZA0fS4wGAygKAp9fX1BtxFOG1qn04WctEYQBGJiYkSbhDSeUK3BcEhC8sVoNIactEYQRNjMR1ZWVshJayaTCfHx8dMe3yoJfQagF16oP1i4LGCZTAaDwRCS9WMymVBYWCjKaqMTQWu2wYYp0klI4aIYMJG0Roc4hwNyuTzkpDWCIFBUVDRt+Kok9BkgMTERer0+aKEfDklI4wlVsw0nLQ7wzEcoSWt0ElJGRgbDI+MHrVaLtLS0oIVcb28v2trawmqNhOry8vchGJTQHxkZwbp161BZWYlbb70VPT09Y67v3bsXq1atwqpVq7By5UokJSWhrq4ONTU1mDt3rvfaX//612C6FyShaLbhkoTki8FgCDppjU5CCqf5oMMsg10j4ZC4N55QhBw9j+G0RkJJWnO73X4rSkEJ/XfeeQeFhYWoqqrCmjVr8Morr4y5Xl5ejp07d2Lnzp2oqKjAj3/8Y+Tn56OmpgY/+tGPvNduuummYLoXJKEs4HBJQvLFaDTCYrGgpaUl4Hs7OjrQ09MTVlpcXFwcsrOzQ1oj4TQfQGgBECdOnMCMGTOQkJDA8Kj4w2g0wmw2B1Wa/Ny5cxgcHGRP6B88eBDl5eUAPAJ+//79E36Poij87//+r/fg9OPHj2P37t2orKzEAw88gKGhoWC6FyR0yFUwx56Fm1YLXEhaC0bIhUsS0niCtQbpJKRwWyMGgwGnTp0KKmktHPdMQUEB5HJ5UGuEIAgoFAq/Qr6nPRh9+/btePPNN8d8lpqaivj4eAAeDWayQ0S2bt2KH/3oR4iMjAQALFiwAOvXr8e8efPwq1/9Ci+//DJ++ctfTtp3KDGrXDN79mzY7XYcO3YMRUVFAd1bU1ODJUuWhNVDEPDUkj969CiuueaagO47cuQIZs2aBbfbHVZzMmfOHPz9738P+G9qamrC8PAwsrOzQ5oPq9Ua9L1skJ2dDZvNhpqamoBj7WtqalBRURFW6wPwnDdw9OhRXHnllQHdd+zYMeTk5MDhcGBoaAhxcXGTfndaob9+/XqsX79+zGdr166FxWIBAAwNDUGj0Vx0n8vlwmeffYann37a+9nq1au95tjq1avxxBNPTNl3ZGTklIMXEgaDAWq1Gk1NTbj88sv9vs9ut6O+vh4PP/ywaP5WfykuLkZ9fX3Af1dDQwOKi4vDbj5KSkrwm9/8BgqFAjExMX7f19zcjIiICMyfPz/kmHQhzWlxcTGioqLQ1NSEkpISv++z2WxobGzEggULBPX3MEGwe6aurg6XXXaZX/cF5d4pKyvD7t27AXhe2i5evPii75w6dQp5eXmIjo72fnbzzTfj6NGjAID9+/dj3rx5wXQvSOiQq0DdGXQSUrj5a4Hgfbbh6L8GPPMRTNJaOCUh+aJUKlFYWBjwGqGTkIqLi1kaGX8EG/UWyJ4JSujfe++9qK2tRUVFBd5//32vz/6ZZ57xCvXGxkbMmjVrzH2//vWv8dRTT2HVqlU4dOgQHnvssWC6FyzBCDmTyYTo6OiwSULyxWAwgCRJ9Pf3+33P8PAwGhsbw85fC3iS1hISEoJaI+E4H0BwARAmkwlxcXHTVpMUIwaDAS0tLQGdu202m9Ha2ur3GpnWvTMRMTEx2LZt20WfP/fcc97/v+GGG3DDDTeMuT5v3rxpD+0VM0ajEX/5y1/gdrv9Dq2jEyrCJQnJF9+ktSVLlvh1z+nTp0V/EtJk0CetBSrkCILAgw8+yNKo+MVoNGLXrl0B3UNnr4v19LCpoNf9yZMnJ/SgTESgId/hN2s8YjAYMDAwAIqi/L4nnDJxx5OUlAS9Xh+QZmsymZCUlITMzEwWR8YfgVqD4ZiE5IvRaERXV1dASWvhbPkEk7RmMpmQlpYGrVbr1/cloc8gc+fOhVwu91uToxMqwnUBAwj4PQc9H+GUhOQLHbbpb9JaOCYh+UJHuvkr5AJJQhIrgbq8Ap0PSegzSExMDHJzc/1ewJ2dnWGXhDSeQDXbcLZ8gAtJa62trX59nyCIsEtC8iXQk9ZIkoTZbA77NRLonglEKZCEPsME4rMlCCIsk5B8MRqNqK2t9StpzeVyhbXpDlxIWvP3aLxwtwSBwJLWCIKAXC4Pi3MnJiOQpDWHwxHw6WGS0GeYQEwzgiCQnZ0NtVrN8qj4w2g0wm63o66ubtrv0ichhbMWF+hJa+HuygACV5TmzJkzJhQ83DAajbBarWhsbJz2u42NjQGfOyEJfYYxGo1obm72K1Mw3LVaAJg1axbUarVfmpzJZIJKpQqLk5Cmwl/N1maz+XUSktgxGAxoaGjAyMjItN+9FPZMTk4OoqKi/FojBEEgOjoaubm5frcvCX2GCaRO+KWgxQWStEYnIUVERHAwMv7w12cbzklIvgSStHYp7Bk6ac2fPWMymTB37tyAQr4loc8waWlpSE1NnXZTh3MS0nj81WwvBf814H/SWjgnIfmi1+uh0WimXSODg4NoaWm5ZNaIv3sm0IegJPQZhj41arqndDgnIY2H9tlOVyc83CN3aPw9aS2ck5B88TdpjbaeL5U14q91LAl9AeCP+W4ymZCYmBi2SUi+GAwG9Pf3o62tbdLv9PX1gaKoS0KLS0pKgk6n82uNXArzAfin2ZpMJmi1Wr+TkMSMwWCYNmmts7MT3d3dAa8RSeizgNFoxKlTp+B0/r/27j+mqvqP4/iTH4YUlzuxFlNZkAOCCf5hRpisjdC4XkjGKGoOatZIB2ODUZBXV2ACujSwmOQ0p6wWpCtHF7Jgk6hgUxcMbCOR5Y+1+QNj3OuEgHu/f7h7v4gXLqhw7vW8Hxt/cM/h8trd5/O+n3vu+Xw+Y5OeY3uHflgnIY0XGRnpdNKa7ZgaRnHg/C4vNUxCGs82UJpq0pqaXo/pTFqztZ+ZLuUuRX8WLFu2jFu3bnH+/PlJz1HTKO7RRx9l6dKlUzbg7u5ulixZwoIFC+YwmXKcfRq0TUJSSxtZtmwZJpOJixcvTnqOmvqMv78/wcHBTvtMSEjIjJdhlqI/C0JDQ/Hx8Zl0JGebhKSWUQs4v0apli9xbZxNWrNNQoqIiJjjZMp45pln8Pb2nnTS2r1MQnJ30+kz9/J6SNGfBd7e3kREREz6Lv33339z8+ZNVRU5Z9ds1TSKg9uvh20DHUe6u7vv2o/iYebj40NYWNikbeT8+fMMDQ2pro3MRp+Roj9LpnqX7urqYt68eYSHh89xKuVERUXR19dn33FtvP/++4+enh5VjeJCQkJ47LHHpmwjano9wHmfmT9//owmIbk7277bjiat3bp1i3Pnzt1TG7mn9fSFc9HR0Xz11Vc89dRTdx0bHh5WxSSk8aKiorBarfaVSMezWq2MjIw89JOQxvP09CQqKoq8vDyKioruOm4ymfjwww8VSKac6Ohotm3bNmmfiYyMxNtbPSXLNmktPDz8rhs+LBYLFotFir4reeONN9BqtZPewaOmAgcQGBjI0aNHuXbtmsPjCxYsICQkZI5TKauiooI//vjD4TFPT08SExPnOJGyMjIyeOKJJybtM8uXL5/jRMoKCgqirq6O/v5+h8cXLlzIkiVLZvy8HgMDA1PPmJlCfX09x48f58CBA3cdO3z4MIcOHcLb25uCggISExPp7+/nnXfeYWhoiMDAQKqqqqbcINrZru5CiOmT/iTgPq7pFxYWUlJS4vC+2itXrvDFF19w4sQJjh07RklJCcPDw+zcuZO0tDQaGxuJjo7m0KFD9xVeCCHEzNxz0Y+JiWH37t0Oj505c4aYmBh8fHzQarWEhIRw9uxZ2tvbSUhIACAhIYGWlpZ7/fdCCCHugdNr+keOHGHfvn13PFZVVUVqaiqtra0O/8ZkMuHv72//3c/Pj8HBwTse12g0M9rxXQghxP1zWvQzMzPJzMyc0ZNqNJo7bs0zm81otVr7476+vphMJrRa7ZTPMzw8PKP/K4SY3NDQkNIRxByZ6rubWbl7Z8WKFXz88ccMDQ3ZN4KIiIggJiaGn376iQ0bNtDU1ERsbOyUz+Pj4yNfPAnxAEl/Eg+06H/++ec8/fTTrFu3jnfffRedTofFYmHr1q3Mnz+f9957j82bN3PkyBECAgIc3vUjhBBi9tzXLZuzTW4xE+LBkf4kQJZhEEIIVXHpkb4QQogHS0b6QgihIlL0hRBCRaToCyGEikjRF0IIFXH7om+xWMjLy2PNmjXo9Xr6+vr4/fffeemll0hISHCbNclPnz6NXq8HoK+vj8TERHQ6Hfn5+VNuFu0KxmffuHEjer0evV5PVFQUGzduVDjd5EZGRsjKykKn0xEfH09DQ4P92LfffsuaNWsUTOfc2NgY2dnZvPzyyyQmJvLnn3/aj33wwQd8+eWXCqZzzlHftbUdvV5PWFgYH330kdIxnRrf/m1cuf24/Xr6P/zwA0NDQ/z888+cOnUKg8HAP//8w+HDhwkODiYpKYnOzk6XXou7srKS2tpa+zLTW7ZswWAwEBcXR15eHkajkeTkZIVTOjYxu63QDAwMkJSURGlpqZLxplRbW0tAQAD79+/n33//JS4ujnXr1tHZ2UlNTQ1Wq2vf2NbY2AjAiRMnaG1tZfv27Xz22Wds2rSJ3t5eQkNDFU44NUd912g0Are3FH3rrbcoKChQOOXUJrZ/wOXbj9uP9Mev3Lly5Uo6Ojpobm4mODgYs9nM4OAgfn5+CqecWnBwMDU1NfbfOzs7Wb16NeD6q5FOzG5TWlpKVlYWgYGBCqSanpSUFAwGA3B79y4vLy9u3LjB9u3bKSsrUzidc0lJSVRWVgJw6dIltFotZrOZoqIi0tPTFU7nnKO+a1NUVERxcbHb9V13aD9uX/Qnrujp5eUFwKlTp4iNjeXJJ59k0aJFSsWblvXr19+xDZzVarVvj2ZbodRVTcwOcO3aNX755Rc2bNigUKrp8fPzQ6PRYDKZyMzMxGAwkJOTw44dO1y+2Nh4e3uzadMmCgsLee211wgODubZZ59VOta0OOq7o6OjdHd3YzKZePHFFxVMNz3j2//Y2JhbtB+3L/oTV/S0WCx4e3uzcuVKurq6WL58OZ9++qmCCWdu/B6ythVK3cnx48dJS0uzvwG7ssuXL5OcnEx6ejpLly6lr6+P/Px83n77bXp6ehzuX+tqqqurOX36NLm5udy8eVPpONM2Wd+tq6vjzTffVDDZveno6HCL9uP2Rd+2cifcHt1HRkai0+kYGBgAbo/mJm7E7eqioqLsexVMZzVSV3Py5En7x3ZXdvXqVVJTUykuLiYjI4MVK1bQ3t6O0Wjk4MGDhIeHU15ernTMSX3zzTfs2bMHAF9fXzw9Pd2qrTvquwAtLS1u0X4mcpf24/Zf5CYnJ3Py5EnWrl2L1WqlqqqKc+fOkZaWxiOPPEJgYCB79+5VOuaM7Nixg9zcXEpKSggLC2P9+vVKR5qR3t5egoODlY7h1O7duxkYGGDXrl3s2rULgKNHj+Lr66twsulJTk4mOzsbnU7H6OgoZWVlbpMdHPdduP1mHBAQoHC6h5esvSOEECriPp8FhRBC3Dcp+kIIoSJS9IUQQkWk6AshhIpI0RdCCBWRoi+EECoiRV8IIVREir4QQqiIFH0hhFARKfpCCKEiUvSFEEJFpOgLIYSKSNEXQggVkaIvhBAq4lJFX6/X89dffykdQwi3deHCBYKCgtDr9fafnTt3OjxX+ps6uf0mKkKIO4WHh2M0GpWOIVyUyxX9/v5+0tPTGR4e5sqVKxgMBpKSkli1ahUvvPACZ8+excPDg6+//trt9o4VQinFxcW0tbUxNjZGdnY2KSkpAJSWltLf34+Pjw/V1dU8/vjjCicVs82lLu8AdHV1kZOTw/fff09FRQUHDhwAwGQykZaWRkNDA4sWLaKpqUnhpEK4pp6enjsu79TV1XHhwgV+/PFH6uvr+eSTT+x7SCcnJ1NfX09iYqJ9v13xcFN8pG82m/Hx8WHevHkAxMbGUlFRQU1NDR4eHoyMjNjPjY6OBmDx4sUMDQ0pklcIVzfx8k5lZSUdHR3o9XoARkdHuXjxIgCrVq0C4LnnnrNvUi4eboqP9Ddv3kxbWxsWi4Xr16+zZcsWXn/9dfbv309cXBxW6/+38PXw8FAwqRDuKTQ0lLi4OIxGI/X19aSkpBASEgLAmTNnAGhrayMiIkLJmGKOKD7Sz8nJobCwEIBXXnmF8PBwtm3bxp49e1i8eDE3btxQOKEQ7k2n0/Hrr7+i0+kwm80kJSWh0WgAMBqN7Nu3D41GQ3V1tcJJxVzwGBgYsDo/TQghxMNA8cs7Qggh5o4UfSGEUBEp+kIIoSKKFP2RkRGysrLQ6XTEx8fT0NBAX18fiYmJ6HQ68vPzsVgsAJSXlxMfH8/atWvtdxpMdq4QQoipKVL0a2trCQgIoLGxkWPHjvH++++zZcsWDAYDjY2NWK1WjEYjHR0d/PbbbzQ3N3Pw4EEKCgoAHJ4rhBDCOUWKfkpKCgaDAQCr1YqXlxednZ2sXr0agISEBFpaWmhvbyc+Ph4PDw+CgoIYHR3l+vXrDs8VQgjhnCJF38/PD41Gg8lkIjMzk61bt2K1Wu2Tr/z8/BgcHMRkMuHv73/H3w0ODjo8VwghhHOKfZF7+fJlkpOTSU9P59VXX8XT8/9RzGYzWq0WjUaD2Wy+63FH5wohhHBOkaJ/9epVUlNTKS4uJiMjA4CoqChaW1sBaGpqIjY2lueff57m5mYsFguXLl3CYrGwcOFCh+cKIYRwTpEZuYWFhXz33XeEhobaHysvL6ewsJCRkRHCwsLYu3cvXl5elJWV0dTUhMViobS0lNjYWHp7e8nNzb3rXCGEEFOTZRiEEEJFZHKWEEKoiBR9IYRQESn6QgihIlL0hRBCRaToCyGEikjRF0IIFZGiL4QQKiJFXwghVOR/K/wF4HANWXEAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -79,14 +80,15 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -106,14 +108,15 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -136,14 +139,15 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -164,14 +168,15 @@ "metadata": {}, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -192,42 +197,42 @@ "metadata": {}, "outputs": [ { - "name": "stderr", "output_type": "stream", + "name": "stderr", "text": [ - "[2020-09-28 09:15:59,266] INFO | darts.models.tcn_model | Number of layers chosen: 2\n" + "[2020-11-09 10:47:02,159] INFO | darts.models.tcn_model | Number of layers chosen: 2\n", + "[2020-11-09 10:47:02,159] INFO | darts.models.tcn_model | Number of layers chosen: 2\n" ] }, { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=300.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "b3f299ab1a114ffd92d2eaaee2a15818", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=300.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "6b85165462224c9286fae8e891859cd0" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "Training loss: 0.0228, validation loss: 0.0610\n" + "\n" ] }, { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -278,42 +283,42 @@ "metadata": {}, "outputs": [ { - "name": "stderr", "output_type": "stream", + "name": "stderr", "text": [ - "[2020-09-28 09:16:05,973] INFO | darts.models.tcn_model | Number of layers chosen: 2\n" + "[2020-11-09 10:47:13,405] INFO | darts.models.tcn_model | Number of layers chosen: 2\n", + "[2020-11-09 10:47:13,405] INFO | darts.models.tcn_model | Number of layers chosen: 2\n" ] }, { + "output_type": "display_data", "data": { + "text/plain": "HBox(children=(FloatProgress(value=0.0, max=300.0), HTML(value='')))", "application/vnd.jupyter.widget-view+json": { - "model_id": "499f0aba4c6a42489a37848e6794738f", "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=300.0), HTML(value='')))" - ] + "version_minor": 0, + "model_id": "d75a6e40ae50456186a45006fe8bca01" + } }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "Training loss: 0.0159, validation loss: 0.0428\n" + "\n" ] }, { + "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "needs_background": "light" + } } ], "source": [ @@ -376,7 +381,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.8.5-final" } }, "nbformat": 4, diff --git a/requirements/release.txt b/requirements/release.txt index be687ff20e..93af2d59e7 100644 --- a/requirements/release.txt +++ b/requirements/release.txt @@ -1,5 +1,5 @@ # docs -sphinx +sphinx==3.2.1 sphinx-automodapi sphinx_autodoc_typehints nbsphinx